crow-cli 0.1.32__tar.gz → 0.1.34__tar.gz

{crow_cli-0.1.32 → crow_cli-0.1.34}/PKG-INFO

@@ -1,23 +1,24 @@
 Metadata-Version: 2.5
 Name: crow-cli
-Version: 0.1.32
+Version: 0.1.34
 Summary: Add your description here
 Project-URL: Homepage, https://github.com/crow-cli/crow-cli
 Project-URL: Repository, https://github.com/crow-cli/crow-cli
 Project-URL: Issues, https://github.com/crow-cli/crow-cli/issues
 Project-URL: Documentation, https://github.com/crow-cli/crow-cli#readme
 Requires-Python: >=3.14
-Requires-Dist: agent-client-protocol<0.13.0,>=0.12.0
+Requires-Dist: agent-client-protocol[http]<0.13.0,>=0.12.0
 Requires-Dist: coolname>=2.2.0
+Requires-Dist: crow-memory==0.1.34
 Requires-Dist: directory-tree>=1.0.0
 Requires-Dist: docker>=7.2.0
 Requires-Dist: fastmcp>=2.14.5
 Requires-Dist: httpx>=0.28.1
+Requires-Dist: hypercorn>=0.17
 Requires-Dist: jinja2>=3.1.6
 Requires-Dist: openai>=2.21.0
 Requires-Dist: pyyaml>=6.0.3
 Requires-Dist: rich>=14.3.3
-Requires-Dist: sqlalchemy>=2.0.51
 Requires-Dist: typer>=0.24.1
 Description-Content-Type: text/markdown
 
@@ -171,13 +172,13 @@ cd crow-cli
 uv sync --project crow-cli
 ```
 
-Run the unit tests — fast and hermetic, no services required (tests that touch sessions use an in-memory fake of the memory service):
+Run the unit tests — fast and hermetic, no services required (unit tests that touch sessions use an in-memory fake of the persistence client; the integration tier uses a real throwaway sqlite db):
 
 ```bash
 uv run --project crow-cli pytest crow-cli/tests/unit
 ```
 
-The persistence layer itself is tested in `crow-cli/tests/unit/test_db.py`. Integration and end-to-end tiers are opt-in:
+The persistence layer itself lives in the `crow-memory` package and is tested in `crow-memory/tests/test_store.py`. Integration and end-to-end tiers are opt-in:
 
 ```bash
 uv run --project crow-cli pytest crow-cli/tests --run-integration   # spawn the agent
@@ -189,6 +190,7 @@ uv run --project crow-cli pytest crow-cli/tests --run-e2e           # live LLM c
 ```
 crow-cli/               the agent — ACP server, ReAct loop, CLI
 crow-mcp/               built-in MCP tool server
+crow-memory/            shared SQL persistence (sqlite default, postgres-ready)
 ```
 
 ## License

{crow_cli-0.1.32 → crow_cli-0.1.34}/README.md

@@ -148,13 +148,13 @@ cd crow-cli
 uv sync --project crow-cli
 ```
 
-Run the unit tests — fast and hermetic, no services required (tests that touch sessions use an in-memory fake of the memory service):
+Run the unit tests — fast and hermetic, no services required (unit tests that touch sessions use an in-memory fake of the persistence client; the integration tier uses a real throwaway sqlite db):
 
 ```bash
 uv run --project crow-cli pytest crow-cli/tests/unit
 ```
 
-The persistence layer itself is tested in `crow-cli/tests/unit/test_db.py`. Integration and end-to-end tiers are opt-in:
+The persistence layer itself lives in the `crow-memory` package and is tested in `crow-memory/tests/test_store.py`. Integration and end-to-end tiers are opt-in:
 
 ```bash
 uv run --project crow-cli pytest crow-cli/tests --run-integration   # spawn the agent
@@ -166,6 +166,7 @@ uv run --project crow-cli pytest crow-cli/tests --run-e2e           # live LLM c
 ```
 crow-cli/               the agent — ACP server, ReAct loop, CLI
 crow-mcp/               built-in MCP tool server
+crow-memory/            shared SQL persistence (sqlite default, postgres-ready)
 ```
 
 ## License

