@ekairos/thread 1.21.88-beta.0

package/dist/thread.engine.js

@@ -0,0 +1,471 @@
+import { getWritable } from "workflow";
+import { registerThreadEnv } from "./env.js";
+import { applyToolExecutionResultToParts } from "./thread.toolcalls.js";
+import { toolsToModelTools } from "./tools-to-model-tools.js";
+import { createAiSdkReactor, } from "./thread.reactor.js";
+import { closeThreadStream, writeContextSubstate, writeThreadPing, writeToolOutputs, } from "./steps/stream.steps.js";
+import { completeExecution, createThreadStep, emitContextIdChunk, initializeContext, saveReactionItem, saveTriggerAndCreateExecution, saveThreadPartsStep, updateThreadStep, updateContextContent, updateItem, } from "./steps/store.steps.js";
+import { getClientResumeHookUrl, toolApprovalHookToken, toolApprovalWebhookToken, } from "./thread.hooks.js";
+export { toolApprovalHookToken, toolApprovalWebhookToken, getClientResumeHookUrl };
+export class Thread {
+    constructor(opts = {}, reactor) {
+        this.opts = opts;
+        this.reactor = reactor ?? createAiSdkReactor();
+    }
+    /**
+     * First-class event expansion stage (runs on every iteration of the durable loop).
+     *
+     * Use this to expand/normalize events before they are converted into model messages.
+     * Typical use-cases:
+     * - Expand file/document references into text (LlamaCloud/Reducto/…)
+     * - Token compaction / summarization of older parts
+     * - Attaching derived context snippets to the next model call
+     *
+     * IMPORTANT:
+     * - This stage is ALWAYS executed by the engine.
+     * - If you don't provide an implementation, the default behavior is an identity transform
+     *   (events pass through unchanged).
+     * - If your implementation performs I/O, implement it as a `"use-step"` function (provided via
+     *   the builder) so results are durable and replay-safe.
+     * - If it’s pure/deterministic, it can run in workflow context.
+     */
+    async expandEvents(events, _context, _env) {
+        return events;
+    }
+    getModel(_context, _env) {
+        return "openai/gpt-5";
+    }
+    getReactor(_context, _env) {
+        return this.reactor;
+    }
+    /**
+     * Thread stop/continue hook.
+     *
+     * After the model streamed and tools executed, the story can decide whether the loop should
+     * continue.
+     *
+     * Default: `true` (continue).
+     */
+    async shouldContinue(_args) {
+        return true;
+    }
+    async react(incomingEventOrParams, paramsMaybe) {
+        return await Thread.runLoop(this, incomingEventOrParams, paramsMaybe);
+    }
+    static async runLoop(story, incomingEventOrParams, paramsMaybe) {
+        const params = typeof incomingEventOrParams?.type === "string" && paramsMaybe
+            ? {
+                env: paramsMaybe.env,
+                triggerEvent: incomingEventOrParams,
+                contextIdentifier: paramsMaybe.context ?? null,
+                options: paramsMaybe.options,
+            }
+            : incomingEventOrParams;
+        const triggerEvent = params.triggerEvent ?? params.incomingEvent;
+        if (!triggerEvent) {
+            throw new Error("Thread.react: triggerEvent is required");
+        }
+        // Register env for step runtimes (workflow-friendly).
+        try {
+            const { getWorkflowMetadata } = await import("workflow");
+            const meta = getWorkflowMetadata?.();
+            const runId = meta?.workflowRunId ? String(meta.workflowRunId) : null;
+            registerThreadEnv(params.env, runId ?? undefined);
+        }
+        catch {
+            registerThreadEnv(params.env);
+        }
+        const maxIterations = params.options?.maxIterations ?? 20;
+        const maxModelSteps = params.options?.maxModelSteps ?? 1;
+        const preventClose = params.options?.preventClose ?? false;
+        const sendFinish = params.options?.sendFinish ?? true;
+        const silent = params.options?.silent ?? false;
+        let writable = params.options?.writable;
+        // 1) Ensure context exists (step)
+        const ctxResult = await initializeContext(params.env, params.contextIdentifier, { silent, writable });
+        const currentContext = ctxResult.context;
+        // If the caller didn't provide a writable, we still stream by default (unless silent),
+        // using a namespaced stream per context: `context:<contextId>`.
+        if (!silent && !writable) {
+            writable = getWritable({
+                namespace: `context:${String(currentContext.id)}`,
+            });
+            // If the context was created in `initializeContext` (which didn't have a writable yet),
+            // re-emit the context id chunk now so clients can subscribe to the right persisted thread.
+            if (ctxResult.isNew) {
+                await emitContextIdChunk({
+                    env: params.env,
+                    contextId: String(currentContext.id),
+                    writable,
+                });
+            }
+        }
+        const contextSelector = params.contextIdentifier?.id
+            ? { id: String(params.contextIdentifier.id) }
+            : params.contextIdentifier?.key
+                ? { key: params.contextIdentifier.key }
+                : { id: String(currentContext.id) };
+        if (ctxResult.isNew) {
+            await story.opts.onContextCreated?.({ env: params.env, context: currentContext });
+        }
+        // 2) Persist trigger event + create execution shell (single step)
+        const { triggerEventId, reactionEventId, executionId } = await saveTriggerAndCreateExecution({
+            env: params.env,
+            contextIdentifier: contextSelector,
+            triggerEvent,
+        });
+        // Emit a simple ping chunk early so clients can validate that streaming works end-to-end.
+        // This should be ignored safely by clients that don't care about it.
+        if (!silent) {
+            await writeThreadPing({ label: "thread-start", writable });
+        }
+        let reactionEvent = null;
+        // Latest persisted context state for this run (we keep it in memory; store is updated via steps).
+        let updatedContext = currentContext;
+        let currentStepId = null;
+        const failExecution = async () => {
+            try {
+                await completeExecution(params.env, contextSelector, executionId, "failed");
+            }
+            catch {
+                // noop
+            }
+            try {
+                if (!silent) {
+                    await closeThreadStream({ preventClose, sendFinish, writable });
+                }
+            }
+            catch {
+                // noop
+            }
+        };
+        try {
+            for (let iter = 0; iter < maxIterations; iter++) {
+                // Create a persisted step per iteration (IDs generated in step runtime for replay safety)
+                const stepCreate = await createThreadStep({
+                    env: params.env,
+                    executionId,
+                    iteration: iter,
+                });
+                currentStepId = stepCreate.stepId;
+                // Hook: Thread DSL `context()` (implemented by subclasses via `initialize()`)
+                const nextContent = await story.initialize(updatedContext, params.env);
+                updatedContext = await updateContextContent(params.env, contextSelector, nextContent);
+                await story.opts.onContextUpdated?.({ env: params.env, context: updatedContext });
+                // Hook: Thread DSL `narrative()` (implemented by subclasses via `buildSystemPrompt()`)
+                const systemPrompt = await story.buildSystemPrompt(updatedContext, params.env);
+                // Hook: Thread DSL `actions()` (implemented by subclasses via `buildTools()`)
+                const toolsAll = await story.buildTools(updatedContext, params.env);
+                // IMPORTANT: step args must be serializable.
+                // Match DurableAgent behavior: convert tool input schemas to plain JSON Schema in workflow context.
+                const toolsForModel = toolsToModelTools(toolsAll);
+                // Execute model reaction for this iteration using the stable reaction event id.
+                //
+                // IMPORTANT:
+                // We expose a single visible `context_event` per story turn (`reactionEventId`).
+                // If we stream with a per-step id, the UI will render an optimistic assistant message
+                // (step id) and then a second persisted assistant message (reaction id) with the same
+                // content once InstantDB updates.
+                const reactor = story.getReactor(updatedContext, params.env);
+                const { assistantEvent, toolCalls, messagesForModel } = await reactor({
+                    env: params.env,
+                    context: updatedContext,
+                    contextIdentifier: contextSelector,
+                    triggerEvent,
+                    model: story.getModel(updatedContext, params.env),
+                    systemPrompt,
+                    actions: toolsAll,
+                    toolsForModel,
+                    eventId: reactionEventId,
+                    executionId,
+                    contextId: String(currentContext.id),
+                    stepId: String(stepCreate.stepId),
+                    iteration: iter,
+                    maxModelSteps,
+                    // Only emit a `start` chunk once per story turn.
+                    sendStart: !silent && iter === 0 && reactionEvent === null,
+                    silent,
+                    writable,
+                });
+                const reviewRequests = toolCalls.length > 0
+                    ? toolCalls.flatMap((tc) => {
+                        const toolDef = toolsAll[tc.toolName];
+                        const auto = toolDef?.auto !== false;
+                        tc.auto = auto;
+                        if (auto)
+                            return [];
+                        return [
+                            {
+                                toolCallId: String(tc.toolCallId),
+                                toolName: String(tc.toolName ?? ""),
+                            },
+                        ];
+                    })
+                    : [];
+                // Persist normalized parts hanging off the producing step (thread_parts).
+                // IMPORTANT:
+                // We intentionally do NOT persist the per-step LLM assistant event as a `context_event`.
+                // The story exposes a single visible `context_event` per turn (`reactionEventId`) so the UI
+                // doesn't render duplicate assistant messages (LLM-step + aggregated reaction).
+                const stepParts = (assistantEvent?.content?.parts ?? []);
+                await saveThreadPartsStep({
+                    env: params.env,
+                    stepId: stepCreate.stepId,
+                    parts: stepParts,
+                    executionId,
+                    contextId: String(currentContext.id),
+                    iteration: iter,
+                });
+                // Persist/append the aggregated reaction event (stable `reactionEventId` for the execution).
+                if (!reactionEvent) {
+                    const reactionPayload = {
+                        ...assistantEvent,
+                        status: "pending",
+                    };
+                    reactionEvent = await saveReactionItem(params.env, contextSelector, reactionPayload, {
+                        executionId,
+                        contextId: String(currentContext.id),
+                        reviewRequests,
+                    });
+                }
+                else {
+                    reactionEvent = await updateItem(params.env, reactionEvent.id, {
+                        ...reactionEvent,
+                        content: {
+                            parts: [
+                                ...(reactionEvent?.content?.parts ?? []),
+                                ...(assistantEvent?.content?.parts ?? []),
+                            ],
+                        },
+                        status: "pending",
+                    }, { executionId, contextId: String(currentContext.id) });
+                }
+                story.opts.onEventCreated?.(assistantEvent);
+                // Done: no tool calls requested by the model
+                if (!toolCalls.length) {
+                    const endResult = await story.callOnEnd(assistantEvent);
+                    if (endResult) {
+                        // Mark iteration step completed (no tools)
+                        await updateThreadStep({
+                            env: params.env,
+                            stepId: stepCreate.stepId,
+                            patch: {
+                                status: "completed",
+                                toolCalls: [],
+                                toolExecutionResults: [],
+                                continueLoop: false,
+                            },
+                            executionId,
+                            contextId: String(currentContext.id),
+                            iteration: iter,
+                        });
+                        // Mark reaction event completed
+                        await updateItem(params.env, reactionEventId, {
+                            ...reactionEvent,
+                            status: "completed",
+                        }, { executionId, contextId: String(currentContext.id) });
+                        await completeExecution(params.env, contextSelector, executionId, "completed");
+                        if (!silent) {
+                            await closeThreadStream({ preventClose, sendFinish, writable });
+                        }
+                        return {
+                            contextId: currentContext.id,
+                            context: updatedContext,
+                            triggerEventId,
+                            reactionEventId,
+                            executionId,
+                        };
+                    }
+                }
+                // Execute tool calls (workflow context; tool implementations decide step vs workflow)
+                if (!silent && toolCalls.length) {
+                    await writeContextSubstate({ key: "actions", transient: true, writable });
+                }
+                const executionResults = await Promise.all(toolCalls.map(async (tc) => {
+                    const toolDef = toolsAll[tc.toolName];
+                    if (!toolDef || typeof toolDef.execute !== "function") {
+                        return {
+                            tc,
+                            success: false,
+                            output: null,
+                            errorText: `Tool "${tc.toolName}" not found or has no execute().`,
+                        };
+                    }
+                    try {
+                        let toolArgs = tc.args;
+                        if (toolDef?.auto === false) {
+                            const { createHook, createWebhook } = await import("workflow");
+                            const toolCallId = String(tc.toolCallId);
+                            const hookToken = toolApprovalHookToken({ executionId, toolCallId });
+                            const webhookToken = toolApprovalWebhookToken({ executionId, toolCallId });
+                            const hook = createHook({ token: hookToken });
+                            const webhook = createWebhook({ token: webhookToken });
+                            const approvalOrRequest = await Promise.race([
+                                hook.then((approval) => ({ source: "hook", approval })),
+                                webhook.then((request) => ({ source: "webhook", request })),
+                            ]);
+                            const approval = approvalOrRequest.source === "hook"
+                                ? approvalOrRequest.approval
+                                : await approvalOrRequest.request.json().catch(() => null);
+                            if (!approval || approval.approved !== true) {
+                                return {
+                                    tc,
+                                    success: false,
+                                    output: null,
+                                    errorText: approval && "comment" in approval && approval.comment
+                                        ? `Tool execution not approved: ${approval.comment}`
+                                        : "Tool execution not approved",
+                                };
+                            }
+                            if ("args" in approval && approval.args !== undefined) {
+                                toolArgs = approval.args;
+                            }
+                        }
+                        const output = await toolDef.execute(toolArgs, {
+                            toolCallId: tc.toolCallId,
+                            messages: messagesForModel,
+                            eventId: reactionEventId,
+                            executionId,
+                            triggerEventId,
+                            contextId: currentContext.id,
+                        });
+                        return { tc, success: true, output };
+                    }
+                    catch (e) {
+                        return {
+                            tc,
+                            success: false,
+                            output: null,
+                            errorText: e instanceof Error ? e.message : String(e),
+                        };
+                    }
+                }));
+                // Emit tool outputs to the workflow stream (step)
+                if (!silent) {
+                    await writeToolOutputs({
+                        results: executionResults.map((r) => r.success
+                            ? { toolCallId: r.tc.toolCallId, success: true, output: r.output }
+                            : {
+                                toolCallId: r.tc.toolCallId,
+                                success: false,
+                                errorText: r.errorText,
+                            }),
+                        writable,
+                    });
+                }
+                // Clear action status once tool execution results have been emitted.
+                if (!silent && toolCalls.length) {
+                    await writeContextSubstate({ key: null, transient: true, writable });
+                }
+                // Merge tool results into persisted parts (so next LLM call can see them)
+                if (reactionEvent) {
+                    let parts = reactionEvent?.content?.parts ?? [];
+                    for (const r of executionResults) {
+                        parts = applyToolExecutionResultToParts(parts, r.tc, {
+                            success: Boolean(r.success),
+                            result: r.output,
+                            message: r.errorText,
+                        });
+                    }
+                    reactionEvent = await updateItem(params.env, reactionEventId, {
+                        ...reactionEvent,
+                        content: { parts },
+                        status: "pending",
+                    }, { executionId, contextId: String(currentContext.id) });
+                }
+                // Callback for observability/integration
+                for (const r of executionResults) {
+                    await story.opts.onToolCallExecuted?.({
+                        toolCall: r.tc,
+                        success: r.success,
+                        output: r.output,
+                        errorText: r.errorText,
+                        eventId: reactionEventId,
+                        executionId,
+                    });
+                }
+                // Stop/continue boundary: allow the Thread to decide if the loop should continue.
+                // IMPORTANT: we call this after tool results have been merged into the persisted `reactionEvent`,
+                // so stories can inspect `reactionEvent.content.parts` deterministically.
+                const continueLoop = await story.shouldContinue({
+                    env: params.env,
+                    context: updatedContext,
+                    reactionEvent: reactionEvent ?? assistantEvent,
+                    assistantEvent,
+                    toolCalls,
+                    toolExecutionResults: executionResults,
+                });
+                // Persist per-iteration step outcome (tools + continue signal)
+                await updateThreadStep({
+                    env: params.env,
+                    stepId: stepCreate.stepId,
+                    patch: {
+                        status: "completed",
+                        toolCalls,
+                        toolExecutionResults: executionResults,
+                        continueLoop: continueLoop !== false,
+                    },
+                    executionId,
+                    contextId: String(currentContext.id),
+                    iteration: iter,
+                });
+                if (continueLoop === false) {
+                    await updateItem(params.env, reactionEventId, {
+                        ...reactionEvent,
+                        status: "completed",
+                    }, { executionId, contextId: String(currentContext.id) });
+                    await completeExecution(params.env, contextSelector, executionId, "completed");
+                    if (!silent) {
+                        await closeThreadStream({ preventClose, sendFinish, writable });
+                    }
+                    return {
+                        contextId: currentContext.id,
+                        context: updatedContext,
+                        triggerEventId,
+                        reactionEventId,
+                        executionId,
+                    };
+                }
+            }
+            throw new Error(`Thread: maxIterations reached (${maxIterations}) without completion`);
+        }
+        catch (error) {
+            // Best-effort: persist failure on the current iteration step (if any)
+            if (currentStepId) {
+                try {
+                    await updateThreadStep({
+                        env: params.env,
+                        stepId: currentStepId,
+                        patch: {
+                            status: "failed",
+                            errorText: error instanceof Error ? error.message : String(error),
+                        },
+                        executionId,
+                        contextId: String(currentContext.id),
+                    });
+                }
+                catch {
+                    // noop
+                }
+            }
+            await failExecution();
+            throw error;
+        }
+    }
+    /**
+     * @deprecated Use `react()` instead. Kept for backwards compatibility.
+     */
+    async stream(triggerEvent, params) {
+        return await this.react(triggerEvent, params);
+    }
+    async callOnEnd(lastEvent) {
+        if (!this.opts.onEnd)
+            return true;
+        const result = await this.opts.onEnd(lastEvent);
+        if (typeof result === "boolean")
+            return result;
+        if (result && typeof result === "object" && "end" in result)
+            return Boolean(result.end);
+        return true;
+    }
+}

