crabcode 0.1.9__tar.gz → 0.1.10__tar.gz

{crabcode-0.1.9 → crabcode-0.1.10}/CLIENT_PACKAGING.md

@@ -12,7 +12,7 @@ runner, then reuses those bundles for the extensions and installers.
 
 The workflow must be committed before creating the release tag. The tag must be
 the version in the checked-out client manifests, with an optional `v` prefix
-(for example, `0.1.9` or `v0.1.9`). Version mismatches fail before native builds.
+(for example, `0.1.10` or `v0.1.10`). Version mismatches fail before native builds.
 Use a new version when changing published packages; existing registry versions
 are not replaced. The independent `python-publish.yml` workflow continues to
 handle Python/PyPI publishing.

{crabcode-0.1.9 → crabcode-0.1.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: crabcode
-Version: 0.1.9
+Version: 0.1.10
 Summary: CrabCode - AI coding assistant in the terminal
 Requires-Python: >=3.10
 Requires-Dist: anthropic>=0.40.0

{crabcode-0.1.9 → crabcode-0.1.10}/packages/cli/pyproject.toml

@@ -1,11 +1,11 @@
 [project]
 name = "crabcode-cli"
 # Synced from packages/core/crabcode_core/_version.py by scripts/sync_version.py.
-version = "0.1.9"
+version = "0.1.10"
 description = "CrabCode CLI - terminal frontend for CrabCode"
 requires-python = ">=3.10"
 dependencies = [
-    "crabcode-core>=0.1.9",
+    "crabcode-core>=0.1.10",
     "typer>=0.12.0",
     "rich>=13.0.0",
     "prompt-toolkit>=3.0.0",

{crabcode-0.1.9 → crabcode-0.1.10}/packages/computer-use/Cargo.lock

@@ -402,7 +402,7 @@ dependencies = [
 
 [[package]]
 name = "crabcode-computer-use-core"
-version = "0.1.9"
+version = "0.1.10"
 dependencies = [
  "base64",
  "core-foundation",
@@ -423,7 +423,7 @@ dependencies = [
 
 [[package]]
 name = "crabcode-computer-use-host"
-version = "0.1.9"
+version = "0.1.10"
 dependencies = [
  "cc",
  "crabcode-computer-use-core",

{crabcode-0.1.9 → crabcode-0.1.10}/packages/computer-use/core/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "crabcode-computer-use-core"
-version = "0.1.9"
+version = "0.1.10"
 edition = "2021"
 description = "CrabCode native Computer Use engine shared by all clients"
 

{crabcode-0.1.9 → crabcode-0.1.10}/packages/computer-use/host/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "crabcode-computer-use-host"
-version = "0.1.9"
+version = "0.1.10"
 edition = "2021"
 
 [[bin]]

{crabcode-0.1.9 → crabcode-0.1.10}/packages/core/crabcode_core/_version.py

@@ -1,3 +1,3 @@
 """Single source of truth for the CrabCode release version."""
 
-VERSION = "0.1.9"
+VERSION = "0.1.10"

{crabcode-0.1.9 → crabcode-0.1.10}/packages/core/crabcode_core/api/anthropic_adapter.py

@@ -183,22 +183,17 @@ class AnthropicAdapter(APIAdapter):
             return
 
         payload = dict(params)
+        payload.update(payload.pop("extra_body", {}))
         payload["stream"] = True
-
-        timeout = httpx.Timeout(
-            float(self.config.timeout),
-            connect=min(float(self.config.timeout), 10.0),
-            read=float(self.config.timeout),
-            write=float(self.config.timeout),
-        )
-        from crabcode_core.api.network import http_options
+        from crabcode_core.api.network import http_options, request_timeout, retry_stream_context
+        timeout = payload.pop("timeout", request_timeout(self.config))
         async with httpx.AsyncClient(timeout=timeout, **http_options(self.config)) as client:
-            async with client.stream(
+            async with retry_stream_context(self.config, lambda: client.stream(
                 "POST",
                 url,
                 headers=self._manual_headers(),
                 json=payload,
-            ) as response:
+            )) as response:
                 content_type = response.headers.get("content-type", "")
                 if response.status_code >= 400:
                     body = await response.aread()
@@ -425,11 +420,24 @@ class AnthropicAdapter(APIAdapter):
                 "budget_tokens": config.thinking_budget,
             }
 
-        if config.reasoning_effort in {"low", "medium", "high", "xhigh", "max"}:
-            params["output_config"] = {"effort": config.reasoning_effort}
+        reasoning_effort = (
+            config.reasoning_effort
+            if config.reasoning_effort is not None
+            else self.config.reasoning_effort
+        )
+        if reasoning_effort == "minimal":
+            reasoning_effort = "low"
+        if reasoning_effort in {"low", "medium", "high", "xhigh", "max"}:
+            params["output_config"] = {"effort": reasoning_effort}
+        elif reasoning_effort == "none":
+            params["thinking"] = {"type": "disabled"}
 
         if config.temperature is not None:
             params["temperature"] = config.temperature
+        if config.stop_sequences is not None:
+            params["stop_sequences"] = safe_utf8_json_tree(config.stop_sequences)
+        if self.config.extra_body:
+            params["extra_body"] = safe_utf8_json_tree(self.config.extra_body)
 
         return params
 
@@ -441,8 +449,9 @@ class AnthropicAdapter(APIAdapter):
         if isinstance(self, (BedrockAdapter, VertexAdapter)):
             return None
         payload = self._request_params(messages, system, tools, config)
-        payload.pop("max_tokens", None)
-        payload.pop("temperature", None)
+        payload.update(payload.pop("extra_body", {}))
+        supported = {"model", "messages", "system", "tools", "tool_choice", "thinking"}
+        payload = {key: value for key, value in payload.items() if key in supported}
         headers = {key: value for key, value in self._manual_headers().items()
                    if key.lower() != "accept"}
         headers["accept"] = "application/json"
@@ -463,6 +472,13 @@ class AnthropicAdapter(APIAdapter):
         use_httpx_stream = transport == "httpx" or (
             transport == "auto" and bool(self.config.base_url)
         )
+        # Cloud platforms need their SDK's signing/authentication and URL format.
+        if isinstance(self, (BedrockAdapter, VertexAdapter)):
+            use_httpx_stream = False
+        from crabcode_core.api.network import request_timeout
+        params["timeout"] = request_timeout(
+            config, None if use_httpx_stream else self._sdk, fallback=self.config,
+        )
         stream = (
             self._stream_message_httpx(params) if use_httpx_stream
             else self._stream_message_sdk(params)
@@ -510,7 +526,8 @@ class AnthropicAdapter(APIAdapter):
         current_block_type = ""
         current_block_id = ""
 
-        async with self.client.messages.stream(**params) as stream:
+        from crabcode_core.api.network import retry_stream_context
+        async with retry_stream_context(self.config, lambda: self.client.messages.stream(**params)) as stream:
             async for event in stream:
                 event_type = getattr(event, "type", "")
 
@@ -633,7 +650,14 @@ class BedrockAdapter(AnthropicAdapter):
     def __init__(self, config: ApiConfig):
         self.config = config
         from crabcode_core.api.network import sdk_options
-        self.client = anthropic.AsyncAnthropicBedrock(**sdk_options(config, self._sdk))
+        kwargs: dict[str, Any] = {}
+        if config.base_url:
+            kwargs["base_url"] = config.base_url
+        if config.http_headers:
+            kwargs["default_headers"] = config.http_headers
+        if config.api_key_env and os.environ.get(config.api_key_env):
+            kwargs["api_key"] = os.environ[config.api_key_env]
+        self.client = anthropic.AsyncAnthropicBedrock(**kwargs, **sdk_options(config, self._sdk))
 
 
 class VertexAdapter(AnthropicAdapter):
@@ -642,8 +666,16 @@ class VertexAdapter(AnthropicAdapter):
     def __init__(self, config: ApiConfig):
         from crabcode_core.api.network import sdk_options
         self.config = config
+        kwargs: dict[str, Any] = {}
+        if config.base_url:
+            kwargs["base_url"] = config.base_url
+        if config.http_headers:
+            kwargs["default_headers"] = config.http_headers
+        if config.api_key_env and os.environ.get(config.api_key_env):
+            kwargs["access_token"] = os.environ[config.api_key_env]
         self.client = anthropic.AsyncAnthropicVertex(
             region=os.environ.get("CLOUD_ML_REGION", "us-east5"),
             project_id=os.environ.get("ANTHROPIC_VERTEX_PROJECT_ID"),
+            **kwargs,
             **sdk_options(config, self._sdk),
         )

{crabcode-0.1.9 → crabcode-0.1.10}/packages/core/crabcode_core/api/azure_adapter.py

@@ -24,8 +24,7 @@ class AzureOpenAIAdapter(OpenAIAdapter):
     """
 
     def __init__(self, config: ApiConfig):
-        # Azure deployment name: env override takes precedence
-        self._deployment_override = os.environ.get("AZURE_OPENAI_DEPLOYMENT")
+        self._deployment_override = config.azure_deployment or os.environ.get("AZURE_OPENAI_DEPLOYMENT")
         super().__init__(config)
 
     def _create_client(self, config: ApiConfig) -> Any:
@@ -40,12 +39,12 @@ class AzureOpenAIAdapter(OpenAIAdapter):
             api_key = os.environ.get("AZURE_OPENAI_API_KEY")
 
         # --- Azure endpoint ---
-        azure_endpoint = os.environ.get("AZURE_OPENAI_ENDPOINT")
+        azure_endpoint = config.azure_endpoint or os.environ.get("AZURE_OPENAI_ENDPOINT")
         if not azure_endpoint and config.base_url:
             azure_endpoint = config.base_url
 
         # --- API version ---
-        api_version = os.environ.get("AZURE_OPENAI_API_VERSION", "2024-10-21")
+        api_version = config.azure_api_version or os.environ.get("AZURE_OPENAI_API_VERSION", "2024-10-21")
 
         kwargs: dict[str, Any] = {}
         if api_key:

{crabcode-0.1.9 → crabcode-0.1.10}/packages/core/crabcode_core/api/base.py

@@ -79,9 +79,9 @@ class ModelConfig:
     thinking_budget: int = 10000
     temperature: float | None = None
     stop_sequences: list[str] | None = None
-    timeout: int = 300  # seconds
+    timeout: int | None = None  # seconds; None inherits the adapter configuration
     context_window: int = 0  # 0 means unknown / not resolved yet
-    reasoning_effort: str | None = None  # call-level override for Responses-style APIs
+    reasoning_effort: str | None = None  # call-level override for the provider's reasoning effort
 
 
 @dataclass

{crabcode-0.1.9 → crabcode-0.1.10}/packages/core/crabcode_core/api/codex_adapter.py

@@ -795,13 +795,15 @@ class CodexAdapter(APIAdapter):
         self,
         params: dict[str, Any],
     ) -> AsyncGenerator[StreamChunk, None]:
+        params = dict(params)
+        from crabcode_core.api.network import http_options, request_timeout
+        timeout = params.pop("timeout", request_timeout(self.config))
         url = f"{self._base_url.rstrip('/')}/responses"
         active_calls: dict[str, dict[str, str]] = {}
         finalized_call_items: set[str] = set()
         saw_terminal_event = False
 
-        from crabcode_core.api.network import http_options, request_timeout
-        async with httpx.AsyncClient(timeout=request_timeout(self.config), **http_options(self.config)) as client:
+        async with httpx.AsyncClient(timeout=timeout, **http_options(self.config)) as client:
             async with self._httpx_stream_with_retry(
                 client,
                 url=url,
@@ -1026,6 +1028,8 @@ class CodexAdapter(APIAdapter):
         tools: list[dict[str, Any]], config: ModelConfig,
     ) -> dict[str, Any]:
         """Share input serialization between generation and server counting."""
+        if config.stop_sequences:
+            raise ValueError("The Responses API does not support stop_sequences")
         model = config.model or self.config.model or "codex-mini-latest"
 
         # Responses API uses 'instructions' for system prompt
@@ -1067,11 +1071,9 @@ class CodexAdapter(APIAdapter):
             else self.config.reasoning_effort
         )
         if reasoning_effort is not None:
-            if reasoning_effort != "none":
-                params["reasoning"] = {
-                    "effort": reasoning_effort,
-                    "summary": "auto",
-                }
+            params["reasoning"] = {"effort": reasoning_effort}
+            if reasoning_effort != "none" and config.thinking_enabled:
+                params["reasoning"]["summary"] = "auto"
         elif config.thinking_enabled:
             # Backward-compatible mapping from thinking_budget to reasoning effort
             budget = config.thinking_budget
@@ -1120,6 +1122,9 @@ class CodexAdapter(APIAdapter):
         sdk_params = self._request_params(messages, system, tools, config)
         raw_params = dict(sdk_params)
         raw_params.update(raw_params.pop("extra_body", {}))
+        from crabcode_core.api.network import request_timeout
+        sdk_params["timeout"] = request_timeout(config, getattr(self, "_sdk", None), fallback=self.config)
+        raw_params["timeout"] = request_timeout(config, fallback=self.config)
 
         if self._using_codex_oauth:
             # The Codex OAuth endpoint does not support server-side response

{crabcode-0.1.9 → crabcode-0.1.10}/packages/core/crabcode_core/api/gemini_adapter.py

@@ -12,8 +12,8 @@ class GeminiAdapter(OpenAIAdapter):
     Google Gemini has provided an OpenAI-compatible endpoint since late 2024
     (``https://generativelanguage.googleapis.com/v1beta/openai/``), so we
     simply inherit from :class:`OpenAIAdapter` and pre-fill the base URL,
-    API key environment variable, and disable thinking (not supported on the
-    OpenAI-compatible surface).
+    and API key environment variable. The shared adapter forwards reasoning
+    effort and requests thought summaries through Google's extra_body extension.
     """
 
     def __init__(self, config: ApiConfig):
@@ -21,6 +21,4 @@ class GeminiAdapter(OpenAIAdapter):
             config = config.model_copy(update={"base_url": "https://generativelanguage.googleapis.com/v1beta/openai/"})
         if not config.api_key_env:
             config = config.model_copy(update={"api_key_env": "GEMINI_API_KEY"})
-        if config.thinking_enabled is True:
-            config = config.model_copy(update={"thinking_enabled": False})
         super().__init__(config)

crabcode-0.1.10/packages/core/crabcode_core/api/network.py

@@ -0,0 +1,145 @@
+"""Shared HTTP routing policy. Never fall back from a proxy to direct access."""
+from __future__ import annotations
+
+import asyncio
+from contextlib import asynccontextmanager
+import ssl
+import sys
+from typing import Any, AsyncIterator, Awaitable, Callable, TypeVar
+from urllib.parse import urlsplit
+
+import httpx
+
+
+def http_options(config: Any) -> dict[str, Any]:
+    mode = getattr(config, "network_mode", "inherit")
+    if mode == "inherit":
+        return {}
+    if mode == "direct":
+        return {"trust_env": False}
+    proxy = getattr(config, "proxy_url", None)
+    try:
+        parsed = urlsplit(proxy or "")
+        valid = parsed.scheme in {"http", "https"} and bool(parsed.hostname) and parsed.port != 0
+        valid = valid and not parsed.username and not parsed.password
+    except ValueError:
+        valid = False
+    if not valid:
+        raise ValueError("Proxy mode requires an HTTP(S) proxy URL without embedded credentials")
+    return {"trust_env": False, "proxy": proxy}
+
+
+def request_timeout(config: Any, sdk: Any = None, *, fallback: Any = None) -> Any:
+    value = getattr(config, "timeout", None)
+    timeout = float(value if value is not None else getattr(fallback, "timeout", 300))
+    # SDK exports follow their supported transport (httpx or httpx2).
+    timeout_type = sdk.Timeout if sdk is not None else httpx.Timeout
+    return timeout_type(timeout, connect=min(timeout, 10.0))
+
+
+def sdk_http_client(config: Any, sdk: Any = None) -> Any:
+    client_type = sdk.DefaultAsyncHttpxClient if sdk is not None else httpx.AsyncClient
+    return client_type(**http_options(config), timeout=request_timeout(config, sdk))
+
+
+def sdk_options(config: Any, sdk: Any) -> dict[str, Any]:
+    # Adapters own request retries; the query loop owns stream reconnects.
+    # Disable SDK retries so they do not multiply those budgets.
+    options: dict[str, Any] = {"max_retries": 0, "timeout": request_timeout(config, sdk)}
+    routing = http_options(config)
+    if routing:
+        options["http_client"] = sdk_http_client(config, sdk)
+    return options
+
+
+_T = TypeVar("_T")
+
+
+def request_error_is_retryable(exc: BaseException) -> bool:
+    """Only transport failures and 5xx belong to the request retry budget."""
+    if certificate_failure(exc):
+        return False
+    pending = [exc]
+    seen: set[int] = set()
+    while pending:
+        current = pending.pop()
+        if id(current) in seen:
+            continue
+        seen.add(id(current))
+        if isinstance(current, httpx.TransportError):
+            return True
+        status = getattr(current, "status_code", None)
+        if isinstance(status, int) and status >= 500:
+            return True
+        pending.extend(item for item in (current.__cause__, current.__context__) if item is not None)
+    return False
+
+
+def request_retry_limit(config: Any) -> int:
+    from crabcode_core.query.retry import MAX_REQUEST_RETRIES
+    return min(max(0, int(getattr(config, "request_max_retries", 4))), MAX_REQUEST_RETRIES)
+
+
+async def retry_request(config: Any, request: Callable[[], Awaitable[_T]]) -> _T:
+    """Retry opening a request, never reading/replaying a started stream."""
+    from crabcode_core.query.retry import request_retry_backoff
+    limit = request_retry_limit(config)
+    for attempt in range(limit + 1):
+        try:
+            return await request()
+        except Exception as exc:
+            if attempt >= limit or not request_error_is_retryable(exc):
+                raise
+            await asyncio.sleep(request_retry_backoff(attempt + 1))
+    raise RuntimeError("unreachable request retry state")
+
+
+@asynccontextmanager
+async def retry_stream_context(config: Any, factory: Callable[[], Any]) -> AsyncIterator[Any]:
+    """Open an SDK/HTTP stream with retries and always close its context."""
+    from crabcode_core.query.retry import request_retry_backoff
+    limit = request_retry_limit(config)
+    for attempt in range(limit + 1):
+        manager = factory()
+        try:
+            stream = await manager.__aenter__()
+        except Exception as exc:
+            if attempt >= limit or not request_error_is_retryable(exc):
+                raise
+        else:
+            # Raw HTTP returns error responses; SDKs raise on context entry.
+            # Return the final response intact for provider error diagnostics.
+            status = getattr(stream, "status_code", 0)
+            if not isinstance(status, int) or status < 500 or attempt >= limit:
+                break
+            await manager.__aexit__(None, None, None)
+        await asyncio.sleep(request_retry_backoff(attempt + 1))
+    try:
+        yield stream
+    except BaseException:
+        if not await manager.__aexit__(*sys.exc_info()):
+            raise
+    else:
+        await manager.__aexit__(None, None, None)
+
+
+def certificate_failure(exc: BaseException) -> bool:
+    seen: set[int] = set()
+    pending = [exc]
+    while pending:
+        current = pending.pop()
+        if id(current) in seen:
+            continue
+        seen.add(id(current))
+        if isinstance(current, ssl.SSLCertVerificationError) or "CERTIFICATE_VERIFY_FAILED" in str(current):
+            return True
+        pending.extend(item for item in (current.__cause__, current.__context__) if item is not None)
+    return False
+
+
+def network_error_message(exc: BaseException, config: Any) -> str:
+    if certificate_failure(exc):
+        return "模型连接证书校验失败，请检查证书或网络拦截；未自动重试"
+    mode = getattr(config, "network_mode", "inherit")
+    route = {"inherit": "继承进程代理环境", "direct": "直连", "proxy": "指定代理"}.get(mode, mode)
+    return f"模型连接中断（{type(exc).__name__}，{route}）。请检查网络或代理状态后重试；更改系统环境变量需重启 Gateway。"

{crabcode-0.1.9 → crabcode-0.1.10}/packages/core/crabcode_core/api/ollama_adapter.py

@@ -12,8 +12,8 @@ class OllamaAdapter(OpenAIAdapter):
     Ollama natively exposes an OpenAI-compatible endpoint at
     ``http://localhost:11434/v1`` and does not require a real API key,
     but the OpenAI SDK still expects *some* value for ``api_key``.
-    This adapter pre-fills those defaults and disables extended thinking
-    (local models do not support it).
+    This adapter pre-fills those defaults and preserves reasoning controls
+    for local models that support thinking.
     """
 
     def __init__(self, config: ApiConfig):
@@ -22,6 +22,7 @@ class OllamaAdapter(OpenAIAdapter):
             config = config.model_copy(update={"base_url": "http://localhost:11434/v1"})
         if not config.api_key_env:
             config = config.model_copy(update={"api_key_env": "OLLAMA_API_KEY"})
-        if config.thinking_enabled is True:
-            config = config.model_copy(update={"thinking_enabled": False})
         super().__init__(config)
+
+    def _allows_placeholder_api_key(self) -> bool:
+        return True

{crabcode-0.1.9 → crabcode-0.1.10}/packages/core/crabcode_core/api/openai_adapter.py

@@ -181,6 +181,8 @@ class OpenAIAdapter(APIAdapter):
         api_key: str | None = None
         if config.api_key_env:
             api_key = os.environ.get(config.api_key_env)
+        if not api_key and self._allows_placeholder_api_key():
+            api_key = "ollama"
         if not api_key:
             api_key = os.environ.get("OPENAI_API_KEY")
 
@@ -195,6 +197,9 @@ class OpenAIAdapter(APIAdapter):
         from crabcode_core.api.network import sdk_options
         return openai.AsyncOpenAI(**kwargs, **sdk_options(config, self._sdk))
 
+    def _allows_placeholder_api_key(self) -> bool:
+        return False
+
     def _resolve_model(self, config: ModelConfig) -> str:
         """Resolve the model name for the API call.  Override in subclasses."""
         return config.model or self.config.model or "gpt-4o"
@@ -226,14 +231,69 @@ class OpenAIAdapter(APIAdapter):
 
         if config.temperature is not None:
             params["temperature"] = config.temperature
-
+        if config.stop_sequences is not None:
+            params["stop"] = safe_utf8_json_tree(config.stop_sequences)
+        if self.config.prompt_cache_key:
+            params["prompt_cache_key"] = self.config.prompt_cache_key
+        if self.config.prompt_cache_retention:
+            params["prompt_cache_retention"] = self.config.prompt_cache_retention
+
+        reasoning_effort = (
+            config.reasoning_effort
+            if config.reasoning_effort is not None
+            else self.config.reasoning_effort
+        )
+        if self._allows_placeholder_api_key() and reasoning_effort is None and not config.thinking_enabled:
+            reasoning_effort = "none"
         extra_body = safe_utf8_json_tree(dict(self.config.extra_body or {}))
+        model_name = model.rsplit("/", 1)[-1].lower()
+        is_gemini = (
+            model_name.startswith("gemini-")
+            or self.config.provider == "gemini"
+            or (self.config.provider == "router" and self.config.format == "gemini")
+        )
+        if is_gemini:
+            # The shared composer has higher effort levels than Gemini exposes.
+            if reasoning_effort in {"xhigh", "max"}:
+                reasoning_effort = "high"
+
+            # Python SDK extra_body is merged into the HTTP body. Google's
+            # extension itself is a nested wire-level "extra_body" field.
+            # Preserve explicit provider settings, including summary opt-out.
+            # Legacy non-thinking models must not receive a thinking config.
+            google_extra = (
+                extra_body.setdefault("extra_body", {})
+                if not model_name.startswith(("gemini-1.", "gemini-2.0"))
+                else None
+            )
+            if isinstance(google_extra, dict):
+                google = google_extra.setdefault("google", {})
+                if isinstance(google, dict):
+                    thinking = google.setdefault("thinking_config", {})
+                    if isinstance(thinking, dict):
+                        if "includeThoughts" not in thinking:
+                            thinking.setdefault("include_thoughts", config.thinking_enabled)
+                        # Native level/budget and OpenAI effort are mutually
+                        # exclusive. Explicit extra_body remains authoritative.
+                        if any(key in thinking for key in (
+                            "thinking_level", "thinking_budget", "thinkingLevel", "thinkingBudget",
+                        )):
+                            reasoning_effort = None
+                        elif model_name.startswith("gemini-2.5-") and reasoning_effort is None and config.thinking_enabled:
+                            # Token budgets are supported by 2.5; later models
+                            # use named levels instead. Explicit effort wins.
+                            thinking["thinking_budget"] = config.thinking_budget
+
+        if reasoning_effort is not None:
+            params["reasoning_effort"] = reasoning_effort
         if extra_body:
             params["extra_body"] = extra_body
 
         tool_call_buffers: dict[int, dict[str, str]] = {}
 
-        stream = await self.client.chat.completions.create(**params)
+        from crabcode_core.api.network import request_timeout, retry_request
+        params["timeout"] = request_timeout(config, getattr(self, "_sdk", None), fallback=self.config)
+        stream = await retry_request(self.config, lambda: self.client.chat.completions.create(**params))
         async for chunk in stream:
             if not chunk.choices:
                 if chunk.usage:

{crabcode-0.1.9 → crabcode-0.1.10}/packages/core/crabcode_core/types/config.py

@@ -129,7 +129,7 @@ class ApiConfig(BaseModel):
     # Explicit opt-in for a separate unbounded 5s..60s connection retry path.
     unbounded_connection_retries: bool = False
     context_window: int | None = None  # override auto-detected context window
-    prompt_cache_key: str | None = None  # OpenAI Responses API prompt cache routing key
+    prompt_cache_key: str | None = None  # OpenAI Chat Completions / Responses cache routing key
     prompt_caching: Literal["auto", "enabled", "disabled"] = "auto"
     prompt_cache_retention: Literal["in_memory", "24h"] | None = None
     extra_body: dict[str, Any] = Field(default_factory=dict)

{crabcode-0.1.9 → crabcode-0.1.10}/packages/core/pyproject.toml

@@ -1,7 +1,7 @@
 [project]
 name = "crabcode-core"
 # Synced from packages/core/crabcode_core/_version.py by scripts/sync_version.py.
-version = "0.1.9"
+version = "0.1.10"
 description = "CrabCode core library - AI coding assistant engine"
 requires-python = ">=3.10"
 dependencies = [

{crabcode-0.1.9 → crabcode-0.1.10}/packages/debugger/pyproject.toml

@@ -5,11 +5,11 @@ build-backend = "hatchling.build"
 [project]
 name = "crabcode-debugger"
 # Synced from packages/core/crabcode_core/_version.py by scripts/sync_version.py.
-version = "0.1.9"
+version = "0.1.10"
 description = "DAP and process-level debugging tools for CrabCode"
 requires-python = ">=3.10"
 dependencies = [
-    "crabcode-core>=0.1.9",
+    "crabcode-core>=0.1.10",
 ]
 
 [tool.hatch.build.targets.wheel]

{crabcode-0.1.9 → crabcode-0.1.10}/packages/desktop/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "crabcode-desktop",
-  "version": "0.1.9",
+  "version": "0.1.10",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "crabcode-desktop",
-      "version": "0.1.9",
+      "version": "0.1.10",
       "dependencies": {
         "@tauri-apps/api": "^2.8.0",
         "@tauri-apps/plugin-global-shortcut": "^2.3.2",

{crabcode-0.1.9 → crabcode-0.1.10}/packages/desktop/package.json

@@ -1,7 +1,7 @@
 {
   "name": "crabcode-desktop",
   "private": true,
-  "version": "0.1.9",
+  "version": "0.1.10",
   "type": "module",
   "scripts": {
     "computer-use:build": "node ../computer-use/scripts/build.mjs --out src-tauri/resources/computer-use --sync-local-clients",