hum-cli 0.2.63__py3-none-any.whl → 0.2.64__py3-none-any.whl

hum/__init__.py

@@ -1,2 +1,2 @@
 """Hum — an agent harness built as an RL environment that humans can drive."""
-__version__ = "0.2.63"
+__version__ = "0.2.64"

hum/client.py

@@ -183,11 +183,14 @@ class VisibleTools(ToolRegistry):
         return results
 
 
-def retry_line(kind: str, model: str | None, wait_s: float, attempt: int, since_s: float) -> str:
-    """``model capacity (google/gemini-3.8-flash): waiting 30 s — retry 2 · 1m 05s so far``"""
-    m, s = divmod(int(since_s), 60)
-    return (f"model {kind}{f' ({model})' if model else ''}: waiting {wait_s:.0f} s — retry {attempt} · "
-            f"{f'{m}m {s:02d}s' if m else f'{s}s'} so far")
+def retry_line(kind: str, wait_s: float, attempt: int, of: int) -> str:
+    """``Retrying in 30s · attempt 2/10 · capacity``, as Claude Code says it."""
+    return f"Retrying in {wait_s:.0f}s · attempt {attempt}/{of} · {kind}"
+
+
+def waiting_line(s: float) -> str:
+    """An attempt that has shown nothing for ``s`` seconds."""
+    return f"still waiting for the model ({s:.0f}s)"
 
 
 class VisiblePolicy(PolicyDriver):
@@ -198,14 +201,13 @@ class VisiblePolicy(PolicyDriver):
                          **({"retries": retries} if retries is not None else {}))
         self.ui = ui
         self.on_retry = self._retrying
+        self.on_waiting = lambda s: ui.set_phase(waiting_line(s))
         if hasattr(llm, "on_notice"):
             llm.on_notice = ui.warn     # our proxy's word on the person's credits, once
 
     def _retrying(self, attempt: int, e: BaseException, delay: float) -> None:
-        """The person sees the failure's kind, the model it came from and the wait before the next attempt."""
-        since = self.clock() - (self.started_at or self.clock())
-        self.ui.retry(attempt, (k := failure_of(e).kind), delay, retry_line(k, getattr(self.llm, "model", None),
-                                                                             delay, attempt, since))
+        """The person sees the wait before the next attempt, which attempt of how many, and the failure's kind."""
+        self.ui.retry(attempt, (k := failure_of(e).kind), delay, retry_line(k, delay, attempt, self.retries))
 
     async def next(self, messages, tools):  # type: ignore[override]
         self.ui.turn_started()

hum/core.py

@@ -673,7 +673,7 @@ class WireUI(UI):
             self._text = []
             self._announced.clear()
             self._fold_thought()
-        self.set_phase(f"model {kind}: retry {attempt} in {wait_s:.0f} s")
+        self.set_phase(text)
         self.wire.send("retry", attempt=attempt, kind=kind, wait_s=wait_s, text=text)
 
     def error(self, msg: str) -> None:

hum/runtime/config.py

@@ -65,9 +65,11 @@ class Config:
     api_key: str | None = None
     reasoning_effort: str | None = None
     temperature: float | None = None
-    idle_timeout_s: float = 600.0   # a stream silent this long is dead (models can think silently for minutes)
+    # [model] idle_timeout_s: once an attempt is answered, the longest silence between stream events (keepalives count)
+    # before it is cut and retried; the gateway keeps a long think alive (hum.runtime.llm.STREAM_IDLE_S)
+    idle_timeout_s: float = 300.0
     # [model] retries: requests tried again after a throttle, an upstream failure or a dropped connection
-    retries: int = 10   # a cap; the wait budget (hum.runtime.drivers.RETRY_BUDGET_S) is what binds
+    retries: int = 10   # the most retries of a turn; fewer by kind and wait (hum.runtime.drivers)
     mcp: list[MCPConfig] = field(default_factory=list)
     lsp: list[LSPConfig] = field(default_factory=list)   # [[lsp]]: language servers, beside the ones found on PATH
     gate: str = "off"
@@ -293,7 +295,7 @@ def load(path: Path | None = None) -> Config:
         # server's default
         reasoning_effort=_env("HUM_REASONING_EFFORT") or m.get("reasoning_effort") or cred.get("reasoning_effort")
             or None,
