@ekairos/thread 1.21.88-beta.0

package/dist/events.js

@@ -0,0 +1,102 @@
+import { convertToModelMessages } from "ai";
+export const USER_MESSAGE_TYPE = "user.message";
+export const ASSISTANT_MESSAGE_TYPE = "assistant.message";
+export const SYSTEM_MESSAGE_TYPE = "system.message";
+export const WEB_CHANNEL = "web";
+export const AGENT_CHANNEL = "whatsapp";
+export const EMAIL_CHANNEL = "email";
+export function createUserEventFromUIMessages(messages) {
+    if (!Array.isArray(messages) || messages.length === 0) {
+        throw new Error("Missing messages to create event");
+    }
+    const lastMessage = messages[messages.length - 1];
+    return {
+        id: lastMessage.id,
+        type: USER_MESSAGE_TYPE,
+        channel: WEB_CHANNEL,
+        content: {
+            parts: lastMessage.parts,
+        },
+        createdAt: new Date().toISOString(),
+    };
+}
+export function createAssistantEventFromUIMessages(eventId, messages) {
+    if (!Array.isArray(messages) || messages.length === 0) {
+        throw new Error("Missing messages to create event");
+    }
+    const lastMessage = messages[messages.length - 1];
+    return {
+        id: eventId,
+        type: ASSISTANT_MESSAGE_TYPE,
+        channel: WEB_CHANNEL,
+        content: {
+            parts: lastMessage.parts,
+        },
+        createdAt: new Date().toISOString(),
+    };
+}
+export function convertToUIMessage(event) {
+    let role;
+    if (event.type === USER_MESSAGE_TYPE) {
+        role = "user";
+    }
+    else {
+        role = "assistant";
+    }
+    return {
+        id: event.id,
+        role: role,
+        parts: event.content.parts,
+        metadata: {
+            channel: event.channel,
+            type: event.type,
+            createdAt: event.createdAt,
+        }
+    };
+}
+/**
+ * Converts stored ContextEvents to AI SDK ModelMessages.
+ *
+ * IMPORTANT:
+ * - Store-agnostic and workflow-safe.
+ * - Attachment/document handling MUST happen in the store boundary:
+ *   `StoryStore.eventsToModelMessages(events)`.
+ */
+export async function convertEventsToModelMessages(events) {
+    const results = [];
+    for (const event of events) {
+        results.push(await convertEventToModelMessages(event));
+    }
+    return results.flat();
+}
+export async function convertEventToModelMessages(event) {
+    const message = convertToUIMessage(event);
+    return convertToModelMessages([message]);
+}
+export function convertModelMessageToEvent(eventId, message) {
+    let type;
+    switch (message.message.role) {
+        case "user":
+            type = USER_MESSAGE_TYPE;
+            break;
+        case "assistant":
+            type = ASSISTANT_MESSAGE_TYPE;
+            break;
+        case "system":
+            type = SYSTEM_MESSAGE_TYPE;
+            break;
+        default:
+            // Fallback for roles not mapped to our event types (e.g. tool).
+            type = ASSISTANT_MESSAGE_TYPE;
+            break;
+    }
+    return {
+        id: eventId,
+        type: type,
+        channel: WEB_CHANNEL,
+        content: {
+            parts: message.message.content,
+        },
+        createdAt: message.timestamp.toISOString(),
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+export { thread, createThread, createAiSdkReactor, type CreateAiSdkReactorOptions, type ThreadConfig, type ThreadInstance, type ThreadOptions, type ThreadStreamOptions, type ThreadReactor, type ThreadReactorParams, type ThreadReactionResult, type ThreadReactionToolCall, type ThreadReactionLLM, Thread, type RegistrableThreadBuilder, } from "./thread.js";
+export type { ThreadStore, ThreadIdentifier, ContextIdentifier, StoredThread, StoredContext, ThreadItem, } from "./thread.store.js";
+export type { WireDate, ThreadMirrorContext, ThreadMirrorExecution, ThreadMirrorWrite, ThreadMirrorRequest, } from "./mirror.js";
+export { registerThread, getThread, getThreadFactory, hasThread, listThreads, type ThreadKey, } from "./thread.registry.js";
+export { threadDomain } from "./schema.js";
+export { didToolExecute, extractToolCallsFromParts } from "./thread.toolcalls.js";
+export { INPUT_TEXT_ITEM_TYPE, OUTPUT_TEXT_ITEM_TYPE, SYSTEM_TEXT_ITEM_TYPE, WEB_CHANNEL, AGENT_CHANNEL, EMAIL_CHANNEL, createUserItemFromUIMessages, createAssistantItemFromUIMessages, convertToUIMessage, convertItemToModelMessages, convertItemsToModelMessages, convertModelMessageToItem, type ResponseMessage, } from "./thread.events.js";
+export { DEFAULT_CODEX_TOOL_NAME, DEFAULT_CODEX_MODEL, codexToolInputSchema, buildDefaultCodexNarrative, didCodexToolExecute, createCodexThreadBuilder, type CodexThreadRuntimeMode, type CodexThreadReasoningLevel, type CodexThreadRuntime, type CodexThreadEnv, type CodexToolInput, type CodexToolOutput, type CodexExecuteArgs, type CodexThreadBuilderConfig, type CodexThreadBuilder, } from "./codex.js";
+export { useThread, type ThreadSnapshot, type ThreadStreamChunk, type UseThreadOptions, } from "./react.js";

package/dist/index.js

@@ -0,0 +1,9 @@
+export { 
+// Thread API
+thread, createThread, createAiSdkReactor, Thread, } from "./thread.js";
+export { registerThread, getThread, getThreadFactory, hasThread, listThreads, } from "./thread.registry.js";
+export { threadDomain } from "./schema.js";
+export { didToolExecute, extractToolCallsFromParts } from "./thread.toolcalls.js";
+export { INPUT_TEXT_ITEM_TYPE, OUTPUT_TEXT_ITEM_TYPE, SYSTEM_TEXT_ITEM_TYPE, WEB_CHANNEL, AGENT_CHANNEL, EMAIL_CHANNEL, createUserItemFromUIMessages, createAssistantItemFromUIMessages, convertToUIMessage, convertItemToModelMessages, convertItemsToModelMessages, convertModelMessageToItem, } from "./thread.events.js";
+export { DEFAULT_CODEX_TOOL_NAME, DEFAULT_CODEX_MODEL, codexToolInputSchema, buildDefaultCodexNarrative, didCodexToolExecute, createCodexThreadBuilder, } from "./codex.js";
+export { useThread, } from "./react.js";

package/dist/mcp.d.ts

@@ -0,0 +1 @@
+export { createMcpHandler, withMcpAuth } from "@vercel/mcp-adapter";

package/dist/mcp.js

@@ -0,0 +1 @@
+export { createMcpHandler, withMcpAuth } from "@vercel/mcp-adapter";

package/dist/mirror.d.ts

@@ -0,0 +1,41 @@
+import type { ThreadItem, StoredContext } from "./thread.store.js";
+/**
+ * Wire-safe (JSON) mirror types shared by:
+ * - the workflow sender (`@ekairos/thread` steps)
+ * - the ekairos-core receiver (`/api/thread`)
+ *
+ * Note: `StoredContext` contains Date objects, but over HTTP we send ISO strings.
+ */
+export type WireDate = string;
+export type ThreadMirrorContext = Omit<StoredContext<unknown>, "createdAt" | "updatedAt"> & {
+    createdAt: WireDate;
+    updatedAt?: WireDate;
+};
+export type ThreadMirrorExecution = Record<string, unknown> & {
+    createdAt?: WireDate;
+    updatedAt?: WireDate;
+};
+export type ThreadMirrorWrite = {
+    type: "context.upsert";
+    context: ThreadMirrorContext;
+} | {
+    type: "event.upsert";
+    contextId: string;
+    event: ThreadItem;
+} | {
+    type: "event.update";
+    eventId: string;
+    event: ThreadItem;
+} | {
+    type: "execution.upsert";
+    contextId: string;
+    executionId: string;
+    execution: ThreadMirrorExecution;
+    triggerEventId: string;
+    reactionEventId: string;
+    setCurrentExecution?: boolean;
+};
+export type ThreadMirrorRequest = {
+    orgId: string;
+    writes: ThreadMirrorWrite[];
+};

package/dist/mirror.js

@@ -0,0 +1 @@
+export {};

package/dist/oidc.d.ts

@@ -0,0 +1,7 @@
+type VerifyOidcOptions = {
+    jwksUrl?: string;
+    issuer?: string;
+    audience?: string | string[];
+};
+export declare function verifyOidcToken(token: string, options?: VerifyOidcOptions): Promise<boolean>;
+export {};

package/dist/oidc.js

@@ -0,0 +1,25 @@
+import { createRemoteJWKSet, jwtVerify } from "jose";
+const jwksCache = new Map();
+function getJwks(jwksUrl) {
+    const cached = jwksCache.get(jwksUrl);
+    if (cached)
+        return cached;
+    const jwks = createRemoteJWKSet(new URL(jwksUrl));
+    jwksCache.set(jwksUrl, jwks);
+    return jwks;
+}
+export async function verifyOidcToken(token, options = {}) {
+    if (!token)
+        return false;
+    const jwksUrl = String(options.jwksUrl ?? "").trim();
+    if (!jwksUrl) {
+        throw new Error("Missing jwksUrl for OIDC verification");
+    }
+    const verifyOptions = {};
+    if (options.issuer)
+        verifyOptions.issuer = options.issuer;
+    if (options.audience)
+        verifyOptions.audience = options.audience;
+    await jwtVerify(token, getJwks(jwksUrl), verifyOptions);
+    return true;
+}

package/dist/polyfills/dom-events.d.ts

@@ -0,0 +1 @@
+export declare function ensureDomEvents(): void;

package/dist/polyfills/dom-events.js

@@ -0,0 +1,89 @@
+function ensureEvent() {
+    if (typeof globalThis.Event !== "undefined")
+        return;
+    class NodeEvent {
+        constructor(type, init) {
+            this.defaultPrevented = false;
+            this.cancelable = false;
+            this.timeStamp = Date.now();
+            this.type = type;
+            if (init && typeof init === "object") {
+                Object.assign(this, init);
+            }
+        }
+        preventDefault() {
+            this.defaultPrevented = true;
+        }
+    }
+    globalThis.Event = NodeEvent;
+}
+function ensureEventTarget() {
+    if (typeof globalThis.EventTarget !== "undefined")
+        return;
+    class NodeEventTarget {
+        constructor() {
+            this.listeners = new Map();
+        }
+        addEventListener(type, listener) {
+            if (!listener)
+                return;
+            const bucket = this.listeners.get(type) ?? new Set();
+            bucket.add(listener);
+            this.listeners.set(type, bucket);
+        }
+        removeEventListener(type, listener) {
+            if (!listener)
+                return;
+            const bucket = this.listeners.get(type);
+            if (!bucket)
+                return;
+            bucket.delete(listener);
+            if (bucket.size === 0)
+                this.listeners.delete(type);
+        }
+        dispatchEvent(event) {
+            const bucket = this.listeners.get(event?.type);
+            if (bucket) {
+                for (const listener of [...bucket]) {
+                    try {
+                        listener.call(this, event);
+                    }
+                    catch {
+                        // ignore listener errors
+                    }
+                }
+            }
+            const handler = this[`on${event?.type}`];
+            if (typeof handler === "function") {
+                try {
+                    handler.call(this, event);
+                }
+                catch {
+                    // ignore handler errors
+                }
+            }
+            return !event?.defaultPrevented;
+        }
+    }
+    globalThis.EventTarget = NodeEventTarget;
+}
+function ensureMessageEvent() {
+    if (typeof globalThis.MessageEvent !== "undefined")
+        return;
+    const BaseEvent = globalThis.Event;
+    class NodeMessageEvent extends BaseEvent {
+        constructor(type, init) {
+            super(type, init);
+            this.data = init?.data;
+            this.origin = typeof init?.origin === "string" ? init.origin : "";
+            this.lastEventId = typeof init?.lastEventId === "string" ? init.lastEventId : "";
+        }
+    }
+    globalThis.MessageEvent = NodeMessageEvent;
+}
+export function ensureDomEvents() {
+    ensureEvent();
+    ensureEventTarget();
+    ensureMessageEvent();
+}
+ensureDomEvents();

package/dist/react.d.ts

@@ -0,0 +1,62 @@
+export type ThreadSnapshot<Context = unknown, Item = Record<string, unknown>> = {
+    thread: {
+        id: string;
+        key: string;
+        status: string;
+        createdAt: string | null;
+        updatedAt: string | null;
+    };
+    context: {
+        id: string;
+        status: string;
+        content: Context;
+        createdAt: string | null;
+        updatedAt: string | null;
+    } | null;
+    items: Item[];
+};
+export type ThreadStreamChunk = {
+    type: "data-context-id";
+    data?: {
+        contextId?: string;
+    };
+    id?: string;
+} | {
+    type: "data-context-substate";
+    data?: {
+        key?: string | null;
+    };
+    transient?: boolean;
+} | {
+    type: "tool-output-available";
+    toolCallId?: string;
+    output?: unknown;
+} | {
+    type: "tool-output-error";
+    toolCallId?: string;
+    errorText?: string;
+} | {
+    type: string;
+    [key: string]: unknown;
+};
+export type UseThreadOptions<Context = unknown, Item = Record<string, unknown>> = {
+    threadKey: string;
+    orgId?: string;
+    endpoint?: string;
+    refreshMs?: number;
+    ensure?: boolean;
+    enabled?: boolean;
+    initialData?: ThreadSnapshot<Context, Item> | null;
+    fetchImpl?: typeof fetch;
+};
+export declare function useThread<Context = unknown, Item = Record<string, unknown>>(options: UseThreadOptions<Context, Item>): {
+    data: ThreadSnapshot<Context, Item> | null;
+    isLoading: boolean;
+    error: string | null;
+    refresh: () => Promise<void>;
+    setData: import("react").Dispatch<import("react").SetStateAction<ThreadSnapshot<Context, Item> | null>>;
+    contextId: string | null;
+    substateKey: string | null;
+    applyChunk: (chunk: ThreadStreamChunk) => void;
+    url: string;
+};

package/dist/react.js

@@ -0,0 +1,101 @@
+"use client";
+import { useCallback, useEffect, useMemo, useState } from "react";
+function toErrorMessage(error) {
+    if (error instanceof Error)
+        return error.message;
+    return String(error ?? "unknown_error");
+}
+function buildThreadUrl(options) {
+    const base = String(options.endpoint || "/api/thread").replace(/\/+$/, "");
+    const key = encodeURIComponent(options.threadKey);
+    const params = new URLSearchParams();
+    if (options.orgId)
+        params.set("orgId", options.orgId);
+    if (options.ensure)
+        params.set("ensure", "1");
+    const query = params.toString();
+    return query.length > 0 ? `${base}/${key}?${query}` : `${base}/${key}`;
+}
+export function useThread(options) {
+    const [data, setData] = useState(options.initialData ?? null);
+    const [isLoading, setIsLoading] = useState(true);
+    const [error, setError] = useState(null);
+    const [contextId, setContextId] = useState(null);
+    const [substateKey, setSubstateKey] = useState(null);
+    const enabled = options.enabled ?? true;
+    const url = useMemo(() => {
+        if (!enabled || !options.threadKey)
+            return "";
+        return buildThreadUrl(options);
+    }, [enabled, options.endpoint, options.orgId, options.threadKey, options.ensure]);
+    const refresh = useCallback(async () => {
+        if (!enabled || !options.threadKey)
+            return;
+        setIsLoading(true);
+        setError(null);
+        const fetchImpl = options.fetchImpl ?? fetch;
+        try {
+            const response = await fetchImpl(url, { cache: "no-store" });
+            if (!response.ok) {
+                const body = await response.text();
+                throw new Error(body || `thread_fetch_failed:${response.status}`);
+            }
+            const snapshot = (await response.json());
+            setData(snapshot);
+            setContextId(snapshot.context?.id ?? null);
+        }
+        catch (err) {
+            setError(toErrorMessage(err));
+        }
+        finally {
+            setIsLoading(false);
+        }
+    }, [enabled, options.fetchImpl, options.threadKey, url]);
+    const applyChunk = useCallback((chunk) => {
+        if (!chunk || typeof chunk !== "object")
+            return;
+        if (chunk.type === "data-context-id") {
+            const payload = "data" in chunk && chunk.data && typeof chunk.data === "object"
+                ? chunk.data
+                : undefined;
+            const candidate = typeof payload?.contextId === "string"
+                ? payload.contextId
+                : typeof chunk.id === "string"
+                    ? chunk.id
+                    : null;
+            if (candidate)
+                setContextId(candidate);
+            return;
+        }
+        if (chunk.type === "data-context-substate") {
+            const payload = "data" in chunk && chunk.data && typeof chunk.data === "object"
+                ? chunk.data
+                : undefined;
+            const key = payload?.key;
+            setSubstateKey(typeof key === "string" ? key : null);
+            return;
+        }
+    }, []);
+    useEffect(() => {
+        void refresh();
+    }, [refresh]);
+    useEffect(() => {
+        if (!enabled || !options.refreshMs || options.refreshMs <= 0)
+            return;
+        const intervalId = setInterval(() => {
+            void refresh();
+        }, options.refreshMs);
+        return () => clearInterval(intervalId);
+    }, [enabled, options.refreshMs, refresh]);
+    return {
+        data,
+        isLoading,
+        error,
+        refresh,
+        setData,
+        contextId,
+        substateKey,
+        applyChunk,
+        url,
+    };
+}

package/dist/runtime.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Runtime-only entrypoint for @ekairos/thread.
+ *
+ * This file intentionally exports the "wiring" pieces that connect durable steps to a concrete
+ * store runtime (Instant/Postgres/etc).
+ *
+ * IMPORTANT:
+ * - Do NOT import this entrypoint from client/browser code.
+ * - Keep `@ekairos/thread` main entrypoint safe to import from schema/domain modules.
+ */
+export { getThreadRuntime, } from "./runtime.step.js";
+export type { ThreadEnvironment, ThreadRuntime } from "./thread.config.js";
+export { registerThreadEnv, getThreadEnv } from "./env.js";
+export type RegistrableThread = {
+    key?: string;
+    register: () => void;
+};

package/dist/runtime.js

@@ -0,0 +1,23 @@
+/**
+ * Runtime-only entrypoint for @ekairos/thread.
+ *
+ * This file intentionally exports the "wiring" pieces that connect durable steps to a concrete
+ * store runtime (Instant/Postgres/etc).
+ *
+ * IMPORTANT:
+ * - Do NOT import this entrypoint from client/browser code.
+ * - Keep `@ekairos/thread` main entrypoint safe to import from schema/domain modules.
+ */
+if (typeof globalThis.Event === "undefined") {
+    class NodeEvent {
+        constructor(type, init) {
+            this.type = type;
+            if (init && typeof init === "object") {
+                Object.assign(this, init);
+            }
+        }
+    }
+    globalThis.Event = NodeEvent;
+}
+export { getThreadRuntime, } from "./runtime.step.js";
+export { registerThreadEnv, getThreadEnv } from "./env.js";

package/dist/runtime.step.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Internal helper to resolve Thread runtime from within workflow steps.
+ *
+ * Why dynamic import?
+ * - Some bundlers (notably Turbopack step bundles) can drop/hoist static imports in "use-step" modules.
+ * - Keeping `resolveRuntime` behind a dynamic import makes symbol resolution local to step execution.
+ */
+import type { ThreadEnvironment, ThreadRuntime } from "./thread.config.js";
+export declare function getThreadRuntime(env: ThreadEnvironment): Promise<ThreadRuntime>;

package/dist/runtime.step.js

@@ -0,0 +1,7 @@
+import { coerceThreadRuntime } from "./thread.config.js";
+import { threadDomain } from "./schema.js";
+export async function getThreadRuntime(env) {
+    const { resolveRuntime } = await import("@ekairos/domain/runtime");
+    const resolved = await resolveRuntime(threadDomain, env);
+    return await coerceThreadRuntime(resolved);
+}

package/dist/schema.d.ts

@@ -0,0 +1,2 @@
+import { type DomainSchemaResult } from "@ekairos/domain";
+export declare const threadDomain: DomainSchemaResult;