@swirls/looms 0.4.0 → 0.5.0

package/dist/agent/module.js

@@ -9,7 +9,7 @@ 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 agentDefinitions = makeDefinitionStore('agent', 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))
@@ -31,6 +31,10 @@ export function agent(options = {}) {
         },
         services: () => Layer.merge(llmLayer, AgentDefinitionsLive(agentDefinitions)),
         interruptsOnSignal,
+        bindHost(host) {
+            agentDefinitions.useResolver(host.definitionResolver);
+            sessionDefinitions.useResolver(host.definitionResolver);
+        },
     }));
 }
 /** A stop or an interrupting steer abandons the turn in progress on its thread. */

package/dist/agent/scope.d.ts

@@ -97,6 +97,7 @@ export declare const agentModule: import("@swirls/looms/core").ModuleScope<"agen
         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>;
+        readonly depth: import("effect/Schema").optional<import("effect/Schema").Finite>;
     }>;
     'effects.requested': import("effect/Schema").Struct<{
         readonly toolCallId: import("effect/Schema").String;
@@ -135,6 +136,9 @@ export declare const agentModule: import("@swirls/looms/core").ModuleScope<"agen
                     readonly actorId: import("effect/Schema").optional<import("effect/Schema").String>;
                 }>, import("effect/Schema").Struct<{
                     readonly type: import("effect/Schema").Literal<"system">;
+                }>, import("effect/Schema").Struct<{
+                    readonly type: import("effect/Schema").Literal<"run">;
+                    readonly runId: import("effect/Schema").String;
                 }>]>>;
                 readonly ephemeral: import("effect/Schema").optional<import("effect/Schema").Boolean>;
                 readonly id: import("effect/Schema").optional<import("effect/Schema").String>;
@@ -152,16 +156,56 @@ export declare const agentModule: import("@swirls/looms/core").ModuleScope<"agen
             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").Literal<"runtime.launch">;
+            readonly runId: 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>;
+            readonly close: import("effect/Schema").withDecodingDefaultKey<import("effect/Schema").Union<readonly [import("effect/Schema").Literal<"terminate">, import("effect/Schema").Literal<"wait">]>, never>;
+            readonly tag: import("effect/Schema").optional<import("effect/Schema").String>;
+        }>, import("effect/Schema").Struct<{
+            readonly type: import("effect/Schema").Literal<"runtime.cancelRun">;
+            readonly runId: 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 at: import("effect/Schema").optional<import("effect/Schema").Finite>;
         }>]>>;
         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>>;
         }>>;
     }>;
+    lineage: import("effect/Schema").Struct<{
+        readonly depth: import("effect/Schema").Finite;
+    }>;
+    'context.compacted': import("effect/Schema").Struct<{
+        readonly turn: import("effect/Schema").Finite;
+        readonly originalCount: import("effect/Schema").Finite;
+        readonly compactedCount: import("effect/Schema").Finite;
+        readonly summary: import("effect/Schema").optional<import("effect/Schema").String>;
+        readonly reason: import("effect/Schema").optional<import("effect/Schema").Union<readonly [import("effect/Schema").Literal<"overflow">, import("effect/Schema").Literal<"manual">, import("effect/Schema").Literal<"threshold">]>>;
+        readonly messages: import("effect/Schema").optional<import("effect/Schema").$Array<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;
+            readonly toolCallId: import("effect/Schema").optional<import("effect/Schema").String>;
+            readonly name: import("effect/Schema").optional<import("effect/Schema").String>;
+            readonly toolCalls: import("effect/Schema").optional<import("effect/Schema").mutable<import("effect/Schema").$Array<import("effect/Schema").Struct<{
+                readonly id: import("effect/Schema").String;
+                readonly name: import("effect/Schema").String;
+                readonly arguments: import("effect/Schema").Codec<import("effect/Schema").Json, import("effect/Schema").Json, never, never>;
+            }>>>>;
+        }>>>;
+    }>;
+    'turn.usage': import("effect/Schema").Struct<{
+        readonly turn: import("effect/Schema").Finite;
+        readonly input: import("effect/Schema").Finite;
+        readonly output: import("effect/Schema").Finite;
+    }>;
 }>, undefined>, import("@swirls/looms/core").EventCatalog<"agent", {
     'message.received': import("effect/Schema").Struct<{
         readonly message: import("effect/Schema").Struct<{
@@ -260,6 +304,7 @@ export declare const agentModule: import("@swirls/looms/core").ModuleScope<"agen
         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>;
+        readonly depth: import("effect/Schema").optional<import("effect/Schema").Finite>;
     }>;
     'effects.requested': import("effect/Schema").Struct<{
         readonly toolCallId: import("effect/Schema").String;
@@ -298,6 +343,9 @@ export declare const agentModule: import("@swirls/looms/core").ModuleScope<"agen
                     readonly actorId: import("effect/Schema").optional<import("effect/Schema").String>;
                 }>, import("effect/Schema").Struct<{
                     readonly type: import("effect/Schema").Literal<"system">;
+                }>, import("effect/Schema").Struct<{
+                    readonly type: import("effect/Schema").Literal<"run">;
+                    readonly runId: import("effect/Schema").String;
                 }>]>>;
                 readonly ephemeral: import("effect/Schema").optional<import("effect/Schema").Boolean>;
                 readonly id: import("effect/Schema").optional<import("effect/Schema").String>;
@@ -315,15 +363,55 @@ export declare const agentModule: import("@swirls/looms/core").ModuleScope<"agen
             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").Literal<"runtime.launch">;
+            readonly runId: 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>;
+            readonly close: import("effect/Schema").withDecodingDefaultKey<import("effect/Schema").Union<readonly [import("effect/Schema").Literal<"terminate">, import("effect/Schema").Literal<"wait">]>, never>;
+            readonly tag: import("effect/Schema").optional<import("effect/Schema").String>;
+        }>, import("effect/Schema").Struct<{
+            readonly type: import("effect/Schema").Literal<"runtime.cancelRun">;
+            readonly runId: 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 at: import("effect/Schema").optional<import("effect/Schema").Finite>;
         }>]>>;
         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>>;
         }>>;
     }>;
