claude

type AssistantEvent struct {
	// MessageID is the unique message identifier from the API.
	MessageID string `json:"id"`

	// Content contains the content blocks (text, tool_use, etc.).
	Content []ContentBlock `json:"content"`

	// Model is the model that generated this message.
	Model string `json:"model"`

	// StopReason indicates why generation stopped ("end_turn", "tool_use", etc.).
	StopReason string `json:"stop_reason,omitempty"`

	// Usage contains per-message token usage (includes cache tokens).
	Usage MessageUsage `json:"usage"`

	// Text is a convenience field with concatenated text content.
	Text string `json:"-"`
}

type AssistantMessage = session.AssistantMessage

type CLIModelUsage struct {
	InputTokens              int     `json:"inputTokens"`
	OutputTokens             int     `json:"outputTokens"`
	CacheReadInputTokens     int     `json:"cacheReadInputTokens"`
	CacheCreationInputTokens int     `json:"cacheCreationInputTokens"`
	CostUSD                  float64 `json:"costUSD"`
}

type CLIResponse struct {
	Type             string                   `json:"type"`
	Subtype          string                   `json:"subtype"`
	IsError          bool                     `json:"is_error"`
	Result           string                   `json:"result"`
	StructuredOutput json.RawMessage          `json:"structured_output,omitempty"`
	SessionID        string                   `json:"session_id"`
	DurationMS       int                      `json:"duration_ms"`
	DurationAPI      int                      `json:"duration_api_ms"`
	NumTurns         int                      `json:"num_turns"`
	TotalCostUSD     float64                  `json:"total_cost_usd"`
	Usage            CLIUsage                 `json:"usage"`
	ModelUsage       map[string]CLIModelUsage `json:"modelUsage"`
}

type CLIUsage struct {
	InputTokens              int `json:"input_tokens"`
	OutputTokens             int `json:"output_tokens"`
	CacheCreationInputTokens int `json:"cache_creation_input_tokens"`
	CacheReadInputTokens     int `json:"cache_read_input_tokens"`
}

type CacheDetails struct {
	Ephemeral5mInputTokens int `json:"ephemeral_5m_input_tokens,omitempty"`
	Ephemeral1hInputTokens int `json:"ephemeral_1h_input_tokens,omitempty"`
}

type Capabilities struct {
	// Streaming indicates if the provider supports streaming responses.
	Streaming bool `json:"streaming"`

	// Tools indicates if the provider supports tool/function calling.
	Tools bool `json:"tools"`

	// MCP indicates if the provider supports MCP (Model Context Protocol) servers.
	MCP bool `json:"mcp"`

	// Sessions indicates if the provider supports multi-turn conversation sessions.
	Sessions bool `json:"sessions"`

	// Images indicates if the provider supports image inputs.
	Images bool `json:"images"`

	// NativeTools lists the provider's built-in tools by name.
	NativeTools []string `json:"native_tools"`

	// ContextFile is the filename for project-specific context (e.g., "CLAUDE.md").
	ContextFile string `json:"context_file,omitempty"`
}

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

type ClaudeOption func(*ClaudeCLI)

type Client interface {
	// Complete sends a request and returns the full response.
	// The context controls cancellation and timeouts.
	Complete(ctx context.Context, req CompletionRequest) (*CompletionResponse, error)

	// StreamJSON sends a request and returns streaming events plus a result future.
	// Events include init (session_id), assistant (per-message content/usage), result (final totals).
	// The channel closes when streaming completes. Use result.Wait() for the final ResultEvent.
	StreamJSON(ctx context.Context, req CompletionRequest) (<-chan StreamEvent, *StreamResult, error)
}

