@swirls/looms 0.0.1

package/dist/agent/effects.js

@@ -0,0 +1,318 @@
+import { Effect, Predicate, Schema } from 'effect';
+import { createThreadId, validateInput } from '@swirls/looms/core';
+import { normalizeTools } from './definitions.js';
+import { AgentDefinitionsTag } from './definitions-store.js';
+import { LlmTag } from './llm.js';
+import { agentModule } from './scope.js';
+import { toolSpecs } from './tool-schema.js';
+import { MessageSchema, ToolCallSchema } from './types.js';
+const CallLlmInput = Schema.Struct({
+    turn: Schema.Number,
+    definitionName: Schema.optional(Schema.String),
+    messages: Schema.optional(Schema.Array(MessageSchema)),
+    input: Schema.optional(Schema.Json),
+});
+const ExecuteToolInput = Schema.Struct({
+    turn: Schema.Number,
+    definitionName: Schema.optional(Schema.String),
+    toolCall: ToolCallSchema,
+});
+function findTool(tools, name) {
+    return tools.find((tool) => tool.name === name);
+}
+export const callLlmEffect = agentModule.effect({
+    type: 'agent.callLLM',
+    input: CallLlmInput,
+    execute: (input, ctx) => runCallLlm({
+        turn: input.turn,
+        definitionName: input.definitionName,
+        // SAFETY: message arrays in callLLM input are serialized Message objects.
+        messages: input.messages ?? [],
+        input: input.input ?? null,
+        runId: ctx.runId,
+        threadId: ctx.threadId,
+        emit: (event) => ctx.emit(event),
+    }),
+});
+function runCallLlm(args) {
+    return Effect.gen(function* () {
+        const { turn, threadId, emit, definitionName, messages, input } = args;
+        const agents = yield* AgentDefinitionsTag;
+        const llm = yield* LlmTag;
+        const definition = definitionName ? agents.get(definitionName) : undefined;
+        if (!definition) {
+            return [
+                {
+                    type: 'runtime.thread.failed',
+                    payload: { threadId, error: `Unknown agent definition for ${threadId}` },
+                    threadId,
+                },
+            ];
+        }
+        if (turn > (definition.maxTurns ?? 20)) {
+            return [
+                {
+                    type: 'runtime.thread.failed',
+                    payload: { threadId, error: `Max turns exceeded (${definition.maxTurns ?? 20})` },
+                    threadId,
+                },
+            ];
+        }
+        const tools = normalizeTools(definition.tools);
+        const events = [
+            {
+                type: 'agent.turn.started',
+                payload: { turn },
+                threadId,
+            },
+        ];
+        const turnCtx = {
+            threadId,
+            turn,
+            messages,
+            input,
+            tools,
+            instructions: definition.instructions,
+        };
+        const result = definition.runTurn
+            ? yield* Effect.tryPromise({
+                try: () => Promise.resolve(definition.runTurn(turnCtx)),
+                catch: (cause) => (cause instanceof Error ? cause : new Error(String(cause))),
+            })
+            : yield* llm.complete({
+                model: definition.model,
+                instructions: definition.instructions,
+                messages: [{ role: 'system', content: definition.instructions }, ...turnCtx.messages],
+                tools,
+                toolSpecs: toolSpecs(tools),
+                onTextDelta: async (delta) => {
+                    await emit({
+                        type: 'agent.turn.text_delta',
+                        payload: { turn, delta },
+                        threadId,
+                        ephemeral: true,
+                    });
+                },
+            });
+        const toolCalls = result.toolCalls ?? result.message.toolCalls ?? [];
+        const shouldStop = definition.stopWhen?.({
+            turn,
+            maxTurns: definition.maxTurns ?? 20,
+            messages: turnCtx.messages,
+            toolCalls,
+            result,
+        });
+        events.push({
+            type: 'agent.message',
+            payload: {
+                turn,
+                message: result.message,
+                usage: result.usage,
+            },
+            threadId,
+        });
+        if (shouldStop) {
+            if (!definition.conversational) {
+                events.push({
+                    type: 'runtime.thread.completed',
+                    payload: { threadId, output: result.output ?? { text: result.message.content } },
+                    threadId,
+                });
+            }
+            return events;
+        }
+        for (const toolCall of toolCalls) {
+            events.push({
+                type: 'agent.tool_call.requested',
+                payload: { turn, toolCall },
+                threadId,
+            });
+        }
+        if (toolCalls.length === 0 && !definition.conversational) {
+            events.push({
+                type: 'runtime.thread.completed',
+                payload: {
+                    threadId,
+                    output: result.output ?? { text: result.message.content },
+                },
+                threadId,
+            });
+        }
+        return events;
+    });
+}
+export const executeToolEffect = agentModule.effect({
+    type: 'agent.executeTool',
+    input: ExecuteToolInput,
+    execute: (input, ctx) => Effect.gen(function* () {
+        const threadId = ctx.threadId;
+        const agents = yield* AgentDefinitionsTag;
+        const definition = input.definitionName ? agents.get(input.definitionName) : undefined;
+        if (!definition) {
+            return [
+                {
+                    type: 'agent.tool.result',
+                    payload: {
+                        turn: input.turn,
+                        toolCallId: input.toolCall.id,
+                        name: input.toolCall.name,
+                        result: null,
+                        error: 'Unknown agent definition',
+                    },
+                    threadId,
+                },
+            ];
+        }
+        const tools = normalizeTools(definition.tools);
+        const tool = findTool(tools, input.toolCall.name);
+        if (!tool) {
+            return [
+                {
+                    type: 'agent.tool.result',
+                    payload: {
+                        turn: input.turn,
+                        toolCallId: input.toolCall.id,
+                        name: input.toolCall.name,
+                        result: null,
+                        error: `Unknown tool: ${input.toolCall.name}`,
+                    },
+                    threadId,
+                },
+            ];
+        }
+        switch (tool.kind) {
+            case 'function': {
+                const validated = yield* Effect.tryPromise({
+                    try: () => validateInput(tool.input, input.toolCall.arguments),
+                    catch: (cause) => (cause instanceof Error ? cause : new Error(String(cause))),
+                }).pipe(Effect.map((value) => ({ ok: true, value })), Effect.catch((err) => Effect.succeed({ ok: false, error: err.message })));
+                if (!validated.ok) {
+                    return [
+                        {
+                            type: 'agent.tool.result',
+                            payload: {
+                                turn: input.turn,
+                                toolCallId: input.toolCall.id,
+                                name: input.toolCall.name,
+                                result: null,
+                                error: validated.error,
+                            },
+                            threadId,
+                        },
+                    ];
+                }
+                const result = yield* Effect.tryPromise({
+                    try: () => Promise.resolve(tool.handler(validated.value, {
+                        threadId,
+                        turn: input.turn,
+                    })),
+                    catch: (cause) => (cause instanceof Error ? cause : new Error(String(cause))),
+                }).pipe(Effect.map((value) => ({ ok: true, value })), Effect.catch((err) => Effect.succeed({ ok: false, error: err.message })));
+                return [
+                    {
+                        type: 'agent.tool.result',
+                        payload: {
+                            turn: input.turn,
+                            toolCallId: input.toolCall.id,
+                            name: input.toolCall.name,
+                            result: result.ok ? result.value : null,
+                            error: result.ok ? null : result.error,
+                        },
+                        threadId,
+                    },
+                ];
+            }
+            case 'thread': {
+                const validated = tool.input
+                    ? yield* Effect.tryPromise({
+                        try: () => validateInput(tool.input, input.toolCall.arguments),
+                        catch: (cause) => (cause instanceof Error ? cause : new Error(String(cause))),
+                    }).pipe(Effect.map((value) => ({ ok: true, value })), Effect.catch((err) => Effect.succeed({ ok: false, error: err.message })))
+                    : { ok: true, value: input.toolCall.arguments };
+                if (!validated.ok) {
+                    return [
+                        {
+                            type: 'agent.tool.result',
+                            payload: {
+                                turn: input.turn,
+                                toolCallId: input.toolCall.id,
+                                name: input.toolCall.name,
+                                result: null,
+                                error: validated.error,
+                            },
+                            threadId,
+                        },
+                    ];
+                }
+                const childInput = tool.mapInput ? tool.mapInput(validated.value) : validated.value;
+                const childThreadId = createThreadId();
+                return [
+                    {
+                        type: 'agent.spawn.requested',
+                        payload: {
+                            childThreadId,
+                            kind: tool.childKind,
+                            definitionName: tool.childName,
+                            input: childInput,
+                            toolCallId: input.toolCall.id,
+                        },
+                        threadId,
+                    },
+                ];
+            }
+            case 'effects': {
+                const validated = tool.input
+                    ? yield* Effect.tryPromise({
+                        try: () => validateInput(tool.input, input.toolCall.arguments),
+                        catch: (cause) => (cause instanceof Error ? cause : new Error(String(cause))),
+                    }).pipe(Effect.map((value) => ({ ok: true, value })), Effect.catch((err) => Effect.succeed({ ok: false, error: err.message })))
+                    : { ok: true, value: input.toolCall.arguments };
+                if (!validated.ok) {
+                    return [
+                        {
+                            type: 'agent.tool.result',
+                            payload: {
+                                turn: input.turn,
+                                toolCallId: input.toolCall.id,
+                                name: input.toolCall.name,
+                                result: null,
+                                error: validated.error,
+                            },
+                            threadId,
+                        },
+                    ];
+                }
+                const effects = tool.effects(validated.value);
+                return [
+                    {
+                        type: 'agent.effects.requested',
+                        payload: {
+                            toolCallId: input.toolCall.id,
+                            effects,
+                            waitOn: tool.waitOn
+                                ? {
+                                    type: tool.waitOn.type,
+                                    match: tool.waitOn.match,
+                                }
+                                : undefined,
+                        },
+                        threadId,
+                    },
+                ];
+            }
+            default: {
+                const exhaustiveCheck = tool;
+                return exhaustiveCheck;
+            }
+        }
+    }),
+});
+export function readToolCall(value) {
+    if (!Predicate.isObject(value)) {
+        return null;
+    }
+    if (!Predicate.isString(value.id) || !Predicate.isString(value.name)) {
+        return null;
+    }
+    return { id: value.id, name: value.name, arguments: value.arguments ?? null };
+}

