minima-cli 0.4.9__py3-none-any.whl

minima_harness/ai/providers/google.py

@@ -0,0 +1,221 @@
+"""Google Generative AI (Gemini) provider via ``google-genai``.
+
+Reuses minima's optional ``reasoner-gemini`` / ``harness`` extra. Iterates
+``generate_content_stream`` chunks, mapping incremental text/thought/function-call parts
+onto PI's event taxonomy. Gemini does not stream function-call arguments incrementally,
+so a full ``toolcall_end`` is emitted when a ``function_call`` part arrives (matches PI's
+documented behaviour).
+"""
+
+from __future__ import annotations
+
+from collections.abc import AsyncIterator
+from typing import TYPE_CHECKING, Any
+
+from minima_harness.ai.compat import normalize_for_target
+from minima_harness.ai.events import (
+    DoneEvent,
+    ErrorEvent,
+    StartEvent,
+    TextDeltaEvent,
+    TextEndEvent,
+    TextStartEvent,
+    ThinkingDeltaEvent,
+    ThinkingEndEvent,
+    ThinkingStartEvent,
+    ToolCall,
+    ToolCallEndEvent,
+    ToolCallStartEvent,
+)
+from minima_harness.ai.providers._common import resolve_api_key, to_json_schema
+from minima_harness.ai.types import (
+    AssistantMessage,
+    ImageContent,
+    Message,
+    TextContent,
+    ThinkingContent,
+)
+from minima_harness.ai.usage import attach_cost
+
+if TYPE_CHECKING:
+    from minima_harness.ai.events import Event
+    from minima_harness.ai.types import Context, Model
+
+_FINISH_MAP = {"STOP": "stop", "MAX_TOKENS": "length", "SAFETY": "stop"}
+
+
+class GoogleProvider:
+    api_id = "google-generative-ai"
+
+    def __init__(self, client: Any | None = None) -> None:
+        self._client = client
+
+    def _build_client(self, options: dict[str, Any]) -> Any:
+        if self._client is not None:
+            return self._client
+        import google.genai as genai  # lazy; optional extra
+
+        api_key = resolve_api_key(
+            options, "GEMINI_API_KEY", "GOOGLE_API_KEY", "GOOGLE_GENAI_API_KEY"
+        )
+        timeout = int(float(options.get("timeout", 60.0)) * 1000)
+        return genai.Client(api_key=api_key, http_options={"timeout": timeout})
+
+    async def stream(
+        self,
+        model: Model,
+        context: Context,
+        *,
+        options: dict[str, Any] | None = None,
+        signal: object | None = None,
+    ) -> AsyncIterator[Event]:
+        options = options or {}
+        client = self._build_client(options)
+        config = _build_config(model, context, options)
+
+        text_buf: list[str] = []
+        think_buf: list[str] = []
+        tool_calls: list[ToolCall] = []
+        seen_text = seen_think = False
+        in_tokens = out_tokens = thought_tokens = cache_read = 0
+        stop_reason = "stop"
+
+        assistant = AssistantMessage(content=[], model=model.id, stop_reason="stop")
+        yield StartEvent(partial=assistant)
+        try:
+            contents = _to_contents(context)
+            stream = await client.aio.models.generate_content_stream(
+                model=model.id, contents=contents, config=config
+            )
+            async for chunk in stream:
+                usage = getattr(chunk, "usage_metadata", None)
+                if usage is not None:
+                    in_tokens = getattr(usage, "prompt_token_count", 0) or 0
+                    out_tokens = getattr(usage, "candidates_token_count", 0) or 0
+                    thought_tokens = getattr(usage, "thoughts_token_count", 0) or 0
+                    cache_read = getattr(usage, "cached_content_token_count", 0) or 0
+                for cand in getattr(chunk, "candidates", None) or []:
+                    fr = getattr(cand, "finish_reason", None)
+                    if fr:
+                        stop_reason = _FINISH_MAP.get(str(fr), "stop")
+                    content = getattr(cand, "content", None)
+                    for part in getattr(content, "parts", None) or []:
+                        if getattr(part, "thought", False):
+                            txt = getattr(part, "text", "") or ""
+                            if txt:
+                                if not seen_think:
+                                    seen_think = True
+                                    yield ThinkingStartEvent(content_index=0)
+                                think_buf.append(txt)
+                                yield ThinkingDeltaEvent(delta=txt, content_index=0)
+                        elif getattr(part, "function_call", None):
+                            fc = part.function_call
+                            name = getattr(fc, "name", "") or ""
+                            args = dict(getattr(fc, "args", None) or {})
+                            call = ToolCall(id=f"call_{len(tool_calls)}", name=name, arguments=args)
+                            tool_calls.append(call)
+                            idx = len(tool_calls) - 1
+                            yield ToolCallStartEvent(content_index=idx)
+                            yield ToolCallEndEvent(tool_call=call, content_index=idx)
+                        else:
+                            txt = getattr(part, "text", None)
+                            if txt:
+                                if not seen_text:
+                                    seen_text = True
+                                    yield TextStartEvent(content_index=0)
+                                text_buf.append(txt)
+                                yield TextDeltaEvent(delta=txt, content_index=0)
+        except Exception as exc:  # noqa: BLE001
+            err = AssistantMessage(
+                content=[TextContent(text="")], stop_reason="error", error_message=str(exc)
+            )
+            err.model = model.id
+            yield ErrorEvent(reason="error", error=err)
+            return
+
+        # Assemble content in canonical order: thinking, text, tool calls.
+        blocks: list[Any] = []
+        if seen_think:
+            thinking = "".join(think_buf)
+            blocks.append(ThinkingContent(thinking=thinking))
+            yield ThinkingEndEvent(content=thinking, content_index=0)
+        if seen_text:
+            text = "".join(text_buf)
+            blocks.append(TextContent(text=text))
+            yield TextEndEvent(content=text, content_index=0)
+        blocks.extend(tool_calls)
+        if not blocks:
+            blocks.append(TextContent(text=""))
+
+        if tool_calls:
+            stop_reason = "toolUse"
+        assistant.content = blocks
+        assistant.stop_reason = stop_reason  # type: ignore[assignment]
+        assistant.usage.input = in_tokens
+        assistant.usage.output = out_tokens + thought_tokens
+        assistant.usage.cache_read = cache_read
+        attach_cost(model, assistant.usage)
+        yield DoneEvent(reason=assistant.stop_reason, message=assistant)
+
+
+def _build_config(model: Model, context: Context, options: dict[str, Any]) -> dict[str, Any]:
+    config: dict[str, Any] = {"max_output_tokens": options.get("max_tokens", model.max_tokens)}
+    if context.system_prompt:
+        config["system_instruction"] = context.system_prompt
+    if context.tools:
+        config["tools"] = [
+            {
+                "function_declarations": [
+                    {
+                        "name": t.name,
+                        "description": t.description,
+                        # Use `parameters_json_schema` (standard JSON Schema), NOT `parameters`
+                        # (the SDK's strict Schema model). The strict model rejects `$ref`/`$defs`
+                        # — which pydantic emits for any tool with a nested model (e.g. the
+                        # `tasks` tool's TaskItem) — with a pydantic ValidationError, breaking the
+                        # whole call. The json_schema path lets google-genai inline/convert refs
+                        # itself, per Gemini's function-declaration rules.
+                        "parameters_json_schema": to_json_schema(t.parameters),
+                    }
+                    for t in context.tools
+                ]
+            }
+        ]
+    if options.get("thinking") and model.reasoning:
+        config["thinking_config"] = {"include_thoughts": True}
+    return config
+
+
+def _to_contents(context: Context) -> list[dict[str, Any]]:
+    """Build google-genai ``contents`` (role user/model + parts) from the context."""
+    messages = normalize_for_target(context.messages, "google-generative-ai")
+    out: list[dict[str, Any]] = []
+    for m in messages:
+        role = "model" if m.role == "assistant" else "user"
+        parts: list[dict[str, Any]] = []
+        if m.role == "toolResult":
+            parts.append(
+                {
+                    "function_response": {
+                        "name": m.tool_name or "",
+                        "response": {"result": _flatten_text(m)},
+                    }
+                }
+            )
+        else:
+            blocks = m.content if not isinstance(m.content, str) else [TextContent(text=m.content)]
+            for b in blocks:
+                if isinstance(b, TextContent):
+                    parts.append({"text": b.text})
+                elif isinstance(b, ImageContent):
+                    parts.append({"inline_data": {"mime_type": b.mime_type, "data": b.data}})
+                elif isinstance(b, ToolCall):
+                    parts.append({"function_call": {"name": b.name, "args": b.arguments or {}}})
+        out.append({"role": role, "parts": parts})
+    return out
+
+
+def _flatten_text(m: Message) -> str:
+    if isinstance(m.content, str):
+        return m.content
+    return "".join(b.text for b in m.content if isinstance(b, TextContent))