type CompletionRequest struct {
	// SystemPrompt sets the system message that guides the model's behavior.
	SystemPrompt string `json:"system_prompt,omitempty"`

	// Messages is the conversation history to send to the model.
	Messages []Message `json:"messages"`

	// Model specifies which model to use (e.g., "claude-sonnet-4-20250514").
	Model string `json:"model,omitempty"`

	// MaxTokens limits the response length.
	MaxTokens int `json:"max_tokens,omitempty"`

	// Temperature controls response randomness (0.0 = deterministic, 1.0 = creative).
	Temperature float64 `json:"temperature,omitempty"`

	// Tools lists available tools the model can invoke.
	Tools []Tool `json:"tools,omitempty"`

	// Options holds provider-specific configuration not covered by standard fields.
	Options map[string]any `json:"options,omitempty"`

	// JSONSchema forces structured output matching the given JSON schema.
	// When set, Claude will output valid JSON conforming to this schema.
	// This overrides any client-level schema set via WithJSONSchema().
	JSONSchema string `json:"json_schema,omitempty"`

	// OnEvent is called for each streaming event during execution.
	// Use this to capture transcripts in real-time, track progress, or log activity.
	// Events include: StreamEventInit, StreamEventAssistant, StreamEventResult, StreamEventHook.
	// If nil, events are still processed internally but not exposed to caller.
	// This callback is invoked synchronously - keep handlers fast to avoid blocking.
	OnEvent func(StreamEvent) `json:"-"`
}

type CompletionResponse struct {
	Content      string        `json:"content"`
	ToolCalls    []ToolCall    `json:"tool_calls,omitempty"`
	Usage        TokenUsage    `json:"usage"`
	Model        string        `json:"model"`
	FinishReason string        `json:"finish_reason"`
	Duration     time.Duration `json:"duration"`

	// Claude CLI specific fields (populated when using JSON output)
	SessionID string  `json:"session_id,omitempty"`
	CostUSD   float64 `json:"cost_usd,omitempty"`
	NumTurns  int     `json:"num_turns,omitempty"`
}

type Config struct {

	// Model is the primary model to use.
	// Default: "claude-sonnet-4-20250514"
	Model string `json:"model" yaml:"model" mapstructure:"model"`

	// FallbackModel is used when primary model is unavailable.
	// Optional.
	FallbackModel string `json:"fallback_model" yaml:"fallback_model" mapstructure:"fallback_model"`

	// SystemPrompt is the system message prepended to all requests.
	// Optional.
	SystemPrompt string `json:"system_prompt" yaml:"system_prompt" mapstructure:"system_prompt"`

	// AppendSystemPrompt is appended to the existing system prompt.
	// Use when you want to add to defaults rather than replace.
	AppendSystemPrompt string `json:"append_system_prompt" yaml:"append_system_prompt" mapstructure:"append_system_prompt"`

	// MaxTurns limits conversation turns (tool calls + responses).
	// 0 means no limit. Default: 10.
	MaxTurns int `json:"max_turns" yaml:"max_turns" mapstructure:"max_turns"`

	// Timeout is the maximum duration for a completion request.
	// 0 uses the default (5 minutes).
	Timeout time.Duration `json:"timeout" yaml:"timeout" mapstructure:"timeout"`

	// MaxBudgetUSD limits spending per request.
	// 0 means no limit.
	MaxBudgetUSD float64 `json:"max_budget_usd" yaml:"max_budget_usd" mapstructure:"max_budget_usd"`

	// WorkDir is the working directory for file operations.
	// Default: current directory.
	WorkDir string `json:"work_dir" yaml:"work_dir" mapstructure:"work_dir"`

	// AllowedTools limits which tools Claude can use.
	// Empty means all tools allowed.
	AllowedTools []string `json:"allowed_tools" yaml:"allowed_tools" mapstructure:"allowed_tools"`

	// DisallowedTools explicitly blocks certain tools.
	// Takes precedence over AllowedTools.
	DisallowedTools []string `json:"disallowed_tools" yaml:"disallowed_tools" mapstructure:"disallowed_tools"`

	// Tools specifies the exact list of available tools.
	// Different from AllowedTools which is a whitelist filter.
	Tools []string `json:"tools" yaml:"tools" mapstructure:"tools"`

	// DangerouslySkipPermissions bypasses permission prompts.
	// Use with extreme caution, only in trusted environments.
	DangerouslySkipPermissions bool `json:"dangerously_skip_permissions" yaml:"dangerously_skip_permissions" mapstructure:"dangerously_skip_permissions"`

	// PermissionMode sets the permission handling mode.
	// Valid values: "", "acceptEdits", "bypassPermissions"
	PermissionMode PermissionMode `json:"permission_mode" yaml:"permission_mode" mapstructure:"permission_mode"`

	// SessionID enables session persistence with this ID.
	// Optional.
	SessionID string `json:"session_id" yaml:"session_id" mapstructure:"session_id"`

	// Continue resumes the last session.
	Continue bool `json:"continue" yaml:"continue" mapstructure:"continue"`

	// Resume resumes a specific session by ID.
	Resume string `json:"resume" yaml:"resume" mapstructure:"resume"`

	// NoSessionPersistence disables session saving.
	NoSessionPersistence bool `json:"no_session_persistence" yaml:"no_session_persistence" mapstructure:"no_session_persistence"`

	// HomeDir overrides the home directory (for containers).
	HomeDir string `json:"home_dir" yaml:"home_dir" mapstructure:"home_dir"`

	// ConfigDir overrides the .claude config directory.
	ConfigDir string `json:"config_dir" yaml:"config_dir" mapstructure:"config_dir"`

	// Env provides additional environment variables.
	Env map[string]string `json:"env" yaml:"env" mapstructure:"env"`

	// OutputFormat controls CLI output format.
	// Default: "json".
	OutputFormat OutputFormat `json:"output_format" yaml:"output_format" mapstructure:"output_format"`

	// JSONSchema forces structured output matching the given schema.
	JSONSchema string `json:"json_schema" yaml:"json_schema" mapstructure:"json_schema"`

	// AddDirs adds directories to Claude's file access scope.
	AddDirs []string `json:"add_dirs" yaml:"add_dirs" mapstructure:"add_dirs"`

	// SettingSources specifies which setting sources to use.
	// Valid values: "project", "local", "user"
	SettingSources []string `json:"setting_sources" yaml:"setting_sources" mapstructure:"setting_sources"`

	// MCPConfigPath is the path to an MCP configuration JSON file.
	// Maps to the --mcp-config CLI flag.
	MCPConfigPath string `json:"mcp_config_path" yaml:"mcp_config_path" mapstructure:"mcp_config_path"`

	// MCPServers defines MCP servers inline (alternative to config file).
	// Keys are server names, values are server configurations.
	MCPServers map[string]MCPServerConfig `json:"mcp_servers" yaml:"mcp_servers" mapstructure:"mcp_servers"`

	// StrictMCPConfig ignores all MCP configurations except those specified.
	// Maps to the --strict-mcp-config CLI flag.
	StrictMCPConfig bool `json:"strict_mcp_config" yaml:"strict_mcp_config" mapstructure:"strict_mcp_config"`

	// ClaudePath is the path to the claude CLI binary.
	// Default: "claude" (found via PATH).
	ClaudePath string `json:"claude_path" yaml:"claude_path" mapstructure:"claude_path"`
}

