ai

type APIError struct {
	Provider   string
	StatusCode int
	Body       string
	// RetryAfter is the wait the server asked for (Retry-After header), or 0.
	RetryAfter time.Duration
}

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

type AgentHook func(step int, msg Message)

type ApprovalFunc func(ctx context.Context, req ApprovalRequest) (Decision, error)

type ApprovalRequest struct {
	Call ToolCall
	Tool *Tool
}

type ApprovalRequiredError struct {
	Pending []ToolCall
}

type Attachment struct {
	MediaType string // e.g. image/png, application/pdf
	Data      []byte
	Name      string // file name, when known
}

type CameraMove string

type ChunkOption func(*chunkConfig)

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

type ComparisonReport struct {
	Suite   string       `json:"suite"`
	Reports []EvalReport `json:"reports"`
}

type Config struct {
	Provider string
	Model    string
	// ImageProvider and ImageModel configure image generation separately from
	// text. Images come from a different endpoint, and the best image model is
	// rarely from the same family as the text model — so "gemini for pictures,
	// something else for reasoning" is a supported combination.
	//
	// Resolution order for the model: ai.Image().Model(…) → ImageModel →
	// the provider's default.
	ImageProvider string
	ImageModel    string
	// ImageAPIKey and ImageBaseURL put image generation on its own account
	// and endpoint; VideoProvider, VideoModel, VideoAPIKey and VideoBaseURL
	// do the same for video. Unset, each falls back to the text setting
	// (see media.go).
	ImageAPIKey   string
	ImageBaseURL  string
	VideoProvider string
	VideoModel    string
	VideoAPIKey   string
	VideoBaseURL  string
	// FallbackModel is the model an app retries on when the main one has
	// nothing to give (out of credit, overloaded). With FallbackProvider,
	// FallbackAPIKey or FallbackBaseURL set it lives on its own account:
	// a request naming FallbackModel is sent there (see media.go).
	FallbackProvider string
	FallbackModel    string
	FallbackAPIKey   string
	FallbackBaseURL  string

	Timeout   int
	MaxTokens int
	// MaxRetries is how many times a rate-limited or failed request is
	// retried (0 = DefaultMaxRetries, negative = never). See retry.go.
	MaxRetries int
	// PromptCache turns on prompt caching for every request (see
	// WithPromptCache). AI_PROMPT_CACHE=true.
	PromptCache bool
	// Text generation providers
	OpenAIKey        string
	OpenAIBaseURL    string
	AnthropicKey     string
	AnthropicBaseURL string
	AnthropicAPIURL  string
	CohereKey        string
	GeminiKey        string
	MistralKey       string
	XAIKey           string
	// Ollama uses OLLAMA_HOST (default localhost:11434), no key
	OllamaHost string
	// Embeddings / specialized (for future use)
	JinaKey       string
	VoyageAIKey   string
	ElevenLabsKey string
	// contains filtered or unexported fields
}

type ContentFilter int

type ContextOption func(*contextPolicy)

type ConversationRecord struct {
	ID        uint      `gorm:"primarykey"`
	Key       string    `gorm:"index;size:255;not null"`
	Messages  string    `gorm:"type:text;not null"` // JSON-encoded []Message
	CreatedAt time.Time `gorm:"autoCreateTime"`
	UpdatedAt time.Time `gorm:"autoUpdateTime"`
}

type CostConfig struct {
	// MonthlyBudget is the monthly budget in USD. 0 = unlimited.
	MonthlyBudget float64

	// AlertThresholds are budget percentages that trigger alerts.
	// Default: [50, 75, 90, 100].
	AlertThresholds []float64

	// OnBudgetAlert is called when a threshold is crossed.
	OnBudgetAlert func(CostSummary)

	// CustomPricing overrides or extends default pricing.
	CustomPricing map[string]ModelPricing
}

type CostEntry struct {
	Timestamp        time.Time `json:"timestamp"`
	Provider         string    `json:"provider"`
	Model            string    `json:"model"`
	PromptTokens     int       `json:"prompt_tokens"`
	CompletionTokens int       `json:"completion_tokens"`
	TotalTokens      int       `json:"total_tokens"`
	PromptCost       float64   `json:"prompt_cost"`
	CompletionCost   float64   `json:"completion_cost"`
	TotalCost        float64   `json:"total_cost"`
}