+    lineage: import("effect/Schema").Struct<{
+        readonly depth: import("effect/Schema").Finite;
+    }>;
+    'context.compacted': import("effect/Schema").Struct<{
+        readonly turn: import("effect/Schema").Finite;
+        readonly originalCount: import("effect/Schema").Finite;
+        readonly compactedCount: import("effect/Schema").Finite;
+        readonly summary: import("effect/Schema").optional<import("effect/Schema").String>;
+        readonly reason: import("effect/Schema").optional<import("effect/Schema").Union<readonly [import("effect/Schema").Literal<"overflow">, import("effect/Schema").Literal<"manual">, import("effect/Schema").Literal<"threshold">]>>;
+        readonly messages: import("effect/Schema").optional<import("effect/Schema").$Array<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;
+            readonly toolCallId: import("effect/Schema").optional<import("effect/Schema").String>;
+            readonly name: import("effect/Schema").optional<import("effect/Schema").String>;
+            readonly toolCalls: import("effect/Schema").optional<import("effect/Schema").mutable<import("effect/Schema").$Array<import("effect/Schema").Struct<{
+                readonly id: import("effect/Schema").String;
+                readonly name: import("effect/Schema").String;
+                readonly arguments: import("effect/Schema").Codec<import("effect/Schema").Json, import("effect/Schema").Json, never, never>;
+            }>>>>;
+        }>>>;
+    }>;
+    'turn.usage': import("effect/Schema").Struct<{
+        readonly turn: import("effect/Schema").Finite;
+        readonly input: import("effect/Schema").Finite;
+        readonly output: import("effect/Schema").Finite;
+    }>;
 }>, undefined>;
 export type AgentEvent = EventOf<typeof agentModule>;

package/dist/agent/threads.js

@@ -1,5 +1,6 @@
 import { Predicate } from 'effect';
-import { cancel, createWaitId, DEFAULT_DEFINITION_VERSION, emit, invoke, isWithdrawnError, parseEffectId, spawn, wait, waitOutcome, } from '@swirls/looms/core';
+import { cancel, createWaitId, DEFAULT_DEFINITION_VERSION, emit, invoke, isJsonObject, isWithdrawnError, parseEffectId, spawn, wait, waitOutcome, } from '@swirls/looms/core';
+import { STRUCTURED_OUTPUT_TOOL_NAME } from './definitions.js';
 import { callLlmEffect, executeToolEffect } from './effects.js';
 import { agentModule } from './scope.js';
 import { closeOpenToolCalls } from './transcript.js';