type ContentBlock struct {
	Type      string          `json:"type"` // "text", "tool_use", "tool_result", "thinking"
	Text      string          `json:"text,omitempty"`
	ID        string          `json:"id,omitempty"`        // For tool_use
	Name      string          `json:"name,omitempty"`      // For tool_use
	Input     json.RawMessage `json:"input,omitempty"`     // For tool_use
	Thinking  string          `json:"thinking,omitempty"`  // For thinking blocks (extended thinking)
	Signature string          `json:"signature,omitempty"` // For thinking blocks (cryptographic signature)
}

type CredentialFile struct {
	ClaudeAiOauth *Credentials `json:"claudeAiOauth"`
}

type Credentials struct {
	// AccessToken is the OAuth access token for API authentication.
	AccessToken string `json:"accessToken"`

	// RefreshToken is used to obtain new access tokens.
	RefreshToken string `json:"refreshToken"`

	// ExpiresAt is the Unix timestamp (milliseconds) when the access token expires.
	ExpiresAt int64 `json:"expiresAt"`

	// Scopes are the OAuth scopes granted to this token.
	Scopes []string `json:"scopes"`

	// SubscriptionType indicates the Claude subscription tier (e.g., "max").
	SubscriptionType string `json:"subscriptionType"`

	// RateLimitTier indicates the rate limit tier for this subscription.
	RateLimitTier string `json:"rateLimitTier"`
}

type Error struct {
	Op        string // Operation that failed ("complete", "stream")
	Err       error  // Underlying error
	Retryable bool   // Whether the error is likely transient
}

