eve-hub 0.6.39 → 0.6.42

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # eve-hub
 
+## 0.6.42
+
+### Patch Changes
+
+- The state frame carries each bot's latest finished turn per thread (`lastTurn`), so the app marks a thread failed from that turn.
+
+## 0.6.41
+
+### Patch Changes
+
+- A model call that sends no data for 30 s ends with a timeout instead of waiting 5 minutes per attempt; the clock restarts on every chunk, and the AI SDK's two retries stay, so a brief hang recovers without a hand retry.
+
+## 0.6.40
+
+### Patch Changes
+
+- The hub records the size of each input a bot receives and each compaction, from eve's own stream, so the team-model work has a measured before.
+
 ## 0.6.39
 
 ### Patch Changes

package/model-timeout.mjs

@@ -0,0 +1,79 @@
+// A model call that gets no response fails fast. Node's fetch waits 300 s for
+// response headers and for each body chunk (undici's default headersTimeout /
+// bodyTimeout), and eve hands the AI SDK no timeout of its own, so one hung
+// gateway request stalled a turn for 5 minutes (15 with retries). Every
+// streaming gateway request now gets an idle limit instead: no headers, or no
+// chunk while a read is waiting, within MODEL_CALL_TIMEOUT_MS ends it with a
+// TimeoutError; the clock restarts on every chunk, so an answer that is still
+// streaming is never cut off. The AI SDK retries that twice (3 x 30 s plus its
+// backoff of 2 s and 4 s, about 1 min 36 s), then eve parks the turn as recoverable, so a transient hang
+// recovers without a hand retry.
+//
+// Streaming calls only: a non-streaming call (eve's compaction `generateText`)
+// legitimately waits for the whole generation, so a hung compaction still waits
+// the 300 s default. Remove this module when eve forwards `timeout`/`maxRetries`
+// to the AI SDK (vercel/eve#3984).
+export const MODEL_CALL_TIMEOUT_MS = 30_000;
+
+const INSTALLED = Symbol.for("hub.modelCallTimeout");
+const GATEWAY_HOST = "ai-gateway.vercel.sh";
+
+function isStreamingGatewayCall(input, init) {
+  let url;
+  try {
+    url = new URL(typeof input === "string" || input instanceof URL ? input : input.url);
+  } catch {
+    return false;
+  }
+  if (url.hostname !== GATEWAY_HOST) return false;
+  const headers = new Headers(init?.headers ?? (input instanceof Request ? input.headers : undefined));
+  return headers.get("ai-language-model-streaming") === "true";
+}
+
+export function withModelCallTimeout(baseFetch, ms) {
+  return async function fetchWithModelCallTimeout(input, init) {
+    if (!isStreamingGatewayCall(input, init)) return baseFetch(input, init);
+    const ctrl = new AbortController();
+    const caller = init?.signal ?? (input instanceof Request ? input.signal : undefined);
+    const signal = caller ? AbortSignal.any([caller, ctrl.signal]) : ctrl.signal;
+    let timer;
+    const arm = () => {
+      timer = setTimeout(() => ctrl.abort(new DOMException(`model call got no response for ${ms} ms`, "TimeoutError")), ms);
+    };
+    arm();
+    let res;
+    try {
+      res = await baseFetch(input, { ...init, signal });
+    } finally {
+      clearTimeout(timer);
+    }
+    if (!res.body) return res;
+    const reader = res.body.getReader();
+    const body = new ReadableStream({
+      async pull(controller) {
+        arm();
+        try {
+          const { done, value } = await reader.read();
+          if (done) controller.close();
+          else controller.enqueue(value);
+        } catch (error) {
+          controller.error(error);
+        } finally {
+          clearTimeout(timer);
+        }
+      },
+      cancel(reason) {
+        clearTimeout(timer);
+        return reader.cancel(reason);
+      },
+    });
+    return new Response(body, { status: res.status, statusText: res.statusText, headers: res.headers });
+  };
+}
+
+export function installModelCallTimeout() {
+  if (globalThis.fetch[INSTALLED]) return;
+  const wrapped = withModelCallTimeout(globalThis.fetch.bind(globalThis), MODEL_CALL_TIMEOUT_MS);
+  wrapped[INSTALLED] = true;
+  globalThis.fetch = wrapped;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eve-hub",
-  "version": "0.6.39",
+  "version": "0.6.42",
   "license": "Apache-2.0",
   "description": "Bot-side code shared by every hub agent: registry tools, the roster hook, the eve channel, the host sandbox and browser, and model helpers.",
   "type": "module",

package/roster-model.mjs

@@ -16,8 +16,10 @@ import { defineDynamic } from "eve";
 import { CONTEXT_WINDOW, selectModel } from "./bot-model.mjs";
 import { DEFAULT_SUBAGENT_CAP } from "./subagent-cap.mjs";
 import { sessionLimits } from "./session-limits.mjs";
+import { installModelCallTimeout } from "./model-timeout.mjs";
 import { findWorkspaceRoot, loadWorkspace, parseWorkspace } from "./workspace.mjs";
 const real = process.env.ROSTER_MODELS !== "mock";
+installModelCallTimeout();
 
 export function createRosterModel({ agents, subagentCap }) {
   return function rosterModel(name, { mock, copyMock } = {}) {

package/world.mjs

@@ -626,6 +626,9 @@ var names = (text, { person, names: names2 }) => {
 var record = (id, person) => s("INSERT OR IGNORE INTO notifications (message_id, person) SELECT ?, ? WHERE EXISTS (SELECT 1 FROM messages WHERE id = ?)", id, person, id);
 var notificationFor = (messageId2, kind, text, notify) => notify && kind === "agent" && names(text, notify) ? [record(messageId2, notify.person)] : [];
 
+// ../../hosted-hub/src/dispatch/bot.ts
+var MESSAGE_LINE = "\n[thread ";
+
 // ../../hosted-hub/src/store/subagents.ts
 var UP = `up(session_id, parent) AS (
   SELECT session_id, parent FROM subagent_links WHERE session_id = ?
@@ -26782,6 +26785,8 @@ var HubThread = object2({
   status: maybe(map2("ThreadStatus", string5())),
   busySince: maybe(map2("ThreadBusySince", string5())),
   turnCounts: maybe(map2("ThreadTurnCounts", int2())),
+  /** Each bot's latest finished turn here: done | failed | cancelled. */
+  lastTurn: maybe(map2("ThreadLastTurn", string5())),
   archived: maybe(Archived),
   source: maybe(ThreadSource),
   tags: maybe(ThreadTags),
@@ -27323,7 +27328,35 @@ function fold(state, chunks, now = Date.now()) {
           SELECT ?, ?, ?, ?, ?, 'streaming', ? WHERE EXISTS (SELECT 1 FROM sessions WHERE id = ? AND ended_at IS NULL)`, open3.id, session.thread, session.id, data.turnId, session.bot, at, session.id));
         log("turn.status", { turnId: open3.id, status: "streaming" });
       }
+      if (event.type === "compaction.completed")
+        stmts.push(s(
+          "INSERT OR IGNORE INTO compaction_events (session_id, chunk, position, sequence, step_index, at, thread_id, bot) VALUES (?, ?, ?, ?, ?, ?, ?, ?)",
+          session.id,
+          index,
+          eventIndex,
+          data.sequence ?? null,
+          data.stepIndex ?? null,
+          at,
+          session.thread,
+          session.bot
+        ));
       if (!open3) continue;
+      if (event.type === "message.received" && typeof data.message === "string") {
+        const cut = data.message.indexOf(MESSAGE_LINE);
+        const state2 = cut < 0 ? 0 : cut;
+        stmts.push(s(
+          "INSERT OR IGNORE INTO inputs (session_id, chunk, position, turn_id, at, thread_id, bot, state_chars, message_chars) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)",
+          session.id,
+          index,
+          eventIndex,
+          open3.id,
+          at,
+          session.thread,
+          session.bot,
+          state2,
+          data.message.length - state2
+        ));
+      }
       for (const deliveryId2 of event.meta?.deliveryIds ?? []) {
         open3.trigger ??= messageOfDelivery(deliveryId2, session.bot);
         stmts.push(s("INSERT OR IGNORE INTO turn_deliveries (delivery_id, turn_id) SELECT id, ? FROM deliveries WHERE id = ? AND session_id = ?", open3.id, deliveryId2, session.id));