@ekairos/thread 1.21.88-beta.0

package/dist/schema.js

@@ -0,0 +1,200 @@
+import { i } from "@instantdb/core";
+import { domain } from "@ekairos/domain";
+export const threadDomain = domain("thread")
+    .schema({
+    entities: {
+        thread_threads: i.entity({
+            createdAt: i.date(),
+            updatedAt: i.date().optional(),
+            key: i.string().optional().indexed().unique(),
+            name: i.string().optional(),
+            status: i.string().optional().indexed(), // open | streaming | closed | failed
+        }),
+        thread_contexts: i.entity({
+            createdAt: i.date(),
+            updatedAt: i.date().optional(),
+            status: i.string().optional().indexed(), // open | streaming | closed
+            content: i.any().optional(),
+        }),
+        thread_items: i.entity({
+            channel: i.string().indexed(),
+            createdAt: i.date().indexed(),
+            type: i.string().optional().indexed(),
+            content: i.any().optional(),
+            status: i.string().optional().indexed(),
+        }),
+        thread_executions: i.entity({
+            createdAt: i.date(),
+            updatedAt: i.date().optional(),
+            status: i.string().optional().indexed(), // executing | completed | failed
+            workflowRunId: i.string().optional().indexed(),
+        }),
+        thread_steps: i.entity({
+            createdAt: i.date().indexed(),
+            updatedAt: i.date().optional(),
+            status: i.string().optional().indexed(), // running | completed | failed
+            iteration: i.number().indexed(),
+            // Deterministic ids generated in step runtime; stored for convenience/debugging
+            executionId: i.string().indexed(),
+            triggerEventId: i.string().indexed().optional(),
+            reactionEventId: i.string().indexed().optional(),
+            eventId: i.string().indexed(),
+            toolCalls: i.any().optional(),
+            toolExecutionResults: i.any().optional(),
+            continueLoop: i.boolean().optional(),
+            errorText: i.string().optional(),
+        }),
+        // Normalized parts (parts-first persistence). These hang off the step that produced them.
+        // We still keep `thread_items.content.parts` for back-compat.
+        thread_parts: i.entity({
+            key: i.string().unique().indexed(), // `${stepId}:${idx}`
+            stepId: i.string().indexed(),
+            idx: i.number().indexed(),
+            type: i.string().optional().indexed(),
+            part: i.any().optional(),
+            updatedAt: i.date().optional(),
+        }),
+        thread_trace_events: i.entity({
+            key: i.string().unique().indexed(), // `${workflowRunId}:${eventId}`
+            workflowRunId: i.string().indexed(),
+            seq: i.number().indexed(),
+            eventId: i.string().indexed(),
+            eventKind: i.string().indexed(),
+            eventAt: i.date().optional(),
+            ingestedAt: i.date().optional(),
+            orgId: i.string().optional().indexed(),
+            projectId: i.string().optional().indexed(),
+            contextKey: i.string().optional().indexed(),
+            contextId: i.string().optional().indexed(),
+            executionId: i.string().optional().indexed(),
+            stepId: i.string().optional().indexed(),
+            contextEventId: i.string().optional().indexed(),
+            toolCallId: i.string().optional().indexed(),
+            partKey: i.string().optional().indexed(),
+            partIdx: i.number().optional().indexed(),
+            spanId: i.string().optional().indexed(),
+            parentSpanId: i.string().optional().indexed(),
+            isDeleted: i.boolean().optional(),
+            aiProvider: i.string().optional().indexed(),
+            aiModel: i.string().optional().indexed(),
+            promptTokens: i.number().optional(),
+            promptTokensCached: i.number().optional(),
+            promptTokensUncached: i.number().optional(),
+            completionTokens: i.number().optional(),
+            totalTokens: i.number().optional(),
+            latencyMs: i.number().optional(),
+            cacheCostUsd: i.number().optional(),
+            computeCostUsd: i.number().optional(),
+            costUsd: i.number().optional(),
+            payload: i.any().optional(),
+        }),
+        thread_trace_runs: i.entity({
+            workflowRunId: i.string().unique().indexed(),
+            orgId: i.string().optional().indexed(),
+            projectId: i.string().optional().indexed(),
+            firstEventAt: i.date().optional().indexed(),
+            lastEventAt: i.date().optional().indexed(),
+            lastIngestedAt: i.date().optional().indexed(),
+            eventsCount: i.number().optional(),
+            status: i.string().optional().indexed(),
+            payload: i.any().optional(),
+        }),
+        thread_trace_spans: i.entity({
+            spanId: i.string().unique().indexed(),
+            parentSpanId: i.string().optional().indexed(),
+            workflowRunId: i.string().indexed(),
+            executionId: i.string().optional().indexed(),
+            stepId: i.string().optional().indexed(),
+            kind: i.string().optional().indexed(),
+            name: i.string().optional().indexed(),
+            status: i.string().optional().indexed(),
+            startedAt: i.date().optional().indexed(),
+            endedAt: i.date().optional().indexed(),
+            durationMs: i.number().optional(),
+            payload: i.any().optional(),
+        }),
+        // Documents (moved from schema-document.ts)
+        document_documents: i.entity({
+            name: i.string().optional().indexed(),
+            mimeType: i.string().optional(),
+            size: i.number().optional(),
+            ownerId: i.string().optional().indexed(),
+            orgId: i.string().optional().indexed(),
+            createdAt: i.date().optional().indexed(),
+            processedAt: i.date().optional().indexed(),
+            updatedAt: i.date().optional(),
+            lastJobId: i.string().optional(),
+            content: i.json().optional(), // Store parsed content (pages, text, etc.)
+        }),
+    },
+    links: {
+        // Contexts belong to a thread
+        threadContextsThread: {
+            forward: { on: "thread_contexts", has: "one", label: "thread" },
+            reverse: { on: "thread_threads", has: "many", label: "contexts" },
+        },
+        // Items belong to a thread (conversation timeline)
+        threadItemsThread: {
+            forward: { on: "thread_items", has: "one", label: "thread" },
+            reverse: { on: "thread_threads", has: "many", label: "items" },
+        },
+        threadItemsContext: {
+            forward: { on: "thread_items", has: "one", label: "context" },
+            reverse: { on: "thread_contexts", has: "many", label: "items" },
+        },
+        // Executions belong to a context
+        threadExecutionsContext: {
+            forward: { on: "thread_executions", has: "one", label: "context" },
+            reverse: { on: "thread_contexts", has: "many", label: "executions" },
+        },
+        // Executions also belong to a thread
+        threadExecutionsThread: {
+            forward: { on: "thread_executions", has: "one", label: "thread" },
+            reverse: { on: "thread_threads", has: "many", label: "executions" },
+        },
+        // Current execution pointer on a context
+        threadContextsCurrentExecution: {
+            forward: { on: "thread_contexts", has: "one", label: "currentExecution" },
+            reverse: { on: "thread_executions", has: "one", label: "currentOf" },
+        },
+        // Link execution to its trigger event
+        threadExecutionsTrigger: {
+            forward: { on: "thread_executions", has: "one", label: "trigger" },
+            reverse: { on: "thread_items", has: "many", label: "executionsAsTrigger" },
+        },
+        // Link execution to its reaction event
+        threadExecutionsReaction: {
+            forward: { on: "thread_executions", has: "one", label: "reaction" },
+            reverse: { on: "thread_items", has: "many", label: "executionsAsReaction" },
+        },
+        // Steps belong to an execution
+        threadStepsExecution: {
+            forward: { on: "thread_steps", has: "one", label: "execution" },
+            reverse: { on: "thread_executions", has: "many", label: "steps" },
+        },
+        // Iteration events belong to an execution (enables: event -> execution -> steps)
+        threadExecutionItems: {
+            forward: { on: "thread_items", has: "one", label: "execution" },
+            reverse: { on: "thread_executions", has: "many", label: "items" },
+        },
+        // Parts belong to a step
+        threadPartsStep: {
+            forward: { on: "thread_parts", has: "one", label: "step" },
+            reverse: { on: "thread_steps", has: "many", label: "parts" },
+        },
+        // Documents (moved from schema-document.ts)
+        documentFile: {
+            forward: {
+                on: "document_documents",
+                has: "one",
+                label: "file",
+            },
+            reverse: {
+                on: "$files",
+                has: "one",
+                label: "document",
+            },
+        },
+    },
+    rooms: {},
+});

