limbo-code 0.1.0__tar.gz → 0.1.1__tar.gz

limbo_code-0.1.1/PKG-INFO

@@ -0,0 +1,172 @@
+Metadata-Version: 2.4
+Name: limbo-code
+Version: 0.1.1
+Summary: A minimal terminal AI coding agent
+Requires-Python: >=3.11
+Requires-Dist: httpx>=0.27
+Requires-Dist: openai>=1.30
+Requires-Dist: pydantic>=2.0
+Requires-Dist: textual>=0.58
+Requires-Dist: toml>=0.10
+Provides-Extra: dev
+Requires-Dist: mypy>=1.10; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.23; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: respx>=0.21; extra == 'dev'
+Requires-Dist: ruff>=0.4; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# Limbo
+
+A minimal terminal AI coding agent.
+
+## Install
+
+Requires Python 3.11 or later.
+
+```bash
+pip install -e .
+```
+
+## Configure
+
+Create `~/.limbo/config.toml`:
+
+```toml
+[llm]
+api_key = "your-api-key"
+model = "deepseek-chat"
+base_url = "https://api.deepseek.com/v1"
+```
+
+Limbo speaks to LLMs through a **provider/model catalog**
+(`src/limbo/llm/catalog.py`). Each provider declares its API dialect,
+endpoint, and credential env var; each model carries its own context window,
+max output tokens, and thinking/reasoning behavior. A client factory
+(`src/limbo/llm/factory.py`) picks the client implementation from the
+provider's API dialect, so non-OpenAI dialects can be added without touching
+call sites. Models not in the catalog fall back to generic
+OpenAI-compatible defaults driven by `base_url` + `model` + `api_key`.
+
+Built-in providers:
+
+| Provider | API dialect | Endpoint | Key env var |
+|----------|-------------|----------|-------------|
+| `deepseek` | openai-completions | `https://api.deepseek.com/v1` | `DEEPSEEK_API_KEY` |
+| `moonshotai` (Kimi) | openai-completions | `https://api.moonshot.ai/v1` | `MOONSHOT_API_KEY` |
+| `kimi-coding` (Kimi For Coding) | anthropic-messages | `https://api.kimi.com/coding` | `KIMI_API_KEY` |
+
+Built-in Kimi models include `kimi-k3` (1M context, pay-per-token), and for
+Kimi For Coding subscriptions: `k3` (1M context), `kimi-for-coding`, and
+`kimi-for-coding-highspeed` (256K context). The two use different endpoints
+and keys — a `sk-kimi-*` Kimi For Coding key only works with the
+`kimi-coding` models (`k3`, ...) and vice versa.
+
+Switching to a catalog model only requires changing `model` — the provider's
+endpoint and key env var are picked up automatically:
+
+```toml
+[llm]
+model = "k3"             # Kimi For Coding; base_url/api_key resolve from the catalog
+```
+
+The `anthropic-messages` dialect is served by a dedicated client
+(`src/limbo/llm/anthropic_client.py`, plain httpx SSE) selected by the
+client factory. It converts OpenAI-style tool definitions to Anthropic's
+shape, merges consecutive tool results into a single user turn, and replays
+assistant thinking blocks with their signature.
+
+For the mainland-China Moonshot endpoint, set `base_url =
+"https://api.moonshot.cn/v1"` explicitly (a configured `base_url` always
+wins over the catalog).
+
+### Optional LLM settings
+
+```toml
+[llm]
+temperature = 0.2        # 0.0 - 2.0, default 0.2
+max_iterations = 10      # safety limit on tool-turn loops, default 10
+max_tokens = 8192        # output cap; default = the model's catalog value
+thinking_effort = "high" # reasoning control; default = provider behavior
+```
+
+`thinking_effort` is interpreted per model dialect:
+
+- `k3`, `kimi-for-coding*` (Anthropic adaptive thinking): `low` | `high` |
+  `max` → `thinking: {type: adaptive}` + `output_config.effort`. Thinking
+  cannot be disabled; temperature is omitted while thinking is enabled.
+- `kimi-k3` (moonshotai, OpenAI-style): `low` | `high` | `max` → sent as
+  `reasoning_effort`. Thinking cannot be disabled on K3.
+- `kimi-k2-thinking`, `kimi-k2.5`+ (DeepSeek-style): any non-`off` value →
+  `thinking: {type: enabled}`; `"off"` → `thinking: {type: disabled}`
+  (except `kimi-k2.7-code*`, where thinking is always on).
+- Non-reasoning models: ignored.
+
+Reasoning output streams into the chat as muted thinking blocks and is
+stored on the assistant message so it can be replayed to APIs that require
+it (Kimi K3 rejects tool-call replays without `reasoning_content`).
+
+Optional tool settings:
+
+```toml
+[tools]
+bash_enabled = true
+```
+
+### Session storage
+
+Conversations are saved as JSONL files in `~/.limbo/sessions/` so you can
+review or debug them later. Use the `--session-dir` argument to redirect them
+to another location.
+
+Old session files are not automatically cleaned up; remove them manually when
+you no longer need them.
+
+## Run
+
+```bash
+limbo --workdir /path/to/project
+```
+
+## Safety
+
+Limbo executes every tool call immediately, without asking for confirmation.
+File tools (`read`, `edit`, `write`, `grep`, `find`, `ls`) are bounded to the
+current working directory and reject paths that escape it, including via
+symlinks. The boundary check resolves the path before each operation, so a
+symlink swapped between the check and the operation (a time-of-check-to-time-of-use
+race) could escape the workdir. **This is a known limitation for the MVP.**
+
+Bash is an exception: it is started in the working directory but is **not**
+sandboxed. Commands can `cd ..`, use absolute paths, and read or write outside
+the workdir. In addition, commands that match dangerous patterns such as `rm`
+or `git reset --hard` are **rejected outright**.
+The pattern list is configurable but cannot be disabled from the UI. Bash
+commands are filtered with a simple heuristic, but that filter can be bypassed
+by subshells (`bash -c 'rm -rf /'`), command substitution (`$(rm -rf /)`),
+variable indirection, options before the command name
+(`git -C /foo reset --hard`), variable assignments before the command name
+(`VAR=1 rm -rf /`), and similar shell constructs. Only run Limbo with
+trusted commands and in repositories you can afford to modify or lose.
+
+If you need to work with untrusted projects, disable the bash tool entirely:
+
+```toml
+[tools]
+bash_enabled = false
+```
+
+## Development
+
+Run tests:
+
+```bash
+pytest tests/ -v
+```
+
+Run linting and type checks:
+
+```bash
+ruff check src tests
+mypy src
+```

