tau-coding-agent 0.1.0__py3-none-any.whl

tau/auth/storage.py

@@ -0,0 +1,82 @@
+from abc import ABC, abstractmethod
+from tau.auth.types import LockResult
+from filelock import FileLock
+from typing import Callable, Awaitable
+from pathlib import Path
+
+
+class AuthStorage(ABC):
+    """Abstract storage backend for auth credentials."""
+
+    @abstractmethod
+    def with_lock(self, fn: Callable[[str | None], LockResult]) -> LockResult:
+        """Execute fn with exclusive access to storage."""
+        pass
+
+    @abstractmethod
+    async def with_lock_async(self, fn: Callable[[str | None], Awaitable[LockResult]]) -> LockResult:
+        """Execute async fn with exclusive access to storage."""
+        pass
+
+
+class FileAuthStorage(AuthStorage):
+    """File-based storage backend with locking."""
+
+    def __init__(self, store_path: Path):
+        """Initialize file storage at the given path."""
+        self.store_path = store_path
+        self.lock_path = store_path.with_suffix(".lock")
+        self._ensure_parent_dir()
+        self._ensure_file_exists()
+
+    def _ensure_parent_dir(self) -> None:
+        """Create parent directory if it doesn't exist."""
+        self.store_path.parent.mkdir(parents=True, exist_ok=True, mode=0o700)
+
+    def _ensure_file_exists(self) -> None:
+        """Create storage file if it doesn't exist."""
+        if not self.store_path.exists():
+            self.store_path.write_text("{}", encoding="utf-8")
+            self.store_path.chmod(0o600)
+
+    def with_lock(self, fn: Callable[[str | None], LockResult]) -> LockResult:
+        """Execute fn with exclusive access to storage."""
+        with FileLock(self.lock_path):
+            current = self.store_path.read_text(encoding="utf-8") if self.store_path.exists() else None
+            result = fn(current)
+            if result.next is not None:
+                self.store_path.write_text(result.next, encoding="utf-8")
+                self.store_path.chmod(0o600)
+            return result
+
+    async def with_lock_async(self, fn: Callable[[str | None], Awaitable[LockResult]]) -> LockResult:
+        """Execute async fn with exclusive access to storage."""
+        with FileLock(self.lock_path):
+            current = self.store_path.read_text(encoding="utf-8") if self.store_path.exists() else None
+            result = await fn(current)
+            if result.next is not None:
+                self.store_path.write_text(result.next, encoding="utf-8")
+                self.store_path.chmod(0o600)
+            return result
+
+
+class InMemoryAuthStorage(AuthStorage):
+    """In-memory storage backend for testing."""
+
+    def __init__(self):
+        """Initialize empty in-memory storage."""
+        self._value: str | None = None
+
+    def with_lock(self, fn: Callable[[str | None], LockResult]) -> LockResult:
+        """Execute fn with exclusive access to memory storage."""
+        result = fn(self._value)
+        if result.next is not None:
+            self._value = result.next
+        return result
+
+    async def with_lock_async(self, fn: Callable[[str | None], Awaitable[LockResult]]) -> LockResult:
+        """Execute async fn with exclusive access to memory storage."""
+        result = await fn(self._value)
+        if result.next is not None:
+            self._value = result.next
+        return result

tau/auth/types.py

@@ -0,0 +1,41 @@
+from tau.inference.types import AuthType
+from dataclasses import dataclass, field
+from typing import Generic, TypeVar, Optional, Literal
+
+
+@dataclass
+class OAuthCredential:
+    """OAuth 2.0 credential with access and refresh tokens."""
+    type: AuthType = field(default_factory=lambda: AuthType.OAuth, init=False)
+    access: str = ""
+    refresh: str = ""
+    expires: int = 0  # Unix timestamp in milliseconds
+    extra: dict[str, str] = field(default_factory=dict)
+
+
+@dataclass
+class APICredential:
+    """API key credential."""
+    type: AuthType = field(default_factory=lambda: AuthType.ApiKey, init=False)
+    key: str = ""
+
+
+AuthCredential = OAuthCredential | APICredential
+
+
+@dataclass
+class AuthStatus:
+    """Authentication status and source information."""
+    configured: bool
+    source: Optional[Literal["stored", "runtime", "env"]] = None
+    label: Optional[str] = None
+
+
+T = TypeVar('T')
+
+
+@dataclass
+class LockResult(Generic[T]):
+    """Result of a locked operation with next continuation."""
+    result: T
+    next: str | None = None

