@swirls/looms 0.2.0 → 0.4.0

package/dist/agent/module.js

@@ -4,7 +4,7 @@ import { createAgentSessionThread } from './agent-session.js';
 import { AgentDefinitionsLive } from './definitions-store.js';
 import { callLlmEffect, executeToolEffect } from './effects.js';
 import { llmFromAdapter, LlmTag, StubLlmLive } from './llm.js';
-import { conversation, tokenUsage } from './projections.js';
+import { conversation, tokenUsage, turnActivity } from './projections.js';
 import { agentModule } from './scope.js';
 import { agentThread } from './threads.js';
 export function agent(options = {}) {
@@ -27,13 +27,17 @@ export function agent(options = {}) {
         projections: {
             conversation,
             tokenUsage,
+            turnActivity,
         },
         services: () => Layer.merge(llmLayer, AgentDefinitionsLive(agentDefinitions)),
-        interruptsOnSignal: (event) => event.type === 'agent.steered' &&
-            Predicate.isObject(event.payload) &&
-            event.payload.interrupt === true &&
-            event.threadId
-            ? [event.threadId]
-            : [],
+        interruptsOnSignal,
     }));
 }
+/** A stop or an interrupting steer abandons the turn in progress on its thread. */
+function interruptsOnSignal(event) {
+    const abandonsTurn = event.type === 'agent.turn.stopped' ||
+        (event.type === 'agent.steered' &&
+            Predicate.isObject(event.payload) &&
+            event.payload.interrupt === true);
+    return abandonsTurn && event.threadId ? [event.threadId] : [];
+}

package/dist/agent/projections.d.ts

@@ -11,6 +11,11 @@ export declare const conversation: import("@swirls/looms/core").ProjectionDefini
         }[] | undefined;
     }[];
 }>;
+/** Whether the run's root agent or session has a turn in progress that `stopAgentTurn` can end. */
+export declare const turnActivity: import("@swirls/looms/core").ProjectionDefinition<{
+    readonly rootThreadId: string | null;
+    readonly active: boolean;
+}>;
 export declare const tokenUsage: import("@swirls/looms/core").ProjectionDefinition<{
     readonly input: number;
     readonly output: number;

package/dist/agent/projections.js

@@ -1,6 +1,7 @@
 import { Predicate } from 'effect';
 import { agentModule } from './scope.js';
-import { ConversationSchema, TokenUsageSchema } from './types.js';
+import { closeOpenToolCalls } from './transcript.js';
+import { ConversationSchema, TokenUsageSchema, TurnActivitySchema, } from './types.js';
 export const conversation = agentModule.projection({
     name: 'conversation',
     shape: ConversationSchema,
@@ -40,7 +41,8 @@ export const conversation = agentModule.projection({
                     name: raw.name ?? undefined,
                     toolCalls,
                 };
-                return { lines: [...state.lines, line] };
+                const interrupted = event.type === 'agent.steered' && event.payload.interrupt === true;
+                return { lines: [...(interrupted ? closeOpenToolCalls(state.lines) : state.lines), line] };
             }
             case 'agent.tool.result': {
                 const { error, result, toolCallId, name } = event.payload;
@@ -56,6 +58,45 @@ export const conversation = agentModule.projection({
                     lines: [...state.lines, toolLine],
                 };
             }
+            case 'agent.turn.stopped':
+                return { lines: closeOpenToolCalls(state.lines) };
+            default:
+                return state;
+        }
+    },
+});
+/** Whether the run's root agent or session has a turn in progress that `stopAgentTurn` can end. */
+export const turnActivity = agentModule.projection({
+    name: 'turnActivity',
+    shape: TurnActivitySchema,
+    initialState: { rootThreadId: null, active: false },
+    reduce(state, event) {
+        if (event.type === 'runtime.run.started') {
+            return { ...state, rootThreadId: event.payload.rootThreadId ?? null };
+        }
+        if (event.threadId === null || event.threadId !== state.rootThreadId) {
+            return state;
+        }
+        switch (event.type) {
+            case 'runtime.thread.started':
+                return { ...state, active: event.payload.kind === 'agent' };
+            case 'agent.message.received':
+            case 'agent.tool_call.requested':
+            case 'agent.session.turn.started':
+                return { ...state, active: true };
+            case 'agent.steered':
+                return event.payload.interrupt === true ? { ...state, active: true } : state;
+            case 'agent.message':
+            case 'agent.turn.stopped':
+            case 'runtime.thread.completed':
+            case 'runtime.thread.failed':
+            case 'runtime.thread.cancelled':
+                return { ...state, active: false };
+            case 'runtime.wait.satisfied':
+                return Predicate.isObject(event.payload.tag) &&
+                    event.payload.tag.kind === 'agent-session-turn'
+                    ? { ...state, active: false }
+                    : state;
             default:
                 return state;
         }

package/dist/agent/scope.d.ts

@@ -69,6 +69,7 @@ export declare const agentModule: import("@swirls/looms/core").ModuleScope<"agen
         }>;
         readonly interrupt: import("effect/Schema").optional<import("effect/Schema").Boolean>;
     }>;
+    'turn.stopped': import("effect/Schema").Struct<{}>;
     'session.message.submitted': import("effect/Schema").Struct<{
         readonly messageId: import("effect/Schema").String;
         readonly text: import("effect/Schema").String;
@@ -231,6 +232,7 @@ export declare const agentModule: import("@swirls/looms/core").ModuleScope<"agen
         }>;
         readonly interrupt: import("effect/Schema").optional<import("effect/Schema").Boolean>;
     }>;