type FileResult struct {
	FilePath   string `json:"filePath"`
	Content    string `json:"content"`
	NumLines   int    `json:"numLines"`
	StartLine  int    `json:"startLine"`
	TotalLines int    `json:"totalLines"`
}

type HookEvent struct {
	SessionID string `json:"session_id"`
	HookName  string `json:"hook_name"`
	HookEvent string `json:"hook_event"`
	Stdout    string `json:"stdout"`
	Stderr    string `json:"stderr"`
	ExitCode  int    `json:"exit_code"`
}

type InitEvent struct {
	SessionID         string      `json:"session_id"`
	Model             string      `json:"model"`
	CWD               string      `json:"cwd"`
	Tools             []string    `json:"tools"`
	MCPServers        []MCPServer `json:"mcp_servers,omitempty"`
	ClaudeCodeVersion string      `json:"claude_code_version"`
	PermissionMode    string      `json:"permissionMode"`
}

type InitMessage = session.InitMessage

type MCPServer struct {
	Name   string `json:"name"`
	Status string `json:"status"`
}

type MCPServerConfig struct {
	// Type specifies the transport type: "stdio", "http", or "sse".
	// If empty, defaults to "stdio" for servers with Command set.
	Type string `json:"type,omitempty" yaml:"type,omitempty" mapstructure:"type"`

	// Command is the command to run the MCP server (for stdio transport).
	Command string `json:"command,omitempty" yaml:"command,omitempty" mapstructure:"command"`

	// Args are the arguments to pass to the command (for stdio transport).
	Args []string `json:"args,omitempty" yaml:"args,omitempty" mapstructure:"args"`

	// Env provides environment variables for the server process.
	Env map[string]string `json:"env,omitempty" yaml:"env,omitempty" mapstructure:"env"`

	// URL is the server endpoint (for http/sse transport).
	URL string `json:"url,omitempty" yaml:"url,omitempty" mapstructure:"url"`

	// Headers are HTTP headers (for http/sse transport).
	Headers []string `json:"headers,omitempty" yaml:"headers,omitempty" mapstructure:"headers"`
}

type ManagerOption = session.ManagerOption

type Message struct {
	Role    Role   `json:"role"`
	Content string `json:"content"`
	Name    string `json:"name,omitempty"` // For tool results
}

type MessageUsage struct {
	InputTokens              int           `json:"input_tokens"`
	OutputTokens             int           `json:"output_tokens"`
	CacheCreationInputTokens int           `json:"cache_creation_input_tokens,omitempty"`
	CacheReadInputTokens     int           `json:"cache_read_input_tokens,omitempty"`
	CacheCreation            *CacheDetails `json:"cache_creation,omitempty"`
	ServiceTier              string        `json:"service_tier,omitempty"`
}

type MockClient struct {

	// Calls tracks all requests for assertions.
	Calls []CompletionRequest
	// contains filtered or unexported fields
}

type ModelUsageDetail struct {
	InputTokens              int     `json:"inputTokens"`
	OutputTokens             int     `json:"outputTokens"`
	CacheReadInputTokens     int     `json:"cacheReadInputTokens,omitempty"`
	CacheCreationInputTokens int     `json:"cacheCreationInputTokens,omitempty"`
	WebSearchRequests        int     `json:"webSearchRequests,omitempty"`
	CostUSD                  float64 `json:"costUSD"`
	ContextWindow            int     `json:"contextWindow,omitempty"`
	MaxOutputTokens          int     `json:"maxOutputTokens,omitempty"`
}

type OutputFormat string

type OutputMessage = session.OutputMessage

type PermissionMode string

type ResultEvent struct {
	// Subtype is "success" or "error".
	Subtype string `json:"subtype"`

	// IsError indicates if this is an error result.
	IsError bool `json:"is_error"`

	// Result is the text result (for non-schema requests).
	Result string `json:"result"`

	// StructuredOutput contains JSON when --json-schema was used.
	StructuredOutput json.RawMessage `json:"structured_output,omitempty"`

	// SessionID is the session identifier.
	SessionID string `json:"session_id"`

	// DurationMS is the total request duration in milliseconds.
	DurationMS int `json:"duration_ms"`

	// DurationAPIMS is the time spent in API calls.
	DurationAPIMS int `json:"duration_api_ms"`

	// NumTurns is the number of agentic turns taken.
	NumTurns int `json:"num_turns"`

	// TotalCostUSD is the total cost of this request.
	TotalCostUSD float64 `json:"total_cost_usd"`

	// Usage contains cumulative token usage.
	Usage ResultUsage `json:"usage"`

	// ModelUsage contains per-model usage breakdown.
	ModelUsage map[string]ModelUsageDetail `json:"modelUsage,omitempty"`
}

