tools

type A2AAuthConfig struct {
	Scheme   string `json:"scheme" yaml:"scheme"`                           // e.g. "Bearer", "Basic"
	Token    string `json:"token,omitempty" yaml:"token,omitempty"`         // Static token value
	TokenEnv string `json:"token_env,omitempty" yaml:"token_env,omitempty"` // Env var containing the token
}

type A2AConfig struct {
	AgentURL       string            `json:"agent_url" yaml:"agent_url"`
	SkillID        string            `json:"skill_id" yaml:"skill_id"`
	TimeoutMs      int               `json:"timeout_ms,omitempty" yaml:"timeout_ms,omitempty"`
	Headers        map[string]string `json:"headers,omitempty" yaml:"headers,omitempty"`
	HeadersFromEnv []string          `json:"headers_from_env,omitempty" yaml:"headers_from_env,omitempty"`
	Auth           *A2AAuthConfig    `json:"auth,omitempty" yaml:"auth,omitempty"`
	RetryPolicy    *A2ARetryConfig   `json:"retry,omitempty" yaml:"retry,omitempty"`
	SkillFilter    *A2ASkillFilter   `json:"skill_filter,omitempty" yaml:"skill_filter,omitempty"`
}

type A2ARetryConfig struct {
	MaxRetries     int `json:"max_retries,omitempty" yaml:"max_retries,omitempty"`
	InitialDelayMs int `json:"initial_delay_ms,omitempty" yaml:"initial_delay_ms,omitempty"`
	MaxDelayMs     int `json:"max_delay_ms,omitempty" yaml:"max_delay_ms,omitempty"`
}

type A2ASkillFilter struct {
	Allowlist []string `json:"allowlist,omitempty" yaml:"allowlist,omitempty"`
	Blocklist []string `json:"blocklist,omitempty" yaml:"blocklist,omitempty"`
}

type AsyncToolExecutor interface {
	Executor // Still implements the basic Executor interface

	// ExecuteAsync may return immediately with a pending status
	ExecuteAsync(ctx context.Context, descriptor *ToolDescriptor, args json.RawMessage) (*ToolExecutionResult, error)
}

type ClientConfig struct {
	Consent        *ConsentConfig `json:"consent,omitempty" yaml:"consent,omitempty"`
	TimeoutMs      int            `json:"timeout_ms,omitempty" yaml:"timeout_ms,omitempty"`
	Categories     []string       `json:"categories,omitempty" yaml:"categories,omitempty"`
	ValidateOutput bool           `json:"validate_output,omitempty" yaml:"validate_output,omitempty"`
}

type Coercion struct {
	Path string `json:"path"`
	From any    `json:"from"`
	To   any    `json:"to"`
}

type ConsentConfig struct {
	Required bool   `json:"required" yaml:"required"`
	Message  string `json:"message,omitempty" yaml:"message,omitempty"`
	// DeclineStrategy: "fallback" | "error" | "retry"
	DeclineStrategy string `json:"decline_strategy,omitempty" yaml:"decline_strategy,omitempty"`
}

type DefaultRequestMapper struct{}

type DefaultResponseMapper struct{}

type ErrToolsPending struct {
	Pending []PendingToolExecution
}

type Executor interface {
	Execute(ctx context.Context, descriptor *ToolDescriptor, args json.RawMessage) (json.RawMessage, error)
	Name() string
}

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

type HTTPConfig struct {
	URL            string            `json:"url" yaml:"url"`
	Method         string            `json:"method" yaml:"method"`
	HeadersFromEnv []string          `json:"headers_from_env,omitempty" yaml:"headers_from_env,omitempty"`
	TimeoutMs      int               `json:"timeout_ms" yaml:"timeout_ms"`
	Redact         []string          `json:"redact,omitempty" yaml:"redact,omitempty"`
	Headers        map[string]string `json:"headers,omitempty" yaml:"headers,omitempty"`

	// Request/response mapping configuration
	Request  *RequestMapping  `json:"request,omitempty" yaml:"request,omitempty"`
	Response *ResponseMapping `json:"response,omitempty" yaml:"response,omitempty"`

	// Multimodal response handling
	Multimodal *MultimodalConfig `json:"multimodal,omitempty" yaml:"multimodal,omitempty"`
}

type HTTPExecutor struct {

	// RequestMapper customizes how tool args map to HTTP requests.
	// If nil, DefaultRequestMapper is used.
	RequestMapper RequestMapper

	// ResponseMapper customizes how HTTP responses map to tool results.
	// If nil, DefaultResponseMapper is used.
	ResponseMapper ResponseMapper
	// contains filtered or unexported fields
}

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

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

type MockScriptedExecutor struct{}

type MockStaticExecutor struct{}

type MockToolErrorConfig struct {
	Type    string `yaml:"type"`
	Message string `yaml:"message"`
}

type MockToolResponseConfig struct {
	CallArgs map[string]any       `yaml:"call_args"`
	Result   any                  `yaml:"result,omitempty"`
	Error    *MockToolErrorConfig `yaml:"error,omitempty"`
}

