agentshim 0.6.0__tar.gz → 0.6.1__tar.gz

{agentshim-0.6.0 → agentshim-0.6.1}/CHANGELOG.md

@@ -1,5 +1,58 @@
 # Changelog
 
+## 0.6.1 (2026-09-10)
+
+Additive only: every new field defaults, so a 0.6.0 consumer's existing
+`ProviderProfile` construction and every shipped provider keep working
+unchanged.
+
+`ProviderProfile` gains four fields:
+
+- `container_env: Mapping[str, str]` (default empty): environment a CLI
+  needs to run as root in a container, beyond auth. Claude Code sets
+  `IS_SANDBOX=1`, which it requires before accepting
+  `--dangerously-skip-permissions` as root; the other four providers need
+  nothing extra.
+- `state_root_env: str | None` (default `None`): the CLI's own documented
+  variable for relocating its primary state directory (`state_dirs[0]`).
+  `CLAUDE_CONFIG_DIR` for Claude, `CODEX_HOME` for Codex, `COPILOT_HOME` for
+  Copilot; `None` for Gemini and opencode, which document no such variable.
+- `auth_files: tuple[str, ...]` (default empty): home-relative paths to the
+  files that hold credentials and user configuration, the minimal set to
+  copy into another environment so the CLI is already logged in. Every entry
+  lies inside a `state_dirs` entry.
+- `mcp_config_file: str | None` (default `None`): for a `CONFIG_FILE`
+  provider, the workspace-relative path its MCP config is written to for a
+  turn (`.mcp.json`, `.gemini/settings.json`, `opencode.json`). The provider
+  module defines it as the same constant `install_mcp` writes to, so the two
+  cannot drift. `None` for `CLI_FLAGS`/`NONE` providers.
+
+`tests/unit/providers/test_conventions.py` pins these across every provider:
+`auth_files` entries lie inside `state_dirs`, `mcp_config_file` is set
+exactly when `mcp` is `CONFIG_FILE` and matches where `install_mcp` actually
+writes, `state_root_env` is uppercase when set, and `container_env` keys are
+uppercase.
+
+### Added
+
+- `agentshim.testing.scripted_resume_failure(provider, *, session_id=None)`:
+  a `FakeRun` that fails the way *provider* recognises a lost resumed
+  conversation, so a consumer can test `SessionResumeError` handling without
+  knowing any provider's wire format. Backed by a required
+  `resume_failure_lines(...)` entry in every `providers/<name>/scripted.py`,
+  found through `providers.get_resume_failure_lines(name)` the same way
+  `scripted_turn` finds `scripted_lines`, so a new provider cannot ship
+  without one.
+- `agentshim.testing.installed_mcp_servers(provider, request, workspace)`:
+  the MCP servers one turn installed, keyed by server name, each normalized
+  to `command`/`args`/`env` (stdio) or `url`/`transport` (HTTP) regardless of
+  how the provider itself renders it. Reads the config file for a
+  CONFIG_FILE provider and parses `request.argv` for a CLI_FLAGS one, via a
+  `parse_mcp_servers` kept next to the renderer it inverts
+  (`providers/codex/provider.py`, `providers/copilot/provider.py`). Meant to
+  be called from inside a `FakeExecutor` `run` callback: a CONFIG_FILE
+  provider's config exists only for the lifetime of the turn.
+
 ## 0.6.0
 
 A restructure, not an upgrade. 0.6 replaces the whole public API of 0.5 and