-        temperature=m.get("temperature"), idle_timeout_s=float(m.get("idle_timeout_s", 600.0)),
+        temperature=m.get("temperature"), idle_timeout_s=float(m.get("idle_timeout_s", 300.0)),
         retries=int(m.get("retries", 10)),
         mcp=[_server(s) for s in d.get("mcp", []) if s.get("name")],
         lsp=[LSPConfig(name=str(s["name"]), command=str(s["command"]), args=[str(x) for x in s.get("args", [])],

hum/runtime/drivers.py

@@ -12,23 +12,30 @@ from typing import Any, Awaitable, Callable
 
 from pydantic import BaseModel
 
-from .llm import ATTEMPT_BUDGET_S, LLM, REQUEST_KEY, Failure, StreamEvents, failure_of
+from .llm import LLM, REQUEST_KEY, RETRY_AFTER_MAX_S, Failure, ProviderError, StreamEvents, failure_of
 from .models import Intervention, Turn
 
-# the most attempts a turn makes after its first; the wait budget below is what binds under this default
+# the most retries a turn makes after its first attempt (Claude Code's 10). Each attempt is bounded on its own (the
+# client's answer and stream-idle clocks, hum.runtime.llm), never the turn, so a slow first token is waited out; the
+# kinds below are retried fewer times
 RETRIES = 10
-# the longest a turn's attempts may run, wall time from its first send: the time inside failed attempts (the gateway
-# waits out a capacity 429 or holds a silent stream itself before it answers) and the waits between them. A person is
-# waiting on it; 3 min outlasts a Vertex capacity episode (429 RESOURCE_EXHAUSTED, 10-07..10-14: median 1 min, p90
-# 2.2 min). No retry starts whose wait would end past it, so retries never stack on the gateway's own into minutes
-# of silence
-RETRY_BUDGET_S = 180.0
-# the least an attempt is started with, in seconds of budget left after its wait: the gateway narrows its deadline to
-# the declared timeout less its 30 s margin, so under this an attempt has under 15 s to show first output, which an
-# upstream answering through a capacity wave rarely does; it would only add silence before the same failure
-RETRY_MIN_ATTEMPT_S = 45.0
-RETRY_BASE_S = 1.0       # the first backoff ceiling; doubles each attempt
-RETRY_CAP_S = 60.0       # the highest the backoff ceiling grows to
+# a clock that ran out: the gateway already retried inside the attempt, and each retry thinks the reply again from the
+# start, so twice is all the person waits on it (worst case 3 attempts of ~5 min)
+RETRIES_BY_KIND = {"deadline_exceeded": 2, "stream_idle": 2, "upstream_timeout": 2}
+# a throttle (capacity, overloaded, rate_limit, a 429): the gateway waits it out and retries inside each attempt, so
+# every retry here multiplies its sends. No retry starts once the person has waited this long on the throttle (the
+# failed attempts and the waits between them): worst case this plus one last attempt, ~10 min, against ~50 min for 11
+# attempts the gateway holds to its deadline
+THROTTLE_WAIT_MAX_S = 300.0
+THROTTLE_KINDS = frozenset({"capacity", "overloaded", "rate_limit"})
+# full-jitter backoff when the server named no wait: the ceiling doubles from 1 s to Claude Code's 32 s cap
+# (code.claude.com/docs/en/errors)
+RETRY_BASE_S = 1.0
+RETRY_CAP_S = 32.0
+# how long an attempt may show nothing before the person is told it is still waited on, then how often after
+# (Claude Code's banner after 20 s with no data)
+WAITING_AFTER_S = 20.0
+WAITING_EVERY_S = 1.0
 
 
 def backoff(attempt: int) -> float:
@@ -37,33 +44,43 @@ def backoff(attempt: int) -> float:
     return random.uniform(0.0, min(RETRY_CAP_S, RETRY_BASE_S * 2 ** (attempt - 1)))
 
 
-def retry_wait(attempt: int, f: Failure, left_s: float) -> float | None:
-    """How long to wait before attempt ``attempt``, or None when there is no retry: the failure is not
-    retryable, or the wait the server asked for does not fit in what is left of the budget (an early retry would be
-    answered the same). With no wait named, the backoff, cut to what is left."""
-    if not f.retryable or left_s <= 0:
+def retry_wait(attempt: int, f: Failure) -> float | None:
+    """How long to wait before attempt ``attempt``, or None when there is no retry (the failure is not retryable;
+    failure_of already counts a wait past RETRY_AFTER_MAX_S as that): the wait the server named, else the backoff."""
+    if not f.retryable:
         return None
-    if f.retry_after is not None:
-        return f.retry_after if f.retry_after <= left_s else None
-    return min(backoff(attempt), left_s)
+    return f.retry_after if f.retry_after is not None else backoff(attempt)
+
+
+def throttle(f: Failure) -> bool:
+    return f.kind in THROTTLE_KINDS or f.status == 429
+
+
+def said(e: BaseException, f: Failure) -> BaseException:
+    """The failure that ends the turn, as the person reads it: a wait asked for and not waited says so."""
+    if isinstance(e, ProviderError) and not f.retryable and f.retry_after is not None:
+        m, s = divmod(int(f.retry_after), 60)
+        return ProviderError(e.status, f"{e.message} — the provider asks to wait {f'{m}m {s:02d}s' if m else f'{s}s'}, "
+                             f"past {RETRY_AFTER_MAX_S:.0f} s: not retried", type=e.type, code=e.code,
+                             retry_after=e.retry_after, body=e.body, location=e.location, should_retry=False,
+                             kind=e.kind)
+    return e
 
 
 class PolicyDriver:
     author = "policy"
 
     def __init__(self, llm: LLM, author: str = "policy", on_text: Any = None, events: StreamEvents | None = None,
-                 retries: int = RETRIES, budget_s: float = RETRY_BUDGET_S,
-                 tool_choice: Any = None):
+                 retries: int = RETRIES, tool_choice: Any = None):
         self.llm = llm
         self.author = author
         self.tool_choice = tool_choice   # a caller that requires one named tool (the judge) says so here
         self.events = events or StreamEvents(text=on_text)
         self.retries = retries
-        self.budget_s = budget_s
         self.on_retry: Any = None  # client hook: (attempt, exception, delay_s) -> None
+        # client hook: (seconds) -> None, while an attempt has shown nothing past WAITING_AFTER_S
+        self.on_waiting: Callable[[float], None] | None = None
         self.sleep: Callable[[float], Awaitable[Any]] | None = None   # the wait between attempts; asyncio.sleep unset
-        self.clock: Callable[[], float] = time.monotonic   # the budget's clock
-        self.started_at: float | None = None   # the turn's first send, on ``clock``
         # the last call as the person waited for it: request_at, first_at (first streamed delta), done_at, attempts
         self.timing: dict[str, Any] | None = None
         # the last call as the record keeps it, with the attempts that failed before it; the loop takes it with the node
@@ -93,17 +110,23 @@ class PolicyDriver:
                              reasoning=(lambda s: (seen(), ev.reasoning(s))[1]) if ev.reasoning else None,
                              tool=(lambda i, n, a: (seen(), ev.tool(i, n, a))[1]) if ev.tool else None)
         attempt = 0
-        self.started_at = self.clock()
+        by_kind: dict[str, int] = {}   # the retries of each kind so far
+        throttled = 0.0   # the time the person has waited on a throttle: its failed attempts and the waits after them
+        loop = asyncio.get_running_loop()
         key = REQUEST_KEY.set(f"hum-{uuid.uuid4()}")   # one per turn: every retry below is the same request again
