@frockbot/plugin-shell 0.3.16 → 0.3.18

package/frockbot.json

@@ -55,7 +55,7 @@
         "kind": "tool",
         "connectionTypes": [],
         "admission": {
-          "turnTypes": ["chat"]
+          "turnTypes": ["chat", "agent"]
         }
       },
       {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@frockbot/plugin-shell",
-  "version": "0.3.16",
+  "version": "0.3.18",
   "private": false,
   "type": "module",
   "exports": {
@@ -26,6 +26,7 @@
     "./debug-protocol": "./src/debug-protocol.ts",
     "./client/FrockBotApp.vue": "./src/client/FrockBotApp.vue",
     "./client/notify": "./src/client/notify.ts",
+    "./client/voice-microphone": "./src/client/voice-microphone.ts",
     "./client/styles.css": "./src/client/styles.css",
     "./client/voice-worklet": "./src/client/voice-worklet.ts",
     "./focus": "./src/focus.ts",
@@ -51,42 +52,42 @@
   },
   "dependencies": {
     "@cordisjs/plugin-webui": "0.8.2",
-    "@frockbot/agent-runtime": "0.3.16",
-    "@frockbot/application-foundation": "0.3.16",
-    "@frockbot/catalog-core": "0.3.16",
-    "@frockbot/client-core": "0.3.16",
-    "@frockbot/client-ui": "0.3.16",
-    "@frockbot/computer-core": "0.3.16",
-    "@frockbot/computer-host-protocol": "0.3.16",
-    "@frockbot/configuration-core": "0.3.16",
-    "@frockbot/connection-core": "0.3.16",
-    "@frockbot/kernel-agent-loop": "0.3.16",
-    "@frockbot/kernel-composition": "0.3.16",
-    "@frockbot/kernel-contracts": "0.3.16",
-    "@frockbot/kernel-do": "0.3.16",
-    "@frockbot/machine-protocol": "0.3.16",
-    "@frockbot/plugin-applets": "0.3.16",
-    "@frockbot/plugin-authoring": "0.3.16",
-    "@frockbot/plugin-bot-template": "0.3.16",
-    "@frockbot/plugin-computer": "0.3.16",
-    "@frockbot/plugin-flock": "0.3.16",
-    "@frockbot/plugin-image": "0.3.16",
-    "@frockbot/plugin-machine-messages": "0.3.16",
-    "@frockbot/plugin-mcp": "0.3.16",
-    "@frockbot/plugin-memory": "0.3.16",
-    "@frockbot/plugin-package-catalog": "0.3.16",
-    "@frockbot/plugin-routines": "0.3.16",
-    "@frockbot/plugin-skills": "0.3.16",
-    "@frockbot/plugin-subagents": "0.3.16",
-    "@frockbot/plugin-user-machine": "0.3.16",
-    "@frockbot/protocol": "0.3.16",
+    "@frockbot/agent-runtime": "0.3.18",
+    "@frockbot/application-foundation": "0.3.18",
+    "@frockbot/catalog-core": "0.3.18",
+    "@frockbot/client-core": "0.3.18",
+    "@frockbot/client-ui": "0.3.18",
+    "@frockbot/computer-core": "0.3.18",
+    "@frockbot/computer-host-protocol": "0.3.18",
+    "@frockbot/configuration-core": "0.3.18",
+    "@frockbot/connection-core": "0.3.18",
+    "@frockbot/kernel-agent-loop": "0.3.18",
+    "@frockbot/kernel-composition": "0.3.18",
+    "@frockbot/kernel-contracts": "0.3.18",
+    "@frockbot/kernel-do": "0.3.18",
+    "@frockbot/machine-protocol": "0.3.18",
+    "@frockbot/plugin-applets": "0.3.18",
+    "@frockbot/plugin-authoring": "0.3.18",
+    "@frockbot/plugin-bot-template": "0.3.18",
+    "@frockbot/plugin-computer": "0.3.18",
+    "@frockbot/plugin-flock": "0.3.18",
+    "@frockbot/plugin-image": "0.3.18",
+    "@frockbot/plugin-machine-messages": "0.3.18",
+    "@frockbot/plugin-mcp": "0.3.18",
+    "@frockbot/plugin-memory": "0.3.18",
+    "@frockbot/plugin-package-catalog": "0.3.18",
+    "@frockbot/plugin-routines": "0.3.18",
+    "@frockbot/plugin-skills": "0.3.18",
+    "@frockbot/plugin-subagents": "0.3.18",
+    "@frockbot/plugin-user-machine": "0.3.18",
+    "@frockbot/protocol": "0.3.18",
     "cordis": "4.0.0-rc.8",
     "vue": "3.5.41"
   },
   "devDependencies": {
     "@cloudflare/workers-types": "latest",
-    "@frockbot/plugin-prompt": "0.3.16",
-    "@frockbot/plugin-tools": "0.3.16",
+    "@frockbot/plugin-prompt": "0.3.18",
+    "@frockbot/plugin-tools": "0.3.18",
     "@types/bun": "1.3.6",
     "@types/node": "26.2.0",
     "@vitejs/plugin-vue": "6.0.8",

package/src/agent.test.ts

@@ -74,7 +74,7 @@ async function invoke(
 }
 
 describe("the Shell's tool admission", () => {
-  test("offers the send tool and its alias on chat turns only", async () => {
+  test("offers the send tool on chat and agent Turns", async () => {
     const mounted = await mount();
     try {
       const chat = mounted.root.tools
@@ -86,10 +86,16 @@ describe("the Shell's tool admission", () => {
       const subagent = mounted.root.tools
         .schemas({ turnType: "subagent" })
         .map((tool) => tool.name);
+      const agent = mounted.root.tools
+        .schemas({ turnType: "agent" })
+        .map((tool) => tool.name);
 
       expect(chat).toContain(SEND_TO_USER_TOOL_V1);
       expect(chat).toContain(SEND_MESSAGE_ALIAS_V1);
       expect(chat).not.toContain(WAKE_PARENT_TOOL_V1);
+      expect(agent).toContain(SEND_TO_USER_TOOL_V1);
+      expect(agent).toContain(SEND_MESSAGE_ALIAS_V1);
+      expect(agent).not.toContain(WAKE_PARENT_TOOL_V1);
       expect(automation).toEqual([
         WAKE_PARENT_TOOL_V1,
         "get_dynamic_tools",
@@ -179,7 +185,10 @@ describe("the Shell's tool admission", () => {
   });
 
   test("bounds each tool by the turn types its manifest Capability declares", () => {
-    expect(shellAdmissionCeilingV1(USER_VOICE_CAPABILITY_V1)).toEqual(["chat"]);
+    expect(shellAdmissionCeilingV1(USER_VOICE_CAPABILITY_V1)).toEqual([
+      "chat",
+      "agent",
+    ]);
     expect(shellAdmissionCeilingV1(PARENT_HANDOFF_CAPABILITY_V1)).toEqual([
       "automation",
       "subagent",
@@ -492,6 +501,80 @@ describe("the acknowledgement reaches the user", () => {
     }
   });
 
+  test("a step that is about to call send_to_user is not promoted", async () => {
+    const mounted = await mount();
+    try {
+      // Bob on production, 2026-09-04: the model wrote the acknowledgement as
+      // plain text and passed the same line to `send_to_user` in one step, and
+      // the person saw two identical bubbles.
+      await mounted.root.serial(
+        "agent/assistant-text",
+        { session: mounted.session } as never,
+        "On it — building your to-do applet now.",
+        {
+          turn: 3,
+          step: 1,
+          requestId: "request-1",
+          toolNames: [SEND_TO_USER_TOOL_V1, "applet_create"],
+        },
+      );
+      await mounted.root.serial(
+        "agent/assistant-text",
+        { session: mounted.session } as never,
+        "Sending it another way.",
+        {
+          turn: 3,
+          step: 2,
+          requestId: "request-2",
+          toolNames: [SEND_MESSAGE_ALIAS_V1],
+        },
+      );
+
+      const sends = mounted.session.events.filter(
+        (event) => event.type === "send/to-user",
+      );
+      expect(sends).toHaveLength(0);
+    } finally {
+      await mounted.dispose();
+    }
+  });
+
+  test("the last steps of a reply tell the model to send a status", async () => {
+    const mounted = await mount();
+    try {
+      const assemble = (current: number) =>
+        mounted.root.systemPrompt.assemble({
+          sessionId: "session-1",
+          provider: "provider-1",
+          model: "model-1",
+          turnType: "chat",
+          step: { current, max: 64 },
+        });
+      const early = await assemble(10);
+      expect(early.text).not.toContain("<step_budget>");
+      const warning = await assemble(61);
+      expect(warning.text).toContain("<step_budget>");
+      expect(warning.text).toContain("3 steps left after this one");
+      expect(warning.text).toContain(SEND_TO_USER_TOOL_V1);
+      const last = await assemble(64);
+      expect(last.text).toContain("This is the last step of this reply");
+      // The budget section sits after the conversation contract, where the
+      // model reads it last.
+      expect(last.text.indexOf("<step_budget>")).toBeGreaterThan(
+        last.text.indexOf("send_to_user"),
+      );
+      const outside = await mounted.root.systemPrompt.assemble({
+        sessionId: "session-1",
+        provider: "provider-1",
+        model: "model-1",
+        turnType: "chat",
+      });
+      expect(outside.text).not.toContain("<step_budget>");
+    } finally {
+      await mounted.dispose();
+    }
+  });
+
   test("a step that already spoke is left alone, and a replay adds nothing", async () => {
     const mounted = await mount();
     try {

package/src/agent.ts

@@ -46,7 +46,12 @@ import {
   turnScopedMessagesV1,
   turnTypesByTurnV1,
 } from "./history.js";
-import { runCompactionV1 } from "./compaction.js";
+import {
+  COMPACTION_RESPONSE_SCHEMA_V1,
+  type CompactionSummaryPayloadV1,
+  renderCompactionSummaryV1,
+  runCompactionV1,
+} from "./compaction.js";
 import { compactionWorkV1 } from "./compaction-scheduler.js";
 import type { Plugin } from "cordis";
 import manifest from "../frockbot.json" with { type: "json" };
@@ -155,11 +160,25 @@ export function promotedSendOccurrenceIdV1(requestId: string): string {
 export async function promoteAssistantTextToSendV1(
   session: Session,
   text: string,
-  position: { turn: number; step: number; requestId: string },
+  position: {
+    turn: number;
+    step: number;
+    requestId: string;
+    toolNames?: readonly string[];
+  },
 ): Promise<void> {
   const trimmed = text.trim();
   if (trimmed.length === 0 || trimmed.length > PROMOTED_ASSISTANT_TEXT_LIMIT_V1)
     return;
+  // A step that narrates "On it — building it now." AND calls `send_to_user`
+  // with the same line is about to speak for itself; promoting the narration
+  // too is how the person saw the bubble twice. The send has not run yet when
+  // this hook fires (it runs before the tools, on purpose), so the pending
+  // call names are the only evidence.
+  const aboutToSend = (position.toolNames ?? []).some(
+    (name) => name === SEND_TO_USER_TOOL_V1 || name === SEND_MESSAGE_ALIAS_V1,
+  );
+  if (aboutToSend) return;
   const occurrenceId = promotedSendOccurrenceIdV1(position.requestId);
   const spokeThisStep = session.events.some(
     (event) =>
@@ -210,6 +229,42 @@ export const CONVERSATION_PROMPT_SECTION_V1 = "conversation";
 /** Ordered after identity (0), before anything a Package contributes. */
 export const CONVERSATION_PROMPT_ORDER_V1 = 1;
 
+export const STEP_BUDGET_PROMPT_SECTION_V1 = "step-budget";
+/** Late in the prompt, where the model reads it last and heeds it most. */
+export const STEP_BUDGET_PROMPT_ORDER_V1 = 90;
+/** The section appears when this many steps or fewer remain after this one. */
+export const STEP_BUDGET_WARNING_STEPS_V1 = 3;
+
+/**
+ * What the model is told when its reply is about to be stopped.
+ *
+ * A Turn that reaches the loop's step ceiling ends `interrupted`, and a model
+ * that was mid-work says nothing: the person sees a notice and no status. Bob
+ * (2026-09-04) spent twenty steps retrying a failing publish and the thread
+ * went quiet. So the last few steps carry a countdown and one instruction —
+ * stop starting work, send a status — and the final step allows nothing else.
+ */
+export function stepBudgetPromptTextV1(context: {
+  step?: { current: number; max: number };
+}): string {
+  const step = context.step;
+  if (!step) return "";
+  const remaining = step.max - step.current;
+  if (remaining > STEP_BUDGET_WARNING_STEPS_V1 || remaining < 0) return "";
+  if (remaining === 0) {
+    return [
+      "<step_budget>",
+      `This is the last step of this reply; after it the reply is stopped automatically. Do nothing except call \`${SEND_TO_USER_TOOL_V1}\` once with a short status for the person: what is finished, what is not, and what they can do next.`,
+      "</step_budget>",
+    ].join("\n");
+  }
+  return [
+    "<step_budget>",
+    `This reply has ${remaining} ${remaining === 1 ? "step" : "steps"} left after this one before it is stopped automatically. Do not start new work. Call \`${SEND_TO_USER_TOOL_V1}\` now with a short status for the person: what is finished, what is not, and what they can do next.`,
+    "</step_budget>",
+  ].join("\n");
+}
+
 export const CONVERSATION_PROMPT_TEXT_V1 = [
   "## Talking to the user",
   "",
@@ -271,7 +326,7 @@ function createSendToUserTool(
       string,
       unknown
     >,
-    admission: { turnTypes: ["chat"] },
+    admission: { turnTypes: ["chat", "agent"] },
     validate: (input: unknown) =>
       typeof input === "object" && input !== null && !Array.isArray(input),
     execute: async (
@@ -407,6 +462,13 @@ export const shellAgentPlugin: Plugin.Function = (ctx) => {
       order: CONVERSATION_PROMPT_ORDER_V1,
       render: () => CONVERSATION_PROMPT_TEXT_V1,
     }),
+    // Empty for most of a Turn; a countdown and one instruction at the end of
+    // its step budget. See `stepBudgetPromptTextV1`.
+    ctx.systemPrompt.register({
+      id: STEP_BUDGET_PROMPT_SECTION_V1,
+      order: STEP_BUDGET_PROMPT_ORDER_V1,
+      render: (context) => stepBudgetPromptTextV1(context),
+    }),
     ctx.tools.register(
       createSendToUserTool(SEND_TO_USER_TOOL_V1, ctx.sessions),
       userVoice ? { admissionCeiling: userVoice } : undefined,
@@ -449,27 +511,32 @@ export const shellAgentPlugin: Plugin.Function = (ctx) => {
               currentTurn: turn,
               newEffectId: () => `compaction-${crypto.randomUUID()}`,
               summarise: async (request) => {
-                let text = "";
                 // Two deadlines, one call: the compaction's own, and the abort
                 // a newly admitted Turn raises when it takes the log back.
                 const cancelled = AbortSignal.any([request.signal, signal]);
-                for await (const event of scoped.llm.stream(
-                  {
-                    requestId: `compaction-${crypto.randomUUID()}`,
-                    provider: request.provider,
-                    model: request.model,
-                    system: request.system,
-                    messages: request.messages,
-                    tools: [],
-                    ...(request.modelBinding
-                      ? { modelBinding: request.modelBinding }
-                      : {}),
-                  },
-                  cancelled,
-                )) {
-                  if (event.type === "text-delta") text += event.text;
+                const result =
+                  await scoped.llm.structured<CompactionSummaryPayloadV1>(
+                    {
+                      requestId: `compaction-${crypto.randomUUID()}`,
+                      provider: request.provider,
+                      model: request.model,
+                      system: request.system,
+                      messages: request.messages,
+                      tools: [],
+                      ...(request.modelBinding
+                        ? { modelBinding: request.modelBinding }
+                        : {}),
+                    },
+                    {
+                      name: "conversation_compaction",
+                      schema: COMPACTION_RESPONSE_SCHEMA_V1,
+                    },
+                    cancelled,
+                  );
+                if (result.status === "failed") {
+                  throw new Error(result.failure.message);
                 }
-                return text;
+                return renderCompactionSummaryV1(result.value);
               },
             });
           });

package/src/backend-applets.ts

@@ -294,7 +294,7 @@ export interface AppletCapabilityHostOptionsV1 {
    * told so in the failure when the files are missing, rather than the publish
    * silently using old bytes.
    */
-  syncSourceRootNow?(): Promise<void>;
+  syncSourceRootNow?(appletId: string): Promise<void>;
   composition: Pick<CompositionStore, "current" | "lastKnownGood" | "propose">;
   now?(): Date;
 }
@@ -731,7 +731,7 @@ export function createAppletCapabilityHostV1(
 
       // Force a pull of the source root so the publish sees what the Bot just
       // built, not the last synced copy. See the seam note on the option.
-      await options.syncSourceRootNow?.();
+      await options.syncSourceRootNow?.(input.appletId);
 
       const server = await readFile(
         input.appletId,

package/src/backend-composition.ts

@@ -112,6 +112,11 @@ export interface ShellCompositionMountOptions {
   agentPackages?: readonly FoundationAgentPackage[];
   modelSelection?: RuntimeModelSelection;
   systemPromptSection?: string;
+  /** Called after the loop has flushed `turn/end`; errors are non-fatal. */
+  onTurnStopping?(input: {
+    turn: number;
+    events: readonly SessionEvent[];
+  }): Promise<void>;
   /**
    * Durably linearizes each provider or tool effect against Stop immediately
    * before it is used. The Bot Durable Object owns the transaction; the mounted
@@ -180,6 +185,20 @@ export function createShellCompositionHost(
         ...(options.turnType ? { turnType: options.turnType } : {}),
         ...(options.subagentRole ? { subagentRole: options.subagentRole } : {}),
       });
+      const disposeTurnStopping = options.onTurnStopping
+        ? runtime.root.on("agent/turn-stopping", async (agent, turn) => {
+            try {
+              await options.onTurnStopping!({
+                turn,
+                events: structuredClone(agent.session.events),
+              });
+            } catch {
+              // Accounting is a durable projection. Its own outbox exposes a
+              // gap; it can never turn a completed model response into a
+              // failed conversation Turn.
+            }
+          })
+        : undefined;
 
       const isolateMembers = generation.members.filter(
         (member) => member.artifact !== undefined,
@@ -290,6 +309,7 @@ export function createShellCompositionHost(
       }
 
       const dispose = async () => {
+        disposeTurnStopping?.();
         for (const unregister of unregisterApplets.toReversed()) unregister();
         for (const contribution of active.toReversed()) {
           await contribution.dispose();

package/src/backend-flock.ts

@@ -1,17 +1,17 @@
 // The Bot Durable Object's half of the Bot self-management seam.
 //
-// The Flock Package offers a Bot two tools over its own identity and its
-// User's flock. This module decides, for one admitted Turn, what provenance
-// those writes record and which authorities they may reach. It implements
-// neither: the profile write is the Bot Durable Object's own configuration
-// command, and the create is the User Durable Object's `bot/create` — the
-// same two paths the hosted client drives.
+// The Flock Package offers a Bot self-management and direct messaging over its
+// own identity and its User's flock. This module decides, for one admitted
+// Turn, what provenance those effects record and which authorities they may
+// reach. The profile write is the Bot Durable Object's own configuration
+// command, create is the User Durable Object's `bot/create`, and messaging
+// admits an agent Turn through the target Bot's Durable Object.
 //
 // AUTHORITY. "Self-modification never widens authority." The host handed to
-// the Package exposes exactly four calls, all of them things the User's own
-// surfaces already do, and the `botId` on every one of them is fixed here
-// rather than taken from the model's arguments. A Bot cannot address another
-// Bot's settings through this seam because the seam never accepts a target.
+// the Package exposes only narrow authority calls. The `botId` on every
+// mutation is fixed here rather than taken from the model's arguments. A Bot
+// cannot address another Bot's settings through this seam; a message target is
+// instead resolved from the same User's Flock directory before admission.
 //
 // HIBERNATION. Nothing here reaches the Computer registry, a Computer
 // provider, or a Sprite: identity is Durable Object state, so self-management
@@ -26,7 +26,9 @@ import type {
   CreateBotCommandV1,
   FlockReceiptV1,
   FlockSelfRuntimeHostV1,
+  BotMessageOutcomeV1,
 } from "@frockbot/plugin-flock/agent";
+import type { AgentTurnSlotReceiptV1 } from "@frockbot/plugin-flock/quota";
 
 /** The Bot and User whose identity a Turn may change. */
 export interface BotSelfManagementIdentity {
@@ -39,6 +41,9 @@ export interface BotSelfManagementTurn {
   runId: string;
   turnId: string;
   sessionId: string;
+  /** This Turn's pinned profile name, stable across effect recovery. */
+  fromBotName: string;
+  inboundAgent?: FlockSelfRuntimeHostV1["inboundAgent"];
 }
 
 /**
@@ -57,6 +62,51 @@ export interface BotSelfManagementAuthorities {
     userId: string,
     command: CreateBotCommandV1,
   ): Promise<FlockReceiptV1>;
+  reserveAgentTurn(request: {
+    schemaVersion: 1;
+    userId: string;
+    requesterId: string;
+    runId: string;
+    reservedAt: string;
+  }): Promise<AgentTurnSlotReceiptV1>;
+  releaseAgentTurn(request: {
+    schemaVersion: 1;
+    userId: string;
+    requesterId: string;
+    runId: string;
+  }): Promise<void>;
+  runAgent(request: {
+    schemaVersion: 1;
+    userId: string;
+    botId: string;
+    command: {
+      runId: string;
+      sessionId: string;
+      acceptedAt: string;
+      text: string;
+      source: {
+        kind: "bot";
+        fromBotId: string;
+        fromBotName: string;
+        messageId: string;
+      };
+    };
+  }): Promise<{ text: string }>;
+}
+
+async function agentRunIdV1(
+  identity: BotSelfManagementIdentity,
+  targetBotId: string,
+  effectId: string,
+): Promise<string> {
+  const bytes = new TextEncoder().encode(
+    `${identity.userId}\u0000${identity.botId}\u0000${targetBotId}\u0000${effectId}`,
+  );
+  const digest = await crypto.subtle.digest("SHA-256", bytes);
+  const hex = [...new Uint8Array(digest)]
+    .map((byte) => byte.toString(16).padStart(2, "0"))
+    .join("");
+  return `agent-${hex.slice(0, 32)}`;
 }
 
 /**
@@ -92,5 +142,64 @@ export function createBotSelfManagementHost(
     },
     listBots: () => authorities.listBots(identity.userId),
     createBot: (command) => authorities.createBot(identity.userId, command),
+    ...(turn.inboundAgent ? { inboundAgent: turn.inboundAgent } : {}),
+    messageBot: async (request): Promise<BotMessageOutcomeV1> => {
+      if (request.targetBotId === identity.botId) {
+        throw new Error("a Bot cannot message itself");
+      }
+      const directory = await authorities.listBots(identity.userId);
+      const target = directory.bots.find(
+        (bot) => bot.botId === request.targetBotId,
+      );
+      if (!target)
+        throw new Error("the target Bot is not in this User's flock");
+      const runId = await agentRunIdV1(
+        identity,
+        request.targetBotId,
+        request.effectId,
+      );
+      const reservation = await authorities.reserveAgentTurn({
+        schemaVersion: 1,
+        userId: identity.userId,
+        requesterId: identity.botId,
+        runId,
+        reservedAt: new Date().toISOString(),
+      });
+      if (reservation.status === "refused") {
+        throw new Error(reservation.reason);
+      }
+      try {
+        const turnResult = await authorities.runAgent({
+          schemaVersion: 1,
+          userId: identity.userId,
+          botId: request.targetBotId,
+          command: {
+            runId,
+            sessionId: `${identity.userId}:${request.targetBotId}`,
+            acceptedAt: new Date().toISOString(),
+            text: request.message,
+            source: {
+              kind: "bot",
+              fromBotId: identity.botId,
+              fromBotName: turn.fromBotName,
+              messageId: runId,
+            },
+          },
+        });
+        return {
+          targetBotId: request.targetBotId,
+          targetBotName: target.initialName,
+          runId,
+          text: turnResult.text,
+        };
+      } finally {
+        await authorities.releaseAgentTurn({
+          schemaVersion: 1,
+          userId: identity.userId,
+          requesterId: identity.botId,
+          runId,
+        });
+      }
+    },
   };
 }

package/src/backend-recovery-integration.test.ts

@@ -608,7 +608,7 @@ describe("Bot recovery", () => {
       schemaVersion: 1,
       runs: [
         expect.objectContaining({
-          schemaVersion: 2,
+          schemaVersion: 3,
           runId: "run-1",
           status: "completed",
           outcome: { type: "completed", text: "Durable reply" },

package/src/backend-runner.ts

@@ -91,6 +91,7 @@ function settleBotTurn(
       events.some(
         (event) =>
           (event.type === "assistant/message" ||
+            event.type === "model/response-failed" ||
             event.type === "model/effect-not-started") &&
           event.requestId === latestRequest.request.requestId,
       );