@ekairos/thread 1.22.4-beta.feature-thread-unify.0 → 1.22.4-beta.feature-core-thread-registry-sync.0

package/dist/steps/store.steps.d.ts

@@ -1,12 +1,12 @@
 import type { UIMessageChunk } from "ai";
 import type { ThreadEnvironment } from "../thread.config.js";
-import type { ThreadItem, ContextIdentifier, StoredContext } from "../thread.store.js";
+import type { ThreadItem, ContextIdentifier, StoredContext, ContextStatus } from "../thread.store.js";
 export type ThreadReviewRequest = {
     toolCallId: string;
     toolName?: string;
 };
 /**
- * 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.
  */
@@ -18,13 +18,8 @@ export declare function initializeContext<C>(env: ThreadEnvironment, contextIden
     isNew: boolean;
 }>;
 export declare function updateContextContent<C>(env: ThreadEnvironment, contextIdentifier: ContextIdentifier, content: C): Promise<StoredContext<C>>;
-export declare function updateContextStatus(env: ThreadEnvironment, contextIdentifier: ContextIdentifier, status: "open" | "streaming" | "closed"): Promise<void>;
+export declare function updateContextStatus(env: ThreadEnvironment, contextIdentifier: ContextIdentifier, status: ContextStatus): Promise<void>;
 export declare function saveTriggerItem(env: ThreadEnvironment, contextIdentifier: ContextIdentifier, event: ThreadItem): Promise<ThreadItem>;
-export declare function emitContextIdChunk(params: {
-    env: ThreadEnvironment;
-    contextId: string;
-    writable?: WritableStream<UIMessageChunk>;
-}): Promise<void>;
 export declare function saveTriggerAndCreateExecution(params: {
     env: ThreadEnvironment;
     contextIdentifier: ContextIdentifier;
@@ -67,7 +62,6 @@ export declare function createThreadStep(params: {
     iteration: number;
 }): Promise<{
     stepId: string;
-    eventId: string;
 }>;
 export declare function updateThreadStep(params: {
     env: ThreadEnvironment;
@@ -77,8 +71,13 @@ export declare function updateThreadStep(params: {
     iteration?: number;
     patch: {
         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;
     };

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;