teamloader

package
v1.118.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jul 28, 2026 License: Apache-2.0 Imports: 41 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

func Load 

func Load(ctx context.Context, agentSource config.Source, runConfig *config.RuntimeConfig, opts ...Opt) (*team.Team, error)

Load loads an agent team from the given source

func ToolsetIdentity added in v1.54.0 

func ToolsetIdentity(t latest.Toolset) string

ToolsetIdentity returns a stable string that identifies a toolset across reloads. Named toolsets (the common case for MCP/LSP) are keyed by Type+Name. Toolsets without a name fall back to a key derived from their type and connection target.

The function is deterministic and total: every Toolset has a unique non-empty identity even when several share the same config (the fallback includes the JSON signature to break ties).

func ToolsetSignature added in v1.54.0 

func ToolsetSignature(t latest.Toolset) string

ToolsetSignature returns a hex-encoded SHA-256 of the canonical JSON representation of t. Two toolsets with byte-identical signatures are considered configuration-identical for hot-reload purposes.

Any field present in latest.Toolset participates in the signature, so adding new fields automatically participates in change detection without further wiring.

func WithInstructions 

func WithInstructions(inner tools.ToolSet, instruction string) tools.ToolSet

func WithModelOverride added in v1.30.1 

func WithModelOverride(inner tools.ToolSet, model string) tools.ToolSet

WithModelOverride wraps a toolset so that every tool it produces carries the given model in its ModelOverride field, enabling per-toolset model routing.

func WithNoToolsFilter added in v1.111.0 

func WithNoToolsFilter(inner tools.ToolSet) tools.ToolSet

WithNoToolsFilter creates a toolset that exposes no tools but preserves all other capabilities (like Instructions) of the inner toolset.

func WithReadOnlyFilter added in v1.87.0 

func WithReadOnlyFilter(inner tools.ToolSet, readOnly bool) tools.ToolSet

WithReadOnlyFilter wraps a toolset so it only lists and exposes tools whose annotations carry a read-only hint. Every other tool is filtered out, so the agent can never call a mutating tool from this toolset. When readOnly is false the inner toolset is returned unchanged.

func WithToolsExcludeFilter 

func WithToolsExcludeFilter(inner tools.ToolSet, toolNames ...string) tools.ToolSet

WithToolsExcludeFilter creates a toolset that excludes the specified tools. If no tool names are provided, all tools are included.

func WithToolsFilter 

func WithToolsFilter(inner tools.ToolSet, toolNames ...string) tools.ToolSet

WithToolsFilter creates a toolset that only includes the specified tools. If no tool names are provided, all tools are included.

func WithToon 

func WithToon(inner tools.ToolSet, toon string) tools.ToolSet

Types

type LoadResult 

type LoadResult struct {
	Team      *team.Team
	Models    map[string]latest.ModelConfig
	Providers map[string]latest.ProviderConfig
	// ProviderRegistry is the registry used to instantiate model providers for this load.
	ProviderRegistry *provider.Registry
	// AgentDefaultModels maps agent names to their configured default model references
	AgentDefaultModels map[string]string
	// Budget is the manifest's run-wide budget, or nil when the manifest
	// sets no run-wide ceiling. It is per-run rather than per-agent, so it
	// lives on the load result next to the team rather than on any
	// individual agent.
	Budget *latest.BudgetConfig
	// Budgets are the manifest's named budget definitions, and
	// AgentBudgets maps each agent to the budget names it declared. A name
	// referenced by several agents is one shared pot.
	Budgets      map[string]latest.BudgetConfig
	AgentBudgets map[string][]string
}

LoadResult contains the result of loading an agent team, including the team and configuration needed for runtime model switching.

func LoadWithConfig 

func LoadWithConfig(ctx context.Context, agentSource config.Source, runConfig *config.RuntimeConfig, opts ...Opt) (result *LoadResult, err error)

LoadWithConfig loads an agent team and returns both the team and config info needed for runtime model switching.

type Opt 

type Opt func(*loadOptions) error

func WithModelOptions added in v1.103.0 

func WithModelOptions(opts ...options.Opt) Opt

