feat(copilot): authentic @github/copilot CLI identity + Claude context + vision

AGENTS.md

@@ -1175,7 +1175,7 @@ automatically scope to the active profile.
    a unique credential (bot token, API key), call `acquire_scoped_lock()` from
    `gateway.status` in the `connect()`/`start()` method and `release_scoped_lock()` in
    `disconnect()`/`stop()`. This prevents two profiles from using the same credential.
-   See `gateway/platforms/telegram.py` for the canonical pattern.
+   See `plugins/platforms/irc/adapter.py` for the canonical pattern.
 
 6. **Profile operations are HOME-anchored, not HERMES_HOME-anchored** — `_get_profiles_root()`
    returns `Path.home() / ".hermes" / "profiles"`, NOT `get_hermes_home() / "profiles"`.

acp_adapter/session.py

@@ -617,6 +617,10 @@ def _make_agent(
 
         _register_task_cwd(session_id, cwd)
         agent = AIAgent(**kwargs)
+        # Codex app-server sessions are spawned lazily on the first turn. Stamp
+        # the ACP workspace onto the agent so the Codex runtime starts from the
+        # editor/session cwd instead of the Hermes daemon's process cwd.
+        agent.session_cwd = cwd
         # ACP stdio transport requires stdout to remain protocol-only JSON-RPC.
         # Route any incidental human-readable agent output to stderr instead.
         agent._print_fn = _acp_stderr_print

agent/agent_init.py

@@ -808,6 +808,8 @@ def init_agent(
                 # _custom_headers; older/mocked clients may expose
                 # _default_headers instead.
                 _routed_headers = getattr(_routed_client, "_custom_headers", None)
+                if not _routed_headers:
+                    _routed_headers = getattr(_routed_client, "default_headers", None)
                 if not _routed_headers:
                     _routed_headers = getattr(_routed_client, "_default_headers", None)
                 if _routed_headers:
@@ -861,6 +863,8 @@ def init_agent(
                             if _provider_timeout is not None:
                                 client_kwargs["timeout"] = _provider_timeout
                             _fb_headers = getattr(_fb_client, "_custom_headers", None)
+                            if not _fb_headers:
+                                _fb_headers = getattr(_fb_client, "default_headers", None)
                             if not _fb_headers:
                                 _fb_headers = getattr(_fb_client, "_default_headers", None)
                             if _fb_headers:
@@ -1096,6 +1100,12 @@ def init_agent(
     agent._parent_session_id = parent_session_id
     agent._last_flushed_db_idx = 0  # tracks DB-write cursor to prevent duplicate writes
     agent._session_db_created = False  # DB row deferred to run_conversation()
+    # Most agents own their session row and should finalize it on close().
+    # Some temporary helper agents (manual compression / session-hygiene /
+    # background-review forks) rotate or share the session forward to a
+    # continuation row that must remain open after the helper is torn down;
+    # those callers explicitly set this flag to False.
+    agent._end_session_on_close = True
     agent._session_init_model_config = {
         "max_iterations": agent.max_iterations,
         "reasoning_config": reasoning_config,

agent/agent_runtime_helpers.py

@@ -1378,22 +1378,6 @@ def create_openai_client(agent, client_kwargs: dict, *, reason: str, shared: boo
             agent._client_log_context(),
         )
         return client
-    if agent.provider == "google-gemini-cli" or str(client_kwargs.get("base_url", "")).startswith("cloudcode-pa://"):
-        from agent.gemini_cloudcode_adapter import GeminiCloudCodeClient
-
-        # Strip OpenAI-specific kwargs the Gemini client doesn't accept
-        safe_kwargs = {
-            k: v for k, v in client_kwargs.items()
-            if k in {"api_key", "base_url", "default_headers", "project_id", "timeout"}
-        }
-        client = GeminiCloudCodeClient(**safe_kwargs)
-        _ra().logger.info(
-            "Gemini Cloud Code Assist client created (%s, shared=%s) %s",
-            reason,
-            shared,
-            agent._client_log_context(),
-        )
-        return client
     if agent.provider == "gemini":
         from agent.gemini_native_adapter import GeminiNativeClient, is_native_gemini_base_url
 
@@ -2187,25 +2171,36 @@ def copy_reasoning_content_for_api(agent, source_msg: dict, api_msg: dict) -> No
     if source_msg.get("role") != "assistant":
         return
 
-    # 1. Explicit reasoning_content already set — preserve it verbatim
-    # (includes DeepSeek/Kimi's own space-placeholder written at creation
-    # time, and any valid reasoning content from the same provider).
+    needs_thinking_pad = agent._needs_thinking_reasoning_pad()
+
+    # 1. Explicit reasoning_content already set.
+    #
+    # When the active provider enforces the thinking-mode echo-back
+    # (DeepSeek / Kimi / MiMo), preserve it verbatim — that includes their
+    # own space-placeholder written at creation time and any valid reasoning
+    # from the same provider. Sessions persisted BEFORE #17341 have
+    # empty-string placeholders pinned at creation time; DeepSeek V4 Pro
+    # rejects those with HTTP 400, so upgrade "" → " " on replay.
     #
-    # Exception: sessions persisted BEFORE #17341 have empty-string
-    # placeholders pinned at creation time. DeepSeek V4 Pro rejects
-    # those with HTTP 400. When the active provider enforces the
-    # thinking-mode echo, upgrade "" → " " on replay so stale history
-    # doesn't 400 the user on the next turn.
+    # When the active provider does NOT enforce echo-back, strip the field
+    # entirely. Strict OpenAI-compatible providers (Mistral, Cerebras, Groq,
+    # SambaNova, …) reject ANY reasoning_content key in input messages with
+    # HTTP 400/422 ("Extra inputs are not permitted"), even an empty string
+    # or a single-space pad. This is the cross-provider fallback case: a
+    # reasoning primary (DeepSeek/Kimi/MiMo) pads history with " ", then a
+    # fallback to a strict provider replays that pad and 422s. Stripping
+    # here covers the rebuild path; reapply_reasoning_echo_for_provider()
+    # covers the already-built api_messages path. Refs #45655.
     existing = source_msg.get("reasoning_content")
     if isinstance(existing, str):
-        if existing == "" and agent._needs_thinking_reasoning_pad():
+        if not needs_thinking_pad:
+            api_msg.pop("reasoning_content", None)
+        elif existing == "":
             api_msg["reasoning_content"] = " "
         else:
             api_msg["reasoning_content"] = existing
         return
 
-    needs_thinking_pad = agent._needs_thinking_reasoning_pad()
-
     # 2. Cross-provider poisoned history (#15748): on DeepSeek/Kimi,
     # if the source turn has tool_calls AND a 'reasoning' field but no
     # 'reasoning_content' key, the 'reasoning' text was written by a
@@ -2231,9 +2226,13 @@ def copy_reasoning_content_for_api(agent, source_msg: dict, api_msg: dict) -> No
     # for providers that use the internal 'reasoning' key.
     # This must happen before the unconditional empty-string fallback so
     # genuine reasoning content is not overwritten (#15812 regression in
-    # PR #15478).
+    # PR #15478). Only promote for providers that enforce echo-back —
+    # strict providers reject the field (refs #45655).
     if isinstance(normalized_reasoning, str) and normalized_reasoning:
-        api_msg["reasoning_content"] = normalized_reasoning
+        if needs_thinking_pad:
+            api_msg["reasoning_content"] = normalized_reasoning
+        else:
+            api_msg.pop("reasoning_content", None)
         return
 
     # 4. DeepSeek / Kimi thinking mode: all assistant messages need
@@ -2254,34 +2253,53 @@ def copy_reasoning_content_for_api(agent, source_msg: dict, api_msg: dict) -> No
 
 
 def reapply_reasoning_echo_for_provider(agent, api_messages: list) -> int:
-    """Re-pad assistant turns with reasoning_content for the active provider.
+    """Re-pad (or strip) assistant turns' reasoning_content for the active provider.
 
     ``api_messages`` is built once, before the retry loop, while the *primary*
-    provider is active.  If a mid-conversation fallback then switches to a
-    require-side provider (DeepSeek / Kimi / MiMo thinking mode), assistant
-    turns that were built when the prior provider did NOT need the echo-back go
-    out without ``reasoning_content`` and the new provider rejects them with
-    HTTP 400 ("The reasoning_content in the thinking mode must be passed back").
-
-    Calling this immediately before building the request kwargs re-applies the
-    pad against the *current* provider.  It is idempotent and a no-op unless
-    ``_needs_thinking_reasoning_pad()`` is True for the active provider, so it
-    is safe to call every iteration and covers every fallback path.
-
-    Returns the number of assistant turns that gained reasoning_content.
+    provider is active.  A mid-conversation fallback can then switch providers,
+    so the reasoning fields baked into ``api_messages`` are shaped for the
+    *prior* provider and must be reconciled against the *current* one:
+
+    * Switching TO a require-side provider (DeepSeek / Kimi / MiMo thinking
+      mode): assistant turns built when the prior provider did NOT need the
+      echo-back go out without ``reasoning_content`` and the new provider
+      rejects them with HTTP 400 ("The reasoning_content in the thinking mode
+      must be passed back").  Re-apply the pad.
+
+    * Switching TO a strict provider that rejects the field (Mistral,
+      Cerebras, Groq, SambaNova, …): assistant turns built under a reasoning
+      primary carry a ``reasoning_content`` pad (often a single space ``" "``),
+      and the strict provider rejects it with HTTP 400/422 ("Extra inputs are
+      not permitted").  Strip the field.  This is the exact cross-provider
+      fallback bug from #45655 — a DeepSeek primary pads history with ``" "``,
+      the request falls back to Mistral, and Mistral 422s on the stale pad.
+
+    Calling this immediately before building the request kwargs reconciles the
+    fields against the *current* provider.  It is idempotent and safe to call
+    every iteration; it covers every fallback path.
+
+    Returns the number of assistant turns whose reasoning_content was added or
+    removed.
     """
-    if not agent._needs_thinking_reasoning_pad():
-        return 0
-    padded = 0
+    needs_pad = agent._needs_thinking_reasoning_pad()
+    changed = 0
     for api_msg in api_messages:
         if api_msg.get("role") != "assistant":
             continue
-        if api_msg.get("reasoning_content"):
-            continue
-        copy_reasoning_content_for_api(agent, api_msg, api_msg)
-        if api_msg.get("reasoning_content"):
-            padded += 1
-    return padded
+        if needs_pad:
+            if api_msg.get("reasoning_content"):
+                continue
+            copy_reasoning_content_for_api(agent, api_msg, api_msg)
+            if api_msg.get("reasoning_content"):
+                changed += 1
+        else:
+            # Strict provider — strip any stale reasoning_content pad left
+            # over from a reasoning primary so the fallback request doesn't
+            # 400/422 on it.
+            if "reasoning_content" in api_msg:
+                api_msg.pop("reasoning_content", None)
+                changed += 1
+    return changed
 
 
 def _iter_pool_sockets(client: Any):

agent/anthropic_adapter.py

@@ -317,6 +317,16 @@ def _supports_fast_mode(model: str) -> bool:
 _COMMON_BETAS = [
     "interleaved-thinking-2025-05-14",
     "fine-grained-tool-streaming-2025-05-14",
+    # Added 2026-06-04 from Worker-A RE of github.copilot-chat 0.52.2026060402.
+    # The VS Code Copilot Chat extension historically sent these on every
+    # /v1/messages call. Hermes sends them under its single Copilot CLI identity
+    # (`Copilot-Integration-Id: copilot-developer-cli`).
+    # `advanced-tool-use-2025-11-20` enables the newer tool-call envelopes
+    # that Claude 4.7+ emits; `context-management-2025-06-27` enables the
+    # `context_management: [{type: "clear_tool_results_20250919", ...}]`
+    # body field that opus-4.6+ requires for clean 1M-context rolls.
+    "advanced-tool-use-2025-11-20",
+    "context-management-2025-06-27",
 ]
 # MiniMax's Anthropic-compatible endpoints fail tool-use requests when
 # the fine-grained tool streaming beta is present.  Omit it so tool calls
@@ -551,7 +561,38 @@ def _base_url_needs_context_1m_beta(base_url: str | None) -> bool:
     normalized = _normalize_base_url_text(base_url).lower()
     if not normalized:
         return False
-    return "azure.com" in normalized
+    return "azure.com" in normalized or "githubcopilot.com" in normalized
+
+
+def _is_copilot_base_url(base_url: Optional[str]) -> bool:
+    if not base_url:
+        return False
+    try:
+        from urllib.parse import urlparse
+        host = (urlparse(base_url).hostname or "").lower()
+    except Exception:
+        return False
+    return host == "api.githubcopilot.com"
+
+
+def _request_messages_have_image_parts(messages: Any) -> bool:
+    """Return True when any message carries image content.
+
+    Matches both OpenAI-style parts (``image_url`` / ``input_image``): the
+    shape ``build_anthropic_kwargs`` receives before ``convert_messages_to_anthropic``
+    runs, and already-converted Anthropic blocks (``{"type": "image"}``), so the
+    check is robust regardless of where it is called in the pipeline.
+    """
+    def _contains_image(value: Any) -> bool:
+        if isinstance(value, dict):
+            if value.get("type") in {"image_url", "input_image", "image"}:
+                return True
+            return any(_contains_image(v) for v in value.values())
+        if isinstance(value, list):
+            return any(_contains_image(v) for v in value)
+        return False
+
+    return isinstance(messages, list) and any(_contains_image(m) for m in messages)
 
 
 def _is_minimax_anthropic_endpoint(base_url: str | None) -> bool:
@@ -616,8 +657,41 @@ def _common_betas_for_base_url(
     betas = list(_COMMON_BETAS)
     if _base_url_needs_context_1m_beta(base_url) and not drop_context_1m_beta:
         betas.append(_CONTEXT_1M_BETA)
+
+    if _is_copilot_base_url(base_url):
+        # 2026-06-04 (Worker-G RE of github.copilot-chat 0.52.2026060402):
+        # The official VS Code Copilot Chat extension only ever sends THREE
+        # Anthropic betas on the /v1/messages path:
+        #   interleaved-thinking-2025-05-14
+        #   context-management-2025-06-27
+        #   advanced-tool-use-2025-11-20
+        # The historical "Master Probe triplet" of
+        #   cli-internal-2026-02-09 + context-1m-2025-08-07 + task-budgets-2026-03-13
+        # does NOT exist anywhere in the extension bundle (grep on the 32MB
+        # beautified JS returned 0 hits for each string). Sending those
+        # non-existent betas was identified by Worker G as a likely
+        # contributor to historical "Context length exceeded → snap-back to
+        # 168k" loops on accounts not pre-advertising context-1m. 1M context
+        # is unlocked by the `Copilot-Integration-Id` we send
+        # (`copilot-developer-cli`, the official CLI's id) + the server-side
+        # account entitlement, never by any beta.
+        #
+        # All three real betas already live in _COMMON_BETAS, so this block
+        # is intentionally a no-op now \u2014 kept as a docstring marker so
+        # future readers don't reintroduce the fictional triplet.
+        pass
+
     if _is_minimax_anthropic_endpoint(base_url):
-        _stripped = {_TOOL_STREAMING_BETA, _CONTEXT_1M_BETA}
+        # MiniMax's Anthropic-compatible endpoint rejects most vendor-specific
+        # betas. Strip everything except interleaved-thinking which it does
+        # honor. The two 2026-06-04 additions (advanced-tool-use,
+        # context-management) are also unrecognized by MiniMax.
+        _stripped = {
+            _TOOL_STREAMING_BETA,
+            _CONTEXT_1M_BETA,
+            "advanced-tool-use-2025-11-20",
+            "context-management-2025-06-27",
+        }
         return [b for b in betas if b not in _stripped]
     if drop_context_1m_beta:
         return [b for b in betas if b != _CONTEXT_1M_BETA]
@@ -782,6 +856,45 @@ def build_anthropic_client(
             "User-Agent": "claude-code/0.1.0",
             **( {"anthropic-beta": ",".join(common_betas)} if common_betas else {} )
         }
+    elif _is_copilot_base_url(normalized_base_url):
+        # GitHub Copilot's Anthropic deployment (POST /v1/messages) is the ONLY
+        # Copilot endpoint that serves Claude at the real 1,000,000-token input
+        # window; /chat/completions clamps it and returns a misleading
+        # "exceeds the limit of 168000" error (see probe/FINDINGS.md §2).  It
+        # requires:
+        #   1. Authorization: Bearer ***  (NOT Anthropic x-api-key)
+        #   2. The full VS Code Copilot identity header set
+        #      (Editor-Version, User-Agent: rest-book, Copilot-Integration-Id:
+        #      vscode-chat, X-GitHub-Api-Version, x-initiator) PLUS the
+        #      X-Copilot-Agent-Slug: copilot-1m-context unlock.
+        #   3. anthropic-beta: cli-internal + context-1m + task-budgets
+        #      (already computed in common_betas for this base_url).
+        # This is the exact header set proved working in
+        # probe/live_transport.py that unlocked opus-4.8 → 992,497 input
+        # tokens on /v1/messages.  Checked BEFORE _requires_bearer_auth and the
+        # x-api-key fallthrough so the Copilot token is sent as Bearer, not as
+        # an Anthropic API key.
+        kwargs["auth_token"] = api_key
+        _copilot_headers: dict[str, str] = {}
+        try:
+            from hermes_cli.copilot_auth import copilot_request_headers
+            # Single Copilot CLI identity (copilot-developer-cli + CLI User-Agent),
+            # the same builder used on the inference path, so /v1/messages and
+            # /chat/completions present one consistent identity.
+            _copilot_headers = copilot_request_headers(
+                is_agent_turn=True, model="claude"
+            )
+        except Exception:
+            # Never block client construction on header enrichment; the
+            # bearer token alone still authenticates, just without the
+            # 1M unlock slug.
+            _copilot_headers = {}
+        # The proven anthropic-beta triplet (computed in common_betas) is
+        # authoritative; apply it last so it always wins over any value the
+        # identity header set may carry.
+        if common_betas:
+            _copilot_headers["anthropic-beta"] = ",".join(common_betas)
+        kwargs["default_headers"] = _copilot_headers
     elif _requires_bearer_auth(normalized_base_url):
         # Some Anthropic-compatible providers (e.g. MiniMax) expect the API key in
         # Authorization: Bearer *** for regular API keys. Route those endpoints
@@ -2494,6 +2607,16 @@ def _to_oauth_wire_name(name: str) -> str:
         betas.append(_FAST_MODE_BETA)
         kwargs["extra_headers"] = {"anthropic-beta": ",".join(betas)}
 
+    # Copilot's /v1/messages proxy only processes image input when the
+    # Copilot-Vision-Request header is set. The persistent Anthropic client is
+    # built with is_vision=False (no such header), so image-bearing turns to
+    # Copilot otherwise return an empty content block (HTTP 200) that the loop
+    # fails as "invalid response". Add it per-request only when an image is
+    # present, gated to the Copilot endpoint so it never leaks to
+    # api.anthropic.com or Bedrock-hosted Anthropic.
+    if _is_copilot_base_url(base_url) and _request_messages_have_image_parts(messages):
+        kwargs.setdefault("extra_headers", {})["Copilot-Vision-Request"] = "true"
+
     return kwargs