-        budget_key = ATTEMPT_BUDGET_S.set(None)
         try:
             while True:
                 # each attempt is its own call: a delta streamed by one that then failed is not this one's first token
                 t_req, first[0] = time.monotonic(), None
-                ATTEMPT_BUDGET_S.set(self.budget_s - (self.clock() - self.started_at))
+                waiting = asyncio.ensure_future(self._waiting(first)) if self.on_waiting else None
+                sent = loop.time()
                 try:
-                    t = await self.llm.complete(messages, tools, events=timed,
-                                                **({"tool_choice": self.tool_choice} if self.tool_choice else {}))
+                    try:
+                        t = await self.llm.complete(messages, tools, events=timed,
+                                                    **({"tool_choice": self.tool_choice} if self.tool_choice else {}))
+                    finally:
+                        if waiting is not None:
+                            waiting.cancel()   # the attempt is over: the wait before the next is said by on_retry
                     break
                 except asyncio.CancelledError:
                     raise
@@ -113,19 +136,29 @@ class PolicyDriver:
                                    "error": (lc or {}).get("error") or {"type": type(e).__name__, "message": str(e)}})
                     if lc is not None:
                         self.llm.last_call = None
-                    # what is left after the wait must be worth an attempt: the person's silence ends by the budget
-                    left = self.budget_s - (self.clock() - self.started_at) - RETRY_MIN_ATTEMPT_S
-                    delay = retry_wait(attempt + 1, failure_of(e), left) if attempt < self.retries else None
+                    f = failure_of(e)
+                    if throttle(f):
+                        throttled += loop.time() - sent
+                    delay = retry_wait(attempt + 1, f) if attempt < self.retries else None
+                    if delay is not None and by_kind.get(f.kind, 0) >= RETRIES_BY_KIND.get(f.kind, self.retries):
+                        delay = None
+                    if delay is not None and throttle(f):
+                        if throttled + delay > THROTTLE_WAIT_MAX_S:
+                            delay = None
+                        else:
+                            throttled += delay
                     if delay is None:
                         self._take_call(failed)   # the calls that were made are on the record even when the turn is not
+                        if (out := said(e, f)) is not e:
+                            raise out from e
                         raise
                     attempt += 1
+                    by_kind[f.kind] = by_kind.get(f.kind, 0) + 1
                     if self.on_retry:
                         self.on_retry(attempt, e, delay)
                     await (self.sleep or asyncio.sleep)(delay)
         finally:
             REQUEST_KEY.reset(key)
-            ATTEMPT_BUDGET_S.reset(budget_key)
         t_done = time.monotonic()
         self.timing = {"started_at": t_start, "request_at": t_req,
                        "first_at": first[0] if first[0] is not None else t_done, "done_at": t_done,
@@ -135,6 +168,16 @@ class PolicyDriver:
             t = t.model_copy(update={"author": self.author})
         return t
 
+    async def _waiting(self, first: list[float | None]) -> None:
+        """Past WAITING_AFTER_S of an attempt with no output, the person is told how long it has been, every
+        WAITING_EVERY_S until output comes or the attempt ends."""
+        loop = asyncio.get_running_loop()
+        t0 = loop.time()
+        await asyncio.sleep(WAITING_AFTER_S)
+        while first[0] is None and self.on_waiting is not None:
+            self.on_waiting(loop.time() - t0)
+            await asyncio.sleep(WAITING_EVERY_S)
+
     def partial(self) -> Turn | None:
         """What the model had produced when it was interrupted, if the client keeps it."""
         fn = getattr(self.llm, "partial", None)

hum/runtime/llm.py

@@ -50,11 +50,25 @@ CONTEXT_HEADERS = ("session", "agent", "parent", "branch", "purpose")
 # instead of calling the model again. x-client-request-id stays one per attempt: it names the attempt, this the request
 REQUEST_KEY: contextvars.ContextVar[str | None] = contextvars.ContextVar("hum_request_key", default=None)
 
-# how long this attempt may keep the person waiting for its first output, in seconds (None: no bound): set by the
-# driver from what is left of the turn's retry budget. Sent as `x-stainless-timeout` (the Stainless SDKs' declared
-# timeout, seconds), which the gateway narrows its own deadline to, less its margin, so its own holds and waits end
-# first and it answers typed; and the client cuts the attempt there itself when no output has come
-ATTEMPT_BUDGET_S: contextvars.ContextVar[float | None] = contextvars.ContextVar("hum_attempt_budget_s", default=None)
+# each attempt is bounded on its own, never the turn. Its answer (headers, or the first stream event) is waited 300 s
+# plus 1 s per 32 KB of request body, Claude Code's first-byte bound (code.claude.com/docs/en/network-config), a long
+# prompt being slower to answer. Sent as `x-stainless-timeout` (the Stainless SDKs' declared timeout, seconds), which
+# the gateway narrows its own deadline to, less its 30 s margin, so its holds and waits end first and it answers typed
+FIRST_OUTPUT_S = 300.0
+FIRST_OUTPUT_BYTES_PER_S = 32 * 1024
+# after that, the longest silence between stream events of any kind (a keepalive comment, response.created, a delta)
+# before the stream is taken for dead: Codex's stream_idle_timeout (codex-rs/model-provider-info/src/lib.rs:66), Claude
+# Code's idle timeout. The client's default; [model] idle_timeout_s sets it
+STREAM_IDLE_S = 300.0
+# the longest wait a server may ask for and be waited: past it (an hourly or daily window) a retry is not slept, the
+# person is told (gemini-cli packages/core/src/utils/googleQuotaErrors.ts:120)
+RETRY_AFTER_MAX_S = 300.0
+
+
+def first_output_s(body_bytes: int) -> float:
+    """How long an attempt whose request is ``body_bytes`` long may go without an answer."""
+    return FIRST_OUTPUT_S + body_bytes / FIRST_OUTPUT_BYTES_PER_S
+
 
 # how the answer travels, not what was asked: left out of the digest
 WIRE_ONLY = ("stream", "stream_options")
@@ -329,20 +343,22 @@ class ProviderError(Exception):
     (the body's ``error.type`` / ``error.code`` in the OpenAI shape, or FastAPI's ``detail`` when it is an
     object); its message; how long it asked us to
     wait; where it sent us instead (the Location header, on a redirect); whether it said to try again (its
-    ``x-should-retry`` header: True, False, or None when it said nothing); and the body whole. Everything a
-    caller decides on is a field here, never a word read out of a sentence."""
+    ``x-should-retry`` header: True, False, or None when it said nothing); the gateway's catalog kind (the body's
+    ``nunatak_kind``, beside the wire's native type and code; None from a base that is not the gateway); and the body
+    whole. Everything a caller decides on is a field here, never a word read out of a sentence."""
 
     def __init__(self, status: int, message: str, *, type: str | None = None, code: str | None = None,
                  retry_after: float | None = None, body: str = "", location: str | None = None,
-                 should_retry: bool | None = None):
+                 should_retry: bool | None = None, kind: str | None = None):
         self.status, self.message, self.type, self.code, self.retry_after, self.body = (int(status), message, type,
             code, retry_after, body)