WithModelOptions appends caller-supplied options.Opt values to every model client teamloader constructs for this load: primary, fallback, title, and compaction models, as well as models built while loading external (OCI/URL-referenced) sub-agents. Use this to thread cross-cutting model configuration — most notably options.WithHTTPTransportWrapper, which lets an embedder authenticate every outbound LLM request (regardless of provider) without depending on provider-specific environment variables or environment.IsTrustedDockerURL. The opts are appended after teamloader's own built-in opts (options.WithGateway, options.WithStructuredOutput, etc.), so they take precedence for any option that both sides set.

func WithModelOverrides 

func WithModelOverrides(overrides []string) Opt

func WithPromptFiles 

func WithPromptFiles(files []string) Opt

WithPromptFiles adds additional prompt files to all agents. These are merged with any prompt files defined in the agent config.

func WithProviderRegistry added in v1.84.0 

func WithProviderRegistry(registry *provider.Registry) Opt

WithProviderRegistry allows using a custom model provider registry instead of the default.

func WithToolsetRegistry 

func WithToolsetRegistry(registry ToolsetRegistry) Opt

WithToolsetRegistry allows using a custom toolset registry instead of the default.

func WithWorkingDir added in v1.104.0 

func WithWorkingDir(dir string) Opt

WithWorkingDir overrides the working directory toolsets are built with, without touching the caller's RuntimeConfig. Callers that share one RuntimeConfig across concurrent loads (the API server, one per session) need this to keep each session's shell, filesystem and git tools rooted in that session's directory.

type ToolsetChange added in v1.54.0 

type ToolsetChange struct {
	Old latest.Toolset
	New latest.Toolset
}

ToolsetChange records a Toolset whose identity is unchanged but whose configuration signature differs.

type ToolsetCreator 

type ToolsetCreator func(ctx context.Context, toolset latest.Toolset, parentDir string, runConfig *config.RuntimeConfig, configName string) (tools.ToolSet, error)

ToolsetCreator is a function that creates a toolset based on the provided configuration. configName identifies the agent config file (e.g. "memory_agent" from "memory_agent.yaml").

type ToolsetDiff added in v1.54.0 

type ToolsetDiff struct {
	Added     []latest.Toolset
	Removed   []latest.Toolset
	Changed   []ToolsetChange
	Unchanged []latest.Toolset
}

ToolsetDiff is the result of comparing two slices of latest.Toolset (typically the currently-running set and a freshly-loaded set from disk). It is a building block for hot-reload: the runtime can stop Removed toolsets, start Added ones, and stop+start Changed ones, while leaving Unchanged toolsets running.

Identity is established by ToolsetIdentity (name+type for named toolsets, falling back to type+command/url for the rare unnamed case). "Changed" is defined as identity-equal but Signature-different.

func DiffToolsets added in v1.54.0 

func DiffToolsets(oldList, newList []latest.Toolset) ToolsetDiff

DiffToolsets compares two slices of toolset configs and returns a classification of which toolsets were added, removed, changed, or are unchanged.

The result preserves the order of the new slice for Added/Changed/ Unchanged, and the order of the old slice for Removed; this is a helpful invariant for status messages.

func (ToolsetDiff) HasChanges added in v1.54.0 

func (d ToolsetDiff) HasChanges() bool

HasChanges reports whether the diff requires any runtime action. It is useful as a fast-path for the hot-reload trigger: if HasChanges is false, the runtime can skip the diff entirely.

type ToolsetRegistry 

type ToolsetRegistry interface {
	CreateTool(ctx context.Context, toolset latest.Toolset, parentDir string, runConfig *config.RuntimeConfig, agentName string) (tools.ToolSet, error)
}

ToolsetRegistry manages the registration of toolset creators by type.

func NewDefaultToolsetRegistry 

func NewDefaultToolsetRegistry() ToolsetRegistry

NewDefaultToolsetRegistry returns the package-level default registry. It is empty unless an application explicitly wires creators into this package; YAML applications should use pkg/teamloader/toolsets.NewDefaultToolsetRegistry.

func NewToolsetRegistry 

func NewToolsetRegistry(creators map[string]ToolsetCreator) ToolsetRegistry

Source Files

View all Source files

Directories

Path Synopsis

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.