types

type ContentBlock struct {
	// Type is the content type ("text" or "image")
	Type string

	// Text contains text content (when Type is "text")
	Text string

	// Image contains image content (when Type is "image")
	Image *ImageContent
}

type Context interface {
	// Embed standard context
	context.Context

	// Session returns the current session
	Session() *Session

	// Tracer returns the observability tracer
	Tracer() observability.Tracer

	// ProgressCallback returns the progress callback (may be nil)
	ProgressCallback() ProgressCallback
}

type ExecutionStage string

type HITLRequestInfo struct {
	// RequestID is the unique HITL request identifier
	RequestID string

	// Question is the question being asked to the human
	Question string

	// RequestType is the type of request (approval, decision, input, review)
	RequestType string

	// Priority is the request priority (low, normal, high, critical)
	Priority string

	// Timeout is how long to wait for human response
	Timeout time.Duration

	// Context provides additional context for the request
	Context map[string]interface{}
}

type ImageContent struct {
	// Type is always "image"
	Type string

	// Source contains the image data
	Source ImageSource
}

type ImageSource struct {
	// Type is the source type ("base64" or "url")
	Type string

	// MediaType is the MIME type ("image/jpeg", "image/png", "image/gif", "image/webp")
	MediaType string

	// Data contains base64-encoded image data (when Type is "base64")
	Data string

	// URL contains the image URL (when Type is "url")
	URL string
}

type LLMProvider interface {
	// Chat sends a conversation to the LLM and returns the response
	Chat(ctx context.Context, messages []Message, tools []shuttle.Tool) (*LLMResponse, error)

	// Name returns the provider name
	Name() string

	// Model returns the model identifier
	Model() string
}

type LLMResponse struct {
	// Content is the text response (if no tool calls)
	Content string

	// ToolCalls contains requested tool executions
	ToolCalls []ToolCall

	// StopReason indicates why the LLM stopped
	StopReason string

	// Usage tracks token usage
	Usage Usage

	// Metadata contains provider-specific metadata
	Metadata map[string]interface{}

	// Thinking contains the agent's internal reasoning process
	// (for models that support extended thinking like Claude with thinking blocks)
	Thinking string
}

type Message struct {
	// ID is the unique message identifier (from database)
	ID string

	// Role is the message sender (user, assistant, tool)
	Role string

	// Content is the message text (for text-only messages, backward compatible)
	Content string

	// ContentBlocks contains multi-modal content (text and/or images)
	// If present, this takes precedence over Content field
	ContentBlocks []ContentBlock

	// ToolCalls contains tool invocations (if role is assistant)
	ToolCalls []ToolCall

	// ToolUseID is the ID of the tool_use block this result corresponds to (if role is tool)
	// This is used by LLM providers like Bedrock/Anthropic to match tool results to tool requests
	ToolUseID string

	// ToolResult contains tool execution result (if role is tool)
	ToolResult *shuttle.Result

	// SessionContext identifies the context (direct, coordinator, shared)
	// Used for cross-session memory filtering
	SessionContext SessionContext

	// Timestamp when the message was created
	Timestamp time.Time

	// TokenCount for cost tracking
	TokenCount int

	// CostUSD for cost tracking
	CostUSD float64
}

type ProgressCallback func(event ProgressEvent)

type ProgressEvent struct {
	// Stage is the current execution stage
	Stage ExecutionStage

	// Progress is the completion percentage (0-100)
	Progress int32

	// Message is a human-readable description of current activity
	Message string

	// ToolName is the tool being executed (if applicable)
	ToolName string

	// Timestamp when this event occurred
	Timestamp time.Time

	// HITLRequest contains HITL request details (only when Stage == StageHumanInTheLoop)
	HITLRequest *HITLRequestInfo

	// PartialContent is the accumulated content so far during streaming
	PartialContent string

	// IsTokenStream indicates if this event is a token streaming update
	IsTokenStream bool

	// TokenCount is the running count of tokens received
	TokenCount int32

	// TTFT is the time to first token in milliseconds (0 if not applicable)
	TTFT int64
}

type SegmentedMemoryInterface interface {
	AddMessage(msg Message)
	GetMessagesForLLM() []Message
}

type Session struct {

	// ID is the unique session identifier
	ID string

	// AgentID identifies which agent owns this session (for cross-session memory)
	// Example: "coordinator-agent", "analyzer-sub-agent"
	// This enables agent-scoped memory where a sub-agent can access messages
	// from multiple sessions (coordinator parent + direct user sessions)
	AgentID string

	// ParentSessionID links sub-agent sessions to their coordinator session
	// NULL for top-level sessions (direct user interaction)
	// Set for sub-agent sessions created by workflow coordinators
	ParentSessionID string

	// Messages is the conversation history (flat, for backward compatibility)
	Messages []Message

	// SegmentedMem is the tiered memory manager (ROM/Kernel/L1/L2)
	// If nil, falls back to flat Messages list
	// Note: SegmentedMemory type will remain in pkg/agent
	SegmentedMem interface{} // Keep as interface{} to avoid circular dependency

	// FailureTracker tracks consecutive tool failures for escalation
	// Note: consecutiveFailureTracker type will remain in pkg/agent
	FailureTracker interface{} // Keep as interface{} to avoid circular dependency

	// Context holds session-specific context (database, table, etc.)
	Context map[string]interface{}

	// CreatedAt is when the session was created
	CreatedAt time.Time

	// UpdatedAt is when the session was last updated
	UpdatedAt time.Time

	// TotalCostUSD is the accumulated cost for this session
	TotalCostUSD float64

	// TotalTokens is the accumulated token usage
	TotalTokens int
	// contains filtered or unexported fields
}

type SessionContext string

type StreamingLLMProvider interface {
	LLMProvider

	// ChatStream streams tokens as they're generated from the LLM.
	// Returns the complete LLMResponse after the stream finishes.
	// Calls tokenCallback for each token/chunk received from the LLM.
	// The callback is called synchronously and should not block.
	ChatStream(ctx context.Context, messages []Message, tools []shuttle.Tool,
		tokenCallback TokenCallback) (*LLMResponse, error)
}

type TokenCallback func(token string)

type ToolCall struct {
	// ID is a unique identifier for this tool call
	ID string

	// Name is the tool name
	Name string

	// Input contains the tool parameters as JSON
	Input map[string]interface{}
}

type Usage struct {
	InputTokens  int
	OutputTokens int
	TotalTokens  int
	CostUSD      float64
}