# Text RLM — Jupyter notebook
from sanjaya import Agent

agent = Agent()
answer = agent.ask("What is the main argument?", context=open("paper.txt").read())
print(answer.text)

# Video RLM — Jupyter notebook
from sanjaya import Agent
from sanjaya.tools.video import VideoToolkit

agent = Agent(model="openrouter:openai/gpt-5.3-codex")
agent.use(VideoToolkit(vision_model="openrouter:openai/gpt-4.1"))

answer = agent.ask("What happens after the explosion?", video="movie.mp4")
for e in answer.evidence:
    print(f"  [{e.source}] {e.rationale}")

# Custom tools
from sanjaya import Agent, tool

@tool
def search_kb(query: str, limit: int = 10) -> list[dict]:
    """Search the knowledge base for relevant documents."""
    return my_db.search(query, limit)

agent = Agent()
agent.use(search_kb)
answer = agent.ask("What's our refund policy?", context=email_text)

class Agent:
    """RLM agent that solves problems by writing code in a sandboxed REPL."""

    def __init__(
        self,
        model: str = "openrouter:openai/gpt-5.3-codex",
        sub_model: str = "openrouter:openai/gpt-4.1-mini",
        vision_model: str | None = None,
        fallback_model: str | None = "openrouter:vikhyatk/moondream2",
        max_iterations: int = 20,
        max_budget_usd: float | None = None,
        max_timeout_s: float | None = None,
        compaction_threshold: float = 0.85,
        tracing: bool = True,
    ):
        """
        Args:
            model: Primary orchestrator model (writes REPL code).
            sub_model: Cheaper model used by llm_query() inside the REPL.
            vision_model: Model for vision_query(). Falls back to sub_model.
            fallback_model: Last-resort model if sub_model fails.
            max_iterations: Hard cap on orchestrator loop iterations.
            max_budget_usd: Stop when cumulative LLM cost exceeds this.
            max_timeout_s: Stop when wall-clock time exceeds this.
            compaction_threshold: Fraction of context window at which to
                compact message history (0.0 to disable).
            tracing: Enable logfire tracing.
        """

    def use(self, *tools_or_toolkits: "Tool | Toolkit") -> "Agent":
        """Register tools or toolkits. Chainable.

        >>> agent = Agent().use(VideoToolkit()).use(my_custom_tool)
        """

    def ask(
        self,
        question: str,
        *,
        context: Any = None,
        video: str | None = None,
        subtitle: str | None = None,
    ) -> "Answer":
        """Run the RLM loop and return a structured answer.

        Args:
            question: The question to answer.
            context: Arbitrary context data (str, list, dict). Accessible
                as `context` variable in the REPL.
            video: Path to a video file. If provided, auto-registers
                VideoToolkit (if not already registered) and makes video
                metadata available as context.
            subtitle: Path to subtitle/transcript file. Used with video.

        Returns:
            Structured Answer with text, evidence, cost, and usage.
        """

    async def ask_async(
        self,
        question: str,
        **kwargs,
    ) -> "Answer":
        """Async version of ask()."""

    @property
    def last_answer(self) -> "Answer | None":
        """Most recent answer, for notebook inspection."""

    @property
    def cost_so_far(self) -> float:
        """Cumulative USD spent across all ask() calls."""

    def reset(self) -> None:
        """Clear all state (budget, history, workspace)."""

from sanjaya import Agent
from sanjaya.tools.video import VideoToolkit

agent = Agent(
    model="openrouter:openai/gpt-5.3-codex",
    sub_model="openrouter:openai/gpt-4.1-mini",
    vision_model="openrouter:openai/gpt-4.1",
    max_iterations=15,
    max_budget_usd=2.0,
)
agent.use(VideoToolkit(workspace_dir="./my_artifacts"))

answer = agent.ask(
    "Does the defendant touch the evidence bag?",
    video="/data/deposition_clip.mp4",
)

print(answer.text)
print(f"Cost: ${answer.cost_usd:.4f}")
print(f"Iterations: {answer.iterations}")
for ev in answer.evidence:
    print(f"  [{ev.source}] {ev.rationale}")

class Evidence(BaseModel):
    """A piece of evidence supporting the answer."""
    source: str                      # e.g. "video:12.5s-45.0s", "context:chunk-3"
    rationale: str                   # why this evidence matters
    artifacts: dict[str, Any] = {}   # tool-specific: clip_path, frame_paths, etc.