minima_harness/ai/providers/openai_compat.py

@@ -0,0 +1,278 @@
+"""OpenAI-compatible Chat Completions provider (raw httpx, no ``openai`` SDK).
+
+One implementation covers openai, openrouter, groq, xai, together, and any server
+speaking the ``POST {base_url}/chat/completions`` SSE protocol — selected by
+``Model.base_url``. Matches PI's fetch-based approach and keeps dependencies lean.
+
+Streaming deltas carry: ``choices[0].delta.content`` (text), ``.tool_calls`` (function
+calls, assembled from partial JSON), and ``.reasoning_content`` / ``.reasoning`` (thinking
+for deepseek/openrouter-style models). The final chunk carries ``usage`` when
+``stream_options.include_usage`` is honoured.
+"""
+
+from __future__ import annotations
+
+import json
+from collections.abc import AsyncIterator
+from typing import TYPE_CHECKING, Any
+
+import httpx
+
+from minima_harness.ai.compat import normalize_for_target
+from minima_harness.ai.events import (
+    DoneEvent,
+    ErrorEvent,
+    StartEvent,
+    TextDeltaEvent,
+    TextEndEvent,
+    TextStartEvent,
+    ThinkingDeltaEvent,
+    ThinkingEndEvent,
+    ThinkingStartEvent,
+    ToolCallDeltaEvent,
+    ToolCallEndEvent,
+    ToolCallStartEvent,
+)
+from minima_harness.ai.provider_quirks import quirks_for
+from minima_harness.ai.providers._common import resolve_api_key, to_json_schema
+from minima_harness.ai.types import (
+    AssistantMessage,
+    ImageContent,
+    Message,
+    TextContent,
+    ThinkingContent,
+    ToolCall,
+)
+from minima_harness.ai.usage import attach_cost
+
+if TYPE_CHECKING:
+    from minima_harness.ai.events import Event
+    from minima_harness.ai.types import Context, Model
+
+_DEFAULT_BASE = "https://api.openai.com/v1"
+_FINISH_MAP = {
+    "stop": "stop",
+    "length": "length",
+    "tool_calls": "toolUse",
+    "function_call": "toolUse",
+}
+
+
+class OpenAICompatProvider:
+    api_id = "openai-completions"
+
+    async def stream(
+        self,
+        model: Model,
+        context: Context,
+        *,
+        options: dict[str, Any] | None = None,
+        signal: object | None = None,
+    ) -> AsyncIterator[Event]:
+        options = options or {}
+        # Resolve the key for THIS model's provider (e.g. a Groq model -> GROQ_API_KEY), so a
+        # key for one provider can't be sent to another provider's endpoint. Unknown/custom
+        # providers fall back to the generic OpenAI-compat vars via env_vars_for_provider.
+        from minima_harness.ai.provider_catalog import env_vars_for_provider
+
+        api_key = resolve_api_key(options, *env_vars_for_provider(model.provider))
+        base = (model.base_url or _DEFAULT_BASE).rstrip("/")
+        url = f"{base}/chat/completions"
+        payload = _build_payload(model, context, options)
+        headers: dict[str, str] = {"Content-Type": "application/json"}
+        if api_key:
+            headers["Authorization"] = f"Bearer {api_key}"
+        headers.update(model.headers)
+
+        timeout = options.get("timeout", 60.0)
+        try:
+            client = options.get("httpx_client") or httpx.AsyncClient(timeout=timeout)
+            req = client.build_request("POST", url, json=payload, headers=headers)
+            resp = await client.send(req, stream=True)
+            try:
+                resp.raise_for_status()
+                async for ev in _consume_sse(resp, model):
+                    yield ev
+            finally:
+                await resp.aclose()
+                if not options.get("httpx_client"):
+                    await client.aclose()
+        except Exception as exc:  # noqa: BLE001 - surface as an error event, not a raise
+            err = AssistantMessage(
+                content=[TextContent(text="")], stop_reason="error", error_message=str(exc)
+            )
+            err.model = model.id
+            yield ErrorEvent(reason="error", error=err)
+
+
+def _build_payload(model: Model, context: Context, options: dict[str, Any]) -> dict[str, Any]:
+    messages = normalize_for_target(context.messages, "openai-completions")
+    out: list[dict[str, Any]] = []
+    if context.system_prompt:
+        out.append({"role": "system", "content": context.system_prompt})
+    out.extend(_to_wire(m) for m in messages)
+    payload: dict[str, Any] = {
+        "model": model.id,
+        "messages": out,
+        "stream": True,
+        "stream_options": {"include_usage": True},
+        # Per-provider request quirks (e.g. OpenAI GPT-5 needs max_completion_tokens) come from
+        # the quirks table, not a growing chain of `if model.provider == ...` branches here.
+        quirks_for(model.provider).token_param: options.get("max_tokens", model.max_tokens),
+    }
+    if context.tools:
+        payload["tools"] = [
+            {
+                "type": "function",
+                "function": {
+                    "name": t.name,
+                    "description": t.description,
+                    "parameters": to_json_schema(t.parameters),
+                },
+            }
+            for t in context.tools
+        ]
+    return payload
+
+
+def _to_wire(m: Message) -> dict[str, Any]:
+    if m.role == "toolResult":
+        return {
+            "role": "tool",
+            "tool_call_id": m.tool_call_id,
+            "content": _flatten_text(m),
+        }
+    blocks = m.content if not isinstance(m.content, str) else [TextContent(text=m.content)]
+    tool_calls = [b for b in blocks if isinstance(b, ToolCall)]
+    entry: dict[str, Any] = {"role": m.role}
+    text = "".join(b.text for b in blocks if isinstance(b, TextContent))
+    images = [b for b in blocks if isinstance(b, ImageContent)]
+    parts: list[dict[str, Any]] = []
+    if text:
+        parts.append({"type": "text", "text": text})
+    for img in images:
+        parts.append(
+            {"type": "image_url", "image_url": {"url": f"data:{img.mime_type};base64,{img.data}"}}
+        )
+    if parts:
+        entry["content"] = parts if images else text
+    else:
+        entry["content"] = text
+    if tool_calls:
+        entry["tool_calls"] = [
+            {
+                "id": tc.id,
+                "type": "function",
+                "function": {"name": tc.name, "arguments": json.dumps(tc.arguments)},
+            }
+            for tc in tool_calls
+        ]
+    return entry
+
+
+def _flatten_text(m: Message) -> str:
+    if isinstance(m.content, str):
+        return m.content
+    return "".join(b.text for b in m.content if isinstance(b, TextContent))
+
+
+async def _consume_sse(resp: httpx.Response, model: Model) -> AsyncIterator[Event]:
+    text_buf: dict[int, list[str]] = {}
+    think_buf: dict[int, list[str]] = {}
+    # tool index -> {id, name, args_parts}
+    tools: dict[int, dict[str, str]] = {}
+    seen_text = seen_think = False
+    finish_reason = "stop"
+    usage_input = usage_output = 0
+    assistant = AssistantMessage(content=[], model=model.id, stop_reason="stop")
+    yield StartEvent(partial=assistant)
+
+    async for line in resp.aiter_lines():
+        line = line.strip()
+        if not line or not line.startswith("data:"):
+            continue
+        data = line[5:].strip()
+        if data == "[DONE]":
+            break
+        try:
+            chunk = json.loads(data)
+        except json.JSONDecodeError:
+            continue
+        if chunk.get("usage"):
+            usage_input = chunk["usage"].get("prompt_tokens", usage_input)
+            usage_output = chunk["usage"].get("completion_tokens", usage_output)
+        choices = chunk.get("choices") or []
+        if not choices:
+            continue
+        choice = choices[0]
+        delta = choice.get("delta") or {}
+        fr = choice.get("finish_reason")
+        if fr:
+            finish_reason = _FINISH_MAP.get(fr, "stop")
+
+        if "reasoning_content" in delta and delta["reasoning_content"]:
+            idx = 0
+            think_buf.setdefault(idx, []).append(delta["reasoning_content"])
+            if not seen_think:
+                seen_think = True
+                yield ThinkingStartEvent(content_index=idx)
+            yield ThinkingDeltaEvent(delta=delta["reasoning_content"], content_index=idx)
+        if delta.get("reasoning"):
+            idx = 0
+            think_buf.setdefault(idx, []).append(delta["reasoning"])
+            if not seen_think:
+                seen_think = True
+                yield ThinkingStartEvent(content_index=idx)
+            yield ThinkingDeltaEvent(delta=delta["reasoning"], content_index=idx)
+
+        content = delta.get("content")
+        if content:
+            idx = 0
+            text_buf.setdefault(idx, []).append(content)
+            if not seen_text:
+                seen_text = True
+                yield TextStartEvent(content_index=idx)
+            yield TextDeltaEvent(delta=content, content_index=idx)
+
+        for tc in delta.get("tool_calls") or []:
+            idx = tc.get("index", 0)
+            slot = tools.setdefault(idx, {"id": "", "name": "", "args": ""})
+            fn = tc.get("function") or {}
+            if tc.get("id") and not slot["id"]:
+                slot["id"] = tc["id"]
+            if fn.get("name") and not slot["name"]:
+                slot["name"] = fn["name"]
+            if fn.get("arguments"):
+                slot["args"] += fn["arguments"]
+                yield ToolCallDeltaEvent(delta=fn["arguments"], content_index=idx)
+
+    # finalize blocks in stable index order: thinking(0) -> text(0) -> tools
+    if seen_think:
+        idx = 0
+        thinking = "".join(think_buf.get(idx, []))
+        assistant.content.append(ThinkingContent(thinking=thinking))
+        yield ThinkingEndEvent(content=thinking, content_index=idx)
+    if seen_text:
+        idx = 0
+        text = "".join(text_buf.get(idx, []))
+        assistant.content.append(TextContent(text=text))
+        yield TextEndEvent(content=text, content_index=idx)
+    for idx in sorted(tools):
+        slot = tools[idx]
+        raw_args = slot["args"] or "{}"
+        try:
+            args = json.loads(raw_args) if raw_args.strip() else {}
+        except json.JSONDecodeError:
+            args = {"_raw": raw_args}
+        call = ToolCall(id=slot["id"] or f"call_{idx}", name=slot["name"], arguments=args)
+        assistant.content.append(call)
+        yield ToolCallStartEvent(content_index=idx)
+        yield ToolCallEndEvent(tool_call=call, content_index=idx)
+
+    assistant.stop_reason = finish_reason  # type: ignore[assignment]
+    if not assistant.content:
+        assistant.content.append(TextContent(text=""))
+    assistant.usage.input = usage_input
+    assistant.usage.output = usage_output
+    attach_cost(model, assistant.usage)
+    yield DoneEvent(reason=assistant.stop_reason, message=assistant)

