agentshim 0.6.0__tar.gz → 0.6.2__tar.gz

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

@@ -1,5 +1,64 @@
 # Changelog
 
+## 0.6.2 (2026-09-26)
+
+- Add optional positive finite `tool_timeout_s` to stdio and HTTP MCP server
+  specs. Codex renders it as an invocation-scoped `tool_timeout_sec` config
+  override; providers that cannot represent it reject the request explicitly.
+
+## 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.2}/PKG-INFO

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

{agentshim-0.6.0 → agentshim-0.6.2}/agentshim/__init__.py

@@ -84,7 +84,7 @@ from .providers.copilot import CopilotProvider
 from .providers.gemini import GeminiProvider
 from .providers.opencode import OpencodeProvider
 
-__version__ = "0.6.0"
+__version__ = "0.6.2"
 
 __all__ = [
     "AgentEvent",

{agentshim-0.6.0 → agentshim-0.6.2}/agentshim/core/mcp.py

@@ -14,6 +14,7 @@ each concurrent turn its own workspace.
 from __future__ import annotations
 
 import json
+import math
 from dataclasses import dataclass, field
 from types import MappingProxyType
 from typing import TYPE_CHECKING, Any, Literal, cast
@@ -37,12 +38,18 @@ def _no_env() -> Mapping[str, str]:
 
 @dataclass(frozen=True)
 class StdioMcpServer:
-    """MCP server launched as a subprocess over stdio."""
+    """MCP server launched as a subprocess over stdio.
+
+    ``tool_timeout_s`` is the maximum time one tool call may run. Providers
+    that cannot express a per-server tool timeout reject a non-``None`` value
+    rather than silently dropping it.
+    """
 
     name: str
     command: str
     args: Sequence[str] = ()
     env: Mapping[str, str] = field(default_factory=_no_env)
+    tool_timeout_s: float | None = None
 
     def __post_init__(self) -> None:
         """Reject a spec the provider could never launch.
@@ -56,6 +63,7 @@ class StdioMcpServer:
         if not self.command:
             msg = f"MCP server {self.name!r} must declare a command"
             raise ValueError(msg)
+        _validate_tool_timeout(self.name, self.tool_timeout_s)
 
 
 #: The two remote MCP transports the CLIs distinguish.
@@ -79,6 +87,7 @@ class HttpMcpServer:
     url: str
     headers: Mapping[str, str] = field(default_factory=_no_env)
     transport: McpTransport = "http"
+    tool_timeout_s: float | None = None
 
     def __post_init__(self) -> None:
         """Reject a spec the provider could never reach.
@@ -95,6 +104,16 @@ class HttpMcpServer:
         if self.transport not in _TRANSPORTS:
             msg = f"MCP server {self.name!r} transport must be one of {_TRANSPORTS}"
             raise ValueError(msg)
+        _validate_tool_timeout(self.name, self.tool_timeout_s)
+
+
+def _validate_tool_timeout(name: str, timeout_s: float | None) -> None:
+    """Reject timeout values no provider can apply meaningfully."""
+    if timeout_s is None:
+        return
+    if isinstance(timeout_s, bool) or not math.isfinite(timeout_s) or timeout_s <= 0:
+        msg = f"MCP server {name!r} tool_timeout_s must be a positive finite number"
+        raise ValueError(msg)
 
 
 McpServer = StdioMcpServer | HttpMcpServer

agentshim-0.6.2/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.2}/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.2}/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.2}/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,
 )
 
 
@@ -150,6 +162,9 @@ def _resumed_session_id(argv: Sequence[str]) -> str | None:
 
 def mcp_entry(server: McpServer) -> dict[str, Any]:
     """Render one server the way ``.mcp.json`` describes it."""
+    if server.tool_timeout_s is not None:
+        msg = "claude cannot configure a per-server MCP tool timeout"
+        raise ProviderCapabilityError(msg)
     if isinstance(server, HttpMcpServer):
         # Claude validates the config strictly and needs an explicit type; it
         # names the two remote transports exactly as the spec does.

{agentshim-0.6.0 → agentshim-0.6.2}/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.2}/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.2}/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,
 )
 
 
@@ -178,7 +186,8 @@ def _server_flags(server: McpServer) -> list[str]:
             raise ProviderCapabilityError(_HTTP_HEADERS_UNSUPPORTED)
         # A ``--config`` override carries the address and nothing else, so
         # Codex works the transport out from the endpoint itself.
-        return ["--config", f"{prefix}.url={_toml_str(server.url)}"]
+        flags = ["--config", f"{prefix}.url={_toml_str(server.url)}"]
+        return flags + _tool_timeout_flags(prefix, server.tool_timeout_s)
     flags = [
         "--config",
         f"{prefix}.command={_toml_str(server.command)}",
@@ -187,7 +196,14 @@ def _server_flags(server: McpServer) -> list[str]:
     ]
     for env_key, env_value in server.env.items():
         flags += ["--config", f"{prefix}.env.{env_key}={_toml_str(env_value)}"]
-    return flags
+    return flags + _tool_timeout_flags(prefix, server.tool_timeout_s)
+
+
+def _tool_timeout_flags(prefix: str, timeout_s: float | None) -> list[str]:
+    """Render Codex's per-server tool timeout as an invocation override."""
+    if timeout_s is None:
+        return []
+    return ["--config", f"{prefix}.tool_timeout_sec={timeout_s}"]
 
 
 def _toml_str(value: str) -> str:
@@ -199,3 +215,95 @@ 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 == "tool_timeout_sec":
+        entry["tool_timeout_s"] = float(raw_value)
+    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.2}/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.2}/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",
 ]