hum-cli 0.2.63__py3-none-any.whl → 0.2.65__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.65"

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()
@@ -550,6 +552,7 @@ class Client:
         return MCPToolset(m.name, url=m.url, command=m.command, args=m.args, headers=server_headers(m),
                           env_pass=self.cfg.sandbox_env_pass, timeout_s=m.timeout_s,
                           connect_timeout_s=m.connect_timeout_s, background_s=m.background_s,
+                          task_timeout_s=m.task_timeout_s,
                           env_extra=self._env_for(m),
                           meta=self.call_meta if source == "deployment" and not by_identity else None,
                           # a server chosen for this session by its author (an agent file's, a program's) is given

hum/core.py

@@ -52,6 +52,10 @@ Front-end → core (commands)
   {"cmd": "attach", "path": "…"}            an image file the person named → image {…}
   {"cmd": "shell", "command": "…"}          the person runs a command themselves (!cmd)
   {"cmd": "interrupt"}                      stop the current turn; what it had so far is kept
+  {"cmd": "background", "cancel"?: "<call id>"}   → info: the calls still out past their turns (a tool server's task,
+                                             a call past background_s); with cancel, that one is stopped (a task is
+                                             cancelled on its server) and the model is woken with its end. The
+                                             one path that cancels a task: a watch's own bound never does
   {"cmd": "model", "name": "…", "default"?: true}   switch model for the rest of the session; default = also the
                                              default for new sessions; no name → models {items, via}, the picker
   {"cmd": "decide", "decision": "accept"|"reject", "note": "…", "remember"?: "session"|"project"}   answer a proposal;
@@ -673,7 +677,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:
@@ -1279,6 +1283,16 @@ class Core:
             content = note or ""
             extra: dict[str, Any] = {"event": "task_note", **keep}
             self.ui.info(f"{name}: {' '.join((note or '').split())[:200]}")
+        elif about.get("unwatched"):
+            # the call did not end: Hum let go of a task that still stands on its server. The record keeps it out
+            # (no task_done), so a session opened again watches it again
+            took = duration(float(about.get("elapsed_s") or 0.0))
+            content = (f"[{name} is no longer watched after {took}; its task still stands on its server. Nothing "
+                       f"here is from the person.]\n{result.content}")
+            extra = {"event": "task_unwatched", **keep, "elapsed_s": about.get("elapsed_s"),
+                     "result": result.model_dump(mode="json")}
+            self.ui.info(f"{name} no longer watched · {took} · task {about.get('task_id') or '?'} still on "
+                         f"{about.get('server') or 'its server'}")
         else:
             how = "finished" if result.ok else "failed"
             took = duration(float(about.get("elapsed_s") or 0.0))
@@ -1627,6 +1641,21 @@ class Core:
     async def _cmd_interrupt(self, cmd: dict[str, Any], w: Writer | None) -> None:
         await self.interrupt()
 
+    async def _cmd_background(self, cmd: dict[str, Any], w: Writer | None) -> None:
+        which = str(cmd.get("cancel") or "").strip()
+        if which:
+            said = self.background.cancel(which, "a person cancelled it")
+            if said == "stopping":
+                self.ui.info(f"stopping {which}: when it has stopped, its end shows here and reaches the model")
+            elif said == "ended":
+                self.ui.info(f"{which} had already ended: its result reaches the model, not a stop")
+            else:
+                self.ui.warn(f"no call {which} is out: /background lists the ones that are")
+            return
+        out = self.background.pending
+        self.ui.info("\n".join(f"{p['call_id']}  {p['name']}" + (f"  task {p['task_id']}" if p.get("task_id") else "")
+                               + f"  {p['elapsed_s']:.0f}s" for p in out) if out else "no calls are out")
+
     async def _cmd_model(self, cmd: dict[str, Any], w: Writer | None) -> None:
         name = str(cmd.get("name", "")).strip()
         if name:
@@ -2392,6 +2421,7 @@ class Core:
         "send": _cmd_send,
         "shell": _cmd_shell,
         "interrupt": _cmd_interrupt,
+        "background": _cmd_background,
         "model": _cmd_model,
         "reasoning": _cmd_reasoning,
         "decide": _cmd_decide,

hum/plain.py

@@ -38,6 +38,8 @@ HELP = """/help          this
 /goal [text]   set the goal the session keeps working toward, exchange after exchange, until the model marks it
                complete or blocked; /goal pause · resume · clear; /goal alone shows where it stands
 /agent <n> …   speak to one running sub-agent (it reads it at its next step); /agent <n> stop ends it
+/background    the tool calls still out past their turns (a server's task, a long call), by call id;
+               /background cancel <call id> stops one (a task is cancelled on its server)
 /diff [what]   what has changed since this session began (/diff last: the last exchange; /diff <path>: one file)
 /rewind [n]    the points you can go back to; /rewind <n> [files|chat|both] goes back to one
 /accept [why]  the work as it stands is what you wanted
@@ -525,6 +527,14 @@ class Plain:
                 send(cmd="agent", agent=int(n), stop=True)
             else:
                 send(cmd="agent", agent=int(n), text=rest.strip())
+        elif cmd == "background":
+            verb, _, which = arg.partition(" ")
+            if not arg:
+                send(cmd="background")
+            elif verb == "cancel" and which.strip():
+                send(cmd="background", cancel=which.strip())
+            else:
+                self.ui.info("/background lists the calls still out; /background cancel <call id> stops one")
         elif cmd == "goal":
             send(cmd="goal", text=arg)
         elif cmd == "diff":

hum/runtime/agent_files.py

@@ -32,7 +32,7 @@ from typing import Any
 
 import yaml
 
-from .config import MCP_BACKGROUND_S, MCP_CONNECT_TIMEOUT_S, MCP_TIMEOUT_S, MCPConfig
+from .config import MCP_BACKGROUND_S, MCP_CONNECT_TIMEOUT_S, MCP_TASK_TIMEOUT_S, MCP_TIMEOUT_S, MCPConfig
 from .skills import _FRONT, _NAME_OK, front_matter
 
 # Hum's own, and nobody else's: another harness keeps its agents in its own folder, in its own format, and
@@ -174,7 +174,8 @@ def _server_words(m: MCPConfig) -> dict[str, Any]:
                               ("timeout_s", m.timeout_s if m.timeout_s != MCP_TIMEOUT_S else None),
                               ("connect_timeout_s", m.connect_timeout_s
                                if m.connect_timeout_s != MCP_CONNECT_TIMEOUT_S else None),
-                              ("background_s", m.background_s if m.background_s != MCP_BACKGROUND_S else None))
+                              ("background_s", m.background_s if m.background_s != MCP_BACKGROUND_S else None),
+                              ("task_timeout_s", m.task_timeout_s if m.task_timeout_s != MCP_TASK_TIMEOUT_S else None))
             if v or (k == "background_s" and v is not None)}
 
 
@@ -191,6 +192,7 @@ def server_config(name: str, spec: Any, root: Path | None = None) -> MCPConfig |
         command = str((root / str(command)).resolve())
     headers = spec.get("headers") or {}
     timeout, connect, background = spec.get("timeout_s"), spec.get("connect_timeout_s"), spec.get("background_s")
+    tasks = spec.get("task_timeout_s")
     return MCPConfig(name=str(name).strip(), url=str(url) if url else None, command=str(command) if command else None,
                      args=[str(a) for a in spec.get("args") or []],
                      headers={str(k): str(v) for k, v in dict(headers).items()},
@@ -198,7 +200,8 @@ def server_config(name: str, spec: Any, root: Path | None = None) -> MCPConfig |
                      env={str(k): str(v) for k, v in dict(spec.get("env") or {}).items()},
                      timeout_s=float(timeout) if timeout else MCP_TIMEOUT_S,
                      connect_timeout_s=float(connect) if connect else MCP_CONNECT_TIMEOUT_S,
-                     background_s=float(background) if background is not None else MCP_BACKGROUND_S)
+                     background_s=float(background) if background is not None else MCP_BACKGROUND_S,
+                     task_timeout_s=float(tasks) if tasks else MCP_TASK_TIMEOUT_S)
 
 
 def _front_servers(text: str, root: Path | None) -> list[MCPConfig]:

hum/runtime/background.py

@@ -90,33 +90,110 @@ class GetTaskRequest(mcp_types.Request[_TaskParams, Literal["tasks/get"]]):
     name_param = "taskId"   # the extension routes tasks/* by the task id in the Mcp-Name header
 
 
+class CancelTaskRequest(mcp_types.Request[_TaskParams, Literal["tasks/cancel"]]):
+    method: Literal["tasks/cancel"] = "tasks/cancel"
+    params: _TaskParams
+    name_param = "taskId"
+
+
 _TASK = TypeAdapter(Task)
+_ANY = TypeAdapter(dict[str, Any])
+POLL_TIMEOUT_S = 30.0   # one tasks/get: a poll the server does not answer in this long is asked again, not waited on
 
 
-async def get_task(session: Any, task_id: str) -> Task:
+async def get_task(session: Any, task_id: str, timeout_s: float | None = POLL_TIMEOUT_S) -> Task:
     """One poll: the task as the server has it now. Raises the SDK's MCPError for a task the server no longer
-    holds (its TTL ran out) or never had."""
-    return await session.send_request(GetTaskRequest(params=_TaskParams(task_id=task_id)), _TASK)
-
-
-async def poll(session: Any, task: Task, *, on_status: Callable[[Task], Any] | None = None,
-               now: bool = False) -> Task:
-    """Follow one task to its end: sleep the interval the server names, ask again, until a terminal status.
-    ``now`` asks before the first sleep (a task known only by its id, from the record). ``on_status`` hears
-    every change of status on the way (working to input_required, and back). A task whose TTL runs out before
-    it ends comes back as it last stood, with ``status`` ``failed`` and the reason in its message, since the
-    server may have dropped it."""
-    seen = time.monotonic()
+    holds (its TTL ran out) or never had, and for a poll it did not answer within ``timeout_s``."""
+    return await session.send_request(GetTaskRequest(params=_TaskParams(task_id=task_id)), _TASK,
+                                      request_read_timeout_seconds=timeout_s)
+
+
+async def cancel_task(session: Any, task_id: str, timeout_s: float | None = POLL_TIMEOUT_S) -> None:
+    """Ask the server to cancel a task. Cancellation is eventually consistent on its side; the ack is all this
+    waits for."""
+    await session.send_request(CancelTaskRequest(params=_TaskParams(task_id=task_id)), _ANY,
+                               request_read_timeout_seconds=timeout_s)
+
+
+class CallCancelled(Exception):
+    """A call still out that a person stopped (Background.cancel), in the words the model reads."""
+
+
+class TaskUnwatched(Exception):
+    """A watch that ended with its task still standing on its server: Hum stopped following it (its ceiling
+    passed, or the server could not be reached), it did not end. The words are what the model reads; the record
+    keeps the call out, so a session opened again watches the task again."""
+
+
+class TaskTimedOut(Exception):
+    """A task Hum followed past its client's ceiling (``task_timeout_s``), the task as it last stood."""
+
+    def __init__(self, task: Task, ceiling_s: float):
+        super().__init__(f"task {task.task_id} was still {task.status} after {ceiling_s:.0f}s")
+        self.task, self.ceiling_s = task, ceiling_s
+
+
+class TaskUnreachable(Exception):
+    """Polls of a task that reached no server, as many in a row as the watch allows: the task's state is
+    unknown, not ended."""
+
+    def __init__(self, task_id: str, tries: int, cause: BaseException):
+        super().__init__(f"task {task_id}: {tries} polls in a row reached no server ({cause})")
+        self.task_id, self.tries, self.cause = task_id, tries, cause
+
+
+def created_at(task: Task) -> float | None:
+    """When the server says the task was made, as wall-clock seconds; None when it does not say legibly. A
+    timestamp with no offset is read as UTC, as the extension's own are written."""
+    if not task.created_at:
+        return None
+    from datetime import datetime, timezone
+    try:
+        when = datetime.fromisoformat(task.created_at.replace("Z", "+00:00"))
+    except ValueError:
+        return None
+    if when.tzinfo is None:
+        when = when.replace(tzinfo=timezone.utc)
+    return when.timestamp()
+
+
+async def poll(fetch: Callable[[str], Awaitable[Task]], task: Task, *,
+               on_status: Callable[[Task], Any] | None = None, now: bool = False,
+               ceiling_s: float | None = None) -> Task:
+    """Follow one task to its end: sleep the interval the server names, ``fetch`` it again, until a terminal
+    status. ``now`` asks before the first sleep (a task known only by its id, from the record). ``on_status``
+    hears every change of status on the way (working to input_required, and back).
+
+    The task's ``ttlMs`` is how long the server may keep it, not a deadline for the client: a task that outlives
+    it is followed while the server still answers for it, and one the server has dropped ends the watch with the
+    server's own error. The client's own bound is ``ceiling_s``: how long this watch follows the task, counted
+    from when it began (a session opened again watches for a fresh while). Past it, a sleep or a fetch still out
+    included, the watch raises TaskTimedOut with the task as it last stood. It only ends the watch: the task
+    stands on its server."""
+    began = time.monotonic()
+
+    def left() -> float:
+        return began + ceiling_s - time.monotonic() if ceiling_s is not None else float("inf")
+
     while not task.done:
-        if task.ttl_ms and time.monotonic() - seen > task.ttl_ms / 1000.0 + task.interval_s():
-            return task.model_copy(update={"status": "failed",
-                                           "status_message": f"the task's time to live ({task.ttl_ms} ms) ran out "
-                                                             f"with it still {task.status}"})
+        if left() <= 0:
+            raise TaskTimedOut(task, ceiling_s or 0.0)
         if now:
             now = False
         else:
-            await asyncio.sleep(task.interval_s())
-        fresh = await get_task(session, task.task_id)
+            await asyncio.sleep(max(0.0, min(task.interval_s(), left())))
+            if left() <= 0:
+                raise TaskTimedOut(task, ceiling_s or 0.0)
+        if ceiling_s is None:
+            fresh = await fetch(task.task_id)
+        else:
+            try:
+                async with asyncio.timeout(left()) as bound:
+                    fresh = await fetch(task.task_id)
+            except TimeoutError:
+                if bound.expired():
+                    raise TaskTimedOut(task, ceiling_s) from None
+                raise
         if fresh.status != task.status and on_status is not None:
             on_status(fresh)
         task = fresh
@@ -132,7 +209,7 @@ def task_extension() -> tuple[dict[str, dict[str, Any]], dict[str, list[Any]]]:
     from mcp.types import CallToolResult
 
     async def resolve(handle: TaskHandle, ctx: ClaimContext) -> CallToolResult:
-        task = await poll(ctx.session, handle.task())
+        task = await poll(lambda tid: get_task(ctx.session, tid), handle.task())
         return call_result(task)
 
     claim = ResultClaim(result_type="task", model=TaskHandle, resolve=resolve)
@@ -203,6 +280,9 @@ class Deferred:
     outcome: Callable[[Callable[[str], None]], Awaitable[Any]]
     task_id: str | None = None
     waited_s: float = 0.0   # how long the turn waited before the call went on without it
+    # how to stop the call where it runs, for a person who no longer wants it: a task is cancelled on its server
+    # (tasks/cancel), a plain call's request is given up on. None: there is nothing to stop but the watch
+    cancel: Callable[[], Awaitable[None]] | None = None
 
     def about(self) -> dict[str, Any]:
         """The facts the record keeps about the call that went on: enough to pick the watch up again."""
@@ -218,6 +298,9 @@ class Watch:
     deferred: Deferred
     started: float = field(default_factory=time.monotonic)
     task: asyncio.Task | None = None
+    stopped: str | None = None   # why a person stopped this call (Background.cancel); None while it runs
+    stop: asyncio.Event = field(default_factory=asyncio.Event)
+    outcome: asyncio.Future | None = None   # the call's own end, as it runs
 
     def facts(self) -> dict[str, Any]:
         return {"call_id": self.call.id, "name": self.call.name, **self.deferred.about(),
@@ -263,19 +346,66 @@ class Background:
             if self.deliver is not None:
                 self.deliver(w.facts(), None, text)
         try:
+            outcome = w.outcome = asyncio.ensure_future(w.deferred.outcome(say))
+            stop = asyncio.ensure_future(w.stop.wait())
             try:
-                raw = await w.deferred.outcome(say)
-            except asyncio.CancelledError:
-                raise
-            except BaseException as e:   # the failure goes where the text would have: finish renders it
-                raw = e
+                await asyncio.wait((outcome, stop), return_when=asyncio.FIRST_COMPLETED)
+            finally:
+                stop.cancel()
+                if not outcome.done():
+                    outcome.cancel()
+                    with contextlib.suppress(asyncio.CancelledError, Exception):
+                        await outcome
+            if not outcome.cancelled() and outcome.exception() is None:
+                raw = outcome.result()
+            elif w.stopped is not None:
+                raw = CallCancelled(await self._stop_at_source(w))
+            elif outcome.cancelled():
+                raise asyncio.CancelledError()
+            else:   # the failure goes where the text would have: finish renders it
+                raw = outcome.exception()
             result = await finish(raw, w.started)
         except asyncio.CancelledError:
             self._watches.pop(w.call.id, None)
             raise
         self._watches.pop(w.call.id, None)
         if self.deliver is not None:
-            self.deliver(w.facts(), result, None)
+            # a watch that let go of a task still standing says so: the record keeps the call out for the next
+            # opening to watch again, where an ended call is answered
+            self.deliver({**w.facts(), **({"unwatched": True} if isinstance(raw, TaskUnwatched) else {})},
+                         result, None)
+
+    def cancel(self, call_id: str, why: str = "a person cancelled it") -> Literal["stopping", "ended"] | None:
+        """Stop one call still out, by the id of the call that started it: a task is cancelled on its server, a
+        plain call is given up on, and the model is woken with the call's end in those words. ``stopping`` when
+        the stop goes ahead; ``ended`` when the call had already ended and its result is on its way (it is
+        delivered, not stopped); None when no call by that id is out. This is the one path that cancels a task
+        on its server: a person's or the model's word, never a watch's own bound."""
+        w = self._watches.get(call_id)
+        if w is None or w.task is None or w.task.done():
+            return None
+        if w.stopped is not None:
+            return "stopping"
+        if w.outcome is not None and w.outcome.done():
+            return "ended"
+        w.stopped = why
+        w.stop.set()
+        return "stopping"
+
+    @staticmethod
+    async def _stop_at_source(w: Watch) -> str:
+        """What stopping the call did where it runs, in the words the model reads."""
+        what = f"{w.call.name}" + (f" (task {w.deferred.task_id})" if w.deferred.task_id else "")
+        if w.deferred.cancel is None:
+            return f"{what} was stopped: {w.stopped}. Hum no longer waits for it."
+        try:
+            await w.deferred.cancel()
+        except Exception as e:
+            return (f"{what} was stopped: {w.stopped}. Hum asked {w.deferred.server} to cancel it and it did not "
+                    f"say it would ({type(e).__name__}: {e}); it may still run there.")
+        if w.deferred.kind == "task":
+            return f"{what} was stopped: {w.stopped}. Hum asked {w.deferred.server} to cancel the task."
+        return f"{what} was stopped: {w.stopped}. Hum gave up its request; the server may still finish it."
 
     async def close(self) -> None:
         """Stop watching: the tasks stand on their servers, and a session opened again finds them by the ids

hum/runtime/config.py

@@ -18,6 +18,11 @@ MCP_TIMEOUT_S = 900.0
 MCP_CONNECT_TIMEOUT_S = 30.0
 # how long a call holds the turn before it goes on in the background and its result comes back as a wake
 MCP_BACKGROUND_S = 120.0
+# how long one watch follows a tool server's task before it lets go: the client's own bound, whatever time to live the
+# server names, so a task that never ends does not hold a watch forever. Letting go never cancels the task: it goes on
+# on its server, the model is told its id, and a session opened again watches it again. Generous: a Harwell run may
+# take an hour, and a task is a call that was always going to be long
+MCP_TASK_TIMEOUT_S = 7200.0
 
 
 @dataclass
@@ -33,6 +38,8 @@ class MCPConfig:
     # [[mcp]] background_s: seconds a call holds the turn before it goes on in the background; 0 holds the turn
     # to the deadline
     background_s: float = MCP_BACKGROUND_S
+    # [[mcp]] task_timeout_s: seconds one watch follows one of this server's tasks before it lets go (never cancels it)
+    task_timeout_s: float = MCP_TASK_TIMEOUT_S
     env: dict[str, str] = field(default_factory=dict)   # a plugin's server: what its process is given
     plugin: str = ""                                    # the plugin that brought it, when one did
     of_repository: bool = False                         # the repository's word named it, not the person's (trust.claim)
@@ -65,9 +72,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"
@@ -169,6 +178,7 @@ def _server(s: dict[str, Any], of_repository: bool = False) -> MCPConfig:
         timeout_s=float(s.get("timeout_s") or MCP_TIMEOUT_S),
         connect_timeout_s=float(s.get("connect_timeout_s") or MCP_CONNECT_TIMEOUT_S),
         background_s=float(s["background_s"]) if s.get("background_s") is not None else MCP_BACKGROUND_S,
+        task_timeout_s=float(s.get("task_timeout_s") or MCP_TASK_TIMEOUT_S),
         env={str(k): str(v) for k, v in (s.get("env") or {}).items()},
         of_repository=of_repository)
 
@@ -293,7 +303,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", [])],