tool

type ActivationSpec struct {
	// Kind selects the activation mode: "history" or "tool_call".
	Kind string `yaml:"kind,omitempty" json:"kind,omitempty"`
	// Scope controls how many recorded calls are considered when kind==history:
	//  - "last" (default): only the most recent matching call is used
	//  - "all": aggregate data from all matching calls in the turn
	Scope string `yaml:"scope,omitempty" json:"scope,omitempty"`
	// Optional explicit tool to invoke when kind==tool_call. When omitted,
	// match.service/method may be used as a fallback by the consumer.
	Service string                 `yaml:"service,omitempty" json:"service,omitempty"`
	Method  string                 `yaml:"method,omitempty" json:"method,omitempty"`
	Args    map[string]interface{} `yaml:"args,omitempty" json:"args,omitempty"`
}

type AskFunc func(ctx context.Context, name string, args map[string]interface{}, p *Policy) bool

type AsyncResolver interface {
	AsyncConfig(name string) (*asynccfg.Config, bool)
}

type ContextMatcher interface {
	MatchDefinitionWithContext(ctx context.Context, pattern string) []*llm.ToolDefinition
}

type DataFeed struct {
	Name        string      `json:"name" yaml:"name"`
	Data        interface{} `json:"data" yaml:"data"`
	RawSelector string      `json:"rawSelector" yaml:"rawSelector"`
}

type DataSource struct {
	types.DataSource `yaml:",inline"`
	Source           string `json:"source" yaml:"source"`
	Name             string `json:"name" yaml:"name"`
}

type DataSources map[string]*DataSource

type Feed struct {
	ID string `json:"id" yaml:"id"`

	// Data holds resolved data blocks keyed by data-source or container name.
	Data DataFeed `json:"dataFeed" yaml:"dataFeed"`

	// UI carries a renderable container definition for Forge-based UIs.
	UI *types.Container `json:"ui" yaml:"ui"`

	// DataSources defines UI data sources
	DataSources map[string]*types.DataSource `yaml:"dataSources,omitempty" json:"dataSources,omitempty"`

	Invoked bool `json:"-" yaml:"-"`
}

type FeedSpec struct {
	ID          string          `yaml:"id,omitempty" json:"id,omitempty"`
	Title       string          `yaml:"title,omitempty" json:"title,omitempty"`
	Priority    int             `yaml:"priority,omitempty" json:"priority,omitempty"`
	Match       MatchSpec       `yaml:"match" json:"match"`
	Activation  ActivationSpec  `yaml:"activation" json:"activation"`
	DataSources DataSources     `yaml:"dataSource,omitempty" json:"dataSource,omitempty"`
	UI          types.Container `yaml:"ui" json:"ui"`
}

type FeedSpecs []*FeedSpec

type Handler func(ctx context.Context, args map[string]interface{}) (string, error)

type MatchSpec struct {
	Service string `yaml:"service,omitempty" json:"service,omitempty"`
	Method  string `yaml:"method,omitempty" json:"method,omitempty"`
}

type Policy struct {
	Mode      string   // ask, auto or deny
	AllowList []string // optional set of allowed tools (empty => all)
	BlockList []string // optional set of blocked tools
	Ask       AskFunc  // optional callback when Mode==ask
}

type PolicyError struct {
	// contains filtered or unexported fields
}

type Registry interface {
	// Definitions returns the merged list of available tool definitions.
	Definitions() []llm.ToolDefinition

	//MatchDefinition matches tool definition based on pattern
	MatchDefinition(pattern string) []*llm.ToolDefinition

	// GetDefinition fetches the definition for the given tool name. The second
	// result value indicates whether the definition exists.
	GetDefinition(name string) (*llm.ToolDefinition, bool)

	// MustHaveTools converts a set of patterns into the LLM toolkit slice used by
	// generation prompts.
	MustHaveTools(patterns []string) ([]llm.Tool, error)

	// Execute invokes the given tool with the supplied arguments and returns
	// its textual result.
	Execute(ctx context.Context, name string, args map[string]interface{}) (string, error)

	// SetDebugLogger attaches a writer that receives every executed tool call
	// for debugging.
	SetDebugLogger(w io.Writer)

	// Initialize allows registry implementations to perform optional
	// one-time discovery or warm-up (e.g., preload MCP servers/tools).
	// Implementations should be idempotent. Callers may safely ignore it.
	Initialize(ctx context.Context)
}

type Source struct {
	Service string `json:"service" yaml:"service"`
	Method  string `json:"method" yaml:"method"`
}

type TimeoutResolver interface {
	ToolTimeout(name string) (time.Duration, bool)
}