@ekairos/thread 1.21.89-beta.0 → 1.21.90-beta.0

package/dist/schema.js

@@ -13,6 +13,7 @@ export const threadDomain = domain("thread")
         thread_contexts: i.entity({
             createdAt: i.date(),
             updatedAt: i.date().optional(),
+            // Required for prefix/history queries that use `$like` over context keys.
             key: i.string().optional().indexed().unique(),
             status: i.string().optional().indexed(), // open | streaming | closed
             content: i.any().optional(),

package/dist/steps/store.steps.js

@@ -74,6 +74,39 @@ function inferDirection(item) {
     }
     return undefined;
 }
+function shouldDebugThreadStoreSteps() {
+    return (process.env.EKAIROS_THREAD_DEBUG === "1" ||
+        process.env.PLAYWRIGHT_TEST === "1");
+}
+function summarizeStepError(error) {
+    const err = error;
+    return {
+        name: err?.name,
+        message: err?.message,
+        code: err?.code,
+        status: err?.status ?? err?.statusCode,
+        details: err?.details ?? err?.body ?? err?.response ?? err?.data,
+        stack: typeof err?.stack === "string"
+            ? err.stack.slice(0, 1500)
+            : undefined,
+    };
+}
+function summarizeContextIdentifierForLog(identifier) {
+    return {
+        id: identifier && typeof identifier.id === "string"
+            ? String(identifier.id)
+            : undefined,
+        key: identifier && typeof identifier.key === "string"
+            ? String(identifier.key)
+            : undefined,
+    };
+}
+function logStepDebug(message, payload) {
+    if (!shouldDebugThreadStoreSteps())
+        return;
+    // eslint-disable-next-line no-console
+    console.error(`[thread][store.steps] ${message}`, payload);
+}
 /**
  * Initializes/ensures the story context exists and emits a single `data-context-id` chunk.
  *
@@ -174,13 +207,54 @@ export async function saveTriggerAndCreateExecution(params) {
     const { getThreadRuntime } = await import("@ekairos/thread/runtime");
     const runtime = await getThreadRuntime(params.env);
     const { store, db } = runtime;
-    const saved = await store.saveItem(params.contextIdentifier, params.triggerEvent);
+    logStepDebug("saveTriggerAndCreateExecution:start", {
+        contextIdentifier: summarizeContextIdentifierForLog(params.contextIdentifier),
+        triggerEventId: params.triggerEvent?.id,
+        triggerEventType: params.triggerEvent?.type,
+        triggerEventChannel: params.triggerEvent?.channel,
+        triggerEventCreatedAt: params.triggerEvent?.createdAt,
+    });
+    let saved;
+    try {
+        saved = await store.saveItem(params.contextIdentifier, params.triggerEvent);
+    }
+    catch (error) {
+        logStepDebug("saveTriggerAndCreateExecution:saveItem:error", {
+            contextIdentifier: summarizeContextIdentifierForLog(params.contextIdentifier),
+            triggerEventId: params.triggerEvent?.id,
+            error: summarizeStepError(error),
+        });
+        throw error;
+    }
     const uuid = globalThis.crypto?.randomUUID?.();
     const reactionEventId = typeof uuid === "string"
         ? uuid
         : `${Date.now()}-${Math.random().toString(16).slice(2)}`;
-    await store.updateContextStatus(params.contextIdentifier, "streaming");
-    const execution = await store.createExecution(params.contextIdentifier, saved.id, reactionEventId);
+    try {
+        await store.updateContextStatus(params.contextIdentifier, "streaming");
+    }
+    catch (error) {
+        logStepDebug("saveTriggerAndCreateExecution:updateContextStatus:error", {
+            contextIdentifier: summarizeContextIdentifierForLog(params.contextIdentifier),
+            triggerEventId: saved.id,
+            reactionEventId,
+            error: summarizeStepError(error),
+        });
+        throw error;
+    }
+    let execution;
+    try {
+        execution = await store.createExecution(params.contextIdentifier, saved.id, reactionEventId);
+    }
+    catch (error) {
+        logStepDebug("saveTriggerAndCreateExecution:createExecution:error", {
+            contextIdentifier: summarizeContextIdentifierForLog(params.contextIdentifier),
+            triggerEventId: saved.id,
+            reactionEventId,
+            error: summarizeStepError(error),
+        });
+        throw error;
+    }
     const { runId, meta } = await resolveWorkflowRunId({
         env: params.env,
         db,

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

@@ -14,6 +14,7 @@ export type InstantStoreDb = any;
 export declare class InstantStore implements ThreadStore {
     private db;
     constructor(db: InstantStoreDb);
+    private syncLegacyThreadRowBestEffort;
     private ensureContextThreadLink;
     private normalizeThread;
     private normalizeContext;

package/dist/stores/instant.store.js

@@ -4,10 +4,92 @@ 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";
+function shouldDebugInstantStore() {
+    return (process.env.EKAIROS_THREAD_DEBUG === "1" ||
+        process.env.PLAYWRIGHT_TEST === "1");
+}
+function clipText(value, max = 500) {
+    if (value.length <= max)
+        return value;
+    return `${value.slice(0, max)}...<truncated:${value.length - max}>`;
+}
+function simplifyForLog(value, depth = 0) {
+    if (value === null || value === undefined)
+        return value;
+    if (typeof value === "string")
+        return clipText(value);
+    if (typeof value === "number" || typeof value === "boolean")
+        return value;
+    if (value instanceof Date)
+        return value.toISOString();
+    if (depth >= 2)
+        return "[max-depth]";
+    if (Array.isArray(value)) {
+        const maxItems = 8;
+        const items = value
+            .slice(0, maxItems)
+            .map((item) => simplifyForLog(item, depth + 1));
+        if (value.length > maxItems) {
+            items.push(`...+${value.length - maxItems} more`);
+        }
+        return items;
+    }
+    if (typeof value === "object") {
+        const entries = Object.entries(value);
+        const maxEntries = 16;
+        const out = {};
+        for (const [key, entryValue] of entries.slice(0, maxEntries)) {
+            out[key] = simplifyForLog(entryValue, depth + 1);
+        }
+        if (entries.length > maxEntries) {
+            out.__truncatedKeys = entries.length - maxEntries;
+        }
+        return out;
+    }
+    return String(value);
+}
+function summarizeError(error) {
+    const err = error;
+    return {
+        name: err?.name,
+        message: err?.message,
+        code: err?.code,
+        status: err?.status ?? err?.statusCode,
+        details: simplifyForLog(err?.details ?? err?.body ?? err?.response ?? err?.data),
+        stack: typeof err?.stack === "string"
+            ? clipText(err.stack, 1500)
+            : undefined,
+    };
+}
+function logInstantTransactFailure(params) {
+    if (!shouldDebugInstantStore())
+        return;
+    const payload = {
+        action: params.action,
+        meta: simplifyForLog(params.meta ?? {}),
+        txs: simplifyForLog(params.txs),
+        error: summarizeError(params.error),
+    };
+    // eslint-disable-next-line no-console
+    console.error("[thread][instant.store] transact failed", payload);
+}
 export class InstantStore {
     constructor(db) {
         this.db = db;
     }
+    async syncLegacyThreadRowBestEffort(threadId) {
+        if (!threadId)
+            return;
+        try {
+            await this.db.transact([
+                this.db.tx.thread[threadId].update({}),
+            ]);
+        }
+        catch {
+            // Legacy `thread` entity does not exist on all apps.
+            // This is a best-effort compatibility write.
+        }
+    }
     async ensureContextThreadLink(context, contextIdentifier) {
         if (context.threadId)
             return context;
@@ -15,6 +97,7 @@ export class InstantStore {
             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.syncLegacyThreadRowBestEffort(thread.id);
         const txs = [this.db.tx.thread_contexts[context.id].link({ thread: thread.id })];
         if (!context.key && thread.key) {
             txs.push(this.db.tx.thread_contexts[context.id].update({
@@ -56,6 +139,7 @@ export class InstantStore {
         };
     }
     async getThreadByContextId(contextId) {
+        let contextKey = null;
         try {
             const res = await this.db.query({
                 thread_contexts: {
@@ -64,13 +148,27 @@ export class InstantStore {
                 },
             });
             const ctx = res?.thread_contexts?.[0];
+            contextKey = typeof ctx?.key === "string" ? ctx.key : null;
             const threadNode = Array.isArray(ctx?.thread) ? ctx.thread[0] : ctx?.thread;
-            if (threadNode)
-                return this.normalizeThread(threadNode);
+            if (threadNode) {
+                const normalized = this.normalizeThread(threadNode);
+                if (normalized.id)
+                    return normalized;
+            }
         }
         catch {
             // fallback below
         }
+        if (contextKey) {
+            try {
+                const byKey = await this.getThread({ key: contextKey });
+                if (byKey?.id)
+                    return byKey;
+            }
+            catch {
+                // continue fallback chain
+            }
+        }
         try {
             const res = await this.db.query({
                 thread_threads: {
@@ -81,7 +179,23 @@ export class InstantStore {
             return row ? this.normalizeThread(row) : null;
         }
         catch {
-            return null;
+            try {
+                const executionFallback = await this.db.query({
+                    thread_executions: {
+                        $: { where: { "context.id": contextId }, limit: 1 },
+                        thread: {},
+                    },
+                });
+                const executionRow = executionFallback?.thread_executions?.[0];
+                const executionThread = Array.isArray(executionRow?.thread)
+                    ? executionRow.thread[0]
+                    : executionRow?.thread;
+                const normalized = executionThread ? this.normalizeThread(executionThread) : null;
+                return normalized?.id ? normalized : null;
+            }
+            catch {
+                return null;
+            }
         }
     }
     async getContextByThreadId(threadId) {
@@ -142,6 +256,7 @@ export class InstantStore {
                 key,
             }),
         ]);
+        await this.syncLegacyThreadRowBestEffort(threadId);
         const thread = await this.getThread({ id: threadId });
         if (!thread) {
             throw new Error("InstantStore: failed to create thread");
@@ -333,7 +448,26 @@ export class InstantStore {
         ];
         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);
+        try {
+            await this.db.transact(txs);
+        }
+        catch (error) {
+            logInstantTransactFailure({
+                action: "saveItem",
+                meta: {
+                    contextIdentifier: simplifyForLog(contextIdentifier),
+                    contextId: context.id,
+                    threadId: thread.id,
+                    eventId: event?.id,
+                    eventType: event?.type,
+                    eventChannel: event?.channel,
+                    eventCreatedAt: event?.createdAt,
+                },
+                txs,
+                error,
+            });
+            throw error;
+        }
         const persisted = await this.getItem(event.id);
         if (!persisted)
             throw new Error("InstantStore: failed to read event after save");
@@ -414,7 +548,25 @@ export class InstantStore {
             status: "streaming",
             updatedAt: new Date(),
         }));
-        await this.db.transact(txs);
+        try {
+            await this.db.transact(txs);
+        }
+        catch (error) {
+            logInstantTransactFailure({
+                action: "createExecution",
+                meta: {
+                    contextIdentifier: simplifyForLog(contextIdentifier),
+                    contextId: context.id,
+                    threadId: thread.id,
+                    executionId,
+                    triggerEventId,
+                    reactionEventId,
+                },
+                txs,
+                error,
+            });
+            throw error;
+        }
         return { id: executionId };
     }
     async completeExecution(contextIdentifier, executionId, status) {
@@ -442,7 +594,23 @@ export class InstantStore {
             }),
         ];
         txs.push(this.db.tx.thread_steps[stepId].link({ execution: params.executionId }));
-        await this.db.transact(txs);
+        try {
+            await this.db.transact(txs);
+        }
+        catch (error) {
+            logInstantTransactFailure({
+                action: "createStep",
+                meta: {
+                    executionId: params.executionId,
+                    iteration: params.iteration,
+                    stepId,
+                    eventId,
+                },
+                txs,
+                error,
+            });
+            throw error;
+        }
         return { id: stepId, eventId };
     }
     async updateStep(stepId, patch) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ekairos/thread",
-  "version": "1.21.89-beta.0",
+  "version": "1.21.90-beta.0",
   "description": "Pulzar Thread - Workflow-based AI Threads",
   "type": "module",
   "main": "dist/index.js",
@@ -110,7 +110,7 @@
   },
   "dependencies": {
     "@ai-sdk/openai": "^2.0.52",
-    "@ekairos/domain": "^1.21.89-beta.0",
+    "@ekairos/domain": "^1.21.90-beta.0",
     "@instantdb/admin": "0.22.126",
     "@instantdb/core": "0.22.126",
     "@vercel/mcp-adapter": "^1.0.0",
@@ -120,7 +120,7 @@
     "jose": "^6.1.3",
     "llamaindex": "^0.12.0",
     "react": "^19.2.0",
-    "workflow": "4.1.0-beta.53",
+    "workflow": "4.1.0-beta.55",
     "xmlbuilder2": "^3.1.1",
     "zod": "^4.1.8"
   },