package/dist/thread.events.d.ts

@@ -0,0 +1,35 @@
+import { type ModelMessage, type UIMessage } from "ai";
+import type { ThreadItem } from "./thread.store.js";
+export declare const INPUT_TEXT_ITEM_TYPE = "input_text";
+export declare const OUTPUT_TEXT_ITEM_TYPE = "output_text";
+export declare const SYSTEM_TEXT_ITEM_TYPE = "ekairos:system";
+export declare const WEB_CHANNEL = "web";
+export declare const AGENT_CHANNEL = "whatsapp";
+export declare const EMAIL_CHANNEL = "email";
+export declare function createUserItemFromUIMessages(messages: UIMessage[]): ThreadItem;
+export declare function createAssistantItemFromUIMessages(itemId: string, messages: UIMessage[]): ThreadItem;
+export declare function convertToUIMessage(item: ThreadItem): UIMessage;
+/**
+ * Converts stored ThreadItems to AI SDK ModelMessages.
+ *
+ * IMPORTANT:
+ * - Store-agnostic and workflow-safe.
+ * - Attachment/document handling MUST happen in the store boundary:
+ *   `ThreadStore.itemsToModelMessages(items)`.
+ */
+export declare function convertItemsToModelMessages(items: ThreadItem[]): Promise<ModelMessage[]>;
+export declare function convertItemToModelMessages(item: ThreadItem): Promise<ModelMessage[]>;
+export type AIMessage = {
+    id: string;
+    role: "user" | "assistant" | "system";
+    content: string;
+    createdAt: Date;
+};
+export type ResponseMessage = {
+    id: string;
+    timestamp: Date;
+    modelId: string;
+    headers?: Record<string, string>;
+    message: ModelMessage;
+};
+export declare function convertModelMessageToItem(itemId: string, message: ResponseMessage): ThreadItem;

