@swirls/looms 0.0.2 → 0.2.0

package/dist/agent/module.js

@@ -1,5 +1,6 @@
-import { Layer } from 'effect';
-import { defineModule } from '@swirls/looms/core';
+import { Layer, Predicate } from 'effect';
+import { defineModule, makeDefinitionStore } from '@swirls/looms/core';
+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';
@@ -8,12 +9,17 @@ import { agentModule } from './scope.js';
 import { agentThread } from './threads.js';
 export function agent(options = {}) {
     const definitions = options.definitions ?? [];
+    const agentDefinitions = definitions.filter((definition) => definition.kind === 'agent');
+    const sessionDefinitions = makeDefinitionStore('agent-session', definitions.filter((definition) => definition.kind === 'agent-session'));
     const llmLayer = options.llm
         ? Layer.succeed(LlmTag, llmFromAdapter(options.llm))
         : StubLlmLive(options.llmPolicy);
     return defineModule(agentModule, () => ({
         definitions,
-        threads: { agent: agentThread },
+        threads: {
+            agent: agentThread,
+            'agent-session': createAgentSessionThread(sessionDefinitions),
+        },
         effects: {
             callLLM: callLlmEffect,
             executeTool: executeToolEffect,
@@ -22,6 +28,12 @@ export function agent(options = {}) {
             conversation,
             tokenUsage,
         },
-        services: () => Layer.merge(llmLayer, AgentDefinitionsLive(definitions)),
+        services: () => Layer.merge(llmLayer, AgentDefinitionsLive(agentDefinitions)),
+        interruptsOnSignal: (event) => event.type === 'agent.steered' &&
+            Predicate.isObject(event.payload) &&
+            event.payload.interrupt === true &&
+            event.threadId
+            ? [event.threadId]
+            : [],
     }));
 }

package/dist/agent/scope.d.ts

@@ -14,14 +14,14 @@ export declare const agentModule: import("@swirls/looms/core").ModuleScope<"agen
         }>;
     }>;
     'turn.started': import("effect/Schema").Struct<{
-        readonly turn: import("effect/Schema").Number;
+        readonly turn: import("effect/Schema").Finite;
     }>;
     'turn.text_delta': import("effect/Schema").Struct<{
-        readonly turn: import("effect/Schema").Number;
+        readonly turn: import("effect/Schema").Finite;
         readonly delta: import("effect/Schema").String;
     }>;
     message: import("effect/Schema").Struct<{
-        readonly turn: import("effect/Schema").Number;
+        readonly turn: import("effect/Schema").Finite;
         readonly message: import("effect/Schema").Struct<{
             readonly role: import("effect/Schema").Union<readonly [import("effect/Schema").Literal<"system">, import("effect/Schema").Literal<"user">, import("effect/Schema").Literal<"assistant">, import("effect/Schema").Literal<"tool">]>;
             readonly content: import("effect/Schema").String;
@@ -34,12 +34,12 @@ export declare const agentModule: import("@swirls/looms/core").ModuleScope<"agen
             }>>>>;
         }>;
         readonly usage: import("effect/Schema").optional<import("effect/Schema").Struct<{
-            readonly input: import("effect/Schema").Number;
-            readonly output: import("effect/Schema").Number;
+            readonly input: import("effect/Schema").Finite;
+            readonly output: import("effect/Schema").Finite;
         }>>;
     }>;
     'tool_call.requested': import("effect/Schema").Struct<{
-        readonly turn: import("effect/Schema").Number;
+        readonly turn: import("effect/Schema").Finite;
         readonly toolCall: import("effect/Schema").Struct<{
             readonly id: import("effect/Schema").String;
             readonly name: import("effect/Schema").String;
@@ -47,14 +47,15 @@ export declare const agentModule: import("@swirls/looms/core").ModuleScope<"agen
         }>;
     }>;
     'tool.result': import("effect/Schema").Struct<{
-        readonly turn: import("effect/Schema").Number;
+        readonly turn: import("effect/Schema").Finite;
         readonly toolCallId: import("effect/Schema").String;
         readonly name: import("effect/Schema").String;
         readonly result: import("effect/Schema").NullOr<import("effect/Schema").Codec<import("effect/Schema").Json, import("effect/Schema").Json, never, never>>;
         readonly error: import("effect/Schema").NullOr<import("effect/Schema").String>;
     }>;
     steered: import("effect/Schema").Struct<{
-        readonly turn: import("effect/Schema").Number;
+        readonly turn: import("effect/Schema").Finite;
+        readonly messageId: import("effect/Schema").optional<import("effect/Schema").String>;
         readonly message: import("effect/Schema").Struct<{
             readonly role: import("effect/Schema").Union<readonly [import("effect/Schema").Literal<"system">, import("effect/Schema").Literal<"user">, import("effect/Schema").Literal<"assistant">, import("effect/Schema").Literal<"tool">]>;
             readonly content: import("effect/Schema").String;
@@ -68,16 +69,93 @@ export declare const agentModule: import("@swirls/looms/core").ModuleScope<"agen
         }>;
         readonly interrupt: import("effect/Schema").optional<import("effect/Schema").Boolean>;
     }>;