minima_harness/ai/registry.py

@@ -0,0 +1,184 @@
+"""Model registry: ``get_model(provider, id)`` and discovery helpers.
+
+The seed table covers the candidate set Minima's example agents route over plus a few
+OpenAI/OpenRouter entries. Prices (per-million-token USD) are sourced from the comments
+in ``examples/agent_warmup.py`` so the harness agrees with Minima's existing catalog
+expectations out of the box; Phase 3's mapping layer reconciles against Minima's live
+``GET /v1/models`` catalog where they diverge.
+
+PI exposes ~25 providers; this lean port starts with 4 (anthropic, google, openai,
+openrouter) and is extensible via :func:`register_model`.
+"""
+
+from __future__ import annotations
+
+from minima_harness.ai.types import Modality, Model, ModelCost
+
+# (provider, model_id) -> Model
+_MODELS: dict[tuple[str, str], Model] = {}
+
+
+def register_model(model: Model) -> Model:
+    _MODELS[(model.provider, model.id)] = model
+    return model
+
+
+def get_model(provider: str, model_id: str) -> Model:
+    try:
+        return _MODELS[(provider, model_id)]
+    except KeyError:
+        known = ", ".join(f"{p}/{m}" for p, m in sorted(_MODELS)) or "<none>"
+        raise KeyError(f"unknown model {provider}/{model_id!r}; known: {known}") from None
+
+
+def try_get_model(provider: str, model_id: str) -> Model | None:
+    return _MODELS.get((provider, model_id))
+
+
+def get_models(provider: str) -> list[Model]:
+    return [m for (p, _), m in _MODELS.items() if p == provider]
+
+
+def get_providers() -> list[str]:
+    return sorted({p for p, _ in _MODELS})
+
+
+def all_models() -> list[Model]:
+    return list(_MODELS.values())
+
+
+def find_model_by_id(model_id: str) -> Model | None:
+    """First registered model with the given id (any provider). Used by cross-provider
+    compat to infer which api produced a replayed assistant message."""
+    for (__, mid), model in _MODELS.items():
+        if mid == model_id:
+            return model
+    return None
+
+
+# ---------------------------------------------------------------------------
+# Seed catalog
+# ---------------------------------------------------------------------------
+
+_TEXT = (Modality.text,)
+_MULTIMODAL = (Modality.text, Modality.image)
+
+_OPENROUTER_BASE = "https://openrouter.ai/api/v1"
+
+
+def _seed() -> None:
+    # --- Anthropic (api: anthropic-messages) ---
+    register_model(
+        Model(
+            id="claude-haiku-4-5",
+            provider="anthropic",
+            api="anthropic-messages",
+            name="Claude Haiku 4.5",
+            cost=ModelCost(input=1.0, output=5.0, cache_read=0.08, cache_write=1.25),
+            context_window=200_000,
+            max_tokens=8192,
+            input=_MULTIMODAL,
+            reasoning=False,
+        )
+    )
+    register_model(
+        Model(
+            id="claude-sonnet-4-6",
+            provider="anthropic",
+            api="anthropic-messages",
+            name="Claude Sonnet 4.6",
+            cost=ModelCost(input=3.0, output=15.0, cache_read=0.30, cache_write=3.75),
+            context_window=200_000,
+            max_tokens=16_384,
+            input=_MULTIMODAL,
+            reasoning=True,
+        )
+    )
+    register_model(
+        Model(
+            id="claude-opus-4-8",
+            provider="anthropic",
+            api="anthropic-messages",
+            name="Claude Opus 4.8",
+            cost=ModelCost(input=15.0, output=75.0, cache_read=1.50, cache_write=18.75),
+            context_window=200_000,
+            max_tokens=16_384,
+            input=_MULTIMODAL,
+            reasoning=True,
+        )
+    )
+
+    # --- Google / Gemini (api: google-generative-ai) ---
+    register_model(
+        Model(
+            id="gemini-2.5-flash",
+            provider="google",
+            api="google-generative-ai",
+            name="Gemini 2.5 Flash",
+            cost=ModelCost(input=0.30, output=2.50),
+            context_window=1_000_000,
+            max_tokens=8192,
+            input=_MULTIMODAL,
+            reasoning=True,
+        )
+    )
+    register_model(
+        Model(
+            id="gemini-2.5-pro",
+            provider="google",
+            api="google-generative-ai",
+            name="Gemini 2.5 Pro",
+            cost=ModelCost(input=1.25, output=10.0),
+            context_window=2_000_000,
+            max_tokens=8192,
+            input=_MULTIMODAL,
+            reasoning=True,
+        )
+    )
+
+    # --- OpenAI (api: openai-completions via raw httpx in Phase 1) ---
+    register_model(
+        Model(
+            id="gpt-4o-mini",
+            provider="openai",
+            api="openai-completions",
+            name="GPT-4o mini",
+            cost=ModelCost(input=0.15, output=0.60, cache_read=0.075),
+            context_window=128_000,
+            max_tokens=16_384,
+            input=_MULTIMODAL,
+            reasoning=False,
+        )
+    )
+    register_model(
+        Model(
+            id="gpt-4o",
+            provider="openai",
+            api="openai-completions",
+            name="GPT-4o",
+            cost=ModelCost(input=2.5, output=10.0, cache_read=1.25),
+            context_window=128_000,
+            max_tokens=16_384,
+            input=_MULTIMODAL,
+            reasoning=False,
+        )
+    )
+
+    # --- OpenRouter (api: openai-completions; base_url set) ---
+    register_model(
+        Model(
+            id="google/gemini-2.5-flash",
+            provider="openrouter",
+            api="openai-completions",
+            name="Gemini 2.5 Flash (OpenRouter)",
+            cost=ModelCost(input=0.30, output=2.50),
+            context_window=1_000_000,
+            max_tokens=8192,
+            input=_MULTIMODAL,
+            reasoning=True,
+            base_url=_OPENROUTER_BASE,
+        )
+    )
+
+
+_seed()