class Answer(BaseModel):
    """Structured output from Agent.ask()."""
    question: str
    text: str                        # the final answer string
    evidence: list[Evidence] = []
    iterations: int                  # how many orchestrator loops ran
    cost_usd: float | None = None
    input_tokens: int | None = None
    output_tokens: int | None = None
    wall_time_s: float | None = None
    trace_id: str | None = None      # logfire trace ID for linking

from sanjaya import tool

@tool
def search_database(query: str, limit: int = 10) -> list[dict]:
    """Search the vector database for relevant documents.

    Use this when you need to find information related to a query.
    Returns a list of document dicts with 'text' and 'score' keys.

    Args:
        query: The search query string.
        limit: Maximum number of results to return.
    """
    return db.search(query, limit)

@dataclass
class Tool:
    """A callable tool available in the agent's REPL environment."""
    name: str                          # function name in REPL
    description: str                   # shown to LLM in system prompt
    fn: Callable[..., Any]             # the actual implementation
    parameters: dict[str, ToolParam]   # parsed from signature
    return_type: str                   # e.g. "list[dict]", "str"

@dataclass
class ToolParam:
    name: str
    type_hint: str       # e.g. "str", "int", "list[str]"
    default: Any         # inspect.Parameter.empty if required
    description: str     # parsed from docstring Args section

class Toolkit(ABC):
    """Bundle of related tools with shared state."""

    @abstractmethod
    def tools(self) -> list[Tool]:
        """Return all tools this toolkit provides."""

    def setup(self, context: dict[str, Any]) -> None:
        """Called once before the RLM loop starts.
        Receives the full context dict (question, video path, etc.).
        Use this to initialize shared state (workspace, transcript, etc.).
        """

    def teardown(self) -> None:
        """Called after the RLM loop ends. Cleanup resources."""

    def get_state(self) -> dict[str, Any]:
        """Return toolkit state for introspection.
        Merged into the get_state() builtin response.
        """
        return {}

    def build_evidence(self) -> list[Evidence]:
        """Convert toolkit artifacts into Evidence items for the Answer."""
        return []

    def prompt_section(self) -> str | None:
        """Optional extra prompt text injected into the system prompt.
        Use for domain-specific strategy guidance.
        """
        return None

class ToolRegistry:
    """Manages tool registration and generates prompt documentation."""

    def register(self, tool: Tool) -> None: ...
    def register_toolkit(self, toolkit: Toolkit) -> None: ...
    def get(self, name: str) -> Tool | None: ...
    def all_tools(self) -> list[Tool]: ...

    def build_external_functions(self) -> dict[str, Callable]:
        """Build the external_functions dict for MontyRepl.feed_run().
        Maps tool names to their callables.
        """

    def generate_tool_docs(self) -> str:
        """Auto-generate the tool contract section of the system prompt.

        Example output:
            Available tools in the REPL:
            - `search_transcript(query: str, top_k: int = 10) -> list[dict]`
              Search subtitle segments for relevant content.
            - `extract_clip(window_id: str = None, start_s: float = None, ...) -> dict`
              Extract a video clip from the source video.
        """

class VideoToolkit(Toolkit):
    """Complete video analysis toolkit with retrieval, media, and vision tools."""

    def __init__(
        self,
        vision_model: str | None = None,       # override agent's vision_model
        subtitle_mode: str = "auto",            # auto | local | api | none
        workspace_dir: str = "./sanjaya_artifacts",
        max_frames_per_clip: int = 8,
        window_size_s: float = 45.0,
        stride_s: float = 30.0,
        retrieval: "RetrievalBackend | None" = None,  # defaults to SQLiteFTSBackend
    ): ...

    def tools(self) -> list[Tool]:
        """Returns all 7 video tools."""

    def setup(self, context: dict[str, Any]) -> None:
        """Resolves subtitles, loads transcript, indexes segments in
        retrieval backend, creates workspace."""

    def get_state(self) -> dict[str, Any]:
        """Returns accumulated clips, windows, visited ranges, manifest."""

    def build_evidence(self) -> list[Evidence]:
        """Converts clip manifest into Evidence items."""

    def prompt_section(self) -> str:
        """Returns video-specific strategy guidance + transcript."""

# ── Information ──────────────────────────────────────────

def get_video_info() -> dict:
    """Get video metadata: duration, resolution, codec, file size.

    Call this first to understand what you're working with.
    Returns: {"duration_s": float, "width": int, "height": int,
              "codec": str, "file_size_mb": float}
    """