tau/builtins/__init__.py

@@ -0,0 +1,4 @@
+# tau.builtins — concrete built-in implementations.
+#
+#   Tools:   from tau.builtins.tools import TOOLS, TerminalTool, …
+#   Themes:  from tau.themes.registry import theme_registry

tau/builtins/commands/__init__.py

@@ -0,0 +1,41 @@
+from __future__ import annotations
+
+from tau.commands.types import CommandInfo
+from tau.builtins.commands.session import cmd_new, cmd_fork
+from tau.builtins.commands.reload import cmd_reload
+from tau.builtins.commands.compact import cmd_compact
+from tau.builtins.commands.clear import cmd_clear
+
+
+def get_builtin_commands() -> list[CommandInfo]:
+    """Get the list of builtin slash commands."""
+    return [
+        CommandInfo(
+            name="new",
+            description="Start a fresh session.",
+            call=cmd_new,
+        ),
+        CommandInfo(
+            name="fork",
+            description="Branch the session tree at a given entry ID.",
+            call=cmd_fork,
+            argument_hint="<entry_id>",
+            required_arg_names=["entry_id"],
+        ),
+        CommandInfo(
+            name="reload",
+            description="Reload extensions, themes, and prompt appends.",
+            call=cmd_reload,
+        ),
+        CommandInfo(
+            name="compact",
+            description="Summarise and compact the current session context.",
+            call=cmd_compact,
+            argument_hint="<custom_instruction>",
+        ),
+        CommandInfo(
+            name="clear",
+            description="Clear the message list.",
+            call=cmd_clear,
+        ),
+    ]

tau/builtins/commands/clear.py

@@ -0,0 +1,16 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from tau.commands.registry import CommandRegistry
+
+
+async def cmd_clear(reg: CommandRegistry, _args: list[str]) -> None:
+    """Clear the message list."""
+    if reg.runtime is None:
+        return
+    from tau.extensions.context import ExtensionContext
+    ctx = ExtensionContext.from_runtime(reg.runtime)
+    if ctx.ui is not None:
+        ctx.ui.clear_messages()

tau/builtins/commands/compact.py

@@ -0,0 +1,28 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from tau.commands.registry import CommandRegistry
+
+
+async def cmd_compact(reg: CommandRegistry, args: list[str]) -> None:
+    """Manually compact the current session context."""
+    if reg.runtime is None or reg.runtime.agent is None:
+        return
+
+    sm = reg.runtime.settings_manager
+    if sm is not None and not sm.is_compaction_enabled():
+        from tau.extensions.context import ExtensionContext
+        ctx = ExtensionContext.from_runtime(reg.runtime)
+        if ctx.ui is not None:
+            ctx.ui.notify("Compaction is disabled. Enable it in /settings → Compaction.")
+        return
+
+    custom_instructions = " ".join(args).strip() or None
+    did_compact = await reg.runtime.agent.compact(custom_instructions=custom_instructions)
+    if not did_compact:
+        from tau.extensions.context import ExtensionContext
+        ctx = ExtensionContext.from_runtime(reg.runtime)
+        if ctx.ui is not None:
+            ctx.ui.notify("Nothing to compact — conversation is too short to summarize.")

tau/builtins/commands/reload.py

@@ -0,0 +1,27 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from tau.commands.registry import CommandRegistry
+
+
+async def cmd_reload(reg: CommandRegistry, _args: list[str]) -> None:
+    """Reload extensions, themes, and prompt appends."""
+    if reg.runtime is None:
+        return
+    result = await reg.runtime.reload_extensions()
+
+    from tau.extensions.context import ExtensionContext
+    ctx = ExtensionContext.from_runtime(reg.runtime)
+    if ctx.ui is None:
+        return
+
+    n = len(result.extensions)
+    ext_word = "extension" if n == 1 else "extensions"
+    if result.errors:
+        e = len(result.errors)
+        err_word = "error" if e == 1 else "errors"
+        ctx.ui.notify(f"Reloaded {n} {ext_word} with {e} {err_word}.")
+    else:
+        ctx.ui.notify(f"Reloaded {n} {ext_word}.")