package/dist/agent/events.d.ts

@@ -0,0 +1,170 @@
+import { Schema } from 'effect';
+import { type RuntimeEffect } from '@swirls/looms/core';
+export declare const AgentMessageReceivedPayloadSchema: Schema.Struct<{
+    readonly message: Schema.Struct<{
+        readonly role: Schema.Union<readonly [Schema.Literal<"system">, Schema.Literal<"user">, Schema.Literal<"assistant">, Schema.Literal<"tool">]>;
+        readonly content: Schema.String;
+        readonly toolCallId: Schema.optional<Schema.String>;
+        readonly name: Schema.optional<Schema.String>;
+        readonly toolCalls: Schema.optional<Schema.mutable<Schema.$Array<Schema.Struct<{
+            readonly id: Schema.String;
+            readonly name: Schema.String;
+            readonly arguments: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        }>>>>;
+    }>;
+}>;
+export declare const AgentTurnStartedPayloadSchema: Schema.Struct<{
+    readonly turn: Schema.Number;
+}>;
+export declare const AgentTurnTextDeltaPayloadSchema: Schema.Struct<{
+    readonly turn: Schema.Number;
+    readonly delta: Schema.String;
+}>;
+export declare const AgentMessageEventPayloadSchema: Schema.Struct<{
+    readonly turn: Schema.Number;
+    readonly message: Schema.Struct<{
+        readonly role: Schema.Union<readonly [Schema.Literal<"system">, Schema.Literal<"user">, Schema.Literal<"assistant">, Schema.Literal<"tool">]>;
+        readonly content: Schema.String;
+        readonly toolCallId: Schema.optional<Schema.String>;
+        readonly name: Schema.optional<Schema.String>;
+        readonly toolCalls: Schema.optional<Schema.mutable<Schema.$Array<Schema.Struct<{
+            readonly id: Schema.String;
+            readonly name: Schema.String;
+            readonly arguments: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        }>>>>;
+    }>;
+    readonly usage: Schema.optional<Schema.Struct<{
+        readonly input: Schema.Number;
+        readonly output: Schema.Number;
+    }>>;
+}>;
+export declare const AgentToolCallRequestedPayloadSchema: Schema.Struct<{
+    readonly turn: Schema.Number;
+    readonly toolCall: Schema.Struct<{
+        readonly id: Schema.String;
+        readonly name: Schema.String;
+        readonly arguments: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+    }>;
+}>;
+export declare const AgentToolResultPayloadSchema: Schema.Struct<{
+    readonly turn: Schema.Number;
+    readonly toolCallId: Schema.String;
+    readonly name: Schema.String;
+    readonly result: Schema.NullOr<Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+    readonly error: Schema.NullOr<Schema.String>;
+}>;
+export declare const AgentSteeredPayloadSchema: Schema.Struct<{
+    readonly turn: Schema.Number;
+    readonly message: Schema.Struct<{
+        readonly role: Schema.Union<readonly [Schema.Literal<"system">, Schema.Literal<"user">, Schema.Literal<"assistant">, Schema.Literal<"tool">]>;
+        readonly content: Schema.String;
+        readonly toolCallId: Schema.optional<Schema.String>;
+        readonly name: Schema.optional<Schema.String>;
+        readonly toolCalls: Schema.optional<Schema.mutable<Schema.$Array<Schema.Struct<{
+            readonly id: Schema.String;
+            readonly name: Schema.String;
+            readonly arguments: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        }>>>>;
+    }>;
+    readonly interrupt: Schema.optional<Schema.Boolean>;
+}>;
+export declare const AgentSpawnRequestedPayloadSchema: Schema.Struct<{
+    readonly childThreadId: Schema.String;
+    readonly kind: Schema.String;
+    readonly definitionName: Schema.String;
+    readonly toolCallId: Schema.String;
+    readonly input: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+}>;
+export declare const AgentEffectsRequestedPayloadSchema: Schema.Struct<{
+    readonly toolCallId: Schema.String;
+    readonly effects: Schema.$Array<Schema.Schema<RuntimeEffect>>;
+    readonly waitOn: Schema.optional<Schema.Struct<{
+        readonly type: Schema.Union<readonly [Schema.String, Schema.$Array<Schema.String>]>;
+        readonly match: Schema.optional<Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+    }>>;
+}>;
+export declare const agentCatalog: import("@swirls/looms/core").EventCatalog<"agent", {
+    'message.received': Schema.Struct<{
+        readonly message: Schema.Struct<{
+            readonly role: Schema.Union<readonly [Schema.Literal<"system">, Schema.Literal<"user">, Schema.Literal<"assistant">, Schema.Literal<"tool">]>;
+            readonly content: Schema.String;
+            readonly toolCallId: Schema.optional<Schema.String>;
+            readonly name: Schema.optional<Schema.String>;
+            readonly toolCalls: Schema.optional<Schema.mutable<Schema.$Array<Schema.Struct<{
+                readonly id: Schema.String;
+                readonly name: Schema.String;
+                readonly arguments: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+            }>>>>;
+        }>;
+    }>;
+    'turn.started': Schema.Struct<{
+        readonly turn: Schema.Number;
+    }>;
+    'turn.text_delta': Schema.Struct<{
+        readonly turn: Schema.Number;
+        readonly delta: Schema.String;
+    }>;
+    message: Schema.Struct<{
+        readonly turn: Schema.Number;
+        readonly message: Schema.Struct<{
+            readonly role: Schema.Union<readonly [Schema.Literal<"system">, Schema.Literal<"user">, Schema.Literal<"assistant">, Schema.Literal<"tool">]>;
+            readonly content: Schema.String;
+            readonly toolCallId: Schema.optional<Schema.String>;
+            readonly name: Schema.optional<Schema.String>;
+            readonly toolCalls: Schema.optional<Schema.mutable<Schema.$Array<Schema.Struct<{
+                readonly id: Schema.String;
+                readonly name: Schema.String;
+                readonly arguments: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+            }>>>>;
+        }>;
+        readonly usage: Schema.optional<Schema.Struct<{
+            readonly input: Schema.Number;
+            readonly output: Schema.Number;
+        }>>;
+    }>;
+    'tool_call.requested': Schema.Struct<{
+        readonly turn: Schema.Number;
+        readonly toolCall: Schema.Struct<{
+            readonly id: Schema.String;
+            readonly name: Schema.String;
+            readonly arguments: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        }>;
+    }>;
+    'tool.result': Schema.Struct<{
+        readonly turn: Schema.Number;
+        readonly toolCallId: Schema.String;
+        readonly name: Schema.String;
+        readonly result: Schema.NullOr<Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+        readonly error: Schema.NullOr<Schema.String>;
+    }>;
+    steered: Schema.Struct<{
+        readonly turn: Schema.Number;
+        readonly message: Schema.Struct<{
+            readonly role: Schema.Union<readonly [Schema.Literal<"system">, Schema.Literal<"user">, Schema.Literal<"assistant">, Schema.Literal<"tool">]>;
+            readonly content: Schema.String;
+            readonly toolCallId: Schema.optional<Schema.String>;
+            readonly name: Schema.optional<Schema.String>;
+            readonly toolCalls: Schema.optional<Schema.mutable<Schema.$Array<Schema.Struct<{
+                readonly id: Schema.String;
+                readonly name: Schema.String;
+                readonly arguments: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+            }>>>>;
+        }>;
+        readonly interrupt: Schema.optional<Schema.Boolean>;
+    }>;
+    'spawn.requested': Schema.Struct<{
+        readonly childThreadId: Schema.String;
+        readonly kind: Schema.String;
+        readonly definitionName: Schema.String;
+        readonly toolCallId: Schema.String;
+        readonly input: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+    }>;
+    'effects.requested': Schema.Struct<{
+        readonly toolCallId: Schema.String;
+        readonly effects: Schema.$Array<Schema.Schema<RuntimeEffect>>;
+        readonly waitOn: Schema.optional<Schema.Struct<{
+            readonly type: Schema.Union<readonly [Schema.String, Schema.$Array<Schema.String>]>;
+            readonly match: Schema.optional<Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+        }>>;
+    }>;
+}>;