# ── Retrieval ────────────────────────────────────────────

def list_windows(
    question: str | None = None,
    top_k: int | None = None,
    window_size_s: float = 45.0,
) -> list[dict]:
    """Generate ranked candidate temporal windows for analysis.

    Uses the retrieval backend (SQLite FTS by default) for scoring
    subtitle segments, combined with uniform sliding windows.
    Previously-visited windows are auto-excluded (progressive scanning).
    top_k auto-scales with video duration when None.

    Args:
        question: Override question for scoring. Defaults to the original query.
        top_k: Max windows. None = auto-scale with duration.
        window_size_s: Window duration in seconds.

    Returns: [{"window_id": str, "start_s": float, "end_s": float,
               "score": float, "strategy": str, "reason": str | None}]
    """

# ── Media extraction ─────────────────────────────────────

def extract_clip(
    *,
    window_id: str | None = None,
    start_s: float | None = None,
    end_s: float | None = None,
) -> dict:
    """Extract a video clip from the source video.

    Provide either a window_id (from list_windows) or explicit timestamps.
    The extracted clip is saved to the workspace.

    Returns: {"clip_id": str, "clip_path": str, "start_s": float, "end_s": float}
    """

def sample_frames(
    *,
    clip_id: str | None = None,
    clip_path: str | None = None,
    max_frames: int = 8,
) -> list[str]:
    """Sample uniformly-spaced frames from an extracted clip.

    Args:
        clip_id: ID from extract_clip().
        clip_path: Direct path (alternative to clip_id).
        max_frames: Number of frames to extract.

    Returns: List of JPEG frame file paths.
    """

# ── Vision ───────────────────────────────────────────────

def vision_query(
    *,
    prompt: str | None = None,
    clip_id: str | None = None,
    frame_paths: list[str] | None = None,
) -> str:
    """Query a vision model about video frames or a clip.

    Sends frames (preferred) or a clip to a multimodal LLM.
    If no prompt given, uses the original question.

    Args:
        prompt: What to ask about the visual content.
        clip_id: ID from extract_clip() (will use its frames).
        frame_paths: Direct frame paths (alternative to clip_id).

    Returns: Vision model's text response.
    """

def vision_query_batched(
    queries: list[dict],
) -> list[str]:
    """Run multiple vision queries concurrently.

    Much faster than sequential vision_query() calls for independent
    analyses of different clips.

    Args:
        queries: List of dicts, each with keys matching vision_query params:
            [{"prompt": "...", "clip_id": "..."}, ...]

    Returns: List of responses in the same order as input queries.
    """

# ── State ────────────────────────────────────────────────

def get_state() -> dict:
    """Inspect accumulated analysis state and workspace manifest.

    Returns: {"clips_extracted": int, "windows_visited": int,
              "visited_ranges": [...], "total_coverage_s": float,
              "clips": {...}, "candidate_windows": [...],
              "run_id": str}
    """

class RetrievalBackend(ABC):
    """Pluggable retrieval backend for semantic/keyword search."""

    @abstractmethod
    def index(
        self,
        documents: list[str],
        metadata: list[dict[str, Any]] | None = None,
        collection: str = "default",
    ) -> None:
        """Index documents. Metadata is stored alongside for filtering."""

    @abstractmethod
    def search(
        self,
        query: str,
        *,
        top_k: int = 10,
        collection: str = "default",
        filter_condition: str | None = None,
    ) -> list[dict[str, Any]]:
        """Search indexed documents.

        Returns: [{"text": str, "score": float, "metadata": dict, "doc_id": int}]
        """

    @abstractmethod
    def delete(
        self,
        *,
        collection: str = "default",
        condition: str | None = None,
    ) -> int:
        """Delete documents. Returns count deleted."""


class SQLiteFTSBackend(RetrievalBackend):
    """SQLite FTS5 full-text search. Default backend.

    - Zero external dependencies (sqlite3 is stdlib)
    - Indexing: <100ms for a video's worth of subtitle segments
    - Persists to disk — cross-run memory out of the box
    - BM25 ranking built into FTS5
    """

    def __init__(self, path: str = ".sanjaya/retrieval.db"):
        """
        Args:
            path: Path to SQLite database file. Created if it doesn't exist.
                  Use ":memory:" for ephemeral (single-run) usage.
        """

    def index(self, documents, metadata=None, collection="default"):
        """INSERT into FTS5 virtual table. <100ms for hundreds of segments."""

    def search(self, query, *, top_k=10, collection="default", filter_condition=None):
        """FTS5 MATCH with BM25 ranking. <10ms per query."""

    def delete(self, *, collection="default", condition=None):
        """DELETE with optional WHERE clause on metadata."""

    def collections(self) -> list[str]:
        """List all indexed collections."""

    def count(self, collection: str = "default") -> int:
        """Count documents in a collection."""

