docs(agent): guard and bound every rule-4 fragment; make errorText fully total

Convergence review of the previous commit:

- README rule 4: the settle fragment now carries the AbortSignal third arg
  (its own bold sentence mandates bounding every recovery request), and
  the prose spells out the agent.chatId guard (undefined before the first
  turn) instead of prescribing a fragment that neither typechecks nor
  no-ops safely.
- errorText: an Error subclass with a throwing `message` getter could
  escape the try blocks — the instanceof branch is now wrapped too, so
  the totality contract holds.

Change-Id: I8580e2de0d4326f29fc40cccbbd4625df21803f5
Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Signed-off-by: Thomas Kosiewski <tk@coder.com>

Author: ThomasK33

packages/agent/README.md

@@ -364,15 +364,17 @@ Rules that keep it robust — each guards against a failure mode observed live:
 4. **Settle a turn that stopped on a tool call.** If the loop stops on a
    tool‑call step — e.g. your `stopWhen` ceiling lands exactly on the
    `structured_output` call (`finishReason: "tool-calls"`) — the tool results
-   ran locally but never reached the server. Submit the stranded step's
-   (`result.steps.at(-1)`) locally‑executed client outcomes directly via
-   `agent.client.submitToolResults(agent.chatId, { results: [{ tool_call_id, output, is_error }] })`
+   ran locally but never reached the server. Guard on `agent.chatId` (it is
+   `undefined` until the first turn creates the chat), then submit the
+   stranded step's (`result.steps.at(-1)`) locally‑executed client outcomes
+   directly via
+   `agent.client.submitToolResults(chatId, { results: [{ tool_call_id, output, is_error }] }, AbortSignal.timeout(8_000))`
    before touching the chat again, or it strands as in rule 1. Read the
    outcomes off the step's **content parts**: a `tool-result` part is a
    success, a `tool-error` part (the tool's `execute` threw) must be submitted
    with `is_error: true` — mirroring what the resume path would have sent. If
    a pending call has no local outcome (or the submit fails), end the stranded
-   turn with `agent.client.interruptChat(agent.chatId, AbortSignal.timeout(8_000))`
+   turn with `agent.client.interruptChat(chatId, AbortSignal.timeout(8_000))`
    instead. **Bound every one of these recovery requests with an
    `AbortSignal`** — they target a server that may already be stalled, and the
    bare `agent.interrupt()` / `agent.archive()` helpers carry no timeout. A

packages/agent/examples/06-structured-output.ts

@@ -44,7 +44,11 @@ function isAborted(err: unknown): boolean {
 function errorText(err: unknown): string {
   if (err == null) return "unknown error";
   if (typeof err === "string") return err;
-  if (err instanceof Error) return err.message;
+  try {
+    if (err instanceof Error && typeof err.message === "string") return err.message;
+  } catch {
+    // pathological `message` getter — fall through
+  }
   try {
     const json = JSON.stringify(err); // undefined for symbols/functions
     if (typeof json === "string") return json;