+    'turn.stopped': import("effect/Schema").Struct<{}>;
     'session.message.submitted': import("effect/Schema").Struct<{
         readonly messageId: import("effect/Schema").String;
         readonly text: import("effect/Schema").String;

package/dist/agent/signals.d.ts

@@ -16,6 +16,11 @@ export declare function userMessage(content: string, options?: AgentSignalOption
 export declare function steer(content: string, options?: AgentSignalOptions & {
     readonly interrupt?: boolean;
 }): EventInput;
+/**
+ * Build the `agent.turn.stopped` event. A conversational agent aborts its in-flight turn and
+ * waits for the next message; an agent session cancels its active turn and stays open.
+ */
+export declare function stopAgentTurn(options?: AgentSignalOptions): EventInput;
 export interface AgentSessionMessageOptions extends AgentSignalOptions {
     readonly delivery?: AgentMessageDelivery;
     /** Set by the client helper when a steer is aimed at an active child. */

package/dist/agent/signals.js

@@ -18,6 +18,13 @@ export function steer(content, options = {}) {
         message: { role: 'user', content },
     }, { threadId: options.threadId });
 }
+/**
+ * Build the `agent.turn.stopped` event. A conversational agent aborts its in-flight turn and
+ * waits for the next message; an agent session cancels its active turn and stays open.
+ */
+export function stopAgentTurn(options = {}) {
+    return agentModule.input('turn.stopped', {}, { threadId: options.threadId });
+}
 export function submitAgentMessage(messageId, text, options = {}) {
     return agentModule.input('session.message.submitted', {
         messageId,

package/dist/agent/threads.js

@@ -1,7 +1,8 @@
 import { Predicate } from 'effect';
-import { createWaitId, DEFAULT_DEFINITION_VERSION, emit, invoke, isWithdrawnError, parseEffectId, spawn, wait, waitOutcome, } from '@swirls/looms/core';
+import { cancel, createWaitId, DEFAULT_DEFINITION_VERSION, emit, invoke, isWithdrawnError, parseEffectId, spawn, wait, waitOutcome, } from '@swirls/looms/core';
 import { callLlmEffect, executeToolEffect } from './effects.js';
 import { agentModule } from './scope.js';
+import { closeOpenToolCalls } from './transcript.js';
 function inputToLine(input) {
     if (input === null) {
         return null;
@@ -26,20 +27,31 @@ function inputToLine(input) {
     return { role: 'user', content: JSON.stringify(input) };
 }
 function attachToolCall(lines, toolCall) {
-    for (let index = lines.length - 1; index >= 0; index -= 1) {
-        const line = lines[index];
-        if (line?.role !== 'assistant') {
-            continue;
-        }
-        const existing = line.toolCalls ?? [];
-        if (existing.some((item) => item.id === toolCall.id)) {
-            return [...lines];
-        }
-        const next = [...lines];
-        next[index] = { ...line, toolCalls: [...existing, toolCall] };
-        return next;
+    const index = lines.findLastIndex((line) => line.role === 'assistant');
+    const line = lines[index];
+    if (!line || line.toolCalls?.some((item) => item.id === toolCall.id)) {
+        return [...lines];
     }
-    return [...lines];
+    return lines.with(index, { ...line, toolCalls: [...(line.toolCalls ?? []), toolCall] });
+}
+/** Drop the turn in progress: answer its open tool calls and cancel the children they started. */
+function abandonTurn(state) {
+    return {
+        ...state,
+        lines: closeOpenToolCalls(state.lines),
+        pendingSteer: null,
+        pendingToolCalls: [],
+        executingToolCalls: [],
+        pendingSpawns: [],
+        pendingEffects: [],
+        pendingEmits: [],
+        pendingEffectTools: {},
+        needsLlmCall: false,
+        abandonedChildThreadIds: [
+            ...(state.abandonedChildThreadIds ?? []),
+            ...state.pendingSpawns.map((item) => item.childThreadId),
+        ],
+    };
 }
 export const agentThread = agentModule.thread({
     kind: 'agent',
@@ -86,6 +98,7 @@ export const agentThread = agentModule.thread({
                     turn: event.payload.turn,
                     needsLlmCall: false,
                     pendingSteer: null,
+                    abandonedChildThreadIds: [],
                 };
             }
             case 'agent.message.received': {
@@ -148,15 +161,11 @@ export const agentThread = agentModule.thread({
                     ? [...state.consumedSteerMessageIds, messageId]
                     : state.consumedSteerMessageIds;
                 if (interrupt) {
+                    const abandoned = abandonTurn(state);
                     return {
-                        ...state,
-                        lines: [...state.lines, message],
+                        ...abandoned,
+                        lines: [...abandoned.lines, message],
                         pendingSteer: message,
-                        pendingToolCalls: [],
-                        executingToolCalls: [],
-                        pendingSpawns: [],
-                        pendingEffects: [],
-                        pendingEmits: [],
                         needsLlmCall: true,
                         consumedSteerMessageIds,
                     };
@@ -168,6 +177,8 @@ export const agentThread = agentModule.thread({
                     consumedSteerMessageIds,
                 };
             }
+            case 'agent.turn.stopped':
+                return abandonTurn(state);
             case 'agent.spawn.requested': {
                 const { childThreadId, kind, definitionName, definitionVersion, toolCallId, input } = event.payload;
                 return {
@@ -370,6 +381,9 @@ export const agentThread = agentModule.thread({
         for (const emitReq of state.pendingEmits) {
             effects.push(emit(emitReq.event));
         }
+        for (const childThreadId of state.abandonedChildThreadIds ?? []) {
+            effects.push(cancel(childThreadId));
+        }
         return effects;
     },
 });

package/dist/agent/transcript.d.ts

@@ -0,0 +1,7 @@
+import type { Message } from './types';
+export declare const STOPPED_TOOL_RESULT = "Stopped before the tool returned a result.";
+/**
+ * Answer every assistant tool call that has no tool result yet. Model APIs reject a transcript
+ * whose tool calls are left unanswered, so a stopped turn closes them before the next turn.
+ */
+export declare function closeOpenToolCalls(lines: readonly Message[]): Message[];

package/dist/agent/transcript.js

@@ -0,0 +1,19 @@
+export const STOPPED_TOOL_RESULT = 'Stopped before the tool returned a result.';
+/**
+ * Answer every assistant tool call that has no tool result yet. Model APIs reject a transcript
+ * whose tool calls are left unanswered, so a stopped turn closes them before the next turn.
+ */
+export function closeOpenToolCalls(lines) {
+    const answered = new Set(lines.flatMap((line) => (line.toolCallId ? [line.toolCallId] : [])));
+    const closing = lines.flatMap((line) => line.role === 'assistant'
+        ? (line.toolCalls ?? [])
+            .filter((call) => !answered.has(call.id))
+            .map((call) => ({
+            role: 'tool',
+            content: STOPPED_TOOL_RESULT,
+            toolCallId: call.id,
+            name: call.name,
+        }))
+        : []);
+    return closing.length === 0 ? [...lines] : [...lines, ...closing];
+}

package/dist/agent/types.d.ts

@@ -39,6 +39,11 @@ export declare const TokenUsageSchema: Schema.Struct<{
     readonly output: Schema.Finite;
 }>;
 export type TokenUsage = Schema.Schema.Type<typeof TokenUsageSchema>;
+export declare const TurnActivitySchema: Schema.Struct<{
+    readonly rootThreadId: Schema.NullOr<Schema.String>;
+    readonly active: Schema.Boolean;
+}>;
+export type TurnActivity = Schema.Schema.Type<typeof TurnActivitySchema>;
 export declare const ThreadStartedPayloadSchema: Schema.Struct<{
     readonly definitionName: Schema.optional<Schema.String>;
     readonly definitionVersion: Schema.withDecodingDefaultKey<Schema.String, never>;
@@ -87,6 +92,11 @@ export interface AgentState {
         [causingSeq: string]: PendingEffectTool;
     };
     consumedSteerMessageIds: string[];
+    /**
+     * Children of an abandoned turn that still need cancelling, cleared when the next turn starts.
+     * Optional so snapshots taken before turns could be abandoned still fold.
+     */
+    abandonedChildThreadIds?: string[];
 }
 export type AgentMessageDelivery = 'steer' | 'followUp' | 'nextTurn';
 export type AgentSessionTurnStatus = 'completed' | 'failed' | 'cancelled';

package/dist/agent/types.js

@@ -25,6 +25,10 @@ export const TokenUsageSchema = Schema.Struct({
     input: Schema.Finite,
     output: Schema.Finite,
 });
+export const TurnActivitySchema = Schema.Struct({
+    rootThreadId: Schema.NullOr(Schema.String),
+    active: Schema.Boolean,
+});
 export const ThreadStartedPayloadSchema = Schema.Struct({
     definitionName: Schema.optional(Schema.String),
     definitionVersion: Schema.String.pipe(Schema.withDecodingDefaultKey(Effect.succeed(DEFAULT_DEFINITION_VERSION))),

package/dist/approval/debugger/approvals-view.js

@@ -1,16 +1,18 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { Button, StatusBadge, useDebugger } from '@swirls/looms/debugger';
-import { useProjection, useRunStore } from '@swirls/looms/react';
+import { useProjection, useRunStore, useRunSummary } from '@swirls/looms/react';
 import { pendingApprovals } from '../projections.js';
 import { decision } from '../signals.js';
 export function ApprovalsView({ runId }) {
     const { client } = useDebugger();
-    const state = useProjection(useRunStore(runId), pendingApprovals);
+    const store = useRunStore(runId);
+    const state = useProjection(store, pendingApprovals);
+    const { finished } = useRunSummary(store);
     if (state.items.length === 0) {
         return _jsx("p", { className: "text-muted-foreground text-xs", children: "No approvals requested." });
     }
     function decide(approvalId, outcome) {
         void client.signal(runId, [decision(approvalId, outcome)]);
     }
-    return (_jsx("ul", { className: "grid gap-2", children: state.items.map((item) => (_jsxs("li", { className: "border-border bg-card/60 rounded-lg border p-2.5", children: [_jsxs("div", { className: "flex items-center gap-2 text-xs", children: [_jsx("span", { className: "min-w-0 flex-1 truncate font-medium", children: item.title || item.approvalId }), _jsx(StatusBadge, { status: item.status })] }), item.status === 'pending' ? (_jsxs("div", { className: "mt-2 flex gap-1.5", children: [_jsx(Button, { size: "xs", onClick: () => decide(item.approvalId, 'approve'), children: "Approve" }), _jsx(Button, { size: "xs", variant: "outline", onClick: () => decide(item.approvalId, 'reject'), children: "Reject" })] })) : null] }, item.approvalId))) }));
+    return (_jsx("ul", { className: "grid gap-2", children: state.items.map((item) => (_jsxs("li", { className: "border-border bg-card/60 rounded-lg border p-2.5", children: [_jsxs("div", { className: "flex items-center gap-2 text-xs", children: [_jsx("span", { className: "min-w-0 flex-1 truncate font-medium", children: item.title || item.approvalId }), _jsx(StatusBadge, { status: item.status })] }), item.status === 'pending' && !finished ? (_jsxs("div", { className: "mt-2 flex gap-1.5", children: [_jsx(Button, { size: "xs", onClick: () => decide(item.approvalId, 'approve'), children: "Approve" }), _jsx(Button, { size: "xs", variant: "outline", onClick: () => decide(item.approvalId, 'reject'), children: "Reject" })] })) : null] }, item.approvalId))) }));
 }

package/dist/approval/effects.d.ts

@@ -116,6 +116,11 @@ export declare const requestApprovalEffect: NoInfer<import("@swirls/looms/core")
         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: {
@@ -127,6 +132,12 @@ export declare const requestApprovalEffect: NoInfer<import("@swirls/looms/core")
         readonly output: import("effect/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: {
@@ -159,6 +170,7 @@ export declare const requestApprovalEffect: NoInfer<import("@swirls/looms/core")
     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/approval/module.d.ts

@@ -138,6 +138,11 @@ export declare function approval(): import("@swirls/looms/core").RuntimeModule<"
             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: {
@@ -149,6 +154,12 @@ export declare function approval(): import("@swirls/looms/core").RuntimeModule<"
             readonly output: import("effect/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: {
@@ -181,6 +192,7 @@ export declare function approval(): import("@swirls/looms/core").RuntimeModule<"
         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";
@@ -372,6 +384,11 @@ export declare function approval(): import("@swirls/looms/core").RuntimeModule<"
                 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: {
@@ -383,6 +400,12 @@ export declare function approval(): import("@swirls/looms/core").RuntimeModule<"
                 readonly output: import("effect/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: {
@@ -415,6 +438,7 @@ export declare function approval(): import("@swirls/looms/core").RuntimeModule<"
             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";