@ekairos/thread 1.22.16-beta.feature-core-thread-registry-sync.0 → 1.22.18-beta.feature-core-thread-registry-sync.0

package/dist/steps/store.steps.js

@@ -31,15 +31,13 @@ function parseRunIdFromTriggerId(triggerEventId) {
     return parsed || undefined;
 }
 async function resolveWorkflowRunId(params) {
-    const meta = await readWorkflowMetadata();
-    let runId = meta && meta.workflowRunId !== undefined && meta.workflowRunId !== null
-        ? String(meta.workflowRunId)
+    const envRunId = params.env?.workflowRunId;
+    let runId = typeof envRunId === "string" && envRunId.trim()
+        ? envRunId.trim()
         : "";
-    if (!runId) {
-        const envRunId = params.env?.workflowRunId;
-        if (typeof envRunId === "string" && envRunId.trim()) {
-            runId = envRunId.trim();
-        }
+    const meta = runId ? null : await readWorkflowMetadata();
+    if (!runId && meta && meta.workflowRunId !== undefined && meta.workflowRunId !== null) {
+        runId = String(meta.workflowRunId);
     }
     if (!runId && params.triggerEventId) {
         const parsed = parseRunIdFromTriggerId(params.triggerEventId);
@@ -65,13 +63,11 @@ async function resolveWorkflowRunId(params) {
     return { runId: runId || undefined, meta };
 }
 function inferDirection(item) {
-    const type = typeof item?.type === "string" ? item.type : "";
-    if (type.startsWith("output") || type.startsWith("tool") || type.startsWith("assistant")) {
-        return "outbound";
-    }
-    if (type.startsWith("input") || type.startsWith("user")) {
+    const type = typeof item?.type === "string" ? String(item.type) : "";
+    if (type === "input")
         return "inbound";
-    }
+    if (type === "output")
+        return "outbound";
     return undefined;
 }
 function shouldDebugThreadStoreSteps() {
@@ -107,13 +103,13 @@ function logStepDebug(message, payload) {
     console.error(`[thread][store.steps] ${message}`, payload);
 }
 /**
- * Initializes/ensures the story context exists and emits a single `data-context-id` chunk.
+ * Initializes/ensures the story context exists.
  *
  * This is the "context init" boundary for the story engine.
  */
 export async function initializeContext(env, contextIdentifier, opts) {
     "use step";
-    const { getThreadRuntime } = await import("@ekairos/thread/runtime");
+    const { getThreadRuntime } = await import("../runtime.js");
     const runtime = await getThreadRuntime(env);
     const { store, db } = runtime;
     // Detect creation explicitly so the engine can run onContextCreated hooks.
@@ -132,21 +128,6 @@ export async function initializeContext(env, contextIdentifier, opts) {
             result = { context: created, isNew: true };
         }
     }
-    // If we're running in a non-streaming context (e.g. tests or headless usage),
-    // we skip writing stream chunks entirely.
-    if (!opts?.silent && opts?.writable) {
-        const writer = opts.writable.getWriter();
-        try {
-            await writer.write({
-                type: "data-context-id",
-                id: String(result.context.id),
-                data: { contextId: String(result.context.id) },
-            });
-        }
-        finally {
-            writer.releaseLock();
-        }
-    }
     const { runId } = await resolveWorkflowRunId({ env, db });
     if (runId) {
         await maybeWriteTraceEvents(env, [
@@ -168,42 +149,26 @@ export async function initializeContext(env, contextIdentifier, opts) {
 }
 export async function updateContextContent(env, contextIdentifier, content) {
     "use step";
-    const { getThreadRuntime } = await import("@ekairos/thread/runtime");
+    const { getThreadRuntime } = await import("../runtime.js");
     const { store } = await getThreadRuntime(env);
     return await store.updateContextContent(contextIdentifier, content);
 }
 export async function updateContextStatus(env, contextIdentifier, status) {
     "use step";
-    const { getThreadRuntime } = await import("@ekairos/thread/runtime");
+    const { getThreadRuntime } = await import("../runtime.js");
     const { store } = await getThreadRuntime(env);
     await store.updateContextStatus(contextIdentifier, status);
 }
 export async function saveTriggerItem(env, contextIdentifier, event) {
     "use step";
-    const { getThreadRuntime } = await import("@ekairos/thread/runtime");
+    const { getThreadRuntime } = await import("../runtime.js");
     const { store } = await getThreadRuntime(env);
     const saved = await store.saveItem(contextIdentifier, event);
     return saved;
 }
-export async function emitContextIdChunk(params) {
-    "use step";
-    if (!params.writable)
-        return;
-    const writer = params.writable.getWriter();
-    try {
-        await writer.write({
-            type: "data-context-id",
-            id: String(params.contextId),
-            data: { contextId: String(params.contextId) },
-        });
-    }
-    finally {
-        writer.releaseLock();
-    }
-}
 export async function saveTriggerAndCreateExecution(params) {
     "use step";
-    const { getThreadRuntime } = await import("@ekairos/thread/runtime");
+    const { getThreadRuntime } = await import("../runtime.js");
     const runtime = await getThreadRuntime(params.env);
     const { store, db } = runtime;
     logStepDebug("saveTriggerAndCreateExecution:start", {
@@ -229,18 +194,6 @@ export async function saveTriggerAndCreateExecution(params) {
     const reactionEventId = typeof uuid === "string"
         ? uuid
         : `${Date.now()}-${Math.random().toString(16).slice(2)}`;
-    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);
@@ -342,7 +295,7 @@ export async function saveTriggerAndCreateExecution(params) {
 }
 export async function saveReactionItem(env, contextIdentifier, event, opts) {
     "use step";
-    const { getThreadRuntime } = await import("@ekairos/thread/runtime");
+    const { getThreadRuntime } = await import("../runtime.js");
     const runtime = await getThreadRuntime(env);
     const { store, db } = runtime;
     const saved = await store.saveItem(contextIdentifier, event);
@@ -409,7 +362,7 @@ export async function saveReactionItem(env, contextIdentifier, event, opts) {
 }
 export async function updateItem(env, eventId, event, opts) {
     "use step";
-    const { getThreadRuntime } = await import("@ekairos/thread/runtime");
+    const { getThreadRuntime } = await import("../runtime.js");
     const runtime = await getThreadRuntime(env);
     const { store, db } = runtime;
     const saved = await store.updateItem(eventId, event);
@@ -439,26 +392,25 @@ export async function updateItem(env, eventId, event, opts) {
 }
 export async function createExecution(env, contextIdentifier, triggerEventId, reactionEventId) {
     "use step";
-    const { getThreadRuntime } = await import("@ekairos/thread/runtime");
+    const { getThreadRuntime } = await import("../runtime.js");
     const { store } = await getThreadRuntime(env);
     return await store.createExecution(contextIdentifier, triggerEventId, reactionEventId);
 }
 export async function createReactionItem(params) {
     "use step";
-    const { getThreadRuntime } = await import("@ekairos/thread/runtime");
+    const { getThreadRuntime } = await import("../runtime.js");
     const { store } = await getThreadRuntime(params.env);
     // Generate a new reaction event id inside the step boundary.
     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, params.triggerEventId, reactionEventId);
     return { reactionEventId, executionId: execution.id };
 }
 export async function completeExecution(env, contextIdentifier, executionId, status) {
     "use step";
-    const { getThreadRuntime } = await import("@ekairos/thread/runtime");
+    const { getThreadRuntime } = await import("../runtime.js");
     const runtime = await getThreadRuntime(env);
     const { store, db } = runtime;
     await store.completeExecution(contextIdentifier, executionId, status);
@@ -488,7 +440,7 @@ export async function completeExecution(env, contextIdentifier, executionId, sta
 }
 export async function updateExecutionWorkflowRun(params) {
     "use step";
-    const { getThreadRuntime } = await import("@ekairos/thread/runtime");
+    const { getThreadRuntime } = await import("../runtime.js");
     const runtime = await getThreadRuntime(params.env);
     const db = runtime?.db;
     if (db) {
@@ -502,17 +454,17 @@ export async function updateExecutionWorkflowRun(params) {
 }
 export async function createThreadStep(params) {
     "use step";
-    const { getThreadRuntime } = await import("@ekairos/thread/runtime");
+    const { getThreadRuntime } = await import("../runtime.js");
     const { store } = await getThreadRuntime(params.env);
     const res = await store.createStep({
         executionId: params.executionId,
         iteration: params.iteration,
     });
-    return { stepId: res.id, eventId: res.eventId };
+    return { stepId: res.id };
 }
 export async function updateThreadStep(params) {
     "use step";
-    const { getThreadRuntime } = await import("@ekairos/thread/runtime");
+    const { getThreadRuntime } = await import("../runtime.js");
     const runtime = await getThreadRuntime(params.env);
     const { store, db } = runtime;
     await store.updateStep(params.stepId, {
@@ -536,9 +488,14 @@ export async function updateThreadStep(params) {
                 stepId: String(params.stepId),
                 payload: {
                     status: params.patch.status,
+                    kind: params.patch.kind,
+                    actionName: params.patch.actionName,
+                    actionInput: params.patch.actionInput,
+                    actionOutput: params.patch.actionOutput,
+                    actionError: params.patch.actionError,
                     iteration: params.iteration,
-                    toolCalls: params.patch.toolCalls,
-                    toolExecutionResults: params.patch.toolExecutionResults,
+                    actionRequests: params.patch.actionRequests,
+                    actionResults: params.patch.actionResults,
                     continueLoop: params.patch.continueLoop,
                     errorText: params.patch.errorText,
                 },
@@ -548,13 +505,13 @@ export async function updateThreadStep(params) {
 }
 export async function linkItemToExecutionStep(params) {
     "use step";
-    const { getThreadRuntime } = await import("@ekairos/thread/runtime");
+    const { getThreadRuntime } = await import("../runtime.js");
     const { store } = await getThreadRuntime(params.env);
     await store.linkItemToExecution({ itemId: params.itemId, executionId: params.executionId });
 }
 export async function saveThreadPartsStep(params) {
     "use step";
-    const { getThreadRuntime } = await import("@ekairos/thread/runtime");
+    const { getThreadRuntime } = await import("../runtime.js");
     const runtime = await getThreadRuntime(params.env);
     const { store, db } = runtime;
     await store.saveStepParts({ stepId: params.stepId, parts: params.parts });

package/dist/steps/stream.steps.d.ts

@@ -1,37 +1,7 @@
 import type { UIMessageChunk } from "ai";
-export declare function writeContextSubstate(params: {
-    /**
-     * Ephemeral substate key for the UI (thread engine internal state).
-     *
-     * - Provide a string key like "actions" to set it
-     * - Provide null to clear it
-     */
-    key: string | null;
-    transient?: boolean;
-    writable?: WritableStream<UIMessageChunk>;
-}): Promise<void>;
-export declare function writeContextIdChunk(params: {
-    contextId: string;
-    writable?: WritableStream<UIMessageChunk>;
-}): Promise<void>;
-export declare function writeThreadPing(params: {
-    /**
-     * Simple ping event to validate that the workflow stream is alive.
-     * This is intentionally generic so clients can ignore it safely.
-     */
-    label?: string;
-    writable?: WritableStream<UIMessageChunk>;
-}): Promise<void>;
-export declare function writeToolOutputs(params: {
-    results: Array<{
-        toolCallId: string;
-        success: true;
-        output: unknown;
-    } | {
-        toolCallId: string;
-        success: false;
-        errorText: string;
-    }>;
+import type { ThreadStreamEvent } from "../thread.stream.js";
+export declare function writeThreadEvents(params: {
+    events: ThreadStreamEvent[];
     writable?: WritableStream<UIMessageChunk>;
 }): Promise<void>;
 export declare function closeThreadStream(params: {

package/dist/steps/stream.steps.js

@@ -1,76 +1,15 @@
-export async function writeContextSubstate(params) {
+export async function writeThreadEvents(params) {
     "use step";
     const writable = params.writable;
-    if (!writable)
-        return;
-    const writer = writable.getWriter();
-    try {
-        await writer.write({
-            type: "data-context-substate",
-            data: { key: params.key },
-            transient: params.transient ?? true,
-        });
-    }
-    finally {
-        writer.releaseLock();
-    }
-}
-export async function writeContextIdChunk(params) {
-    "use step";
-    const writable = params.writable;
-    if (!writable)
-        return;
-    const writer = writable.getWriter();
-    try {
-        await writer.write({
-            type: "data-context-id",
-            id: params.contextId,
-            data: { contextId: params.contextId },
-        });
-    }
-    finally {
-        writer.releaseLock();
-    }
-}
-export async function writeThreadPing(params) {
-    "use step";
-    const writable = params.writable;
-    if (!writable)
-        return;
-    const writer = writable.getWriter();
-    try {
-        await writer.write({
-            type: "data-thread-ping",
-            data: { label: params.label ?? "thread-ping" },
-            transient: true,
-        });
-    }
-    finally {
-        writer.releaseLock();
-    }
-}
-export async function writeToolOutputs(params) {
-    "use step";
-    const writable = params.writable;
-    if (!writable)
+    if (!writable || !params.events.length)
         return;
     const writer = writable.getWriter();
     try {
-        for (const r of params.results) {
-            if (r.success) {
-                await writer.write({
-                    type: "tool-output-available",
-                    toolCallId: r.toolCallId,
-                    output: r.output,
-                });
-            }
-            else {
-                await writer.write({
-                    type: "tool-output-error",
-                    toolCallId: r.toolCallId,
-                    errorText: r.errorText,
-                });
-            }
+        for (const event of params.events) {
+            await writer.write({
+                type: `data-${String(event.type)}`,
+                data: event,
+            });
         }
     }
     finally {

package/dist/steps/trace.steps.js

@@ -84,7 +84,7 @@ export async function writeThreadTraceEvents(params) {
     const strict = envTrace?.strict === true || process.env.EKAIROS_TRACES_STRICT === "1";
     // 1) Local trace persistence (InstantDB source of truth).
     try {
-        const { getThreadRuntime } = await import("@ekairos/thread/runtime");
+        const { getThreadRuntime } = await import("../runtime.js");
         const runtime = await getThreadRuntime(params.env);
         const db = runtime?.db;
         if (db) {

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

@@ -10,7 +10,7 @@ export declare function expandEventsWithInstantDocuments(params: {
      */
     maxChars?: number;
     /**
-     * Event type used for derived document text. Defaults to "output_text".
+     * Event type used for derived document text. Defaults to "output".
      */
     derivedEventType?: ThreadItem["type"];
 }): Promise<ThreadItem[]>;

package/dist/stores/instant.documents.js

@@ -72,7 +72,7 @@ async function ensureDocumentParsedForFile(db, params) {
 export async function expandEventsWithInstantDocuments(params) {
     const db = params.db;
     const maxChars = typeof params.maxChars === "number" ? params.maxChars : 120000;
-    const derivedEventType = params.derivedEventType ?? "output_text";
+    const derivedEventType = params.derivedEventType ?? "output";
     const out = [];
     for (const event of params.events) {
         const parts = event?.content?.parts;

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

@@ -44,12 +44,16 @@ export declare class InstantStore implements ThreadStore {
         iteration: number;
     }): Promise<{
         id: string;
-        eventId: string;
     }>;
     updateStep(stepId: string, patch: Partial<{
         status: "running" | "completed" | "failed";
-        toolCalls: any;
-        toolExecutionResults: any;
+        kind: "message" | "action_execute" | "action_result";
+        actionName: string;
+        actionInput: unknown;
+        actionOutput: unknown;
+        actionError: string;
+        actionRequests: any;
+        actionResults: any;
         continueLoop: boolean;
         errorText: string;
         updatedAt: Date;

package/dist/stores/instant.store.js

@@ -121,7 +121,7 @@ export class InstantStore {
             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"),
+            status: (typeof row?.status === "string" ? row.status : "idle"),
             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,
         };
@@ -253,7 +253,7 @@ export class InstantStore {
             this.db.tx.thread_threads[threadId].create({
                 createdAt: new Date(),
                 updatedAt: new Date(),
-                status: "open",
+                status: "idle",
                 key,
             }),
         ]);
@@ -424,7 +424,7 @@ export class InstantStore {
         ];
         if (context.threadId) {
             const thread = await this.getThread({ id: context.threadId });
-            const nextThreadStatus = (status === "closed" ? "closed" : status);
+            const nextThreadStatus = "idle";
             if (thread && thread.status !== nextThreadStatus) {
                 assertThreadTransition(thread.status, nextThreadStatus);
             }
@@ -484,10 +484,10 @@ export class InstantStore {
             });
             throw error;
         }
-        const persisted = await this.getItem(event.id);
-        if (!persisted)
-            throw new Error("InstantStore: failed to read event after save");
-        return persisted;
+        return {
+            ...event,
+            status: "stored",
+        };
     }
     async updateItem(eventId, event) {
         const current = await this.getItem(eventId);
@@ -495,10 +495,11 @@ export class InstantStore {
             assertItemTransition(current.status, event.status);
         }
         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;
+        return {
+            ...current,
+            ...event,
+            id: eventId,
+        };
     }
     async getItem(eventId) {
         const res = await this.db.query({
@@ -559,6 +560,13 @@ export class InstantStore {
             status: "executing",
         });
         const txs = [execCreate];
+        if (context.status !== "open") {
+            assertContextTransition(context.status, "open");
+            txs.push(this.db.tx.thread_contexts[context.id].update({
+                status: "open",
+                updatedAt: new Date(),
+            }));
+        }
         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 }));
@@ -603,17 +611,19 @@ export class InstantStore {
         if (currentExecutionStatus !== status) {
             assertExecutionTransition(currentExecutionStatus, status);
         }
-        if (context.status !== "open") {
-            assertContextTransition(context.status, "open");
+        if (context.status !== "closed") {
+            assertContextTransition(context.status, "closed");
         }
-        const nextThreadStatus = status === "failed" ? "failed" : "open";
+        const nextThreadStatus = "idle";
         if (thread.status !== nextThreadStatus) {
             assertThreadTransition(thread.status, nextThreadStatus);
         }
         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_contexts[context.id].update({
+            status: "closed",
+            updatedAt: new Date(),
+        }));
         txs.push(this.db.tx.thread_threads[thread.id].update({
             status: nextThreadStatus,
             updatedAt: new Date(),
@@ -622,14 +632,11 @@ export class InstantStore {
     }
     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 }));
@@ -643,14 +650,13 @@ export class InstantStore {
                     executionId: params.executionId,
                     iteration: params.iteration,
                     stepId,
-                    eventId,
                 },
                 txs,
                 error,
             });
             throw error;
         }
-        return { id: stepId, eventId };
+        return { id: stepId };
     }
     async updateStep(stepId, patch) {
         if (patch.status) {
@@ -697,76 +703,16 @@ export class InstantStore {
         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;
-            }
-        }
+        // `thread_steps` only links to execution.
+        // Item reconstruction uses embedded `item.content.parts` as source for model messages.
+        const eventsWithParts = events;
         // Default behavior for Instant-backed stories:
-        // - Expand file parts into derived `output_text` events (persisting parsed content into document_documents)
+        // - Expand file parts into derived `message` items (persisting parsed content into document_documents)
         // - Then convert expanded events to model messages
         const expanded = await expandEventsWithInstantDocuments({
             db: this.db,
             events: eventsWithParts,
-            derivedEventType: "output_text",
+            derivedEventType: "output",
         });
         return await convertItemsToModelMessages(expanded);
     }