package/dist/agent/events.js

@@ -0,0 +1,61 @@
+import { Schema } from 'effect';
+import { defineEventCatalog } from '@swirls/looms/core';
+import { MessageSchema, TokenUsageSchema, ToolCallSchema } from './types.js';
+export const AgentMessageReceivedPayloadSchema = Schema.Struct({
+    message: MessageSchema,
+});
+export const AgentTurnStartedPayloadSchema = Schema.Struct({
+    turn: Schema.Number,
+});
+export const AgentTurnTextDeltaPayloadSchema = Schema.Struct({
+    turn: Schema.Number,
+    delta: Schema.String,
+});
+export const AgentMessageEventPayloadSchema = Schema.Struct({
+    turn: Schema.Number,
+    message: MessageSchema,
+    usage: Schema.optional(TokenUsageSchema),
+});
+export const AgentToolCallRequestedPayloadSchema = Schema.Struct({
+    turn: Schema.Number,
+    toolCall: ToolCallSchema,
+});
+export const AgentToolResultPayloadSchema = Schema.Struct({
+    turn: Schema.Number,
+    toolCallId: Schema.String,
+    name: Schema.String,
+    result: Schema.NullOr(Schema.Json),
+    error: Schema.NullOr(Schema.String),
+});
+export const AgentSteeredPayloadSchema = Schema.Struct({
+    turn: Schema.Number,
+    message: MessageSchema,
+    interrupt: Schema.optional(Schema.Boolean),
+});
+export const AgentSpawnRequestedPayloadSchema = Schema.Struct({
+    childThreadId: Schema.String,
+    kind: Schema.String,
+    definitionName: Schema.String,
+    toolCallId: Schema.String,
+    input: Schema.Json,
+});
+export const AgentEffectsRequestedPayloadSchema = Schema.Struct({
+    toolCallId: Schema.String,
+    // SAFETY: RuntimeEffect represents serializable requested effect instructions.
+    effects: Schema.Array(Schema.Unknown),
+    waitOn: Schema.optional(Schema.Struct({
+        type: Schema.Union([Schema.String, Schema.Array(Schema.String)]),
+        match: Schema.optional(Schema.Json),
+    })),
+});
+export const agentCatalog = defineEventCatalog('agent', {
+    'message.received': AgentMessageReceivedPayloadSchema,
+    'turn.started': AgentTurnStartedPayloadSchema,
+    'turn.text_delta': AgentTurnTextDeltaPayloadSchema,
+    message: AgentMessageEventPayloadSchema,
+    'tool_call.requested': AgentToolCallRequestedPayloadSchema,
+    'tool.result': AgentToolResultPayloadSchema,
+    steered: AgentSteeredPayloadSchema,
+    'spawn.requested': AgentSpawnRequestedPayloadSchema,
+    'effects.requested': AgentEffectsRequestedPayloadSchema,
+});