type CostSummary struct {
	// Totals
	TotalCost       float64 `json:"total_cost"`
	TotalRequests   int64   `json:"total_requests"`
	TotalTokens     int64   `json:"total_tokens"`
	MonthlyBudget   float64 `json:"monthly_budget"`
	BudgetPercent   float64 `json:"budget_percent"`
	BudgetRemaining float64 `json:"budget_remaining"`

	// Per-model breakdown
	CostByModel map[string]*ModelCostSummary `json:"cost_by_model"`

	// Per-provider breakdown
	CostByProvider map[string]*ProviderCostSummary `json:"cost_by_provider"`

	// Time-series (hourly buckets for the current day)
	HourlyCosts [24]float64 `json:"hourly_costs"`

	// Recent entries for detailed view
	RecentEntries []CostEntry `json:"recent_entries"`
}

type DatabaseMemoryOption func(*databaseMemory)

type Decision struct {
	CallID   string
	Approved bool
	// Reason is told to the model when a call is denied.
	Reason string
}

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

type Document struct {
	ID       string            `json:"id"`
	Text     string            `json:"text"`
	Vector   []float32         `json:"vector,omitempty"`
	Metadata map[string]string `json:"metadata,omitempty"`
	Score    float32           `json:"score,omitempty"` // populated on search results
}

type EmbeddingProvider interface {
	Embed(ctx context.Context, req *EmbeddingRequest) (*EmbeddingResponse, error)
}

type EmbeddingRequest struct {
	Input []string `json:"input"`
	Model string   `json:"model,omitempty"`
}

type EmbeddingResponse struct {
	Embeddings [][]float32 `json:"embeddings"`
	Model      string      `json:"model"`
	Usage      *Usage      `json:"usage,omitempty"`
}

type EvalCase struct {
	Name     string            `json:"name"`
	Prompt   string            `json:"prompt"`
	System   string            `json:"system,omitempty"`
	Options  []GenerateOption  `json:"-"`
	Checks   []EvalCheck       `json:"-"`
	Metadata map[string]string `json:"metadata,omitempty"`
}

type EvalCheck func(response string) EvalScore

type EvalReport struct {
	Suite      string        `json:"suite"`
	Model      string        `json:"model"`
	Provider   string        `json:"provider"`
	Results    []EvalResult  `json:"results"`
	TotalCases int           `json:"total_cases"`
	Passed     int           `json:"passed"`
	Failed     int           `json:"failed"`
	Errors     int           `json:"errors"`
	AvgScore   float64       `json:"avg_score"`
	AvgLatency time.Duration `json:"avg_latency"`
	TotalCost  float64       `json:"total_cost"`
	Duration   time.Duration `json:"duration"`
	Timestamp  time.Time     `json:"timestamp"`
}

type EvalResult struct {
	Case     string        `json:"case"`
	Prompt   string        `json:"prompt"`
	Response string        `json:"response"`
	Model    string        `json:"model"`
	Provider string        `json:"provider"`
	Scores   []EvalScore   `json:"scores"`
	AvgScore float64       `json:"avg_score"`
	Passed   bool          `json:"passed"`
	Latency  time.Duration `json:"latency"`
	Tokens   int           `json:"tokens"`
	Cost     float64       `json:"cost"`
	Error    string        `json:"error,omitempty"`
}

type EvalScore struct {
	Name    string  `json:"name"`
	Score   float64 `json:"score"`   // 0.0 to 1.0
	Passed  bool    `json:"passed"`  // true if score >= threshold
	Details string  `json:"details"` // human-readable explanation
}

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

type Example struct {
	Input  string
	Output string
}

type ExtractOption func(*extractConfig)

type FakeProvider struct {

	// StreamTools makes Stream report tool calls, like the OpenAI provider.
	// Without it the fake behaves like providers that do not.
	StreamTools bool
	// Repeat answers with the last response once the script runs out,
	// instead of failing with ErrFakeExhausted.
	Repeat bool
	// contains filtered or unexported fields
}

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

type GenerateOption func(*GenerateRequest)