package/dist/steps/do-story-stream-step.d.ts

@@ -0,0 +1,29 @@
+import type { ModelMessage } from "ai";
+import type { ContextEvent } from "../story.store.js";
+import type { SerializableToolForModel } from "../tools-to-model-tools.js";
+/**
+ * Runs a single LLM streaming step as a Workflow step.
+ *
+ * - Performs the provider/network call in a step (Node/runtime allowed).
+ * - Pipes AI SDK UI message chunks into the workflow-owned writable stream.
+ * - Returns the assistant event + extracted tool calls for the workflow loop.
+ */
+export declare function doStoryStreamStep(params: {
+    model: any;
+    system: string;
+    messages: ModelMessage[];
+    tools: Record<string, SerializableToolForModel>;
+    eventId: string;
+    maxSteps: number;
+    /**
+     * Whether to emit a `start` chunk for this streamed assistant message.
+     *
+     * IMPORTANT:
+     * Our story loop may call the model multiple times within a single "turn" while continuing
+     * to append to the same `eventId`. In that case, `start` must only be sent once.
+     */
+    sendStart?: boolean;
+}): Promise<{
+    assistantEvent: ContextEvent;
+    toolCalls: import("../story.toolcalls.js").ToolCall[];
+}>;

package/dist/steps/do-story-stream-step.js

