code-puppy-core-plugins 0.0.102__tar.gz → 0.0.104__tar.gz

{code_puppy_core_plugins-0.0.102 → code_puppy_core_plugins-0.0.104}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: code-puppy-core-plugins
-Version: 0.0.102
+Version: 0.0.104
 Summary: Official plugin bundle for Code Puppy
 Project-URL: Repository, https://github.com/mpfaffenberger/code_puppy_core_plugins
 Project-URL: Homepage, https://github.com/mpfaffenberger/code_puppy_core_plugins
@@ -41,6 +41,8 @@ Requires-Dist: pyobjc-framework-cocoa>=10.3; (sys_platform == 'darwin') and extr
 Requires-Dist: pyobjc-framework-quartz>=10.3; (sys_platform == 'darwin') and extra == 'computer-use'
 Requires-Dist: pywinauto<0.7,>=0.6.9; (sys_platform == 'win32') and extra == 'computer-use'
 Requires-Dist: windows-capture<3,>=2.0.1; (sys_platform == 'win32') and extra == 'computer-use'
+Provides-Extra: logfire
+Requires-Dist: logfire>=4.0; extra == 'logfire'
 Description-Content-Type: text/markdown
 
 # Code Puppy Core Plugins
@@ -108,6 +110,21 @@ player can play it. Linux uses `notify-send` for desktop notifications when it
 is installed; Windows uses a best-effort PowerShell toast. No external Python
 dependencies are required.
 
+## Logfire
+
+The `logfire_instrumentation`, `logfire_oauth` and `logfire_sessions` plugins
+do not import the SDK until you opt in. The SDK is an optional extra:
+
+```bash
+uv tool install code-puppy --with 'code-puppy-core-plugins[logfire]'
+```
+
+Opt in to pydantic-ai instrumentation with `/set enable_logfire=true` (or a
+truthy `CODE_PUPPY_ENABLE_LOGFIRE` for headless runs), then restart. Spans are
+sent only when a write token is available, either your own `LOGFIRE_TOKEN` or
+one minted by `/logfire onboard`. Opting in without the extra installed shows
+an install hint instead.
+
 ## pstack
 
 The `pstack` plugin bundles poteto's [pstack](https://github.com/cursor/plugins/tree/main/pstack)

{code_puppy_core_plugins-0.0.102 → code_puppy_core_plugins-0.0.104}/README.md

@@ -63,6 +63,21 @@ player can play it. Linux uses `notify-send` for desktop notifications when it
 is installed; Windows uses a best-effort PowerShell toast. No external Python
 dependencies are required.
 
+## Logfire
+
+The `logfire_instrumentation`, `logfire_oauth` and `logfire_sessions` plugins
+do not import the SDK until you opt in. The SDK is an optional extra:
+
+```bash
+uv tool install code-puppy --with 'code-puppy-core-plugins[logfire]'
+```
+
+Opt in to pydantic-ai instrumentation with `/set enable_logfire=true` (or a
+truthy `CODE_PUPPY_ENABLE_LOGFIRE` for headless runs), then restart. Spans are
+sent only when a write token is available, either your own `LOGFIRE_TOKEN` or
+one minted by `/logfire onboard`. Opting in without the extra installed shows
+an install hint instead.
+
 ## pstack
 
 The `pstack` plugin bundles poteto's [pstack](https://github.com/cursor/plugins/tree/main/pstack)

{code_puppy_core_plugins-0.0.102 → code_puppy_core_plugins-0.0.104}/code_puppy_core_plugins/acp/README.md

@@ -119,6 +119,7 @@ Every file stays well under the 600-line cap and owns one concern.
 | `register_callbacks.py` | Register the `--acp` flag; when present, redirect the console to stderr, run `acp.run_agent(CodePuppyAgent())` on its own loop in a thread, and return `{"handled": True}` so the TUI never starts. |
 | `agent.py` | `CodePuppyAgent(acp.Agent)` — the SDK agent implementation: initialize, new/load/resume/fork/list/close session, prompt, cancel, set_session_mode/model, set_config_option, authenticate, plus `on_connect` (stashes the client handle + installs approvals). |
 | `capabilities.py` | Declarative capability negotiation in SDK models: our `AgentCapabilities`, and parsing the client's `ClientCapabilities` into `(fs_read, fs_write, terminal)`. |