package/dist/agent/index.d.ts

@@ -0,0 +1,13 @@
+export * from './types';
+export * from './stop-when';
+export * from './definitions';
+export * from './definitions-store';
+export * from './events';
+export * from './scope';
+export * from './threads';
+export * from './effects';
+export * from './projections';
+export * from './signals';
+export * from './llm';
+export * from './tool-schema';
+export * from './module';

package/dist/agent/index.js

@@ -0,0 +1,13 @@
+export * from './types.js';
+export * from './stop-when.js';
+export * from './definitions.js';
+export * from './definitions-store.js';
+export * from './events.js';
+export * from './scope.js';
+export * from './threads.js';
+export * from './effects.js';
+export * from './projections.js';
+export * from './signals.js';
+export * from './llm.js';
+export * from './tool-schema.js';
+export * from './module.js';

package/dist/agent/llm.d.ts

@@ -0,0 +1,35 @@
+import { Context, Effect, Layer } from 'effect';
+import type { JsonValue } from '@swirls/looms/core';
+import type { AgentTurnContext, AgentTurnResult, ToolLike } from './definitions';
+import type { Message, ToolCall } from './types';
+export interface LlmToolSpec {
+    readonly name: string;
+    readonly description: string;
+    readonly inputJsonSchema: JsonValue;
+}
+export interface LlmCompleteArgs {
+    model?: string;
+    instructions: string;
+    messages: Message[];
+    tools: ToolLike[];
+    toolSpecs?: LlmToolSpec[];
+    onTextDelta?: (delta: string) => void | Promise<void>;
+    signal?: AbortSignal;
+}
+export interface LlmService {
+    readonly complete: (args: LlmCompleteArgs) => Effect.Effect<AgentTurnResult, Error>;
+}
+export interface LlmAdapter {
+    readonly complete: (args: LlmCompleteArgs) => Promise<AgentTurnResult>;
+}
+export declare function llmFromAdapter(adapter: LlmAdapter): LlmService;
+declare const LlmTag_base: Context.ServiceClass<LlmTag, "looms/Llm", LlmService>;
+export declare class LlmTag extends LlmTag_base {
+}
+export interface StubLlmPolicy {
+    toolCallsFor?: (ctx: AgentTurnContext) => ToolCall[] | undefined;
+    doneAfterText?: boolean;
+}
+export declare const makeStubLlm: (policy?: StubLlmPolicy) => LlmService;
+export declare const StubLlmLive: (policy?: StubLlmPolicy) => Layer.Layer<LlmTag, never, never>;
+export {};