type GenerateRequest struct {
	Messages    []Message       `json:"messages"`
	Model       string          `json:"model,omitempty"`
	MaxTokens   int             `json:"max_tokens,omitempty"`
	Temperature float32         `json:"temperature,omitempty"`
	TopP        float32         `json:"top_p,omitempty"`
	System      string          `json:"system,omitempty"`
	Tools       []ToolSpec      `json:"tools,omitempty"`
	Schema      json.RawMessage `json:"response_format,omitempty"` // JSON schema for structured output
	Stop        []string        `json:"stop,omitempty"`
	Stream      bool            `json:"stream,omitempty"`
	// Images carries attachments for the current user turn (data URIs, http(s)
	// URLs, or provider-resolvable paths). The Agent moves these onto the
	// current user Message; providers serialize them as multimodal content.
	Images []string `json:"-"`
	// Files carries documents for the current user turn (see WithFiles).
	Files []string `json:"-"`
	// Cache asks the provider to cache the stable start of the prompt
	// (system prompt, tools, conversation so far). See WithPromptCache.
	Cache bool `json:"-"`
	// Reasoning turns on thinking for reasoning models (see WithReasoning).
	Reasoning *Reasoning `json:"-"`
	// ToolChoice controls tool use: "" or "auto" (the model decides),
	// "none" (no tools), "required" (must call one), or a tool's name.
	ToolChoice string `json:"-"`
}

type GenerateResponse struct {
	Text      string     `json:"text"`
	ToolCalls []ToolCall `json:"tool_calls,omitempty"`
	// Reasoning is the model's visible thinking (Anthropic, Gemini, Ollama,
	// DeepSeek-style APIs); OpenAI's reasoning models do not return it.
	Reasoning       string           `json:"reasoning,omitempty"`
	ReasoningBlocks []ReasoningBlock `json:"reasoning_blocks,omitempty"`
	Usage           *Usage           `json:"usage,omitempty"`
	Model           string           `json:"model"`
	FinishReason    string           `json:"finish_reason,omitempty"`
	// Agent names the agent that produced the response, after handoffs
	// (empty for unnamed agents).
	Agent string `json:"agent,omitempty"`
}

type GuardrailCheck func(output string) error

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

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

type ImageData struct {
	URL     string `json:"url,omitempty"`
	B64JSON string `json:"b64_json,omitempty"`
}

type ImageProvider interface {
	GenerateImage(ctx context.Context, req *ImageRequest) (*ImageResponse, error)
}

type ImageRequest struct {
	Prompt string `json:"prompt"`
	Model  string `json:"model,omitempty"`
	N      int    `json:"n,omitempty"`
	Size   string `json:"size,omitempty"` // e.g. "1024x1024"
	Style  string `json:"style,omitempty"`
}

type ImageResponse struct {
	Images []ImageData `json:"images"`
	Model  string      `json:"model"`
}

type LegacyStreamProvider interface {
	Generate(ctx context.Context, req *GenerateRequest) (*GenerateResponse, error)
	LegacyStream(ctx context.Context, req *GenerateRequest) (<-chan string, <-chan error)
}

type LogExporter struct{}

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

type MCPOption func(*mcpConfig)

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

type Memory interface {
	// Load retrieves the conversation history for the given key.
	Load(ctx context.Context, key string) ([]Message, error)

	// Save persists the conversation history for the given key.
	Save(ctx context.Context, key string, messages []Message) error

	// Clear removes the conversation history for the given key.
	Clear(ctx context.Context, key string) error
}

type MemoryStoreOption func(*memoryStore)

type Message struct {
	Role    string   `json:"role"`
	Content string   `json:"content"`
	Images  []string `json:"images,omitempty"`
	// Files are documents (PDF, text) or images attached to a user turn:
	// paths, data: URIs or URLs. See WithFiles.
	Files      []string   `json:"files,omitempty"`
	ToolCalls  []ToolCall `json:"tool_calls,omitempty"`
	ToolCallID string     `json:"tool_call_id,omitempty"`
	// Reasoning is the model's thinking on an assistant turn, kept so it
	// can be sent back: Anthropic requires the signed thinking blocks of a
	// turn that called tools to accompany the tool results.
	Reasoning []ReasoningBlock `json:"reasoning,omitempty"`
}

type Metrics struct {
	TotalRequests   int64         `json:"total_requests"`
	TotalTokens     int64         `json:"total_tokens"`
	TotalErrors     int64         `json:"total_errors"`
	TotalLatency    time.Duration `json:"total_latency_ms"`
	RequestsByModel sync.Map      `json:"-"`
}

type ModelCostSummary struct {
	Model            string  `json:"model"`
	Requests         int64   `json:"requests"`
	PromptTokens     int64   `json:"prompt_tokens"`
	CompletionTokens int64   `json:"completion_tokens"`
	TotalCost        float64 `json:"total_cost"`
	AvgCostPerReq    float64 `json:"avg_cost_per_request"`
}

