@swirls/looms 0.0.1

package/dist/ai-vercel/messages.js

@@ -0,0 +1,68 @@
+import {} from 'ai';
+export function toModelMessages(messages) {
+    const converted = [];
+    for (const message of messages) {
+        switch (message.role) {
+            case 'system':
+                break;
+            case 'user':
+                converted.push({ role: 'user', content: message.content });
+                break;
+            case 'assistant': {
+                const toolCalls = message.toolCalls ?? [];
+                if (toolCalls.length === 0) {
+                    converted.push({ role: 'assistant', content: message.content });
+                    break;
+                }
+                const content = [];
+                if (message.content) {
+                    content.push({ type: 'text', text: message.content });
+                }
+                for (const toolCall of toolCalls) {
+                    content.push({
+                        type: 'tool-call',
+                        toolCallId: toolCall.id,
+                        toolName: toolCall.name,
+                        input: toolCall.arguments,
+                    });
+                }
+                converted.push({ role: 'assistant', content });
+                break;
+            }
+            case 'tool':
+                converted.push({
+                    role: 'tool',
+                    content: [
+                        {
+                            type: 'tool-result',
+                            toolCallId: message.toolCallId ?? message.name ?? 'unknown',
+                            toolName: message.name ?? 'unknown',
+                            output: parseToolOutput(message.content),
+                        },
+                    ],
+                });
+                break;
+            default: {
+                const exhaustiveCheck = message.role;
+                return exhaustiveCheck;
+            }
+        }
+    }
+    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 };
+    }
+}
+export function toLoomsToolCalls(calls) {
+    return calls.map((call) => ({
+        id: call.toolCallId,
+        name: call.toolName,
+        arguments: call.input,
+    }));
+}

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

@@ -0,0 +1,8 @@
+import { type LanguageModel } from 'ai';
+import type { LlmAdapter } from '@swirls/looms/agent';
+export interface VercelLlmOptions {
+    readonly model: LanguageModel;
+    /** Prefer streamText when the turn supplies `onTextDelta`. Default true. */
+    readonly stream?: boolean;
+}
+export declare function vercelLlm(options: VercelLlmOptions): LlmAdapter;

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

@@ -0,0 +1,98 @@
+import { generateText, jsonSchema, streamText, tool } from 'ai';
+import { toLoomsToolCalls, toModelMessages } from './messages.js';
+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),
+        }),
+    ]));
+}
+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 ?? {});
+}
+export function vercelLlm(options) {
+    const streamEnabled = options.stream !== false;
+    return {
+        async complete(args) {
+            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) {
+                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,
+                    })
+                    : streamText({
+                        model: options.model,
+                        instructions: args.instructions,
+                        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]);
+                    const toolCalls = toLoomsToolCalls(rawToolCalls.map((call) => ({
+                        toolCallId: call.toolCallId,
+                        toolName: call.toolName,
+                        input: toolCallInput(call),
+                    })));
+                    return {
+                        message: { role: 'assistant', content: text, toolCalls },
+                        toolCalls,
+                        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,
+                })
+                : await generateText({
+                    model: options.model,
+                    instructions: args.instructions,
+                    messages,
+                    abortSignal: args.signal,
+                });
+            const toolCalls = toLoomsToolCalls(result.toolCalls.map((call) => ({
+                toolCallId: call.toolCallId,
+                toolName: call.toolName,
+                input: toolCallInput(call),
+            })));
+            return {
+                message: { role: 'assistant', content: result.text, toolCalls },
+                toolCalls,
+                usage: {
+                    input: result.usage?.inputTokens ?? 0,
+                    output: result.usage?.outputTokens ?? result.text.length,
+                },
+            };
+        },
+    };
+}

package/dist/approval/effects.d.ts

