@ekairos/thread 1.21.88-beta.0

package/dist/stores/instant.store.d.ts

@@ -0,0 +1,78 @@
+import "../polyfills/dom-events.js";
+import type { DomainSchemaResult } from "@ekairos/domain";
+import type { ModelMessage } from "ai";
+import type { ThreadItem, ContextIdentifier, ThreadIdentifier, ThreadStatus, ContextStatus, StoredThread, StoredContext, ThreadStore } from "../thread.store.js";
+export { parseAndStoreDocument } from "./instant.document-parser.js";
+export { coerceDocumentTextPages, expandEventsWithInstantDocuments, } from "./instant.documents.js";
+/**
+ * InstantDB-backed ThreadStore.
+ *
+ * This is intentionally kept behind the store boundary so the core story engine
+ * can remain database-agnostic.
+ */
+export type InstantStoreDb = any;
+export declare class InstantStore implements ThreadStore {
+    private db;
+    constructor(db: InstantStoreDb);
+    private ensureContextThreadLink;
+    private normalizeThread;
+    private normalizeContext;
+    private getThreadByContextId;
+    private getContextByThreadId;
+    private createThread;
+    getOrCreateThread(threadIdentifier: ThreadIdentifier | null): Promise<StoredThread>;
+    getThread(threadIdentifier: ThreadIdentifier): Promise<StoredThread | null>;
+    updateThreadStatus(threadIdentifier: ThreadIdentifier, status: ThreadStatus): Promise<void>;
+    getOrCreateContext<C>(contextIdentifier: ContextIdentifier | null): Promise<StoredContext<C>>;
+    private createContextForThread;
+    getContext<C>(contextIdentifier: ContextIdentifier): Promise<StoredContext<C> | null>;
+    updateContextContent<C>(contextIdentifier: ContextIdentifier, content: C): Promise<StoredContext<C>>;
+    updateContextStatus(contextIdentifier: ContextIdentifier, status: ContextStatus): Promise<void>;
+    private resolveThreadContext;
+    saveItem(contextIdentifier: ContextIdentifier, event: ThreadItem): Promise<ThreadItem>;
+    updateItem(eventId: string, event: ThreadItem): Promise<ThreadItem>;
+    getItem(eventId: string): Promise<ThreadItem | null>;
+    getItems(contextIdentifier: ContextIdentifier): Promise<ThreadItem[]>;
+    createExecution(contextIdentifier: ContextIdentifier, triggerEventId: string, reactionEventId: string): Promise<{
+        id: string;
+    }>;
+    completeExecution(contextIdentifier: ContextIdentifier, executionId: string, status: "completed" | "failed"): Promise<void>;
+    createStep(params: {
+        executionId: string;
+        iteration: number;
+    }): Promise<{
+        id: string;
+        eventId: string;
+    }>;
+    updateStep(stepId: string, patch: Partial<{
+        status: "running" | "completed" | "failed";
+        toolCalls: any;
+        toolExecutionResults: any;
+        continueLoop: boolean;
+        errorText: string;
+        updatedAt: Date;
+    }>): Promise<void>;
+    linkItemToExecution(params: {
+        itemId: string;
+        executionId: string;
+    }): Promise<void>;
+    saveStepParts(params: {
+        stepId: string;
+        parts: any[];
+    }): Promise<void>;
+    itemsToModelMessages(events: ThreadItem[]): Promise<ModelMessage[]>;
+}
+/**
+ * Helper to create a ThreadRuntimeResolver that returns an InstantStore.
+ *
+ * This keeps the app-level `ekairos.ts` extremely small.
+ */
+export declare function createInstantStoreRuntime(params: {
+    getDb: (orgId: string) => Promise<InstantStoreDb> | InstantStoreDb;
+    getOrgId?: (env: Record<string, unknown>) => string;
+    domain?: DomainSchemaResult;
+}): (env: Record<string, unknown>) => Promise<{
+    store: InstantStore;
+    db: InstantStoreDb;
+    domain?: any;
+}>;

package/dist/stores/instant.store.js

