@mitralab.io/platform-sdk 1.1.0 → 1.1.1

package/README.md

@@ -246,7 +246,9 @@ unsubscribe()
 session.close()
 ```
 
-Open an existing task with `session({ taskId })`. The default `auto` transport refreshes before connecting, opens `/copilot/ws/tasks/{taskId}`, and performs at most one safe recovery through persisted history plus the HTTP/SSE channel. Set `transport: "http"` when WebSockets are unavailable. Messages sent during a turn enter a FIFO queue with a maximum of 10 items; the session also exposes edit, remove, clear, approval, cancel, history, close, and typed events.
+Open an existing task with `session({ taskId })`. The default `auto` transport refreshes before connecting, asks the Copilot where the chat is served, and opens whichever channel it names: the box that runs the agent when one is offered, `/copilot/ws/tasks/{taskId}` otherwise. The choice belongs to the server, never to application configuration, so a Copilot that stops offering the box leaves every application on the Copilot socket without a republish. Opening the box never asks it to replay, whether the conversation is new to the session or is being opened again after an idle close: what an idle conversation missed is history, which the application loads over REST. A box socket that drops in the middle of a turn is redialed by the SDK itself, with a bounded backoff (1, 2, 4, 8 and 16 seconds) and the replay from the last position seen on that socket, so the answer keeps streaming; a position taken on one box is forgotten when the Copilot points the conversation to another box; replayed `textChunk` frames reach the `delta` event like live text. While that happens the session emits `raw` events of type `channelReconnecting` (payload `attempt`, `maxAttempts`, `reason`) and `channelConnected` (payload `attempt`); the session `status` stays `streaming`, because Core has no reconnecting status. The disconnect reaches Core, and with it the `error` event, only when the attempts run out or the Copilot no longer offers the box. A drop with no turn in flight, a channel taken over by another tab (close code 4409), and any close of the Copilot socket the session did not ask for are reported at once, whatever the code, so the next send reopens the channel instead of waiting on a socket that is gone. Recovery through persisted history plus the HTTP/SSE channel is unchanged. Set `transport: "http"` when WebSockets are unavailable. Messages sent during a turn enter a FIFO queue with a maximum of 10 items; the session also exposes edit, remove, clear, approval, cancel, history, close, and typed events.
+
+A prompt sent while the browser says it is offline (`navigator.onLine === false`) does not enter Core at all, because Core opens the channel and reads the turn baseline before the prompt goes out and every one of those requests would fail first: the session keeps the prompt in an outbox, emits a `raw` event of type `inputUnsent` (payload `attempt` 0, `reason`, `waitingForOnline` true) and hands it to Core, in order, when the browser fires `online`; the turn starts then. A prompt whose `POST /inputs` went out but got no response at all is kept the same way: the session sends the same request again when the browser fires `online` or on a bounded backoff (2, 5, 10, 20 and 40 seconds), while the turn stays `streaming`, with `inputUnsent` events (payload `attempt`, `reason`, `waitingForOnline`, `retryInMs` when a timer is armed) and, once it goes through, `inputSent` (payload `attempts`). A response from the server, an error included, is never retried: the prompt fails through the `error` event as before. A session closed with a prompt still waiting emits `error` with code `INPUT_UNSENT` before it goes quiet, and `sendAndWait` rejects. The retry cannot tell a request the server never received from one whose response was lost on the way back, so a prompt may reach the server twice in that case; the Copilot's `/inputs` accepts no client message id yet. The public `agentTasks.sendInput` primitive is not held back: it fails immediately, as it always did.
 
 API keys and removal accept `ANTHROPIC` or `OPENAI`. OAuth accepts only `ANTHROPIC`; device authorization accepts only `OPENAI`. The facade enforces those producer-supported pairs in TypeScript and at runtime.
 

package/dist/index.cjs

@@ -1460,8 +1460,230 @@ var QueriesModule = class {
 // src/modules/agent-tasks.ts
 var import_sdk_core8 = require("@mitralab.io/sdk-core");
 
+// src/modules/agent-outbox.ts
+var OUTBOX_DELAYS_MS = [2e3, 5e3, 1e4, 2e4, 4e4];
+var browserNetwork = {
+  isOffline: () => globalThis.navigator?.onLine === false,
+  onOnline: (listener) => {
+    const target = globalThis;
+    if (typeof target.addEventListener !== "function") return () => void 0;
+    target.addEventListener("online", listener);
+    return () => target.removeEventListener?.("online", listener);
+  }
+};
+function sendGotNoResponse(error) {
+  return error instanceof TypeError;
+}
+function reasonOf(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function neverSent(pending) {
+  return new Error(
+    `Agent prompt was never sent: the session closed while it waited for the network (${pending} pending).`
+  );
+}
+var AgentInputOutbox = class {
+  constructor(tasks, announce, network = browserNetwork) {
+    this.tasks = tasks;
+    this.announce = announce;
+    this.network = network;
+  }
+  held = /* @__PURE__ */ new Map();
+  gated = /* @__PURE__ */ new Map();
+  async sendInput(taskId, input) {
+    try {
+      await this.tasks.sendInput(taskId, input);
+    } catch (error) {
+      if (input.type !== "message" || !sendGotNoResponse(error)) throw error;
+      await this.hold(taskId, input, error);
+    }
+  }
+  /** The session is closing: a prompt still waiting is reported, never dropped in silence. */
+  abandon(taskId) {
+    const pending = this.held.get(taskId);
+    if (!pending?.length) return;
+    this.held.delete(taskId);
+    this.drop(taskId, pending);
+  }
+  /** True when the browser says there is no network at all. */
+  get offline() {
+    return this.network.isOffline();
+  }
+  /**
+   * Keeps a prompt out of the core until the browser reports the network is back, then hands it
+   * over through `deliver`. Prompts held for one session leave in the order they arrived. The
+   * promise settles when the prompt is handed over, or rejects if the session closes first.
+   */
+  holdUntilOnline(session, taskId, deliver) {
+    return new Promise((resolve, reject) => {
+      const prompt = { resolve, reject, disarm: () => void 0 };
+      this.gated.set(session, [...this.gated.get(session) ?? [], prompt]);
+      if (taskId) {
+        this.announce(taskId, {
+          type: "inputUnsent",
+          payload: { attempt: 0, reason: "The browser is offline.", waitingForOnline: true },
+          timestamp: Date.now()
+        });
+      }
+      const offOnline = this.network.onOnline(() => {
+        prompt.disarm();
+        const rest = (this.gated.get(session) ?? []).filter((candidate) => candidate !== prompt);
+        if (rest.length) this.gated.set(session, rest);
+        else this.gated.delete(session);
+        deliver();
+        resolve();
+      });
+      prompt.disarm = () => {
+        offOnline();
+        prompt.disarm = () => void 0;
+      };
+    });
+  }
+  /** The session is closing with prompts that never entered the core: same report as `abandon`. */
+  abandonGated(session, taskId) {
+    const pending = this.gated.get(session);
+    if (!pending?.length) return;
+    this.gated.delete(session);
+    this.drop(taskId, pending);
+  }
+  drop(taskId, pending) {
+    const error = neverSent(pending.length);
+    if (taskId) {
+      this.announce(taskId, {
+        type: "error",
+        payload: { code: "INPUT_UNSENT", message: error.message },
+        timestamp: Date.now()
+      });
+    }
+    for (const prompt of pending) {
+      prompt.disarm();
+      prompt.reject(error);
+    }
+  }
+  hold(taskId, input, cause) {
+    return new Promise((resolve, reject) => {
+      const prompt = { input, attempts: 1, resolve, reject, disarm: () => void 0 };
+      this.held.set(taskId, [...this.held.get(taskId) ?? [], prompt]);
+      this.schedule(taskId, prompt, cause);
+    });
+  }
+  schedule(taskId, prompt, cause) {
+    const waitingForOnline = this.network.isOffline();
+    const retryInMs = waitingForOnline ? void 0 : OUTBOX_DELAYS_MS[prompt.attempts - 1];
+    if (!waitingForOnline && retryInMs === void 0) {
+      this.release(taskId, prompt);
+      prompt.reject(new Error(
+        `Agent prompt was not sent after ${prompt.attempts} attempts: ${reasonOf(cause)}`
+      ));
+      return;
+    }
+    this.announce(taskId, {
+      type: "inputUnsent",
+      payload: {
+        attempt: prompt.attempts,
+        reason: reasonOf(cause),
+        waitingForOnline,
+        ...retryInMs === void 0 ? {} : { retryInMs }
+      },
+      timestamp: Date.now()
+    });
+    const retry = () => {
+      prompt.disarm();
+      void this.retry(taskId, prompt);
+    };
+    const timer = retryInMs === void 0 ? null : globalThis.setTimeout(retry, retryInMs);
+    const offOnline = this.network.onOnline(retry);
+    prompt.disarm = () => {
+      if (timer !== null) globalThis.clearTimeout(timer);
+      offOnline();
+      prompt.disarm = () => void 0;
+    };
+  }
+  async retry(taskId, prompt) {
+    prompt.attempts += 1;
+    try {
+      await this.tasks.sendInput(taskId, prompt.input);
+    } catch (error) {
+      if (!this.isHeld(taskId, prompt)) return;
+      if (!sendGotNoResponse(error)) {
+        this.release(taskId, prompt);
+        prompt.reject(error instanceof Error ? error : new Error(String(error)));
+        return;
+      }
+      this.schedule(taskId, prompt, error);
+      return;
+    }
+    if (!this.isHeld(taskId, prompt)) return;
+    this.release(taskId, prompt);
+    this.announce(taskId, {
+      type: "inputSent",
+      payload: { attempts: prompt.attempts },
+      timestamp: Date.now()
+    });
+    prompt.resolve();
+  }
+  isHeld(taskId, prompt) {
+    return this.held.get(taskId)?.includes(prompt) ?? false;
+  }
+  release(taskId, prompt) {
+    const rest = (this.held.get(taskId) ?? []).filter((candidate) => candidate !== prompt);
+    if (rest.length) this.held.set(taskId, rest);
+    else this.held.delete(taskId);
+  }
+};
+function holdSendsWhileOffline(session, outbox) {
+  const passThrough = (prompt) => !outbox.offline || !prompt.trim() || session.status === "closed";
+  const gated = {
+    send: (prompt, options) => {
+      if (passThrough(prompt)) {
+        session.send(prompt, options);
+        return;
+      }
+      void outbox.holdUntilOnline(session, session.taskId, () => session.send(prompt, options)).catch(() => void 0);
+    },
+    sendAndWait: (prompt, options) => {
+      if (passThrough(prompt)) return session.sendAndWait(prompt, options);
+      let turn;
+      return outbox.holdUntilOnline(session, session.taskId, () => {
+        turn = session.sendAndWait(prompt, options);
+      }).then(() => turn);
+    },
+    close: () => {
+      outbox.abandonGated(session, session.taskId);
+      session.close();
+    }
+  };
+  return new Proxy(session, {
+    get: (target, key) => key in gated ? gated[key] : Reflect.get(target, key, target)
+  });
+}
+
 // src/modules/agent-session.ts
 var CONNECT_TIMEOUT_MS = 15e3;
+var CHANNEL_BOOT_TIMEOUT_MS = 9e4;
+var CHANNEL_BOOT_RETRY_MS = 2e3;
+var SILENCE_TIMEOUT_MS = 6e4;
+var RECONNECT_DELAYS_MS = [1e3, 2e3, 4e3, 8e3, 16e3];
+var SUPERSEDED_CLOSE_CODE = 4409;
+var SilenceWatchdog = class {
+  constructor(onSilence) {
+    this.onSilence = onSilence;
+  }
+  timer = null;
+  touch() {
+    this.clear();
+    this.timer = globalThis.setTimeout(this.onSilence, SILENCE_TIMEOUT_MS);
+  }
+  clear() {
+    if (this.timer !== null) {
+      globalThis.clearTimeout(this.timer);
+      this.timer = null;
+    }
+  }
+};
+function silenceError(transport) {
+  return new Error(`Agent ${transport} went silent for ${SILENCE_TIMEOUT_MS / 1e3}s.`);
+}
 function stripBearer2(token) {
   return token.replace(/^Bearer\s+/i, "");
 }
@@ -1480,6 +1702,37 @@ function expectEvent(value) {
     ...typeof event.sequence === "number" ? { sequence: event.sequence } : {}
   };
 }
+function isSameGateway(candidate, apiUrl) {
+  try {
+    const target = new URL(candidate);
+    if (target.protocol !== "ws:" && target.protocol !== "wss:") return false;
+    return target.host === new URL(apiUrl).host;
+  } catch {
+    return false;
+  }
+}
+function boxAddress(wsUrl) {
+  const url = new URL(wsUrl);
+  return `${url.origin}${url.pathname}`;
+}
+function toDirectChannel(body, apiUrl) {
+  if (typeof body !== "object" || body === null) return null;
+  const channel = body;
+  if (typeof channel.wsUrl !== "string" || !isSameGateway(channel.wsUrl, apiUrl)) return null;
+  return {
+    wsUrl: channel.wsUrl,
+    lastSequence: typeof channel.lastSequence === "number" && channel.lastSequence > 0 ? channel.lastSequence : 0
+  };
+}
+function sleep(ms, signal) {
+  return new Promise((resolve) => {
+    const timer = globalThis.setTimeout(resolve, ms);
+    signal?.addEventListener("abort", () => {
+      globalThis.clearTimeout(timer);
+      resolve();
+    }, { once: true });
+  });
+}
 function parseEvent(raw) {
   if (typeof raw !== "string") return expectEvent(raw);
   try {
@@ -1488,8 +1741,25 @@ function parseEvent(raw) {
     return null;
   }
 }
-function isNormalClose(event) {
-  return event.code === 1e3 || event.code === 4409;
+function asDelta(event) {
+  if (event.type !== "textChunk") return event;
+  const kind = asObject(event.payload)?.kind;
+  return { ...event, type: kind === "thinking" ? "thinking" : "textDelta" };
+}
+var TURN_FRAME_TYPES = /* @__PURE__ */ new Set(["textDelta", "thinking", "toolCall", "toolResult"]);
+var TURN_END_REASONS = /* @__PURE__ */ new Set(["stop", "endTurn", "interrupted"]);
+function turnAfter(event, inTurn) {
+  if (TURN_FRAME_TYPES.has(event.type)) return true;
+  if (event.type === "error") return false;
+  if (event.type === "stepFinish") {
+    const payload = asObject(event.payload);
+    if (TURN_END_REASONS.has(payload?.reason)) return false;
+    return asObject(payload?.lifecycle)?.interruptTerminal !== true;
+  }
+  return inTurn;
+}
+function channelEvent(type, payload) {
+  return { type, payload, timestamp: Date.now() };
 }
 var BrowserAgentTaskEventSource = class {
   constructor(auth, apiUrl) {
@@ -1498,6 +1768,18 @@ var BrowserAgentTaskEventSource = class {
   }
   apiUrl;
   sseFallbackTasks = /* @__PURE__ */ new Set();
+  // Tasks whose last WebSocket was the box itself. A box socket that closes says nothing about
+  // WebSockets: the box went idle or the channel was superseded, and the answer is to ask the
+  // copilot for the channel again. Only the copilot's own socket failing sends a task to SSE.
+  directTasks = /* @__PURE__ */ new Set();
+  /**
+   * Ate onde esta sessao ja viu o log da caixa, por conversa, e de qual caixa esse log e. So o
+   * redial no meio de um turno pede repeticao a partir daqui; abrir a conversa de novo nunca
+   * pede. O cursor vale para uma caixa: outra caixa tem outro log, e um cursor da anterior
+   * repetiria turnos antigos como se fossem texto ao vivo.
+   */
+  boxCursors = /* @__PURE__ */ new Map();
+  boxAddresses = /* @__PURE__ */ new Map();
   async open(taskId, observer, signal, transport = "auto") {
     if (transport === "http") return this.openSse(taskId, observer, signal);
     if (transport === "websocket") return this.openWebSocket(taskId, observer, signal);
@@ -1508,13 +1790,13 @@ var BrowserAgentTaskEventSource = class {
       const connection = await this.openWebSocket(taskId, {
         ...observer,
         onDisconnect: (error) => {
-          this.sseFallbackTasks.add(taskId);
+          if (!this.directTasks.has(taskId)) this.sseFallbackTasks.add(taskId);
           observer.onDisconnect(error);
         }
       }, signal);
       return this.wrapAutoConnection(taskId, connection);
     } catch {
-      this.sseFallbackTasks.add(taskId);
+      if (!this.directTasks.has(taskId)) this.sseFallbackTasks.add(taskId);
       return this.wrapAutoConnection(taskId, await this.openSse(taskId, observer, signal));
     }
   }
@@ -1522,6 +1804,9 @@ var BrowserAgentTaskEventSource = class {
     return {
       close: () => {
         this.sseFallbackTasks.delete(taskId);
+        this.directTasks.delete(taskId);
+        this.boxCursors.delete(taskId);
+        this.boxAddresses.delete(taskId);
         connection.close();
       }
     };
@@ -1534,13 +1819,161 @@ var BrowserAgentTaskEventSource = class {
     }
     return token;
   }
+  /**
+   * Pergunta ao copilot onde esta conversa e servida. Nada aqui e fatal: uma recusa, uma
+   * resposta que nao entendemos ou uma rede que falhou significam apenas que a conversa segue
+   * pelo socket do copilot, que e como toda conversa era servida antes da caixa existir.
+   */
+  requestDirectChannel(taskId, token, signal) {
+    return this.askDirectChannel(taskId, token, signal).catch(() => null);
+  }
+  /** Like `requestDirectChannel`, but a request the network lost is thrown, not a refusal. */
+  async askDirectChannel(taskId, token, signal) {
+    const url = `${this.apiUrl}/copilot/api/v1/tasks/${encodeURIComponent(taskId)}/channel`;
+    const deadline = Date.now() + CHANNEL_BOOT_TIMEOUT_MS;
+    for (; ; ) {
+      if (signal?.aborted) return null;
+      const response = await globalThis.fetch(url, {
+        method: "POST",
+        headers: { Authorization: `Bearer ${stripBearer2(token)}` },
+        ...signal ? { signal } : {}
+      });
+      if (response.status === 202) {
+        if (Date.now() >= deadline) return null;
+        await sleep(CHANNEL_BOOT_RETRY_MS, signal);
+        continue;
+      }
+      if (!response.ok) return null;
+      try {
+        return toDirectChannel(await response.json(), this.apiUrl);
+      } catch {
+        return null;
+      }
+    }
+  }
   async openWebSocket(taskId, observer, signal) {
     if (typeof globalThis.WebSocket !== "function") {
       throw new TypeError("WebSocket is not available.");
     }
     if (signal?.aborted) throw signal.reason ?? new Error("Agent WebSocket connection aborted.");
     const token = await this.requireFreshToken();
+    const direct = await this.requestDirectChannel(taskId, token, signal);
+    if (direct) this.directTasks.add(taskId);
+    else this.directTasks.delete(taskId);
+    if (direct) return this.openDirect(taskId, direct, observer, signal);
     const url = `${this.apiUrl.replace(/^http/i, "ws")}/copilot/ws/tasks/${encodeURIComponent(taskId)}?token=${encodeURIComponent(stripBearer2(token))}`;
+    const socket = await this.dial(url, {
+      signal,
+      onFrame: (event) => observer.onEvent(event),
+      onLost: (error) => observer.onDisconnect(error)
+    });
+    return { close: () => socket.close() };
+  }
+  /** Forgets the cursor when the copilot points the conversation to a box other than the last dialed. */
+  adoptBox(taskId, channel) {
+    const box = boxAddress(channel.wsUrl);
+    if (this.boxAddresses.get(taskId) === box) return;
+    this.boxAddresses.set(taskId, box);
+    this.boxCursors.delete(taskId);
+  }
+  /**
+   * The box path. A drop in the middle of a turn is redialed from here, with the replay the
+   * box offers, so the core keeps one connection and one stream: reporting the drop instead
+   * would make it reconcile the turn from persisted history, which is the screen freezing and
+   * the rest of the answer landing at once. The core hears a disconnect only when the redial
+   * gives up, when the copilot no longer offers the box, or when there is no turn to resume:
+   * the sandbox pauses an idle box, and dialing it again would wake it for nobody.
+   *
+   * Opening never asks for a replay, whether the conversation is new to this session or was
+   * open before. What an idle conversation missed is history, which the app loads by REST. Beta
+   * 2026-09-14: a tab open overnight had its box replaced, and the open that followed replayed
+   * the old box's cursor against the new log, which put every old turn on screen as live text.
+   */
+  async openDirect(taskId, channel, observer, signal) {
+    this.adoptBox(taskId, channel);
+    this.boxCursors.set(taskId, channel.lastSequence);
+    const link = new AbortController();
+    const onAbort = () => link.abort(signal?.reason);
+    signal?.addEventListener("abort", onAbort, { once: true });
+    let inTurn = false;
+    let current = null;
+    const onFrame = (event) => {
+      if (typeof event.sequence === "number") {
+        const seen = this.boxCursors.get(taskId) ?? 0;
+        if (event.sequence > seen) this.boxCursors.set(taskId, event.sequence);
+      }
+      inTurn = turnAfter(event, inTurn);
+      observer.onEvent(event);
+    };
+    const onLost = (error, code) => {
+      current = null;
+      if (link.signal.aborted) return;
+      if (!inTurn || code === SUPERSEDED_CLOSE_CODE) {
+        observer.onDisconnect(error);
+        return;
+      }
+      void this.redial(taskId, error, link.signal, observer, { onFrame, onLost }).then((socket) => {
+        current = socket;
+      });
+    };
+    current = await this.dial(channel.wsUrl, { signal: link.signal, onFrame, onLost });
+    return {
+      close: () => {
+        signal?.removeEventListener("abort", onAbort);
+        link.abort();
+        current?.close();
+      }
+    };
+  }
+  async redial(taskId, cause, signal, observer, handlers) {
+    let lastError = cause;
+    for (const [index, delayMs] of RECONNECT_DELAYS_MS.entries()) {
+      const attempt = index + 1;
+      observer.onEvent(channelEvent("channelReconnecting", {
+        attempt,
+        maxAttempts: RECONNECT_DELAYS_MS.length,
+        reason: lastError.message
+      }));
+      await sleep(delayMs, signal);
+      if (signal.aborted) return null;
+      const outcome = await this.reopenOnce(taskId, signal, handlers);
+      if (signal.aborted) return null;
+      if (outcome.kind === "socket") {
+        observer.onEvent(channelEvent("channelConnected", { attempt }));
+        return outcome.socket;
+      }
+      if (outcome.kind === "refused") {
+        observer.onDisconnect(new Error(
+          `The copilot no longer offers the box channel (after: ${cause.message})`
+        ));
+        return null;
+      }
+      lastError = outcome.error;
+    }
+    observer.onDisconnect(new Error(
+      `Agent box channel could not be reopened after ${RECONNECT_DELAYS_MS.length} attempts: ${lastError.message}`
+    ));
+    return null;
+  }
+  // One attempt to get the box back: a fresh token, the channel request, the dial. A failure is
+  // returned rather than thrown, so the caller decides between another attempt and giving up.
+  async reopenOnce(taskId, signal, handlers) {
+    try {
+      const token = await this.requireFreshToken();
+      const channel = await this.askDirectChannel(taskId, token, signal);
+      if (signal.aborted) return { kind: "failed", error: new Error("Agent box redial aborted.") };
+      if (!channel) return { kind: "refused" };
+      this.adoptBox(taskId, channel);
+      const replayFrom = this.boxCursors.get(taskId);
+      if (replayFrom === void 0) this.boxCursors.set(taskId, channel.lastSequence);
+      const socket = await this.dial(channel.wsUrl, { ...handlers, signal, replayFrom });
+      return { kind: "socket", socket };
+    } catch (error) {
+      return { kind: "failed", error: error instanceof Error ? error : new Error(String(error)) };
+    }
+  }
+  dial(url, options) {
+    const { signal, replayFrom } = options;
     return new Promise((resolve, reject) => {
       const socket = new globalThis.WebSocket(url);
       let opened = false;
@@ -1559,9 +1992,17 @@ var BrowserAgentTaskEventSource = class {
         socket.close();
         reject(error);
       };
+      const watchdog = new SilenceWatchdog(() => {
+        if (intentionalClose) return;
+        intentionalClose = true;
+        removeAbortListener();
+        options.onLost(silenceError("WebSocket"));
+        socket.close(1e3, "Client closed");
+      });
       const close = () => {
         if (intentionalClose) return;
         intentionalClose = true;
+        watchdog.clear();
         removeAbortListener();
         socket.close(1e3, "Client closed");
       };
@@ -1581,24 +2022,33 @@ var BrowserAgentTaskEventSource = class {
         opened = true;
         settled = true;
         globalThis.clearTimeout(timer);
+        watchdog.touch();
+        if (replayFrom !== void 0) {
+          try {
+            socket.send(JSON.stringify({ type: "replay", fromSequence: replayFrom }));
+          } catch {
+          }
+        }
         resolve({ close });
       };
       socket.onerror = () => {
         if (!opened) rejectHandshake(new Error("Failed to connect to the Agent WebSocket."));
       };
       socket.onmessage = (message) => {
+        watchdog.touch();
         const event = parseEvent(message.data);
-        if (event) observer.onEvent(event);
+        if (event) options.onFrame(asDelta(event));
       };
       socket.onclose = (event) => {
         globalThis.clearTimeout(timer);
+        watchdog.clear();
         removeAbortListener();
         if (!opened) {
           rejectHandshake(new Error(`Agent WebSocket closed during handshake (${event.code}).`));
           return;
         }
-        if (!intentionalClose && !isNormalClose(event)) {
-          observer.onDisconnect(new Error(`Agent WebSocket disconnected (${event.code}).`));
+        if (!intentionalClose) {
+          options.onLost(new Error(`Agent WebSocket closed (${event.code}).`), event.code);
         }
       };
     });
@@ -1634,7 +2084,7 @@ var BrowserAgentTaskEventSource = class {
       disconnected = true;
       observer.onDisconnect(error);
     };
-    void this.readSse(response.body, observer, abort.signal).then(() => disconnect()).catch((error) => disconnect(error)).finally(() => signal?.removeEventListener("abort", onAbort));
+    void this.readSse(response.body, observer, abort).then(() => disconnect()).catch((error) => disconnect(error)).finally(() => signal?.removeEventListener("abort", onAbort));
     return {
       close: () => {
         if (intentionalClose) return;
@@ -1644,13 +2094,28 @@ var BrowserAgentTaskEventSource = class {
       }
     };
   }
-  async readSse(body, observer, signal) {
+  async readSse(body, observer, abort) {
     const reader = body.getReader();
     const decoder = new TextDecoder();
     let buffer = "";
+    let breakSilence;
+    const silence = new Promise((_, reject) => {
+      breakSilence = reject;
+    });
+    const watchdog = new SilenceWatchdog(() => breakSilence(silenceError("SSE stream")));
     try {
-      while (!signal.aborted) {
-        const { done, value } = await reader.read();
+      watchdog.touch();
+      while (!abort.signal.aborted) {
+        let chunk;
+        try {
+          chunk = await Promise.race([reader.read(), silence]);
+        } catch (error) {
+          abort.abort();
+          await reader.cancel().catch(() => void 0);
+          throw error;
+        }
+        watchdog.touch();
+        const { done, value } = chunk;
         if (done) break;
         buffer += decoder.decode(value, { stream: true });
         let separator = /\r?\n\r?\n/.exec(buffer);
@@ -1664,6 +2129,7 @@ var BrowserAgentTaskEventSource = class {
         }
       }
     } finally {
+      watchdog.clear();
       reader.releaseLock();
     }
   }
@@ -1672,11 +2138,35 @@ var BrowserAgentTaskEventSource = class {
 // src/modules/agent-tasks.ts
 function createBrowserAgentTasksModule(httpClient, auth, apiUrl) {
   const tasks = (0, import_sdk_core8.createAgentTasksModule)(httpClient, coreErrors);
+  const source = new BrowserAgentTaskEventSource(auth, apiUrl);
+  const observers = /* @__PURE__ */ new Map();
+  const outbox = new AgentInputOutbox(tasks, (taskId, event) => observers.get(taskId)?.onEvent(event));
+  const eventSource = {
+    async open(taskId, observer, signal, transport) {
+      observers.set(taskId, observer);
+      let connection;
+      try {
+        connection = await source.open(taskId, observer, signal, transport);
+      } catch (error) {
+        observers.delete(taskId);
+        throw error;
+      }
+      return {
+        close: () => {
+          outbox.abandon(taskId);
+          observers.delete(taskId);
+          connection.close();
+        }
+      };
+    }
+  };
   const manager = (0, import_sdk_core8.createAgentTaskSessionManager)({
-    tasks,
-    eventSource: new BrowserAgentTaskEventSource(auth, apiUrl)
+    tasks: { ...tasks, sendInput: (taskId, input) => outbox.sendInput(taskId, input) },
+    eventSource
+  });
+  return (0, import_sdk_core8.withAgentTaskSessions)(tasks, {
+    session: (options) => holdSendsWhileOffline(manager.session(options), outbox)
   });
-  return (0, import_sdk_core8.withAgentTaskSessions)(tasks, manager);
 }
 
 // src/modules/agent-credentials.ts

package/dist/index.js

@@ -1423,8 +1423,230 @@ import {
   withAgentTaskSessions
 } from "@mitralab.io/sdk-core";
 
+// src/modules/agent-outbox.ts
+var OUTBOX_DELAYS_MS = [2e3, 5e3, 1e4, 2e4, 4e4];
+var browserNetwork = {
+  isOffline: () => globalThis.navigator?.onLine === false,
+  onOnline: (listener) => {
+    const target = globalThis;
+    if (typeof target.addEventListener !== "function") return () => void 0;
+    target.addEventListener("online", listener);
+    return () => target.removeEventListener?.("online", listener);
+  }
+};
+function sendGotNoResponse(error) {
+  return error instanceof TypeError;
+}
+function reasonOf(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function neverSent(pending) {
+  return new Error(
+    `Agent prompt was never sent: the session closed while it waited for the network (${pending} pending).`
+  );
+}
+var AgentInputOutbox = class {
+  constructor(tasks, announce, network = browserNetwork) {
+    this.tasks = tasks;
+    this.announce = announce;
+    this.network = network;
+  }
+  held = /* @__PURE__ */ new Map();
+  gated = /* @__PURE__ */ new Map();
+  async sendInput(taskId, input) {
+    try {
+      await this.tasks.sendInput(taskId, input);
+    } catch (error) {
+      if (input.type !== "message" || !sendGotNoResponse(error)) throw error;
+      await this.hold(taskId, input, error);
+    }
+  }
+  /** The session is closing: a prompt still waiting is reported, never dropped in silence. */
+  abandon(taskId) {
+    const pending = this.held.get(taskId);
+    if (!pending?.length) return;
+    this.held.delete(taskId);
+    this.drop(taskId, pending);
+  }
+  /** True when the browser says there is no network at all. */
+  get offline() {
+    return this.network.isOffline();
+  }
+  /**
+   * Keeps a prompt out of the core until the browser reports the network is back, then hands it
+   * over through `deliver`. Prompts held for one session leave in the order they arrived. The
+   * promise settles when the prompt is handed over, or rejects if the session closes first.
+   */
+  holdUntilOnline(session, taskId, deliver) {
+    return new Promise((resolve, reject) => {
+      const prompt = { resolve, reject, disarm: () => void 0 };
+      this.gated.set(session, [...this.gated.get(session) ?? [], prompt]);
+      if (taskId) {
+        this.announce(taskId, {
+          type: "inputUnsent",
+          payload: { attempt: 0, reason: "The browser is offline.", waitingForOnline: true },
+          timestamp: Date.now()
+        });
+      }
+      const offOnline = this.network.onOnline(() => {
+        prompt.disarm();
+        const rest = (this.gated.get(session) ?? []).filter((candidate) => candidate !== prompt);
+        if (rest.length) this.gated.set(session, rest);
+        else this.gated.delete(session);
+        deliver();
+        resolve();
+      });
+      prompt.disarm = () => {
+        offOnline();
+        prompt.disarm = () => void 0;
+      };
+    });
+  }
+  /** The session is closing with prompts that never entered the core: same report as `abandon`. */
+  abandonGated(session, taskId) {
+    const pending = this.gated.get(session);
+    if (!pending?.length) return;
+    this.gated.delete(session);
+    this.drop(taskId, pending);
+  }
+  drop(taskId, pending) {
+    const error = neverSent(pending.length);
+    if (taskId) {
+      this.announce(taskId, {
+        type: "error",
+        payload: { code: "INPUT_UNSENT", message: error.message },
+        timestamp: Date.now()
+      });
+    }
+    for (const prompt of pending) {
+      prompt.disarm();
+      prompt.reject(error);
+    }
+  }
+  hold(taskId, input, cause) {
+    return new Promise((resolve, reject) => {
+      const prompt = { input, attempts: 1, resolve, reject, disarm: () => void 0 };
+      this.held.set(taskId, [...this.held.get(taskId) ?? [], prompt]);
+      this.schedule(taskId, prompt, cause);
+    });
+  }
+  schedule(taskId, prompt, cause) {
+    const waitingForOnline = this.network.isOffline();
+    const retryInMs = waitingForOnline ? void 0 : OUTBOX_DELAYS_MS[prompt.attempts - 1];
+    if (!waitingForOnline && retryInMs === void 0) {
+      this.release(taskId, prompt);
+      prompt.reject(new Error(
+        `Agent prompt was not sent after ${prompt.attempts} attempts: ${reasonOf(cause)}`
+      ));
+      return;
+    }
+    this.announce(taskId, {
+      type: "inputUnsent",
+      payload: {
+        attempt: prompt.attempts,
+        reason: reasonOf(cause),
+        waitingForOnline,
+        ...retryInMs === void 0 ? {} : { retryInMs }
+      },
+      timestamp: Date.now()
+    });
+    const retry = () => {
+      prompt.disarm();
+      void this.retry(taskId, prompt);
+    };
+    const timer = retryInMs === void 0 ? null : globalThis.setTimeout(retry, retryInMs);
+    const offOnline = this.network.onOnline(retry);
+    prompt.disarm = () => {
+      if (timer !== null) globalThis.clearTimeout(timer);
+      offOnline();
+      prompt.disarm = () => void 0;
+    };
+  }
+  async retry(taskId, prompt) {
+    prompt.attempts += 1;
+    try {
+      await this.tasks.sendInput(taskId, prompt.input);
+    } catch (error) {
+      if (!this.isHeld(taskId, prompt)) return;
+      if (!sendGotNoResponse(error)) {
+        this.release(taskId, prompt);
+        prompt.reject(error instanceof Error ? error : new Error(String(error)));
+        return;
+      }
+      this.schedule(taskId, prompt, error);
+      return;
+    }
+    if (!this.isHeld(taskId, prompt)) return;
+    this.release(taskId, prompt);
+    this.announce(taskId, {
+      type: "inputSent",
+      payload: { attempts: prompt.attempts },
+      timestamp: Date.now()
+    });
+    prompt.resolve();
+  }
+  isHeld(taskId, prompt) {
+    return this.held.get(taskId)?.includes(prompt) ?? false;
+  }
+  release(taskId, prompt) {
+    const rest = (this.held.get(taskId) ?? []).filter((candidate) => candidate !== prompt);
+    if (rest.length) this.held.set(taskId, rest);
+    else this.held.delete(taskId);
+  }
+};
+function holdSendsWhileOffline(session, outbox) {
+  const passThrough = (prompt) => !outbox.offline || !prompt.trim() || session.status === "closed";
+  const gated = {
+    send: (prompt, options) => {
+      if (passThrough(prompt)) {
+        session.send(prompt, options);
+        return;
+      }
+      void outbox.holdUntilOnline(session, session.taskId, () => session.send(prompt, options)).catch(() => void 0);
+    },
+    sendAndWait: (prompt, options) => {
+      if (passThrough(prompt)) return session.sendAndWait(prompt, options);
+      let turn;
+      return outbox.holdUntilOnline(session, session.taskId, () => {
+        turn = session.sendAndWait(prompt, options);
+      }).then(() => turn);
+    },
+    close: () => {
+      outbox.abandonGated(session, session.taskId);
+      session.close();
+    }
+  };
+  return new Proxy(session, {
+    get: (target, key) => key in gated ? gated[key] : Reflect.get(target, key, target)
+  });
+}
+
 // src/modules/agent-session.ts
 var CONNECT_TIMEOUT_MS = 15e3;
+var CHANNEL_BOOT_TIMEOUT_MS = 9e4;
+var CHANNEL_BOOT_RETRY_MS = 2e3;
+var SILENCE_TIMEOUT_MS = 6e4;
+var RECONNECT_DELAYS_MS = [1e3, 2e3, 4e3, 8e3, 16e3];
+var SUPERSEDED_CLOSE_CODE = 4409;
+var SilenceWatchdog = class {
+  constructor(onSilence) {
+    this.onSilence = onSilence;
+  }
+  timer = null;
+  touch() {
+    this.clear();
+    this.timer = globalThis.setTimeout(this.onSilence, SILENCE_TIMEOUT_MS);
+  }
+  clear() {
+    if (this.timer !== null) {
+      globalThis.clearTimeout(this.timer);
+      this.timer = null;
+    }
+  }
+};
+function silenceError(transport) {
+  return new Error(`Agent ${transport} went silent for ${SILENCE_TIMEOUT_MS / 1e3}s.`);
+}
 function stripBearer2(token) {
   return token.replace(/^Bearer\s+/i, "");
 }
@@ -1443,6 +1665,37 @@ function expectEvent(value) {
     ...typeof event.sequence === "number" ? { sequence: event.sequence } : {}
   };
 }
+function isSameGateway(candidate, apiUrl) {
+  try {
+    const target = new URL(candidate);
+    if (target.protocol !== "ws:" && target.protocol !== "wss:") return false;
+    return target.host === new URL(apiUrl).host;
+  } catch {
+    return false;
+  }
+}
+function boxAddress(wsUrl) {
+  const url = new URL(wsUrl);
+  return `${url.origin}${url.pathname}`;
+}
+function toDirectChannel(body, apiUrl) {
+  if (typeof body !== "object" || body === null) return null;
+  const channel = body;
+  if (typeof channel.wsUrl !== "string" || !isSameGateway(channel.wsUrl, apiUrl)) return null;
+  return {
+    wsUrl: channel.wsUrl,
+    lastSequence: typeof channel.lastSequence === "number" && channel.lastSequence > 0 ? channel.lastSequence : 0
+  };
+}
+function sleep(ms, signal) {
+  return new Promise((resolve) => {
+    const timer = globalThis.setTimeout(resolve, ms);
+    signal?.addEventListener("abort", () => {
+      globalThis.clearTimeout(timer);
+      resolve();
+    }, { once: true });
+  });
+}
 function parseEvent(raw) {
   if (typeof raw !== "string") return expectEvent(raw);
   try {
@@ -1451,8 +1704,25 @@ function parseEvent(raw) {
     return null;
   }
 }
-function isNormalClose(event) {
-  return event.code === 1e3 || event.code === 4409;
+function asDelta(event) {
+  if (event.type !== "textChunk") return event;
+  const kind = asObject(event.payload)?.kind;
+  return { ...event, type: kind === "thinking" ? "thinking" : "textDelta" };
+}
+var TURN_FRAME_TYPES = /* @__PURE__ */ new Set(["textDelta", "thinking", "toolCall", "toolResult"]);
+var TURN_END_REASONS = /* @__PURE__ */ new Set(["stop", "endTurn", "interrupted"]);
+function turnAfter(event, inTurn) {
+  if (TURN_FRAME_TYPES.has(event.type)) return true;
+  if (event.type === "error") return false;
+  if (event.type === "stepFinish") {
+    const payload = asObject(event.payload);
+    if (TURN_END_REASONS.has(payload?.reason)) return false;
+    return asObject(payload?.lifecycle)?.interruptTerminal !== true;
+  }
+  return inTurn;
+}
+function channelEvent(type, payload) {
+  return { type, payload, timestamp: Date.now() };
 }
 var BrowserAgentTaskEventSource = class {
   constructor(auth, apiUrl) {
@@ -1461,6 +1731,18 @@ var BrowserAgentTaskEventSource = class {
   }
   apiUrl;
   sseFallbackTasks = /* @__PURE__ */ new Set();
+  // Tasks whose last WebSocket was the box itself. A box socket that closes says nothing about
+  // WebSockets: the box went idle or the channel was superseded, and the answer is to ask the
+  // copilot for the channel again. Only the copilot's own socket failing sends a task to SSE.
+  directTasks = /* @__PURE__ */ new Set();
+  /**
+   * Ate onde esta sessao ja viu o log da caixa, por conversa, e de qual caixa esse log e. So o
+   * redial no meio de um turno pede repeticao a partir daqui; abrir a conversa de novo nunca
+   * pede. O cursor vale para uma caixa: outra caixa tem outro log, e um cursor da anterior
+   * repetiria turnos antigos como se fossem texto ao vivo.
+   */
+  boxCursors = /* @__PURE__ */ new Map();
+  boxAddresses = /* @__PURE__ */ new Map();
   async open(taskId, observer, signal, transport = "auto") {
     if (transport === "http") return this.openSse(taskId, observer, signal);
     if (transport === "websocket") return this.openWebSocket(taskId, observer, signal);
@@ -1471,13 +1753,13 @@ var BrowserAgentTaskEventSource = class {
       const connection = await this.openWebSocket(taskId, {
         ...observer,
         onDisconnect: (error) => {
-          this.sseFallbackTasks.add(taskId);
+          if (!this.directTasks.has(taskId)) this.sseFallbackTasks.add(taskId);
           observer.onDisconnect(error);
         }
       }, signal);
       return this.wrapAutoConnection(taskId, connection);
     } catch {
-      this.sseFallbackTasks.add(taskId);
+      if (!this.directTasks.has(taskId)) this.sseFallbackTasks.add(taskId);
       return this.wrapAutoConnection(taskId, await this.openSse(taskId, observer, signal));
     }
   }
@@ -1485,6 +1767,9 @@ var BrowserAgentTaskEventSource = class {
     return {
       close: () => {
         this.sseFallbackTasks.delete(taskId);
+        this.directTasks.delete(taskId);
+        this.boxCursors.delete(taskId);
+        this.boxAddresses.delete(taskId);
         connection.close();
       }
     };
@@ -1497,13 +1782,161 @@ var BrowserAgentTaskEventSource = class {
     }
     return token;
   }
+  /**
+   * Pergunta ao copilot onde esta conversa e servida. Nada aqui e fatal: uma recusa, uma
+   * resposta que nao entendemos ou uma rede que falhou significam apenas que a conversa segue
+   * pelo socket do copilot, que e como toda conversa era servida antes da caixa existir.
+   */
+  requestDirectChannel(taskId, token, signal) {
+    return this.askDirectChannel(taskId, token, signal).catch(() => null);
+  }
+  /** Like `requestDirectChannel`, but a request the network lost is thrown, not a refusal. */
+  async askDirectChannel(taskId, token, signal) {
+    const url = `${this.apiUrl}/copilot/api/v1/tasks/${encodeURIComponent(taskId)}/channel`;
+    const deadline = Date.now() + CHANNEL_BOOT_TIMEOUT_MS;
+    for (; ; ) {
+      if (signal?.aborted) return null;
+      const response = await globalThis.fetch(url, {
+        method: "POST",
+        headers: { Authorization: `Bearer ${stripBearer2(token)}` },
+        ...signal ? { signal } : {}
+      });
+      if (response.status === 202) {
+        if (Date.now() >= deadline) return null;
+        await sleep(CHANNEL_BOOT_RETRY_MS, signal);
+        continue;
+      }
+      if (!response.ok) return null;
+      try {
+        return toDirectChannel(await response.json(), this.apiUrl);
+      } catch {
+        return null;
+      }
+    }
+  }
   async openWebSocket(taskId, observer, signal) {
     if (typeof globalThis.WebSocket !== "function") {
       throw new TypeError("WebSocket is not available.");
     }
     if (signal?.aborted) throw signal.reason ?? new Error("Agent WebSocket connection aborted.");
     const token = await this.requireFreshToken();
+    const direct = await this.requestDirectChannel(taskId, token, signal);
+    if (direct) this.directTasks.add(taskId);
+    else this.directTasks.delete(taskId);
+    if (direct) return this.openDirect(taskId, direct, observer, signal);
     const url = `${this.apiUrl.replace(/^http/i, "ws")}/copilot/ws/tasks/${encodeURIComponent(taskId)}?token=${encodeURIComponent(stripBearer2(token))}`;
+    const socket = await this.dial(url, {
+      signal,
+      onFrame: (event) => observer.onEvent(event),
+      onLost: (error) => observer.onDisconnect(error)
+    });
+    return { close: () => socket.close() };
+  }
+  /** Forgets the cursor when the copilot points the conversation to a box other than the last dialed. */
+  adoptBox(taskId, channel) {
+    const box = boxAddress(channel.wsUrl);
+    if (this.boxAddresses.get(taskId) === box) return;
+    this.boxAddresses.set(taskId, box);
+    this.boxCursors.delete(taskId);
+  }
+  /**
+   * The box path. A drop in the middle of a turn is redialed from here, with the replay the
+   * box offers, so the core keeps one connection and one stream: reporting the drop instead
+   * would make it reconcile the turn from persisted history, which is the screen freezing and
+   * the rest of the answer landing at once. The core hears a disconnect only when the redial
+   * gives up, when the copilot no longer offers the box, or when there is no turn to resume:
+   * the sandbox pauses an idle box, and dialing it again would wake it for nobody.
+   *
+   * Opening never asks for a replay, whether the conversation is new to this session or was
+   * open before. What an idle conversation missed is history, which the app loads by REST. Beta
+   * 2026-09-14: a tab open overnight had its box replaced, and the open that followed replayed
+   * the old box's cursor against the new log, which put every old turn on screen as live text.
+   */
+  async openDirect(taskId, channel, observer, signal) {
+    this.adoptBox(taskId, channel);
+    this.boxCursors.set(taskId, channel.lastSequence);
+    const link = new AbortController();
+    const onAbort = () => link.abort(signal?.reason);
+    signal?.addEventListener("abort", onAbort, { once: true });
+    let inTurn = false;
+    let current = null;
+    const onFrame = (event) => {
+      if (typeof event.sequence === "number") {
+        const seen = this.boxCursors.get(taskId) ?? 0;
+        if (event.sequence > seen) this.boxCursors.set(taskId, event.sequence);
+      }
+      inTurn = turnAfter(event, inTurn);
+      observer.onEvent(event);
+    };
+    const onLost = (error, code) => {
+      current = null;
+      if (link.signal.aborted) return;
+      if (!inTurn || code === SUPERSEDED_CLOSE_CODE) {
+        observer.onDisconnect(error);
+        return;
+      }
+      void this.redial(taskId, error, link.signal, observer, { onFrame, onLost }).then((socket) => {
+        current = socket;
+      });
+    };
+    current = await this.dial(channel.wsUrl, { signal: link.signal, onFrame, onLost });
+    return {
+      close: () => {
+        signal?.removeEventListener("abort", onAbort);
+        link.abort();
+        current?.close();
+      }
+    };
+  }
+  async redial(taskId, cause, signal, observer, handlers) {
+    let lastError = cause;
+    for (const [index, delayMs] of RECONNECT_DELAYS_MS.entries()) {
+      const attempt = index + 1;
+      observer.onEvent(channelEvent("channelReconnecting", {
+        attempt,
+        maxAttempts: RECONNECT_DELAYS_MS.length,
+        reason: lastError.message
+      }));
+      await sleep(delayMs, signal);
+      if (signal.aborted) return null;
+      const outcome = await this.reopenOnce(taskId, signal, handlers);
+      if (signal.aborted) return null;
+      if (outcome.kind === "socket") {
+        observer.onEvent(channelEvent("channelConnected", { attempt }));
+        return outcome.socket;
+      }
+      if (outcome.kind === "refused") {
+        observer.onDisconnect(new Error(
+          `The copilot no longer offers the box channel (after: ${cause.message})`
+        ));
+        return null;
+      }
+      lastError = outcome.error;
+    }
+    observer.onDisconnect(new Error(
+      `Agent box channel could not be reopened after ${RECONNECT_DELAYS_MS.length} attempts: ${lastError.message}`
+    ));
+    return null;
+  }
+  // One attempt to get the box back: a fresh token, the channel request, the dial. A failure is
+  // returned rather than thrown, so the caller decides between another attempt and giving up.
+  async reopenOnce(taskId, signal, handlers) {
+    try {
+      const token = await this.requireFreshToken();
+      const channel = await this.askDirectChannel(taskId, token, signal);
+      if (signal.aborted) return { kind: "failed", error: new Error("Agent box redial aborted.") };
+      if (!channel) return { kind: "refused" };
+      this.adoptBox(taskId, channel);
+      const replayFrom = this.boxCursors.get(taskId);
+      if (replayFrom === void 0) this.boxCursors.set(taskId, channel.lastSequence);
+      const socket = await this.dial(channel.wsUrl, { ...handlers, signal, replayFrom });
+      return { kind: "socket", socket };
+    } catch (error) {
+      return { kind: "failed", error: error instanceof Error ? error : new Error(String(error)) };
+    }
+  }
+  dial(url, options) {
+    const { signal, replayFrom } = options;
     return new Promise((resolve, reject) => {
       const socket = new globalThis.WebSocket(url);
       let opened = false;
@@ -1522,9 +1955,17 @@ var BrowserAgentTaskEventSource = class {
         socket.close();
         reject(error);
       };
+      const watchdog = new SilenceWatchdog(() => {
+        if (intentionalClose) return;
+        intentionalClose = true;
+        removeAbortListener();
+        options.onLost(silenceError("WebSocket"));
+        socket.close(1e3, "Client closed");
+      });
       const close = () => {
         if (intentionalClose) return;
         intentionalClose = true;
+        watchdog.clear();
         removeAbortListener();
         socket.close(1e3, "Client closed");
       };
@@ -1544,24 +1985,33 @@ var BrowserAgentTaskEventSource = class {
         opened = true;
         settled = true;
         globalThis.clearTimeout(timer);
+        watchdog.touch();
+        if (replayFrom !== void 0) {
+          try {
+            socket.send(JSON.stringify({ type: "replay", fromSequence: replayFrom }));
+          } catch {
+          }
+        }
         resolve({ close });
       };
       socket.onerror = () => {
         if (!opened) rejectHandshake(new Error("Failed to connect to the Agent WebSocket."));
       };
       socket.onmessage = (message) => {
+        watchdog.touch();
         const event = parseEvent(message.data);
-        if (event) observer.onEvent(event);
+        if (event) options.onFrame(asDelta(event));
       };
       socket.onclose = (event) => {
         globalThis.clearTimeout(timer);
+        watchdog.clear();
         removeAbortListener();
         if (!opened) {
           rejectHandshake(new Error(`Agent WebSocket closed during handshake (${event.code}).`));
           return;
         }
-        if (!intentionalClose && !isNormalClose(event)) {
-          observer.onDisconnect(new Error(`Agent WebSocket disconnected (${event.code}).`));
+        if (!intentionalClose) {
+          options.onLost(new Error(`Agent WebSocket closed (${event.code}).`), event.code);
         }
       };
     });
@@ -1597,7 +2047,7 @@ var BrowserAgentTaskEventSource = class {
       disconnected = true;
       observer.onDisconnect(error);
     };
-    void this.readSse(response.body, observer, abort.signal).then(() => disconnect()).catch((error) => disconnect(error)).finally(() => signal?.removeEventListener("abort", onAbort));
+    void this.readSse(response.body, observer, abort).then(() => disconnect()).catch((error) => disconnect(error)).finally(() => signal?.removeEventListener("abort", onAbort));
     return {
       close: () => {
         if (intentionalClose) return;
@@ -1607,13 +2057,28 @@ var BrowserAgentTaskEventSource = class {
       }
     };
   }
-  async readSse(body, observer, signal) {
+  async readSse(body, observer, abort) {
     const reader = body.getReader();
     const decoder = new TextDecoder();
     let buffer = "";
+    let breakSilence;
+    const silence = new Promise((_, reject) => {
+      breakSilence = reject;
+    });
+    const watchdog = new SilenceWatchdog(() => breakSilence(silenceError("SSE stream")));
     try {
-      while (!signal.aborted) {
-        const { done, value } = await reader.read();
+      watchdog.touch();
+      while (!abort.signal.aborted) {
+        let chunk;
+        try {
+          chunk = await Promise.race([reader.read(), silence]);
+        } catch (error) {
+          abort.abort();
+          await reader.cancel().catch(() => void 0);
+          throw error;
+        }
+        watchdog.touch();
+        const { done, value } = chunk;
         if (done) break;
         buffer += decoder.decode(value, { stream: true });
         let separator = /\r?\n\r?\n/.exec(buffer);
@@ -1627,6 +2092,7 @@ var BrowserAgentTaskEventSource = class {
         }
       }
     } finally {
+      watchdog.clear();
       reader.releaseLock();
     }
   }
@@ -1635,11 +2101,35 @@ var BrowserAgentTaskEventSource = class {
 // src/modules/agent-tasks.ts
 function createBrowserAgentTasksModule(httpClient, auth, apiUrl) {
   const tasks = createAgentTasksModule(httpClient, coreErrors);
+  const source = new BrowserAgentTaskEventSource(auth, apiUrl);
+  const observers = /* @__PURE__ */ new Map();
+  const outbox = new AgentInputOutbox(tasks, (taskId, event) => observers.get(taskId)?.onEvent(event));
+  const eventSource = {
+    async open(taskId, observer, signal, transport) {
+      observers.set(taskId, observer);
+      let connection;
+      try {
+        connection = await source.open(taskId, observer, signal, transport);
+      } catch (error) {
+        observers.delete(taskId);
+        throw error;
+      }
+      return {
+        close: () => {
+          outbox.abandon(taskId);
+          observers.delete(taskId);
+          connection.close();
+        }
+      };
+    }
+  };
   const manager = createAgentTaskSessionManager({
-    tasks,
-    eventSource: new BrowserAgentTaskEventSource(auth, apiUrl)
+    tasks: { ...tasks, sendInput: (taskId, input) => outbox.sendInput(taskId, input) },
+    eventSource
+  });
+  return withAgentTaskSessions(tasks, {
+    session: (options) => holdSendsWhileOffline(manager.session(options), outbox)
   });
-  return withAgentTaskSessions(tasks, manager);
 }
 
 // src/modules/agent-credentials.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mitralab.io/platform-sdk",
-  "version": "1.1.0",
+  "version": "1.1.1",
   "description": "JavaScript/TypeScript SDK for building apps on the Mitra Platform",
   "type": "module",
   "sideEffects": false,
@@ -62,7 +62,7 @@
     "url": "https://github.com/mitralab-dev/mitra-platform-sdk/issues"
   },
   "dependencies": {
-    "@mitralab.io/sdk-core": "0.2.0",
+    "@mitralab.io/sdk-core": "0.2.1",
     "mitra-interactions-sdk": "1.0.60-beta.48"
   },
   "devDependencies": {