@@ -0,0 +1,89 @@
+/**
+ * Runs a single LLM streaming step as a Workflow step.
+ *
+ * - Performs the provider/network call in a step (Node/runtime allowed).
+ * - Pipes AI SDK UI message chunks into the workflow-owned writable stream.
+ * - Returns the assistant event + extracted tool calls for the workflow loop.
+ */
+export async function doStoryStreamStep(params) {
+    "use step";
+    const { getWritable } = await import("workflow");
+    const writable = getWritable();
+    const { jsonSchema, gateway, smoothStream, stepCountIs, streamText } = await import("ai");
+    const { extractToolCallsFromParts } = await import("@ekairos/thread");
+    // Match DurableAgent's model init behavior:
+    // - string => AI Gateway model id, resolved via `gateway(...)` in the step runtime
+    // - function => model factory (should be a `"use step"` function for workflow serialization)
+    const resolvedModel = typeof params.model === "string"
+        ? gateway(params.model)
+        : typeof params.model === "function"
+            ? await params.model()
+            : params.model;
+    // IMPORTANT:
+    // `streamText` expects tools in the AI SDK ToolSet shape, where `inputSchema` is a Schema-like value.
+    // We pass plain JSON schema objects across the step boundary (serializable), then wrap them here with
+    // `jsonSchema(...)` so the AI SDK does not attempt Zod conversion at runtime.
+    const toolsForStreamText = {};
+    for (const [name, t] of Object.entries(params.tools)) {
+        toolsForStreamText[name] = {
+            description: t?.description,
+            inputSchema: jsonSchema(t.inputSchema),
+        };
+    }
+    const result = streamText({
+        model: resolvedModel,
+        system: params.system,
+        messages: params.messages,
+        tools: toolsForStreamText,
+        toolChoice: "required",
+        stopWhen: stepCountIs(params.maxSteps),
+        experimental_transform: smoothStream({ delayInMs: 30, chunking: "word" }),
+    });
+    // Ensure the underlying stream is consumed (AI SDK requirement)
+    result.consumeStream();
+    let resolveFinish;
+    let rejectFinish;
+    const finishPromise = new Promise((resolve, reject) => {
+        resolveFinish = resolve;
+        rejectFinish = reject;
+    });
+    const uiStream = result
+        .toUIMessageStream({
+        // Emit `start` only when the engine says so (typically once per turn).
+        sendStart: Boolean(params.sendStart),
+        generateMessageId: () => params.eventId,
+        messageMetadata() {
+            return { eventId: params.eventId };
+        },
+        onFinish: ({ messages }) => {
+            const lastMessage = messages[messages.length - 1];
+            const event = {
+                id: params.eventId,
+                type: "assistant.message",
+                channel: "web",
+                createdAt: new Date().toISOString(),
+                content: { parts: lastMessage?.parts ?? [] },
+            };
+            resolveFinish(event);
+        },
+        onError: (e) => {
+            rejectFinish(e);
+            return e instanceof Error ? e.message : String(e);
+        },
+    })
+        // Filter out per-step finish boundary. Workflow will emit a single finish.
+        .pipeThrough(new TransformStream({
+        transform(chunk, controller) {
+            if (chunk.type === "finish")
+                return;
+            controller.enqueue(chunk);
+        },
+    }));
+    await uiStream.pipeTo(writable, { preventClose: true });
+    const assistantEvent = await finishPromise;
+    const toolCalls = extractToolCallsFromParts(assistantEvent?.content?.parts);
+    return {
+        assistantEvent,
+        toolCalls,
+    };
+}

package/dist/steps/do-thread-stream-step.d.ts