# VideoToolkit.setup() indexes subtitle segments
backend.index(
    documents=[seg.text for seg in subtitle_segments],
    metadata=[{"start_s": seg.start_s, "end_s": seg.end_s, "idx": i}
              for i, seg in enumerate(subtitle_segments)],
    collection="transcripts",
)

# list_windows() queries it for scoring
hits = backend.search(question, top_k=top_k * 2, collection="transcripts")

# ReportToolkit.save_note() indexes saved content
backend.index(
    documents=[content],
    metadata=[{"filename": filename, "run_id": run_id, "timestamp": time.time()}],
    collection="reports",
)

class ReportToolkit(Toolkit):
    """Save analysis outputs and build cross-run memory."""

    def __init__(
        self,
        output_dir: str = "./sanjaya_reports",
        retrieval: RetrievalBackend | None = None,
    ):
        """
        Args:
            output_dir: Directory for saved files.
            retrieval: If provided, saved content is auto-indexed
                in the "reports" collection for cross-run search.
        """

    def tools(self) -> list[Tool]:
        """Returns 3 report tools."""

def save_note(content: str, filename: str) -> str:
    """Save a markdown/text note to the reports directory.

    Content is also indexed in the retrieval backend (if configured)
    so future runs can find it via semantic_search.

    Args:
        content: The text content to save.
        filename: Filename (e.g., "analysis.md", "findings.txt").

    Returns: Absolute path to the saved file.
    """

def save_qmd(content: str, filename: str) -> str:
    """Save a Quarto markdown document to the reports directory.

    Use this for structured reports with YAML frontmatter.
    Auto-indexed for cross-run retrieval.

    Args:
        content: Full QMD content including frontmatter.
        filename: Filename (e.g., "report.qmd").

    Returns: Absolute path to the saved file.
    """

def save_data(data: Any, filename: str) -> str:
    """Save structured data (JSON, CSV) to the reports directory.

    Args:
        data: Dict/list for JSON, or list[list] for CSV.
        filename: Filename with extension (e.g., "results.json", "data.csv").

    Returns: Absolute path to the saved file.
    """

# core/errors.py

MONTY_HINTS: dict[type, str] = {
    ModuleNotFoundError: (
        "This module is not available in the sandboxed REPL. "
        "Use the provided tools for external operations: "
        "get_video_info() for metadata, extract_clip() for media, "
        "save_note() for file output, llm_query() for LLM calls."
    ),
    FileNotFoundError: (
        "Direct file access is not available. Use the provided tools: "
        "get_video_info(), extract_clip(), sample_frames(), save_note()."
    ),
    PermissionError: (
        "The REPL is sandboxed. Use save_note() or save_data() to write files."
    ),
}

def format_error_with_hints(exc: Exception, registry: ToolRegistry) -> str:
    """Format an error with Monty-specific recovery hints.

    Includes: the error message, a hint based on error type,
    and a list of available tools that might help.
    """

# core/patterns.py

class PatternMemory:
    """Learn what code works/fails in the REPL across runs.

    Stores patterns in a SQLite database alongside the retrieval backend.
    Successful patterns are injected into the system prompt as worked examples.
    Failed patterns are injected as warnings.
    """

    def __init__(self, path: str = ".sanjaya/patterns.db"): ...

    def record_success(
        self,
        code: str,
        tools_used: list[str],
        description: str | None = None,
    ) -> None:
        """Record a code block that executed successfully."""

    def record_failure(
        self,
        code: str,
        error_type: str,
        error_message: str,
    ) -> None:
        """Record a code block that failed."""

    def get_examples(
        self,
        tools: list[str],
        limit: int = 3,
    ) -> list[dict]:
        """Get proven code examples relevant to the registered tools.

        Returns: [{"code": str, "description": str, "tools_used": [...]}]
        Used by build_system_prompt() to inject worked examples.
        """

    def get_anti_patterns(self, limit: int = 5) -> list[dict]:
        """Get common failure patterns to warn about.

        Returns: [{"code_snippet": str, "error": str, "hint": str}]
        """