tau/builtins/commands/session.py

@@ -0,0 +1,19 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from tau.commands.registry import CommandRegistry
+
+
+async def cmd_new(reg: CommandRegistry, _args: list[str]) -> None:
+    """Start a new session."""
+    if reg.runtime is not None:
+        await reg.runtime.new_session()
+
+
+async def cmd_fork(reg: CommandRegistry, args: list[str]) -> None:
+    """Fork the session at a given entry ID."""
+    if reg.runtime is None:
+        return
+    await reg.runtime.fork_session(args[0])

tau/builtins/extensions/footer/__init__.py

@@ -0,0 +1,76 @@
+"""Built-in footer status extension — git branch left, model/context right."""
+from __future__ import annotations
+
+from .git import GitBadge
+from .model import ModelBadge
+
+
+def register(tau: object) -> None:
+    from tau.tui.component import Row
+
+    git_badge   = GitBadge()
+    model_badge = ModelBadge()
+    row         = Row([(git_badge, "left"), (model_badge, "right")])  # type: ignore[arg-type]
+
+    def _request_render(ctx: object) -> None:
+        layout = getattr(ctx, "_layout", None)
+        if layout is not None:
+            layout._tui.request_render()
+
+    @tau.on("tui_ready")
+    def on_ready(event, ctx):
+        ctx._layout.footer.add_child(row)
+        git_badge.update(str(ctx.cwd))
+        model_badge.update_from_ctx(ctx)
+        _request_render(ctx)
+
+    @tau.on("session_start")
+    def on_session_start(event, ctx):
+        if ctx.has_ui:
+            git_badge.update(str(ctx.cwd))
+            model_badge.update_from_ctx(ctx)
+            _request_render(ctx)
+
+    @tau.on("model_select")
+    def on_model_select(event, ctx):
+        if not ctx.has_ui:
+            return
+        model = getattr(event, "model", None)
+        if model is not None:
+            model_badge.set_model(
+                getattr(model, "id", "") or "",
+                getattr(model, "provider", "") or "",
+                bool(getattr(model, "thinking", False)),
+            )
+        # The new model usually has a different context window, so the usage %
+        # changes even though the token count didn't — refresh it immediately
+        # instead of waiting for the next turn.
+        model_badge.update_context_from_ctx(ctx)
+        _request_render(ctx)
+
+    @tau.on("thinking_level_select")
+    def on_thinking_level_select(event, ctx):
+        if not ctx.has_ui:
+            return
+        model_badge.set_thinking_level(getattr(event, "level", None))
+        _request_render(ctx)
+
+    @tau.on("settled")
+    def on_settled(event, ctx):
+        if ctx.has_ui:
+            git_badge.update(str(ctx.cwd))
+            model_badge.update_context_from_ctx(ctx)
+            _request_render(ctx)
+
+    @tau.on("message_end")
+    def on_message_end(event, ctx):
+        if ctx.has_ui:
+            git_badge.update(str(ctx.cwd))
+            model_badge.update_context_from_ctx(ctx)
+            _request_render(ctx)
+
+    @tau.on("compaction_end")
+    def on_compaction_end(event, ctx):
+        if ctx.has_ui:
+            model_badge.update_context_from_ctx(ctx)
+            _request_render(ctx)

tau/builtins/extensions/footer/git.py

@@ -0,0 +1,26 @@
+"""Git branch badge component."""
+from __future__ import annotations
+
+from .utils import read_branch, shorten_home
+
+
+class GitBadge:
+    """Renders ``~/path (branch)`` for the footer Row left slot."""
+
+    def __init__(self) -> None:
+        self._text = ""
+
+    def update(self, cwd: str) -> None:
+        branch = read_branch(cwd)
+        display = shorten_home(cwd)
+        self._text = f"{display} ({branch})" if branch else display
+
+    def render(self, width: int) -> list[str]:  # noqa: ARG002
+        from tau.tui.ansi import DIM, RESET
+        return [DIM + self._text + RESET]
+
+    def handle_input(self, event: object) -> bool:  # noqa: ARG002
+        return False
+
+    def invalidate(self) -> None:
+        pass