+| `auth_status.py` | Neutral provider registry that lets any plugin report sign-in state; read-only snapshots feed `authMethods` and `authenticate`. |
 | `content.py` | Parse ACP prompt content blocks → text + multimodal attachments (`BinaryContent` / `ImageUrl`), honouring `embeddedContext` + `image`. |
 | `session.py` | `ACPSession`: one ACP session ⇄ one `BaseAgent` + its `_message_history`. Runs each turn as a cancellable `asyncio.Task`; persists history after each turn; owns the final-result fallback. |
 | `commands.py` | Execute client-typed `/slash` commands via `command_handler`, capturing MessageBus output and forwarding it (never touches stdin). |
@@ -186,7 +187,7 @@ double-send.
 | Method | Behaviour |
 |--------|-----------|
 | `initialize` | Negotiate version + capabilities; install capability-gated I/O delegation. |
-| `authenticate` / `logout` | No-op (auth is via Code Puppy's own model config/env). |
+| `authenticate` / `logout` | `authenticate` reports (read-only) the registered auth status for a known method id as `_meta.codePuppy.authStatus`, and succeeds even when that status is `missing` or `expired`; clients must read `status`, not infer from success. An unknown method id gets an empty response. `logout` is a no-op. |
 | `session/new` | Create an `ACPSession` (fresh `BaseAgent`) from `cwd` + `additionalDirectories`; attach client `mcpServers`; return models + config options; schedule `available_commands_update`. |
 | `session/load` | Re-open a thread: **replay persisted history into the agent AND stream it back to the client** as `session/update`s so the client rebuilds the thread UI. |
 | `session/resume` | Rehydrate + replay a session across a restart from persisted history. |
@@ -204,6 +205,66 @@ call in 0.10.1), `plan` updates (no native plan model), and the unstable
 unimplemented method to a clean "method not found", so we advertise honestly
 and stub nothing.
 
+### Reporting sign-in state
+
+`auth_status.py` is a neutral registry: any plugin can register a provider that
+reports its sign-in state, and ACP clients see it in `initialize` (`authMethods`)
+and `authenticate`. Providers must be fast and synchronous; a provider that raises
+or returns a report with wrong-typed fields is skipped. If two providers report the
+same `method_id`, the first registered wins, so the outcome depends on plugin load order.
+
+```python
+from datetime import datetime, timezone
+
+from code_puppy_core_plugins.acp.auth_status import (
+    AuthStatusReport,
+    register_auth_status_provider,
+)
+
+
+def example_auth_status() -> AuthStatusReport | None:
+    session = _load_session()
+    if session is None:
+        return AuthStatusReport("example-login", "Example Login", "missing")
+    return AuthStatusReport(
+        "example-login",
+        "Example Login",
+        "signed_in",
+        expires_at=datetime(2030, 1, 2, 3, 4, 5, tzinfo=timezone.utc),
+        user_id=session.user_name,
+    )
+
+
+register_auth_status_provider(example_auth_status)
+```
+
+`expires_at` is serialized as ISO-8601 UTC (`...Z`); a naive value is treated as UTC,
+and an aware value is converted to UTC. `user_id` is a display string (trimmed, max 128 chars).
+
+Wire shape in the `initialize` result (`authMethods` is omitted when no provider is registered):
+
+```json
+{
+  "authMethods": [
+    {
+      "id": "example-login",
+      "name": "Example Login",
+      "_meta": {
+        "codePuppy": {
+          "authStatus": { "status": "signed_in", "expiresAt": "2030-01-02T03:04:05Z", "userId": "jdoe" }
+        }
+      }
+    }
+  ]
+}
+```
+
+Readers must never trigger login, network or prompts. `id`, `name` and `description`
+are provider-supplied display strings and must never contain secrets; only the contents of
+`_meta.codePuppy.authStatus` are allow-listed to `status`, `expiresAt` and `userId`.
+A `status` of `not_applicable` means the method does not apply to this
+install, so clients should hide any sign-in UI for it.
+
 ### Outbound notifications (us → the client) — `session/update`
 
 `agent_message_chunk`, `agent_thought_chunk`, `tool_call`, `tool_call_update`,

{code_puppy_core_plugins-0.0.102 → code_puppy_core_plugins-0.0.104}/code_puppy_core_plugins/acp/agent.py

