@junejs/server 1.0.0-dev.36 → 1.0.0-dev.45

package/dist/worker.js

@@ -1,4 +1,5 @@
 import { durableAgentSurface, durableChannelSurface } from "./agent-durable.js";
+import { compareRoutePatterns, parseSegment } from "./route-rank.js";
 import { acceptTarget } from "./negotiate.js";
 import { createPipeline } from "./pipeline.js";
 import { RESERVED_PREFIX, contentTypeFor, safeRelativePath } from "./static-files.js";
@@ -8,34 +9,16 @@ function compilePattern(pattern) {
 	let source = "";
 	let allOptional = true;
 	for (const seg of pattern.split("/").filter(Boolean)) {
-		const oca = seg.match(/^\[\[\.\.\.(\w+)\]\]$/);
-		if (oca) {
-			names.push(oca[1]);
-			source += "(?:/(.+))?";
-			continue;
-		}
-		const ca = seg.match(/^\[\.\.\.(\w+)\]$/);
-		if (ca) {
-			names.push(ca[1]);
-			source += "/(.+)";
-			allOptional = false;
-			continue;
-		}
-		const op = seg.match(/^\[\[(\w+)\]\]$/);
-		if (op) {
-			names.push(op[1]);
-			source += "(?:/([^/]+))?";
-			continue;
-		}
-		const p = seg.match(/^\[(\w+)\]$/);
-		if (p) {
-			names.push(p[1]);
-			source += "/([^/]+)";
+		const { kind, name } = parseSegment(seg);
+		if (name) names.push(name);
+		if (kind === "optionalCatchAll") source += "(?:/(.+))?";
+		else if (kind === "optional") source += "(?:/([^/]+))?";
+		else {
+			if (kind === "catchAll") source += "/(.+)";
+			else if (kind === "param") source += "/([^/]+)";
+			else source += "/" + seg.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 			allOptional = false;
-			continue;
 		}
-		source += "/" + seg.replace(/[.*+?^${}()|\\]/g, "\\$&");
-		allOptional = false;
 	}
 	if (source === "") return {
 		regex: /^\/$/,
@@ -47,20 +30,42 @@ function compilePattern(pattern) {
 	};
 }
 function createWorker(manifest, opts = {}) {
-	const dynamic = (manifest.dynamicRoutes ?? []).map((d) => ({
-		...compilePattern(d.pattern),
-		def: d.def,
-		pattern: d.pattern
-	}));
-	const resources = (manifest.resourceRoutes ?? []).map((r) => ({
-		...compilePattern(r.pattern),
-		handler: r.handler,
-		pattern: r.pattern
-	}));
+	const generated = new Set(manifest.generatedRoutes ?? []);
+	const row = (pattern) => ({
+		...compilePattern(pattern),
+		pattern,
+		generated: generated.has(pattern)
+	});
+	const table = [
+		...Object.entries(manifest.routes).map(([pattern, def]) => ({
+			...row(pattern),
+			def
+		})),
+		...(manifest.dynamicRoutes ?? []).map((d) => ({
+			...row(d.pattern),
+			def: d.def
+		})),
+		...(manifest.resourceRoutes ?? []).map((r) => ({
+			...row(r.pattern),
+			handler: r.handler
+		}))
+	];
+	table.sort((a, b) => Number(a.generated) - Number(b.generated) || compareRoutePatterns(a.pattern, b.pattern) || Number(!!a.handler) - Number(!!b.handler));
 	const routeList = [...Object.keys(manifest.routes), ...(manifest.dynamicRoutes ?? []).map((d) => d.pattern)].sort();
 	const chainFor = (key) => manifest.layoutChains?.[key] ?? [];
 	const loadingFor = (key) => manifest.loadings?.[key];
 	const boundaryFor = (key) => manifest.layoutBoundaries?.[key] ?? null;
+	const resolvedPage = (def, key, params) => {
+		const b = boundaryFor(key);
+		return {
+			def,
+			params,
+			chain: chainFor(key),
+			boundaryIndex: b?.index ?? null,
+			boundaryKey: b?.key ?? null,
+			loading: loadingFor(key)
+		};
+	};
 	let currentEnv;
 	const requestLocals = /* @__PURE__ */ new WeakMap();
 	const provider = manifest.resources;
@@ -102,47 +107,18 @@ function createWorker(manifest, opts = {}) {
 		services: servicesProvider ? () => (servicesCache ??= { v: servicesProvider(currentEnv) }).v : void 0,
 		resolve: async (pathname) => {
 			const staticDef = manifest.routes[pathname];
-			if (staticDef) {
-				const b = boundaryFor(pathname);
-				return {
-					def: staticDef,
-					params: {},
-					chain: chainFor(pathname),
-					boundaryIndex: b?.index ?? null,
-					boundaryKey: b?.key ?? null,
-					loading: loadingFor(pathname)
-				};
-			}
-			for (const d of dynamic) {
-				const m = pathname.match(d.regex);
-				if (m) {
-					const params = Object.fromEntries(d.names.flatMap((n, i) => {
-						const v = m[i + 1];
-						return v === void 0 ? [] : [[n, decodeURIComponent(v)]];
-					}));
-					const b = boundaryFor(d.pattern);
-					return {
-						def: d.def,
-						params,
-						chain: chainFor(d.pattern),
-						boundaryIndex: b?.index ?? null,
-						boundaryKey: b?.key ?? null,
-						loading: loadingFor(d.pattern)
-					};
-				}
-			}
-			for (const r of resources) {
+			if (staticDef && !generated.has(pathname)) return resolvedPage(staticDef, pathname, {});
+			for (const r of table) {
 				const m = pathname.match(r.regex);
-				if (m) {
-					const params = Object.fromEntries(r.names.flatMap((n, i) => {
-						const v = m[i + 1];
-						return v === void 0 ? [] : [[n, decodeURIComponent(v)]];
-					}));
-					return {
-						handler: r.handler,
-						params
-					};
-				}
+				if (!m) continue;
+				const params = Object.fromEntries(r.names.flatMap((n, i) => {
+					const v = m[i + 1];
+					return v === void 0 ? [] : [[n, decodeURIComponent(v)]];
+				}));
+				return r.handler ? {
+					handler: r.handler,
+					params
+				} : resolvedPage(r.def, r.pattern, params);
 			}
 			return null;
 		}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@junejs/server",
-  "version": "1.0.0-dev.36",
+  "version": "1.0.0-dev.45",
   "description": "June host adapters + dev server. Host-coupled; depends on the pure @junejs/core contract layer.",
   "type": "module",
   "license": "MIT",
@@ -136,11 +136,11 @@
     "@momiji-rs/sparkdown": "^0.0.4",
     "@resvg/resvg-wasm": "^2.6.2",
     "lightningcss": "^1.27.0",
-    "oxc-parser": "^0.151.0",
+    "oxc-parser": "^0.152.0",
     "rolldown": "^1.1.0"
   },
   "peerDependencies": {
-    "@junejs/core": ">=0.2.0-dev.57",
+    "@junejs/core": ">=0.2.0-dev.65",
     "react": "^19.2.0",
     "react-dom": "^19.2.0",
     "react-server-dom-webpack": "19.3.0",

package/src/agent-durable.ts

@@ -22,6 +22,8 @@ import {
   withSystem,
   type Answerers,
   type AuthorizeAnswer,
+  type InputAnnouncement,
+  type NoteKind,
   type ChannelPolicy,
   type EventSink,
   type TurnEvent,
@@ -76,6 +78,10 @@ export interface SqlStorage {
 export interface DurableStorage {
   sql: SqlStorage;
   transactionSync<T>(fn: () => T): T;
+  // Schedules the object's alarm() — the watchdog and retry for input-announcement delivery
+  // (#260). Optional so a storage without alarms (a test double) still works; delivery then
+  // waits for the next announcement, settled turn or rebuild.
+  setAlarm?(scheduledTime: number): unknown;
 }
 export interface DurableObjectState {
   storage: DurableStorage;
@@ -151,7 +157,7 @@ export class DoSessionStore implements SessionStore {
   // tables + the generation counter are created lazily, so existing objects stay
   // untouched until their first reset. seq keeps counting across generations (DELETE
   // doesn't reset AUTOINCREMENT), so an archived (generation, seq) stays unique.
-  reset(): number {
+  reset(inTx?: () => void): number {
     return this.storage.transactionSync(() => {
       const sql = this.sql;
       sql.exec(`CREATE TABLE IF NOT EXISTS agent_messages_archive (generation INTEGER, seq INTEGER, body TEXT)`);
@@ -164,6 +170,7 @@ export class DoSessionStore implements SessionStore {
       sql.exec("DELETE FROM agent_steps");
       this.setStatus("new");
       sql.exec("INSERT INTO agent_meta (k, v) VALUES ('generation', ?) ON CONFLICT(k) DO UPDATE SET v = ?", String(generation + 1), String(generation + 1));
+      inTx?.(); // writes into the fresh generation, committed with the archive (#260)
       return generation;
     });
   }
@@ -245,6 +252,9 @@ export type DoAgentDef = {
   // Decides a { policy } answerer of a parked requestInput at /resume (#261) — the same hook
   // an AgentDefinition carries natively; assembleDurable passes agent.ts's through.
   authorizeAnswer?: AuthorizeAnswer;
+  // Receives this session's input announcements (#260) — run inside the request scope, so it
+  // can write the app's cross-session index with the ambient db.
+  onInputAnnouncement?: (a: InputAnnouncement) => void | Promise<void>;
 };
 
 // The agent runtime INSIDE a Durable Object. A plain class (constructor takes the
@@ -288,6 +298,10 @@ export class AgentDurableObject {
   private readonly doEnv: unknown;
   private readonly services: unknown;
   private readonly authorizeAnswer?: AuthorizeAnswer;
+  private readonly onInputAnnouncement?: (a: InputAnnouncement) => void | Promise<void>;
+  private readonly storage: DurableStorage;
+  // Consecutive failed announcement deliveries (#260) — sets the alarm retry's backoff.
+  private announceFailures = 0;
   private resolveResources(): Promise<Resources> {
     return (this.resourcesOpened ??= Promise.resolve(
       typeof this.resourcesInput === "function" ? this.resourcesInput(this.doEnv) : (this.resourcesInput ?? {}),
@@ -330,6 +344,8 @@ export class AgentDurableObject {
     this.doEnv = def.env;
     this.services = def.services;
     this.authorizeAnswer = def.authorizeAnswer;
+    this.onInputAnnouncement = def.onInputAnnouncement;
+    this.storage = state.storage;
     const name = def.name ?? "agent";
     // Failure observability (#76): a turn that dies after the fast-ACK has no other
     // observable surface on the edge — the webhook already 200'd and runBackground
@@ -339,6 +355,13 @@ export class AgentDurableObject {
     // over reporting; if IT throws, fall back to the default so nothing goes silent.
     // (InProcEventSink already guards emit against a throwing subscriber.)
     const sink = new InProcEventSink();
+    // Announcement watchdog (#260): a park is committed inside a turn, after turn.started, so
+    // arming here comes before its announcement can commit — whichever path started the turn,
+    // a held turn drained later included. Resume, reset and a held inbound turn arm at their
+    // call sites (armWatchdog).
+    sink.subscribe((e) => {
+      if (e.type === "turn.started") this.armWatchdog();
+    });
     sink.subscribe((e) => {
       if (e.type !== "turn.failed") return;
       // The stack already opens with the message; log it INSTEAD of the message line
@@ -436,8 +459,91 @@ export class AgentDurableObject {
     if (key !== undefined && key !== "self" && stored === undefined) this.store.setSessionKey(key);
     this.sessionKey = resolved;
     this.session = new AgentSession(this.name, resolved, this.store, this.sink, this.model, this.tools, crossDoUnsupported, this.channelInstructions);
+    // A held turn (#263) that asked for delivery is rendered through its source channel when
+    // it finally runs — possibly in a later life of this object, which is why the ask rides
+    // in the turn's hostContext and this hook is installed on every rebuild.
+    this.session.onDequeue = (heldTurnId, held) => {
+      if ((held.hostContext as { deliver?: boolean } | undefined)?.deliver && held.event) this.deliverHeld(this.session!, heldTurnId, held.event);
+    };
+    // Input announcements (#260): delivered in the request scope (the hook writes the app's
+    // index), and flushed on every rebuild — an earlier life may have committed a park and
+    // died before delivering it.
+    const announce = this.onInputAnnouncement;
+    if (announce) {
+      // ensureScope() here, not only in the request handlers: a session can first be rebuilt by
+      // a path that never wires async scope (/reset, /transcript, the direct API), and without it
+      // runInScope is a pass-through and the hook would see no ambient db.
+      this.session.onAnnounce = async (a) => {
+        await ensureScope();
+        const resources = await this.ready();
+        try {
+          await runInScope({ resources, services: this.services }, () => announce(a));
+        } catch (err) {
+          // The engine keeps the announcement and logs; retry it on the alarm, 5 s doubling
+          // to 5 min — a quiet session would otherwise hold it until its next activity.
+          this.scheduleAlarm(Math.min(5_000 * 2 ** this.announceFailures, 300_000));
+          this.announceFailures++;
+          throw err;
+        }
+        this.announceFailures = 0;
+      };
+      void this.session.flushAnnouncements();
+    }
     return this.session;
   }
+
+  // The Durable Object alarm (#260): delivers input announcements left undelivered — a hook
+  // that failed (its retry), or an object that died between committing one and delivering
+  // it (the watchdog). The shell forwards it — `alarm() { return this.agent.alarm(); }`;
+  // june build's does. Resolves the session like any key-less path (the persisted key),
+  // which rebuilds it after an eviction and flushes. Never rejects: a failed delivery
+  // reschedules itself through onAnnounce.
+  async alarm(): Promise<void> {
+    if (!this.onInputAnnouncement) return;
+    await this.resolveSession().flushAnnouncements();
+  }
+  // A watchdog alarm a minute out, armed BEFORE anything can commit an announcement (a
+  // turn starting, a resume, a reset, a held inbound turn): arming after the commit would
+  // leave exactly the window it exists for. A delivery that succeeds leaves it to find
+  // nothing.
+  private armWatchdog(): void {
+    if (this.onInputAnnouncement) this.scheduleAlarm(60_000);
+  }
+  // One alarm per object: the latest schedule wins.
+  private scheduleAlarm(inMs: number): void {
+    const failed = (err: unknown) => console.error(`[june] agent "${this.name}": could not schedule the announcement alarm — delivery waits for the next announcement, turn or rebuild:`, err);
+    try {
+      Promise.resolve(this.storage.setAlarm?.(Date.now() + inMs)).catch(failed);
+    } catch (err) {
+      failed(err);
+    }
+  }
+
+  // Render a held turn's reply through its source channel (#263), like /turn?deliver=1 does
+  // for a turn started now. Called from onDequeue, synchronously as the turn starts: the
+  // event subscription is taken HERE, before any event can emit, and buffers until the
+  // (async) resources are ready. Nothing may escape — there is no caller to report to; the
+  // log is the only surfacing path, as for any delivered render.
+  private deliverHeld(session: AgentSession, turnId: string, event: InboundEvent): void {
+    const logRenderFailure = (err: unknown) =>
+      console.error(`[june] agent "${this.name}": delivered render for held turn ${turnId} failed:`, err);
+    try {
+      const channel = this.channels.find((c) => c.name === event.source);
+      if (!channel?.deliver) {
+        logRenderFailure(new Error(`no deliver()-capable channel named "${event.source}" is wired into this DO — the held turn runs, but its reply is not rendered`));
+        return;
+      }
+      const it = observeTurnEvents(session, turnId)[Symbol.asyncIterator]();
+      const events: AsyncIterable<TurnEvent> = { [Symbol.asyncIterator]: () => it };
+      const target = { channelId: event.channelId, threadId: event.threadId, recipientUserId: event.user?.id, recipientTeamId: event.teamId };
+      this.ready()
+        .then((resources) => runInScope({ resources, services: this.services }, () => channel.deliver!(target, events, { session: this.sessionKey })))
+        .catch(logRenderFailure)
+        .finally(() => { void it.return?.(); });
+    } catch (err) {
+      logRenderFailure(err);
+    }
+  }
   // Run the whole turn inside a request scope seeded from this DO's env, so ambient
   // `db`/`kv`/`blob` and `currentServices()` resolve inside a tool exactly as in a
   // route loader. `locals` is intentionally NOT set here: a fresh scope object per
@@ -461,10 +567,18 @@ export class AgentDurableObject {
     const session = this.resolveSession(input.session);
     return runInScope({ resources, services: this.services }, () => session.start(input));
   }
+  // An attributed note (#262) for custom shells — the direct sibling of the /note route. No
+  // scope needed: a note touches only the store.
+  note(input: { by: string; kind: NoteKind; text: string; session?: string }): Promise<{ noteId: string }> {
+    const { session, ...note } = input;
+    return this.resolveSession(session).note(note);
+  }
   // Session reset (#129) for custom shells — the direct sibling of the /reset route. No
   // scope needed: reset touches only the store (no tools run).
   reset(opts?: { session?: string }): Promise<{ previousSession: string; generation: number }> {
-    return this.resolveSession(opts?.session).reset();
+    const session = this.resolveSession(opts?.session);
+    this.armWatchdog(); // a reset can retire a park (#260)
+    return session.reset();
   }
   // Read-only: folds the durable log. When an identity exists (live, or persisted from a
   // prior life) the session resolves and caches like any other path. Only a read on a
@@ -484,7 +598,7 @@ export class AgentDurableObject {
     // hand-rolled fetch → the pre-#75 "self" fallback keeps old callers working.
     const key = req.headers.get(SESSION_HEADER) ?? undefined;
     if (req.method === "POST" && url.pathname.endsWith("/turn")) {
-      const { userText, turnId, event, trigger } = (await req.json()) as { userText: string; turnId?: string; event?: InboundEvent; trigger?: ProactiveTrigger };
+      const { userText, turnId, event, trigger, ifSuspended } = (await req.json()) as { userText: string; turnId?: string; event?: InboundEvent; trigger?: ProactiveTrigger; ifSuspended?: "reject" | "queue" };
       await ensureScope();
       // CANCEL-AND-REPLACE (#129): supersede every unfinished turn on this session before
       // queuing this one (debounce). A mode flag like deliver/detach, so it rides the query
@@ -498,6 +612,15 @@ export class AgentDurableObject {
       // surface: on a pre-start rejection the caller may fall back to consumer-side rendering
       // without double-running the turn.
       const wantsDeliver = url.searchParams.get("deliver") === "1";
+      const detached = url.searchParams.get("detach") === "1";
+      // HOLD (#263): only a caller with no live consumer may ask to be held — a streaming
+      // caller wants the reply now, and a held turn's reply comes after the park resolves.
+      if (ifSuspended === "queue" && !wantsDeliver && !detached) {
+        return Response.json({ error: `ifSuspended "queue" needs deliver=1 or detach=1: a held turn runs later, when no one is streaming it` }, { status: 400 });
+      }
+      if (ifSuspended === "queue" && replace) {
+        return Response.json({ error: `ifSuspended "queue" and replace=1 cannot be combined — replacing would drop held turns that were accepted` }, { status: 400 });
+      }
       let deliverChannel: Channel | undefined;
       if (wantsDeliver) {
         if (!event?.channelId) {
@@ -517,15 +640,21 @@ export class AgentDurableObject {
       // BEFORE this block — the section from start() to the subscription stays synchronous.
       const resources = await this.ready();
       let session: AgentSession;
-      let started: { turnId: string };
+      let started: { turnId: string; queued?: true };
       try {
         session = this.resolveSession(key);
-        started = runInScope({ resources, services: this.services }, () => session.start({ userText, turnId, event, trigger, replace }));
+        // `hostContext` tells onDequeue how to finish a held turn (#263): a delivered one is
+        // rendered through its source channel when it runs, exactly as it would be now.
+        // start() itself runs turns a restart left held ahead of this one.
+        this.armWatchdog(); // a held turn commits a "held" announcement without starting (#260)
+        started = runInScope({ resources, services: this.services }, () =>
+          session.start({ userText, turnId, event, trigger, replace, ifSuspended, hostContext: wantsDeliver ? { deliver: true } : undefined }));
       } catch (err) {
         // e.g. the session is suspended awaiting input, or the key mis-matches this
         // object's identity — a client-resolvable conflict, not a crash
         return Response.json({ error: err instanceof Error ? err.message : String(err) }, { status: 409 });
       }
+      if (started.queued) return Response.json({ turnId: started.turnId, queued: true }, { status: 202 });
       if (wantsDeliver) {
         // Subscribe synchronously (same guarantee sseTurnStream relies on: start() scheduled
         // the turn, no event can have emitted yet), then render under THIS DO's lifetime —
@@ -565,7 +694,7 @@ export class AgentDurableObject {
       // this DO's lifetime (alive while work is pending), so its duration is no longer
       // bounded by however long the CALLER can hold a connection (the edge waitUntil
       // ceiling). Nobody consumes the result; failures surface via the #76 log/hook.
-      if (url.searchParams.get("detach") === "1") return Response.json({ turnId: started.turnId }, { status: 202 });
+      if (detached) return Response.json({ turnId: started.turnId }, { status: 202 });
       return new Response(sseTurnStream(session, started.turnId), { headers: SSE_HEADERS });
     }
     // Provide the input a suspended turn is waiting on and stream its continuation as SSE.
@@ -619,6 +748,7 @@ export class AgentDurableObject {
         console.error(`[june] agent "${this.name}": authorizeAnswer failed for input "${inputId}" of turn ${turnId}:`, err);
         return Response.json({ error: `authorizeAnswer failed: ${err instanceof Error ? err.message : String(err)} — the answer was NOT applied` }, { status: 500 });
       }
+      this.armWatchdog(); // the answer commits a "resolved" announcement (#260)
       try {
         runInScope({ resources, services: this.services }, () => session.resume(turnId, inputId, input, { by, granted }));
       } catch (err) {
@@ -662,6 +792,7 @@ export class AgentDurableObject {
       } catch (err) {
         return Response.json({ error: err instanceof Error ? err.message : String(err) }, { status: 409 });
       }
+      this.armWatchdog(); // a reset can retire a park (#260)
       try {
         return Response.json(await session.reset());
       } catch (err) {
@@ -669,6 +800,28 @@ export class AgentDurableObject {
         return Response.json({ error: err instanceof Error ? err.message : String(err) }, { status: 409 });
       }
     }
+    // An attributed note (#262): body { by, kind, text } → { noteId }. A malformed body is a
+    // 400; a session-key conflict is a 409, like every other route.
+    if (req.method === "POST" && url.pathname.endsWith("/note")) {
+      let input: { by?: unknown; kind?: unknown; text?: unknown };
+      try {
+        input = (await req.json()) as typeof input;
+      } catch {
+        return Response.json({ error: "note: the body must be JSON { by, kind, text }" }, { status: 400 });
+      }
+      let session: AgentSession;
+      try {
+        session = this.resolveSession(key);
+      } catch (err) {
+        return Response.json({ error: err instanceof Error ? err.message : String(err) }, { status: 409 });
+      }
+      try {
+        return Response.json(await session.note(input as { by: string; kind: string; text: string }));
+      } catch (err) {
+        if (err instanceof TypeError) return Response.json({ error: err.message }, { status: 400 });
+        throw err;
+      }
+    }
     if (url.pathname.endsWith("/transcript")) {
       // A keyed read still conflict-checks (and may commit the key — it is authentic,
       // idFromName routed it here); a key-less read stays non-committal via transcript().
@@ -681,7 +834,7 @@ export class AgentDurableObject {
       }
       return Response.json({ transcript: this.transcript() });
     }
-    return new Response("agent DO — POST /turn, POST /resume, POST /reset, or GET /transcript", { status: 404 });
+    return new Response("agent DO — POST /turn, POST /resume, POST /reset, POST /note, or GET /transcript", { status: 404 });
   }
 }
 
@@ -964,7 +1117,7 @@ export function durableChannelSurface(
         const detail = (await res.text()).slice(0, 200);
         throw new Error(`runDetached: turn was not accepted (status ${res.status}): ${detail}`);
       }
-      return (await res.json()) as { turnId: string };
+      return (await res.json()) as { turnId: string; queued?: true };
     },
     // DELIVERED: runDetached's reply-bearing sibling — the DO runs the turn AND renders its
     // reply through the source channel's deliver() under its OWN lifetime, so a reply-bearing
@@ -988,7 +1141,7 @@ export function durableChannelSurface(
         const detail = (await res.text()).slice(0, 200);
         throw new Error(`runDelivered: delivered turn was not accepted (status ${res.status}): ${detail}`);
       }
-      return (await res.json()) as { turnId: string };
+      return (await res.json()) as { turnId: string; queued?: true };
     },
     // The LIVE path: hand the channel the TurnEvent stream so it can render as the turn runs.
     runStream: async function* (message, o) {
@@ -1086,8 +1239,8 @@ function serializeResume(o: { turnId: string; inputId: string; input: unknown; b
 
 // `trigger` is ProactiveTrigger — plain strings by construction — so only event.raw can make
 // the stringify throw; the fallback that strips it stays sufficient.
-function serializeTurn(userText: string, o?: { turnId?: string; event?: InboundEvent; trigger?: ProactiveTrigger }): string {
-  const payload = { userText, turnId: o?.turnId, event: o?.event, trigger: o?.trigger };
+function serializeTurn(userText: string, o?: { turnId?: string; event?: InboundEvent; trigger?: ProactiveTrigger; ifSuspended?: "reject" | "queue" }): string {
+  const payload = { userText, turnId: o?.turnId, event: o?.event, trigger: o?.trigger, ifSuspended: o?.ifSuspended };
   try {
     return JSON.stringify(payload);
   } catch {