@@ -67,6 +68,9 @@ export const agentThread = agentModule.thread({
         needsLlmCall: false,
         turn: 0,
         maxTurns: 20,
+        depth: 0,
+        structuredOutput: null,
+        alreadyCompactedTurns: [],
         pendingSteer: null,
         input: ctx.input,
         output: null,
@@ -92,6 +96,8 @@ export const agentThread = agentModule.thread({
                     needsLlmCall: true,
                 };
             }
+            case 'agent.lineage':
+                return { ...state, depth: event.payload.depth };
             case 'agent.turn.started': {
                 return {
                     ...state,
@@ -132,6 +138,11 @@ export const agentThread = agentModule.thread({
                 const pendingEffects = state.pendingEffects.filter((item) => item.toolCallId !== toolCallId);
                 const pendingEmits = state.pendingEmits.filter((item) => item.id !== `res_${toolCallId}`);
                 const content = Predicate.isString(error) && error.length > 0 ? error : JSON.stringify(result ?? null);
+                let structuredOutput = state.structuredOutput;
+                if (name === STRUCTURED_OUTPUT_TOOL_NAME && !error && result !== null) {
+                    structuredOutput =
+                        isJsonObject(result) && 'output' in result ? (result.output ?? null) : result;
+                }
                 const lines = [
                     ...state.lines,
                     {
@@ -145,6 +156,7 @@ export const agentThread = agentModule.thread({
                 return {
                     ...state,
                     lines,
+                    structuredOutput,
                     pendingToolCalls,
                     executingToolCalls,
                     pendingSpawns,
@@ -177,10 +189,21 @@ export const agentThread = agentModule.thread({
                     consumedSteerMessageIds,
                 };
             }
+            case 'agent.context.compacted': {
+                const compactedMessages = event.payload.messages;
+                const alreadyCompactedTurns = state.alreadyCompactedTurns
+                    ? [...state.alreadyCompactedTurns, event.payload.turn]
+                    : [event.payload.turn];
+                return {
+                    ...state,
+                    lines: compactedMessages ? [...compactedMessages] : state.lines,
+                    alreadyCompactedTurns,
+                };
+            }
             case 'agent.turn.stopped':
                 return abandonTurn(state);
             case 'agent.spawn.requested': {
-                const { childThreadId, kind, definitionName, definitionVersion, toolCallId, input } = event.payload;
+                const { childThreadId, kind, definitionName, definitionVersion, toolCallId, input, depth } = event.payload;
                 return {
                     ...state,
                     executingToolCalls: state.executingToolCalls.filter((item) => item.id !== toolCallId),
@@ -194,6 +217,7 @@ export const agentThread = agentModule.thread({
                             toolCallId,
                             // SAFETY: schema-decoded input is JSON
                             input: input ?? null,
+                            depth: depth ?? state.depth + 1,
                         },
                     ],
                 };
@@ -338,6 +362,8 @@ export const agentThread = agentModule.thread({
                 definitionVersion: state.definitionVersion ?? DEFAULT_DEFINITION_VERSION,
                 messages: state.lines,
                 input: state.input,
+                structuredOutput: state.structuredOutput,
+                alreadyCompacted: (state.alreadyCompactedTurns ?? []).includes(state.turn + 1),
                 consumedSteerMessageIds: state.consumedSteerMessageIds,
             }, `llm_turn_${state.turn + 1}`));
         }
@@ -347,6 +373,8 @@ export const agentThread = agentModule.thread({
                 definitionName: state.definitionName,
                 definitionVersion: state.definitionVersion ?? DEFAULT_DEFINITION_VERSION,
                 toolCall,
+                input: state.input,
+                depth: state.depth,
             }, `tool_${toolCall.id}`));
         }
         for (const spawnReq of state.pendingSpawns) {
@@ -357,7 +385,15 @@ export const agentThread = agentModule.thread({
                 definitionName: spawnReq.definitionName,
                 definitionVersion: spawnReq.definitionVersion,
                 input: spawnReq.input,
-            }), wait({
+            }));
+            if (spawnReq.kind === 'agent') {
+                effects.push(emit({
+                    type: 'agent.lineage',
+                    payload: { depth: spawnReq.depth ?? state.depth + 1 },
+                    threadId: spawnReq.childThreadId,
+                }, `lineage_${spawnReq.childThreadId}`));
+            }
+            effects.push(wait({
                 waitId,
                 on: {
                     type: ['runtime.thread.completed', 'runtime.thread.failed'],

package/dist/agent/types.d.ts

@@ -60,6 +60,7 @@ export interface AgentPendingSpawn {
     readonly definitionVersion: string;
     readonly toolCallId: string;
     readonly input: JsonValue;
+    readonly depth?: number;
 }
 export interface AgentPendingEffects {
     readonly toolCallId: string;
@@ -85,6 +86,9 @@ export interface AgentState {
     needsLlmCall: boolean;
     turn: number;
     maxTurns: number;
+    depth: number;
+    structuredOutput?: JsonValue | null;
+    alreadyCompactedTurns?: number[];
     pendingSteer: Message | null;
     input: JsonValue;
     output: JsonValue | null;

package/dist/approval/effects.d.ts

@@ -34,6 +34,19 @@ export declare const requestApprovalEffect: NoInfer<import("@swirls/looms/core")
     readonly payload: {
         readonly approvalId: string;
     };
+}) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+    readonly type: "runtime.child.close.requested";
+    readonly payload: {
+        readonly policy: "terminate" | "wait";
+    };
+}) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+    readonly type: "runtime.child.settled";
+    readonly payload: {
+        readonly runId: string;
+        readonly status: "cancelled" | "completed" | "failed";
+        readonly output: import("effect/Schema").Json;
+        readonly error: string | null;
+    };
 }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
     readonly type: "runtime.effect.ambiguous";
     readonly payload: {
@@ -78,6 +91,8 @@ export declare const requestApprovalEffect: NoInfer<import("@swirls/looms/core")
     readonly payload: {
         readonly effectId: string;
         readonly error: string;
+        readonly nonRetryable?: boolean | undefined;
+        readonly retryAfterMs?: number | undefined;
     };
 }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
     readonly type: "runtime.effect.heartbeat";
@@ -86,6 +101,7 @@ export declare const requestApprovalEffect: NoInfer<import("@swirls/looms/core")
         readonly attempt: number;
         readonly heartbeatAt: number;
         readonly deadlineAt: number | null;
+        readonly details?: import("effect/Schema").Json | undefined;
     };
 }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
     readonly type: "runtime.effect.queued";
@@ -138,6 +154,16 @@ export declare const requestApprovalEffect: NoInfer<import("@swirls/looms/core")
         readonly sourceRunId: string;
         readonly sourceSeq: number;
     };
+}) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+    readonly type: "runtime.run.launched";
+    readonly payload: {
+        readonly runId: string;
+        readonly kind: string;
+        readonly definitionName: string;
+        readonly definitionVersion: string;
+        readonly effectId: string;
+        readonly close: "terminate" | "wait";
+    };
 }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
     readonly type: "runtime.run.started";
     readonly payload: {
@@ -147,6 +173,20 @@ export declare const requestApprovalEffect: NoInfer<import("@swirls/looms/core")
         readonly definitionVersion: string;
         readonly input: import("effect/Schema").Json;
         readonly requestedThreadId?: string | null | undefined;
+        readonly launchedBy?: {
+            readonly runId: string;
+            readonly threadId: string;
+            readonly effectId: string;
+            readonly causationId: string;
+            readonly causationSeq: number;
+        } | undefined;
+        readonly attributes?: {
+            readonly [x: string]: string;
+        } | undefined;
+        readonly trace?: {
+            readonly traceparent: string;
+            readonly tracestate?: string | undefined;
+        } | undefined;
     };
 }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
     readonly type: "runtime.signal.received";

package/dist/approval/module.d.ts

@@ -56,6 +56,19 @@ export declare function approval(): import("@swirls/looms/core").RuntimeModule<"
         readonly payload: {
             readonly approvalId: string;
         };
+    }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+        readonly type: "runtime.child.close.requested";
+        readonly payload: {
+            readonly policy: "terminate" | "wait";
+        };
+    }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+        readonly type: "runtime.child.settled";
+        readonly payload: {
+            readonly runId: string;
+            readonly status: "cancelled" | "completed" | "failed";
+            readonly output: import("effect/Schema").Json;
+            readonly error: string | null;
+        };
     }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
         readonly type: "runtime.effect.ambiguous";
         readonly payload: {
@@ -100,6 +113,8 @@ export declare function approval(): import("@swirls/looms/core").RuntimeModule<"
         readonly payload: {
             readonly effectId: string;
             readonly error: string;
+            readonly nonRetryable?: boolean | undefined;
+            readonly retryAfterMs?: number | undefined;
         };
     }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
         readonly type: "runtime.effect.heartbeat";
