@swirls/looms 0.2.0 → 0.4.0

package/CHANGELOG.md

@@ -1,5 +1,36 @@
 # @swirls/looms
 
+## 0.4.0
+
+### Minor Changes
+
+- 46be9ee: `LoomsRegister`, `RegisteredEvent`, and `AnyEventEnvelope` now live in `@swirls/looms/core`; `@swirls/looms/react` re-exports them, so existing `declare module '@swirls/looms/react'` registrations keep working. Standalone `defineProjection` reducers receive the registered event union, so client-only projections are typed without annotations. Registered event payloads were previously typed as `any`; they now carry their catalog types, so code that relied on `any` may need to narrow on `event.type` first.
+- 46be9ee: `createFold`, `useEventFold`, `EventFoldDefinition`, and `foldEvents` in `@swirls/looms/react` are now `defineLiveFold`, `useLiveFold`, `LiveFoldDefinition`, and `foldLive(fold, events)`. A live fold always sees ephemeral events, so the `includeEphemeral` option is gone; use a projection for anything that does not need them. Live folds take an optional `shape` schema that infers their state type, and passing a projection where a live fold is expected is a type error.
+
+  Live folds no longer see ephemeral events from an effect attempt that the runtime retried, so streamed text from a failed attempt disappears without reducer code. `@swirls/looms/core` exports the rule as `dropSupersededAttempts(events)`, with `retriedEffectId(event)`.
+
+## 0.3.0
+
+### Minor Changes
+
+- 331ff55: `stopAgentTurn()` builds an `agent.turn.stopped` signal that ends the turn in progress without ending the run. A conversational agent aborts its in-flight model call or tool, cancels child threads its tool calls started, answers open tool calls with a stopped result, and waits for the next message. An agent session cancels its active turn and stays open. The debugger chat shows a Stop button while a turn is running.
+
+  An interrupting `steer` now ends the turn the same way before it starts the next one, so it no longer leaves tool calls unanswered or tool children running.
+
+  Cancelling a thread now cancels every live thread below it, and a signal interrupt also aborts in-flight work in the named thread's descendants.
+
+  The new `turnActivity` projection reports whether the root agent thread has a turn in progress.
+
+- 8da450e: `POST /runs/:id/cancel` and `client.cancel(runId, threadId?)` cancel a run or thread over HTTP. The debugger's Cancel button now uses it, so cancelling an in-flight agent turn stops the run instead of retrying the turn. Cancel stays available while a wake is running. `POST /runs/:id/wake` and `client.wake()` return `appended`, the number of events the run gained during the wake, and the debugger's Wake button reports it. Client run tables, the debugger, and projector indexes now mark a cancelled run as `cancelled` instead of `running`, and projector indexes mark a run that completed with an error as `failed` instead of `completed`. `RunRow.status` and `RunSummary.status` are typed as `RunStatus`, and `completedRunStatus()` reads the outcome of a `runtime.run.completed` payload.
+
+  Signals sent to a completed, failed, or cancelled run now reject with `RunTerminalError` (HTTP 409) instead of being appended and ignored. Retrying a signal whose `idempotencyKey` was already accepted still succeeds. `useRunSummary` exposes `finished`, and the debugger disables the agent follow-up composer and approval decisions on finished runs.
+
+- 6230fe1: `looms.fork(runId)`, `POST /runs/:id/fork`, and `client.fork()` start a new run that continues where a failed or cancelled run stopped. The fork copies the source's history up to the point it finished, keeping thread ids and sequence numbers, records `runtime.run.forked`, and re-issues the effects outstanding there. A cancelled agent re-runs the model call the cancel cut off; a failed run retries the effect whose failure ended it. Effects can declare `deterministic: true` so a fork retries the work behind them instead; workflow scheduling does. Forking a missing run rejects with `RunNotFoundError` (404 over HTTP). Actor and Durable Object hosts return 501. The debugger shows Continue on failed and cancelled runs, and `useRunSummary` reports `resumable` for them.
+
+  `runtime.thread.cancelled` records `resumeSeq` on the thread a cancel targeted: the run's last seq before the cancellation began.
+
+- 275e6a8: The projector index is keyed by run, so runs that share thread or approval ids stay apart. `getActor(runId, actorId?)` returns the run row by default or one of its threads, review rows carry `runId` instead of `actorId`, and the tables are now `looms_run_actors` and `looms_run_reviews`. The built-in index projectors moved to version 2, so delivery rebuilds them; the old `looms_actors` and `looms_reviews` tables are no longer written.
+
 ## 0.2.0
 
 ### Minor Changes