type MultimodalConfig struct {
	// Enabled activates Content-Type-based detection of binary responses.
	Enabled bool `json:"enabled" yaml:"enabled"`

	// AcceptTypes lists the MIME types the tool may return (e.g. "image/png", "audio/wav").
	// If empty, common image/audio/video types are auto-detected.
	AcceptTypes []string `json:"accept_types,omitempty" yaml:"accept_types,omitempty"`
}

type MultimodalExecutor interface {
	Executor

	// ExecuteMultimodal returns both the JSON result and optional content parts.
	ExecuteMultimodal(
		ctx context.Context, descriptor *ToolDescriptor, args json.RawMessage,
	) (json.RawMessage, []types.ContentPart, error)
}

type PendingToolExecution struct {
	CallID      string                  `json:"call_id"`
	ToolName    string                  `json:"tool_name"`
	Args        map[string]any          `json:"args"`
	PendingInfo *PendingToolInfo        `json:"pending_info,omitempty"`
	ToolResult  types.MessageToolResult `json:"tool_result"`
}

type PendingToolInfo struct {
	// Reason for pending (e.g., "requires_approval", "waiting_external_api")
	Reason string `json:"reason"`

	// Human-readable description
	Message string `json:"message"`

	// Tool details (for middleware to use in notifications)
	ToolName string          `json:"tool_name"`
	Args     json.RawMessage `json:"args"`

	// Optional: expiration, callback URL, etc.
	ExpiresAt   *time.Time `json:"expires_at,omitempty"`
	CallbackURL string     `json:"callback_url,omitempty"`

	// Arbitrary metadata for custom middleware
	Metadata map[string]any `json:"metadata,omitempty"`
}

type PredictMessage struct {
	Role               string     `json:"role"`
	Content            string     `json:"content"`
	ToolCalls          []ToolCall `json:"tool_calls,omitempty"`
	ToolCallResponseID string     `json:"tool_call_id,omitempty"` // For tool result messages
}

type PredictionRequest struct {
	System      string           `json:"system"`
	Messages    []PredictMessage `json:"messages"`
	Temperature float32          `json:"temperature"`
	TopP        float32          `json:"top_p"`
	MaxTokens   int              `json:"max_tokens"`
	Seed        *int             `json:"seed,omitempty"`
}

type PredictionResponse struct {
	Content   string        `json:"content"`
	TokensIn  int           `json:"tokens_in"`
	TokensOut int           `json:"tokens_out"`
	Latency   time.Duration `json:"latency"`
	Raw       []byte        `json:"raw,omitempty"`
	ToolCalls []ToolCall    `json:"tool_calls,omitempty"` // Tools called in this response
}

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

type RegistryOption func(*Registry)

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

type RequestMapper interface {
	// RenderURL applies path parameter substitution to the URL template.
	RenderURL(urlTemplate string, args map[string]any) (string, error)

	// PartitionArgs splits tool arguments into query, header, and body buckets
	// based on the mapping configuration.
	PartitionArgs(args map[string]any, cfg *RequestMapping, urlTemplate string) (query, header, body map[string]any)

	// BuildBody produces the JSON request body from the body arguments.
	// If a JMESPath body_mapping is configured, it reshapes the args.
	BuildBody(bodyArgs map[string]any, jmespathExpr string) (json.RawMessage, error)

	// RenderHeaders applies template interpolation to header values.
	RenderHeaders(templates map[string]string, args map[string]any) (map[string]string, error)
}

type RequestMapping struct {
	// QueryParams lists argument keys to route as URL query parameters.
	QueryParams []string `json:"query_params,omitempty" yaml:"query_params,omitempty"`

	// HeaderParams maps HTTP header names to Go text/template strings
	// that interpolate tool arguments. E.g. {"Authorization": "Bearer {{.token}}"}.
	HeaderParams map[string]string `json:"header_params,omitempty" yaml:"header_params,omitempty"`

	// BodyMapping is a JMESPath expression to reshape the body arguments
	// before sending. Only applies to POST/PUT/PATCH requests.
	BodyMapping string `json:"body_mapping,omitempty" yaml:"body_mapping,omitempty"`

	// Exclude lists argument keys to omit from the request entirely.
	// Keys consumed by URL path templates and header templates are
	// automatically excluded from the body.
	Exclude []string `json:"exclude,omitempty" yaml:"exclude,omitempty"`

	// StaticQuery injects fixed query parameters into every request.
	// These are not part of the LLM's input schema — they control
	// API behavior (e.g. result count, language, format).
	StaticQuery map[string]string `json:"static_query,omitempty" yaml:"static_query,omitempty"`

	// StaticHeaders injects fixed headers into every request.
	// Unlike header_params, these are literal values, not templates.
	StaticHeaders map[string]string `json:"static_headers,omitempty" yaml:"static_headers,omitempty"`

	// StaticBody injects fixed fields into the JSON request body.
	// Only applies to POST/PUT/PATCH. Merged with LLM-provided body fields.
	StaticBody map[string]any `json:"static_body,omitempty" yaml:"static_body,omitempty"`
}