@@ -108,6 +123,7 @@ export declare function approval(): import("@swirls/looms/core").RuntimeModule<"
             readonly attempt: number;
             readonly heartbeatAt: number;
             readonly deadlineAt: number | null;
+            readonly details?: import("effect/Schema").Json | undefined;
         };
     }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
         readonly type: "runtime.effect.queued";
@@ -160,6 +176,16 @@ export declare function approval(): import("@swirls/looms/core").RuntimeModule<"
             readonly sourceRunId: string;
             readonly sourceSeq: number;
         };
+    }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+        readonly type: "runtime.run.launched";
+        readonly payload: {
+            readonly runId: string;
+            readonly kind: string;
+            readonly definitionName: string;
+            readonly definitionVersion: string;
+            readonly effectId: string;
+            readonly close: "terminate" | "wait";
+        };
     }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
         readonly type: "runtime.run.started";
         readonly payload: {
@@ -169,6 +195,20 @@ export declare function approval(): import("@swirls/looms/core").RuntimeModule<"
             readonly definitionVersion: string;
             readonly input: import("effect/Schema").Json;
             readonly requestedThreadId?: string | null | undefined;
+            readonly launchedBy?: {
+                readonly runId: string;
+                readonly threadId: string;
+                readonly effectId: string;
+                readonly causationId: string;
+                readonly causationSeq: number;
+            } | undefined;
+            readonly attributes?: {
+                readonly [x: string]: string;
+            } | undefined;
+            readonly trace?: {
+                readonly traceparent: string;
+                readonly tracestate?: string | undefined;
+            } | undefined;
         };
     }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
         readonly type: "runtime.signal.received";