@@ -0,0 +1,29 @@
+import type { ModelMessage } from "ai";
+import type { ThreadItem } from "../thread.store.js";
+import type { SerializableToolForModel } from "../tools-to-model-tools.js";
+/**
+ * Runs a single LLM streaming step as a Workflow step.
+ *
+ * - Performs the provider/network call in a step (Node/runtime allowed).
+ * - Pipes AI SDK UI message chunks into the workflow-owned writable stream.
+ * - Returns the assistant event + extracted tool calls for the workflow loop.
+ */
+export declare function doThreadStreamStep(params: {
+    model: any;
+    system: string;
+    messages: ModelMessage[];
+    tools: Record<string, SerializableToolForModel>;
+    eventId: string;
+    maxSteps: number;
+    /**
+     * Whether to emit a `start` chunk for this streamed assistant message.
+     *
+     * IMPORTANT:
+     * Our thread loop may call the model multiple times within a single "turn" while continuing
+     * to append to the same `eventId`. In that case, `start` must only be sent once.
+     */
+    sendStart?: boolean;
+}): Promise<{
+    assistantEvent: ThreadItem;
+    toolCalls: import("../thread.toolcalls.js").ToolCall[];
+}>;

package/dist/steps/do-thread-stream-step.js

@@ -0,0 +1,90 @@
+import { OUTPUT_TEXT_ITEM_TYPE } from "../thread.events.js";
+/**
+ * Runs a single LLM streaming step as a Workflow step.
+ *
+ * - Performs the provider/network call in a step (Node/runtime allowed).
+ * - Pipes AI SDK UI message chunks into the workflow-owned writable stream.
+ * - Returns the assistant event + extracted tool calls for the workflow loop.
+ */
+export async function doThreadStreamStep(params) {
+    "use step";
+    const { getWritable } = await import("workflow");
+    const writable = getWritable();
+    const { jsonSchema, gateway, smoothStream, stepCountIs, streamText } = await import("ai");
+    const { extractToolCallsFromParts } = await import("@ekairos/thread");
+    // Match DurableAgent's model init behavior:
+    // - string => AI Gateway model id, resolved via `gateway(...)` in the step runtime
+    // - function => model factory (should be a `"use step"` function for workflow serialization)
+    const resolvedModel = typeof params.model === "string"
+        ? gateway(params.model)
+        : typeof params.model === "function"
+            ? await params.model()
+            : params.model;
+    // IMPORTANT:
+    // `streamText` expects tools in the AI SDK ToolSet shape, where `inputSchema` is a Schema-like value.
+    // We pass plain JSON schema objects across the step boundary (serializable), then wrap them here with
+    // `jsonSchema(...)` so the AI SDK does not attempt Zod conversion at runtime.
+    const toolsForStreamText = {};
+    for (const [name, t] of Object.entries(params.tools)) {
+        toolsForStreamText[name] = {
+            description: t?.description,
+            inputSchema: jsonSchema(t.inputSchema),
+        };
+    }
+    const result = streamText({
+        model: resolvedModel,
+        system: params.system,
+        messages: params.messages,
+        tools: toolsForStreamText,
+        toolChoice: "required",
+        stopWhen: stepCountIs(params.maxSteps),
+        experimental_transform: smoothStream({ delayInMs: 30, chunking: "word" }),
+    });
+    // Ensure the underlying stream is consumed (AI SDK requirement)
+    result.consumeStream();
+    let resolveFinish;
+    let rejectFinish;
+    const finishPromise = new Promise((resolve, reject) => {
+        resolveFinish = resolve;
+        rejectFinish = reject;
+    });
+    const uiStream = result
+        .toUIMessageStream({
+        // Emit `start` only when the engine says so (typically once per turn).
+        sendStart: Boolean(params.sendStart),
+        generateMessageId: () => params.eventId,
+        messageMetadata() {
+            return { eventId: params.eventId };
+        },
+        onFinish: ({ messages }) => {
+            const lastMessage = messages[messages.length - 1];
+            const event = {
+                id: params.eventId,
+                type: OUTPUT_TEXT_ITEM_TYPE,
+                channel: "web",
+                createdAt: new Date().toISOString(),
+                content: { parts: lastMessage?.parts ?? [] },
+            };
+            resolveFinish(event);
+        },
+        onError: (e) => {
+            rejectFinish(e);
+            return e instanceof Error ? e.message : String(e);
+        },
+    })
+        // Filter out per-step finish boundary. Workflow will emit a single finish.
+        .pipeThrough(new TransformStream({
+        transform(chunk, controller) {
+            if (chunk.type === "finish")
+                return;
+            controller.enqueue(chunk);
+        },
+    }));
+    await uiStream.pipeTo(writable, { preventClose: true });
+    const assistantEvent = await finishPromise;
+    const toolCalls = extractToolCallsFromParts(assistantEvent?.content?.parts);
+    return {
+        assistantEvent,
+        toolCalls,
+    };
+}

