docagent-cli 0.0.35__py3-none-any.whl

docagent_cli/configurable_model.py

@@ -0,0 +1,162 @@
+"""CLI middleware for runtime model selection via LangGraph runtime context.
+
+Allows switching the model per invocation by passing a `CLIContext` via
+`context=` on `agent.astream()` / `agent.invoke()` without recompiling
+the graph.
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING, Any
+
+from deepagents._models import model_matches_spec  # noqa: PLC2701
+from langchain.agents.middleware.types import (
+    AgentMiddleware,
+    ModelRequest,
+    ModelResponse,
+)
+
+if TYPE_CHECKING:
+    from collections.abc import Awaitable, Callable
+
+
+logger = logging.getLogger(__name__)
+
+
+def _is_anthropic_model(model: object) -> bool:
+    """Check whether a resolved model reports `'anthropic'` as its provider.
+
+    Uses `_get_ls_params` from `BaseChatModel` to read the provider name.
+
+    Returns:
+        `True` if the model's `ls_provider` is `'anthropic'`.
+    """
+    try:
+        ls_params = model._get_ls_params()  # type: ignore[attr-defined]
+    except (AttributeError, TypeError, RuntimeError):
+        logger.debug(
+            "_get_ls_params raised for %s; assuming non-Anthropic",
+            type(model).__name__,
+        )
+        return False
+    return isinstance(ls_params, dict) and ls_params.get("ls_provider") == "anthropic"
+
+
+_ANTHROPIC_ONLY_SETTINGS: set[str] = {"cache_control"}
+"""Keys injected by Anthropic-specific middleware (e.g.
+`AnthropicPromptCachingMiddleware`) that are not accepted by other providers and
+must be stripped on cross-provider swap."""
+
+
+def _apply_overrides(request: ModelRequest) -> ModelRequest:
+    """Apply model/param overrides from `CLIContext` on the runtime.
+
+    Returns:
+        The original request unchanged when no `CLIContext` is present or it
+            contains no overrides, otherwise a new request with overrides.
+    """
+    runtime = request.runtime
+    if runtime is None:
+        return request
+
+    ctx = runtime.context
+    if not isinstance(ctx, dict):
+        return request
+
+    overrides: dict[str, Any] = {}
+
+    # Model swap
+    new_model = None
+    model = ctx.get("model")
+    if model and not model_matches_spec(request.model, model):
+        from docagent_cli.config import create_model
+        from docagent_cli.model_config import ModelConfigError
+
+        logger.debug("Overriding model to %s", model)
+        try:
+            model_result = create_model(model)
+            new_model = model_result.model
+        except ModelConfigError:
+            logger.exception(
+                "Failed to resolve runtime model override '%s'; "
+                "continuing with current model",
+                model,
+            )
+            return request
+        overrides["model"] = new_model
+
+    # Param merge
+    model_params = ctx.get("model_params", {})
+    if model_params:
+        overrides["model_settings"] = {**request.model_settings, **model_params}
+
+    if not overrides:
+        return request
+
+    # When switching away from Anthropic, strip provider-specific settings
+    # that would cause errors on other providers (e.g. cache_control passed
+    # to the OpenAI SDK raises TypeError).
+    if new_model is not None and not _is_anthropic_model(new_model):
+        settings = overrides.get("model_settings", request.model_settings)
+        dropped = settings.keys() & _ANTHROPIC_ONLY_SETTINGS
+        if dropped:
+            logger.debug(
+                "Stripped Anthropic-only settings %s for non-Anthropic model",
+                dropped,
+            )
+            overrides["model_settings"] = {
+                k: v for k, v in settings.items() if k not in dropped
+            }
+
+    # Patch the Model Identity section in the system prompt so the new model
+    # sees its own name/provider/context-limit, not the original's.
+    # We read metadata from model_result (not the CLI settings singleton)
+    # because the middleware runs in the server subprocess where settings
+    # are never updated by /model.
+    if new_model is not None and request.system_prompt:
+        from docagent_cli.agent import (
+            MODEL_IDENTITY_RE,
+            build_model_identity_section,
+        )
+
+        prompt = request.system_prompt
+        new_identity = build_model_identity_section(
+            model_result.model_name,
+            provider=model_result.provider,
+            context_limit=model_result.context_limit,
+            unsupported_modalities=model_result.unsupported_modalities,
+        )
+        patched = MODEL_IDENTITY_RE.sub(new_identity, prompt, count=1)
+        if patched != prompt:
+            overrides["system_prompt"] = patched
+        elif "### Model Identity" in prompt:
+            logger.warning(
+                "System prompt contains '### Model Identity' but regex "
+                "did not match; identity section was NOT updated for "
+                "model '%s'. The regex may be out of sync with the "
+                "prompt template.",
+                model_result.model_name,
+            )
+
+    return request.override(**overrides)
+
+
+class ConfigurableModelMiddleware(AgentMiddleware):
+    """Swap the model or per-call settings from `runtime.context`."""
+
+    def wrap_model_call(  # noqa: PLR6301
+        self,
+        request: ModelRequest,
+        handler: Callable[[ModelRequest], ModelResponse],
+    ) -> ModelResponse:
+        """Apply runtime overrides and delegate to the next handler."""  # noqa: DOC201
+        return handler(_apply_overrides(request))
+
+    async def awrap_model_call(  # noqa: PLR6301
+        self,
+        request: ModelRequest,
+        handler: Callable[[ModelRequest], Awaitable[ModelResponse]],
+    ) -> ModelResponse:
+        """Apply runtime overrides and delegate to the next async handler."""  # noqa: DOC201
+        return await handler(_apply_overrides(request))

docagent_cli/default_agent_prompt.md

@@ -0,0 +1,12 @@
+# Project Notes
+
+This file is for tracking project-specific context as you work.
+You can update this file to remember decisions, patterns, and context about this project.
+
+## Architecture Notes
+
+(Add notes about project structure, key files, patterns as you discover them)
+
+## Decisions
+
+(Track important decisions and their rationale)

docagent_cli/editor.py

@@ -0,0 +1,142 @@
+"""External editor support for composing prompts."""
+
+from __future__ import annotations
+
+import contextlib
+import logging
+import os
+import shlex
+import subprocess  # noqa: S404
+import sys
+import tempfile
+from pathlib import Path
+
+logger = logging.getLogger(__name__)
+
+GUI_WAIT_FLAG: dict[str, str] = {
+    "code": "--wait",
+    "cursor": "--wait",
+    "zed": "--wait",
+    "atom": "--wait",
+    "subl": "-w",
+    "windsurf": "--wait",
+}
+"""Mapping of GUI editor base names to their blocking flag."""
+
+VIM_EDITORS = {"vi", "vim", "nvim"}
+"""Set of vim-family editor base names that receive the `-i NONE` flag."""
+
+
+def resolve_editor() -> list[str] | None:
+    """Resolve editor command from environment.
+
+    Checks $VISUAL, then $EDITOR, then falls back to platform default.
+
+    Returns:
+        Tokenized command list, or `None` if the env var was set but empty after
+            tokenization.
+    """
+    editor = os.environ.get("VISUAL") or os.environ.get("EDITOR")
+    if not editor:
+        if sys.platform == "win32":
+            return ["notepad"]
+        return ["vi"]
+    tokens = shlex.split(editor)
+    return tokens or None
+
+
+def _prepare_command(cmd: list[str], filepath: str) -> list[str]:
+    """Build the full command list with appropriate flags.
+
+    Adds --wait/-w for GUI editors and `-i NONE` for vim-family editors.
+
+    Returns:
+        The complete command list with flags and filepath appended.
+    """
+    cmd = list(cmd)  # copy
+    exe = Path(cmd[0]).stem.lower()
+
+    # Auto-inject wait flag for GUI editors
+    if exe in GUI_WAIT_FLAG:
+        flag = GUI_WAIT_FLAG[exe]
+        if flag not in cmd:
+            cmd.insert(1, flag)
+
+    # Vim workaround: avoid viminfo errors in temp environments
+    if exe in VIM_EDITORS and "-i" not in cmd:
+        cmd.extend(["-i", "NONE"])
+
+    cmd.append(filepath)
+    return cmd
+
+
+def open_in_editor(current_text: str) -> str | None:
+    """Open current_text in an external editor.
+
+    Creates a temp .md file, launches the editor, and reads back the result.
+
+    Args:
+        current_text: The text to pre-populate in the editor.
+
+    Returns:
+        The edited text with normalized line endings, or `None` if the editor
+            exited with a non-zero status, was not found, or the result was
+            empty/whitespace-only.
+    """
+    cmd = resolve_editor()
+    if cmd is None:
+        return None
+
+    tmp_path: str | None = None
+    try:
+        with tempfile.NamedTemporaryFile(
+            suffix=".md",
+            prefix="docagent-edit-",
+            delete=False,
+            mode="w",
+            encoding="utf-8",
+        ) as tmp:
+            tmp_path = tmp.name
+            tmp.write(current_text)
+
+        full_cmd = _prepare_command(cmd, tmp_path)
+
+        # S603: editor command comes from user's own $EDITOR env var
+        result = subprocess.run(  # noqa: S603
+            full_cmd,
+            stdin=sys.stdin,
+            stdout=sys.stdout,
+            stderr=sys.stderr,
+            check=False,
+        )
+        if result.returncode != 0:
+            logger.warning(
+                "Editor exited with code %d: %s", result.returncode, full_cmd
+            )
+            return None
+
+        edited = Path(tmp_path).read_text(encoding="utf-8")
+
+        # Normalize line endings
+        edited = edited.replace("\r\n", "\n").replace("\r", "\n")
+
+        # Most editors append a final newline on save (POSIX convention).
+        # Strip exactly one so the cursor lands on content, not a blank line,
+        # while preserving any intentional trailing newlines the user added.
+        edited = edited.removesuffix("\n")
+
+        # Treat empty result as cancellation
+        if not edited.strip():
+            return None
+
+    except FileNotFoundError:
+        return None
+    except Exception:
+        logger.warning("Editor failed", exc_info=True)
+        return None
+    else:
+        return edited
+    finally:
+        if tmp_path is not None:
+            with contextlib.suppress(OSError):
+                Path(tmp_path).unlink(missing_ok=True)