tool

type Attachment struct {
	Data     string `json:"data"`     // base64 encoded
	MimeType string `json:"mimeType"` // e.g., "image/png"
	Filename string `json:"filename,omitempty"`
}

type CallOptions struct {
	ToolCallID  string
	AbortSignal context.Context
}

type ContextKey string

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

type DeniedError struct {
	Reason string
}

type ExecuteFunc func(ctx context.Context, input json.RawMessage, opts CallOptions) (Result, error)

type Executor interface {
	// Execute runs a tool and returns the result.
	// The executor handles all local concerns (file system, permissions, etc.)
	Execute(ctx context.Context, req Request) (Response, error)

	// Tools returns information about available tools.
	// This is used to build the tool list for the LLM.
	Tools() []Info
}

type FatalToolError interface {
	error
	FatalToolError() bool
}

type Info struct {
	Name        string          `json:"name"`
	Description string          `json:"description"`
	InputSchema json.RawMessage `json:"input_schema"`
}

type Kind string

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

type ParseToolCallOptions struct {
	// ToolCall is the raw tool call from the model.
	ToolCall RawToolCall
	// Tools is the set of available tools. May be nil.
	Tools Set
	// RepairToolCall is an optional function to repair invalid tool calls.
	RepairToolCall RepairToolCallFunc
	// System is the system message (for repair context).
	System string
	// Messages is the conversation history (for repair context).
	Messages []message.Message
}

type ParsedToolCall struct {
	Type       string `json:"type"` // "tool-call"
	ToolCallID string `json:"toolCallId"`
	ToolName   string `json:"toolName"`
	// Input is the parsed JSON input (may be any JSON value)
	Input any `json:"input"`
	// Title is the optional tool title
	Title string `json:"title,omitempty"`
	// Dynamic indicates this is a dynamic tool call
	Dynamic bool `json:"dynamic,omitempty"`
	// Invalid indicates the tool call failed validation
	Invalid bool `json:"invalid,omitempty"`
	// Error contains the validation error if Invalid is true
	Error error `json:"error,omitempty"`
	// ProviderExecuted indicates the tool was executed by the provider
	ProviderExecuted bool `json:"providerExecuted,omitempty"`
	// ProviderMetadata contains provider-specific metadata
	ProviderMetadata map[string]any `json:"providerMetadata,omitempty"`
}

type PermissionRequest struct {
	// Permission type (e.g., "bash", "edit", "external_directory")
	Permission string `json:"permission"`

	// Patterns that need approval (e.g., command, file path)
	Patterns []string `json:"patterns"`

	// Description of what the tool wants to do
	Description string `json:"description,omitempty"`

	// Metadata contains additional context
	Metadata map[string]any `json:"metadata,omitempty"`
}

type RawToolCall struct {
	Type       string `json:"type"` // "tool-call"
	ToolCallID string `json:"toolCallId"`
	ToolName   string `json:"toolName"`
	Input      string `json:"input"` // JSON string of the input
	// Dynamic indicates the tool is not statically defined
	Dynamic bool `json:"dynamic,omitempty"`
	// ProviderExecuted indicates the tool was executed by the provider
	ProviderExecuted bool `json:"providerExecuted,omitempty"`
	// ProviderMetadata contains provider-specific metadata
	ProviderMetadata map[string]any `json:"providerMetadata,omitempty"`
}

type RepairToolCallContext struct {
	// ToolCall is the invalid tool call.
	ToolCall RawToolCall
	// Tools is the set of available tools.
	Tools Set
	// InputSchema returns the JSON schema for a tool by name.
	InputSchema func(toolName string) json.RawMessage
	// System is the system message.
	System string
	// Messages is the conversation history.
	Messages []message.Message
	// Error is the validation error that triggered repair.
	Error error
}

type RepairToolCallFunc func(ctx RepairToolCallContext) (*RawToolCall, error)

type Request struct {
	// ToolCallID is the unique identifier for this tool call (from LLM)
	ToolCallID string `json:"tool_call_id"`

	// ToolName is the name of the tool to execute
	ToolName string `json:"tool_name"`

	// Input is the tool-specific input (JSON)
	Input json.RawMessage `json:"input"`

	// SessionID identifies the session for file tracking and permissions
	SessionID string `json:"session_id,omitempty"`

	// WorkDir is the working directory for the tool
	WorkDir string `json:"work_dir,omitempty"`
}

type Response struct {
	// Output is the tool's text output
	Output string `json:"output"`

	// Title is an optional title for the result
	Title string `json:"title,omitempty"`

	// Error is set if the tool execution failed
	Error string `json:"error,omitempty"`

	// IsError indicates whether this response represents an error
	IsError bool `json:"is_error,omitempty"`

	// Denied indicates the call was refused (permission/policy) rather than
	// failed. Distinct from IsError so it serializes to execution-denied.
	// DeniedReason is the optional human-facing reason.
	Denied       bool   `json:"denied,omitempty"`
	DeniedReason string `json:"denied_reason,omitempty"`

	// NoExecute is true when the tool has no execute function.
	// This matches ai-sdk behavior where tools without execute return undefined.
	NoExecute bool `json:"no_execute,omitempty"`

	// Metadata contains optional structured data
	Metadata map[string]any `json:"metadata,omitempty"`

	// Attachments contains optional file attachments
	Attachments []Attachment `json:"attachments,omitempty"`

	// PermissionRequired is set when the tool needs permission to proceed.
	// The orchestrator should handle this by requesting permission and
	// potentially re-executing the tool.
	PermissionRequired *PermissionRequest `json:"permission_required,omitempty"`
}

type Result struct {
	Output      string         `json:"output"`
	Title       string         `json:"title,omitempty"`
	Metadata    map[string]any `json:"metadata,omitempty"`
	Attachments []Attachment   `json:"attachments,omitempty"`
}

type Set map[string]Tool

type Tool struct {
	// Type is "" (function tool) or "provider" (provider-defined tool).
	Type string `json:"type,omitempty"`

	// ProviderID is the canonical id for provider-defined tools, e.g.
	// "google.google_search", "openai.web_search". Empty for function tools.
	ProviderID string `json:"providerID,omitempty"`

	// Args is the JSON-encoded argument payload for provider-defined tools.
	// Empty when the tool takes no args.
	Args json.RawMessage `json:"args,omitempty"`

	Name        string          `json:"name"`
	Description string          `json:"description,omitempty"`
	InputSchema json.RawMessage `json:"inputSchema,omitempty"` // JSON Schema (function tools)
	// InputExamples is an optional list of example inputs that show the
	// language model what the tool input should look like. Mirrors ai-sdk's
	// LanguageModelV4FunctionTool.inputExamples. Providers that natively
	// accept examples (e.g. Anthropic via input_examples) pass them through;
	// others can use middleware.AddToolInputExamples to serialize them into
	// the description instead.
	InputExamples []ToolInputExample `json:"inputExamples,omitempty"`
	// OutputSchema is an optional JSON Schema describing the tool's result.
	// It travels with the tool for downstream consumers (MCP structuredContent,
	// result validation) but is NOT part of the wire tool definition sent to
	// providers like OpenAI, which advertise tool inputs only.
	OutputSchema    json.RawMessage `json:"outputSchema,omitempty"`
	Execute         ExecuteFunc     `json:"-"`
	ProviderOptions map[string]any  `json:"providerOptions,omitempty"`
}

type ToolInputExample struct {
	Input json.RawMessage `json:"input"`
}

type TypedDef[In, Out any] struct {
	// contains filtered or unexported fields
}

type TypedFunc[In, Out any] func(ctx context.Context, in In) (Out, error)