+    'session.message.submitted': import("effect/Schema").Struct<{
+        readonly messageId: import("effect/Schema").String;
+        readonly text: import("effect/Schema").String;
+        readonly delivery: import("effect/Schema").optional<import("effect/Schema").Union<readonly [import("effect/Schema").Literal<"steer">, import("effect/Schema").Literal<"followUp">, import("effect/Schema").Literal<"nextTurn">]>>;
+        readonly activeChildThreadId: import("effect/Schema").optional<import("effect/Schema").String>;
+    }>;
+    'session.steer.delivered': import("effect/Schema").Struct<{
+        readonly messageId: import("effect/Schema").String;
+        readonly activeMessageId: import("effect/Schema").String;
+    }>;
+    'session.turn.started': import("effect/Schema").Struct<{
+        readonly messageId: import("effect/Schema").String;
+        readonly childThreadId: import("effect/Schema").String;
+    }>;
+    'session.turn.closed': import("effect/Schema").Struct<{
+        readonly messageId: import("effect/Schema").String;
+        readonly status: import("effect/Schema").Union<readonly [import("effect/Schema").Literal<"completed">, import("effect/Schema").Literal<"failed">, import("effect/Schema").Literal<"cancelled">]>;
+        readonly error: import("effect/Schema").optional<import("effect/Schema").String>;
+    }>;
+    'session.cancel.requested': import("effect/Schema").Struct<{}>;
     'spawn.requested': import("effect/Schema").Struct<{
         readonly childThreadId: import("effect/Schema").String;
         readonly kind: import("effect/Schema").String;
         readonly definitionName: import("effect/Schema").String;
+        readonly definitionVersion: import("effect/Schema").withDecodingDefaultKey<import("effect/Schema").String, never>;
         readonly toolCallId: import("effect/Schema").String;
         readonly input: import("effect/Schema").Codec<import("effect/Schema").Json, import("effect/Schema").Json, never, never>;
     }>;
     'effects.requested': import("effect/Schema").Struct<{
         readonly toolCallId: import("effect/Schema").String;
-        readonly effects: import("effect/Schema").$Array<import("effect/Schema").Schema<import("@swirls/looms/core").RuntimeEffect>>;
+        readonly effects: import("effect/Schema").$Array<import("effect/Schema").Union<readonly [import("effect/Schema").Struct<{
+            readonly type: import("effect/Schema").Literal<"runtime.spawn">;
+            readonly childThreadId: import("effect/Schema").String;
+            readonly kind: import("effect/Schema").String;
+            readonly definitionName: import("effect/Schema").String;
+            readonly definitionVersion: import("effect/Schema").withDecodingDefaultKey<import("effect/Schema").String, never>;
+            readonly input: import("effect/Schema").Codec<import("effect/Schema").Json, import("effect/Schema").Json, never, never>;
+        }>, import("effect/Schema").Struct<{
+            readonly type: import("effect/Schema").Literal<"runtime.wait">;
+            readonly waitId: import("effect/Schema").String;
+            readonly on: import("effect/Schema").Union<readonly [import("effect/Schema").Struct<{
+                readonly type: import("effect/Schema").Union<readonly [import("effect/Schema").String, import("effect/Schema").$Array<import("effect/Schema").String>]>;
+                readonly match: import("effect/Schema").optional<import("effect/Schema").Codec<import("effect/Schema").Json, import("effect/Schema").Json, never, never>>;
+            }>, import("effect/Schema").Struct<{
+                readonly timerAt: import("effect/Schema").Finite;
+            }>]>;
+            readonly tag: import("effect/Schema").optional<import("effect/Schema").Codec<import("effect/Schema").Json, import("effect/Schema").Json, never, never>>;
+        }>, import("effect/Schema").Struct<{
+            readonly type: import("effect/Schema").Literal<"runtime.emit">;
+            readonly event: import("effect/Schema").Struct<{
+                readonly type: import("effect/Schema").String;
+                readonly payload: import("effect/Schema").Codec<import("effect/Schema").Json, import("effect/Schema").Json, never, never>;
+                readonly threadId: import("effect/Schema").optional<import("effect/Schema").NullOr<import("effect/Schema").String>>;
+                readonly parentThreadId: import("effect/Schema").optional<import("effect/Schema").NullOr<import("effect/Schema").String>>;
+                readonly causationId: import("effect/Schema").optional<import("effect/Schema").NullOr<import("effect/Schema").String>>;
+                readonly correlationId: import("effect/Schema").optional<import("effect/Schema").NullOr<import("effect/Schema").String>>;
+                readonly effectId: import("effect/Schema").optional<import("effect/Schema").NullOr<import("effect/Schema").String>>;
+                readonly origin: import("effect/Schema").optional<import("effect/Schema").Union<readonly [import("effect/Schema").Struct<{
+                    readonly type: import("effect/Schema").Literal<"thread">;
+                    readonly threadId: import("effect/Schema").String;
+                }>, import("effect/Schema").Struct<{
+                    readonly type: import("effect/Schema").Literal<"external">;
+                    readonly actorId: import("effect/Schema").optional<import("effect/Schema").String>;
+                }>, import("effect/Schema").Struct<{
+                    readonly type: import("effect/Schema").Literal<"system">;
+                }>]>>;
+                readonly ephemeral: import("effect/Schema").optional<import("effect/Schema").Boolean>;
+                readonly id: import("effect/Schema").optional<import("effect/Schema").String>;
+                readonly ts: import("effect/Schema").optional<import("effect/Schema").Finite>;
+                readonly idempotencyKey: import("effect/Schema").optional<import("effect/Schema").NullOr<import("effect/Schema").String>>;
+            }>;
+            readonly tag: import("effect/Schema").optional<import("effect/Schema").String>;
+        }>, import("effect/Schema").Struct<{
+            readonly type: import("effect/Schema").Literal<"runtime.complete">;
+            readonly output: import("effect/Schema").Codec<import("effect/Schema").Json, import("effect/Schema").Json, never, never>;
+        }>, import("effect/Schema").Struct<{
+            readonly type: import("effect/Schema").Literal<"runtime.fail">;
+            readonly error: import("effect/Schema").String;
+        }>, import("effect/Schema").Struct<{
+            readonly type: import("effect/Schema").Literal<"runtime.cancel">;
+            readonly threadId: import("effect/Schema").String;
+            readonly tag: import("effect/Schema").optional<import("effect/Schema").String>;
+        }>, import("effect/Schema").Struct<{
+            readonly type: import("effect/Schema").String;
+            readonly input: import("effect/Schema").Codec<import("effect/Schema").Json, import("effect/Schema").Json, never, never>;
+            readonly tag: import("effect/Schema").optional<import("effect/Schema").String>;
+        }>]>>;
         readonly waitOn: import("effect/Schema").optional<import("effect/Schema").Struct<{
             readonly type: import("effect/Schema").Union<readonly [import("effect/Schema").String, import("effect/Schema").$Array<import("effect/Schema").String>]>;
             readonly match: import("effect/Schema").optional<import("effect/Schema").Codec<import("effect/Schema").Json, import("effect/Schema").Json, never, never>>;
@@ -98,14 +176,14 @@ export declare const agentModule: import("@swirls/looms/core").ModuleScope<"agen
         }>;
     }>;
     'turn.started': import("effect/Schema").Struct<{
-        readonly turn: import("effect/Schema").Number;
+        readonly turn: import("effect/Schema").Finite;
     }>;
     'turn.text_delta': import("effect/Schema").Struct<{
-        readonly turn: import("effect/Schema").Number;
+        readonly turn: import("effect/Schema").Finite;
         readonly delta: import("effect/Schema").String;
     }>;
     message: import("effect/Schema").Struct<{
-        readonly turn: import("effect/Schema").Number;
+        readonly turn: import("effect/Schema").Finite;
         readonly message: import("effect/Schema").Struct<{
             readonly role: import("effect/Schema").Union<readonly [import("effect/Schema").Literal<"system">, import("effect/Schema").Literal<"user">, import("effect/Schema").Literal<"assistant">, import("effect/Schema").Literal<"tool">]>;
             readonly content: import("effect/Schema").String;
@@ -118,12 +196,12 @@ export declare const agentModule: import("@swirls/looms/core").ModuleScope<"agen
             }>>>>;
         }>;
         readonly usage: import("effect/Schema").optional<import("effect/Schema").Struct<{
-            readonly input: import("effect/Schema").Number;
-            readonly output: import("effect/Schema").Number;
+            readonly input: import("effect/Schema").Finite;
+            readonly output: import("effect/Schema").Finite;
         }>>;
     }>;
     'tool_call.requested': import("effect/Schema").Struct<{
-        readonly turn: import("effect/Schema").Number;
+        readonly turn: import("effect/Schema").Finite;
         readonly toolCall: import("effect/Schema").Struct<{
             readonly id: import("effect/Schema").String;
             readonly name: import("effect/Schema").String;
@@ -131,14 +209,15 @@ export declare const agentModule: import("@swirls/looms/core").ModuleScope<"agen
         }>;
     }>;
     'tool.result': import("effect/Schema").Struct<{
-        readonly turn: import("effect/Schema").Number;
+        readonly turn: import("effect/Schema").Finite;
         readonly toolCallId: import("effect/Schema").String;
         readonly name: import("effect/Schema").String;
         readonly result: import("effect/Schema").NullOr<import("effect/Schema").Codec<import("effect/Schema").Json, import("effect/Schema").Json, never, never>>;
         readonly error: import("effect/Schema").NullOr<import("effect/Schema").String>;
     }>;
     steered: import("effect/Schema").Struct<{
-        readonly turn: import("effect/Schema").Number;
+        readonly turn: import("effect/Schema").Finite;
+        readonly messageId: import("effect/Schema").optional<import("effect/Schema").String>;
         readonly message: import("effect/Schema").Struct<{
             readonly role: import("effect/Schema").Union<readonly [import("effect/Schema").Literal<"system">, import("effect/Schema").Literal<"user">, import("effect/Schema").Literal<"assistant">, import("effect/Schema").Literal<"tool">]>;
             readonly content: import("effect/Schema").String;
@@ -152,16 +231,93 @@ export declare const agentModule: import("@swirls/looms/core").ModuleScope<"agen
         }>;
         readonly interrupt: import("effect/Schema").optional<import("effect/Schema").Boolean>;
     }>;