# In core/loop.py run_loop():
for code_block in code_blocks:
    result = repl.execute(code_block)
    if result.stderr:
        # Format with hints
        feedback = format_error_with_hints(result.error, registry)
        # Record failure for future runs
        pattern_memory.record_failure(code_block, type(result.error).__name__, str(result.error))
    else:
        # Record success for future runs
        tools_used = [t for t in registry.all_tools() if t.name in code_block]
        pattern_memory.record_success(code_block, [t.name for t in tools_used])

# In core/prompts.py build_system_prompt():
examples = pattern_memory.get_examples(tools=[t.name for t in registry.all_tools()])
anti_patterns = pattern_memory.get_anti_patterns()

# Inject into prompt:
# "Here are proven code patterns that work in this REPL:"
# "WARNING: These patterns are known to fail in this REPL:"

class AgentREPL:
    """Sandboxed Python REPL with dynamic tool injection."""

    def __init__(
        self,
        registry: ToolRegistry,
        context: Any = None,
        os_access: OSAccess | None = None,
    ):
        self.monty = MontyRepl()
        self.registry = registry
        self.context = context
        self._os_access = os_access

    def execute(
        self,
        code: str,
        *,
        iteration: int | None = None,
        block_index: int | None = None,
        block_total: int | None = None,
    ) -> ExecutionResult:
        """Execute a code block in the sandbox.

        Injects all registered tools + builtins (context, llm_query,
        llm_query_batched, done, get_state) as external_functions.
        """

    def set_context(self, context: Any) -> None:
        """Update the context variable."""

    def set_os_access(self, os_access: OSAccess | None) -> None:
        """Update the Monty filesystem mount."""

@dataclass
class LoopConfig:
    max_iterations: int = 20
    max_budget_usd: float | None = None
    max_timeout_s: float | None = None
    compaction_threshold: float = 0.85
    force_all_iterations: bool = False

@dataclass
class LoopResult:
    raw_answer: Any              # whatever done() received
    iterations_used: int
    messages: list[dict]         # full message history
    budget: BudgetTracker
    wall_time_s: float


def run_loop(
    *,
    orchestrator: LLMClient,
    repl: AgentREPL,
    system_prompt: str,
    question: str,
    config: LoopConfig,
    budget: BudgetTracker,
    tracer: Tracer,
) -> LoopResult:
    """The RLM iteration loop.

    1. Build initial messages [system, user]
    2. For each iteration:
       a. Check budget/timeout
       b. Call orchestrator LLM
       c. Extract code blocks
       d. Execute each block in REPL
       e. Format feedback, append to messages
       f. Check for done() signal
       g. If approaching context limit, compact history
    3. If max iterations reached, force final answer
    4. Return LoopResult
    """

def compact_history(
    *,
    messages: list[dict[str, str]],
    llm: LLMClient,
    system_prompt: str,
    threshold_pct: float = 0.85,
    model_context_limit: int = 200_000,
) -> list[dict[str, str]]:
    """Summarize message history when approaching context limit.

    Asks the LLM to summarize progress in 1-3 paragraphs,
    preserving key intermediate results. Replaces history with
    [system_prompt, summary, "continue from summary"].

    Returns the new (shorter) message list, or the original
    if under threshold.
    """

class BudgetTracker:
    """Tracks cumulative cost and tokens across the run."""

    def __init__(
        self,
        max_budget_usd: float | None = None,
        max_timeout_s: float | None = None,
    ): ...

    def record(
        self,
        input_tokens: int = 0,
        output_tokens: int = 0,
        cost_usd: float = 0.0,
        model: str | None = None,
    ) -> None: ...

    @property
    def total_cost_usd(self) -> float: ...

    @property
    def total_input_tokens(self) -> int: ...

    @property
    def total_output_tokens(self) -> int: ...

    @property
    def elapsed_s(self) -> float: ...

    @property
    def budget_exceeded(self) -> bool: ...

    @property
    def timeout_exceeded(self) -> bool: ...

    def should_stop(self) -> bool:
        """True if any limit is exceeded."""

def build_system_prompt(
    *,
    registry: ToolRegistry,
    context_metadata: dict[str, Any] | None = None,
    toolkit_sections: list[str] | None = None,
) -> str:
    """Build the full system prompt.

    Structure:
    1. Core RLM instructions (you have a REPL, use it to solve problems)
    2. Built-in functions (context, llm_query, llm_query_batched, done, get_state)
    3. Auto-generated tool docs (from registry)
    4. Toolkit-specific strategy sections (e.g., video analysis workflow)
    5. Context metadata (type, size, chunk lengths)
    6. Examples and guardrails
    """