type ModelPricing struct {
	PromptPer1K     float64 `json:"prompt_per_1k"`
	CompletionPer1K float64 `json:"completion_per_1k"`
	// CacheReadPer1K and CacheWritePer1K price prompt-cache hits and
	// writes. Zero means half the prompt price for reads (OpenAI's
	// discount) and the prompt price for writes.
	CacheReadPer1K  float64 `json:"cache_read_per_1k,omitempty"`
	CacheWritePer1K float64 `json:"cache_write_per_1k,omitempty"`
}

type NamedStep struct {
	Name    string
	Handler StepHandler
}

type OTLPExporter struct {
	Endpoint string // e.g. "http://localhost:4318/v1/traces"
}

type OutputFormat struct {
	Name   string `json:"name"`
	Width  int    `json:"width"`
	Height int    `json:"height"`
	Aspect string `json:"aspect"` // e.g. "9:16"
}

type PgvectorOption func(*pgvectorStore)

type PgvectorRecord struct {
	ID       string `gorm:"primarykey;size:255"`
	Text     string `gorm:"type:text"`
	Vector   string `gorm:"type:text"` // stored as text representation of float array
	Metadata string `gorm:"type:text"` // JSON metadata
}

type PineconeOption func(*pineconeStore)

type Plugin struct {
	nimbus.BasePlugin
	// contains filtered or unexported fields
}

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

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

type Provider interface {
	// Name returns the provider identifier (e.g. "openai", "anthropic").
	Name() string

	// Generate produces a single completion.
	Generate(ctx context.Context, req *GenerateRequest) (*GenerateResponse, error)

	// Stream produces a streaming completion. If the provider does not
	// support native streaming, the default implementation calls
	// Generate and wraps the result in a single-chunk stream.
	Stream(ctx context.Context, req *GenerateRequest) (*StreamResponse, error)
}

type ProviderCostSummary struct {
	Provider  string  `json:"provider"`
	Requests  int64   `json:"requests"`
	TotalCost float64 `json:"total_cost"`
}

type ProviderFactory func(cfg *Config) (Provider, error)

type QdrantOption func(*qdrantStore)

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

type RAGResponse struct {
	Answer  string     `json:"answer"`
	Sources []Document `json:"sources"`
	Usage   *Usage     `json:"usage,omitempty"`
}

type RawToolFunc func(ctx context.Context, args json.RawMessage) (json.RawMessage, error)

type Reasoning struct {
	Effort       string
	BudgetTokens int
}

type ReasoningBlock struct {
	Text string `json:"text,omitempty"`
	// Signature verifies the block to the provider (Anthropic).
	Signature string `json:"signature,omitempty"`
	// Redacted holds encrypted thinking the provider did not show.
	Redacted string `json:"redacted,omitempty"`
}

type RedisMemoryOption func(*redisMemory)

type RequestEvent struct {
	Provider  string        `json:"provider"`
	Model     string        `json:"model"`
	Prompt    string        `json:"prompt,omitempty"`
	Messages  []Message     `json:"messages,omitempty"`
	Usage     *Usage        `json:"usage,omitempty"`
	Latency   time.Duration `json:"latency_ms"`
	Error     error         `json:"error,omitempty"`
	Timestamp time.Time     `json:"timestamp"`
}

type RequestHook func(RequestEvent)

type RerankProvider interface {
	Rerank(ctx context.Context, req *RerankRequest) ([]RerankResult, error)
}

type RerankRequest struct {
	Query     string
	Documents []string
	TopN      int
	Model     string
}

type RerankResult struct {
	Index    int // position in the documents passed in
	Document string
	Score    float64 // higher is more relevant (0–1 for Cohere)
}

type Scene struct {
	Index       int            `json:"index"`
	Prompt      string         `json:"prompt"`
	Camera      CameraMove     `json:"camera"`
	Duration    int            `json:"duration"` // seconds
	KeyframeURL string         `json:"keyframe_url,omitempty"`
	VideoURL    string         `json:"video_url,omitempty"`
	Metadata    map[string]any `json:"metadata,omitempty"`
}

type ScenePlan struct {
	OriginalPrompt string  `json:"original_prompt"`
	ExpandedPrompt string  `json:"expanded_prompt"`
	GlobalStyle    string  `json:"global_style"`
	Scenes         []Scene `json:"scenes"`
}

type Skill struct {
	Name        string
	Description string
	// contains filtered or unexported fields
}

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

type SocialPackage struct {
	Caption      string            `json:"caption"`
	Hashtags     []string          `json:"hashtags"`
	ThumbnailURL string            `json:"thumbnail_url,omitempty"`
	Formats      map[string]string `json:"formats"` // format name → video URL
}