tau/builtins/extensions/footer/model.py

@@ -0,0 +1,69 @@
+"""Model + context-usage badge component."""
+from __future__ import annotations
+
+
+class ModelBadge:
+    """Renders ``(provider) model ∙ Level|context%`` for the footer Row right slot.
+
+    The ``∙ Level`` segment only appears when the active model supports
+    extended thinking and a thinking level is set.
+    """
+
+    def __init__(self) -> None:
+        self._provider = ""
+        self._model = ""
+        self._tokens = 0
+        self._context_window = 0
+        self._thinking = False
+        self._thinking_level = ""
+
+    def set_model(self, model_id: str, provider: str, thinking: bool = False) -> None:
+        self._model = model_id
+        self._provider = provider
+        self._thinking = thinking
+
+    def set_thinking_level(self, level: object) -> None:
+        self._thinking_level = str(getattr(level, "value", level) or "")
+
+    def set_context(self, tokens: int, context_window: int) -> None:
+        self._tokens = tokens
+        self._context_window = context_window
+
+    def update_from_ctx(self, ctx: object) -> None:
+        self.set_model(
+            getattr(ctx, "model_id", "") or "",
+            getattr(ctx, "provider_id", "") or "",
+            bool(getattr(ctx, "model_thinking", False)),
+        )
+        settings = getattr(ctx, "settings", None)
+        if settings is not None:
+            self.set_thinking_level(settings.get_thinking_level())
+        self.update_context_from_ctx(ctx)
+
+    def update_context_from_ctx(self, ctx: object) -> None:
+        usage = getattr(ctx, "get_context_usage", lambda: None)()
+        if usage is not None:
+            tokens = usage.get("tokens") or 0
+            window = usage.get("context_window") or 0
+            self.set_context(tokens, window)
+
+    def render(self, width: int) -> list[str]:  # noqa: ARG002
+        from tau.tui.ansi import DIM, RESET
+        if not self._provider and not self._model:
+            return []
+
+        left = f"({self._provider}) {self._model}" if self._provider else self._model
+        if self._thinking and self._thinking_level and self._thinking_level != "off":
+            left += f" ∙ {self._thinking_level.title()}"
+
+        if self._context_window > 0 and self._tokens > 0:
+            pct = self._tokens / self._context_window * 100
+            label = f"{pct:.1f}%" if pct < 1 else f"{int(round(pct))}%"
+            return [DIM + f"{left}|{label}" + RESET]
+        return [DIM + left + RESET]
+
+    def handle_input(self, event: object) -> bool:  # noqa: ARG002
+        return False
+
+    def invalidate(self) -> None:
+        pass

tau/builtins/extensions/footer/utils.py

@@ -0,0 +1,44 @@
+"""Shared helpers for the status extension."""
+from __future__ import annotations
+
+
+def read_branch(cwd: object) -> str:
+    """Return the current git branch name for the given directory, or ''."""
+    import os
+    from pathlib import Path
+    try:
+        path = Path(str(cwd))
+        for candidate in [path, *path.parents]:
+            git = candidate / ".git"
+            if git.is_dir():
+                head = git / "HEAD"
+            elif git.is_file():
+                content = git.read_text(encoding="utf-8").strip()
+                if not content.startswith("gitdir: "):
+                    continue
+                gitdir = os.path.normpath(
+                    os.path.join(str(candidate), content[8:].strip())
+                )
+                head = Path(gitdir) / "HEAD"
+            else:
+                continue
+            if not head.is_file():
+                continue
+            text = head.read_text(encoding="utf-8").strip()
+            if text.startswith("ref: refs/heads/"):
+                return text[len("ref: refs/heads/"):]
+            return text[:7]
+        return ""
+    except OSError:
+        return ""
+
+
+def shorten_home(path: str) -> str:
+    """Replace the home directory prefix with ``~``."""
+    import os
+    home = os.path.expanduser("~")
+    if path == home:
+        return "~"
+    if path.startswith(home + os.sep):
+        return "~" + path[len(home):]
+    return path

tau/builtins/extensions/header/__init__.py