def extract_code_blocks(response: str) -> list[str]:
    """Extract ```python or ```repl code blocks from LLM response."""

def format_execution_feedback(result: ExecutionResult, block_index: int) -> str:
    """Format REPL output as a user message for the next iteration."""

def extract_final_answer(result: ExecutionResult, response: str) -> Any | None:
    """Check for done() signal, FINAL(...), or 'final answer:' in response."""

class LLMClient:
    """Unified LLM client with text, vision, and batched support."""

    def __init__(
        self,
        model: str,
        vision_model: str | None = None,
        fallback_model: str | None = None,
    ): ...

    def completion(self, prompt: str | list[dict], timeout: int = 300) -> str:
        """Single text completion."""

    def vision_completion(
        self,
        *,
        prompt: str,
        frame_paths: list[str] | None = None,
        clip_paths: list[str] | None = None,
        timeout: int = 300,
    ) -> str:
        """Single vision completion with image/video attachments."""

    def completion_batched(
        self,
        prompts: list[str],
        timeout: int = 300,
    ) -> list[str]:
        """Concurrent text completions via asyncio.gather.
        Returns responses in same order as input prompts.
        """

    def vision_completion_batched(
        self,
        queries: list[dict],
        timeout: int = 300,
    ) -> list[str]:
        """Concurrent vision completions.
        Each query dict has keys: prompt, frame_paths, clip_paths.
        """

    @property
    def last_usage(self) -> UsageSnapshot | None: ...

    @property
    def last_cost_usd(self) -> float | None: ...

class Tracer:
    """Unified tracer for logfire spans + in-memory SSE events."""

    def __init__(self, track_events: bool = False): ...

    # ── Generic spans (replace all 28 duplicated methods) ──

    @contextmanager
    def completion(self, *, question: str, model: str, **kwargs) -> TraceContext:
        """Top-level agent.ask() span."""

    @contextmanager
    def iteration(self, *, iteration: int, **kwargs) -> TraceContext:
        """One orchestrator loop iteration."""

    @contextmanager
    def orchestrator_call(self, *, model: str, **kwargs) -> TraceContext:
        """Orchestrator LLM call."""

    @contextmanager
    def code_execution(self, *, code: str, **kwargs) -> TraceContext:
        """REPL code block execution."""

    @contextmanager
    def tool_call(self, *, tool_name: str, **kwargs) -> TraceContext:
        """Any tool invocation (generic — works for video, custom, etc.)."""

    @contextmanager
    def llm_call(self, *, model: str, prompt: str, **kwargs) -> TraceContext:
        """Sub-LLM call (llm_query, vision_query, etc.)."""

    # ── Events (for SSE) ──

    @property
    def events(self) -> list[dict]:
        """All emitted events, for SSE polling."""

    def emit(self, kind: str, **payload) -> None:
        """Emit a named event."""

[project]
name = "sanjaya"
version = "0.2.0"
description = "Extensible RLM agent framework with video understanding"
requires-python = ">=3.12"
dependencies = [
    "pydantic>=2.0",
    "pydantic-ai>=0.2.0",
    "pydantic-monty>=0.0.9",
    "pydantic-settings>=2.0",
    "python-dotenv>=1.0",
    "rich>=14.0",
    "genai-prices>=0.0.56",
]

[project.optional-dependencies]
video = ["logfire"]  # ffmpeg/ffprobe must be on PATH
tracing = ["logfire"]
all = ["sanjaya[video,tracing]"]

# api/sanjaya_api/services/orchestrator.py (new version)
from sanjaya import Agent
from sanjaya.tools.video import VideoToolkit
from sanjaya.tracing import Tracer

def _run_completion(record: RunRecord, request: RunRequest):
    tracer = Tracer(track_events=True)
    record.tracer = tracer

    agent = Agent(
        model="openrouter:openai/gpt-5.3-codex",
        max_iterations=request.max_iterations,
        tracing=True,
    )
    agent.use(VideoToolkit(subtitle_mode=request.subtitle_mode))
    # Inject the tracer (agent accepts external tracer for SSE use case)
    agent._tracer = tracer

    record.answer = agent.ask(
        request.question,
        video=request.video_path,
        subtitle=request.subtitle_path,
    )
    record.status = "complete"