type Span struct {
	TraceID    string            `json:"trace_id"`
	SpanID     string            `json:"span_id"`
	ParentID   string            `json:"parent_id,omitempty"`
	Name       string            `json:"name"`
	Kind       string            `json:"kind"` // "client", "internal"
	StartTime  time.Time         `json:"start_time"`
	EndTime    time.Time         `json:"end_time"`
	Duration   time.Duration     `json:"duration"`
	Status     string            `json:"status"` // "ok", "error"
	Attributes map[string]string `json:"attributes"`
	Events     []SpanEvent       `json:"events,omitempty"`
	Error      string            `json:"error,omitempty"`
}

type SpanEvent struct {
	Name       string            `json:"name"`
	Timestamp  time.Time         `json:"timestamp"`
	Attributes map[string]string `json:"attributes,omitempty"`
}

type SpanExporter interface {
	ExportSpan(ctx context.Context, span Span) error
}

type SpeakOption func(*SpeechRequest)

type Speech struct {
	Data      []byte
	MediaType string // audio/mpeg, audio/wav, …
}

type SpeechProvider interface {
	Speak(ctx context.Context, req *SpeechRequest) (*Speech, error)
}

type SpeechRequest struct {
	Text         string
	Model        string
	Voice        string
	Format       string // mp3 (default), wav, opus, aac, flac, pcm
	Speed        float64
	Instructions string // tone and delivery, for models that take it
}

type StepHandler func(wc *WorkflowContext) error

type StepResult struct {
	Name     string        `json:"name"`
	Duration time.Duration `json:"duration"`
	Error    error         `json:"error,omitempty"`
}

type StitchConfig struct {
	FadeSeconds float64 `json:"fade_seconds"`
	MusicPath   string  `json:"music_path,omitempty"`
	CaptionText string  `json:"caption_text,omitempty"`
	OutputPath  string  `json:"output_path"`
	ConcatFile  string  `json:"concat_file"` // path to write the file list
}

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

type StreamChunk struct {
	Text      string     `json:"text,omitempty"`
	ToolCalls []ToolCall `json:"tool_calls,omitempty"`
	// Reasoning carries completed thinking blocks (with signatures) so they
	// can be sent back with tool results.
	Reasoning []ReasoningBlock `json:"reasoning,omitempty"`
	Usage     *Usage           `json:"usage,omitempty"`
	Done      bool             `json:"done,omitempty"`
}

type StreamResponse struct {
	// Chunks delivers text/tool-call chunks until closed.
	Chunks <-chan StreamChunk
	// Err is buffered (cap=1). A nil send signals clean completion.
	Err <-chan error
}

type SummarizeOption func(*summarizeConfig)

type Tool struct {
	Name        string `json:"name"`
	Description string `json:"description"`

	// Run is the handler function. It must have the signature:
	//   func(ctx context.Context, input T) (U, error)
	// where T is the input struct (used to generate JSON schema)
	// and U is the output (marshaled to JSON for the model).
	Run any `json:"-"`

	// Exec is an alternative to Run for tools whose arguments are only known
	// as JSON at run time (MCP tools, agents used as tools). It receives the
	// model's raw arguments and returns raw JSON. Set Parameters with it.
	Exec RawToolFunc `json:"-"`

	// Parameters is the tool's JSON Schema. Leave it empty with Run (it is
	// generated from the input struct); set it with Exec.
	Parameters json.RawMessage `json:"-"`

	// NeedsApproval marks a tool whose calls must be approved before they
	// run (see Agent.OnApproval).
	NeedsApproval bool `json:"-"`
	// contains filtered or unexported fields
}

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

type ToolCall struct {
	ID   string          `json:"id"`
	Name string          `json:"name"`
	Args json.RawMessage `json:"arguments"`
	// Signature is a provider token that must accompany the call when it is
	// sent back (Gemini's thought signature with thinking on).
	Signature string `json:"signature,omitempty"`
}

type ToolCallStreamer interface {
	StreamsToolCalls() bool
}

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

type TraceContext struct {
	TraceID  string
	SpanID   string
	ParentID string
}

type TracingConfig struct {
	// ServiceName is the service name for the tracer (default: "nimbus-ai").
	ServiceName string

	// Enabled turns tracing on/off (default: true when EnableTracing called).
	Enabled bool

	// RecordPrompts controls whether prompt text is recorded in span
	// attributes. Disable in production for privacy (default: false).
	RecordPrompts bool

	// RecordResponses controls whether response text is recorded.
	// Disable for privacy (default: false).
	RecordResponses bool
}