package/dist/thread.events.js

@@ -0,0 +1,105 @@
+import { convertToModelMessages } from "ai";
+export const INPUT_TEXT_ITEM_TYPE = "input_text";
+export const OUTPUT_TEXT_ITEM_TYPE = "output_text";
+export const SYSTEM_TEXT_ITEM_TYPE = "ekairos:system";
+export const WEB_CHANNEL = "web";
+export const AGENT_CHANNEL = "whatsapp";
+export const EMAIL_CHANNEL = "email";
+export function createUserItemFromUIMessages(messages) {
+    if (!Array.isArray(messages) || messages.length === 0) {
+        throw new Error("Missing messages to create item");
+    }
+    const lastMessage = messages[messages.length - 1];
+    return {
+        id: lastMessage.id,
+        type: INPUT_TEXT_ITEM_TYPE,
+        channel: WEB_CHANNEL,
+        content: {
+            parts: lastMessage.parts,
+        },
+        createdAt: new Date().toISOString(),
+    };
+}
+export function createAssistantItemFromUIMessages(itemId, messages) {
+    if (!Array.isArray(messages) || messages.length === 0) {
+        throw new Error("Missing messages to create item");
+    }
+    const lastMessage = messages[messages.length - 1];
+    return {
+        id: itemId,
+        type: OUTPUT_TEXT_ITEM_TYPE,
+        channel: WEB_CHANNEL,
+        content: {
+            parts: lastMessage.parts,
+        },
+        createdAt: new Date().toISOString(),
+    };
+}
+export function convertToUIMessage(item) {
+    let role;
+    if (item.type === INPUT_TEXT_ITEM_TYPE) {
+        role = "user";
+    }
+    else if (item.type === SYSTEM_TEXT_ITEM_TYPE) {
+        role = "system";
+    }
+    else {
+        role = "assistant";
+    }
+    return {
+        id: item.id,
+        role: role,
+        parts: item.content.parts,
+        metadata: {
+            channel: item.channel,
+            type: item.type,
+            createdAt: item.createdAt,
+        }
+    };
+}
+/**
+ * Converts stored ThreadItems to AI SDK ModelMessages.
+ *
+ * IMPORTANT:
+ * - Store-agnostic and workflow-safe.
+ * - Attachment/document handling MUST happen in the store boundary:
+ *   `ThreadStore.itemsToModelMessages(items)`.
+ */
+export async function convertItemsToModelMessages(items) {
+    const results = [];
+    for (const item of items) {
+        results.push(await convertItemToModelMessages(item));
+    }
+    return results.flat();
+}
+export async function convertItemToModelMessages(item) {
+    const message = convertToUIMessage(item);
+    return convertToModelMessages([message]);
+}
+export function convertModelMessageToItem(itemId, message) {
+    let type;
+    switch (message.message.role) {
+        case "user":
+            type = INPUT_TEXT_ITEM_TYPE;
+            break;
+        case "assistant":
+            type = OUTPUT_TEXT_ITEM_TYPE;
+            break;
+        case "system":
+            type = SYSTEM_TEXT_ITEM_TYPE;
+            break;
+        default:
+            // Fallback for roles not mapped to our item types (e.g. tool).
+            type = OUTPUT_TEXT_ITEM_TYPE;
+            break;
+    }
+    return {
+        id: itemId,
+        type: type,
+        channel: WEB_CHANNEL,
+        content: {
+            parts: message.message.content,
+        },
+        createdAt: message.timestamp.toISOString(),
+    };
+}