@@ -302,6 +342,19 @@ export declare function approval(): import("@swirls/looms/core").RuntimeModule<"
             readonly payload: {
                 readonly approvalId: string;
             };
+        }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+            readonly type: "runtime.child.close.requested";
+            readonly payload: {
+                readonly policy: "terminate" | "wait";
+            };
+        }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+            readonly type: "runtime.child.settled";
+            readonly payload: {
+                readonly runId: string;
+                readonly status: "cancelled" | "completed" | "failed";
+                readonly output: import("effect/Schema").Json;
+                readonly error: string | null;
+            };
         }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
             readonly type: "runtime.effect.ambiguous";
             readonly payload: {
@@ -346,6 +399,8 @@ export declare function approval(): import("@swirls/looms/core").RuntimeModule<"
             readonly payload: {
                 readonly effectId: string;
                 readonly error: string;
+                readonly nonRetryable?: boolean | undefined;
+                readonly retryAfterMs?: number | undefined;
             };
         }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
             readonly type: "runtime.effect.heartbeat";
@@ -354,6 +409,7 @@ export declare function approval(): import("@swirls/looms/core").RuntimeModule<"
                 readonly attempt: number;
                 readonly heartbeatAt: number;
                 readonly deadlineAt: number | null;
+                readonly details?: import("effect/Schema").Json | undefined;
             };
         }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
             readonly type: "runtime.effect.queued";
@@ -406,6 +462,16 @@ export declare function approval(): import("@swirls/looms/core").RuntimeModule<"
                 readonly sourceRunId: string;
                 readonly sourceSeq: number;
             };
+        }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+            readonly type: "runtime.run.launched";
+            readonly payload: {
+                readonly runId: string;
+                readonly kind: string;
+                readonly definitionName: string;
+                readonly definitionVersion: string;
+                readonly effectId: string;
+                readonly close: "terminate" | "wait";
+            };
         }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
             readonly type: "runtime.run.started";
             readonly payload: {
@@ -415,6 +481,20 @@ export declare function approval(): import("@swirls/looms/core").RuntimeModule<"
                 readonly definitionVersion: string;
                 readonly input: import("effect/Schema").Json;
                 readonly requestedThreadId?: string | null | undefined;
+                readonly launchedBy?: {
+                    readonly runId: string;
+                    readonly threadId: string;
+                    readonly effectId: string;
+                    readonly causationId: string;
+                    readonly causationSeq: number;
+                } | undefined;
+                readonly attributes?: {
+                    readonly [x: string]: string;
+                } | undefined;
+                readonly trace?: {
+                    readonly traceparent: string;
+                    readonly tracestate?: string | undefined;
+                } | undefined;
             };
         }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
             readonly type: "runtime.signal.received";