@swirls/looms 0.0.2 → 0.2.0

package/dist/agent/threads.js

@@ -1,8 +1,7 @@
 import { Predicate } from 'effect';
-import { createWaitId, emit, invoke, isWithdrawnError, parseEffectId, spawn, wait, } from '@swirls/looms/core';
+import { 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 { AgentStateSchema } from './types.js';
 function inputToLine(input) {
     if (input === null) {
         return null;
@@ -44,9 +43,9 @@ function attachToolCall(lines, toolCall) {
 }
 export const agentThread = agentModule.thread({
     kind: 'agent',
-    shape: AgentStateSchema,
     initialState: (ctx) => ({
         definitionName: ctx.definitionName,
+        definitionVersion: ctx.definitionVersion,
         lines: [],
         pendingToolCalls: [],
         executingToolCalls: [],
@@ -60,12 +59,14 @@ export const agentThread = agentModule.thread({
         input: ctx.input,
         output: null,
         pendingEffectTools: {},
+        consumedSteerMessageIds: [],
     }),
     step(state, event, ctx) {
         switch (event.type) {
             case 'runtime.thread.started': {
                 const payload = event.payload;
                 const defName = payload.definitionName || state.definitionName;
+                const defVersion = payload.definitionVersion ?? state.definitionVersion ?? DEFAULT_DEFINITION_VERSION;
                 // SAFETY: event payload input is JSON
                 const input = payload.input !== undefined ? payload.input : state.input;
                 const line = inputToLine(input);
@@ -73,6 +74,7 @@ export const agentThread = agentModule.thread({
                 return {
                     ...state,
                     definitionName: defName,
+                    definitionVersion: defVersion,
                     input,
                     lines,
                     needsLlmCall: true,
@@ -141,6 +143,10 @@ export const agentThread = agentModule.thread({
             case 'agent.steered': {
                 const message = event.payload.message;
                 const interrupt = event.payload.interrupt ?? false;
+                const messageId = event.payload.messageId;
+                const consumedSteerMessageIds = messageId && !state.consumedSteerMessageIds.includes(messageId)
+                    ? [...state.consumedSteerMessageIds, messageId]
+                    : state.consumedSteerMessageIds;
                 if (interrupt) {
                     return {
                         ...state,
@@ -152,16 +158,18 @@ export const agentThread = agentModule.thread({
                         pendingEffects: [],
                         pendingEmits: [],
                         needsLlmCall: true,
+                        consumedSteerMessageIds,
                     };
                 }
                 return {
                     ...state,
                     lines: [...state.lines, message],
                     pendingSteer: message,
+                    consumedSteerMessageIds,
                 };
             }
             case 'agent.spawn.requested': {
-                const { childThreadId, kind, definitionName, toolCallId, input } = event.payload;
+                const { childThreadId, kind, definitionName, definitionVersion, toolCallId, input } = event.payload;
                 return {
                     ...state,
                     executingToolCalls: state.executingToolCalls.filter((item) => item.id !== toolCallId),
@@ -171,6 +179,7 @@ export const agentThread = agentModule.thread({
                             childThreadId,
                             kind,
                             definitionName,
+                            definitionVersion,
                             toolCallId,
                             // SAFETY: schema-decoded input is JSON
                             input: input ?? null,
@@ -180,10 +189,7 @@ export const agentThread = agentModule.thread({
             }
             case 'agent.effects.requested': {
                 const { toolCallId, effects: rawEffects, waitOn } = event.payload;
-                // SAFETY: handler serialized RuntimeEffect values into the event payload.
-                const effects = Array.isArray(rawEffects)
-                    ? [...rawEffects]
-                    : [];
+                const effects = Array.isArray(rawEffects) ? [...rawEffects] : [];
                 const taggedEffects = effects.map((effect, idx) => {
                     if (!('tag' in effect && Predicate.isString(effect.tag))) {
                         return { ...effect, tag: `${toolCallId}_${effect.type}_${idx}` };
@@ -211,7 +217,6 @@ export const agentThread = agentModule.thread({
                             waitOn: waitOn
                                 ? {
                                     type: waitOn.type,
-                                    // SAFETY: schema-decoded match is JSON
                                     match: waitOn.match ?? undefined,
                                 }
                                 : undefined,
@@ -283,17 +288,9 @@ export const agentThread = agentModule.thread({
                 if (!toolCallId) {
                     return state;
                 }
-                const embedded = event.payload.event;
-                const embeddedObj = Predicate.isObject(embedded) && Predicate.isObject(embedded.payload)
-                    ? embedded.payload
-                    : {};
                 const threadId = ctx.threadId;
                 const name = Predicate.isString(tag.name) ? tag.name : 'child';
-                const error = Predicate.isString(embeddedObj.error) ? embeddedObj.error : null;
-                // SAFETY: embedded output/payload is JSON
-                const result = embeddedObj.output ??
-                    (Predicate.isObject(embedded) ? embedded.payload : null) ??
-                    null;
+                const { result, error } = waitOutcome(event.payload.event, tag);
                 return {
                     ...state,
                     pendingSpawns: state.pendingSpawns.filter((item) => item.toolCallId !== toolCallId),
@@ -327,14 +324,17 @@ export const agentThread = agentModule.thread({
             effects.push(invoke(callLlmEffect, {
                 turn: state.turn + 1,
                 definitionName: state.definitionName,
+                definitionVersion: state.definitionVersion ?? DEFAULT_DEFINITION_VERSION,
                 messages: state.lines,
                 input: state.input,
+                consumedSteerMessageIds: state.consumedSteerMessageIds,
             }, `llm_turn_${state.turn + 1}`));
         }
         for (const toolCall of state.executingToolCalls) {
             effects.push(invoke(executeToolEffect, {
                 turn: state.turn,
                 definitionName: state.definitionName,
+                definitionVersion: state.definitionVersion ?? DEFAULT_DEFINITION_VERSION,
                 toolCall,
             }, `tool_${toolCall.id}`));
         }
@@ -344,6 +344,7 @@ export const agentThread = agentModule.thread({
                 childThreadId: spawnReq.childThreadId,
                 kind: spawnReq.kind,
                 definitionName: spawnReq.definitionName,
+                definitionVersion: spawnReq.definitionVersion,
                 input: spawnReq.input,
             }), wait({
                 waitId,
@@ -384,15 +385,9 @@ export function satisfiedToToolResult(event) {
     if (!toolCallId) {
         return null;
     }
-    const embedded = event.payload.event;
-    const embeddedPayload = Predicate.isObject(embedded) && Predicate.isObject(embedded.payload) ? embedded.payload : {};
     const threadId = event.threadId ?? null;
     const name = Predicate.isString(tag.name) ? tag.name : 'child';
-    const error = Predicate.isString(embeddedPayload.error) ? embeddedPayload.error : null;
-    // SAFETY: embedded output/payload is JSON
-    const result = embeddedPayload.output ??
-        (Predicate.isObject(embedded) ? embedded.payload : null) ??
-        null;
+    const { result, error } = waitOutcome(event.payload.event, tag);
     return emit({
         type: 'agent.tool.result',
         payload: {

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,44 +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 {
-        // SAFETY: Effect Schema values used as tool input codecs produce Standard JSON Schema.
-        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;
@@ -53,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) => ({
@@ -62,6 +25,3 @@ export function toolSpecs(tools = []) {
         inputJsonSchema: toolJsonSchema(tool),
     }));
 }
-export function jsonSchemaFromStandard(schema) {
-    return fromInputCandidate(schema ?? undefined) ?? EMPTY_OBJECT_SCHEMA;
-}

package/dist/agent/types.d.ts

@@ -1,5 +1,5 @@
 import { Schema } from 'effect';
-import type { EventInput, JsonValue, RuntimeEffect } from '@swirls/looms/core';
+import { type EventInput, type JsonValue, type RuntimeEffect } from '@swirls/looms/core';
 export declare const ToolCallSchema: Schema.Struct<{
     readonly id: Schema.String;
     readonly name: Schema.String;
@@ -35,12 +35,13 @@ export declare const ConversationSchema: Schema.Struct<{
 }>;
 export type ConversationState = Schema.Schema.Type<typeof ConversationSchema>;
 export declare const TokenUsageSchema: Schema.Struct<{
-    readonly input: Schema.Number;
-    readonly output: Schema.Number;
+    readonly input: Schema.Finite;
+    readonly output: Schema.Finite;
 }>;
 export type TokenUsage = Schema.Schema.Type<typeof TokenUsageSchema>;
 export declare const ThreadStartedPayloadSchema: Schema.Struct<{
     readonly definitionName: Schema.optional<Schema.String>;
+    readonly definitionVersion: Schema.withDecodingDefaultKey<Schema.String, never>;
     readonly input: Schema.optional<Schema.Unknown>;
 }>;
 export interface PendingEffectTool {
@@ -51,6 +52,7 @@ export interface AgentPendingSpawn {
     readonly childThreadId: string;
     readonly kind: string;
     readonly definitionName: string;
+    readonly definitionVersion: string;
     readonly toolCallId: string;
     readonly input: JsonValue;
 }
@@ -68,6 +70,7 @@ export interface AgentPendingEmit {
 }
 export interface AgentState {
     definitionName?: string;
+    definitionVersion?: string;
     lines: Message[];
     pendingToolCalls: ToolCall[];
     executingToolCalls: ToolCall[];
@@ -83,5 +86,47 @@ export interface AgentState {
     pendingEffectTools: {
         [causingSeq: string]: PendingEffectTool;
     };
+    consumedSteerMessageIds: string[];
+}
+export type AgentMessageDelivery = 'steer' | 'followUp' | 'nextTurn';
+export type AgentSessionTurnStatus = 'completed' | 'failed' | 'cancelled';
+export interface AgentSessionMessage {
+    readonly messageId: string;
+    readonly text: string;
+    readonly delivery?: AgentMessageDelivery;
+    readonly steeredIntoMessageId?: string;
+}
+export interface AgentSessionActiveTurn {
+    readonly messageId: string;
+    readonly childThreadId: string;
+    readonly text: string;
+}
+export interface AgentSessionClosure {
+    readonly messageId: string;
+    readonly status: AgentSessionTurnStatus;
+    readonly error?: string;
+}
+export interface AgentSessionState {
+    readonly definitionName: string;
+    readonly definitionVersion: string;
+    readonly pendingMessages: AgentSessionMessage[];
+    readonly nextTurnMessages: AgentSessionMessage[];
+    readonly processedMessageIds: string[];
+    readonly activeTurn: AgentSessionActiveTurn | null;
+    readonly pendingSteerDeliveries: AgentSessionMessage[];
+    readonly pendingClosures: AgentSessionClosure[];
+    readonly lastSequence: number;
+    readonly idleTimeoutMs: number;
+    readonly idleDeadlineAt: number | null;
+    readonly parked: boolean;
+    readonly cancelling: boolean;
+}
+export interface AgentSessionSnapshot {
+    readonly activeTurnId: string | null;
+    readonly activeChildThreadId: string | null;
+    readonly pendingMessageCount: number;
+    readonly nextTurnHeldCount: number;
+    readonly processedMessageIds: readonly string[];
+    readonly lastSequence: number;
+    readonly parked: boolean;
 }
-export declare const AgentStateSchema: Schema.Schema<AgentState>;

package/dist/agent/types.js

@@ -1,4 +1,5 @@
-import { Schema } from 'effect';
+import { Effect, Schema } from 'effect';
+import { DEFAULT_DEFINITION_VERSION, } from '@swirls/looms/core';
 export const ToolCallSchema = Schema.Struct({
     id: Schema.String,
     name: Schema.String,
@@ -21,12 +22,11 @@ export const ConversationSchema = Schema.Struct({
     lines: Schema.mutable(Schema.Array(MessageSchema)),
 });
 export const TokenUsageSchema = Schema.Struct({
-    input: Schema.Number,
-    output: Schema.Number,
+    input: Schema.Finite,
+    output: Schema.Finite,
 });
 export const ThreadStartedPayloadSchema = Schema.Struct({
     definitionName: Schema.optional(Schema.String),
+    definitionVersion: Schema.String.pipe(Schema.withDecodingDefaultKey(Effect.succeed(DEFAULT_DEFINITION_VERSION))),
     input: Schema.optional(Schema.Unknown),
 });
-// SAFETY: AgentState is folded by reducers; Schema.Unknown is a typed placeholder, not a decoder.
-export const AgentStateSchema = Schema.Unknown;

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

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

package/dist/ai-vercel/index.js

@@ -1,2 +1,3 @@
 export { vercelLlm } from './vercel-llm.js';
+export { toEvaluatorAnswers, vercelEvaluator, } from './vercel-evaluator.js';
 export { toLoomsToolCalls, toModelMessages } from './messages.js';

package/dist/ai-vercel/messages.js

@@ -1,4 +1,22 @@
 import {} from 'ai';
+import { Option, Predicate, Schema } from 'effect';
+const decodeJson = Schema.decodeOption(Schema.fromJsonString(Schema.Json));
+function toAiJson(value) {
+    if (value === null ||
+        Predicate.isString(value) ||
+        Predicate.isNumber(value) ||
+        Predicate.isBoolean(value)) {
+        return value;
+    }
+    if (Array.isArray(value)) {
+        return value.map(toAiJson);
+    }
+    const converted = {};
+    for (const [key, nested] of Object.entries(value)) {
+        converted[key] = toAiJson(nested);
+    }
+    return converted;
+}
 export function toModelMessages(messages) {
     const converted = [];
     for (const message of messages) {
@@ -51,13 +69,10 @@ export function toModelMessages(messages) {
     return converted;
 }
 function parseToolOutput(content) {
-    try {
-        // SAFETY: tool message content is parsed JSON from JSON.parse.
-        return { type: 'json', value: JSON.parse(content) };
-    }
-    catch {
-        return { type: 'text', value: content };
-    }
+    return Option.match(decodeJson(content), {
+        onNone: () => ({ type: 'text', value: content }),
+        onSome: (value) => ({ type: 'json', value: toAiJson(value) }),
+    });
 }
 export function toLoomsToolCalls(calls) {
     return calls.map((call) => ({

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

@@ -0,0 +1,36 @@
+import { experimental_evaluate } from 'ai';
+import type { EvaluatorAdapter, EvaluatorAnswers, EvaluatorQuestions } from '@swirls/looms/evaluator';
+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;
+    /** 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;
+}
+/** Map `experimental_evaluate` answers onto evaluator answers. Boolean items only expose probability. */
+export declare function toEvaluatorAnswers(questions: EvaluatorQuestions, raw: {
+    readonly [name: string]: EvaluateAnswer | undefined;
+}): EvaluatorAnswers;
+export declare function vercelEvaluator(options?: VercelEvaluatorOptions): EvaluatorAdapter;
+export {};

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

@@ -0,0 +1,73 @@
+import { experimental_evaluate } from 'ai';
+import { Data, Effect, Predicate } from 'effect';
+const DEFAULT_EVALUATOR_MODEL = 'typesafe-ai/jev';
+class VercelEvaluatorError extends Data.TaggedError('VercelEvaluatorError') {
+    constructor(cause) {
+        super({
+            cause,
+            message: cause instanceof Error ? cause.message : String(cause),
+        });
+        this.name = 'VercelEvaluatorError';
+    }
+}
+function abortSignalFor(timeoutMs, parent) {
+    const timeout = AbortSignal.timeout(timeoutMs);
+    return parent ? AbortSignal.any([parent, timeout]) : timeout;
+}
+/** Map `experimental_evaluate` answers onto evaluator answers. Boolean items only expose probability. */
+export function toEvaluatorAnswers(questions, raw) {
+    const answers = {};
+    for (const [name, question] of Object.entries(questions)) {
+        const item = raw[name];
+        if (question.type === 'boolean') {
+            const probability = Predicate.isNumber(item?.probability) ? item.probability : 0;
+            answers[name] = {
+                type: 'boolean',
+                value: probability >= 0.5,
+                probability,
+            };
+            continue;
+        }
+        if (question.type === 'choice') {
+            answers[name] = {
+                type: 'choice',
+                value: Predicate.isString(item?.choice) ? item.choice : '',
+            };
+            continue;
+        }
+        answers[name] = {
+            type: 'score',
+            value: Predicate.isNumber(item?.score) ? item.score : 0,
+        };
+    }
+    return answers;
+}
+export function vercelEvaluator(options = {}) {
+    const timeoutMs = options.timeoutMs ?? 2000;
+    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: resolveModel(args.model),
+                state: args.state,
+                abortSignal: abortSignalFor(timeoutMs, args.signal),
+                maxRetries: 0,
+                providerOptions,
+                questions: args.questions,
+            }),
+            catch: (cause) => new VercelEvaluatorError(cause),
+        }).pipe(Effect.map((result) => ({
+            answers: toEvaluatorAnswers(args.questions, result.answers),
+            usage: {
+                input: result.usage.inputTokens ?? 0,
+                output: result.usage.outputTokens ?? 0,
+            },
+            raw: result,
+        })))),
+    };
+}

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

@@ -1,36 +1,51 @@
-import { generateText, jsonSchema, streamText, tool } from 'ai';
+import { generateText, jsonSchema, streamText, tool, } from 'ai';
+import { Data, Effect, Option, Predicate, Stream } from 'effect';
+import { asJson } from '@swirls/looms/core';
 import { toLoomsToolCalls, toModelMessages } from './messages.js';
+class VercelLlmError extends Data.TaggedError('VercelLlmError') {
+    constructor(cause) {
+        super({
+            cause,
+            message: cause instanceof Error ? cause.message : String(cause),
+        });
+        this.name = 'VercelLlmError';
+    }
+}
+function isJsonSchema(value) {
+    return Predicate.isReadonlyObject(value) && !Array.isArray(value);
+}
 function toAiTools(specs) {
-    return Object.fromEntries(specs.map((spec) => [
-        spec.name,
-        tool({
-            description: spec.description,
-            // SAFETY: LlmToolSpec.inputJsonSchema is JSON Schema produced by toolJsonSchema.
-            inputSchema: jsonSchema(spec.inputJsonSchema),
-        }),
-    ]));
+    return Object.fromEntries(specs.map((spec) => {
+        if (!isJsonSchema(spec.inputJsonSchema)) {
+            throw new VercelLlmError(`Invalid JSON Schema for tool "${spec.name}"`);
+        }
+        return [
+            spec.name,
+            tool({
+                description: spec.description,
+                inputSchema: jsonSchema(spec.inputJsonSchema),
+            }),
+        ];
+    }));
 }
 function toolCallInput(call) {
     const input = 'input' in call ? call.input : {};
-    // SAFETY: AI SDK tool-call input is JSON produced by the model against our schema.
-    return (input ?? {});
+    return asJson(input ?? {});
 }
 export function vercelLlm(options) {
     const streamEnabled = options.stream !== false;
     return {
-        async complete(args) {
+        complete: (args) => Effect.runPromise(Effect.gen(function* () {
             const messages = toModelMessages(args.messages);
             const tools = args.toolSpecs && args.toolSpecs.length > 0 ? toAiTools(args.toolSpecs) : undefined;
-            const shouldStream = streamEnabled && args.onTextDelta !== undefined;
-            if (shouldStream) {
+            if (streamEnabled && args.onTextDelta) {
                 const result = tools
                     ? streamText({
                         model: options.model,
                         instructions: args.instructions,
                         messages,
                         abortSignal: args.signal,
-                        // SAFETY: VercelAiTool values are `tool()` instances from the AI SDK.
-                        tools: tools,
+                        tools,
                     })
                     : streamText({
                         model: options.model,
@@ -38,16 +53,21 @@ export function vercelLlm(options) {
                         messages,
                         abortSignal: args.signal,
                     });
-                for await (const part of result.fullStream) {
-                    if (part.type === 'text-delta') {
-                        const delta = 'text' in part ? part.text : '';
-                        if (delta) {
-                            await args.onTextDelta?.(delta);
-                        }
-                    }
-                }
-                try {
-                    const [text, rawToolCalls] = await Promise.all([result.text, result.toolCalls]);
+                yield* Stream.fromAsyncIterable(result.fullStream, (cause) => new VercelLlmError(cause)).pipe(Stream.runForEach((part) => {
+                    const delta = part.type === 'text-delta' && 'text' in part ? part.text : '';
+                    return delta
+                        ? Effect.tryPromise({
+                            try: () => Promise.resolve(args.onTextDelta?.(delta)),
+                            catch: (cause) => new VercelLlmError(cause),
+                        })
+                        : Effect.void;
+                }));
+                const streamed = yield* Effect.tryPromise({
+                    try: () => Promise.all([result.text, result.toolCalls]),
+                    catch: (cause) => new VercelLlmError(cause),
+                }).pipe(Effect.asSome, Effect.catchIf((error) => error.message.includes('No output generated'), () => Effect.succeedNone));
+                if (Option.isSome(streamed)) {
+                    const [text, rawToolCalls] = streamed.value;
                     const toolCalls = toLoomsToolCalls(rawToolCalls.map((call) => ({
                         toolCallId: call.toolCallId,
                         toolName: call.toolName,
@@ -59,26 +79,26 @@ export function vercelLlm(options) {
                         usage: { input: 0, output: text.length },
                     };
                 }
-                catch (err) {
-                    if (!(err instanceof Error) || !err.message.includes('No output generated')) {
-                        throw err;
-                    }
-                }
             }
             const result = tools
-                ? await generateText({
-                    model: options.model,
-                    instructions: args.instructions,
-                    messages,
-                    abortSignal: args.signal,
-                    // SAFETY: VercelAiTool values are `tool()` instances from the AI SDK.
-                    tools: tools,
+                ? yield* Effect.tryPromise({
+                    try: () => generateText({
+                        model: options.model,
+                        instructions: args.instructions,
+                        messages,
+                        abortSignal: args.signal,
+                        tools,
+                    }),
+                    catch: (cause) => new VercelLlmError(cause),
                 })
-                : await generateText({
-                    model: options.model,
-                    instructions: args.instructions,
-                    messages,
-                    abortSignal: args.signal,
+                : yield* Effect.tryPromise({
+                    try: () => generateText({
+                        model: options.model,
+                        instructions: args.instructions,
+                        messages,
+                        abortSignal: args.signal,
+                    }),
+                    catch: (cause) => new VercelLlmError(cause),
                 });
             const toolCalls = toLoomsToolCalls(result.toolCalls.map((call) => ({
                 toolCallId: call.toolCallId,
@@ -93,6 +113,6 @@ export function vercelLlm(options) {
                     output: result.usage?.outputTokens ?? result.text.length,
                 },
             };
-        },
+        })),
     };
 }