@@ -0,0 +1,530 @@
+import "../polyfills/dom-events.js";
+import { id, lookup } from "@instantdb/admin";
+import { convertItemsToModelMessages } from "../thread.events.js";
+export { parseAndStoreDocument } from "./instant.document-parser.js";
+import { expandEventsWithInstantDocuments } from "./instant.documents.js";
+export { coerceDocumentTextPages, expandEventsWithInstantDocuments, } from "./instant.documents.js";
+export class InstantStore {
+    constructor(db) {
+        this.db = db;
+    }
+    async ensureContextThreadLink(context, contextIdentifier) {
+        if (context.threadId)
+            return context;
+        const fallbackKey = contextIdentifier?.key ??
+            context.key ??
+            (context.id ? String(context.id) : null);
+        const thread = await this.createThread(fallbackKey ? { key: String(fallbackKey) } : null, context.id ? String(context.id) : undefined);
+        await this.db.transact([
+            this.db.tx.thread_contexts[context.id].link({ thread: thread.id }),
+        ]);
+        const refreshed = await this.getContext({ id: context.id });
+        if (refreshed)
+            return refreshed;
+        return {
+            ...context,
+            threadId: thread.id,
+            key: thread.key ?? context.key,
+        };
+    }
+    normalizeThread(row) {
+        return {
+            id: String(row?.id ?? ""),
+            key: typeof row?.key === "string" ? row.key : null,
+            name: typeof row?.name === "string" ? row.name : null,
+            status: (typeof row?.status === "string" ? row.status : "open"),
+            createdAt: row?.createdAt instanceof Date ? row.createdAt : new Date(row?.createdAt ?? Date.now()),
+            updatedAt: row?.updatedAt instanceof Date ? row.updatedAt : row?.updatedAt ? new Date(row.updatedAt) : undefined,
+        };
+    }
+    normalizeContext(row, thread) {
+        return {
+            id: String(row?.id ?? ""),
+            threadId: thread?.id,
+            key: thread?.key ?? null,
+            status: (typeof row?.status === "string" ? row.status : "open"),
+            createdAt: row?.createdAt instanceof Date ? row.createdAt : new Date(row?.createdAt ?? Date.now()),
+            updatedAt: row?.updatedAt instanceof Date ? row.updatedAt : row?.updatedAt ? new Date(row.updatedAt) : undefined,
+            content: row?.content ?? null,
+        };
+    }
+    async getThreadByContextId(contextId) {
+        try {
+            const res = await this.db.query({
+                thread_contexts: {
+                    $: { where: { id: contextId }, limit: 1 },
+                    thread: {},
+                },
+            });
+            const ctx = res?.thread_contexts?.[0];
+            const threadNode = Array.isArray(ctx?.thread) ? ctx.thread[0] : ctx?.thread;
+            if (threadNode)
+                return this.normalizeThread(threadNode);
+        }
+        catch {
+            // fallback below
+        }
+        try {
+            const res = await this.db.query({
+                thread_threads: {
+                    $: { where: { "contexts.id": contextId }, limit: 1 },
+                },
+            });
+            const row = res?.thread_threads?.[0];
+            return row ? this.normalizeThread(row) : null;
+        }
+        catch {
+            return null;
+        }
+    }
+    async getContextByThreadId(threadId) {
+        try {
+            const res = await this.db.query({
+                thread_contexts: {
+                    $: { where: { thread: threadId }, limit: 1 },
+                },
+            });
+            const row = res?.thread_contexts?.[0];
+            if (!row)
+                return null;
+            const thread = await this.getThread({ id: threadId });
+            return this.normalizeContext(row, thread);
+        }
+        catch {
+            try {
+                const res = await this.db.query({
+                    thread_contexts: {
+                        $: { where: { "thread.id": threadId }, limit: 1 },
+                    },
+                });
+                const row = res?.thread_contexts?.[0];
+                if (!row)
+                    return null;
+                const thread = await this.getThread({ id: threadId });
+                return this.normalizeContext(row, thread);
+            }
+            catch {
+                return null;
+            }
+        }
+    }
+    async createThread(threadIdentifier, fallbackKey) {
+        const threadId = threadIdentifier?.id ?? id();
+        const key = threadIdentifier?.key ??
+            fallbackKey ??
+            (threadIdentifier?.id ? String(threadIdentifier.id) : null);
+        await this.db.transact([
+            this.db.tx.thread_threads[threadId].create({
+                createdAt: new Date(),
+                updatedAt: new Date(),
+                status: "open",
+                key,
+            }),
+        ]);
+        const thread = await this.getThread({ id: threadId });
+        if (!thread) {
+            throw new Error("InstantStore: failed to create thread");
+        }
+        return thread;
+    }
+    async getOrCreateThread(threadIdentifier) {
+        if (!threadIdentifier) {
+            return this.createThread(null);
+        }
+        const existing = await this.getThread(threadIdentifier);
+        if (existing)
+            return existing;
+        return this.createThread(threadIdentifier);
+    }
+    async getThread(threadIdentifier) {
+        try {
+            if (threadIdentifier.id) {
+                const res = await this.db.query({
+                    thread_threads: {
+                        $: { where: { id: threadIdentifier.id }, limit: 1 },
+                    },
+                });
+                const row = res?.thread_threads?.[0];
+                return row ? this.normalizeThread(row) : null;
+            }
+            const res = await this.db.query({
+                thread_threads: {
+                    $: { where: { key: threadIdentifier.key }, limit: 1 },
+                },
+            });
+            const row = res?.thread_threads?.[0];
+            return row ? this.normalizeThread(row) : null;
+        }
+        catch (error) {
+            throw new Error("InstantStore: Error getting thread: " + error.message);
+        }
+    }
+    async updateThreadStatus(threadIdentifier, status) {
+        const thread = await this.getThread(threadIdentifier);
+        if (!thread)
+            throw new Error("InstantStore: thread not found");
+        await this.db.transact([
+            this.db.tx.thread_threads[thread.id].update({
+                status,
+                updatedAt: new Date(),
+            }),
+        ]);
+    }
+    async getOrCreateContext(contextIdentifier) {
+        if (!contextIdentifier) {
+            const contextId = id();
+            const thread = await this.createThread(null, contextId);
+            return await this.createContextForThread(thread, contextId);
+        }
+        const context = await this.getContext(contextIdentifier);
+        if (context) {
+            return await this.ensureContextThreadLink(context, contextIdentifier);
+        }
+        if (contextIdentifier.key) {
+            const thread = await this.getOrCreateThread({ key: contextIdentifier.key });
+            return await this.createContextForThread(thread);
+        }
+        const thread = await this.getOrCreateThread(contextIdentifier.id ? { key: String(contextIdentifier.id) } : null);
+        return await this.createContextForThread(thread, contextIdentifier.id);
+    }
+    async createContextForThread(thread, contextId) {
+        const contextData = {
+            createdAt: new Date(),
+            content: {},
+            status: "open",
+        };
+        const newContextId = contextId ?? id();
+        await this.db.transact([
+            this.db.tx.thread_contexts[newContextId].create(contextData),
+            this.db.tx.thread_contexts[newContextId].link({ thread: thread.id }),
+        ]);
+        const ctx = await this.getContext({ id: newContextId });
+        if (!ctx)
+            throw new Error("InstantStore: failed to create context");
+        return ctx;
+    }
+    async getContext(contextIdentifier) {
+        try {
+            if (contextIdentifier.id) {
+                const res = await this.db.query({
+                    thread_contexts: {
+                        $: { where: { id: contextIdentifier.id }, limit: 1 },
+                    },
+                });
+                const row = res?.thread_contexts?.[0];
+                if (!row)
+                    return null;
+                const thread = await this.getThreadByContextId(String(row.id));
+                return this.normalizeContext(row, thread);
+            }
+            if (contextIdentifier.key) {
+                const thread = await this.getThread({ key: contextIdentifier.key });
+                if (!thread)
+                    return null;
+                return await this.getContextByThreadId(thread.id);
+            }
+            return null;
+        }
+        catch (error) {
+            throw new Error("InstantStore: Error getting context: " + error.message);
+        }
+    }
+    async updateContextContent(contextIdentifier, content) {
+        const context = await this.getContext(contextIdentifier);
+        if (!context?.id)
+            throw new Error("InstantStore: context not found");
+        await this.db.transact([
+            this.db.tx.thread_contexts[context.id].update({
+                content: content,
+                updatedAt: new Date(),
+            }),
+        ]);
+        const ctx = await this.getContext(contextIdentifier);
+        if (!ctx)
+            throw new Error("InstantStore: context not found after update");
+        return ctx;
+    }
+    async updateContextStatus(contextIdentifier, status) {
+        const context = await this.getContext(contextIdentifier);
+        if (!context?.id)
+            throw new Error("InstantStore: context not found");
+        const txs = [
+            this.db.tx.thread_contexts[context.id].update({
+                status,
+                updatedAt: new Date(),
+            }),
+        ];
+        if (context.threadId) {
+            txs.push(this.db.tx.thread_threads[context.threadId].update({
+                status: (status === "closed" ? "closed" : status),
+                updatedAt: new Date(),
+            }));
+        }
+        await this.db.transact(txs);
+    }
+    async resolveThreadContext(contextIdentifier) {
+        const context = await this.getContext(contextIdentifier);
+        if (!context?.id)
+            throw new Error("InstantStore: context not found");
+        let thread = context.threadId
+            ? await this.getThread({ id: context.threadId })
+            : await this.getThreadByContextId(context.id);
+        if (!thread) {
+            const healed = await this.ensureContextThreadLink(context, contextIdentifier);
+            thread = healed.threadId ? await this.getThread({ id: healed.threadId }) : null;
+        }
+        if (!thread)
+            throw new Error("InstantStore: thread not found for context");
+        return { context: { ...context, threadId: thread.id }, thread };
+    }
+    async saveItem(contextIdentifier, event) {
+        const { context, thread } = await this.resolveThreadContext(contextIdentifier);
+        const txs = [
+            this.db.tx.thread_items[event.id].update({
+                ...event,
+                status: "stored",
+            }),
+        ];
+        txs.push(this.db.tx.thread_items[event.id].link({ context: context.id }));
+        txs.push(this.db.tx.thread_items[event.id].link({ thread: thread.id }));
+        await this.db.transact(txs);
+        const persisted = await this.getItem(event.id);
+        if (!persisted)
+            throw new Error("InstantStore: failed to read event after save");
+        return persisted;
+    }
+    async updateItem(eventId, event) {
+        await this.db.transact([this.db.tx.thread_items[eventId].update(event)]);
+        const persisted = await this.getItem(eventId);
+        if (!persisted)
+            throw new Error("InstantStore: event not found after update");
+        return persisted;
+    }
+    async getItem(eventId) {
+        const res = await this.db.query({
+            thread_items: {
+                $: { where: { id: eventId } },
+            },
+        });
+        return res.thread_items?.[0] ?? null;
+    }
+    async getItems(contextIdentifier) {
+        const { thread } = await this.resolveThreadContext(contextIdentifier);
+        let res;
+        try {
+            res = await this.db.query({
+                thread_items: {
+                    $: {
+                        where: { thread: thread.id },
+                        // Keep query constraints minimal to avoid hard dependency on Instant orderable indexes.
+                        // Ordering is applied in-memory below.
+                        limit: 1000,
+                    },
+                },
+            });
+        }
+        catch {
+            res = await this.db.query({
+                thread_items: {
+                    $: {
+                        where: { "thread.id": thread.id },
+                        limit: 1000,
+                    },
+                },
+            });
+        }
+        const items = (res.thread_items ?? []);
+        const toEpoch = (value) => {
+            if (value instanceof Date)
+                return value.getTime();
+            if (typeof value === "string" || typeof value === "number") {
+                const ms = new Date(value).getTime();
+                return Number.isFinite(ms) ? ms : 0;
+            }
+            return 0;
+        };
+        return [...items].sort((a, b) => {
+            const ta = toEpoch(a?.createdAt ?? a?.updatedAt);
+            const tb = toEpoch(b?.createdAt ?? b?.updatedAt);
+            if (ta !== tb)
+                return ta - tb;
+            return String(a?.id ?? "").localeCompare(String(b?.id ?? ""));
+        });
+    }
+    async createExecution(contextIdentifier, triggerEventId, reactionEventId) {
+        const { context, thread } = await this.resolveThreadContext(contextIdentifier);
+        const executionId = id();
+        const execCreate = this.db.tx.thread_executions[executionId].create({
+            createdAt: new Date(),
+            status: "executing",
+        });
+        const txs = [execCreate];
+        txs.push(this.db.tx.thread_executions[executionId].link({ context: context.id }));
+        txs.push(this.db.tx.thread_executions[executionId].link({ thread: thread.id }));
+        txs.push(this.db.tx.thread_contexts[context.id].link({ currentExecution: executionId }));
+        txs.push(this.db.tx.thread_executions[executionId].link({ trigger: triggerEventId }));
+        txs.push(this.db.tx.thread_executions[executionId].link({ reaction: reactionEventId }));
+        txs.push(this.db.tx.thread_threads[thread.id].update({
+            status: "streaming",
+            updatedAt: new Date(),
+        }));
+        await this.db.transact(txs);
+        return { id: executionId };
+    }
+    async completeExecution(contextIdentifier, executionId, status) {
+        const { context, thread } = await this.resolveThreadContext(contextIdentifier);
+        const txs = [];
+        txs.push(this.db.tx.thread_executions[executionId].update({ status, updatedAt: new Date() }));
+        // Update context status back to "open" when execution completes
+        txs.push(this.db.tx.thread_contexts[context.id].update({ status: "open", updatedAt: new Date() }));
+        txs.push(this.db.tx.thread_threads[thread.id].update({
+            status: status === "failed" ? "failed" : "open",
+            updatedAt: new Date(),
+        }));
+        await this.db.transact(txs);
+    }
+    async createStep(params) {
+        const stepId = id();
+        const eventId = id();
+        const txs = [
+            this.db.tx.thread_steps[stepId].create({
+                createdAt: new Date(),
+                status: "running",
+                iteration: params.iteration,
+                executionId: params.executionId,
+                eventId,
+            }),
+        ];
+        txs.push(this.db.tx.thread_steps[stepId].link({ execution: params.executionId }));
+        await this.db.transact(txs);
+        return { id: stepId, eventId };
+    }
+    async updateStep(stepId, patch) {
+        const update = {
+            ...patch,
+            updatedAt: patch.updatedAt ?? new Date(),
+        };
+        await this.db.transact([this.db.tx.thread_steps[stepId].update(update)]);
+    }
+    async linkItemToExecution(params) {
+        await this.db.transact([
+            this.db.tx.thread_items[params.itemId].link({ execution: params.executionId }),
+        ]);
+    }
+    async saveStepParts(params) {
+        const parts = Array.isArray(params.parts) ? params.parts : [];
+        if (parts.length === 0)
+            return;
+        const txs = parts.map((p, idx) => {
+            const key = `${params.stepId}:${idx}`;
+            return this.db.tx.thread_parts[lookup("key", key)]
+                .update({
+                stepId: params.stepId,
+                idx,
+                type: typeof p?.type === "string" ? String(p.type) : undefined,
+                part: p,
+                updatedAt: new Date(),
+            })
+                .link({ step: params.stepId });
+        });
+        await this.db.transact(txs);
+    }
+    async itemsToModelMessages(events) {
+        // Prefer parts-first reconstruction from thread_parts via the producing step.
+        const eventIds = events.map((e) => String(e.id)).filter(Boolean);
+        let eventsWithParts = events;
+        if (eventIds.length) {
+            try {
+                // 1) Get steps for these events (eventId is stored on thread_steps)
+                const stepsRes = await this.db.query({
+                    thread_steps: {
+                        $: {
+                            where: { eventId: { $in: eventIds } },
+                            fields: ["id", "eventId"],
+                            limit: 2000,
+                        },
+                    },
+                });
+                const steps = stepsRes.thread_steps ?? [];
+                const stepIdByEventId = new Map();
+                const stepIds = [];
+                for (const s of steps) {
+                    const sid = String(s.id);
+                    const eid = String(s.eventId);
+                    if (sid && eid) {
+                        stepIdByEventId.set(eid, sid);
+                        stepIds.push(sid);
+                    }
+                }
+                // 2) Load parts for those steps
+                const partsByStepId = new Map();
+                if (stepIds.length) {
+                    const partsRes = await this.db.query({
+                        thread_parts: {
+                            $: {
+                                where: { stepId: { $in: stepIds } },
+                                order: { idx: "asc" },
+                                limit: 5000,
+                            },
+                        },
+                    });
+                    const rows = partsRes.thread_parts ?? [];
+                    for (const r of rows) {
+                        const sid = String(r.stepId);
+                        const arr = partsByStepId.get(sid) ?? [];
+                        arr.push(r.part);
+                        partsByStepId.set(sid, arr);
+                    }
+                }
+                // 3) Attach parts onto events
+                eventsWithParts = events.map((e) => {
+                    const eid = String(e.id);
+                    const sid = stepIdByEventId.get(eid);
+                    if (!sid)
+                        return e;
+                    const parts = partsByStepId.get(sid);
+                    if (!parts || parts.length === 0)
+                        return e;
+                    return { ...e, content: { ...(e?.content ?? {}), parts } };
+                });
+            }
+            catch {
+                // If schema not pushed yet (or table absent), fallback to embedded parts.
+                eventsWithParts = events;
+            }
+        }
+        // Default behavior for Instant-backed stories:
+        // - Expand file parts into derived `document.parsed` events (persisting parsed content into document_documents)
+        // - Then convert expanded events to model messages
+        const expanded = await expandEventsWithInstantDocuments({
+            db: this.db,
+            events: eventsWithParts,
+            derivedEventType: "document.parsed",
+        });
+        return await convertItemsToModelMessages(expanded);
+    }
+}
+/**
+ * Helper to create a ThreadRuntimeResolver that returns an InstantStore.
+ *
+ * This keeps the app-level `ekairos.ts` extremely small.
+ */
+export function createInstantStoreRuntime(params) {
+    const storesByOrg = new Map();
+    return async (env) => {
+        const orgId = params.getOrgId?.(env) ??
+            (typeof env?.orgId === "string" ? String(env.orgId) : "");
+        if (!orgId) {
+            throw new Error('[instant] Missing orgId in env. Provide env.orgId (or customize getOrgId).');
+        }
+        const cached = storesByOrg.get(orgId);
+        if (cached)
+            return cached;
+        const db = await params.getDb(orgId);
+        const store = new InstantStore(db);
+        const concreteDomain = params.domain?.fromDB ? params.domain.fromDB(db) : undefined;
+        const runtime = { store, db, domain: concreteDomain };
+        storesByOrg.set(orgId, runtime);
+        return runtime;
+    };
+}