package/dist/actor/host.js

@@ -2,7 +2,7 @@ import { Data, Effect } from 'effect';
 import { EventStoreTag } from '@swirls/looms/core';
 import { createTimeoutScheduler, isLoomsApiPath } from '@swirls/looms/runtime';
 import { createActorCell } from './cell.js';
-import { resolveRunTarget, RunTargetError } from './routing.js';
+import { crossRunResponse, resolveRunTarget, RunTargetError } from './routing.js';
 class ActorWakeError extends Data.TaggedError('ActorWakeError') {
     constructor(cause) {
         super({
@@ -76,11 +76,9 @@ export function createLocalActorHost(options) {
             if (url.pathname === '/health') {
                 return Promise.resolve(Response.json({ ok: true }));
             }
-            if (req.method === 'GET' &&
-                (url.pathname === '/runs' || url.pathname === '/runs/summaries')) {
-                return Promise.resolve(Response.json({
-                    error: 'Global run listing is not supported in the actor host without a global index',
-                }, { status: 501 }));
+            const unsupported = crossRunResponse(req, 'the actor host');
+            if (unsupported) {
+                return Promise.resolve(unsupported);
             }
             return Effect.runPromise(Effect.gen(function* () {
                 const { runId, request } = yield* Effect.tryPromise({

package/dist/actor/index.d.ts

@@ -1,3 +1,3 @@
 export { createActorCell, type ActorCell, type ActorCellOptions } from './cell';
-export { runIdFromRequest, resolveRunTarget, RunTargetError, type ResolvedRunTarget, } from './routing';
+export { crossRunResponse, runIdFromRequest, resolveRunTarget, RunTargetError, type ResolvedRunTarget, } from './routing';
 export { createLocalActorHost, type LocalActorHost, type LocalActorHostOptions } from './host';

package/dist/actor/index.js

@@ -1,3 +1,3 @@
 export { createActorCell } from './cell.js';
-export { runIdFromRequest, resolveRunTarget, RunTargetError, } from './routing.js';
+export { crossRunResponse, runIdFromRequest, resolveRunTarget, RunTargetError, } from './routing.js';
 export { createLocalActorHost } from './host.js';

package/dist/actor/routing.d.ts

@@ -3,6 +3,11 @@
  * Inspects `x-looms-run-id` and `/runs/:runId/*`.
  */
 export declare function runIdFromRequest(req: Request): string | null;
+/**
+ * A 501 for requests that span runs, which a host with one cell per run cannot answer: listing
+ * runs needs a global index, and a fork writes a second run. `host` names the backend.
+ */
+export declare function crossRunResponse(req: Request, host: string): Response | null;
 export interface ResolvedRunTarget {
     readonly runId: string;
     readonly request: Request;

package/dist/actor/routing.js

@@ -22,6 +22,20 @@ export function runIdFromRequest(req) {
     }
     return null;
 }
+/**
+ * A 501 for requests that span runs, which a host with one cell per run cannot answer: listing
+ * runs needs a global index, and a fork writes a second run. `host` names the backend.
+ */
+export function crossRunResponse(req, host) {
+    const { pathname } = new URL(req.url);
+    if (req.method === 'GET' && (pathname === '/runs' || pathname === '/runs/summaries')) {
+        return Response.json({ error: `Global run listing is not supported in ${host} without a global index` }, { status: 501 });
+    }
+    if (req.method === 'POST' && /^\/runs\/[^/]+\/fork$/.test(pathname)) {
+        return Response.json({ error: `Forking runs is not supported in ${host}; each run lives in its own cell` }, { status: 501 });
+    }
+    return null;
+}
 export class RunTargetError extends Data.TaggedError('RunTargetError') {
     constructor(method, path) {
         super({

package/dist/agent/agent-session.js

@@ -140,6 +140,7 @@ export function createAgentSessionThread(definitions) {
                         pendingClosures: state.pendingClosures.filter((closure) => closure.messageId !== event.payload.messageId),
                     };
                 case 'agent.session.cancel.requested':
+                case 'agent.turn.stopped':
                 case 'runtime.thread.cancel.requested':
                     return state.activeTurn ? { ...state, cancelling: true } : state;
                 case 'runtime.wait.satisfied': {

package/dist/agent/debugger/agent-chat.js

@@ -1,11 +1,12 @@
 import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { Bot, CornerDownRight, MessageSquare, Settings2, User, Wrench } from 'lucide-react';
+import { Bot, CornerDownRight, GitFork, MessageSquare, Settings2, User, Wrench } from 'lucide-react';
 import { useMemo, useState } from 'react';
-import { createEventId, isJsonObject, isJsonString } from '@swirls/looms/core';
-import { cn, Composer, EmptyState, errorMessage, FollowList, inputForm, JsonTree, messageInput, parseStructuredJson, Select, SelectContent, SelectItem, SelectTrigger, SelectValue, shortId, useDebugger, useStartRun, } from '@swirls/looms/debugger';
-import { createFold, useEventFold, useProjection, useRunStore, useRunSummary } from '@swirls/looms/react';
-import { conversation } from '../projections.js';
-import { agentSessionMessageEvents, userMessage } from '../signals.js';
+import { createEventId, isJsonObject, isJsonString, } from '@swirls/looms/core';
+import { Button, cn, Composer, EmptyState, errorMessage, FollowList, inputForm, JsonTree, messageInput, parseStructuredJson, Select, SelectContent, SelectItem, SelectTrigger, SelectValue, shortId, useDebugger, useStartRun, } from '@swirls/looms/debugger';
+import { useLiveFold, useProjection, useRunStore, useRunSummary } from '@swirls/looms/react';
+import { conversation, turnActivity } from '../projections.js';
+import { agentSessionMessageEvents, stopAgentTurn, userMessage } from '../signals.js';
+import { streamingText } from './streaming-text.js';
 /** Child thread of the session turn that is still open, from the events the store already has. */
 function activeSessionChild(events) {
     let child;
@@ -26,32 +27,6 @@ function activeSessionChild(events) {
     }
     return child;
 }
-const streamingFold = createFold({
-    name: 'agentStreamingText',
-    initialState: { lastMessageSeq: -1, turnStarted: false, parts: [] },
-    includeEphemeral: true,
-    reduce(state, event) {
-        if (event.type === 'agent.message') {
-            return { lastMessageSeq: event.seq, turnStarted: false, parts: [] };
-        }
-        if (event.seq <= state.lastMessageSeq) {
-            return state;
-        }
-        if (event.type === 'agent.turn.started') {
-            return { ...state, turnStarted: true };
-        }
-        if (event.type === 'agent.turn.text_delta' &&
-            isJsonObject(event.payload) &&
-            isJsonString(event.payload.delta)) {
-            return {
-                ...state,
-                turnStarted: true,
-                parts: state.parts.concat(event.payload.delta),
-            };
-        }
-        return state;
-    },
-});
 const deliveryOptions = [
     { value: 'followUp', label: 'Follow up', description: 'Queue after the current turn' },
     { value: 'steer', label: 'Steer', description: 'Redirect the active turn' },
@@ -95,7 +70,7 @@ function StreamingItem({ text }) {
 function Transcript({ runId }) {
     const store = useRunStore(runId);
     const convo = useProjection(store, conversation);
-    const streaming = useEventFold(store, streamingFold);
+    const streaming = useLiveFold(store, streamingText);
     const stream = streaming.turnStarted ? streaming.parts.join('') : null;
     const toolNames = useMemo(() => {
         const names = new Map();
@@ -143,17 +118,49 @@ export function AgentChat(context) {
             ? (started) => client.signal(started.runId, agentSessionMessageEvents(createEventId(), content, { threadId: started.threadId }))
             : undefined);
     }
-    return (_jsxs("div", { className: "flex h-full min-h-0 flex-col", children: [runId ? (_jsx(Transcript, { runId: runId })) : (_jsx("div", { className: "min-h-0 flex-1", children: _jsx(EmptyState, { icon: _jsx(MessageSquare, {}), title: `Talk to ${definition.name}`, children: "Your first message starts a new run." }) })), runId ? (_jsx(FollowUp, { runId: runId, session: session, delivery: delivery, setDelivery: setDelivery, startError: error })) : (_jsx(Composer, { value: draft, onChange: setDraft, onSubmit: send, pending: pending, placeholder: `Message ${definition.name}…`, submitLabel: "Start", error: error }))] }));
+    return (_jsxs("div", { className: "flex h-full min-h-0 flex-col", children: [runId ? (_jsx(Transcript, { runId: runId })) : (_jsx("div", { className: "min-h-0 flex-1", children: _jsx(EmptyState, { icon: _jsx(MessageSquare, {}), title: `Talk to ${definition.name}`, children: "Your first message starts a new run." }) })), runId ? (_jsx(FollowUp, { runId: runId, session: session, delivery: delivery, setDelivery: setDelivery, startError: error, onForked: context.onStarted })) : (_jsx(Composer, { value: draft, onChange: setDraft, onSubmit: send, pending: pending, placeholder: `Message ${definition.name}…`, submitLabel: "Start", error: error }))] }));
+}
+function FollowUp({ onForked, ...props }) {
+    const { status, resumable } = useRunSummary(useRunStore(props.runId));
+    return resumable ? (_jsx(ContinueRun, { runId: props.runId, status: status, onForked: onForked })) : (_jsx(Reply, { ...props }));
 }
-function FollowUp({ runId, session, delivery, setDelivery, startError, }) {
+function ContinueRun({ runId, status, onForked, }) {
+    const { client } = useDebugger();
+    const [pending, setPending] = useState(false);
+    const [error, setError] = useState(null);
+    function continueInNewRun() {
+        setPending(true);
+        setError(null);
+        client
+            .fork(runId)
+            .then((forked) => onForked(forked.runId))
+            .catch((cause) => setError(errorMessage(cause)))
+            .finally(() => setPending(false));
+    }
+    return (_jsxs("div", { className: "border-border shrink-0 border-t p-3", children: [_jsxs("div", { className: "flex items-center gap-2", children: [_jsxs("p", { className: "text-muted-foreground min-w-0 flex-1 text-xs", children: ["Run ", status, ". Continue from where it stopped in a new run."] }), _jsxs(Button, { size: "sm", variant: "outline", disabled: pending, onClick: continueInNewRun, children: [_jsx(GitFork, {}), "Continue in new run"] })] }), error ? _jsx("p", { className: "text-status-failed mt-2 text-[11px]", children: error }) : null] }));
+}
+function Reply({ runId, session, delivery, setDelivery, startError }) {
     const store = useRunStore(runId);
-    const { rootThreadId } = useRunSummary(store);
+    const { rootThreadId, status, finished } = useRunSummary(store);
+    const turn = useProjection(store, turnActivity);
     const [draft, setDraft] = useState('');
     const [pending, setPending] = useState(false);
+    const [stopping, setStopping] = useState(false);
     const [error, setError] = useState(null);
+    function stop() {
+        if (!rootThreadId) {
+            return;
+        }
+        setStopping(true);
+        setError(null);
+        store
+            .commit(stopAgentTurn({ threadId: rootThreadId }))
+            .catch((cause) => setError(errorMessage(cause)))
+            .finally(() => setStopping(false));
+    }
     function send() {
         const content = draft.trim();
-        if (!content || !rootThreadId) {
+        if (!content || !rootThreadId || finished) {
             return;
         }
         setPending(true);
@@ -172,5 +179,5 @@ function FollowUp({ runId, session, delivery, setDelivery, startError, }) {
             .catch((cause) => setError(errorMessage(cause)))
             .finally(() => setPending(false));
     }
-    return (_jsx(Composer, { value: draft, onChange: setDraft, onSubmit: send, pending: pending, disabled: !rootThreadId, placeholder: "Send a follow-up\u2026", error: error ?? startError, toolbar: session ? _jsx(DeliverySelect, { value: delivery, onChange: setDelivery }) : null }));
+    return (_jsx(Composer, { value: draft, onChange: setDraft, onSubmit: send, onStop: turn.active && !finished ? stop : undefined, stopping: stopping, pending: pending, disabled: !rootThreadId || finished, placeholder: finished ? `Run ${status}. Start a new run to continue.` : 'Send a follow-up…', error: error ?? startError, toolbar: session ? _jsx(DeliverySelect, { value: delivery, onChange: setDelivery }) : null }));
 }

package/dist/agent/debugger/streaming-text.d.ts

@@ -0,0 +1,6 @@
+/** Text the active turn has streamed since the last durable agent message. */
+export declare const streamingText: import("@swirls/looms/react").LiveFoldDefinition<{
+    readonly lastMessageSeq: number;
+    readonly turnStarted: boolean;
+    readonly parts: readonly string[];
+}, import("@swirls/looms/core").EventEnvelope>;

package/dist/agent/debugger/streaming-text.js

@@ -0,0 +1,33 @@
+import { Schema } from 'effect';
+import { isJsonObject, isJsonString } from '@swirls/looms/core';
+import { defineLiveFold } from '@swirls/looms/react';
+const StreamingTextSchema = Schema.Struct({
+    lastMessageSeq: Schema.Finite,
+    turnStarted: Schema.Boolean,
+    parts: Schema.Array(Schema.String),
+});
+/** Text the active turn has streamed since the last durable agent message. */
+export const streamingText = defineLiveFold({
+    name: 'agentStreamingText',
+    shape: StreamingTextSchema,
+    initialState: { lastMessageSeq: -1, turnStarted: false, parts: [] },
+    reduce(state, event) {
+        if (event.type === 'agent.message' ||
+            event.type === 'agent.turn.stopped' ||
+            event.type === 'runtime.thread.cancelled') {
+            return { lastMessageSeq: event.seq, turnStarted: false, parts: [] };
+        }
+        if (event.seq <= state.lastMessageSeq) {
+            return state;
+        }
+        if (event.type === 'agent.turn.started') {
+            return { ...state, turnStarted: true };
+        }
+        if (event.type === 'agent.turn.text_delta' &&
+            isJsonObject(event.payload) &&
+            isJsonString(event.payload.delta)) {
+            return { ...state, turnStarted: true, parts: state.parts.concat(event.payload.delta) };
+        }
+        return state;
+    },
+});

package/dist/agent/debugger/summarize.js

@@ -38,6 +38,8 @@ export function summarizeAgentEvent(event) {
             };
         case 'agent.steered':
             return { title: 'steered', detail: messageContent(event.payload) };
+        case 'agent.turn.stopped':
+            return { title: 'turn stopped' };
         case 'agent.spawn.requested':
             return {
                 title: 'agent spawn',

package/dist/agent/effects.d.ts

@@ -203,6 +203,9 @@ export declare const callLlmEffect: NoInfer<import("@swirls/looms/core").EffectD
     readonly payload: {
         readonly turn: number;
     };
+}) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+    readonly type: "agent.turn.stopped";
+    readonly payload: {};
 }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
     readonly type: "agent.turn.text_delta";
     readonly payload: {
@@ -291,6 +294,11 @@ export declare const callLlmEffect: NoInfer<import("@swirls/looms/core").EffectD
         readonly attempt: number;
         readonly deadlineAt: number | null;
     };
+}) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+    readonly type: "runtime.fork.elided";
+    readonly payload: {
+        readonly type: string;
+    };
 }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
     readonly type: "runtime.run.cancelled";
     readonly payload: {
@@ -302,6 +310,12 @@ export declare const callLlmEffect: NoInfer<import("@swirls/looms/core").EffectD
         readonly output: Schema.Json;
         readonly error: string | null;
     };
+}) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+    readonly type: "runtime.run.forked";
+    readonly payload: {
+        readonly sourceRunId: string;
+        readonly sourceSeq: number;
+    };
 }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
     readonly type: "runtime.run.started";
     readonly payload: {
@@ -334,6 +348,7 @@ export declare const callLlmEffect: NoInfer<import("@swirls/looms/core").EffectD
     readonly payload: {
         readonly threadId: string;
         readonly reason?: string | undefined;
+        readonly resumeSeq?: number | undefined;
     };
 }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
     readonly type: "runtime.thread.completed";
@@ -587,6 +602,9 @@ export declare const executeToolEffect: NoInfer<import("@swirls/looms/core").Eff
     readonly payload: {
         readonly turn: number;
     };
+}) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+    readonly type: "agent.turn.stopped";
+    readonly payload: {};
 }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
     readonly type: "agent.turn.text_delta";
     readonly payload: {
@@ -675,6 +693,11 @@ export declare const executeToolEffect: NoInfer<import("@swirls/looms/core").Eff
         readonly attempt: number;
         readonly deadlineAt: number | null;
     };
+}) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+    readonly type: "runtime.fork.elided";
+    readonly payload: {
+        readonly type: string;
+    };
 }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
     readonly type: "runtime.run.cancelled";
     readonly payload: {
@@ -686,6 +709,12 @@ export declare const executeToolEffect: NoInfer<import("@swirls/looms/core").Eff
         readonly output: Schema.Json;
         readonly error: string | null;
     };
+}) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+    readonly type: "runtime.run.forked";
+    readonly payload: {
+        readonly sourceRunId: string;
+        readonly sourceSeq: number;
+    };
 }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
     readonly type: "runtime.run.started";
     readonly payload: {
@@ -718,6 +747,7 @@ export declare const executeToolEffect: NoInfer<import("@swirls/looms/core").Eff
     readonly payload: {
         readonly threadId: string;
         readonly reason?: string | undefined;
+        readonly resumeSeq?: number | undefined;
     };
 }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
     readonly type: "runtime.thread.completed";

package/dist/agent/events.d.ts

@@ -69,6 +69,7 @@ export declare const AgentSteeredPayloadSchema: Schema.Struct<{
     readonly interrupt: Schema.optional<Schema.Boolean>;
 }>;
 export declare const AgentSessionDeliverySchema: Schema.Union<readonly [Schema.Literal<"steer">, Schema.Literal<"followUp">, Schema.Literal<"nextTurn">]>;
+export declare const AgentTurnStoppedPayloadSchema: Schema.Struct<{}>;
 export declare const AgentSessionMessageSubmittedPayloadSchema: Schema.Struct<{
     readonly messageId: Schema.String;
     readonly text: Schema.String;
@@ -231,6 +232,7 @@ export declare const agentCatalog: import("@swirls/looms/core").EventCatalog<"ag
         }>;
         readonly interrupt: Schema.optional<Schema.Boolean>;
     }>;
+    'turn.stopped': Schema.Struct<{}>;
     'session.message.submitted': Schema.Struct<{
         readonly messageId: Schema.String;
         readonly text: Schema.String;

package/dist/agent/events.js

@@ -38,6 +38,7 @@ export const AgentSessionDeliverySchema = Schema.Union([
     Schema.Literal('followUp'),
     Schema.Literal('nextTurn'),
 ]);
+export const AgentTurnStoppedPayloadSchema = Schema.Struct({});
 export const AgentSessionMessageSubmittedPayloadSchema = Schema.Struct({
     messageId: Schema.String,
     text: Schema.String,
@@ -86,6 +87,7 @@ export const agentCatalog = defineEventCatalog('agent', {
     'tool_call.requested': AgentToolCallRequestedPayloadSchema,
     'tool.result': AgentToolResultPayloadSchema,
     steered: AgentSteeredPayloadSchema,
+    'turn.stopped': AgentTurnStoppedPayloadSchema,
     'session.message.submitted': AgentSessionMessageSubmittedPayloadSchema,
     'session.steer.delivered': AgentSessionSteerDeliveredPayloadSchema,
     'session.turn.started': AgentSessionTurnStartedPayloadSchema,

package/dist/agent/llm.js

@@ -36,14 +36,7 @@ export const makeStubLlm = (policy = {}) => ({
                 toolCalls,
             };
         }
-        let lastUser;
-        for (let i = args.messages.length - 1; i >= 0; i--) {
-            const item = args.messages[i];
-            if (item?.role === 'user') {
-                lastUser = item;
-                break;
-            }
-        }
+        const lastUser = args.messages.findLast((item) => item.role === 'user');
         const lastContent = args.messages.at(-1)?.content;
         const content = lastUser?.content ??
             (Predicate.isString(lastContent) ? lastContent : stringifyJson(lastContent ?? null));