Function getToolsForAgent

pkg/teamloader/teamloader.go:669–749

getToolsForAgent returns the tool definitions for an agent based on its configuration. Toolset instructions support ${...} JavaScript placeholders (e.g. ${env.X}); they are expanded here using the runtime env provider.

(ctx context.Context, a *latest.AgentConfig, parentDir string, runConfig *config.RuntimeConfig, registry ToolsetRegistry, configName string, expander *js.Expander)

// configuration. Toolset instructions support ${...} JavaScript placeholders
// (e.g. ${env.X}); they are expanded here using the runtime env provider.
func getToolsForAgent(ctx context.Context, a *latest.AgentConfig, parentDir string, runConfig *config.RuntimeConfig, registry ToolsetRegistry, configName string, expander *js.Expander) ([]tools.ToolSet, []string) {
	var (
		toolSets    []tools.ToolSet
		warnings    []string
		lspBackends []lsp.Backend
	)

	deferredToolset := deferred.New()

	for i := range a.Toolsets {
		toolset := a.Toolsets[i]

		tool, err := registry.CreateTool(ctx, toolset, parentDir, runConfig, configName)
		if err != nil {
			// Collect error but continue loading other toolsets
			slog.WarnContext(ctx, "Toolset configuration failed; skipping", "type", toolset.Type, "ref", toolset.Ref, "command", toolset.Command, "error", err)
			warnings = append(warnings, fmt.Sprintf("toolset %s failed: %v", toolset.Type, err))
			continue
		}

		wrapped := WithToolsFilter(tool, toolset.Tools...)
		wrapped = WithReadOnlyFilter(wrapped, toolset.ReadOnly || a.ReadOnly)
		wrapped = WithInstructions(wrapped, expander.Expand(ctx, toolset.Instruction, nil))
		wrapped = WithToon(wrapped, toolset.Toon)
		wrapped = WithModelOverride(wrapped, toolset.Model)

		// Handle deferred tools
		if !toolset.Defer.IsEmpty() {
			deferredToolset.AddSource(wrapped, toolset.Defer.DeferAll, toolset.Defer.Tools)
			if toolset.Defer.DeferAll {
				// Don't add the wrapped toolset to toolSets - all its tools are deferred
				// TODO: maybe we _do_ want to add this toolset since it has instructions?
				continue
			} else {
				wrapped = WithToolsExcludeFilter(wrapped, toolset.Defer.Tools...)
			}
		}

		// Collect LSP backends for multiplexing when there are multiple.
		// Instead of adding them individually (which causes duplicate tool names),
		// they are combined into a single Multiplexer after the loop.
		if toolset.Type == "lsp" {
			if lspTool, ok := tool.(*lsp.ToolSet); ok {
				lspBackends = append(lspBackends, lsp.Backend{LSP: lspTool, Toolset: wrapped})
				continue
			}
			slog.WarnContext(ctx, "Toolset configured as type 'lsp' but registry returned unexpected type; treating as regular toolset",
				"type", fmt.Sprintf("%T", tool), "command", toolset.Command)
		}

		toolSets = append(toolSets, wrapped)
	}

	// Merge LSP backends: if there are multiple, combine them into a single
	// multiplexer so the LLM sees one set of lsp_* tools instead of duplicates.
	if len(lspBackends) > 1 {
		toolSets = append(toolSets, lsp.NewLSPMultiplexer(lspBackends))
	} else if len(lspBackends) == 1 {