@@ -0,0 +1,133 @@
+export declare const requestApprovalEffect: NoInfer<import("@swirls/looms/core").EffectDefinition<{
+    readonly approvalId: string;
+    readonly title: string;
+    readonly description?: string | undefined;
+    readonly actions: readonly {
+        readonly id: string;
+        readonly label: string;
+        readonly outcome: "approve" | "reject";
+    }[];
+    readonly schema?: import("effect/Schema").Json | undefined;
+}, never, (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+    readonly type: "approval.decided";
+    readonly payload: {
+        readonly approvalId: string;
+        readonly actionId: string;
+        readonly outcome: "approve" | "reject";
+        readonly payload?: import("effect/Schema").Json | undefined;
+    };
+}) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+    readonly type: "approval.requested";
+    readonly payload: {
+        readonly approvalId: string;
+        readonly title: string;
+        readonly description?: string | undefined;
+        readonly actions: readonly {
+            readonly id: string;
+            readonly label: string;
+            readonly outcome: "approve" | "reject";
+        }[];
+        readonly schema?: import("effect/Schema").Json | undefined;
+    };
+}) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+    readonly type: "approval.timed_out";
+    readonly payload: {
+        readonly approvalId: string;
+    };
+}) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+    readonly type: "runtime.effect.failed";
+    readonly payload: {
+        readonly effectId: string;
+        readonly error: string;
+    };
+}) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+    readonly type: "runtime.run.completed";
+    readonly payload: {
+        readonly output: import("effect/Schema").Json;
+        readonly error: string | null;
+    };
+}) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+    readonly type: "runtime.run.started";
+    readonly payload: {
+        readonly rootThreadId?: string | undefined;
+        readonly kind: string;
+        readonly definitionName: string;
+        readonly input: import("effect/Schema").Json;
+    };
+}) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+    readonly type: "runtime.signal.received";
+    readonly payload: {
+        readonly signalType: string;
+    };
+}) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+    readonly type: "runtime.snapshot.taken";
+    readonly payload: {
+        readonly seq: number;
+        readonly stateHash: string;
+        readonly state?: import("effect/Schema").Json | undefined;
+    };
+}) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+    readonly type: "runtime.thread.cancelled";
+    readonly payload: {
+        readonly threadId: string;
+        readonly reason?: string | undefined;
+    };
+}) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+    readonly type: "runtime.thread.completed";
+    readonly payload: {
+        readonly threadId: string;
+        readonly output: import("effect/Schema").Json;
+    };
+}) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+    readonly type: "runtime.thread.failed";
+    readonly payload: {
+        readonly threadId: string;
+        readonly error: string;
+    };
+}) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+    readonly type: "runtime.thread.started";
+    readonly payload: {
+        readonly threadId: string;
+        readonly kind: string;
+        readonly definitionName: string;
+        readonly input: import("effect/Schema").Json;
+        readonly parentThreadId: string | null;
+    };
+}) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+    readonly type: "runtime.timer.fired";
+    readonly payload: {
+        readonly timerId: string;
+        readonly waitId: string;
+    };
+}) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+    readonly type: "runtime.timer.set";
+    readonly payload: {
+        readonly timerId: string;
+        readonly waitId: string;
+        readonly wakeAt: number;
+    };
+}) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+    readonly type: "runtime.wait.registered";
+    readonly payload: {
+        readonly waitId: string;
+        readonly threadId?: string | undefined;
+        readonly on: {
+            readonly type: string | readonly string[];
+            readonly match?: import("effect/Schema").Json | undefined;
+        } | {
+            readonly timerAt: number;
+        };
+        readonly tag?: import("effect/Schema").Json | undefined;
+    };
+}) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+    readonly type: "runtime.wait.satisfied";
+    readonly payload: {
+        readonly waitId: string;
+        readonly tag?: import("effect/Schema").Json | undefined;
+        readonly event: {
+            readonly id: string;
+            readonly type: string;
+            readonly payload: import("effect/Schema").Json;
+        };
+    };
+})>>;

package/dist/approval/effects.js

@@ -0,0 +1,13 @@
+import { ApprovalRequestedPayloadSchema } from './events.js';
+import { approvalModule } from './scope.js';
+export const requestApprovalEffect = approvalModule.effect({
+    type: 'approval.request',
+    input: ApprovalRequestedPayloadSchema,
+    execute: (input, ctx) => [
+        {
+            type: 'approval.requested',
+            payload: input,
+            threadId: ctx.threadId,
+        },
+    ],
+});

package/dist/approval/events.d.ts