type ResultMessage = session.ResultMessage

type ResultUsage struct {
	InputTokens              int           `json:"input_tokens"`
	OutputTokens             int           `json:"output_tokens"`
	CacheCreationInputTokens int           `json:"cache_creation_input_tokens,omitempty"`
	CacheReadInputTokens     int           `json:"cache_read_input_tokens,omitempty"`
	CacheCreation            *CacheDetails `json:"cache_creation,omitempty"`
	ServiceTier              string        `json:"service_tier,omitempty"`
}

type Role string

type Session = session.Session

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

type SessionInfo = session.SessionInfo

type SessionManager = session.SessionManager

type SessionOption = session.SessionOption

type SessionStatus = session.SessionStatus

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

type StreamEvent struct {
	// Type identifies which field is populated.
	Type StreamEventType

	// SessionID is available on all events after init.
	SessionID string

	// Init is populated when Type == StreamEventInit.
	Init *InitEvent

	// Assistant is populated when Type == StreamEventAssistant.
	Assistant *AssistantEvent

	// Result is populated when Type == StreamEventResult.
	Result *ResultEvent

	// User is populated when Type == StreamEventUser.
	// Contains tool results from tool executions.
	User *UserEvent

	// Hook is populated when Type == StreamEventHook.
	Hook *HookEvent

	// Error is populated when Type == StreamEventError.
	Error error

	// Raw contains the original JSON for advanced parsing.
	Raw json.RawMessage
}

type StreamEventType string

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

type TokenUsage struct {
	InputTokens  int `json:"input_tokens"`
	OutputTokens int `json:"output_tokens"`
	TotalTokens  int `json:"total_tokens"`

	// Cache-related tokens (Claude specific)
	CacheCreationInputTokens int `json:"cache_creation_input_tokens,omitempty"`
	CacheReadInputTokens     int `json:"cache_read_input_tokens,omitempty"`
}

type Tool struct {
	Name        string          `json:"name"`
	Description string          `json:"description"`
	Parameters  json.RawMessage `json:"parameters"` // JSON Schema
}

type ToolCall struct {
	ID        string          `json:"id"`
	Name      string          `json:"name"`
	Arguments json.RawMessage `json:"arguments"`
}

type ToolResultContent struct {
	Type      string `json:"type"`               // "tool_result"
	ToolUseID string `json:"tool_use_id"`        // Matches the tool_use block's ID
	IsError   bool   `json:"is_error,omitempty"` // True if tool execution failed

	// ContentRaw holds the raw content field which can be:
	// - A string (simple tool result)
	// - An array of objects (complex result like subagent output)
	ContentRaw json.RawMessage `json:"content"`
}

type ToolUseResult struct {
	Type string `json:"type"` // "text", "image", etc.

	// File is populated for file read operations.
	File *FileResult `json:"file,omitempty"`
}

type UserEvent struct {
	// SessionID is the session identifier.
	SessionID string `json:"session_id"`

	// Message contains the tool result content.
	Message UserEventMessage `json:"message"`

	// ParentToolUseID links this result to a subagent's tool use (if any).
	ParentToolUseID *string `json:"parent_tool_use_id"`

	// ToolUseResultRaw contains the raw tool_use_result field.
	// Can be a string (error message) or object (structured result).
	// Use GetToolUseResult() to get the parsed value.
	ToolUseResultRaw json.RawMessage `json:"tool_use_result,omitempty"`

	// UUID is the unique event identifier.
	UUID string `json:"uuid,omitempty"`
}

type UserEventMessage struct {
	Role    string              `json:"role"`
	Content []ToolResultContent `json:"content"`
}

type UserMessage = session.UserMessage