{crow_cli-0.1.32 → crow_cli-0.1.34}/crow-cli.spec

@@ -22,6 +22,7 @@ a = Analysis(
     ),
     hiddenimports=[
         'crow_cli',
+        'crow_memory',
         'crow_cli.agent',
         'crow_cli.agent.main',
         'crow_cli.agent.mcp_client',

{crow_cli-0.1.32 → crow_cli-0.1.34}/pyproject.toml

@@ -1,11 +1,13 @@
 [project]
 name = "crow-cli"
-version = "0.1.32"
+version = "0.1.34"
 description = "Add your description here"
 readme = "README.md"
 requires-python = ">=3.14"
 dependencies = [
-    "agent-client-protocol>=0.12.0,<0.13.0",
+    "agent-client-protocol[http]>=0.12.0,<0.13.0",
+    "crow-memory==0.1.34",
+    "hypercorn>=0.17",
     "coolname>=2.2.0",
     "directory-tree>=1.0.0",
     "docker>=7.2.0",
@@ -15,10 +17,12 @@ dependencies = [
     "openai>=2.21.0",
     "pyyaml>=6.0.3",
     "rich>=14.3.3",
-    "sqlalchemy>=2.0.51",
     "typer>=0.24.1",
 ]
 
+[tool.uv.sources]
+crow-memory = { path = "../crow-memory", editable = true }
+
 
 [project.urls]
 Homepage = "https://github.com/crow-cli/crow-cli"

crow_cli-0.1.34/run_tests.sh

@@ -0,0 +1,4 @@
+#!/usr/bin/env bash
+# Run the crow-cli test suite (unit by default; pass extra pytest args, e.g.
+# ./run_tests.sh tests/integration --run-integration).
+cd "$(dirname "$0")" && exec uv --project . run pytest "$@"

{crow_cli-0.1.32 → crow_cli-0.1.34}/src/crow_cli/agent/compact.py

@@ -17,7 +17,7 @@ from logging import Logger
 
 from openai import AsyncOpenAI
 
-from crow_cli.agent.configure import Config
+from crow_cli.agent.configure import Config, sampling_params_for
 from crow_cli.agent.session import (
     AgentSession,
     make_agent_session,
@@ -123,16 +123,17 @@ async def compact(
     # 3. Append compaction prompt
     messages.append({"role": "user", "content": COMPACTION_PROMPT})
 
-    # 4. Send to LLM
-    request_params = dict(session.request_params)
-    request_params["max_tokens"] = MAX_OUTPUT_TOKENS
-
+    # 4. Send to LLM — same per-model sampling rule as the react loop: the
+    # model's reasoning_effort XOR temperature. Never the provider default
+    # (temp 1.0 makes the model ramble instead of compress) and never the
+    # session's request_params temperature.
     response = await llm.chat.completions.create(
         model=session.model_identifier,
         messages=messages,
         tools=session.tools if session.tools else None,
         tool_choice="none",
-        **request_params,
+        max_tokens=MAX_OUTPUT_TOKENS,
+        **sampling_params_for(config, session.model_identifier),
     )
     summary = response.choices[0].message.content
     usage = {

{crow_cli-0.1.32 → crow_cli-0.1.34}/src/crow_cli/agent/configure.py

@@ -10,10 +10,12 @@ import os
 import re
 from dataclasses import dataclass, field
 from pathlib import Path
-from typing import Any
+from typing import Any, Literal
 
 import yaml
+from crow_memory import normalize_db_uri
 from dotenv import load_dotenv
+from pydantic import BaseModel, ValidationError
 
 from crow_cli.agent.default import (
     COMPOSE_YAML,
@@ -88,6 +90,69 @@ def resolve_env_vars(value: Any, missing: set[str] | None = None) -> Any:
     return value
 
 
+# OpenAI reasoning models (gpt-5, o3, ...) accept `reasoning_effort` instead
+# of `temperature`. These are the enumerable values from the OpenAI API
+# reference (developers.openai.com): none, minimal, low, medium, high, xhigh,
+# max. We validate config.yaml against this set so a typo fails fast at load
+# time instead of as an opaque provider 400 mid-turn.
+ReasoningEffort = Literal["none", "minimal", "low", "medium", "high", "xhigh", "max"]
+REASONING_EFFORT_VALUES = ("none", "minimal", "low", "medium", "high", "xhigh", "max")
+
+# Per-model modality LIST — what the model can take as input. Default
+# ["text", "image"] = assume vision-capable until proven otherwise; a
+# text-only model gets ["text"]. audio/video are filled in by hand (or by a
+# probe) for models that natively take them (qwen3.x-max takes video).
+Modality = Literal["text", "image", "audio", "video"]
+MODALITY_VALUES = ("text", "image", "audio", "video")
+
+
+class ReasoningEffortModel(BaseModel):
+    """Validate a reasoning_effort value against OpenAI's enumerable set."""
+
+    reasoning_effort: ReasoningEffort
+
+
+def parse_reasoning_effort(raw: Any) -> str:
+    """Validate and normalize a config.yaml reasoning_effort value.
+
+    Raises ValueError naming the valid set when the value is not enumerable.
+    """
+    value = str(raw).strip().lower()
+    try:
+        return ReasoningEffortModel(reasoning_effort=value).reasoning_effort
+    except ValidationError:
+        raise ValueError(
+            f"reasoning_effort must be one of {', '.join(REASONING_EFFORT_VALUES)}, "
+            f"got {raw!r}"
+        ) from None
+
+
+def build_sampling_params(
+    reasoning_effort: str | None,
+    temperature: float,
+) -> dict[str, Any]:
+    """The one sampling rule for every LLM call (react loop AND compaction):
+    reasoning_effort when set — temperature omitted, reasoning models reject
+    it — else temperature. Never both, never neither (no provider defaults)."""
+    return (
+        {"reasoning_effort": reasoning_effort}
+        if reasoning_effort
+        else {"temperature": temperature}
+    )
+
+
+def sampling_params_for(config: "Config", model_id: str) -> dict[str, Any]:
+    """Per-model sampling rule for every LLM call (react loop AND compaction):
+    the configured model's reasoning_effort XOR temperature. Models not in
+    config get the defaults (temperature 0.6, no effort)."""
+    model = next(
+        (m for m in config.llm.models.values() if m.model_id == model_id), None
+    )
+    if model is None:
+        return {"temperature": 0.6}
+    return build_sampling_params(model.reasoning_effort, model.temperature)
+
+
 @dataclass
 class LLMProvider:
     name: str
@@ -100,9 +165,14 @@ class LLModel:
     name: str
     provider_name: str
     model_id: str
-    # None = unknown → assume capable of everything (permissive default).
-    # A set restricts: e.g. set() is text-only, {"vision"} handles images.
-    capabilities: set[str] | None = None
+    # Per-model sampling, XOR: reasoning_effort wins and temperature is
+    # omitted entirely (reasoning models reject it); else temperature.
+    temperature: float = 0.6
+    reasoning_effort: ReasoningEffort | None = None
+    # Input modalities. Assume vision-capable until proven otherwise;
+    # ["text"] models get image/audio/video blocks stripped / routed around
+    # (see model_routing).
+    modality: list[Modality] = field(default_factory=lambda: ["text", "image"])
     # Ordered fallback chain (model NAMES from this config) used when this
     # model cannot handle the modalities present in the conversation.
     fallbacks: list[str] = field(default_factory=list)
@@ -118,13 +188,12 @@ class LLMConfig:
 class Config:
     config_dir: Path
     llm: LLMConfig = field(default_factory=LLMConfig)
-    memory_path: str = ""
+    db_uri: str = ""
     skills_dir: str = str(SKILLS_DIR)
     mcp_servers: dict[str, Any] = field(default_factory=dict)
     max_retries_per_step: int = 3
     MAX_COMPACT_TOKENS: int = 190000
     MAX_TOKENS: int = 38192
-    TEMPERATURE: float = 0.6
     chunk_log: bool = False  # Write every raw chunk to JSONL for debugging
     system_prompt: str = SYSTEM_PROMPT
     system_prompt_path: Path | None = None
@@ -164,12 +233,21 @@ class Config:
             _logger.info("No config.yaml found, returning bare Config")
             return cls(
                 config_dir=target_dir,
-                memory_path=str(DEFAULT_CONFIG_DIR / "crow.db"),
+                db_uri=f"sqlite:///{DEFAULT_CONFIG_DIR / 'crow.db'}",
             )
 
         with open(config_file) as f:
             raw = yaml.safe_load(f) or {}
 
+        # Sampling is per-model now (see LLModel) — a leftover global would be
+        # silently ignored, so reject it with a migration hint instead.
+        for stale in ("TEMPERATURE", "reasoning_effort"):
+            if stale in raw:
+                raise ValueError(
+                    f"config.yaml: global {stale!r} was removed; set it per "
+                    f"model under models: (temperature / reasoning_effort)."
+                )
+
         _logger.info("RAW config.yaml mcpServers: %s", raw.get("mcpServers", {}))
         missing_vars: set[str] = set()
         parsed = resolve_env_vars(raw, missing_vars)
@@ -191,25 +269,47 @@ class Config:
 
         # Parse models
         for name, data in parsed.get("models", {}).items():
-            raw_caps = data.get("capabilities")
-            capabilities = set(raw_caps) if raw_caps is not None else None
+            raw_effort = data.get("reasoning_effort")
+            raw_modality = data.get("modality", ["text", "image"])
+            if isinstance(raw_modality, str):
+                raw_modality = [raw_modality]
+            if not isinstance(raw_modality, list):
+                raise ValueError(
+                    f"model {name!r}: modality must be a list, got {raw_modality!r}"
+                )
+            modality = [str(m).strip().lower() for m in raw_modality]
+            bad = [m for m in modality if m not in MODALITY_VALUES]
+            if bad:
+                raise ValueError(
+                    f"model {name!r}: modality entries must be one of "
+                    f"{', '.join(MODALITY_VALUES)}, got {bad}"
+                )
             llm.models[name] = LLModel(
                 name=name,
                 provider_name=data.get("provider", ""),
                 model_id=data.get("model", ""),
-                capabilities=capabilities,
+                temperature=float(data.get("temperature", 0.6)),
+                reasoning_effort=(
+                    parse_reasoning_effort(raw_effort)
+                    if raw_effort is not None
+                    else None
+                ),
+                modality=modality,
                 fallbacks=list(data.get("fallbacks") or []),
             )
 
-        # Parse overrides
-        memory_path = os.path.expanduser(parsed.get("memory_path") or "~/.agents/crow/crow.db")
+        # Parse overrides. db_uri is the canonical key; legacy memory_path
+        # (a plain path) still works and becomes a sqlite URI. Default is
+        # config_dir-relative so custom config dirs stay self-contained.
+        db_uri = normalize_db_uri(
+            parsed.get("db_uri") or parsed.get("memory_path") or str(target_dir / "crow.db")
+        )
         skills_dir = os.path.expanduser(parsed.get("skills_dir") or str(SKILLS_DIR))
         overrides = {}
         for key, typ in (
             ("max_retries_per_step", int),
             ("MAX_COMPACT_TOKENS", int),
             ("MAX_TOKENS", int),
-            ("TEMPERATURE", float),
         ):
             if key in parsed:
                 overrides[key] = typ(parsed[key])
@@ -225,7 +325,7 @@ class Config:
         return cls(
             config_dir=target_dir,
             llm=llm,
-            memory_path=memory_path,
+            db_uri=db_uri,
             skills_dir=skills_dir,
             mcp_servers=mcp_servers,
             system_prompt_path=system_prompt_path,

{crow_cli-0.1.32 → crow_cli-0.1.34}/src/crow_cli/agent/default/defaults.py

@@ -209,18 +209,20 @@ volumes:
     driver: local
 """
 
-CONFIG_YAML = """# config.yaml for the spec at
-# ../src/crow_acp/agent/config.py
+CONFIG_YAML = """# config.yaml — crow-cli configuration
+# (loaded by crow_cli/agent/configure.py)
 
 # DEFAULT mcpServers
 mcpServers:
-  crow-mcp-dev:
+  crow-mcp:
     transport: http
     url: http://127.0.0.1:2770/mcp
 
-# Memory is an in-process sqlite database (schema v3). Images are stored as
-# files next to it (images/) and hydrated to base64 only when sent to the LLM.
-memory_path: ~/.agents/crow/crow.db
+# Memory is a SQL database reached via a SQLAlchemy db_uri — sqlite by
+# default, any SQLAlchemy URI (e.g. postgresql://) works. Owned by the
+# crow-memory package. Images are stored as files next to it (images/) and
+# hydrated to base64 only when sent to the LLM.
+db_uri: sqlite:///~/.agents/crow/crow.db
 
 # Where agent skills live (one directory per skill, each with a SKILL.md).
 # Scanned at session creation and injected into the system prompt.
@@ -243,6 +245,19 @@ system_prompt_path: ~/.agents/crow/prompts/system_prompt.jinja2
 #   placeholder-model:
 #     provider: placeholder-provider
 #     model: gpt-3.5-turbo
+#     temperature: 0.6
+#     # reasoning_effort: medium
+#     modality: [text, image]
+
+# Per-model sampling (all optional):
+#   temperature     — sampling temperature, default 0.6
+#   reasoning_effort — for reasoning models (gpt-5, o3, ...). When set, crow
+#                      sends it and OMITS temperature (reasoning models reject
+#                      temperature). One of: none | minimal | low | medium |
+#                      high | xhigh | max
+#   modality        — list of input modalities (text | image | audio | video).
+#                     Default [text, image] = assume vision-capable until
+#                     proven otherwise; [text] = strip/route images around.
 
 # Compaction parameters
 MAX_COMPACT_TOKENS: 180000

{crow_cli-0.1.32 → crow_cli-0.1.34}/src/crow_cli/agent/main.py

@@ -183,7 +183,7 @@ class AcpAgent(Agent):
                 raise ValueError(
                     f"model {model!r} not found in config.yaml models: {valid}"
                 )
-        self._memory_path = self._config.memory_path
+        self._memory_db_uri = self._config.db_uri
         self._exit_stack = AsyncExitStack()
         self._agent_id: str | None = None
         self._session_id: str | None = None  # stripped version for ACP upstream
@@ -438,14 +438,14 @@ class AcpAgent(Agent):
 
         try:
             # Find the highest-indexed agent for this session
-            max_idx = await AgentSession.get_max_agent_idx(session_id, memory_path=self._memory_path)
+            max_idx = await AgentSession.get_max_agent_idx(session_id, memory_path=self._memory_db_uri)
             agent_id = f"{session_id}-{max_idx}"
             self._logger.info(
                 "LOAD_SESSION: Step 1: Loading agent %s from DB", agent_id
             )
             session = await AgentSession.load(
                 agent_id,
-                memory_path=self._memory_path,
+                memory_path=self._memory_db_uri,
             )
             self._logger.info("LOAD_SESSION: Step 1 complete: Agent loaded from DB")
 
@@ -553,7 +553,7 @@ class AcpAgent(Agent):
         if self._session_id == session_id and self._agent_id:
             agent_id = self._agent_id
         else:
-            max_idx = await AgentSession.get_max_agent_idx(session_id, memory_path=self._memory_path)
+            max_idx = await AgentSession.get_max_agent_idx(session_id, memory_path=self._memory_db_uri)
             agent_id = f"{session_id}-{max_idx}"
 
         # Initialize if not set
@@ -605,7 +605,7 @@ class AcpAgent(Agent):
         if self._session_id == session_id and self._agent_id:
             agent_id = self._agent_id
         else:
-            max_idx = await AgentSession.get_max_agent_idx(session_id, memory_path=self._memory_path)
+            max_idx = await AgentSession.get_max_agent_idx(session_id, memory_path=self._memory_db_uri)
             agent_id = f"{session_id}-{max_idx}"
 
         async def _execute_turn() -> PromptResponse:
@@ -839,21 +839,64 @@ class AcpAgent(Agent):
         return ListSessionsResponse(sessions=sessions, next_cursor=None)
 
 
+async def serve_http(
+    config: Config, model: str | None, host: str, port: int
+) -> None:
+    """Serve the agent over Streamable HTTP + WebSocket (experimental, same
+    JSON-RPC lifecycle as stdio). One AcpAgent instance per connection; all
+    instances share the sqlite session store, so any client can address the
+    same sessions."""
+    import hypercorn.asyncio
+    from acp.http.asgi import create_asgi_app
+    from hypercorn.config import Config as HypercornConfig
+
+    app = create_asgi_app(lambda conn: AcpAgent(config=config, model=model))
+    hcfg = HypercornConfig()
+    hcfg.bind = [f"{host}:{port}"]
+    # Streamable HTTP requires HTTP/2; hypercorn negotiates h2c/h2.
+    hcfg.alpn_protocols = ["h2", "http/1.1"]
+    await hypercorn.asyncio.serve(app, hcfg)
+
+
 async def agent_run(
     config_dir: Path | None = None,
     config: Config | None = None,
     debug: bool = False,
     model: str | None = None,
+    http: bool = False,
+    host: str = "127.0.0.1",
+    port: int = 2769,
 ) -> None:
     if config is None:
         config = Config.load(config_dir=config_dir)
     if debug:
         config.chunk_log = True
-    await run_agent(AcpAgent(config=config, model=model))
+    if http:
+        await serve_http(config, model, host, port)
+    else:
+        await run_agent(AcpAgent(config=config, model=model))
 
 
-def main(config_dir: Path | None = None, config: Config | None = None, debug: bool = False, model: str | None = None):
-    asyncio.run(agent_run(config_dir=config_dir, config=config, debug=debug, model=model))
+def main(
+    config_dir: Path | None = None,
+    config: Config | None = None,
+    debug: bool = False,
+    model: str | None = None,
+    http: bool = False,
+    host: str = "127.0.0.1",
+    port: int = 2769,
+):
+    asyncio.run(
+        agent_run(
+            config_dir=config_dir,
+            config=config,
+            debug=debug,
+            model=model,
+            http=http,
+            host=host,
+            port=port,
+        )
+    )
 
 
 if __name__ == "__main__":

{crow_cli-0.1.32 → crow_cli-0.1.34}/src/crow_cli/agent/memory.py

@@ -1,9 +1,11 @@
-"""Memory layer for crow-cli — in-process SQLite, images on disk.
+"""Memory layer for crow-cli — SQL via crow-memory, images on disk.
 
-Back to the pre-service design (schema v3 in db.py) with one wrinkle: image
-blobs never enter the database. Writes extract inline base64 blocks to
-``config_dir/images/<sha256hex><ext>`` and store ``image_ref`` blocks; loads
-with ``hydrate=True`` swap refs back to base64 data URLs for the LLM.
+The store contract lives in the ``crow-memory`` package (schema v4): this
+class only resolves the db_uri from config and wraps the sync helpers in the
+async shape session.py / main.py expect. One wrinkle: image blobs never
+enter the database. Writes extract inline base64 blocks to
+``<db parent>/images/<sha256hex><ext>`` and store ``image_ref`` blocks;
+loads with ``hydrate=True`` swap refs back to base64 data URLs for the LLM.
 
 Search is SQLite FTS5 + bm25 (keyword). No embeddings, no HTTP service.
 
@@ -13,11 +15,10 @@ sync db helpers.
 """
 
 import logging
-import os
 from dataclasses import dataclass, field
 from pathlib import Path
 
-from crow_cli.agent import db
+import crow_memory as db
 from crow_cli.agent.configure import Config
 
 log = logging.getLogger(__name__)
@@ -125,19 +126,26 @@ def _agent_record(a: db.Agent) -> AgentRecord:
 
 
 class MemoryClient:
-    """SQLite-backed memory. `path` is ignored (kept positionally for compat)."""
+    """crow-memory-backed store. `path` overrides the configured db_uri."""
 
     def __init__(self, path: str | None = None, config_dir: Path | None = None, **_kwargs):
         cfg = Config.load(config_dir)
-        db_path = Path(os.path.expanduser(path or str(cfg.config_dir / "crow.db")))
-        if db_path.is_dir():
-            raise MemoryServiceError(
-                500,
-                f"{db_path} is a directory (leftover lance dataset from the old "
-                "crow-memory service) — remove it so sqlite can own this path",
-            )
-        self.db_uri = f"sqlite:///{db_path}"
-        self.images_dir = db_path.parent / "images"
+        # DEFAULT_MEMORY_PATH is the legacy positional sentinel — it means
+        # "whatever the config says", not a literal override.
+        override = None if path in (None, DEFAULT_MEMORY_PATH) else path
+        self.db_uri = db.normalize_db_uri(override or cfg.db_uri)
+        if self.db_uri.startswith("sqlite:///"):
+            db_path = Path(self.db_uri.removeprefix("sqlite:///"))
+            if db_path.is_dir():
+                raise MemoryServiceError(
+                    500,
+                    f"{db_path} is a directory (leftover lance dataset from the old "
+                    "crow-memory service) — remove it so sqlite can own this path",
+                )
+            self.images_dir = db_path.parent / "images"
+        else:
+            # Non-file backends (e.g. postgres): images stay beside the config.
+            self.images_dir = cfg.config_dir / "images"
         db.create_database(self.db_uri)
         self._engine = db.get_engine(self.db_uri)
 

{crow_cli-0.1.32 → crow_cli-0.1.34}/src/crow_cli/agent/model_routing.py

@@ -3,14 +3,17 @@
 Conversations carry modalities (images, audio) that not every model accepts.
 Per request:
 
-1. Requested model's capabilities unknown (unset in config) or covering the
-   present modalities → use it unchanged.
+1. Requested model's modality list covers the present modalities (the
+   default ["text", "image"] assumes vision-capable until proven otherwise)
+   or no images are present → use it unchanged.
 2. Otherwise walk the model's `fallbacks` chain and take the first model
-   capable of every present modality. The LLM client is bound to one
-   provider, so only same-provider fallbacks are considered.
+   whose list covers them. The LLM client is bound to one provider, so only
+   same-provider fallbacks are considered.
 3. No capable model anywhere → keep the requested model and report which
    modalities to strip; send_request replaces those blocks with placeholders
    (auto-strip on downgrade) instead of hard-failing.
+
+Only image blocks are routed for now; audio/video are not mapped.
 """
 
 from __future__ import annotations
@@ -22,17 +25,15 @@ from crow_cli.agent.configure import Config
 
 logger = logging.getLogger(__name__)
 
-# OpenAI chat-completions content block type -> modality
+# OpenAI chat-completions content block type -> modality (image only for now;
+# audio/video blocks are not routed yet)
 BLOCK_MODALITIES: dict[str, str] = {
-    "image_url": "vision",
-    "image": "vision",
-    "input_audio": "audio",
-    "audio": "audio",
+    "image_url": "image",
+    "image": "image",
 }
 
 PLACEHOLDERS: dict[str, str] = {
-    "vision": "[image omitted: model has no vision capability]",
-    "audio": "[audio omitted: model has no audio capability]",
+    "image": "[image omitted: model has no image capability]",
 }
 
 
@@ -58,8 +59,9 @@ def _model_by_id(config: Config, model_id: str):
 
 
 def _capable(model, modalities: set[str]) -> bool:
-    # Unknown capabilities (None) = permissive: assume the model handles it.
-    return model.capabilities is None or modalities <= model.capabilities
+    # Default ["text", "image"] = permissive: assume vision-capable until
+    # proven otherwise; ["text"] models fail the subset check for images.
+    return modalities <= set(model.modality)
 
 
 def route_model(