@@ -0,0 +1,52 @@
+import { Schema } from 'effect';
+export declare const ApprovalActionSchema: Schema.Struct<{
+    readonly id: Schema.String;
+    readonly label: Schema.String;
+    readonly outcome: Schema.Union<readonly [Schema.Literal<"approve">, Schema.Literal<"reject">]>;
+}>;
+export type ApprovalAction = Schema.Schema.Type<typeof ApprovalActionSchema>;
+export declare const ApprovalRequestedPayloadSchema: Schema.Struct<{
+    readonly approvalId: Schema.String;
+    readonly title: Schema.String;
+    readonly description: Schema.optional<Schema.String>;
+    readonly actions: Schema.$Array<Schema.Struct<{
+        readonly id: Schema.String;
+        readonly label: Schema.String;
+        readonly outcome: Schema.Union<readonly [Schema.Literal<"approve">, Schema.Literal<"reject">]>;
+    }>>;
+    readonly schema: Schema.optional<Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+}>;
+export type ApprovalRequested = Schema.Schema.Type<typeof ApprovalRequestedPayloadSchema>;
+export declare const ApprovalDecidedPayloadSchema: Schema.Struct<{
+    readonly approvalId: Schema.String;
+    readonly actionId: Schema.String;
+    readonly outcome: Schema.Union<readonly [Schema.Literal<"approve">, Schema.Literal<"reject">]>;
+    readonly payload: Schema.optional<Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+}>;
+export type ApprovalDecided = Schema.Schema.Type<typeof ApprovalDecidedPayloadSchema>;
+export declare const ApprovalTimedOutPayloadSchema: Schema.Struct<{
+    readonly approvalId: Schema.String;
+}>;
+export type ApprovalTimedOut = Schema.Schema.Type<typeof ApprovalTimedOutPayloadSchema>;
+export declare const approvalCatalog: import("@swirls/looms/core").EventCatalog<"approval", {
+    requested: Schema.Struct<{
+        readonly approvalId: Schema.String;
+        readonly title: Schema.String;
+        readonly description: Schema.optional<Schema.String>;
+        readonly actions: Schema.$Array<Schema.Struct<{
+            readonly id: Schema.String;
+            readonly label: Schema.String;
+            readonly outcome: Schema.Union<readonly [Schema.Literal<"approve">, Schema.Literal<"reject">]>;
+        }>>;
+        readonly schema: Schema.optional<Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+    }>;
+    decided: Schema.Struct<{
+        readonly approvalId: Schema.String;
+        readonly actionId: Schema.String;
+        readonly outcome: Schema.Union<readonly [Schema.Literal<"approve">, Schema.Literal<"reject">]>;
+        readonly payload: Schema.optional<Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+    }>;
+    timed_out: Schema.Struct<{
+        readonly approvalId: Schema.String;
+    }>;
+}>;

package/dist/approval/events.js

@@ -0,0 +1,28 @@
+import { Schema } from 'effect';
+import { defineEventCatalog } from '@swirls/looms/core';
+export const ApprovalActionSchema = Schema.Struct({
+    id: Schema.String,
+    label: Schema.String,
+    outcome: Schema.Union([Schema.Literal('approve'), Schema.Literal('reject')]),
+});
+export const ApprovalRequestedPayloadSchema = Schema.Struct({
+    approvalId: Schema.String,
+    title: Schema.String,
+    description: Schema.optional(Schema.String),
+    actions: Schema.Array(ApprovalActionSchema),
+    schema: Schema.optional(Schema.Json),
+});
+export const ApprovalDecidedPayloadSchema = Schema.Struct({
+    approvalId: Schema.String,
+    actionId: Schema.String,
+    outcome: Schema.Union([Schema.Literal('approve'), Schema.Literal('reject')]),
+    payload: Schema.optional(Schema.Json),
+});
+export const ApprovalTimedOutPayloadSchema = Schema.Struct({
+    approvalId: Schema.String,
+});
+export const approvalCatalog = defineEventCatalog('approval', {
+    requested: ApprovalRequestedPayloadSchema,
+    decided: ApprovalDecidedPayloadSchema,
+    timed_out: ApprovalTimedOutPayloadSchema,
+});

package/dist/approval/index.d.ts

@@ -0,0 +1,6 @@
+export * from './events';
+export * from './scope';
+export * from './effects';
+export * from './projections';
+export * from './signals';
+export * from './module';

package/dist/approval/index.js

@@ -0,0 +1,6 @@
+export * from './events.js';
+export * from './scope.js';
+export * from './effects.js';
+export * from './projections.js';
+export * from './signals.js';
+export * from './module.js';