ccproxy-api 0.2.4__tar.gz → 0.2.5__tar.gz

{ccproxy_api-0.2.4 → ccproxy_api-0.2.5}/PKG-INFO

@@ -1,42 +1,42 @@
 Metadata-Version: 2.4
 Name: ccproxy-api
-Version: 0.2.4
+Version: 0.2.5
 Summary: API server that provides an Anthropic and OpenAI compatible interface over Claude Code, allowing to use your Claude OAuth account or over the API.
 License-File: LICENSE
 Requires-Python: >=3.11
-Requires-Dist: aiofiles>=24.1.0
-Requires-Dist: fastapi[standard]>=0.115.14
+Requires-Dist: aiofiles>=25.1.0
+Requires-Dist: fastapi[standard]>=0.119.0
 Requires-Dist: httpx[http2]>=0.28.1
 Requires-Dist: packaging>=25.0
-Requires-Dist: pydantic-settings>=2.4.0
-Requires-Dist: pydantic>=2.8.0
+Requires-Dist: pydantic-settings>=2.11.0
+Requires-Dist: pydantic>=2.12.2
 Requires-Dist: pyjwt>=2.10.1
-Requires-Dist: rich-toolkit>=0.14.8
-Requires-Dist: rich>=13.0.0
+Requires-Dist: rich-toolkit>=0.15.1
+Requires-Dist: rich>=14.2.0
 Requires-Dist: sortedcontainers>=2.4.0
 Requires-Dist: structlog>=25.4.0
-Requires-Dist: typer>=0.16.0
-Requires-Dist: typing-extensions>=4.0.0
-Requires-Dist: uvicorn>=0.34.0
+Requires-Dist: typer>=0.19.2
+Requires-Dist: typing-extensions>=4.15.0
+Requires-Dist: uvicorn>=0.37.0
 Provides-Extra: plugins-claude
-Requires-Dist: claude-agent-sdk>=0.1.0; extra == 'plugins-claude'
-Requires-Dist: keyring>=25.0.0; extra == 'plugins-claude'
+Requires-Dist: claude-agent-sdk>=0.1.4; extra == 'plugins-claude'
+Requires-Dist: keyring>=25.7.0; extra == 'plugins-claude'
 Requires-Dist: qrcode>=8.2; extra == 'plugins-claude'
 Provides-Extra: plugins-codex
 Requires-Dist: pyjwt>=2.10.1; extra == 'plugins-codex'
 Requires-Dist: qrcode>=8.2; extra == 'plugins-codex'
 Provides-Extra: plugins-mcp
-Requires-Dist: fastapi-mcp>=0.3.7; extra == 'plugins-mcp'
+Requires-Dist: fastapi-mcp>=0.4.0; extra == 'plugins-mcp'
 Provides-Extra: plugins-metrics
-Requires-Dist: prometheus-client>=0.22.1; extra == 'plugins-metrics'
+Requires-Dist: prometheus-client>=0.23.1; extra == 'plugins-metrics'
 Provides-Extra: plugins-storage
 Requires-Dist: duckdb-engine>=0.17.0; extra == 'plugins-storage'
-Requires-Dist: duckdb<1.4.0,>=1.1.0; extra == 'plugins-storage'
-Requires-Dist: sqlalchemy>=2.0.0; extra == 'plugins-storage'
-Requires-Dist: sqlmodel>=0.0.24; extra == 'plugins-storage'
+Requires-Dist: duckdb>=1.3.2; extra == 'plugins-storage'
+Requires-Dist: sqlalchemy>=2.0.44; extra == 'plugins-storage'
+Requires-Dist: sqlmodel>=0.0.27; extra == 'plugins-storage'
 Provides-Extra: plugins-tui
-Requires-Dist: aioconsole>=0.8.1; extra == 'plugins-tui'
-Requires-Dist: textual>=3.7.1; extra == 'plugins-tui'
+Requires-Dist: aioconsole>=0.8.2; extra == 'plugins-tui'
+Requires-Dist: textual>=6.3.0; extra == 'plugins-tui'
 Description-Content-Type: text/markdown
 
 # CCProxy API Server