type ResponseMapper interface {
	// MapResponse applies a JMESPath expression to reshape the response JSON.
	MapResponse(response json.RawMessage, jmespathExpr string) (json.RawMessage, error)
}

type ResponseMapping struct {
	// BodyMapping is a JMESPath expression to extract or reshape the response JSON.
	BodyMapping string `json:"body_mapping,omitempty" yaml:"body_mapping,omitempty"`
}

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

type ToolCall struct {
	Name string          `json:"name"`
	Args json.RawMessage `json:"args"`
	ID   string          `json:"id"` // Provider-specific call ID
}

type ToolConfig struct {
	APIVersion string            `json:"apiVersion" yaml:"apiVersion"`
	Kind       string            `json:"kind" yaml:"kind"`
	Metadata   metav1.ObjectMeta `json:"metadata,omitempty" yaml:"metadata,omitempty"`
	Spec       ToolDescriptor    `json:"spec" yaml:"spec"`
}

type ToolDescriptor struct {
	Name         string          `json:"name" yaml:"name"`
	Namespace    string          `json:"namespace,omitempty" yaml:"namespace,omitempty"`
	Description  string          `json:"description" yaml:"description"`
	InputSchema  json.RawMessage `json:"input_schema" yaml:"input_schema"`   // JSON Schema Draft-07
	OutputSchema json.RawMessage `json:"output_schema" yaml:"output_schema"` // JSON Schema Draft-07
	Mode         string          `json:"mode" yaml:"mode"`                   // "mock" | "live"
	TimeoutMs    int             `json:"timeout_ms" yaml:"timeout_ms"`

	// Static mock data (in-memory)
	MockResult json.RawMessage `json:"mock_result,omitempty" yaml:"mock_result,omitempty"`
	// Multimodal mock parts (text, image, audio, etc.)
	MockParts []types.ContentPart `json:"mock_parts,omitempty" yaml:"mock_parts,omitempty"`
	// Template for dynamic mocks (inline or file)
	MockTemplate     string `json:"mock_template,omitempty" yaml:"mock_template,omitempty"`
	MockResultFile   string `json:"mock_result_file,omitempty" yaml:"mock_result_file,omitempty"`
	MockTemplateFile string `json:"mock_template_file,omitempty" yaml:"mock_template_file,omitempty"`

	HTTPConfig   *HTTPConfig   `json:"http,omitempty" yaml:"http,omitempty"`     // Live HTTP configuration
	A2AConfig    *A2AConfig    `json:"a2a,omitempty" yaml:"a2a,omitempty"`       // A2A agent configuration
	ClientConfig *ClientConfig `json:"client,omitempty" yaml:"client,omitempty"` // Client-side execution configuration
}

type ToolErrorData struct {
	Type    string `json:"type"`    // Error type/category
	Message string `json:"message"` // Error message
}

type ToolExecutionResult struct {
	Status  ToolExecutionStatus `json:"status"`
	Content json.RawMessage     `json:"content,omitempty"`
	Parts   []types.ContentPart `json:"parts,omitempty"`
	Error   string              `json:"error,omitempty"`

	// Present when Status == ToolStatusPending
	PendingInfo *PendingToolInfo `json:"pending_info,omitempty"`
}

type ToolExecutionStatus string

type ToolGuidance struct {
	Support   string `json:"support,omitempty"`
	Assistant string `json:"assistant,omitempty"`
	Generic   string `json:"generic,omitempty"`
}

type ToolPolicy struct {
	ToolChoice          string   `json:"tool_choice"` // "auto" | "required" | "none"
	MaxToolCallsPerTurn int      `json:"max_tool_calls_per_turn"`
	MaxTotalToolCalls   int      `json:"max_total_tool_calls"`
	Blocklist           []string `json:"blocklist,omitempty"`
}

type ToolRepository interface {
	LoadTool(name string) (*ToolDescriptor, error)
	ListTools() ([]string, error)
	SaveTool(descriptor *ToolDescriptor) error
}

type ToolResponseData struct {
	Result any            `json:"result,omitempty"` // Successful response data
	Error  *ToolErrorData `json:"error,omitempty"`  // Error response
}

type ToolResponseRepository interface {
	// GetToolResponse retrieves a mock response for a tool execution.
	// Returns nil if no matching response is configured (not an error).
	GetToolResponse(toolName string, args map[string]any, contextKey string) (*ToolResponseData, error)
}

type ToolResult struct {
	Name      string              `json:"name"`
	ID        string              `json:"id"` // Matches ToolCall.ID
	Result    json.RawMessage     `json:"result"`
	Parts     []types.ContentPart `json:"parts,omitempty"`
	LatencyMs int64               `json:"latency_ms"`
	Error     string              `json:"error,omitempty"`
}

type ValidationError struct {
	Type   string `json:"type"` // "args_invalid" | "result_invalid" | "policy_violation"
	Tool   string `json:"tool"`
	Detail string `json:"detail"`
	Path   string `json:"path,omitempty"`
}