+    'session.message.submitted': import("effect/Schema").Struct<{
+        readonly messageId: import("effect/Schema").String;
+        readonly text: import("effect/Schema").String;
+        readonly delivery: import("effect/Schema").optional<import("effect/Schema").Union<readonly [import("effect/Schema").Literal<"steer">, import("effect/Schema").Literal<"followUp">, import("effect/Schema").Literal<"nextTurn">]>>;
+        readonly activeChildThreadId: import("effect/Schema").optional<import("effect/Schema").String>;
+    }>;
+    'session.steer.delivered': import("effect/Schema").Struct<{
+        readonly messageId: import("effect/Schema").String;
+        readonly activeMessageId: import("effect/Schema").String;
+    }>;
+    'session.turn.started': import("effect/Schema").Struct<{
+        readonly messageId: import("effect/Schema").String;
+        readonly childThreadId: import("effect/Schema").String;
+    }>;
+    'session.turn.closed': import("effect/Schema").Struct<{
+        readonly messageId: import("effect/Schema").String;
+        readonly status: import("effect/Schema").Union<readonly [import("effect/Schema").Literal<"completed">, import("effect/Schema").Literal<"failed">, import("effect/Schema").Literal<"cancelled">]>;
+        readonly error: import("effect/Schema").optional<import("effect/Schema").String>;
+    }>;
+    'session.cancel.requested': import("effect/Schema").Struct<{}>;
     'spawn.requested': import("effect/Schema").Struct<{
         readonly childThreadId: import("effect/Schema").String;
         readonly kind: import("effect/Schema").String;
         readonly definitionName: import("effect/Schema").String;
+        readonly definitionVersion: import("effect/Schema").withDecodingDefaultKey<import("effect/Schema").String, never>;
         readonly toolCallId: import("effect/Schema").String;
         readonly input: import("effect/Schema").Codec<import("effect/Schema").Json, import("effect/Schema").Json, never, never>;
     }>;
     'effects.requested': import("effect/Schema").Struct<{
         readonly toolCallId: import("effect/Schema").String;
-        readonly effects: import("effect/Schema").$Array<import("effect/Schema").Schema<import("@swirls/looms/core").RuntimeEffect>>;
+        readonly effects: import("effect/Schema").$Array<import("effect/Schema").Union<readonly [import("effect/Schema").Struct<{
+            readonly type: import("effect/Schema").Literal<"runtime.spawn">;
+            readonly childThreadId: import("effect/Schema").String;
+            readonly kind: import("effect/Schema").String;
+            readonly definitionName: import("effect/Schema").String;
+            readonly definitionVersion: import("effect/Schema").withDecodingDefaultKey<import("effect/Schema").String, never>;
+            readonly input: import("effect/Schema").Codec<import("effect/Schema").Json, import("effect/Schema").Json, never, never>;
+        }>, import("effect/Schema").Struct<{
+            readonly type: import("effect/Schema").Literal<"runtime.wait">;
+            readonly waitId: import("effect/Schema").String;
+            readonly on: import("effect/Schema").Union<readonly [import("effect/Schema").Struct<{
+                readonly type: import("effect/Schema").Union<readonly [import("effect/Schema").String, import("effect/Schema").$Array<import("effect/Schema").String>]>;
+                readonly match: import("effect/Schema").optional<import("effect/Schema").Codec<import("effect/Schema").Json, import("effect/Schema").Json, never, never>>;
+            }>, import("effect/Schema").Struct<{
+                readonly timerAt: import("effect/Schema").Finite;
+            }>]>;
+            readonly tag: import("effect/Schema").optional<import("effect/Schema").Codec<import("effect/Schema").Json, import("effect/Schema").Json, never, never>>;
+        }>, import("effect/Schema").Struct<{
+            readonly type: import("effect/Schema").Literal<"runtime.emit">;
+            readonly event: import("effect/Schema").Struct<{
+                readonly type: import("effect/Schema").String;
+                readonly payload: import("effect/Schema").Codec<import("effect/Schema").Json, import("effect/Schema").Json, never, never>;
+                readonly threadId: import("effect/Schema").optional<import("effect/Schema").NullOr<import("effect/Schema").String>>;
+                readonly parentThreadId: import("effect/Schema").optional<import("effect/Schema").NullOr<import("effect/Schema").String>>;
+                readonly causationId: import("effect/Schema").optional<import("effect/Schema").NullOr<import("effect/Schema").String>>;
+                readonly correlationId: import("effect/Schema").optional<import("effect/Schema").NullOr<import("effect/Schema").String>>;
+                readonly effectId: import("effect/Schema").optional<import("effect/Schema").NullOr<import("effect/Schema").String>>;
+                readonly origin: import("effect/Schema").optional<import("effect/Schema").Union<readonly [import("effect/Schema").Struct<{
+                    readonly type: import("effect/Schema").Literal<"thread">;
+                    readonly threadId: import("effect/Schema").String;
+                }>, import("effect/Schema").Struct<{
+                    readonly type: import("effect/Schema").Literal<"external">;
+                    readonly actorId: import("effect/Schema").optional<import("effect/Schema").String>;
+                }>, import("effect/Schema").Struct<{
+                    readonly type: import("effect/Schema").Literal<"system">;
+                }>]>>;
+                readonly ephemeral: import("effect/Schema").optional<import("effect/Schema").Boolean>;
+                readonly id: import("effect/Schema").optional<import("effect/Schema").String>;
+                readonly ts: import("effect/Schema").optional<import("effect/Schema").Finite>;
+                readonly idempotencyKey: import("effect/Schema").optional<import("effect/Schema").NullOr<import("effect/Schema").String>>;
+            }>;
+            readonly tag: import("effect/Schema").optional<import("effect/Schema").String>;
+        }>, import("effect/Schema").Struct<{
+            readonly type: import("effect/Schema").Literal<"runtime.complete">;
+            readonly output: import("effect/Schema").Codec<import("effect/Schema").Json, import("effect/Schema").Json, never, never>;
+        }>, import("effect/Schema").Struct<{
+            readonly type: import("effect/Schema").Literal<"runtime.fail">;
+            readonly error: import("effect/Schema").String;
+        }>, import("effect/Schema").Struct<{
+            readonly type: import("effect/Schema").Literal<"runtime.cancel">;
+            readonly threadId: import("effect/Schema").String;
+            readonly tag: import("effect/Schema").optional<import("effect/Schema").String>;
+        }>, import("effect/Schema").Struct<{
+            readonly type: import("effect/Schema").String;
+            readonly input: import("effect/Schema").Codec<import("effect/Schema").Json, import("effect/Schema").Json, never, never>;
+            readonly tag: import("effect/Schema").optional<import("effect/Schema").String>;
+        }>]>>;
         readonly waitOn: import("effect/Schema").optional<import("effect/Schema").Struct<{
             readonly type: import("effect/Schema").Union<readonly [import("effect/Schema").String, import("effect/Schema").$Array<import("effect/Schema").String>]>;
             readonly match: import("effect/Schema").optional<import("effect/Schema").Codec<import("effect/Schema").Json, import("effect/Schema").Json, never, never>>;

package/dist/agent/signals.d.ts

@@ -1,4 +1,5 @@
-import type { EventInput } from '@swirls/looms/core';
+import type { EventInput, JsonValue } from '@swirls/looms/core';
+import type { AgentMessageDelivery } from './types';
 export interface AgentSignalOptions {
     /** Target thread. Defaults to the run's root thread when omitted. */
     readonly threadId?: string;
@@ -15,3 +16,27 @@ export declare function userMessage(content: string, options?: AgentSignalOption
 export declare function steer(content: string, options?: AgentSignalOptions & {
     readonly interrupt?: boolean;
 }): EventInput;
+export interface AgentSessionMessageOptions extends AgentSignalOptions {
+    readonly delivery?: AgentMessageDelivery;
+    /** Set by the client helper when a steer is aimed at an active child. */
+    readonly activeChildThreadId?: string;
+}
+export declare function submitAgentMessage(messageId: string, text: string, options?: AgentSessionMessageOptions): EventInput;
+export declare function cancelAgentTurn(childThreadId: string, options?: AgentSignalOptions): EventInput[];
+interface AgentSessionSignalClient<Result> {
+    getRun(runId: string): Promise<{
+        rootThreadId: string | null;
+        threads: {
+            [threadId: string]: {
+                state: JsonValue;
+            };
+        };
+    }>;
+    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

@@ -1,3 +1,4 @@
+import { Predicate } from 'effect';
 import { agentModule } from './scope.js';
 /**
  * Build the `agent.message.received` event for a conversational agent.
@@ -17,3 +18,81 @@ export function steer(content, options = {}) {
         message: { role: 'user', content },
     }, { threadId: options.threadId });
 }
+export function submitAgentMessage(messageId, text, options = {}) {
+    return agentModule.input('session.message.submitted', {
+        messageId,
+        text,
+        delivery: options.delivery,
+        activeChildThreadId: options.activeChildThreadId,
+    }, {
+        threadId: options.threadId,
+        idempotencyKey: `agent-session-message:${messageId}`,
+    });
+}
+export function cancelAgentTurn(childThreadId, options = {}) {
+    return [
+        agentModule.input('session.cancel.requested', {}, { threadId: options.threadId }),
+        {
+            type: 'runtime.thread.cancel.requested',
+            payload: { threadId: childThreadId },
+            threadId: options.threadId,
+        },
+    ];
+}
+function activeTurnFrom(value) {
+    if (!Predicate.isObject(value) || !Predicate.isObject(value.activeTurn)) {
+        return null;
+    }
+    const activeTurn = value.activeTurn;
+    return Predicate.isString(activeTurn.messageId) &&
+        Predicate.isString(activeTurn.childThreadId) &&
+        Predicate.isString(activeTurn.text)
+        ? {
+            messageId: activeTurn.messageId,
+            childThreadId: activeTurn.childThreadId,
+            text: activeTurn.text,
+        }
+        : 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;
+        return client.signal(runId, agentSessionMessageEvents(messageId, text, {
+            ...options,
+            threadId,
+            activeChildThreadId: active?.childThreadId,
+        }));
+    });
+}
+export function cancelActiveAgentTurn(client, runId, options = {}) {
+    return client.getRun(runId).then((run) => {
+        const threadId = options.threadId ?? run.rootThreadId ?? undefined;
+        const active = threadId ? activeTurnFrom(run.threads[threadId]?.state) : null;
+        if (!active) {
+            return run;
+        }
+        if (client.cancel) {
+            const cancel = (targetRunId, childThreadId) => client.cancel(targetRunId, childThreadId);
+            const requested = client.signal(runId, [
+                agentModule.input('session.cancel.requested', {}, { threadId }),
+            ]);
+            const cancelled = cancel(runId, active.childThreadId);
+            return Promise.all([requested, cancelled]).then(([, result]) => result);
+        }
+        return client.signal(runId, cancelAgentTurn(active.childThreadId, { threadId }));
+    });
+}

package/dist/agent/threads.d.ts

@@ -1,34 +1,4 @@
-import { type EventEnvelope, type JsonValue, type RuntimeEffect } from '@swirls/looms/core';
-import { type Message, type ToolCall } from './types';
-export declare const agentThread: import("@swirls/looms/core").ThreadDefinition<{
-    definitionName?: string;
-    lines: Message[];
-    pendingToolCalls: ToolCall[];
-    executingToolCalls: ToolCall[];
-    needsLlmCall: boolean;
-    turn: number;
-    maxTurns: number;
-    pendingSteer: Message | null;
-    input: JsonValue;
-    output: JsonValue | null;
-    pendingEffectTools: {
-        [causingSeq: string]: import("./types").PendingEffectTool;
-    };
-    pendingSpawns: import("./types").AgentPendingSpawn[];
-    pendingEffects: import("./types").AgentPendingEffects[];
-    pendingEmits: (import("./types").AgentPendingEmit | {
-        id: string;
-        event: {
-            type: string;
-            payload: {
-                turn: number;
-                toolCallId: string;
-                name: string;
-                result: string | number | boolean | import("effect/Schema").JsonArray | import("effect/Schema").JsonObject | null;
-                error: string | null;
-            };
-            threadId: string;
-        };
-    })[];
-}>;
+import { type EventEnvelope, type RuntimeEffect } from '@swirls/looms/core';
+import type { AgentState } from './types';
+export declare const agentThread: import("@swirls/looms/core").ThreadDefinition<AgentState>;
 export declare function satisfiedToToolResult(event: EventEnvelope): RuntimeEffect | null;