type TranscribeOption func(*TranscriptionRequest)

type TranscriptSegment struct {
	Start, End float64 // seconds
	Text       string
}

type Transcription struct {
	Text     string
	Language string
	Duration float64 // seconds, when the provider reports it
	Segments []TranscriptSegment
}

type TranscriptionProvider interface {
	Transcribe(ctx context.Context, req *TranscriptionRequest) (*Transcription, error)
}

type TranscriptionRequest struct {
	Audio    Attachment
	Model    string
	Language string // ISO-639-1 hint, e.g. "en"
	Prompt   string // vocabulary or context to steer spelling
}

type Usage struct {
	// PromptTokens counts every input token, cached or not.
	PromptTokens     int `json:"prompt_tokens"`
	CompletionTokens int `json:"completion_tokens"`
	TotalTokens      int `json:"total_tokens"`
	// CacheReadTokens are input tokens served from the provider's prompt
	// cache (billed at a discount); CacheWriteTokens were written to it
	// (Anthropic bills these at a premium). Both are part of PromptTokens.
	CacheReadTokens  int `json:"cache_read_tokens,omitempty"`
	CacheWriteTokens int `json:"cache_write_tokens,omitempty"`
	// ReasoningTokens are output tokens spent thinking (part of
	// CompletionTokens), when the provider reports them.
	ReasoningTokens int `json:"reasoning_tokens,omitempty"`
}

type VectorStoreBackend interface {
	// Add stores a document with its embedding vector.
	Add(ctx context.Context, doc Document) error

	// AddBatch stores multiple documents.
	AddBatch(ctx context.Context, docs []Document) error

	// Search finds the top-k most similar documents to the query vector.
	Search(ctx context.Context, vector []float32, topK int) ([]Document, error)

	// Delete removes a document by ID.
	Delete(ctx context.Context, id string) error

	// Count returns the total number of documents.
	Count(ctx context.Context) (int, error)
}

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

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

type VideoPipelineConfig struct {
	ImageModel      string                          `json:"image_model"`
	VideoModel      string                          `json:"video_model"`
	PlannerModel    string                          `json:"planner_model"`  // LLM for scene planning
	ExpanderModel   string                          `json:"expander_model"` // LLM for prompt expansion
	GlobalStyle     string                          `json:"global_style"`
	MaxScenes       int                             `json:"max_scenes"`
	DefaultDuration int                             `json:"default_duration"` // per-scene seconds
	DraftMode       bool                            `json:"draft_mode"`       // shorter preview clips
	Format          OutputFormat                    `json:"format"`
	Parallelism     int                             `json:"parallelism"` // concurrent scene renders
	Seeds           int                             `json:"seeds"`       // keyframe seed variants
	OnScene         func(scene Scene, stage string) // progress callback
}

type VideoProject struct {
	ID             string         `json:"id"`
	Prompt         string         `json:"prompt"`
	Plan           *ScenePlan     `json:"plan"`
	Scenes         []Scene        `json:"scenes"`
	FinalVideoURL  string         `json:"final_video_url,omitempty"`
	Format         OutputFormat   `json:"format"`
	Duration       time.Duration  `json:"duration"`
	Social         *SocialPackage `json:"social,omitempty"`
	RenderDuration time.Duration  `json:"render_duration"`
}

type VideoProvider interface {
	GenerateVideo(ctx context.Context, req *VideoRequest) (*VideoResponse, error)
}

type VideoRequest struct {
	Prompt   string `json:"prompt"`
	Model    string `json:"model,omitempty"`
	ImageURL string `json:"image_url,omitempty"` // for image-to-video
	Duration int    `json:"duration,omitempty"`  // seconds
	FPS      int    `json:"fps,omitempty"`
	Size     string `json:"size,omitempty"` // e.g. "1920x1080"
}

type VideoResponse struct {
	URL      string `json:"url"`
	Model    string `json:"model"`
	Duration int    `json:"duration"`
}

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

type WorkflowContext struct {
	context.Context
	// contains filtered or unexported fields
}

type WorkflowHook func(step string, event string, wc *WorkflowContext)

type WorkflowInput map[string]any

type WorkflowResult struct {
	Data     map[string]any `json:"data"`
	Duration time.Duration  `json:"duration"`
	Steps    []StepResult   `json:"steps"`
}