@@ -40,6 +40,7 @@ from acp.schema import (
 )
 
 from code_puppy_core_plugins.acp import (
+    auth_status,
     capabilities,
     io_delegation,
     mcp_config,
@@ -126,11 +127,16 @@ class CodePuppyAgent(Agent):
                 title="Code Puppy",
                 version=_code_puppy_version(),
             ),
+            auth_methods=auth_status.auth_methods(),
         )
 
     async def authenticate(self, method_id: str, **kwargs: Any) -> AuthenticateResponse:
-        """No auth flow — Code Puppy authenticates via its own model config."""
-        return AuthenticateResponse()
+        """Report the registered auth status for ``method_id``.
+        Never logs in, calls the network, or prompts."""
+        report = auth_status.auth_status_for(method_id)
+        if report is None:
+            return AuthenticateResponse()
+        return AuthenticateResponse(field_meta=auth_status.auth_status_meta(report))
 
     # ---- Session lifecycle ------------------------------------------------
     async def new_session(

code_puppy_core_plugins-0.0.104/code_puppy_core_plugins/acp/auth_status.py

@@ -0,0 +1,148 @@
+"""Neutral registry of sign-in state that plugins report to ACP clients.
+
+Any plugin registers a provider; ACP reads it without knowing who owns it.
+Called by: agent.py :: CodePuppyAgent.initialize() / authenticate().
+Readers must never trigger login, network I/O, or prompts; providers stay read-only.
+"""
+
+from __future__ import annotations
+
+import logging
+import threading
+import typing
+from dataclasses import dataclass
+from datetime import datetime, timezone
+from typing import Any, Callable, Literal
+
+from acp.schema import AuthMethodAgent
+
+logger = logging.getLogger(__name__)
+
+AuthState = Literal["signed_in", "expired", "missing", "not_applicable"]
+
+_USER_ID_MAX_LEN = 128
+
+
+@dataclass(frozen=True)
+class AuthStatusReport:
+    method_id: str
+    name: str
+    status: AuthState
+    description: str | None = None
+    expires_at: datetime | None = None
+    user_id: str | None = None
+
+
+AuthStatusProvider = Callable[[], "AuthStatusReport | None"]
+
+_providers: list[AuthStatusProvider] = []
+_providers_lock = threading.Lock()
+
+
+def register_auth_status_provider(provider: AuthStatusProvider) -> None:
+    with _providers_lock:
+        if provider not in _providers:
+            _providers.append(provider)
+
+
+def unregister_auth_status_provider(provider: AuthStatusProvider) -> None:
+    with _providers_lock:
+        if provider in _providers:
+            _providers.remove(provider)
+
+
+def _is_valid_report(report: object) -> bool:
+    if not isinstance(report, AuthStatusReport):
+        return False
+    if report.status not in typing.get_args(AuthState):
+        return False
+    for text in (report.method_id, report.name):
+        if not isinstance(text, str) or not text.strip():
+            return False
+    if report.description is not None and not isinstance(report.description, str):
+        return False
+    if report.expires_at is not None and not isinstance(report.expires_at, datetime):
+        return False
+    if report.user_id is not None and not isinstance(report.user_id, str):
+        return False
+    return True
+
+
+def current_auth_reports() -> list[AuthStatusReport]:
+    with _providers_lock:
+        providers = list(_providers)
+
+    reports: list[AuthStatusReport] = []
+    seen_ids: set[str] = set()
+    for provider in providers:
+        try:
+            report = provider()
+        except Exception as exc:
+            # Exception type only: messages may carry tokens or other secrets.
+            logger.debug("auth status provider failed: %s", type(exc).__name__)
+            continue
+        if not _is_valid_report(report) or report.method_id in seen_ids:
+            continue
+        seen_ids.add(report.method_id)
+        reports.append(report)
+    return reports
+
+
+def auth_status_for(method_id: str) -> AuthStatusReport | None:
+    for report in current_auth_reports():
+        if report.method_id == method_id and _meta_or_none(report) is not None:
+            return report
+    return None
+
+
+def _format_expires_at(expires_at: datetime) -> str:
+    if expires_at.tzinfo is None:
+        utc_value = expires_at.replace(tzinfo=timezone.utc)
+    else:
+        utc_value = expires_at.astimezone(timezone.utc)
+    return utc_value.replace(microsecond=0).isoformat().replace("+00:00", "Z")
+
+
+def auth_status_meta(report: AuthStatusReport) -> dict[str, Any]:
+    # Allow-list only: copying other fields could leak data a subclass carries.
+    inner: dict[str, Any] = {"status": report.status}
+    if report.expires_at is not None:
+        inner["expiresAt"] = _format_expires_at(report.expires_at)
+    if isinstance(report.user_id, str):
+        user_id = report.user_id.strip()[:_USER_ID_MAX_LEN]
+        if user_id:
+            inner["userId"] = user_id
+    return {"codePuppy": {"authStatus": inner}}
+
+
+def _meta_or_none(report: AuthStatusReport) -> dict[str, Any] | None:
+    try:
+        return auth_status_meta(report)
+    except Exception as exc:
+        # Exception type only: messages may carry tokens or other secrets.
+        logger.debug(
+            "auth status report could not be serialized: %s", type(exc).__name__
+        )
+        return None
+
+
+def auth_methods() -> list[AuthMethodAgent] | None:
+    methods: list[AuthMethodAgent] = []
+    for report in current_auth_reports():
+        meta = _meta_or_none(report)
+        if meta is None:
+            continue
+        try:
+            methods.append(
+                AuthMethodAgent(
+                    id=report.method_id,
+                    name=report.name,
+                    description=report.description,
+                    field_meta=meta,
+                )
+            )
+        except Exception as exc:
+            logger.debug(
+                "auth status report could not be serialized: %s", type(exc).__name__
+            )
+    return methods or None

{code_puppy_core_plugins-0.0.102 → code_puppy_core_plugins-0.0.104}/code_puppy_core_plugins/attachment_references/tool.py

@@ -21,6 +21,7 @@ from pydantic_ai import BinaryContent, RunContext
 from pydantic_ai.messages import UserPromptPart
 
 from code_puppy import config
+from code_puppy.error_logging import log_error
 
 TOOL_NAME = "save_attachments_as_references"
 
@@ -117,6 +118,7 @@ def register_save_attachments_as_references(agent: Any) -> None:
         try:
             paths = await asyncio.to_thread(_save_reference_images, images)
         except OSError as exc:
+            log_error(exc, context="save_attachments_as_references failed")
             return {
                 "success": False,
                 "error": f"Could not save reference images: {exc}",

{code_puppy_core_plugins-0.0.102 → code_puppy_core_plugins-0.0.104}/code_puppy_core_plugins/copilot_auth/register_callbacks.py

@@ -13,6 +13,7 @@ import logging
 from typing import Any, Dict, List, Optional, Tuple
 
 from code_puppy.callbacks import register_callback
+from code_puppy.command_line.utils import safe_input
 from code_puppy.messaging import emit_error, emit_info, emit_success, emit_warning
 
 from .config import COPILOT_AUTH_CONFIG
@@ -212,8 +213,9 @@ def _handle_copilot_login(command: str) -> None:
             "   Press Enter to use github.com."
         )
         try:
-            raw = input("GitHub host [github.com]: ").strip()
-            host = raw if raw else "github.com"
+            # safe_input, not input(): on Windows prompt_toolkit leaves the
+            # console in VT-input mode, so raw input() echoes escape codes.
+            host = safe_input("GitHub host [github.com]: ") or "github.com"
         except (EOFError, KeyboardInterrupt):
             emit_warning("Copilot login cancelled.")
             return

code_puppy_core_plugins-0.0.104/code_puppy_core_plugins/logfire_instrumentation/__init__.py

@@ -0,0 +1 @@
+"""Opt-in Logfire instrumentation of Code Puppy agent runs."""

code_puppy_core_plugins-0.0.104/code_puppy_core_plugins/logfire_instrumentation/instrumentation.py

@@ -0,0 +1,126 @@
+"""Opt-in Logfire instrumentation of pydantic-ai agent runs.
+
+Dormant unless the user opts in with ``/set enable_logfire true`` or a truthy
+``CODE_PUPPY_ENABLE_LOGFIRE``: until then nothing imports the SDK, warns, or
+touches the environment. Even when opted in, nothing leaves the machine
+without a write token (``send_to_logfire="if-token-present"``). Every failure
+degrades to "no telemetry", never to a broken CLI.
+"""
+
+from __future__ import annotations
+
+import os
+from typing import Any
+
+from . import legacy_core
+from .sdk import MISSING_SDK_HINT, sdk_available
+
+ENABLE_KEY = "enable_logfire"
+ENABLE_ENV = "CODE_PUPPY_ENABLE_LOGFIRE"
+_TRUTHY = frozenset({"1", "true", "yes", "on"})
+
+_active = False
+_agent_contexts: dict[str, Any] = {}
+
+
+def _truthy(value: object) -> bool:
+    return str(value or "").strip().lower() in _TRUTHY
+
+
+def opted_in() -> bool:
+    """A truthy env var opts in without touching ``puppy.cfg``."""
+    if _truthy(os.environ.get(ENABLE_ENV)):
+        return True
+    from code_puppy.config import get_value
+
+    return _truthy(get_value(ENABLE_KEY))
+
+
+def resolve_token() -> str | None:
+    """Prefer the user's own ``LOGFIRE_TOKEN``, then the onboarded project's."""
+    token = os.environ.get(legacy_core.TOKEN_ENV)
+    if token:
+        return token
+    from ..logfire_oauth.oauth import load_project_credentials
+
+    credentials = load_project_credentials()
+    return credentials.token if credentials else None
+
+
+def configure(token: str | None = None) -> bool:
+    """Configure Logfire when opted in; return whether instrumentation is live.
+
+    An explicit ``token`` (e.g. one onboarding just minted) beats
+    ``resolve_token()``. Safe to call again: the SDK is reconfigured in place.
+    """
+    global _active
+    _active = False
+
+    if not opted_in():
+        return False
+
+    from code_puppy.messaging import emit_system_message, emit_warning
+
+    legacy = legacy_core.loaded()
+    if legacy is not None:
+        legacy_core.export_token(token or resolve_token(), overwrite=True)
+        return bool(legacy.configure_logfire())
+
+    if not sdk_available():
+        emit_warning(MISSING_SDK_HINT)
+        return False
+
+    try:
+        import logfire
+
+        logfire.configure(
+            service_name="code-puppy",
+            token=token or resolve_token(),
+            send_to_logfire="if-token-present",
+            console=False,
+        )
+        logfire.instrument_pydantic_ai()
+    except Exception as exc:
+        emit_warning(f"Failed to configure Logfire: {exc}")
+        return False
+
+    _active = True
+    emit_system_message(
+        "Logfire instrumentation enabled - spans ship only if a Logfire "
+        "token is configured."
+    )
+    return True
+
+
+def capture_context(group_id: str) -> None:
+    """Remember the live agent span so a later cancellation can nest under it."""
+    if not _active:
+        return
+    try:
+        import logfire
+
+        _agent_contexts[group_id] = logfire.get_context()
+    except Exception:
+        return
+
+
+def clear_context(group_id: str) -> None:
+    """Discard trace context retained for a finished agent run."""
+    _agent_contexts.pop(group_id, None)
+
+
+def emit_cancellation(group_id: str) -> None:
+    """Log a cancellation as a child of its instrumented agent run."""
+    if not _active:
+        return
+    context = _agent_contexts.pop(group_id, None)
+    try:
+        import logfire
+
+        if context is None:
+            logfire.warning("Agent run cancelled", group_id=group_id)
+            return
+        with logfire.attach_context(context):
+            logfire.warning("Agent run cancelled", group_id=group_id)
+    except Exception:
+        return

code_puppy_core_plugins-0.0.104/code_puppy_core_plugins/logfire_instrumentation/legacy_core.py

@@ -0,0 +1,39 @@
+"""Bridge to Code Puppy cores that still ship their own Logfire wiring.
+
+Those cores configure Logfire themselves from ``code_puppy.observability``
+before the ``startup`` hook fires, and read the write token only from the
+environment. This module never imports that legacy module: it only finds it,
+or looks it up once core has imported it.
+
+Delete this module once the minimum supported core no longer ships
+``code_puppy.observability``.
+"""
+
+from __future__ import annotations
+
+import os
+import sys
+from types import ModuleType
+
+from .sdk import module_exists
+
+MODULE_NAME = "code_puppy.observability"
+TOKEN_ENV = "LOGFIRE_TOKEN"
+
+
+def present() -> bool:
+    """Return whether the installed core ships its own Logfire wiring."""
+    return module_exists(MODULE_NAME)
+
+
+def loaded() -> ModuleType | None:
+    """Return the legacy module if core already imported it."""
+    return sys.modules.get(MODULE_NAME)
+
+
+def export_token(token: str | None, *, overwrite: bool) -> None:
+    """Expose ``token`` to a legacy core, the only reader that needs the env."""
+    if not token or not present():
+        return
+    if overwrite or TOKEN_ENV not in os.environ:
+        os.environ[TOKEN_ENV] = token

code_puppy_core_plugins-0.0.104/code_puppy_core_plugins/logfire_instrumentation/register_callbacks.py

@@ -0,0 +1,67 @@
+"""Wire opt-in Logfire instrumentation into core's callback hooks."""
+
+from __future__ import annotations
+
+import logging
+
+from code_puppy.callbacks import register_callback
+from code_puppy.command_line.set_menu_schema import Setting, SettingsCategory
+from code_puppy_core_plugins.plugin_settings import register_settings
+
+from . import instrumentation, legacy_core
+
+logger = logging.getLogger(__name__)
+
+
+def _export_token_for_legacy_core() -> None:
+    """Legacy cores configure Logfire from the env before ``startup`` fires."""
+    try:
+        if legacy_core.present() and instrumentation.opted_in():
+            legacy_core.export_token(instrumentation.resolve_token(), overwrite=False)
+    except Exception:
+        logger.debug("Could not expose the Logfire token to core", exc_info=True)
+
+
+def _on_startup() -> None:
+    if legacy_core.present():
+        return
+    instrumentation.configure()
+
+
+def _on_agent_run_end(
+    _agent_name: str, _model_name: str, session_id: str | None = None, *_args, **_kw
+) -> None:
+    if session_id:
+        instrumentation.clear_context(session_id)
+
+
+def _register_event_stream_start() -> None:
+    try:
+        register_callback("agent_event_stream_start", instrumentation.capture_context)
+    except ValueError:
+        logger.debug("Core predates agent_event_stream_start; it captures context")
+
+
+_export_token_for_legacy_core()
+register_settings(
+    SettingsCategory(
+        "Features",
+        (
+            Setting(
+                key=instrumentation.ENABLE_KEY,
+                display_name="Logfire Instrumentation",
+                description=(
+                    "Send agent traces to your own Logfire project. Needs a "
+                    "write token and the code-puppy-core-plugins[logfire] extra."
+                ),
+                type_hint="bool",
+                effective_getter=instrumentation.opted_in,
+                requires_restart=True,
+            ),
+        ),
+    )
+)
+register_callback("startup", _on_startup)
+register_callback("agent_run_cancel", instrumentation.emit_cancellation)
+register_callback("agent_run_end", _on_agent_run_end)
+_register_event_stream_start()

code_puppy_core_plugins-0.0.104/code_puppy_core_plugins/logfire_instrumentation/sdk.py

@@ -0,0 +1,25 @@
+"""Discovery of the optional ``logfire`` SDK, shared by every Logfire plugin."""
+
+from __future__ import annotations
+
+import importlib.util
+import sys
+
+MISSING_SDK_HINT = (
+    "The optional 'logfire' SDK is not installed. Install the plugin extra and "
+    "restart Code Puppy, e.g. "
+    "uv tool install code-puppy --with 'code-puppy-core-plugins[logfire]'"
+)
+
+
+def module_exists(name: str) -> bool:
+    """Return whether ``name`` can be imported, without importing it."""
+    try:
+        return importlib.util.find_spec(name) is not None
+    except (ImportError, ValueError):
+        return False
+
+
+def sdk_available() -> bool:
+    """Return whether the ``logfire`` SDK is loaded or importable."""
+    return sys.modules.get("logfire") is not None or module_exists("logfire")

{code_puppy_core_plugins-0.0.102 → code_puppy_core_plugins-0.0.104}/code_puppy_core_plugins/logfire_oauth/oauth.py

@@ -309,7 +309,6 @@ def mint_write_token(
             response.json(), base_url=tokens.base_url
         )
         save_project_credentials(credentials)
-        os.environ["LOGFIRE_TOKEN"] = credentials.token
         return credentials
     except httpx.HTTPError as exc:
         raise OAuthError(