{limbo_code-0.1.0 → limbo_code-0.1.1}/pyproject.toml

@@ -1,7 +1,8 @@
 [project]
 name = "limbo-code"
-version = "0.1.0"
+version = "0.1.1"
 description = "A minimal terminal AI coding agent"
+readme = "README.md"
 requires-python = ">=3.11"
 dependencies = [
     "textual>=0.58",

{limbo_code-0.1.0 → limbo_code-0.1.1}/src/limbo/config.py

@@ -7,7 +7,13 @@ from pathlib import Path
 from typing import Any
 
 import toml  # type: ignore[import-untyped]
-from pydantic import BaseModel, Field, ValidationError, field_validator
+from pydantic import (
+    BaseModel,
+    Field,
+    ValidationError,
+    ValidationInfo,
+    field_validator,
+)
 from toml import TomlDecodeError
 
 DEFAULT_CONFIG_PATH = Path.home() / ".limbo" / "config.toml"
@@ -29,6 +35,11 @@ class LLMConfig(BaseModel):
     thinking_effort: str | None = None
     # Per-request output token cap; None = use the model catalog default.
     max_tokens: int | None = None
+    # LLM request retry/timeout knobs (see limbo.llm.retry).
+    max_retries: int = 3
+    retry_base_delay: float = 1.0
+    timeout: float = 600.0
+    connect_timeout: float = 30.0
 
     @field_validator("max_iterations")
     @classmethod
@@ -37,6 +48,62 @@ class LLMConfig(BaseModel):
             raise ValueError("max_iterations must be at least 1")
         return value
 
+    # The retry/timeout fields below clamp-and-warn instead of raising: a
+    # single invalid value must not discard the whole config (load_config
+    # falls back to *all* defaults on ValidationError).
+
+    @field_validator("max_retries")
+    @classmethod
+    def _max_retries_clamped(cls, value: int) -> int:
+        if value < 0:
+            warnings.warn(
+                f"max_retries={value} is invalid; clamped to 0 (retries disabled).",
+                stacklevel=2,
+            )
+            return 0
+        return value
+
+    @field_validator("retry_base_delay")
+    @classmethod
+    def _retry_base_delay_clamped(cls, value: float) -> float:
+        if value <= 0:
+            warnings.warn(
+                f"retry_base_delay={value} is invalid; reset to 1.0.",
+                stacklevel=2,
+            )
+            return 1.0
+        return value
+
+    @field_validator("timeout")
+    @classmethod
+    def _timeout_clamped(cls, value: float) -> float:
+        if value <= 0:
+            warnings.warn(
+                f"timeout={value} is invalid; reset to 600.0.",
+                stacklevel=2,
+            )
+            return 600.0
+        return value
+
+    @field_validator("connect_timeout")
+    @classmethod
+    def _connect_timeout_clamped(cls, value: float, info: ValidationInfo) -> float:
+        if value <= 0:
+            warnings.warn(
+                f"connect_timeout={value} is invalid; reset to 30.0.",
+                stacklevel=2,
+            )
+            return 30.0
+        timeout = info.data.get("timeout")
+        if isinstance(timeout, (int, float)) and value > timeout:
+            warnings.warn(
+                f"connect_timeout={value} exceeds timeout={timeout}; "
+                f"clamped to {timeout}.",
+                stacklevel=2,
+            )
+            return float(timeout)
+        return value
+
     @field_validator("max_tokens")
     @classmethod
     def _max_tokens_must_be_positive(cls, value: int | None) -> int | None:

limbo_code-0.1.1/src/limbo/llm/retry.py

@@ -0,0 +1,198 @@
+"""Unified retry helper for LLM streaming requests.
+
+Shared by both provider clients (OpenAI-compatible and Anthropic) so that
+429/5xx/connection/timeout handling behaves identically on every path.
+
+Core contract of :func:`stream_with_retry`: retries only happen *before the
+first event is yielded*. Once any event has been emitted to the consumer,
+subsequent exceptions propagate untouched — this makes duplicate streamed
+output (and thus duplicated UI text) impossible by construction.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import random
+from collections.abc import AsyncIterator, Callable
+from dataclasses import dataclass
+from datetime import datetime, timezone
+from email.utils import parsedate_to_datetime
+
+import httpx
+from openai import APIConnectionError, APIStatusError, APITimeoutError
+
+from limbo.config import LLMConfig
+from limbo.models import LLMEvent
+
+# Hard cap for a single backoff sleep. Not configurable in the MVP: it bounds
+# the total wait budget of one turn (~90s worst case with max_retries=3).
+DEFAULT_MAX_DELAY = 30.0
+
+
+@dataclass(frozen=True)
+class RetryPolicy:
+    """Retry tuning: max_retries=3 means at most 4 attempts total."""
+
+    max_retries: int = 3
+    base_delay: float = 1.0
+    max_delay: float = DEFAULT_MAX_DELAY
+
+    @classmethod
+    def from_config(cls, cfg: LLMConfig) -> RetryPolicy:
+        return cls(max_retries=cfg.max_retries, base_delay=cfg.retry_base_delay)
+
+
+class LLMHttpError(Exception):
+    """Normalized non-200 HTTP response, carrying structured retry metadata."""
+
+    def __init__(
+        self,
+        status_code: int,
+        message: str = "",
+        retry_after: float | None = None,
+    ) -> None:
+        super().__init__(message or f"HTTP {status_code}")
+        self.status_code = status_code
+        self.retry_after = retry_after
+
+
+class LLMOverloadedError(Exception):
+    """Provider reports overload (e.g. Anthropic SSE ``overloaded_error``)."""
+
+
+def is_retryable(exc: BaseException) -> bool:
+    """Classify whether retrying the request could succeed.
+
+    Retryable: 429, 408, 5xx, connection errors, read/connect timeouts,
+    provider overload. Everything else (other 4xx, cancellations) is not.
+    """
+    if isinstance(exc, (asyncio.CancelledError, KeyboardInterrupt)):
+        return False
+    if isinstance(exc, LLMOverloadedError):
+        return True
+    if isinstance(exc, LLMHttpError):
+        return _status_retryable(exc.status_code)
+    if isinstance(exc, APIStatusError):
+        # Includes RateLimitError (429) and InternalServerError (5xx).
+        return _status_retryable(exc.status_code)
+    if isinstance(exc, (APIConnectionError, APITimeoutError)):
+        return True
+    if isinstance(exc, (httpx.ConnectError, httpx.ReadTimeout, httpx.ConnectTimeout)):
+        return True
+    return False
+
+
+def _status_retryable(status_code: int) -> bool:
+    return status_code in (408, 429) or status_code >= 500
+
+
+def retry_after(exc: BaseException) -> float | None:
+    """Extract the server-provided Retry-After (seconds), if any."""
+    if isinstance(exc, LLMHttpError):
+        return exc.retry_after
+    if isinstance(exc, APIStatusError):
+        return parse_retry_after(exc.response.headers.get("retry-after"))
+    return None
+
+
+def parse_retry_after(value: str | None) -> float | None:
+    """Parse a Retry-After header value (delta-seconds or HTTP-date).
+
+    Returns None on any parse failure — a malformed header must never
+    break the retry flow.
+    """
+    if not value:
+        return None
+    value = value.strip()
+    try:
+        seconds = float(value)
+        return max(0.0, seconds)
+    except ValueError:
+        pass
+    try:
+        date = parsedate_to_datetime(value)
+    except (TypeError, ValueError):
+        return None
+    if date is None:
+        return None
+    if date.tzinfo is None:
+        # HTTP-date is always GMT; assume UTC if parsing dropped the tz.
+        date = date.replace(tzinfo=timezone.utc)
+    return max(0.0, (date - datetime.now(timezone.utc)).total_seconds())
+
+
+def compute_delay(
+    attempt: int,
+    policy: RetryPolicy,
+    retry_after: float | None = None,
+) -> float:
+    """Full-jitter exponential backoff: uniform(0, min(max, base * 2**attempt)).
+
+    A server-provided Retry-After raises the floor (max of the two), still
+    capped at max_delay — bounding the total wait budget of a turn.
+    """
+    computed = random.uniform(0.0, min(policy.max_delay, policy.base_delay * 2**attempt))
+    if retry_after is not None:
+        computed = max(retry_after, computed)
+    return min(policy.max_delay, computed)
+
+
+async def stream_with_retry(
+    factory: Callable[[], AsyncIterator[LLMEvent]],
+    policy: RetryPolicy,
+) -> AsyncIterator[LLMEvent]:
+    """Yield events from factory(), retrying pre-first-event failures.
+
+    Each attempt calls factory() to build a fresh async generator (a brand
+    new HTTP request). Exceptions raised before the first yield are retried
+    when :func:`is_retryable`; once anything has been yielded, exceptions
+    propagate untouched. CancelledError/KeyboardInterrupt always propagate
+    immediately (they are BaseExceptions, never caught here).
+    """
+    attempt = 0
+    while True:
+        yielded = False
+        try:
+            async for event in factory():
+                yielded = True
+                yield event
+            return
+        except Exception as e:
+            if yielded or attempt >= policy.max_retries or not is_retryable(e):
+                raise
+            await asyncio.sleep(compute_delay(attempt, policy, retry_after(e)))
+            attempt += 1
+
+
+def friendly_message(exc: BaseException) -> str | None:
+    """User-facing Chinese hint for an exhausted/unretryable LLM failure.
+
+    Returns None when there is no better advice than the raw error text;
+    the raw exception always stays in the trace log either way.
+    """
+    if isinstance(exc, LLMOverloadedError):
+        return "模型服务过载，已自动重试仍失败，可稍后重发上一条消息"
+    if isinstance(exc, LLMHttpError):
+        if exc.status_code == 429:
+            return "服务限流，已自动重试仍失败，可稍后重发上一条消息"
+        if exc.status_code >= 500:
+            return "模型服务异常，已自动重试仍失败，可稍后重发上一条消息"
+        if exc.status_code == 408:
+            return "请求超时，已自动重试仍失败，请检查网络后重发上一条消息"
+        return None
+    if isinstance(exc, APIStatusError):
+        # RateLimitError (429) is an APIStatusError subclass.
+        if exc.status_code == 429:
+            return "服务限流，已自动重试仍失败，可稍后重发上一条消息"
+        if exc.status_code >= 500:
+            return "模型服务异常，已自动重试仍失败，可稍后重发上一条消息"
+        if exc.status_code == 408:
+            return "请求超时，已自动重试仍失败，请检查网络后重发上一条消息"
+        return None
+    if isinstance(exc, APITimeoutError) or isinstance(
+        exc, (httpx.ReadTimeout, httpx.ConnectTimeout)
+    ):
+        return "请求超时，已自动重试仍失败，请检查网络后重发上一条消息"
+    if isinstance(exc, (APIConnectionError, httpx.ConnectError)):
+        return "网络连接异常，已自动重试仍失败，请检查网络后重发上一条消息"
+    return None

{limbo_code-0.1.0 → limbo_code-0.1.1}/tests/test_config.py

@@ -81,3 +81,69 @@ def test_llm_config_rejects_non_positive_max_iterations():
     with pytest.raises(ValueError, match="max_iterations"):
         LLMConfig(max_iterations=-1)
     assert LLMConfig(max_iterations=1).max_iterations == 1
+
+
+def test_llm_config_retry_defaults():
+    from limbo.config import LLMConfig
+
+    cfg = LLMConfig()
+    assert cfg.max_retries == 3
+    assert cfg.retry_base_delay == 1.0
+    assert cfg.timeout == 600.0
+    assert cfg.connect_timeout == 30.0
+
+
+def test_load_config_retry_fields_from_toml(tmp_path):
+    path = tmp_path / "retry.toml"
+    path.write_text(
+        "[llm]\n"
+        "max_retries = 5\n"
+        "retry_base_delay = 2.5\n"
+        "timeout = 120.0\n"
+        "connect_timeout = 10.0\n"
+    )
+    cfg = load_config(path)
+    assert cfg.llm.max_retries == 5
+    assert cfg.llm.retry_base_delay == 2.5
+    assert cfg.llm.timeout == 120.0
+    assert cfg.llm.connect_timeout == 10.0
+
+
+def test_llm_config_clamps_negative_max_retries():
+    from limbo.config import LLMConfig
+
+    with pytest.warns(UserWarning, match="max_retries"):
+        cfg = LLMConfig(max_retries=-1)
+    assert cfg.max_retries == 0
+
+
+def test_llm_config_clamps_non_positive_delays():
+    from limbo.config import LLMConfig
+
+    with pytest.warns(UserWarning, match="retry_base_delay"):
+        cfg = LLMConfig(retry_base_delay=0)
+    assert cfg.retry_base_delay == 1.0
+    with pytest.warns(UserWarning, match="timeout"):
+        cfg = LLMConfig(timeout=-5)
+    assert cfg.timeout == 600.0
+    with pytest.warns(UserWarning, match="connect_timeout"):
+        cfg = LLMConfig(connect_timeout=0)
+    assert cfg.connect_timeout == 30.0
+
+
+def test_llm_config_connect_timeout_clamped_to_timeout():
+    from limbo.config import LLMConfig
+
+    with pytest.warns(UserWarning, match="connect_timeout"):
+        cfg = LLMConfig(timeout=10.0, connect_timeout=60.0)
+    assert cfg.connect_timeout == 10.0
+
+
+def test_load_config_invalid_retry_value_does_not_discard_other_fields(tmp_path):
+    """A bad retry_base_delay must clamp+warn, not reset the whole config."""
+    path = tmp_path / "partial.toml"
+    path.write_text('[llm]\nmodel = "gpt-4o"\nretry_base_delay = -1\n')
+    with pytest.warns(UserWarning, match="retry_base_delay"):
+        cfg = load_config(path)
+    assert cfg.llm.model == "gpt-4o"
+    assert cfg.llm.retry_base_delay == 1.0

limbo_code-0.1.1/tests/test_retry.py

@@ -0,0 +1,302 @@
+"""Unit tests for limbo.llm.retry (no network; sleeps are monkeypatched)."""
+
+from __future__ import annotations
+
+import asyncio
+import random
+import time
+from email.utils import formatdate
+
+import httpx
+import pytest
+from openai import (
+    APIConnectionError,
+    APIStatusError,
+    APITimeoutError,
+    RateLimitError,
+)
+
+from limbo.config import LLMConfig
+from limbo.llm.retry import (
+    LLMHttpError,
+    LLMOverloadedError,
+    RetryPolicy,
+    compute_delay,
+    friendly_message,
+    is_retryable,
+    parse_retry_after,
+    retry_after,
+    stream_with_retry,
+)
+from limbo.models import TextChunk
+
+
+def _request() -> httpx.Request:
+    return httpx.Request("POST", "http://test/v1/chat/completions")
+
+
+def _status_error(status: int, headers: dict[str, str] | None = None) -> APIStatusError:
+    resp = httpx.Response(status, headers=headers or {}, request=_request())
+    return APIStatusError(f"status {status}", response=resp, body=None)
+
+
+def _rate_limit(headers: dict[str, str] | None = None) -> RateLimitError:
+    resp = httpx.Response(429, headers=headers or {}, request=_request())
+    return RateLimitError("rate limited", response=resp, body=None)
+
+
+# ---------------------------------------------------------------------------
+# is_retryable classification matrix
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.parametrize(
+    ("exc", "expected"),
+    [
+        (_rate_limit(), True),
+        (_status_error(408), True),
+        (_status_error(500), True),
+        (_status_error(503), True),
+        (_status_error(400), False),
+        (_status_error(401), False),
+        (_status_error(404), False),
+        (_status_error(409), False),
+        (APIConnectionError(message="conn", request=_request()), True),
+        (APITimeoutError(request=_request()), True),
+        (LLMHttpError(429), True),
+        (LLMHttpError(408), True),
+        (LLMHttpError(500), True),
+        (LLMHttpError(400), False),
+        (LLMHttpError(401), False),
+        (LLMOverloadedError("overloaded"), True),
+        (httpx.ConnectError("boom", request=_request()), True),
+        (httpx.ReadTimeout("boom", request=_request()), True),
+        (httpx.ConnectTimeout("boom", request=_request()), True),
+        (asyncio.CancelledError(), False),
+        (KeyboardInterrupt(), False),
+        (ValueError("nope"), False),
+        (RuntimeError("nope"), False),
+    ],
+)
+def test_is_retryable(exc: BaseException, expected: bool):
+    assert is_retryable(exc) is expected
+
+
+# ---------------------------------------------------------------------------
+# retry_after / parse_retry_after
+# ---------------------------------------------------------------------------
+
+
+def test_retry_after_from_normalized_error():
+    assert retry_after(LLMHttpError(429, retry_after=5.0)) == 5.0
+    assert retry_after(LLMHttpError(429)) is None
+
+
+def test_retry_after_from_openai_error_delta_seconds():
+    assert retry_after(_rate_limit({"retry-after": "5"})) == 5.0
+
+
+def test_retry_after_from_openai_error_http_date():
+    headers = {"retry-after": formatdate(time.time() + 5, usegmt=True)}
+    value = retry_after(_rate_limit(headers))
+    assert value is not None
+    assert 3.0 < value <= 5.0
+
+
+def test_retry_after_garbage_and_missing_headers():
+    assert retry_after(_rate_limit({"retry-after": "not-a-date"})) is None
+    assert retry_after(_rate_limit()) is None
+    assert retry_after(ValueError("x")) is None
+
+
+def test_parse_retry_after_past_http_date_clamps_to_zero():
+    headers = formatdate(time.time() - 60, usegmt=True)
+    assert parse_retry_after(headers) == 0.0
+
+
+# ---------------------------------------------------------------------------
+# compute_delay
+# ---------------------------------------------------------------------------
+
+
+def _capture_uniform(monkeypatch: pytest.MonkeyPatch) -> list[tuple[float, float]]:
+    bounds: list[tuple[float, float]] = []
+
+    def fake_uniform(a: float, b: float) -> float:
+        bounds.append((a, b))
+        return 0.0
+
+    monkeypatch.setattr(random, "uniform", fake_uniform)
+    return bounds
+
+
+def test_compute_delay_exponential_bounds(monkeypatch: pytest.MonkeyPatch):
+    bounds = _capture_uniform(monkeypatch)
+    policy = RetryPolicy(base_delay=1.0)
+    for attempt, expected_upper in ((0, 1.0), (1, 2.0), (2, 4.0)):
+        compute_delay(attempt, policy)
+        assert bounds[-1] == (0.0, expected_upper)
+
+
+def test_compute_delay_capped_at_max_delay(monkeypatch: pytest.MonkeyPatch):
+    bounds = _capture_uniform(monkeypatch)
+    policy = RetryPolicy(base_delay=1.0, max_delay=30.0)
+    compute_delay(10, policy)  # 2**10 = 1024 >> 30
+    assert bounds[-1] == (0.0, 30.0)
+
+
+def test_compute_delay_retry_after_raises_floor(monkeypatch: pytest.MonkeyPatch):
+    _capture_uniform(monkeypatch)  # uniform returns 0.0
+    policy = RetryPolicy(base_delay=1.0)
+    assert compute_delay(0, policy, retry_after=5.0) == 5.0
+
+
+def test_compute_delay_retry_after_capped_at_max_delay(monkeypatch: pytest.MonkeyPatch):
+    _capture_uniform(monkeypatch)
+    policy = RetryPolicy(max_delay=30.0)
+    assert compute_delay(0, policy, retry_after=120.0) == 30.0
+
+
+def test_retry_policy_from_config():
+    cfg = LLMConfig(max_retries=5, retry_base_delay=2.0)
+    policy = RetryPolicy.from_config(cfg)
+    assert policy.max_retries == 5
+    assert policy.base_delay == 2.0
+    assert policy.max_delay == 30.0
+
+
+# ---------------------------------------------------------------------------
+# stream_with_retry
+# ---------------------------------------------------------------------------
+
+
+def _make_factory(behaviors: list[tuple[list[TextChunk], BaseException | None]]):
+    """Each entry: events to yield, then optional error to raise."""
+    calls = 0
+
+    def factory():
+        nonlocal calls
+        events, error = behaviors[min(calls, len(behaviors) - 1)]
+        calls += 1
+
+        async def gen():
+            for e in events:
+                yield e
+            if error is not None:
+                raise error
+
+        return gen()
+
+    return factory, lambda: calls
+
+
+@pytest.fixture
+def sleeps(monkeypatch: pytest.MonkeyPatch) -> list[float]:
+    recorded: list[float] = []
+
+    async def fake_sleep(delay: float) -> None:
+        recorded.append(delay)
+
+    monkeypatch.setattr(asyncio, "sleep", fake_sleep)
+    return recorded
+
+
+@pytest.mark.asyncio
+async def test_retry_succeeds_after_transient_failures(sleeps: list[float]):
+    events = [TextChunk(text="hello")]
+    factory, calls = _make_factory(
+        [([], _rate_limit()), ([], _status_error(503)), (events, None)]
+    )
+    result = [e async for e in stream_with_retry(factory, RetryPolicy())]
+    assert result == events
+    assert calls() == 3
+    assert len(sleeps) == 2
+
+
+@pytest.mark.asyncio
+async def test_non_retryable_error_raises_immediately(sleeps: list[float]):
+    factory, calls = _make_factory([([], _status_error(400))])
+    with pytest.raises(APIStatusError):
+        [e async for e in stream_with_retry(factory, RetryPolicy())]
+    assert calls() == 1
+    assert sleeps == []
+
+
+@pytest.mark.asyncio
+async def test_error_after_first_event_passes_through(sleeps: list[float]):
+    """Core regression: once an event was yielded, no retry may happen."""
+    factory, calls = _make_factory([([TextChunk(text="partial")], _rate_limit())])
+    collected = []
+    with pytest.raises(RateLimitError):
+        async for e in stream_with_retry(factory, RetryPolicy()):
+            collected.append(e)
+    assert collected == [TextChunk(text="partial")]
+    assert calls() == 1
+    assert sleeps == []
+
+
+@pytest.mark.asyncio
+async def test_max_retries_zero_disables_retry(sleeps: list[float]):
+    factory, calls = _make_factory([([], _rate_limit())])
+    with pytest.raises(RateLimitError):
+        [e async for e in stream_with_retry(factory, RetryPolicy(max_retries=0))]
+    assert calls() == 1
+    assert sleeps == []
+
+
+@pytest.mark.asyncio
+async def test_exhausted_retries_raise_last_error(sleeps: list[float]):
+    factory, calls = _make_factory([([], _status_error(500))])
+    policy = RetryPolicy(max_retries=3)
+    with pytest.raises(APIStatusError):
+        [e async for e in stream_with_retry(factory, policy)]
+    assert calls() == 4  # max_retries + 1 attempts
+    assert len(sleeps) == 3
+
+
+@pytest.mark.asyncio
+async def test_cancelled_error_passes_through(sleeps: list[float]):
+    """Cancellation must never be retried or delayed."""
+    factory, calls = _make_factory([([], asyncio.CancelledError())])
+    with pytest.raises(asyncio.CancelledError):
+        [e async for e in stream_with_retry(factory, RetryPolicy())]
+    assert calls() == 1
+    assert sleeps == []
+
+
+# ---------------------------------------------------------------------------
+# friendly_message
+# ---------------------------------------------------------------------------
+
+
+def test_friendly_message_rate_limit():
+    msg = friendly_message(_rate_limit())
+    assert msg is not None
+    assert "限流" in msg and "稍后重发" in msg
+    msg = friendly_message(LLMHttpError(429))
+    assert msg is not None and "限流" in msg
+
+
+def test_friendly_message_server_error():
+    assert "服务异常" in (friendly_message(_status_error(500)) or "")
+    assert "服务异常" in (friendly_message(LLMHttpError(503)) or "")
+
+
+def test_friendly_message_timeout_and_connection():
+    assert "超时" in (friendly_message(APITimeoutError(request=_request())) or "")
+    assert "超时" in (friendly_message(LLMHttpError(408)) or "")
+    conn = APIConnectionError(message="c", request=_request())
+    assert "网络连接异常" in (friendly_message(conn) or "")
+    assert "网络连接异常" in (
+        friendly_message(httpx.ConnectError("c", request=_request())) or ""
+    )
+
+
+def test_friendly_message_overloaded():
+    assert "过载" in (friendly_message(LLMOverloadedError("x")) or "")
+
+
+def test_friendly_message_returns_none_for_other_errors():
+    assert friendly_message(_status_error(400)) is None
+    assert friendly_message(LLMHttpError(401)) is None
+    assert friendly_message(ValueError("x")) is None

limbo_code-0.1.0/PKG-INFO

@@ -1,16 +0,0 @@
-Metadata-Version: 2.4
-Name: limbo-code
-Version: 0.1.0
-Summary: A minimal terminal AI coding agent
-Requires-Python: >=3.11
-Requires-Dist: httpx>=0.27
-Requires-Dist: openai>=1.30
-Requires-Dist: pydantic>=2.0
-Requires-Dist: textual>=0.58
-Requires-Dist: toml>=0.10
-Provides-Extra: dev
-Requires-Dist: mypy>=1.10; extra == 'dev'
-Requires-Dist: pytest-asyncio>=0.23; extra == 'dev'
-Requires-Dist: pytest>=8.0; extra == 'dev'
-Requires-Dist: respx>=0.21; extra == 'dev'
-Requires-Dist: ruff>=0.4; extra == 'dev'