@@ -0,0 +1,18 @@
+"""Built-in header extension — shows app name and version above the message list."""
+from __future__ import annotations
+
+
+def register(tau: object) -> None:
+    from tau.settings.paths import get_app_name, get_app_version
+    from tau.tui.ansi import BOLD, CYAN, DIM, RESET
+    from tau.tui.component import StaticComponent
+
+    def _build() -> StaticComponent:
+        name = BOLD + CYAN + get_app_name() + RESET
+        version = DIM + f"v{get_app_version()}" + RESET
+        return StaticComponent([f"{name} {version}"])
+
+    @tau.on("tui_ready")
+    def on_ready(event, ctx):
+        if ctx.has_ui:
+            ctx.ui.set_header(_build())

tau/builtins/models/audio.py

@@ -0,0 +1,43 @@
+from tau.inference.model.types import Cost, Model, Modality
+
+_TEXT  = [Modality.Text]
+_AUDIO = [Modality.Audio]
+
+_OPENAI_VOICES = ["alloy", "ash", "ballad", "coral", "echo", "fable", "nova", "onyx", "sage", "shimmer", "verse"]
+_GROQ_VOICES   = ["autumn", "diana", "hannah", "austin", "daniel", "troy"]
+
+models = [
+    # OpenAI TTS
+    Model(id="tts-1",           name="TTS-1",           provider="openai", cost=Cost(input=15.0), input=_TEXT,  output=_AUDIO, api="openai-audio", voices=_OPENAI_VOICES),
+    Model(id="tts-1-hd",        name="TTS-1 HD",        provider="openai", cost=Cost(input=30.0), input=_TEXT,  output=_AUDIO, api="openai-audio", voices=_OPENAI_VOICES),
+    Model(id="gpt-4o-mini-tts", name="GPT-4o Mini TTS", provider="openai", cost=Cost(input=0.60), input=_TEXT,  output=_AUDIO, api="openai-audio", voices=_OPENAI_VOICES),
+    # OpenAI STT
+    Model(id="whisper-1",              name="Whisper 1",              provider="openai", cost=Cost(input=0.006), input=_AUDIO, output=_TEXT, api="openai-audio"),
+    Model(id="gpt-4o-transcribe",      name="GPT-4o Transcribe",      provider="openai", cost=Cost(input=2.5),   input=_AUDIO, output=_TEXT, api="openai-audio"),
+    Model(id="gpt-4o-mini-transcribe", name="GPT-4o Mini Transcribe", provider="openai", cost=Cost(input=0.003), input=_AUDIO, output=_TEXT, api="openai-audio"),
+    # Google Gemini TTS
+    Model(id="gemini-2.5-flash-preview-tts", name="Gemini 2.5 Flash TTS", provider="google", cost=Cost(input=0.50,  output=10.0), input=_TEXT, output=_AUDIO, api="gemini-audio"),
+    Model(id="gemini-2.5-pro-preview-tts",   name="Gemini 2.5 Pro TTS",   provider="google", cost=Cost(input=2.00,  output=16.0), input=_TEXT, output=_AUDIO, api="gemini-audio"),
+    Model(id="gemini-3.1-flash-tts-preview", name="Gemini 3.1 Flash TTS", provider="google", cost=Cost(input=0.10,  output=1.00), input=_TEXT, output=_AUDIO, api="gemini-audio"),
+    # OpenRouter speech models
+    Model(id="openai/gpt-audio",          name="GPT Audio",         provider="openrouter", cost=Cost(input=2.50, output=10.00), input=_TEXT, output=_AUDIO, api="openai-audio"),
+    Model(id="openai/gpt-audio-mini",     name="GPT Audio Mini",    provider="openrouter", cost=Cost(input=0.60, output=2.40),  input=_TEXT, output=_AUDIO, api="openai-audio"),
+    Model(id="openai/gpt-4o-audio-preview", name="GPT-4o Audio",    provider="openrouter", cost=Cost(input=2.50, output=10.00), input=_TEXT, output=_AUDIO, api="openai-audio"),
+    Model(id="google/lyria-3-pro-preview", name="Lyria 3 Pro Preview", provider="openrouter", cost=Cost(), input=_TEXT, output=_AUDIO, api="openai-audio"),
+    Model(id="google/lyria-3-clip-preview", name="Lyria 3 Clip Preview", provider="openrouter", cost=Cost(), input=_TEXT, output=_AUDIO, api="openai-audio"),
+    # Sarvam AI
+    Model(id="bulbul:v3",    name="Bulbul v3",    provider="sarvam", cost=Cost(), input=_TEXT,  output=_AUDIO, api="sarvam-audio"),
+    Model(id="saarika:v2.5", name="Saarika v2.5", provider="sarvam", cost=Cost(), input=_AUDIO, output=_TEXT,  api="sarvam-audio"),
+    Model(id="saaras:v3",    name="Saaras v3",    provider="sarvam", cost=Cost(), input=_AUDIO, output=_TEXT,  api="sarvam-audio"),
+    # ElevenLabs
+    Model(id="eleven_multilingual_v2", name="Eleven Multilingual v2", provider="elevenlabs", cost=Cost(input=0.30), input=_TEXT,  output=_AUDIO, api="elevenlabs-audio"),
+    Model(id="eleven_flash_v2_5",      name="Eleven Flash v2.5",      provider="elevenlabs", cost=Cost(input=0.08), input=_TEXT,  output=_AUDIO, api="elevenlabs-audio"),
+    Model(id="eleven_turbo_v2_5",      name="Eleven Turbo v2.5",      provider="elevenlabs", cost=Cost(input=0.15), input=_TEXT,  output=_AUDIO, api="elevenlabs-audio"),
+    Model(id="scribe_v1",              name="Scribe v1",               provider="elevenlabs", cost=Cost(input=0.40), input=_AUDIO, output=_TEXT,  api="elevenlabs-audio"),
+    Model(id="scribe_v2",              name="Scribe v2",               provider="elevenlabs", cost=Cost(input=0.40), input=_AUDIO, output=_TEXT,  api="elevenlabs-audio"),
+    # Groq TTS
+    Model(id="canopylabs/orpheus-v1-english", name="Orpheus v1 English", provider="groq", cost=Cost(), input=_TEXT, output=_AUDIO, api="openai-audio", voices=_GROQ_VOICES, tts_format="wav"),
+    # Groq STT
+    Model(id="whisper-large-v3",       name="Whisper Large v3",       provider="groq", cost=Cost(input=0.111), input=_AUDIO, output=_TEXT, api="openai-audio"),
+    Model(id="whisper-large-v3-turbo", name="Whisper Large v3 Turbo", provider="groq", cost=Cost(input=0.04),  input=_AUDIO, output=_TEXT, api="openai-audio"),
+]