{ccproxy_api-0.2.4 → ccproxy_api-0.2.5}/ccproxy/core/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.2.4'
-__version_tuple__ = version_tuple = (0, 2, 4)
+__version__ = version = '0.2.5'
+__version_tuple__ = version_tuple = (0, 2, 5)
 
 __commit_id__ = commit_id = None

{ccproxy_api-0.2.4 → ccproxy_api-0.2.5}/ccproxy/core/plugins/factories.py

@@ -14,6 +14,7 @@ from fastapi import APIRouter
 from ccproxy.models.provider import ProviderConfig
 from ccproxy.services.adapters.base import BaseAdapter
 from ccproxy.services.adapters.http_adapter import BaseHTTPAdapter
+from ccproxy.services.adapters.mock_adapter import MockAdapter
 from ccproxy.services.interfaces import (
     IMetricsCollector,
     IRequestTracer,
@@ -104,6 +105,7 @@ class BaseProviderPluginFactory(ProviderPluginFactory):
     cli_commands: list[CliCommandSpec] = []
     cli_arguments: list[CliArgumentSpec] = []
     tool_accumulator_class: type | None = None
+    use_mock_adapter_in_bypass_mode: bool = True
 
     def __init__(self) -> None:
         """Initialize factory with manifest built from class attributes."""
@@ -215,6 +217,24 @@ class BaseProviderPluginFactory(ProviderPluginFactory):
         Returns:
             Adapter instance
         """
+        settings = context.get("settings")
+        service_container = context.get("service_container")
+        if settings and getattr(settings.server, "bypass_mode", False):
+            if not service_container:
+                raise RuntimeError(
+                    f"Cannot initialize plugin '{self.plugin_name}' in bypass mode: "
+                    "service container is required to create mock adapter. "
+                    "This is likely a configuration issue."
+                )
+            logger.warning(
+                "plugin_bypass_mode_enabled",
+                plugin=self.plugin_name,
+                adapter=self.adapter_class.__name__,
+                category="lifecycle",
+            )
+            if self.use_mock_adapter_in_bypass_mode:
+                return MockAdapter(service_container.get_mock_handler())
+
         # Extract services from context (one-time extraction)
         http_pool_manager: HTTPPoolManager | None = cast(
             "HTTPPoolManager | None", context.get("http_pool_manager")
@@ -232,7 +252,6 @@ class BaseProviderPluginFactory(ProviderPluginFactory):
         config = context.get("config")
 
         # Get all adapter dependencies from service container
-        service_container = context.get("service_container")
         if not service_container:
             raise RuntimeError("Service container is required for adapter services")
 
@@ -268,6 +287,8 @@ class BaseProviderPluginFactory(ProviderPluginFactory):
                 if hasattr(context, "get")
                 else None,
             }
+            if settings and getattr(settings.server, "bypass_mode", False):
+                adapter_kwargs["mock_handler"] = service_container.get_mock_handler()
             if self.tool_accumulator_class:
                 adapter_kwargs["tool_accumulator_class"] = self.tool_accumulator_class
 
@@ -303,6 +324,9 @@ class BaseProviderPluginFactory(ProviderPluginFactory):
                 "model_mapper": context.get("model_mapper")
                 if hasattr(context, "get")
                 else None,
+                "mock_handler": service_container.get_mock_handler()
+                if settings and getattr(settings.server, "bypass_mode", False)
+                else None,
             }
             if self.tool_accumulator_class:
                 non_http_adapter_kwargs["tool_accumulator_class"] = (

{ccproxy_api-0.2.4 → ccproxy_api-0.2.5}/ccproxy/llms/formatters/context.py

@@ -11,6 +11,9 @@ _INSTRUCTIONS_VAR: ContextVar[str | None] = ContextVar(
     "formatter_instructions", default=None
 )
 _TOOLS_VAR: ContextVar[list[Any] | None] = ContextVar("formatter_tools", default=None)
+_OPENAI_THINKING_XML_VAR: ContextVar[bool | None] = ContextVar(
+    "formatter_openai_thinking_xml", default=None
+)
 
 
 def register_request(request: Any | None, instructions: str | None = None) -> None:
@@ -114,3 +117,24 @@ def get_last_request_tools() -> list[Any] | None:
 
     cached = _TOOLS_VAR.get()
     return list(cached) if cached else None
+
+
+def register_openai_thinking_xml(enabled: bool | None) -> None:
+    """Cache OpenAI thinking serialization preference for active conversions.
+
+    Args:
+        enabled: Whether thinking blocks should be serialized with XML wrappers.
+            ``None`` means downstream conversion logic should use its default.
+
+    Note:
+        The value is stored in a ``ContextVar``, so concurrent async requests
+        keep independent preferences without leaking into each other.
+    """
+
+    _OPENAI_THINKING_XML_VAR.set(enabled)
+
+
+def get_openai_thinking_xml() -> bool | None:
+    """Return the OpenAI thinking serialization preference for active conversions."""
+
+    return _OPENAI_THINKING_XML_VAR.get()

{ccproxy_api-0.2.4 → ccproxy_api-0.2.5}/ccproxy/llms/formatters/openai_to_openai/responses.py

@@ -15,6 +15,7 @@ from ccproxy.llms.formatters.common import (
     convert_openai_responses_usage_to_completion_usage,
     merge_thinking_segments,
 )
+from ccproxy.llms.formatters.context import get_openai_thinking_xml
 from ccproxy.llms.models import openai as openai_models
 
 from ._helpers import (
@@ -333,6 +334,10 @@ def convert__openai_responses_to_openai_chat__response(
     response: openai_models.ResponseObject,
 ) -> openai_models.ChatCompletionResponse:
     """Convert an OpenAI ResponseObject to a ChatCompletionResponse."""
+    include_thinking = get_openai_thinking_xml()
+    if include_thinking is None:
+        include_thinking = True
+
     text_segments: list[str] = []
     added_reasoning: set[tuple[str, str]] = set()
     tool_calls: list[openai_models.ToolCall] = []
@@ -353,7 +358,7 @@ def convert__openai_responses_to_openai_chat__response(
                     if thinking_text and len(thinking_text) > 30
                     else thinking_text,
                 )
-                if thinking_text:
+                if include_thinking and thinking_text:
                     key = (signature or "", thinking_text)
                     if key not in added_reasoning:
                         text_segments.append(_wrap_thinking(signature, thinking_text))

{ccproxy_api-0.2.4 → ccproxy_api-0.2.5}/ccproxy/llms/formatters/openai_to_openai/streams.py

@@ -27,16 +27,14 @@ from ccproxy.llms.formatters.context import (
     get_last_instructions,
     get_last_request,
     get_last_request_tools,
+    get_openai_thinking_xml,
     register_request,
     register_request_tools,
 )
 from ccproxy.llms.models import openai as openai_models
 from ccproxy.llms.streaming.accumulators import OpenAIAccumulator
 
-from ._helpers import (
-    _convert_tools_chat_to_responses,
-    _get_attr,
-)
+from ._helpers import _convert_tools_chat_to_responses, _get_attr
 from .requests import _build_responses_payload_from_chat_request
 from .responses import (
     _collect_reasoning_segments,
@@ -61,6 +59,10 @@ class OpenAIResponsesToChatStreamAdapter:
         async def generator() -> AsyncGenerator[
             openai_models.ChatCompletionChunk, None
         ]:
+            include_thinking = get_openai_thinking_xml()
+            if include_thinking is None:
+                include_thinking = True
+
             model_id = ""
             role_sent = False
 
@@ -537,7 +539,7 @@ class OpenAIResponsesToChatStreamAdapter:
                             for entry in summary_list:
                                 text = _get_attr(entry, "text")
                                 signature = _get_attr(entry, "signature")
-                                if isinstance(text, str) and text:
+                                if include_thinking and isinstance(text, str) and text:
                                     chunk_text = _wrap_thinking(signature, text)
                                     sequence_counter += 1
                                     yield openai_models.ChatCompletionChunk(

{ccproxy_api-0.2.4 → ccproxy_api-0.2.5}/ccproxy/llms/models/anthropic.py

@@ -352,8 +352,16 @@ class ThinkingConfigDisabled(ThinkingConfigBase):
     type: Literal["disabled"] = Field(default="disabled", alias="type")
 
 
+class ThinkingConfigAdaptive(ThinkingConfigBase):
+    """Configuration for adaptive thinking (Claude 4-6+)."""
+
+    type: Literal["adaptive"] = Field(default="adaptive", alias="type")
+    display: Literal["summarized", "omitted"] | None = None
+
+
 ThinkingConfig = Annotated[
-    ThinkingConfigEnabled | ThinkingConfigDisabled, Field(discriminator="type")
+    ThinkingConfigEnabled | ThinkingConfigDisabled | ThinkingConfigAdaptive,
+    Field(discriminator="type"),
 ]
 
 

{ccproxy_api-0.2.4 → ccproxy_api-0.2.5}/ccproxy/plugins/claude_api/adapter.py

@@ -85,15 +85,14 @@ class ClaudeAPIAdapter(BaseHTTPAdapter):
         # Always set Authorization from OAuth-managed access token
         filtered_headers["authorization"] = f"Bearer {token_value}"
 
-        # PATCH: Add Computer Use beta headers for Anthropic API
-        # These are required for browser automation tools to work
+        # Minimal beta tags required for OAuth-based Claude Code auth
         filtered_headers["anthropic-version"] = "2023-06-01"
-        filtered_headers["anthropic-beta"] = "computer-use-2025-01-24"
+        filtered_headers["anthropic-beta"] = "claude-code-20250219,oauth-2025-04-20"
 
-        # Add CLI headers if available, but never allow overriding auth
+        # Add CLI headers if available, but never allow overriding auth or beta
         cli_headers = self._collect_cli_headers()
         if cli_headers:
-            blocked_overrides = {"authorization", "x-api-key"}
+            blocked_overrides = {"authorization", "x-api-key", "anthropic-beta"}
             for key, value in cli_headers.items():
                 lk = key.lower()
                 if lk in blocked_overrides:

{ccproxy_api-0.2.4 → ccproxy_api-0.2.5}/ccproxy/plugins/codex/adapter.py

@@ -1,4 +1,5 @@
 import contextlib
+import copy
 import json
 import uuid
 from typing import Any, cast
@@ -16,6 +17,7 @@ from ccproxy.core.plugins.interfaces import (
 )
 from ccproxy.services.adapters.chain_composer import compose_from_chain
 from ccproxy.services.adapters.http_adapter import BaseHTTPAdapter
+from ccproxy.services.adapters.mock_adapter import MockAdapter
 from ccproxy.services.handler_config import HandlerConfig
 from ccproxy.streaming import DeferredStreaming, StreamingBufferService
 from ccproxy.utils.headers import (
@@ -57,18 +59,16 @@ class CodexAdapter(BaseHTTPAdapter):
         # Context + request info
         ctx = request.state.context
         self._ensure_tool_accumulator(ctx)
+        if self.mock_handler:
+            return await MockAdapter(self.mock_handler).handle_request(request)
+
         endpoint = ctx.metadata.get("endpoint", "")
         body = await request.body()
         body = await self._map_request_model(ctx, body)
         headers = extract_request_headers(request)
 
         # Determine client streaming intent from body flag (fallback to False)
-        wants_stream = False
-        try:
-            data = json.loads(body.decode()) if body else {}
-            wants_stream = bool(data.get("stream", False))
-        except Exception:  # Malformed/missing JSON -> assume non-streaming
-            wants_stream = False
+        wants_stream = self._detect_streaming_intent(body, headers)
         logger.trace(
             "codex_adapter_request_intent",
             wants_stream=wants_stream,
@@ -256,37 +256,58 @@ class CodexAdapter(BaseHTTPAdapter):
     async def prepare_provider_request(
         self, body: bytes, headers: dict[str, str], endpoint: str
     ) -> tuple[bytes, dict[str, str]]:
-        token_value = await self._resolve_access_token()
+        filtered_headers = await self.prepare_provider_headers(headers)
 
-        # Get profile to extract chatgpt_account_id
-        profile = await self.token_manager.get_profile_quick()
-        chatgpt_account_id = (
-            getattr(profile, "chatgpt_account_id", None) if profile else None
-        )
+        if self._request_body_is_encoded(headers):
+            return body, filtered_headers
+
+        # Body will be re-serialized as plain JSON; drop stale encoding header
+        filtered_headers.pop("content-encoding", None)
 
         # Parse body (format conversion is now handled by format chain)
         body_data = json.loads(body.decode()) if body else {}
+        if self._should_apply_detection_payload():
+            body_data = self._apply_request_template(body_data)
+        else:
+            body_data = self._normalize_input_messages(body_data)
 
-        # Inject instructions mandatory for being allow to
-        # to used the Codex API endpoint
-        # Fetch detected instructions from detection service
-        instructions = self._get_instructions()
+        detected_instructions = (
+            self._get_instructions() if self._should_apply_detection_payload() else ""
+        )
 
         existing_instructions = body_data.get("instructions")
         if isinstance(existing_instructions, str) and existing_instructions:
-            if instructions:
-                instructions = instructions + "\n" + existing_instructions
-            else:
-                instructions = existing_instructions
+            instructions = (
+                detected_instructions + "\n" + existing_instructions
+                if detected_instructions
+                else existing_instructions
+            )
+        else:
+            instructions = detected_instructions
+
+        if instructions:
+            body_data["instructions"] = instructions
+        else:
+            body_data.pop("instructions", None)
 
-        body_data["instructions"] = instructions
+        body_data = self._sanitize_provider_body(body_data)
+
+        return json.dumps(body_data).encode(), filtered_headers
+
+    def _sanitize_provider_body(self, body_data: dict[str, Any]) -> dict[str, Any]:
+        """Apply Codex-specific payload sanitization shared by all request paths."""
 
         # Codex backend requires stream=true, always override
         body_data["stream"] = True
         body_data["store"] = False
 
         # Remove unsupported keys for Codex
-        for key in ("max_output_tokens", "max_completion_tokens", "temperature"):
+        for key in (
+            "max_output_tokens",
+            "max_completion_tokens",
+            "max_tokens",
+            "temperature",
+        ):
             body_data.pop(key, None)
 
         list_input = body_data.get("input", [])
@@ -295,12 +316,23 @@ class CodexAdapter(BaseHTTPAdapter):
             input for input in list_input if input.get("type") != "item_reference"
         ]
 
-        #
         # Remove any prefixed metadata fields that shouldn't be sent to the API
         body_data = self._remove_metadata_fields(body_data)
 
-        # Filter and add headers
+        return body_data
+
+    async def prepare_provider_headers(self, headers: dict[str, str]) -> dict[str, str]:
+        token_value = await self._resolve_access_token()
+
+        profile = await self.token_manager.get_profile_quick()
+        chatgpt_account_id = (
+            getattr(profile, "chatgpt_account_id", None) if profile else None
+        )
+
         filtered_headers = filter_request_headers(headers, preserve_auth=False)
+        content_encoding = headers.get("content-encoding")
+        if content_encoding:
+            filtered_headers["content-encoding"] = content_encoding
 
         session_id = filtered_headers.get("session_id") or str(uuid.uuid4())
         conversation_id = filtered_headers.get("conversation_id") or str(uuid.uuid4())
@@ -318,10 +350,10 @@ class CodexAdapter(BaseHTTPAdapter):
         filtered_headers.update(base_headers)
 
         cli_headers = self._collect_cli_headers()
-        if cli_headers:
-            filtered_headers.update(cli_headers)
+        for key, value in cli_headers.items():
+            filtered_headers.setdefault(key, value)
 
-        return json.dumps(body_data).encode(), filtered_headers
+        return filtered_headers
 
     async def process_provider_response(
         self, response: httpx.Response, endpoint: str
@@ -453,6 +485,10 @@ class CodexAdapter(BaseHTTPAdapter):
         if not self.streaming_handler:
             # Fallback to base behavior
             return await super().handle_streaming(request, endpoint, **kwargs)
+        if self.mock_handler:
+            return await MockAdapter(self.mock_handler).handle_streaming(
+                request, endpoint, **kwargs
+            )
 
         # Get context
         ctx = request.state.context
@@ -581,6 +617,73 @@ class CodexAdapter(BaseHTTPAdapter):
 
         return cleaned_data
 
+    def _apply_request_template(self, data: dict[str, Any]) -> dict[str, Any]:
+        if not isinstance(data, dict):
+            return data
+
+        template = self._get_request_template()
+        if not template:
+            return self._normalize_input_messages(data)
+
+        merged = copy.deepcopy(data)
+
+        for key in ("include", "parallel_tool_calls", "reasoning", "tool_choice"):
+            if key not in merged and key in template:
+                merged[key] = copy.deepcopy(template[key])
+
+        if not merged.get("tools") and isinstance(template.get("tools"), list):
+            merged["tools"] = copy.deepcopy(template["tools"])
+
+        if "prompt_cache_key" not in merged:
+            prompt_cache_key = template.get("prompt_cache_key")
+            if isinstance(prompt_cache_key, str) and prompt_cache_key:
+                merged["prompt_cache_key"] = str(uuid.uuid4())
+
+        return self._normalize_input_messages(merged)
+
+    def _normalize_input_messages(self, data: dict[str, Any]) -> dict[str, Any]:
+        input_items = data.get("input")
+        if not isinstance(input_items, list):
+            return data
+
+        normalized_items: list[Any] = []
+        for item in input_items:
+            if (
+                isinstance(item, dict)
+                and "type" not in item
+                and "role" in item
+                and "content" in item
+            ):
+                normalized_item = dict(item)
+                normalized_item["type"] = "message"
+                normalized_items.append(normalized_item)
+                continue
+
+            normalized_items.append(item)
+
+        result = dict(data)
+        result["input"] = normalized_items
+        return result
+
+    def _request_body_is_encoded(self, headers: dict[str, str]) -> bool:
+        encoding = headers.get("content-encoding", "").strip().lower()
+        return bool(encoding and encoding != "identity")
+
+    def _detect_streaming_intent(self, body: bytes, headers: dict[str, str]) -> bool:
+        if self._request_body_is_encoded(headers):
+            accept = headers.get("accept", "").lower()
+            return "text/event-stream" in accept
+
+        try:
+            data = json.loads(body.decode()) if body else {}
+            return bool(data.get("stream", False))
+        except Exception:
+            accept = headers.get("accept", "").lower()
+            return "text/event-stream" in accept
+
+    def _should_apply_detection_payload(self) -> bool:
+        return bool(getattr(self.config, "inject_detection_payload", True))
+
     def _get_instructions(self) -> str:
         if not self.detection_service:
             return ""
@@ -601,6 +704,16 @@ class CodexAdapter(BaseHTTPAdapter):
 
         return ""
 
+    def _get_request_template(self) -> dict[str, Any]:
+        if not self.detection_service:
+            return {}
+
+        prompts = self.detection_service.get_detected_prompts()
+        if isinstance(prompts.raw, dict) and prompts.raw:
+            return prompts.raw
+
+        return {}
+
     def adapt_error(self, error_body: dict[str, Any]) -> dict[str, Any]:
         """Convert Codex error format to appropriate API error format.
 

{ccproxy_api-0.2.4 → ccproxy_api-0.2.5}/ccproxy/plugins/codex/config.py

@@ -124,6 +124,13 @@ class CodexSettings(ProviderConfig):
     enable_format_registry: bool = Field(
         default=True, description="Whether to enable format adapter registry"
     )
+    inject_detection_payload: bool = Field(
+        default=True,
+        description=(
+            "Whether to inject the captured Codex CLI instructions/template into "
+            "provider requests. Disable this for generic OpenAI-compatible API usage."
+        ),
+    )
 
     # Detection configuration
     detection_home_mode: Literal["temp", "home"] = Field(

{ccproxy_api-0.2.4 → ccproxy_api-0.2.5}/ccproxy/plugins/codex/detection_service.py

@@ -12,6 +12,7 @@ from pathlib import Path
 from typing import Any, cast
 
 from fastapi import FastAPI, Request, Response
+from pydantic import ValidationError
 
 from ccproxy.config.settings import Settings
 from ccproxy.config.utils import get_ccproxy_cache_dir
@@ -43,6 +44,7 @@ class CodexDetectionService:
     ignores_header: list[str] = [
         "host",
         "content-length",
+        "content-encoding",
         "authorization",
         "x-api-key",
         "session_id",
@@ -133,17 +135,40 @@ class CodexDetectionService:
         """Return cached headers as structured data."""
 
         data = self.get_cached_data()
-        if not data:
-            return DetectedHeaders()
-        return data.headers
+        headers = data.headers if data else DetectedHeaders()
+
+        required_headers = {
+            "accept",
+            "content-type",
+            "openai-beta",
+            "originator",
+            "version",
+        }
+        missing_required = [key for key in required_headers if not headers.get(key)]
+        if not missing_required:
+            return headers
+
+        fallback = self._safe_fallback_data()
+        if fallback is None:
+            return headers
+
+        merged_headers = fallback.headers.as_dict()
+        merged_headers.update(
+            {key: value for key, value in headers.as_dict().items() if value}
+        )
+        return DetectedHeaders(merged_headers)
 
     def get_detected_prompts(self) -> DetectedPrompts:
         """Return cached prompt metadata as structured data."""
 
         data = self.get_cached_data()
-        if not data:
-            return DetectedPrompts()
-        return data.prompts
+        prompts = data.prompts if data else DetectedPrompts()
+
+        fallback = self._safe_fallback_data()
+        if fallback is None:
+            return prompts
+
+        return self._merge_detected_prompts(prompts, fallback.prompts)
 
     def get_ignored_headers(self) -> list[str]:
         """Headers that should be ignored when forwarding CLI values."""
@@ -496,6 +521,36 @@ class CodexDetectionService:
             fallback_data_dict = json.load(f)
             return CodexCacheData.model_validate(fallback_data_dict)
 
+    def _safe_fallback_data(self) -> CodexCacheData | None:
+        """Best-effort fallback data loader for partial detection caches."""
+        try:
+            return self._get_fallback_data()
+        except (OSError, json.JSONDecodeError, ValidationError):
+            logger.debug(
+                "safe_fallback_data_load_failed", exc_info=True, category="plugin"
+            )
+            return None
+
+    @staticmethod
+    def _merge_detected_prompts(
+        prompts: DetectedPrompts, fallback: DetectedPrompts
+    ) -> DetectedPrompts:
+        """Merge partial prompt caches with fallback defaults."""
+
+        prompt_raw = prompts.raw if isinstance(prompts.raw, dict) else {}
+        fallback_raw = fallback.raw if isinstance(fallback.raw, dict) else {}
+        merged_raw = dict(fallback_raw)
+        merged_raw.update(prompt_raw)
+
+        instructions = prompts.instructions or fallback.instructions
+        system = prompts.system if prompts.system is not None else fallback.system
+
+        return DetectedPrompts(
+            instructions=instructions,
+            system=system,
+            raw=merged_raw,
+        )
+
     def invalidate_cache(self) -> None:
         """Clear all cached detection data."""
         # Clear the async cache for _get_codex_version

{ccproxy_api-0.2.4 → ccproxy_api-0.2.5}/ccproxy/plugins/codex/plugin.py

@@ -222,6 +222,7 @@ class CodexFactory(BaseProviderPluginFactory):
     """Factory for Codex provider plugin."""
 
     cli_safe = False  # Heavy provider plugin - not safe for CLI
+    use_mock_adapter_in_bypass_mode = False
 
     # Plugin configuration via class attributes
     plugin_name = "codex"