-        self.location, self.should_retry = location, should_retry
-        super().__init__(f"HTTP {self.status}" + (f" {type}" if type else "") + (f": {message}" if message else ""))
+        self.location, self.should_retry, self.kind = location, should_retry, kind
+        named = kind or type
+        super().__init__(f"HTTP {self.status}" + (f" {named}" if named else "") + (f": {message}" if message else ""))
 
     @classmethod
     def from_response(cls, status: int, body: str, headers: Any = None) -> "ProviderError":
-        message, type_, code = body.strip(), None, None
+        message, type_, code, kind = body.strip(), None, None, None
         location = (headers.get("location") if headers is not None else None) or None
         try:
             d = json.loads(body)
@@ -356,6 +372,7 @@ class ProviderError(Exception):
                 message = str(err.get("message") or message)
                 type_ = str(err["type"]) if err.get("type") else None
                 code = str(err["code"]) if err.get("code") is not None else None
+                kind = str(err["nunatak_kind"]) if err.get("nunatak_kind") else None
             elif isinstance(d.get("detail"), str):
                 message = d["detail"]
             elif isinstance(d.get("error"), str):
@@ -363,7 +380,7 @@ class ProviderError(Exception):
         if location and 300 <= status < 400:
             message = f"moved to {location}"   # a redirect's body says "Redirecting"; the person needs the address
         return cls(status, message, type=type_, code=code, retry_after=retry_after_of(headers, message), body=body,
-                   location=location, should_retry=should_retry_of(headers))
+                   location=location, should_retry=should_retry_of(headers), kind=kind)
 
     @classmethod
     def from_frame(cls, err: dict[str, Any]) -> "ProviderError":
@@ -376,12 +393,19 @@ class ProviderError(Exception):
         return cls(status if 400 <= status < 600 else 502, str(err.get("message") or ""),
                    type=str(err["type"]) if err.get("type") else None,
                    code=str(err["code"]) if err.get("code") is not None else None, body=json.dumps({"error": err}),
-                   should_retry=r if isinstance(r, bool) else None)
+                   should_retry=r if isinstance(r, bool) else None,
+                   kind=str(err["nunatak_kind"]) if err.get("nunatak_kind") else None)
 
     @property
     def is_quota(self) -> bool:
         """A 429 that is a budget spent, never a throttle: no retry will help."""
-        return (self.type or "") in QUOTA or (self.code or "") in QUOTA
+        return (self.type or "") in QUOTA or (self.code or "") in QUOTA or self.is_daily_quota
+
+    @property
+    def is_daily_quota(self) -> bool:
+        """A quota that resets daily: the gateway's ``daily_quota`` kind (metaphi-labs/nunatak#232). No retry within the
+        session changes it."""
+        return self.kind == "daily_quota"
 
 
 CREDITS_WARN_AT = 0.8   # the share of credits used at which the person hears it, once per session
@@ -400,10 +424,24 @@ def error_text(e: BaseException) -> str:
     return f"{type(e).__name__}: {first}" if first else type(e).__name__
 
 
-# the gateway's failure kinds (Nunatak's catalog: error.type on any failure before output) and whether another request
-# can be answered differently. A kind named terminal is never retried, whatever its status or header says
-RETRYABLE_KINDS = frozenset({"capacity", "rate_limit", "deadline_exceeded"})
+# the gateway's failure kinds (Nunatak's catalog, config/errors.json: error.nunatak_kind beside the wire's native type
+# and code, before output and in-band) and whether another request can be answered differently. A kind named terminal
+# is never retried, whatever its status or header says
+RETRYABLE_KINDS = frozenset({"capacity", "overloaded", "rate_limit", "deadline_exceeded"})
 TERMINAL_KINDS = frozenset({"bad_request", "credits", "untyped"})
+# a base that is not the gateway names no kind: its native names read as the kind the gateway would have said for them
+# (the reverse of Nunatak's clients.<wire>.native), the code before the type (OpenAI's type "requests" says nothing)
+NATIVE_KINDS = {"rate_limit_exceeded": "rate_limit", "rate_limit_error": "rate_limit",
+                "overloaded_error": "overloaded", "server_is_overloaded": "overloaded",
+                "provider_overloaded": "overloaded", "timeout_error": "upstream_timeout",
+                "billing_error": "credits", "insufficient_quota": "credits"}
+
+
+def kind_of(e: ProviderError) -> str:
+    """The failure's catalog kind: the gateway's ``nunatak_kind``, else what a native code or type stands for, else
+    the provider's own type, else ``http_<status>``."""
+    return (e.kind or NATIVE_KINDS.get(e.code or "") or NATIVE_KINDS.get(e.type or "") or e.type
+            or f"http_{e.status}")
 
 
 @dataclass(frozen=True)