package/dist/story.actions.d.ts

@@ -0,0 +1,60 @@
+import type { StoryEnvironment } from "./story.config.js";
+import type { ContextEvent, ContextIdentifier } from "./story.store.js";
+import type { StoryStreamOptions } from "./story.engine.js";
+type StoryReactInput = ContextEvent | {
+    env?: StoryEnvironment;
+    storyKey?: string;
+    story?: {
+        react: (event: ContextEvent, params: any) => Promise<any> | any;
+        key?: string;
+    };
+    triggerEvent?: ContextEvent;
+    incomingEvent?: ContextEvent;
+    context?: ContextIdentifier | null;
+    contextIdentifier?: ContextIdentifier | null;
+    options?: StoryStreamOptions;
+};
+type StoryActionContext = {
+    env: StoryEnvironment;
+    storyKey?: string;
+    story?: {
+        react: (event: ContextEvent, params: any) => Promise<any> | any;
+        key?: string;
+    };
+    domain?: {
+        meta?: Record<string, unknown>;
+    } | null;
+};
+export declare const storyActions: {
+    react: {
+        description: string;
+        execute: (input: StoryReactInput, ctx?: StoryActionContext) => Promise<any>;
+    };
+    listStories: {
+        description: string;
+        execute: () => Promise<{
+            ok: boolean;
+            data: {
+                stories: string[];
+            };
+        }>;
+    };
+    hasStory: {
+        description: string;
+        execute: (input: {
+            storyKey?: string;
+        }) => Promise<{
+            ok: boolean;
+            error: string;
+            data?: undefined;
+        } | {
+            ok: boolean;
+            data: {
+                storyKey: string;
+                registered: boolean;
+            };
+            error?: undefined;
+        }>;
+    };
+};
+export {};