@ekairos/thread 1.21.88-beta.0

package/dist/steps/reaction.steps.js

@@ -0,0 +1,354 @@
+import { OUTPUT_TEXT_ITEM_TYPE } from "../thread.events.js";
+import { writeThreadTraceEvents } from "./trace.steps.js";
+async function readWorkflowMetadata() {
+    try {
+        const { getWorkflowMetadata } = await import("workflow");
+        return getWorkflowMetadata?.() ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+async function resolveWorkflowRunId(env, executionId) {
+    const meta = await readWorkflowMetadata();
+    let runId = meta && meta.workflowRunId !== undefined && meta.workflowRunId !== null
+        ? String(meta.workflowRunId)
+        : "";
+    if (!runId) {
+        const envRunId = env?.workflowRunId;
+        if (typeof envRunId === "string" && envRunId.trim()) {
+            runId = envRunId.trim();
+        }
+    }
+    if (!runId && executionId) {
+        try {
+            const { getThreadRuntime } = await import("@ekairos/thread/runtime");
+            const runtime = await getThreadRuntime(env);
+            const db = runtime?.db;
+            if (db) {
+                const q = await db.query({
+                    thread_executions: {
+                        $: { where: { id: String(executionId) }, limit: 1 },
+                    },
+                });
+                const row = q?.thread_executions?.[0];
+                if (row?.workflowRunId) {
+                    runId = String(row.workflowRunId);
+                }
+            }
+        }
+        catch {
+            // ignore
+        }
+    }
+    return runId || undefined;
+}
+function safeErrorJson(error) {
+    const seen = new WeakSet();
+    const redactKey = (k) => /token|authorization|cookie|secret|api[_-]?key|password/i.test(k);
+    const err = error;
+    const payload = {
+        name: err?.name,
+        message: err?.message,
+        status: err?.status,
+        body: err?.body,
+        data: err?.data,
+        stack: err?.stack,
+    };
+    try {
+        return JSON.stringify(payload, (k, v) => {
+            if (redactKey(k))
+                return "[redacted]";
+            if (typeof v === "string" && v.length > 5000)
+                return "[truncated-string]";
+            if (typeof v === "object" && v !== null) {
+                if (seen.has(v))
+                    return "[circular]";
+                seen.add(v);
+            }
+            return v;
+        });
+    }
+    catch {
+        return JSON.stringify({ message: String(err?.message ?? "error") });
+    }
+}
+/**
+ * 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 async function executeReaction(params) {
+    "use step";
+    const { getThreadRuntime } = await import("@ekairos/thread/runtime");
+    const { store } = await getThreadRuntime(params.env);
+    let events;
+    try {
+        events = await store.getItems(params.contextIdentifier);
+    }
+    catch (error) {
+        console.error("[ekairos/story] reaction.step store.getItems failed");
+        throw error;
+    }
+    let messagesForModel;
+    try {
+        messagesForModel = (await store.itemsToModelMessages(events));
+    }
+    catch (error) {
+        console.error("[ekairos/story] reaction.step store.itemsToModelMessages failed", safeErrorJson(error));
+        throw error;
+    }
+    const writable = params.silent || !params.writable
+        ? new WritableStream({ write() { } })
+        : params.writable;
+    const { jsonSchema, gateway, smoothStream, stepCountIs, streamText } = await import("ai");
+    const { extractToolCallsFromParts } = await import("@ekairos/thread");
+    const isMockModelConfig = (value) => {
+        if (!value || typeof value !== "object")
+            return false;
+        if ("specificationVersion" in value)
+            return false;
+        if (value.source === "mock")
+            return true;
+        return typeof value.provider === "string" && typeof value.modelId === "string";
+    };
+    const buildMockModel = async (config) => {
+        const toolName = typeof config.toolName === "string" && config.toolName.trim()
+            ? config.toolName.trim()
+            : Object.keys(params.tools || {})[0] || "tool";
+        const provider = config.provider ?? "mock-provider";
+        const modelId = config.modelId ?? "mock-model-id";
+        return {
+            specificationVersion: "v2",
+            provider,
+            modelId,
+            supportedUrls: {},
+            doGenerate: async () => ({
+                content: [
+                    {
+                        type: "tool-call",
+                        toolCallId: "mock-tool-call",
+                        toolName,
+                        input: JSON.stringify({ instruction: "" }),
+                    },
+                ],
+                finishReason: "tool-calls",
+                usage: { inputTokens: 1, outputTokens: 1, totalTokens: 2 },
+                warnings: [],
+            }),
+            doStream: async () => {
+                const toolCallId = `mock-tool-${Date.now()}`;
+                const stream = new ReadableStream({
+                    start(controller) {
+                        controller.enqueue({ type: "stream-start", warnings: [] });
+                        controller.enqueue({
+                            type: "tool-call",
+                            toolCallId,
+                            toolName,
+                            input: JSON.stringify({ instruction: "" }),
+                        });
+                        controller.enqueue({
+                            type: "finish",
+                            finishReason: "tool-calls",
+                            usage: { inputTokens: 1, outputTokens: 1, totalTokens: 2 },
+                        });
+                        controller.close();
+                    },
+                });
+                return { stream };
+            },
+        };
+    };
+    // Match DurableAgent-style model init behavior:
+    const resolvedModel = typeof params.model === "string"
+        ? gateway(params.model)
+        : isMockModelConfig(params.model)
+            ? await buildMockModel(params.model)
+            : typeof params.model === "function"
+                ? await params.model()
+                : params.model;
+    // Wrap plain JSON Schema objects so the AI SDK doesn't 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 startedAtMs = Date.now();
+    const result = streamText({
+        model: resolvedModel,
+        system: params.system,
+        messages: messagesForModel,
+        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({
+        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 finishedAtMs = Date.now();
+    const toolCalls = extractToolCallsFromParts(assistantEvent?.content?.parts);
+    // Best-effort usage extraction (AI SDK provider dependent).
+    // We keep this loose because providers differ and SDK evolves quickly.
+    const latencyMs = Math.max(0, finishedAtMs - startedAtMs);
+    let usage = undefined;
+    let providerMetadata = undefined;
+    try {
+        usage = result?.usage;
+        if (typeof usage?.then === "function")
+            usage = await usage;
+    }
+    catch {
+        usage = undefined;
+    }
+    try {
+        providerMetadata =
+            result?.providerMetadata ??
+                result?.experimental_providerMetadata ??
+                result?.response?.providerMetadata ??
+                undefined;
+    }
+    catch {
+        providerMetadata = undefined;
+    }
+    // Workflow steps must return serializable values. Provider SDKs may include
+    // classes/streams/etc in metadata, so we defensively sanitize.
+    function toPlainJson(value) {
+        if (typeof value === "undefined")
+            return undefined;
+        try {
+            return JSON.parse(JSON.stringify(value));
+        }
+        catch {
+            return undefined;
+        }
+    }
+    const usageJson = toPlainJson(usage);
+    const providerMetadataJson = toPlainJson(providerMetadata);
+    // Derive provider/model from gateway id when available.
+    const modelId = typeof params.model === "string" ? params.model : "";
+    const provider = modelId.includes("/") ? modelId.split("/")[0] : providerMetadata?.provider;
+    const model = modelId.includes("/") ? modelId.split("/").slice(1).join("/") : providerMetadata?.model;
+    // Token accounting: attempt to read cached prompt tokens from OpenAI-like usage shapes.
+    const promptTokens = Number(usage?.promptTokens ?? usage?.prompt_tokens ?? usage?.inputTokens ?? 0) || 0;
+    const completionTokens = Number(usage?.completionTokens ?? usage?.completion_tokens ?? usage?.outputTokens ?? 0) || 0;
+    const totalTokens = Number(usage?.totalTokens ?? usage?.total_tokens ?? 0) || (promptTokens + completionTokens);
+    const cachedPromptTokens = Number(usage?.promptTokensCached ??
+        usage?.cached_prompt_tokens ??
+        usage?.prompt_tokens_details?.cached_tokens ??
+        usage?.input_tokens_details?.cached_tokens ??
+        0) || 0;
+    const uncachedPromptTokens = Math.max(0, promptTokens - cachedPromptTokens);
+    const llm = promptTokens || completionTokens || cachedPromptTokens
+        ? {
+            provider,
+            model,
+            promptTokens,
+            promptTokensCached: cachedPromptTokens,
+            promptTokensUncached: uncachedPromptTokens,
+            completionTokens,
+            totalTokens,
+            latencyMs,
+            rawUsage: usageJson,
+            rawProviderMetadata: providerMetadataJson,
+        }
+        : {
+            provider,
+            model,
+            latencyMs,
+            rawUsage: usageJson,
+            rawProviderMetadata: providerMetadataJson,
+        };
+    try {
+        const runId = await resolveWorkflowRunId(params.env, params.executionId);
+        if (runId && llm) {
+            await writeThreadTraceEvents({
+                env: params.env,
+                events: [
+                    {
+                        workflowRunId: runId,
+                        eventId: `thread_llm:${String(params.executionId ?? "unknown")}:${String(params.stepId ?? params.eventId)}:${String(params.iteration ?? 0)}`,
+                        eventKind: "thread.llm",
+                        eventAt: new Date().toISOString(),
+                        contextId: params.contextId,
+                        executionId: params.executionId,
+                        stepId: params.stepId,
+                        aiProvider: typeof llm.provider === "string" ? llm.provider : undefined,
+                        aiModel: typeof llm.model === "string" ? llm.model : undefined,
+                        promptTokens: Number.isFinite(Number(llm.promptTokens))
+                            ? Number(llm.promptTokens)
+                            : undefined,
+                        promptTokensCached: Number.isFinite(Number(llm.promptTokensCached))
+                            ? Number(llm.promptTokensCached)
+                            : undefined,
+                        promptTokensUncached: Number.isFinite(Number(llm.promptTokensUncached))
+                            ? Number(llm.promptTokensUncached)
+                            : undefined,
+                        completionTokens: Number.isFinite(Number(llm.completionTokens))
+                            ? Number(llm.completionTokens)
+                            : undefined,
+                        totalTokens: Number.isFinite(Number(llm.totalTokens))
+                            ? Number(llm.totalTokens)
+                            : undefined,
+                        latencyMs: Number.isFinite(Number(llm.latencyMs))
+                            ? Number(llm.latencyMs)
+                            : undefined,
+                        payload: {
+                            provider: llm.provider,
+                            model: llm.model,
+                            usage: llm.rawUsage,
+                            providerMetadata: llm.rawProviderMetadata,
+                            iteration: params.iteration,
+                        },
+                    },
+                ],
+            });
+        }
+    }
+    catch {
+        // tracing must not break reaction
+    }
+    return { assistantEvent, toolCalls, messagesForModel, llm };
+}

package/dist/steps/store.steps.d.ts

@@ -0,0 +1,98 @@
+import type { UIMessageChunk } from "ai";
+import type { ThreadEnvironment } from "../thread.config.js";
+import type { ThreadItem, ContextIdentifier, StoredContext } from "../thread.store.js";
+export type ThreadReviewRequest = {
+    toolCallId: string;
+    toolName?: string;
+};
+/**
+ * Initializes/ensures the story context exists and emits a single `data-context-id` chunk.
+ *
+ * This is the "context init" boundary for the story engine.
+ */
+export declare function initializeContext<C>(env: ThreadEnvironment, contextIdentifier: ContextIdentifier | null, opts?: {
+    silent?: boolean;
+    writable?: WritableStream<UIMessageChunk>;
+}): Promise<{
+    context: StoredContext<C>;
+    isNew: boolean;
+}>;
+export declare function updateContextContent<C>(env: ThreadEnvironment, contextIdentifier: ContextIdentifier, content: C): Promise<StoredContext<C>>;
+export declare function updateContextStatus(env: ThreadEnvironment, contextIdentifier: ContextIdentifier, status: "open" | "streaming" | "closed"): Promise<void>;
+export declare function saveTriggerItem(env: ThreadEnvironment, contextIdentifier: ContextIdentifier, event: ThreadItem): Promise<ThreadItem>;
+export declare function emitContextIdChunk(params: {
+    env: ThreadEnvironment;
+    contextId: string;
+    writable?: WritableStream<UIMessageChunk>;
+}): Promise<void>;
+export declare function saveTriggerAndCreateExecution(params: {
+    env: ThreadEnvironment;
+    contextIdentifier: ContextIdentifier;
+    triggerEvent: ThreadItem;
+}): Promise<{
+    triggerEvent: ThreadItem;
+    triggerEventId: string;
+    reactionEventId: string;
+    executionId: string;
+}>;
+export declare function saveReactionItem(env: ThreadEnvironment, contextIdentifier: ContextIdentifier, event: ThreadItem, opts?: {
+    executionId?: string;
+    contextId?: string;
+    reviewRequests?: ThreadReviewRequest[];
+}): Promise<ThreadItem>;
+export declare function updateItem(env: ThreadEnvironment, eventId: string, event: ThreadItem, opts?: {
+    executionId?: string;
+    contextId?: string;
+}): Promise<ThreadItem>;
+export declare function createExecution(env: ThreadEnvironment, contextIdentifier: ContextIdentifier, triggerEventId: string, reactionEventId: string): Promise<{
+    id: string;
+}>;
+export declare function createReactionItem(params: {
+    env: ThreadEnvironment;
+    contextIdentifier: ContextIdentifier;
+    triggerEventId: string;
+}): Promise<{
+    reactionEventId: string;
+    executionId: string;
+}>;
+export declare function completeExecution(env: ThreadEnvironment, contextIdentifier: ContextIdentifier, executionId: string, status: "completed" | "failed"): Promise<void>;
+export declare function updateExecutionWorkflowRun(params: {
+    env: ThreadEnvironment;
+    executionId: string;
+    workflowRunId: string;
+}): Promise<void>;
+export declare function createThreadStep(params: {
+    env: ThreadEnvironment;
+    executionId: string;
+    iteration: number;
+}): Promise<{
+    stepId: string;
+    eventId: string;
+}>;
+export declare function updateThreadStep(params: {
+    env: ThreadEnvironment;
+    stepId: string;
+    executionId?: string;
+    contextId?: string;
+    iteration?: number;
+    patch: {
+        status?: "running" | "completed" | "failed";
+        toolCalls?: any;
+        toolExecutionResults?: any;
+        continueLoop?: boolean;
+        errorText?: string;
+    };
+}): Promise<void>;
+export declare function linkItemToExecutionStep(params: {
+    env: ThreadEnvironment;
+    itemId: string;
+    executionId: string;
+}): Promise<void>;
+export declare function saveThreadPartsStep(params: {
+    env: ThreadEnvironment;
+    stepId: string;
+    executionId?: string;
+    contextId?: string;
+    iteration?: number;
+    parts: any[];
+}): Promise<void>;