@swirls/looms 0.1.0 → 0.3.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. */
@@ -35,6 +40,8 @@ interface AgentSessionSignalClient<Result> {
     signal(runId: string, events: ReadonlyArray<EventInput>): Promise<Result>;
     cancel?(runId: string, threadId?: string): Promise<Result>;
 }
+/** Events for one session message. A steer aimed at `activeChildThreadId` interrupts that turn in the same batch. */
+export declare function agentSessionMessageEvents(messageId: string, text: string, options?: AgentSessionMessageOptions): EventInput[];
 export declare function sendAgentSessionMessage<Result>(client: AgentSessionSignalClient<Result>, runId: string, messageId: string, text: string, options?: Omit<AgentSessionMessageOptions, 'activeChildThreadId'>): Promise<Result>;
 export declare function cancelActiveAgentTurn<Result>(client: AgentSessionSignalClient<Result>, runId: string, options?: AgentSignalOptions): Promise<Result | Awaited<ReturnType<AgentSessionSignalClient<Result>['getRun']>>>;
 export {};

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,
@@ -54,26 +61,28 @@ function activeTurnFrom(value) {
         }
         : null;
 }
+/** Events for one session message. A steer aimed at `activeChildThreadId` interrupts that turn in the same batch. */
+export function agentSessionMessageEvents(messageId, text, options = {}) {
+    const events = [submitAgentMessage(messageId, text, options)];
+    if (options.delivery === 'steer' && options.activeChildThreadId) {
+        events.push(agentModule.input('steered', {
+            turn: 0,
+            messageId,
+            message: { role: 'user', content: text },
+            interrupt: true,
+        }, { threadId: options.activeChildThreadId }));
+    }
+    return events;
+}
 export function sendAgentSessionMessage(client, runId, messageId, text, options = {}) {
     return client.getRun(runId).then((run) => {
         const threadId = options.threadId ?? run.rootThreadId ?? undefined;
         const active = options.delivery === 'steer' && threadId ? activeTurnFrom(run.threads[threadId]?.state) : null;
-        const events = [
-            submitAgentMessage(messageId, text, {
-                ...options,
-                threadId,
-                activeChildThreadId: active?.childThreadId,
-            }),
-        ];
-        if (active) {
-            events.push(agentModule.input('steered', {
-                turn: 0,
-                messageId,
-                message: { role: 'user', content: text },
-                interrupt: true,
-            }, { threadId: active.childThreadId }));
-        }
-        return client.signal(runId, events);
+        return client.signal(runId, agentSessionMessageEvents(messageId, text, {
+            ...options,
+            threadId,
+            activeChildThreadId: active?.childThreadId,
+        }));
     });
 }
 export function cancelActiveAgentTurn(client, runId, options = {}) {

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/tool-schema.d.ts

@@ -1,21 +1,5 @@
-import { Schema } from 'effect';
-import type { JsonValue, SchemaInput } from '@swirls/looms/core';
+import { type JsonValue } from '@swirls/looms/core';
 import { type AgentToolEntry, type ToolLike } from './definitions';
 import type { LlmToolSpec } from './llm';
-interface StandardJsonSchemaConverter {
-    readonly input: (options: {
-        target: string;
-    }) => JsonValue;
-}
-interface StandardJsonSchemaHolder {
-    readonly '~standard': {
-        readonly jsonSchema?: {
-            readonly input?: StandardJsonSchemaConverter['input'];
-        };
-    };
-}
-type SchemaCandidate = SchemaInput | StandardJsonSchemaHolder | Schema.Codec<JsonValue>;
 export declare function toolJsonSchema(tool: ToolLike): JsonValue;
 export declare function toolSpecs(tools?: ReadonlyArray<AgentToolEntry>): LlmToolSpec[];
-export declare function jsonSchemaFromStandard(schema: SchemaCandidate | null | undefined): JsonValue;
-export {};

package/dist/agent/tool-schema.js

@@ -1,43 +1,7 @@
-import { Schema } from 'effect';
+import { jsonSchemaOfInput } from '@swirls/looms/core';
 import { normalizeTools } from './definitions.js';
 const EMPTY_OBJECT_SCHEMA = { type: 'object' };
-function isStandardJsonSchemaHolder(value) {
-    return '~standard' in value;
-}
-function fromStandardJsonSchema(schema) {
-    if (!isStandardJsonSchemaHolder(schema)) {
-        return undefined;
-    }
-    const input = schema['~standard'].jsonSchema?.input;
-    if (!input) {
-        return undefined;
-    }
-    try {
-        return input({ target: 'draft-2020-12' });
-    }
-    catch {
-        return undefined;
-    }
-}
-function fromEffectSchema(schema) {
-    if (!Schema.isSchema(schema)) {
-        return undefined;
-    }
-    try {
-        const standard = Schema.toStandardJSONSchemaV1(schema);
-        return fromStandardJsonSchema(standard);
-    }
-    catch {
-        return undefined;
-    }
-}
-function fromInputCandidate(input) {
-    if (!input) {
-        return undefined;
-    }
-    return fromStandardJsonSchema(input) ?? fromEffectSchema(input);
-}
-function toolInputCandidate(tool) {
+function toolInput(tool) {
     switch (tool.kind) {
         case 'function':
             return tool.input;
@@ -52,7 +16,7 @@ function toolInputCandidate(tool) {
     }
 }
 export function toolJsonSchema(tool) {
-    return tool.inputSchema ?? fromInputCandidate(toolInputCandidate(tool)) ?? EMPTY_OBJECT_SCHEMA;
+    return jsonSchemaOfInput(toolInput(tool)) ?? EMPTY_OBJECT_SCHEMA;
 }
 export function toolSpecs(tools = []) {
     return normalizeTools(tools).map((tool) => ({
@@ -61,6 +25,3 @@ export function toolSpecs(tools = []) {
         inputJsonSchema: toolJsonSchema(tool),
     }));
 }
-export function jsonSchemaFromStandard(schema) {
-    return fromInputCandidate(schema ?? undefined) ?? EMPTY_OBJECT_SCHEMA;
-}

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/ai-vercel/index.d.ts

@@ -1,3 +1,3 @@
 export { vercelLlm, type VercelLlmOptions } from './vercel-llm';
-export { toEvaluatorAnswers, vercelEvaluator, type VercelEvaluatorOptions, } from './vercel-evaluator';
+export { toEvaluatorAnswers, vercelEvaluator, type EvaluationModelProvider, type VercelEvaluatorOptions, } from './vercel-evaluator';
 export { toLoomsToolCalls, toModelMessages } from './messages';

package/dist/ai-vercel/vercel-evaluator.d.ts

@@ -1,16 +1,29 @@
+import { experimental_evaluate } from 'ai';
 import type { EvaluatorAdapter, EvaluatorAnswers, EvaluatorQuestions } from '@swirls/looms/evaluator';
-export interface VercelEvaluatorOptions {
-    /** Model id understood by the AI SDK evaluate API. Defaults to TypeSafe Jev. */
-    readonly model?: string;
+type EvaluateOptions = Parameters<typeof experimental_evaluate>[0];
+type EvaluationModel = Exclude<EvaluateOptions['model'], string>;
+/** An AI SDK provider with evaluation models, such as `createTypeSafeAi({ apiKey })`. */
+export interface EvaluationModelProvider {
+    readonly evaluationModel: (modelId: string) => EvaluationModel;
+}
+interface VercelEvaluatorBaseOptions {
     /** Abort the hosted call after this many milliseconds. Defaults to 2000. */
     readonly timeoutMs?: number;
-    readonly providerOptions?: {
-        readonly gateway?: {
-            readonly zeroDataRetention?: boolean;
-        };
-    };
+    /** Defaults to AI Gateway zero data retention when no `provider` is set. */
+    readonly providerOptions?: EvaluateOptions['providerOptions'];
 }
+export type VercelEvaluatorOptions = VercelEvaluatorBaseOptions & ({
+    /** AI Gateway model id. Defaults to TypeSafe Jev (`typesafe-ai/jev`). */
+    readonly model?: string;
+    readonly provider?: undefined;
+} | {
+    /** Default model id for `provider`. A definition's own `model` takes precedence. */
+    readonly model: string;
+    /** Resolves model ids with your own provider and key instead of the AI Gateway. */
+    readonly provider: EvaluationModelProvider;
+});
 interface EvaluateAnswer {
+    readonly type?: 'boolean' | 'choice' | 'score';
     readonly probability?: number;
     readonly choice?: string;
     readonly score?: number;

package/dist/ai-vercel/vercel-evaluator.js

@@ -44,11 +44,16 @@ export function toEvaluatorAnswers(questions, raw) {
 }
 export function vercelEvaluator(options = {}) {
     const timeoutMs = options.timeoutMs ?? 2000;
-    const providerOptions = options.providerOptions ?? { gateway: { zeroDataRetention: true } };
+    const providerOptions = options.providerOptions ??
+        (options.provider ? undefined : { gateway: { zeroDataRetention: true } });
+    function resolveModel(modelId) {
+        const id = modelId ?? options.model ?? DEFAULT_EVALUATOR_MODEL;
+        return options.provider ? options.provider.evaluationModel(id) : id;
+    }
     return {
         evaluate: (args) => Effect.runPromise(Effect.tryPromise({
             try: () => experimental_evaluate({
-                model: args.model ?? options.model ?? DEFAULT_EVALUATOR_MODEL,
+                model: resolveModel(args.model),
                 state: args.state,
                 abortSignal: abortSignalFor(timeoutMs, args.signal),
                 maxRetries: 0,

package/dist/approval/debugger/approvals-view.d.ts

@@ -0,0 +1,3 @@
+export declare function ApprovalsView({ runId }: {
+    runId: string;
+}): import("react").JSX.Element;

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

@@ -0,0 +1,18 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Button, StatusBadge, useDebugger } from '@swirls/looms/debugger';
+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 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' && !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/debugger/index.d.ts

@@ -0,0 +1,4 @@
+import type { DebuggerPlugin } from '@swirls/looms/debugger';
+import { ApprovalsView } from './approvals-view';
+export declare const approvalDebugger: DebuggerPlugin;
+export { ApprovalsView };

package/dist/approval/debugger/index.js

@@ -0,0 +1,11 @@
+import { pendingApprovals } from '../projections.js';
+import { ApprovalsView } from './approvals-view.js';
+import { summarizeApprovalEvent } from './summarize.js';
+export const approvalDebugger = {
+    name: 'approval',
+    families: [
+        { family: 'approval', color: 'oklch(0.72 0.15 45)', summarize: summarizeApprovalEvent },
+    ],
+    projections: [{ name: pendingApprovals.name, component: ApprovalsView }],
+};
+export { ApprovalsView };

package/dist/approval/debugger/summarize.d.ts

@@ -0,0 +1,2 @@
+import { type DebuggerEvent, type EventSummary } from '@swirls/looms/debugger';
+export declare function summarizeApprovalEvent(event: DebuggerEvent): EventSummary | undefined;

package/dist/approval/debugger/summarize.js

@@ -0,0 +1,17 @@
+import { jsonFields, jsonText } from '@swirls/looms/debugger';
+export function summarizeApprovalEvent(event) {
+    const payload = jsonFields(event.payload);
+    switch (event.type) {
+        case 'approval.requested':
+            return { title: 'approval requested', detail: jsonText(payload.title) };
+        case 'approval.decided':
+            return {
+                title: `approval ${jsonText(payload.outcome) ?? 'decided'}`,
+                detail: jsonText(payload.approvalId),
+            };
+        case 'approval.timed_out':
+            return { title: 'approval timed out', detail: jsonText(payload.approvalId) };
+        default:
+            return undefined;
+    }
+}

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";