package/dist/agent/llm.js

@@ -0,0 +1,48 @@
+import { Context, Effect, Layer, Predicate } from 'effect';
+export function llmFromAdapter(adapter) {
+    return {
+        complete: (args) => Effect.tryPromise({
+            try: () => adapter.complete(args),
+            catch: (cause) => (cause instanceof Error ? cause : new Error(String(cause))),
+        }),
+    };
+}
+export class LlmTag extends Context.Service()('looms/Llm') {
+}
+export const makeStubLlm = (policy = {}) => ({
+    complete: (args) => Effect.sync(() => {
+        const ctx = {
+            threadId: 'stub',
+            turn: 0,
+            messages: args.messages,
+            input: null,
+            tools: args.tools,
+            instructions: args.instructions,
+        };
+        const toolCalls = policy.toolCallsFor?.(ctx);
+        if (toolCalls && toolCalls.length > 0) {
+            return {
+                message: { role: 'assistant', content: '', toolCalls },
+                toolCalls,
+            };
+        }
+        let lastUser;
+        for (let i = args.messages.length - 1; i >= 0; i--) {
+            const item = args.messages[i];
+            if (item?.role === 'user') {
+                lastUser = item;
+                break;
+            }
+        }
+        const lastContent = args.messages.at(-1)?.content;
+        const content = lastUser?.content ??
+            (Predicate.isString(lastContent) ? lastContent : JSON.stringify(lastContent ?? null));
+        return {
+            message: { role: 'assistant', content },
+            done: policy.doneAfterText !== false,
+            output: { text: content },
+            usage: { input: 0, output: content.length },
+        };
+    }),
+});
+export const StubLlmLive = (policy) => Layer.succeed(LlmTag, makeStubLlm(policy));