{agentshim-0.6.0 → agentshim-0.6.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: agentshim
-Version: 0.6.0
+Version: 0.6.1
 Summary: Provider-agnostic coding-agent CLI shims
 Requires-Python: >=3.10
 Provides-Extra: test

agentshim-0.6.1/agentshim/core/profile.py

@@ -0,0 +1,89 @@
+"""Declared provider capabilities.
+
+Every optional behaviour is declared here (or on a protocol) so no caller
+has to probe a provider object for attributes.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from enum import Enum
+from types import MappingProxyType
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from collections.abc import Mapping
+
+
+class McpMechanism(Enum):
+    """How a provider is told about MCP servers."""
+
+    NONE = "none"
+    CONFIG_FILE = "config_file"
+    CLI_FLAGS = "cli_flags"
+
+
+class OutputSchemaStyle(Enum):
+    """How a provider accepts a JSON Schema for structured output."""
+
+    NONE = "none"
+    INLINE_JSON = "inline_json"
+    FILE_PATH = "file_path"
+
+
+class SchemaDialect(Enum):
+    """Which JSON Schema subset a provider accepts.
+
+    ``STRICT`` is Codex's ``--output-schema`` subset: every object declares
+    its properties and forbids undeclared keys. ``OPEN`` also accepts a
+    schema-valued or ``true`` ``additionalProperties``.
+    """
+
+    STRICT = "strict"
+    OPEN = "open"
+
+
+def _no_container_env() -> Mapping[str, str]:
+    """Empty read-only default: a frozen spec must not carry a mutable one.
+
+    A factory rather than a shared constant because Python 3.10 and 3.11
+    reject an unhashable dataclass default, and ``mappingproxy`` is one. See
+    ``agentshim.core.mcp._no_env`` for the same pattern.
+    """
+    return MappingProxyType({})
+
+
+@dataclass(frozen=True)
+class ProviderProfile:
+    """Everything a caller needs to know about a provider without running it.
+
+    The last four fields are additive (0.6.1+) and all default, so an
+    existing keyword-built ``ProviderProfile`` keeps working unchanged.
+    ``container_env`` is environment a CLI needs to run as root in a
+    container, beyond auth (e.g. Claude Code's ``IS_SANDBOX=1``).
+    ``state_root_env`` is the documented variable that relocates
+    ``state_dirs[0]``, or ``None`` when the CLI names none. ``auth_files`` are
+    the home-relative paths, each inside a ``state_dirs`` entry, whose
+    contents are the minimal set to copy so the CLI is logged in elsewhere.
+    ``mcp_config_file`` is the workspace-relative path a ``CONFIG_FILE``
+    provider writes its MCP config to for a turn, and ``None`` for
+    ``CLI_FLAGS``/``NONE`` providers.
+    """
+
+    name: str
+    display_name: str
+    binary: str
+    supports_resume: bool
+    supports_reasoning_effort: bool
+    mcp: McpMechanism
+    output_schema: OutputSchemaStyle
+    schema_dialect: SchemaDialect | None
+    state_dirs: tuple[str, ...]
+    darwin_state_dirs: tuple[str, ...]
+    auth_env_vars: tuple[str, ...]
+    skill_dirs: tuple[str, ...]
+    container_install: tuple[str, ...]
+    container_env: Mapping[str, str] = field(default_factory=_no_container_env)
+    state_root_env: str | None = None
+    auth_files: tuple[str, ...] = ()
+    mcp_config_file: str | None = None

{agentshim-0.6.0 → agentshim-0.6.1}/agentshim/providers/__init__.py

@@ -11,14 +11,19 @@ from __future__ import annotations
 from typing import TYPE_CHECKING, Any, Protocol
 
 from .claude import ClaudeProvider
+from .claude import resume_failure_lines as _claude_resume_failure
 from .claude import scripted_lines as _claude_scripted
 from .codex import CodexProvider
+from .codex import resume_failure_lines as _codex_resume_failure
 from .codex import scripted_lines as _codex_scripted
 from .copilot import CopilotProvider
+from .copilot import resume_failure_lines as _copilot_resume_failure
 from .copilot import scripted_lines as _copilot_scripted
 from .gemini import GeminiProvider
+from .gemini import resume_failure_lines as _gemini_resume_failure
 from .gemini import scripted_lines as _gemini_scripted
 from .opencode import OpencodeProvider
+from .opencode import resume_failure_lines as _opencode_resume_failure
 from .opencode import scripted_lines as _opencode_scripted
 
 if TYPE_CHECKING:
@@ -49,6 +54,21 @@ class ScriptedLines(Protocol):
         ...
 
 
+class ResumeFailureLines(Protocol):
+    """Builds the stdout, stderr and exit code of a resumed turn gone bad."""
+
+    def __call__(
+        self, *, session_id: str | None = None
+    ) -> tuple[Sequence[str], Sequence[str], int]:
+        """Return ``(stdout, stderr, returncode)`` for a ``FakeRun``.
+
+        ``session_id`` is folded into the scripted message for realism only;
+        what a resumed turn's ``classify_exit`` actually reports comes from
+        the turn's own argv.
+        """
+        ...
+
+
 # To add a provider: implement providers/<name>/ (provider.py, parser.py,
 # events.py, scripted.py) and add one entry to each dict below.
 _FACTORIES: dict[str, Callable[[], Provider]] = {
@@ -67,6 +87,14 @@ _SCRIPTED: dict[str, ScriptedLines] = {
     "opencode": _opencode_scripted,
 }
 
+_RESUME_FAILURES: dict[str, ResumeFailureLines] = {
+    "claude": _claude_resume_failure,
+    "codex": _codex_resume_failure,
+    "copilot": _copilot_resume_failure,
+    "gemini": _gemini_resume_failure,
+    "opencode": _opencode_resume_failure,
+}
+
 
 def provider_names() -> list[str]:
     """Return the supported provider names, sorted."""
@@ -91,14 +119,27 @@ def get_scripted_lines(name: str) -> ScriptedLines:
     return scripted
 
 
+def get_resume_failure_lines(name: str) -> ResumeFailureLines:
+    """Return the test-double resume-failure builder for *name*."""
+    resume_failure = _RESUME_FAILURES.get(name)
+    if resume_failure is None:
+        msg = (
+            f"no resume-failure stream for provider {name!r}; available: {sorted(_RESUME_FAILURES)}"
+        )
+        raise ValueError(msg)
+    return resume_failure
+
+
 __all__ = [
     "ClaudeProvider",
     "CodexProvider",
     "CopilotProvider",
     "GeminiProvider",
     "OpencodeProvider",
+    "ResumeFailureLines",
     "ScriptedLines",
     "get_provider",
+    "get_resume_failure_lines",
     "get_scripted_lines",
     "provider_names",
 ]

{agentshim-0.6.0 → agentshim-0.6.1}/agentshim/providers/claude/__init__.py

@@ -5,7 +5,7 @@ from __future__ import annotations
 from .parser import ClaudeStreamParser
 from .provider import PROFILE, ClaudeProvider, mcp_entry
 from .sandbox import SandboxConfig, build_settings, resolve_sandbox
-from .scripted import scripted_lines
+from .scripted import resume_failure_lines, scripted_lines
 
 __all__ = [
     "PROFILE",
@@ -15,5 +15,6 @@ __all__ = [
     "build_settings",
     "mcp_entry",
     "resolve_sandbox",
+    "resume_failure_lines",
     "scripted_lines",
 ]

{agentshim-0.6.0 → agentshim-0.6.1}/agentshim/providers/claude/provider.py

@@ -50,6 +50,18 @@ PROFILE = ProviderProfile(
         # The installer drops the binary in /root/.local/bin.
         "ln -sf /root/.local/bin/claude /usr/local/bin/claude",
     ),
+    # Claude Code refuses --dangerously-skip-permissions as root unless this
+    # is set.
+    container_env={"IS_SANDBOX": "1"},
+    # Documented Claude Code variable that relocates ~/.claude.
+    state_root_env="CLAUDE_CONFIG_DIR",
+    auth_files=(
+        ".claude/.credentials.json",
+        ".claude/settings.json",
+        ".claude/settings.local.json",
+        ".claude.json",
+    ),
+    mcp_config_file=MCP_CONFIG_FILENAME,
 )
 
 

{agentshim-0.6.0 → agentshim-0.6.1}/agentshim/providers/claude/scripted.py

@@ -81,6 +81,27 @@ def scripted_lines(
     return lines
 
 
+def resume_failure_lines(*, session_id: str | None = None) -> tuple[list[str], list[str], int]:
+    """Build the stdout, stderr and exit code of a resumed turn Claude cannot continue.
+
+    ``ClaudeProvider.classify_exit`` treats any nonzero exit of a resumed
+    turn as ``SessionResumeError``: ``claude --resume`` gives no
+    distinguishable exit code for a missing transcript, so a bare failure on
+    stderr is enough to trigger it. ``session_id`` is folded into the message
+    for realism only; the id ``SessionResumeError`` actually reports comes
+    from the resumed turn's own argv, not from anything scripted here.
+
+    Args:
+        session_id: Conversation id to name in the scripted stderr message.
+
+    Returns:
+        ``(stdout, stderr, returncode)`` for a ``FakeRun``.
+    """
+    detail = f" {session_id}" if session_id else ""
+    stderr = [f"Error: no conversation found to resume{detail}\n"]
+    return [], stderr, 1
+
+
 def _usage_payload(usage: TokenUsage | None) -> dict[str, int]:
     if usage is None:
         return {

{agentshim-0.6.0 → agentshim-0.6.1}/agentshim/providers/codex/__init__.py

@@ -3,12 +3,14 @@
 from __future__ import annotations
 
 from .parser import CodexStreamParser
-from .provider import PROFILE, CodexProvider
-from .scripted import scripted_lines
+from .provider import PROFILE, CodexProvider, parse_mcp_servers
+from .scripted import resume_failure_lines, scripted_lines
 
 __all__ = [
     "PROFILE",
     "CodexProvider",
     "CodexStreamParser",
+    "parse_mcp_servers",
+    "resume_failure_lines",
     "scripted_lines",
 ]

{agentshim-0.6.0 → agentshim-0.6.1}/agentshim/providers/codex/provider.py

@@ -2,7 +2,8 @@
 
 from __future__ import annotations
 
-from typing import TYPE_CHECKING
+import re
+from typing import TYPE_CHECKING, Any
 
 from agentshim.core.errors import ProviderCapabilityError, SessionResumeError
 from agentshim.core.mcp import FlagsInstallation, HttpMcpServer, NoopInstallation
@@ -71,6 +72,13 @@ PROFILE = ProviderProfile(
     auth_env_vars=("OPENAI_API_KEY", "OPENAI_BASE_URL"),
     skill_dirs=(".agents/skills",),
     container_install=(_NODE_INSTALL, _CODEX_INSTALL),
+    # Documented Codex CLI variable that relocates ~/.codex (``codex --help``:
+    # "Layer $CODEX_HOME/<name>.config.toml on top of the base user config";
+    # "auth still uses CODEX_HOME").
+    state_root_env="CODEX_HOME",
+    auth_files=(".codex/auth.json", ".codex/config.toml"),
+    # CLI_FLAGS: Codex takes MCP servers as --config overrides, never a file.
+    mcp_config_file=None,
 )
 
 
@@ -199,3 +207,93 @@ def _toml_str(value: str) -> str:
 def _toml_array(values: Sequence[str]) -> str:
     """Render a sequence of strings as a TOML inline array."""
     return "[" + ",".join(_toml_str(value) for value in values) + "]"
+
+
+_CONFIG_OVERRIDE_RE = re.compile(r"^mcp_servers\.([^.=]+)\.(.+)$")
+_TOML_STRING_RE = re.compile(r'"((?:[^"\\]|\\.)*)"')
+
+
+def parse_mcp_servers(argv: Sequence[str]) -> dict[str, dict[str, Any]]:
+    """Recover the MCP servers rendered into *argv* by ``_server_flags``.
+
+    The inverse of that renderer, kept next to it so the two cannot drift:
+    walks the ``--config mcp_servers.<key>.<field>=<value>`` overrides this
+    provider emits and rebuilds one canonical entry per server. A stdio
+    server comes back as ``command``, ``args`` and ``env``; an HTTP one as
+    ``url`` and ``transport`` (always ``"http"``, since a ``--config``
+    override carries only the address and this provider cannot express any
+    other transport).
+
+    Args:
+        argv: The argv a turn actually ran, as recorded on a ``CommandRequest``.
+
+    Returns:
+        One canonical entry per server, keyed by the dotted-path name
+        ``_server_flags`` gave it (``-`` already mangled to ``_``).
+    """
+    servers: dict[str, dict[str, Any]] = {}
+    for key, field, raw_value in _mcp_config_overrides(argv):
+        _apply_mcp_override(servers.setdefault(key, {}), field, raw_value)
+    for entry in servers.values():
+        if "url" not in entry:
+            entry.setdefault("args", [])
+            entry.setdefault("env", {})
+    return servers
+
+
+def _mcp_config_overrides(argv: Sequence[str]) -> list[tuple[str, str, str]]:
+    """Pull every ``mcp_servers.<key>.<field>=<value>`` override out of *argv*."""
+    args = list(argv)
+    overrides: list[tuple[str, str, str]] = []
+    for index, arg in enumerate(args):
+        if arg != "--config" or index + 1 >= len(args):
+            continue
+        path, sep, raw_value = args[index + 1].partition("=")
+        if not sep:
+            continue
+        match = _CONFIG_OVERRIDE_RE.match(path)
+        if match is not None:
+            key, field = match.groups()
+            overrides.append((key, field, raw_value))
+    return overrides
+
+
+def _apply_mcp_override(entry: dict[str, Any], field: str, raw_value: str) -> None:
+    """Fold one dotted-path override into the entry being rebuilt for it."""
+    if field == "command":
+        entry["command"] = _parse_toml_str(raw_value)
+    elif field == "args":
+        entry["args"] = _parse_toml_array(raw_value)
+    elif field == "url":
+        entry["url"] = _parse_toml_str(raw_value)
+        entry["transport"] = "http"
+    elif field.startswith("env."):
+        entry.setdefault("env", {})[field.removeprefix("env.")] = _parse_toml_str(raw_value)
+
+
+def _parse_toml_str(literal: str) -> str:
+    """Reverse ``_toml_str``: unescape one TOML basic string literal."""
+    match = _TOML_STRING_RE.fullmatch(literal)
+    if match is None:
+        return literal
+    return _unescape_toml(match.group(1))
+
+
+def _parse_toml_array(literal: str) -> list[str]:
+    """Reverse ``_toml_array``: unescape every string in a TOML inline array."""
+    return [_unescape_toml(inner) for inner in _TOML_STRING_RE.findall(literal)]
+
+
+def _unescape_toml(escaped: str) -> str:
+    """Undo the backslash-escaping ``_toml_str`` applies to a string body."""
+    result: list[str] = []
+    index = 0
+    while index < len(escaped):
+        char = escaped[index]
+        if char == "\\" and index + 1 < len(escaped):
+            result.append(escaped[index + 1])
+            index += 2
+        else:
+            result.append(char)
+            index += 1
+    return "".join(result)

{agentshim-0.6.0 → agentshim-0.6.1}/agentshim/providers/codex/scripted.py

@@ -85,6 +85,25 @@ def scripted_lines(
     return lines
 
 
+def resume_failure_lines(*, session_id: str | None = None) -> tuple[list[str], list[str], int]:
+    """Build the stdout, stderr and exit code of a resumed turn with no rollout.
+
+    ``CodexProvider.classify_exit`` is the one provider that names its
+    failure explicitly: it matches "thread/resume failed" and "no rollout
+    found" on stderr, so unlike the other providers a plain nonzero exit is
+    not enough here; the message has to say so.
+
+    Args:
+        session_id: Thread id to name in the scripted stderr message.
+
+    Returns:
+        ``(stdout, stderr, returncode)`` for a ``FakeRun``.
+    """
+    thread = session_id or "unknown-thread"
+    stderr = [f"thread/resume failed: no rollout found for thread {thread}\n"]
+    return [], stderr, 1
+
+
 def _usage_payload(usage: TokenUsage | None) -> dict[str, int]:
     if usage is None:
         return {"input_tokens": 0, "cached_input_tokens": 0, "output_tokens": 0}

{agentshim-0.6.0 → agentshim-0.6.1}/agentshim/providers/copilot/__init__.py

@@ -3,13 +3,15 @@
 from __future__ import annotations
 
 from .parser import CopilotStreamParser
-from .provider import PROFILE, CopilotProvider, mcp_entry
-from .scripted import scripted_lines
+from .provider import PROFILE, CopilotProvider, mcp_entry, parse_mcp_servers
+from .scripted import resume_failure_lines, scripted_lines
 
 __all__ = [
     "PROFILE",
     "CopilotProvider",
     "CopilotStreamParser",
     "mcp_entry",
+    "parse_mcp_servers",
+    "resume_failure_lines",
     "scripted_lines",
 ]

{agentshim-0.6.0 → agentshim-0.6.1}/agentshim/providers/copilot/provider.py

@@ -11,7 +11,7 @@ from agentshim.core.profile import McpMechanism, OutputSchemaStyle, ProviderProf
 from .parser import CopilotStreamParser
 
 if TYPE_CHECKING:
-    from collections.abc import Callable, Sequence
+    from collections.abc import Callable, Mapping, Sequence
     from pathlib import Path
 
     from agentshim.core.errors import AgentShimError, CliExitError
@@ -47,6 +47,19 @@ PROFILE = ProviderProfile(
     skill_dirs=(".github/skills",),
     # The npm package ships the CLI; the image supplies node and npm.
     container_install=("npm install -g @github/copilot",),
+    # ``COPILOT_HOME`` relocates ~/.copilot; documented above and by
+    # ``copilot help environment``.
+    state_root_env="COPILOT_HOME",
+    # Copilot documents no specific credential filenames. ``.copilot/`` on a
+    # logged-in install holds ``config.json`` (opaque, not plain JSON; most
+    # likely where the login state lives) and ``settings.json`` (user
+    # config, e.g. the chosen model); ``.config/github-copilot/`` on the same
+    # install held only ``versions.json``, which is not credential-bearing,
+    # so it is left out.
+    auth_files=(".copilot/config.json", ".copilot/settings.json"),
+    # CLI_FLAGS: Copilot takes MCP servers as one --additional-mcp-config
+    # flag, never a file.
+    mcp_config_file=None,
 )
 
 
@@ -132,3 +145,37 @@ def mcp_entry(server: McpServer) -> dict[str, Any]:
     if stdio.env:
         rendered["env"] = dict(stdio.env)
     return rendered
+
+
+def parse_mcp_servers(argv: Sequence[str]) -> dict[str, dict[str, Any]]:
+    """Recover the MCP servers rendered into *argv* by ``install_mcp``.
+
+    The inverse of ``mcp_entry``, kept next to it so the two cannot drift:
+    reads the ``--additional-mcp-config`` flag's JSON payload back and maps
+    each entry to the canonical shape ``installed_mcp_servers`` returns.
+
+    Args:
+        argv: The argv a turn actually ran, as recorded on a ``CommandRequest``.
+
+    Returns:
+        One canonical entry per server, keyed by server name.
+    """
+    args = list(argv)
+    if MCP_CONFIG_FLAG not in args:
+        return {}
+    index = args.index(MCP_CONFIG_FLAG)
+    if index + 1 >= len(args):
+        return {}
+    config = json.loads(args[index + 1])
+    servers = config.get(MCP_SERVER_KEY, {})
+    return {name: _canonical_entry(raw) for name, raw in servers.items()}
+
+
+def _canonical_entry(raw: Mapping[str, Any]) -> dict[str, Any]:
+    if "url" in raw:
+        return {"url": raw["url"], "transport": raw.get("type", "http")}
+    return {
+        "command": raw.get("command", ""),
+        "args": list(raw.get("args", ())),
+        "env": dict(raw.get("env", {})),
+    }

{agentshim-0.6.0 → agentshim-0.6.1}/agentshim/providers/copilot/scripted.py

@@ -104,6 +104,25 @@ def scripted_lines(
     return lines
 
 
+def resume_failure_lines(*, session_id: str | None = None) -> tuple[list[str], list[str], int]:
+    """Build the stdout, stderr and exit code of a resumed turn Copilot cannot continue.
+
+    ``CopilotProvider.classify_exit`` returns every exit unchanged: Copilot
+    gives no signal that distinguishes a lost session from any other
+    failure, so this always surfaces as a plain ``CliExitError``, never
+    ``SessionResumeError``, whether the turn was resumed or not.
+
+    Args:
+        session_id: Conversation id to name in the scripted stderr message.
+
+    Returns:
+        ``(stdout, stderr, returncode)`` for a ``FakeRun``.
+    """
+    detail = f" {session_id}" if session_id else ""
+    stderr = [f"Error: could not resume session{detail}\n"]
+    return [], stderr, 1
+
+
 def _usage_payload(usage: TokenUsage) -> dict[str, Any]:
     """Undo the parser's folding to print the disjoint counts Copilot reports."""
     cached = usage.cached_input_tokens

{agentshim-0.6.0 → agentshim-0.6.1}/agentshim/providers/gemini/__init__.py

@@ -4,12 +4,13 @@ from __future__ import annotations
 
 from .parser import GeminiStreamParser
 from .provider import PROFILE, GeminiProvider, mcp_entry
-from .scripted import scripted_lines
+from .scripted import resume_failure_lines, scripted_lines
 
 __all__ = [
     "PROFILE",
     "GeminiProvider",
     "GeminiStreamParser",
     "mcp_entry",
+    "resume_failure_lines",
     "scripted_lines",
 ]

{agentshim-0.6.0 → agentshim-0.6.1}/agentshim/providers/gemini/provider.py

@@ -38,7 +38,7 @@ if TYPE_CHECKING:
     from agentshim.core.mcp import McpServer
     from agentshim.core.provider import ArgvContext, McpInstallation
 
-MCP_CONFIG_PATH = (".gemini", "settings.json")
+MCP_CONFIG_FILENAME = ".gemini/settings.json"
 MCP_SERVER_KEY = "mcpServers"
 
 _NO_WORKSPACE = "gemini installs MCP servers into <cwd>/.gemini/settings.json; the turn needs a cwd"
@@ -71,6 +71,16 @@ PROFILE = ProviderProfile(
         "rm -f node.tgz; }",
         "npm install -g @google/gemini-cli",
     ),
+    # ``gemini --help`` documents no variable that relocates ~/.gemini, so
+    # this stays unset rather than guessed.
+    state_root_env=None,
+    auth_files=(
+        ".gemini/oauth_creds.json",
+        ".gemini/google_accounts.json",
+        ".gemini/settings.json",
+        ".gemini/.env",
+    ),
+    mcp_config_file=MCP_CONFIG_FILENAME,
 )
 
 
@@ -106,7 +116,7 @@ class GeminiProvider:
         if workspace is None:
             raise ProviderCapabilityError(_NO_WORKSPACE)
         return install_config_file(
-            workspace.joinpath(*MCP_CONFIG_PATH),
+            workspace / MCP_CONFIG_FILENAME,
             server_key=MCP_SERVER_KEY,
             servers={server.name: mcp_entry(server) for server in servers},
         )

{agentshim-0.6.0 → agentshim-0.6.1}/agentshim/providers/gemini/scripted.py

@@ -90,6 +90,27 @@ def scripted_lines(
     return lines
 
 
+def resume_failure_lines(*, session_id: str | None = None) -> tuple[list[str], list[str], int]:
+    """Build the stdout, stderr and exit code of a resumed turn Gemini cannot continue.
+
+    ``GeminiProvider.classify_exit`` treats any nonzero exit of a resumed
+    turn as ``SessionResumeError``: the CLI reports a refused resume the same
+    way it reports any other startup failure. ``session_id`` is folded into
+    the message for realism only; the id ``SessionResumeError`` actually
+    reports comes from the resumed turn's own argv, not from anything
+    scripted here.
+
+    Args:
+        session_id: Conversation id to name in the scripted stderr message.
+
+    Returns:
+        ``(stdout, stderr, returncode)`` for a ``FakeRun``.
+    """
+    detail = f" {session_id}" if session_id else ""
+    stderr = [f"Error: failed to load session{detail}\n"]
+    return [], stderr, 1
+
+
 def _stats(usage: TokenUsage | None, tool_calls: int) -> dict[str, int]:
     """Render token counts the way ``convertToStreamStats`` does.
 

{agentshim-0.6.0 → agentshim-0.6.1}/agentshim/providers/opencode/__init__.py

@@ -4,12 +4,13 @@ from __future__ import annotations
 
 from .parser import OpencodeStreamParser
 from .provider import PROFILE, OpencodeProvider, mcp_entry
-from .scripted import scripted_lines
+from .scripted import resume_failure_lines, scripted_lines
 
 __all__ = [
     "PROFILE",
     "OpencodeProvider",
     "OpencodeStreamParser",
     "mcp_entry",
+    "resume_failure_lines",
     "scripted_lines",
 ]