package/dist/steps/mirror.steps.d.ts

@@ -0,0 +1,6 @@
+import type { ThreadEnvironment } from "../thread.config.js";
+import type { ThreadMirrorWrite } from "../mirror.js";
+export declare function mirrorThreadWrites(params: {
+    env: ThreadEnvironment;
+    writes: ThreadMirrorWrite[];
+}): Promise<void>;

package/dist/steps/mirror.steps.js

@@ -0,0 +1,48 @@
+function requireOrgId(env) {
+    const orgId = env?.orgId;
+    if (typeof orgId !== "string" || !orgId) {
+        throw new Error("[thread/mirror] Missing env.orgId");
+    }
+    return orgId;
+}
+function requireBaseUrl() {
+    const baseUrl = process.env.EKAIROS_CORE_BASE_URL ||
+        process.env.EKAIROS_MIRROR_BASE_URL ||
+        process.env.EKAIROS_BASE_URL;
+    if (!baseUrl) {
+        throw new Error("[thread/mirror] Missing EKAIROS_CORE_BASE_URL (or EKAIROS_MIRROR_BASE_URL)");
+    }
+    return baseUrl.replace(/\/$/, "");
+}
+function requireToken() {
+    // Preferred: Clerk org API key (opaque token) for ekairos-core.
+    const apiKey = process.env.EKAIROS_CLERK_API_KEY;
+    if (apiKey)
+        return apiKey;
+    // Fallback: shared secret token.
+    const token = process.env.EKAIROS_THREAD_MIRROR_TOKEN;
+    if (token)
+        return token;
+    throw new Error("[thread/mirror] Missing EKAIROS_CLERK_API_KEY (or EKAIROS_THREAD_MIRROR_TOKEN fallback)");
+}
+export async function mirrorThreadWrites(params) {
+    "use step";
+    if (!params.writes?.length)
+        return;
+    const orgId = requireOrgId(params.env);
+    const baseUrl = requireBaseUrl();
+    const token = requireToken();
+    const body = { orgId, writes: params.writes };
+    const res = await fetch(`${baseUrl}/api/thread`, {
+        method: "POST",
+        headers: {
+            "content-type": "application/json",
+            authorization: `Bearer ${token}`,
+        },
+        body: JSON.stringify(body),
+    });
+    if (!res.ok) {
+        const text = await res.text().catch(() => "");
+        throw new Error(`[thread/mirror] ekairos-core write failed (${res.status}): ${text}`);
+    }
+}

package/dist/steps/reaction.steps.d.ts

@@ -0,0 +1,43 @@
+import type { ModelMessage, UIMessageChunk } from "ai";
+import type { ThreadEnvironment } from "../thread.config.js";
+import type { ThreadItem, ContextIdentifier } from "../thread.store.js";
+import type { SerializableToolForModel } from "../tools-to-model-tools.js";
+/**
+ * Executes a full "reaction" inside a single workflow step:
+ * - load events from store
+ * - convert events to model messages
+ * - run the streaming model call and emit chunks
+ * - extract tool calls from the resulting assistant event
+ */
+export declare function executeReaction(params: {
+    env: ThreadEnvironment;
+    contextIdentifier: ContextIdentifier;
+    model: any;
+    system: string;
+    tools: Record<string, SerializableToolForModel>;
+    eventId: string;
+    iteration?: number;
+    maxSteps: number;
+    sendStart?: boolean;
+    silent?: boolean;
+    writable?: WritableStream<UIMessageChunk>;
+    executionId?: string;
+    contextId?: string;
+    stepId?: string;
+}): Promise<{
+    assistantEvent: ThreadItem;
+    toolCalls: any[];
+    messagesForModel: ModelMessage[];
+    llm?: {
+        provider?: string;
+        model?: string;
+        promptTokens?: number;
+        promptTokensCached?: number;
+        promptTokensUncached?: number;
+        completionTokens?: number;
+        totalTokens?: number;
+        latencyMs?: number;
+        rawUsage?: any;
+        rawProviderMetadata?: any;
+    };
+}>;