@@ -411,7 +449,8 @@ class Failure:
     """A failed model call as the retry decision reads it, typed once (``failure_of``): its kind (the gateway's
     catalog kind; else ``network`` for no answer at all, ``context_overflow``, or the provider's own type, or
     ``http_<status>``), whether another request can help, how long the server asked us to wait (None: it named
-    no wait), and the wire code, status and message it came with."""
+    no wait; on a failure not retried, only a wait past RETRY_AFTER_MAX_S, the reason it is not), and the wire code,
+    status and message it came with."""
     kind: str
     retryable: bool
     retry_after: float | None = None
@@ -425,12 +464,15 @@ def failure_of(e: BaseException) -> Failure:
     retries; else ``x-should-retry`` (or a stream frame's ``retryable``); else a retryable kind; else the status
     rules for a provider that types nothing: a throttle (a 429 that is not a budget), an upstream failure (5xx),
     a timeout or conflict. A budget spent, a bad request or token, a redirect, a prompt too big (whatever its
-    status: the loop makes the context smaller instead) are not. A connection that dropped or never answered
+    status: the loop makes the context smaller instead) are not, nor a retryable failure that asks for a wait past
+    RETRY_AFTER_MAX_S. A connection that dropped or never answered
     (an httpx transport error) is ``network`` and retried."""
     if isinstance(e, ProviderError):
-        kind = e.type or f"http_{e.status}"
+        kind = kind_of(e)
         if is_context_overflow(e):
             kind, retryable = "context_overflow", False
+        elif e.is_daily_quota:
+            kind, retryable = "daily_quota", False
         elif kind in TERMINAL_KINDS or e.is_quota:
             retryable = False
         elif e.should_retry is not None:
@@ -440,6 +482,8 @@ def failure_of(e: BaseException) -> Failure:
         else:
             # a 3xx says this address is not the host any more: the same request to the same place is answered the same
             retryable = e.status in (408, 409, 425) or e.status >= 500
+        if retryable and e.retry_after is not None and e.retry_after > RETRY_AFTER_MAX_S:
+            return Failure(kind, False, e.retry_after, e.code, e.status, e.message)   # a wait not waited: terminal
         return Failure(kind, retryable, e.retry_after if retryable else None, e.code, e.status, e.message)
     if isinstance(e, httpx.TransportError):
         return Failure("network", True, None, None, None, error_text(e))
@@ -463,7 +507,7 @@ def is_context_overflow(e: BaseException) -> bool:
     the context can be made smaller and the turn sent again."""
     if not isinstance(e, ProviderError):
         return False
-    if (e.code or "") in OVERFLOW_CODES or (e.type or "") in OVERFLOW_CODES:
+    if e.kind == "context_overflow" or (e.code or "") in OVERFLOW_CODES or (e.type or "") in OVERFLOW_CODES:
         return True
     return e.status == 400 and any(s in e.message.lower() for s in OVERFLOW)
 
@@ -492,7 +536,7 @@ class OpenAICompatClient:
 
     def __init__(self, model: str, *, api_base: str, api_key: str | None = None, temperature: float | None = None,
                  reasoning_effort: str | None = None, max_tokens: int | None = None, timeout: float = 3600.0,
-                 idle_timeout: float = 600.0, author: str = "policy", transport: Any = None,
+                 idle_timeout: float = STREAM_IDLE_S, author: str = "policy", transport: Any = None,
                  keep_requests: Path | None = None, hum: bool = True, gateway: Gateway | None = None):
         # on a gateway the model is the catalog's name, whole; elsewhere ``openai/`` names the wire, not the model
         strip = gateway is None and model.startswith("openai/")
@@ -506,9 +550,11 @@ class OpenAICompatClient:
         self.request_id: str | None = None   # the id the current attempt went up under (x-client-request-id)
         self.temperature, self.reasoning_effort, self.max_tokens, self.timeout = (temperature, reasoning_effort,
             max_tokens, timeout)
-        # a model thinking hard can be silent for minutes; a dead stream is silent forever
+        # the longest silence between stream events once the attempt is answered: a model thinking for minutes is kept
+        # alive by the gateway's keepalives; a dead stream is silent forever
         self.idle_timeout = idle_timeout
-        self._first_due: asyncio.Timeout | None = None   # the attempt's first-output clock (_call)
+        self._due: asyncio.Timeout | None = None   # the attempt's clock: first output, then each stream event (_call)
+        self._answered = False   # whether this attempt has been answered yet (headers or any stream event)
         self.author, self._transport = author, transport
         # where to keep each request whole when no server of ours does (the person's own key)
         self.keep_requests = keep_requests
@@ -567,7 +613,7 @@ class OpenAICompatClient:
                 b["session_id"] = str(session)[:256]
         return b, []
 
-    def _headers(self, request_id: str, api_key: str | None) -> dict[str, str]:
+    def _headers(self, request_id: str, api_key: str | None, first_s: float) -> dict[str, str]:
         # the client names itself here too: our proxy is a route of the deployment, which keeps a client floor
         from hum.auth import headers as auth_headers
         # the id this client minted for the request, as Claude Code and Codex send it: every hop logs it, so the call
@@ -576,8 +622,7 @@ class OpenAICompatClient:
              "x-client-request-id": request_id}
         if key := REQUEST_KEY.get():
             h["idempotency-key"] = key
-        if (budget := ATTEMPT_BUDGET_S.get()) is not None:
-            h["x-stainless-timeout"] = str(max(1, int(budget)))
+        h["x-stainless-timeout"] = str(int(first_s))
         if api_key:
             h["authorization"] = f"Bearer {api_key}"
         return h
@@ -624,8 +669,8 @@ class OpenAICompatClient:
         if not self.api_base and self.gateway is None:
             raise ProviderError(401, "no model host: `hum login`, or name an OpenAI-compatible base under [model] "
                                      "api_base in config.toml", type="no_host")
-        # httpx's read timeout is per chunk: a long generation keeps streaming; a stream silent for idle_timeout fails.
-        timeout = httpx.Timeout(self.timeout, connect=30.0, read=self.idle_timeout)
+        # no read timeout: an attempt's own clocks (_call) bound the wait for its answer and each silence after it
+        timeout = httpx.Timeout(self.timeout, connect=30.0, read=None)
         async with httpx.AsyncClient(timeout=timeout, transport=self._transport) as http:
             if self.gateway is None:
                 return await self._call(http, ev, self._body(messages, tools, tool_choice), "/chat/completions")
@@ -658,21 +703,37 @@ class OpenAICompatClient:
     async def _call(self, http: httpx.AsyncClient, ev: StreamEvents, body: dict[str, Any], path: str, *,
                     wire: str | None = None, api_base: str | None = None, api_key: str | None = None,
                     record: dict[str, Any] | None = None, route: str | None = None) -> Turn:
-        """One attempt, held to its budget (ATTEMPT_BUDGET_S) until its first output: from the first delta on, the
-        stream's own clocks apply. An attempt that showed nothing by then is cut, typed ``deadline_exceeded``."""
-        budget = ATTEMPT_BUDGET_S.get()
+        """One attempt, held to FIRST_OUTPUT_S (and its request's size) until it is answered (headers, or its first
+        stream event), then to ``idle_timeout`` between stream events of any kind, keepalive comments included. One
+        not answered in time is cut, typed ``deadline_exceeded``; one silent after, ``stream_idle``."""
+        # serialized once, as httpx would: its size sets the bound
+        raw = json.dumps(body, ensure_ascii=False, separators=(",", ":"), allow_nan=False).encode()
+        first_s = first_output_s(len(raw))
+        self._answered = False
+        t0 = time.monotonic()
         try:
-            async with asyncio.timeout(budget) as self._first_due:
-                return await self._attempt(http, ev, body, path, wire=wire, api_base=api_base, api_key=api_key,
-                                           record=record, route=route)
+            async with asyncio.timeout_at(asyncio.get_running_loop().time() + first_s) as self._due:
+                return await self._attempt(http, ev, body, raw, first_s, path, wire=wire, api_base=api_base,
+                                           api_key=api_key, record=record, route=route)
         except TimeoutError:
-            if budget is None or not self._first_due.expired():
+            if not self._due.expired():
                 raise
-            e = ProviderError(504, f"no output within {budget:.0f} s", type="deadline_exceeded")
-            self._made(body, time.monotonic() - budget, api_base=api_base or self.api_base, wire=record, error=e)
+            e = (ProviderError(504, f"no stream event for {self.idle_timeout:.0f} s", type="stream_idle")
+                 if self._answered else
+                 ProviderError(504, f"no answer within {first_s:.0f} s", type="deadline_exceeded"))
+            p = self._partial
+            self._made(body, t0, api_base=api_base or self.api_base, wire=record, error=e,
+                       response=p.response() if p is not None and not p.empty else None)
             raise e from None
 
-    async def _attempt(self, http: httpx.AsyncClient, ev: StreamEvents, body: dict[str, Any], path: str, *,
+    def _alive(self) -> None:
+        """The attempt was answered, or its stream sent something: the idle clock starts over from now."""
+        self._answered = True
+        if self._due is not None:
+            self._due.reschedule(asyncio.get_running_loop().time() + self.idle_timeout)
+
+    async def _attempt(self, http: httpx.AsyncClient, ev: StreamEvents, body: dict[str, Any], raw: bytes,
+                       first_s: float, path: str, *,
                        wire: str | None = None, api_base: str | None = None, api_key: str | None = None,
                        record: dict[str, Any] | None = None, route: str | None = None) -> Turn:
         """One request and its stream read to the end. ``wire`` is None through Hum's proxy or a base (chat
@@ -685,7 +746,7 @@ class OpenAICompatClient:
         self.request_id = str(uuid.uuid4())   # one per attempt: a retry is another request
         native = wire is not None
         p = self._partial = _Partial(self.author, route or self.model)
-        async with http.stream("POST", url, json=body, headers=self._headers(self.request_id, key)) as r:
+        async with http.stream("POST", url, content=raw, headers=self._headers(self.request_id, key, first_s)) as r:
             def made(**kw: Any) -> None:
                 self._made(body, t0, headers=r.headers, api_base=base, wire=record, **kw)
 
@@ -694,11 +755,14 @@ class OpenAICompatClient:
                 e = ProviderError.from_response(r.status_code, text, r.headers)
                 made(error=e)
                 raise e
+            self._alive()   # answered: from here on, the silence between events is what is bounded
             self._credits(r.headers)
             closed = [False]   # the provider said the reply ended: [DONE], or a finish reason on a chunk
 
             async def data() -> Any:
                 async for line in r.aiter_lines():
+                    if line:
+                        self._alive()   # any event, a keepalive comment or one the reply does not use included
                     if not line.startswith("data:"):
                         continue
                     raw = line[5:].strip()
@@ -735,18 +799,15 @@ class OpenAICompatClient:
                         delta = ch.get("delta") or {}
                         if delta.get("content"):
                             p.content.append(delta["content"])
-                            self._first_due.reschedule(None)   # output: the person is no longer waiting
                             if ev.text:
                                 ev.text(delta["content"])
                         rc = delta.get("reasoning_content") or delta.get("reasoning")
                         if rc:
                             p.reasoning.append(rc)
-                            self._first_due.reschedule(None)   # output: the person is no longer waiting
                             if ev.reasoning:
                                 ev.reasoning(rc)
                         for tc in delta.get("tool_calls") or []:
                             i, name, args = p.tool_delta(tc)
-                            self._first_due.reschedule(None)   # output: the person is no longer waiting
                             if ev.tool:
                                 ev.tool(i, name, args)
             except ProviderError as e:

hum/tui/cli.mjs

@@ -89511,7 +89511,7 @@ var init_install = __esm({
   "src/install.js"() {
     init_define_HUM_CORE_SUBS();
     win = process.platform === "win32";
-    MINE = true ? "0.2.63" : "";
+    MINE = true ? "0.2.64" : "";
     npmFix = (version = "") => `npm i -g @metaphi-ai/hum@${version || "latest"} --foreground-scripts`;
     NPM_FIX = npmFix("latest");
     humHome = (env3 = process.env) => env3.HUM_HOME || path.join(os3.homedir(), ".hum");
@@ -89866,10 +89866,10 @@ function clientEnv() {
     platform: process.platform,
     arch: process.arch,
     terminal: process.env.TERM_PROGRAM || (process.env.WT_SESSION ? "Windows Terminal" : process.env.TERM || ""),
-    tui: true ? "0.2.63" : ""
+    tui: true ? "0.2.64" : ""
   };
 }
-function startFailure(failures, { npm = /^(node|bun)(\.exe)?$/i.test(String(process.execPath).split(/[\\/]/).pop()), platform: platform2 = process.platform, version = true ? "0.2.63" : "" } = {}) {
+function startFailure(failures, { npm = /^(node|bun)(\.exe)?$/i.test(String(process.execPath).split(/[\\/]/).pop()), platform: platform2 = process.platform, version = true ? "0.2.64" : "" } = {}) {
   const refused = failures.find((f) => f.error && f.error.code !== "ENOENT");
   const fix = npm ? npmFix(version) : updateCommand({ kind: "native" }, platform2);
   if (!refused) {
@@ -91384,7 +91384,7 @@ var after = (ms, fn) => {
 
 // src/app.jsx
 var import_jsx_runtime3 = __toESM(require_jsx_runtime(), 1);
-var MINE2 = true ? "0.2.63" : "";
+var MINE2 = true ? "0.2.64" : "";
 var fmtDur = (s) => s < 60 ? `${Math.max(1, Math.round(s))}s` : `${Math.floor(s / 60)}m ${Math.round(s % 60)}s`;
 var plural = (n, w) => `${n} ${w}${n === 1 ? "" : "s"}`;
 var shortSession = (name) => (name || "").replace(/\.jsonl$/, "");
@@ -94070,7 +94070,7 @@ async function sendPending({
 await init_theme();
 var import_jsx_runtime5 = __toESM(require_jsx_runtime(), 1);
 import { spawnSync as spawnSync6 } from "node:child_process";
-var MINE3 = true ? "0.2.63" : "0.0.0";
+var MINE3 = true ? "0.2.64" : "0.0.0";
 var layout = installLayout();
 function completeInstall() {
   if (layout.kind !== "npm" || !needsInstall(MINE3)) return;

{hum_cli-0.2.63.dist-info → hum_cli-0.2.64.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: hum-cli
-Version: 0.2.63
+Version: 0.2.64
 Summary: A self-improving coding agent harness. It improves with your usage.
 License: Copyright (c) 2026 Metaphi, Inc. All rights reserved.
         

{hum_cli-0.2.63.dist-info → hum_cli-0.2.64.dist-info}/RECORD

@@ -1,9 +1,9 @@
-hum/__init__.py,sha256=La2jgS8FEutaqUyCv3vf7b7vM-NlCabo-XlFfNEJj0A,104
+hum/__init__.py,sha256=eopcky-Iu9T5iush8TghzpzdP88uA-cB9Jcfq74yEFQ,104
 hum/auth.py,sha256=Nur8ysHt1WVk7yj0ZICIDLoTebIY8g6Eix_cPp9r3T0,18821
 hum/catalog.py,sha256=6INNvyhwu69UZV80Ri9pGRc6H2eRzSsqkW08vSfMhAU,5290
 hum/cli.py,sha256=9YgOzBuoww1sOflXPZoZhKinSHadY_wcLj2a8218gNU,89486
-hum/client.py,sha256=B9rDzaGq2eEX4w_wk4TpQ1IR_O7TO9IoPISbX82Di4g,79465
-hum/core.py,sha256=TlHSFbKucqvt8dVVGGIISDkHnnheRRp9SWG1B0gYt5U,168336
+hum/client.py,sha256=KDgrgEsLpH23BpnKR0qoCGfqcyul9Zyua6E-Zd9KQxk,79350
+hum/core.py,sha256=ZDjofAn0mANApJxcEs2ZrJS6Nmhi0_YB-_ll7doeKzg,168290
 hum/errors.py,sha256=xnhAU0A-662IYa4kMI0zbtYfcpo24uRRAPY87BYLHs4,4858
 hum/gitcred.py,sha256=vCynyn5ZewYJZa1vx73jQNy7KCdDjx_ppiIWegSH4wM,3698
 hum/jsonui.py,sha256=5zlJn2n99qbz8xvGsfkhSI9Vkb0bBqzUz-vlBG6HD_8,5688
@@ -36,12 +36,12 @@ hum/runtime/ask.py,sha256=SgpoVuknFnDEIEc2S9u54ueAQOA8hhQZyxsQmmAsiIw,24084
 hum/runtime/background.py,sha256=sFvf-m8DQhLfekr65XlumXU0DKHlOGqj9CVfnrR8lTY,14035
 hum/runtime/channel.py,sha256=bZNaFg7yAt9pgtKLcU4Rah9k3ngMYWiRxClZARBMyJo,4378
 hum/runtime/comms.py,sha256=p03TUazJ75VpNpjLEVeDr-aKyR15n9tmAQCXhMPEKcQ,13653
-hum/runtime/config.py,sha256=sXbdGa9gtEF-ZOH67ObRDJGLfZeIgrP9rcsuwXZeN_A,24854
+hum/runtime/config.py,sha256=oML9NShkQQHTuVKczggW2MPyhZJykqUY_KaWxpAPvD4,25000
 hum/runtime/constraints.py,sha256=9WW-Y6W4dNIcKDdtVfxbLBCNYBb4SR18jycOCpf5gPs,6404
 hum/runtime/decision.py,sha256=rUx1ibu5BfwmZkfyfOs1_9fRnOrVCZUk7zytLvarPpA,7876
 hum/runtime/dm.py,sha256=79LUVsGa7Z-wgQumGbLRmQoAbnMgC9jBJz483OaZjHs,7929
 hum/runtime/documents.py,sha256=zIHq3uNJfekF0PZcoQCCsaOZm3HXa8-ThQnQ_u-cpRM,13756
-hum/runtime/drivers.py,sha256=g-ZXBPyR3WAG0OEKaNHVnIllQXroJanEsNVRdFCkWKI,15277
+hum/runtime/drivers.py,sha256=Z-kO1-b19NOzdOcTTVif2dV0436wv8rwg0Sfb7uOjCU,17482
 hum/runtime/evals.py,sha256=KvOYsI7Qzz2hJTD1z1l42ynxyWifdJLNFlAIA84tk9c,8881
 hum/runtime/executor.py,sha256=VOLe-AA0YB6cSaoGE2ThSpFOHE5_QdBIyysUQ-Mc0kU,14684
 hum/runtime/gateway.py,sha256=AmO060cfJZJjkmNr0EOGKDCG3pbyX21wJ_-XqtBX6S4,10155
@@ -50,7 +50,7 @@ hum/runtime/grader.py,sha256=bwgu9J6j7K4JTOqIACGdt8zm_jXX6O4uk-It0vfVK8s,5249
 hum/runtime/hooks.py,sha256=J75DSe5RVT_NDpBY0FRq6gstSDkklrCwmtC9BxRnKMQ,15967
 hum/runtime/images.py,sha256=4rZ7Sqiw-X0I2mayLA1xkNd8ZwREPf8Iq02kJJyFZX4,11594
 hum/runtime/lead.py,sha256=Q34siKxfH-EpwqIEB5iMXJNGbVFTbGV1rUVMS8dEyDQ,31037
-hum/runtime/llm.py,sha256=qUstGmCUiPwy-aOtrWfQ-SAHt18kSZelJqb85hjLxyY,43509
+hum/runtime/llm.py,sha256=phc4fLlPOxIOdBOJG2S-9MEHaWtG82bO8A20-ivwp3Y,47446
 hum/runtime/loop.py,sha256=cv22KY6h2VU2nUllQ3_TAX3ZPNUzkdxA_81v5zJtaYY,101142
 hum/runtime/lsp.py,sha256=1-JhG_KvbfNq_FLnVmVy2NrvK7d3D-2cO8ayWkR9ybc,30319
 hum/runtime/memory.py,sha256=Z2u9boBWxjaQOOOwY50wfWoGFPPFnKcvfaqOv-O4vWU,14429
@@ -118,10 +118,10 @@ hum/skills/artifact-design/references/reports.md,sha256=5MSv7JGYJHobHXfgAclt_xsf
 hum/skills/consult-human/SKILL.md,sha256=5rMKwC5C9L4nn-ifTjQGXl9hsYbeqOCHNl0IEog_T-E,6867
 hum/skills/consult-human/references/examples.md,sha256=hAdTOiJHlv27dTraEyPz0BILqx_8gZj0FPO43b2OMvw,3490
 hum/skills/consult-human/references/hypotheses.md,sha256=a3Hj3_zdxZZS7-bpxXGu2AEgaOV5Q31iVc2VHJ2yjxQ,3263
-hum/tui/cli.mjs,sha256=tOLb7tXUSfk1wNwcGiOA4BbSeDVhb3_ST1y1NGiyHO8,4215247
+hum/tui/cli.mjs,sha256=226j0vquDgYoX3xd0YOAI38TKxYZK0v6jQhqXl_d3Mk,4215247
 humboldt/__init__.py,sha256=EcK3Ou8qg9DLaYCtm5t2EcU-C8xZxP8yxfGBiQkuW-M,236
-hum_cli-0.2.63.dist-info/METADATA,sha256=Zl1JTJ4SQPDaJHGfd1JfDdvDzjIlXXtRsY_z5sYGeco,1638
-hum_cli-0.2.63.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
-hum_cli-0.2.63.dist-info/entry_points.txt,sha256=L-JBWR79zdIsMdTN5K_PSI4HeJ4kwmo1Bm5oc3lVi5A,104
-hum_cli-0.2.63.dist-info/licenses/LICENSE,sha256=-_Jjy2-XAujWZirw6S-ORP1kLKeVuuG8piFwhYLtt8E,742
-hum_cli-0.2.63.dist-info/RECORD,,
+hum_cli-0.2.64.dist-info/METADATA,sha256=VJrmZ2VZcQy4PhmO1jbOZhizrkV7Ikp_Id3kNQkYhy0,1638
+hum_cli-0.2.64.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+hum_cli-0.2.64.dist-info/entry_points.txt,sha256=L-JBWR79zdIsMdTN5K_PSI4HeJ4kwmo1Bm5oc3lVi5A,104
+hum_cli-0.2.64.dist-info/licenses/LICENSE,sha256=-_Jjy2-XAujWZirw6S-ORP1kLKeVuuG8piFwhYLtt8E,742
+hum_cli-0.2.64.dist-info/RECORD,,