package/dist/thread.hooks.d.ts

@@ -0,0 +1,21 @@
+export declare function getClientResumeHookUrl(): string | undefined;
+/**
+ * Deterministic hook token for approving an `auto: false` tool call.
+ *
+ * External systems can resume the hook with:
+ * `resumeHook(toolApprovalHookToken({ executionId, toolCallId }), { approved: true })`
+ */
+export declare function toolApprovalHookToken(params: {
+    executionId: string;
+    toolCallId: string;
+}): string;
+/**
+ * Deterministic webhook token for approving an `auto: false` tool call.
+ *
+ * When using Workflow DevKit, the webhook is available at:
+ * `/.well-known/workflow/v1/webhook/:token`
+ */
+export declare function toolApprovalWebhookToken(params: {
+    executionId: string;
+    toolCallId: string;
+}): string;

package/dist/thread.hooks.js

@@ -0,0 +1,31 @@
+function stripTrailingSlash(value) {
+    return value.replace(/\/$/, "");
+}
+export function getClientResumeHookUrl() {
+    const direct = process.env.EKAIROS_CLIENT_RESUME_HOOK_URL;
+    if (typeof direct === "string" && direct.trim())
+        return direct.trim();
+    const base = process.env.EKAIROS_CLIENT_BASE_URL;
+    if (typeof base === "string" && base.trim()) {
+        return `${stripTrailingSlash(base.trim())}/api/ekairos/resume-hook`;
+    }
+    return undefined;
+}
+/**
+ * Deterministic hook token for approving an `auto: false` tool call.
+ *
+ * External systems can resume the hook with:
+ * `resumeHook(toolApprovalHookToken({ executionId, toolCallId }), { approved: true })`
+ */
+export function toolApprovalHookToken(params) {
+    return `ekairos_thread:tool-approval:${params.executionId}:${params.toolCallId}`;
+}
+/**
+ * Deterministic webhook token for approving an `auto: false` tool call.
+ *
+ * When using Workflow DevKit, the webhook is available at:
+ * `/.well-known/workflow/v1/webhook/:token`
+ */
+export function toolApprovalWebhookToken(params) {
+    return `ekairos_thread:tool-approval-webhook:${params.executionId}:${params.toolCallId}`;
+}

package/dist/thread.js

@@ -0,0 +1,7 @@
+export { 
+// engine
+Thread, } from "./thread.engine.js";
+export { 
+// builder
+thread, createThread, } from "./thread.builder.js";
+export { createAiSdkReactor, } from "./thread.reactor.js";