tau/builtins/models/image.py

@@ -0,0 +1,43 @@
+from tau.inference.model.types import Cost, Model, Modality
+
+_TEXT           = [Modality.Text]
+_IMAGE          = [Modality.Image]
+_TEXT_IMAGE     = [Modality.Text, Modality.Image]
+_TEXT_IMAGE_OUT = [Modality.Text, Modality.Image]
+
+models = [
+    # OpenAI DALL-E
+    Model(id="dall-e-3", name="DALL-E 3", provider="openai", cost=Cost(input=40.0), input=_TEXT, output=_IMAGE, api="openai-image"),
+    Model(id="dall-e-2", name="DALL-E 2", provider="openai", cost=Cost(input=20.0), input=_TEXT, output=_IMAGE, api="openai-image"),
+    # Together AI
+    Model(id="black-forest-labs/FLUX.1-schnell-Free", name="FLUX.1 Schnell Free", provider="together", cost=Cost(),            input=_TEXT, output=_IMAGE, api="openai-image"),
+    Model(id="black-forest-labs/FLUX.1-schnell",      name="FLUX.1 Schnell",      provider="together", cost=Cost(input=0.053), input=_TEXT, output=_IMAGE, api="openai-image"),
+    Model(id="black-forest-labs/FLUX.1-dev",          name="FLUX.1 Dev",          provider="together", cost=Cost(input=0.35),  input=_TEXT, output=_IMAGE, api="openai-image"),
+    Model(id="black-forest-labs/FLUX.1.1-pro",        name="FLUX.1.1 Pro",        provider="together", cost=Cost(input=0.40),  input=_TEXT, output=_IMAGE, api="openai-image"),
+    # Fireworks AI
+    Model(id="accounts/fireworks/models/flux-1-schnell-fp8", name="FLUX.1 Schnell FP8", provider="fireworks", cost=Cost(input=0.053), input=_TEXT, output=_IMAGE, api="openai-image"),
+    Model(id="accounts/fireworks/models/flux-1-dev-fp8",     name="FLUX.1 Dev FP8",     provider="fireworks", cost=Cost(input=0.35),  input=_TEXT, output=_IMAGE, api="openai-image"),
+    # Black Forest Labs FLUX via OpenRouter
+    Model(id="black-forest-labs/flux-2-flex",  name="FLUX.2 Flex",     provider="openrouter", cost=Cost(), input=_TEXT_IMAGE, output=_IMAGE),
+    Model(id="black-forest-labs/flux-2-klein", name="FLUX.2 Klein 4B", provider="openrouter", cost=Cost(), input=_TEXT_IMAGE, output=_IMAGE),
+    Model(id="black-forest-labs/flux-2-max",   name="FLUX.2 Max",      provider="openrouter", cost=Cost(), input=_TEXT_IMAGE, output=_IMAGE),
+    Model(id="black-forest-labs/flux-2-pro",   name="FLUX.2 Pro",      provider="openrouter", cost=Cost(), input=_TEXT_IMAGE, output=_IMAGE),
+    # Google Imagen (native gemini-image API)
+    Model(id="imagen-3.0-generate-002",      name="Imagen 3",      provider="google", cost=Cost(input=0.04), input=_TEXT, output=_IMAGE, api="gemini-image"),
+    Model(id="imagen-3.0-fast-generate-001", name="Imagen 3 Fast", provider="google", cost=Cost(input=0.02), input=_TEXT, output=_IMAGE, api="gemini-image"),
+    # Google Gemini Image via OpenRouter
+    Model(id="google/gemini-2.5-flash-image-generation",         name="Gemini 2.5 Flash Image",         provider="openrouter", cost=Cost(input=0.30,  output=2.50),  input=_TEXT_IMAGE, output=_TEXT_IMAGE_OUT),
+    Model(id="google/gemini-3-pro-image-generation-preview",     name="Gemini 3 Pro Image Preview",     provider="openrouter", cost=Cost(input=2.00,  output=12.00), input=_TEXT_IMAGE, output=_TEXT_IMAGE_OUT),
+    Model(id="google/gemini-3.1-flash-image-generation-preview", name="Gemini 3.1 Flash Image Preview", provider="openrouter", cost=Cost(input=0.50,  output=3.00),  input=_TEXT_IMAGE, output=_TEXT_IMAGE_OUT),
+    # OpenAI GPT Image via OpenRouter
+    Model(id="openai/gpt-5-image",      name="GPT-5 Image",      provider="openrouter", cost=Cost(input=10.00, output=10.00), input=_TEXT_IMAGE, output=_TEXT_IMAGE_OUT),
+    Model(id="openai/gpt-5-image-mini", name="GPT-5 Image Mini", provider="openrouter", cost=Cost(input=2.50,  output=2.00),  input=_TEXT_IMAGE, output=_TEXT_IMAGE_OUT),
+    Model(id="openai/gpt-5.4-image-2",  name="GPT-5.4 Image 2",  provider="openrouter", cost=Cost(input=8.00,  output=15.00), input=_TEXT_IMAGE, output=_TEXT_IMAGE_OUT),
+    # ByteDance
+    Model(id="bytedance/seedream-4.5", name="Seedream 4.5", provider="openrouter", cost=Cost(), input=_TEXT_IMAGE, output=_IMAGE),
+    # Sourceful Riverflow via OpenRouter
+    Model(id="sourceful/riverflow-v2",       name="Riverflow V2",       provider="openrouter", cost=Cost(), input=_TEXT_IMAGE, output=_IMAGE),
+    Model(id="sourceful/riverflow-v2-turbo", name="Riverflow V2 Turbo", provider="openrouter", cost=Cost(), input=_TEXT_IMAGE, output=_IMAGE),
+    Model(id="sourceful/riverflow-v2-max",   name="Riverflow V2 Max",   provider="openrouter", cost=Cost(), input=_TEXT_IMAGE, output=_IMAGE),
+    Model(id="sourceful/riverflow-v2-pro",   name="Riverflow V2 Pro",   provider="openrouter", cost=Cost(), input=_TEXT_IMAGE, output=_IMAGE),
+]