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

package/README.md

@@ -2,6 +2,12 @@
 
 Durable AI threads for production apps.
 
+## Specification
+
+Normative contract and compatibility profile:
+
+- `SPEC.md`
+
 `@ekairos/thread` gives you an execution model that is:
 
 - workflow-compatible,
@@ -33,7 +39,7 @@ This design supports long-running, resumable agent runs without losing state.
 - `Reactor`: pluggable reaction implementation (`AI SDK`, `Codex`, `Claude`, `Cursor`, ...).
 - `Thread Key`: stable public identifier (`thread.key`) for continuity.
 - `Context`: typed persistent state attached to a thread.
-- `Item`: normalized event (`input_text`, `output_text`, etc).
+- `Item`: normalized timeline record (`message`, `action_execute`, `action_result`, ...).
 - `Execution`: one run for a trigger/reaction pair.
 - `Step`: one loop iteration inside an execution.
 - `Part`: normalized content fragment persisted by step.

package/dist/index.d.ts

@@ -1,13 +1,13 @@
-export { thread, createThread, createAiSdkReactor, createScriptedReactor, type CreateAiSdkReactorOptions, type CreateScriptedReactorOptions, type ScriptedReactorStep, 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 { thread, createThread, createAiSdkReactor, createScriptedReactor, type CreateAiSdkReactorOptions, type CreateScriptedReactorOptions, type ScriptedReactorStep, type ThreadConfig, type ThreadInstance, type ThreadOptions, type ThreadStreamOptions, type ThreadReactor, type ThreadReactorParams, type ThreadReactionResult, type ThreadActionRequest, 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 { THREAD_STATUSES, THREAD_CONTEXT_STATUSES, THREAD_EXECUTION_STATUSES, THREAD_STEP_STATUSES, THREAD_ITEM_STATUSES, THREAD_ITEM_TYPES, THREAD_CHANNELS, THREAD_TRACE_EVENT_KINDS, THREAD_STREAM_CHUNK_TYPES, THREAD_CONTEXT_SUBSTATE_KEYS, THREAD_THREAD_TRANSITIONS, THREAD_CONTEXT_TRANSITIONS, THREAD_EXECUTION_TRANSITIONS, THREAD_STEP_TRANSITIONS, THREAD_ITEM_TRANSITIONS, canThreadTransition, canContextTransition, canExecutionTransition, canStepTransition, canItemTransition, assertThreadTransition, assertContextTransition, assertExecutionTransition, assertStepTransition, assertItemTransition, assertThreadPartKey, } from "./thread.contract.js";
-export type { Transition, ThreadThreadStatus, ThreadContextStatus, ThreadExecutionStatus, ThreadStepStatus, ThreadItemStatus, ThreadItemType, ThreadChannel, ThreadTraceEventKind, ThreadStreamChunkType, ThreadContextSubstateKey, ThreadTransition, ContextTransition, ExecutionTransition, StepTransition, ItemTransition, } from "./thread.contract.js";
+export { INPUT_ITEM_TYPE, INPUT_TEXT_ITEM_TYPE, OUTPUT_ITEM_TYPE, WEB_CHANNEL, AGENT_CHANNEL, EMAIL_CHANNEL, createUserItemFromUIMessages, createAssistantItemFromUIMessages, convertToUIMessage, convertItemToModelMessages, convertItemsToModelMessages, convertModelMessageToItem, type ResponseMessage, } from "./thread.events.js";
+export { THREAD_STATUSES, THREAD_CONTEXT_STATUSES, THREAD_EXECUTION_STATUSES, THREAD_STEP_STATUSES, THREAD_STEP_KINDS, THREAD_ITEM_STATUSES, THREAD_ITEM_TYPES, THREAD_CHANNELS, THREAD_TRACE_EVENT_KINDS, THREAD_STREAM_CHUNK_TYPES, THREAD_STREAM_LIFECYCLE_CHUNK_TYPES, THREAD_STREAM_TEXT_CHUNK_TYPES, THREAD_STREAM_REASONING_CHUNK_TYPES, THREAD_STREAM_ACTION_CHUNK_TYPES, THREAD_STREAM_SOURCE_CHUNK_TYPES, THREAD_STREAM_METADATA_CHUNK_TYPES, THREAD_STREAM_ERROR_CHUNK_TYPES, THREAD_THREAD_TRANSITIONS, THREAD_CONTEXT_TRANSITIONS, THREAD_EXECUTION_TRANSITIONS, THREAD_STEP_TRANSITIONS, THREAD_ITEM_TRANSITIONS, canThreadTransition, canContextTransition, canExecutionTransition, canStepTransition, canItemTransition, assertThreadTransition, assertContextTransition, assertExecutionTransition, assertStepTransition, assertItemTransition, isThreadStreamChunkType, assertThreadPartKey, } from "./thread.contract.js";
+export type { Transition, ThreadThreadStatus, ThreadContextStatus, ThreadExecutionStatus, ThreadStepStatus, ThreadStepKind, ThreadItemStatus, ThreadItemType, ThreadChannel, ThreadTraceEventKind, ThreadStreamChunkType, ThreadTransition, ContextTransition, ExecutionTransition, StepTransition, ItemTransition, } from "./thread.contract.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";
 export { parseThreadStreamEvent, assertThreadStreamTransitions, validateThreadStreamTimeline, } from "./thread.stream.js";
-export type { ThreadStreamEvent, ContextCreatedEvent, ContextResolvedEvent, ContextStatusChangedEvent, ThreadCreatedEvent, ThreadResolvedEvent, ThreadStatusChangedEvent, ExecutionCreatedEvent, ExecutionStatusChangedEvent, ItemCreatedEvent, ItemStatusChangedEvent, StepCreatedEvent, StepStatusChangedEvent, PartCreatedEvent, PartUpdatedEvent, ChunkEmittedEvent, ThreadFinishedEvent, } from "./thread.stream.js";
+export type { ThreadStreamEvent, ContextCreatedEvent, ContextResolvedEvent, ContextOpenedEvent, ContextClosedEvent, ContextContentUpdatedEvent, ThreadCreatedEvent, ThreadResolvedEvent, ThreadStreamingStartedEvent, ThreadIdleEvent, ExecutionCreatedEvent, ExecutionCompletedEvent, ExecutionFailedEvent, ItemCreatedEvent, ItemUpdatedEvent, ItemPendingEvent, ItemCompletedEvent, StepCreatedEvent, StepUpdatedEvent, StepCompletedEvent, StepFailedEvent, PartCreatedEvent, PartUpdatedEvent, ChunkEmittedEvent, } from "./thread.stream.js";

package/dist/index.js

@@ -4,8 +4,8 @@ thread, createThread, createAiSdkReactor, createScriptedReactor, Thread, } from
 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 { THREAD_STATUSES, THREAD_CONTEXT_STATUSES, THREAD_EXECUTION_STATUSES, THREAD_STEP_STATUSES, THREAD_ITEM_STATUSES, THREAD_ITEM_TYPES, THREAD_CHANNELS, THREAD_TRACE_EVENT_KINDS, THREAD_STREAM_CHUNK_TYPES, THREAD_CONTEXT_SUBSTATE_KEYS, THREAD_THREAD_TRANSITIONS, THREAD_CONTEXT_TRANSITIONS, THREAD_EXECUTION_TRANSITIONS, THREAD_STEP_TRANSITIONS, THREAD_ITEM_TRANSITIONS, canThreadTransition, canContextTransition, canExecutionTransition, canStepTransition, canItemTransition, assertThreadTransition, assertContextTransition, assertExecutionTransition, assertStepTransition, assertItemTransition, assertThreadPartKey, } from "./thread.contract.js";
+export { INPUT_ITEM_TYPE, INPUT_TEXT_ITEM_TYPE, OUTPUT_ITEM_TYPE, WEB_CHANNEL, AGENT_CHANNEL, EMAIL_CHANNEL, createUserItemFromUIMessages, createAssistantItemFromUIMessages, convertToUIMessage, convertItemToModelMessages, convertItemsToModelMessages, convertModelMessageToItem, } from "./thread.events.js";
+export { THREAD_STATUSES, THREAD_CONTEXT_STATUSES, THREAD_EXECUTION_STATUSES, THREAD_STEP_STATUSES, THREAD_STEP_KINDS, THREAD_ITEM_STATUSES, THREAD_ITEM_TYPES, THREAD_CHANNELS, THREAD_TRACE_EVENT_KINDS, THREAD_STREAM_CHUNK_TYPES, THREAD_STREAM_LIFECYCLE_CHUNK_TYPES, THREAD_STREAM_TEXT_CHUNK_TYPES, THREAD_STREAM_REASONING_CHUNK_TYPES, THREAD_STREAM_ACTION_CHUNK_TYPES, THREAD_STREAM_SOURCE_CHUNK_TYPES, THREAD_STREAM_METADATA_CHUNK_TYPES, THREAD_STREAM_ERROR_CHUNK_TYPES, THREAD_THREAD_TRANSITIONS, THREAD_CONTEXT_TRANSITIONS, THREAD_EXECUTION_TRANSITIONS, THREAD_STEP_TRANSITIONS, THREAD_ITEM_TRANSITIONS, canThreadTransition, canContextTransition, canExecutionTransition, canStepTransition, canItemTransition, assertThreadTransition, assertContextTransition, assertExecutionTransition, assertStepTransition, assertItemTransition, isThreadStreamChunkType, assertThreadPartKey, } from "./thread.contract.js";
 export { DEFAULT_CODEX_TOOL_NAME, DEFAULT_CODEX_MODEL, codexToolInputSchema, buildDefaultCodexNarrative, didCodexToolExecute, createCodexThreadBuilder, } from "./codex.js";
 export { useThread, } from "./react.js";
 export { parseThreadStreamEvent, assertThreadStreamTransitions, validateThreadStreamTimeline, } from "./thread.stream.js";

package/dist/react.d.ts

@@ -1,4 +1,4 @@
-import type { ThreadContextStatus, ThreadContextSubstateKey, ThreadThreadStatus } from "./thread.contract.js";
+import type { ThreadContextStatus, ThreadThreadStatus } from "./thread.contract.js";
 export type ThreadSnapshot<Context = unknown, Item = Record<string, unknown>> = {
     thread: {
         id: string;
@@ -17,25 +17,10 @@ export type ThreadSnapshot<Context = unknown, Item = Record<string, unknown>> =
     items: Item[];
 };
 export type ThreadStreamChunk = {
-    type: "data-context-id";
+    type: `data-context.${string}`;
     data?: {
         contextId?: string;
     };
-    id?: string;
-} | {
-    type: "data-context-substate";
-    data?: {
-        key?: ThreadContextSubstateKey | null;
-    };
-    transient?: boolean;
-} | {
-    type: "tool-output-available";
-    toolCallId?: string;
-    output?: unknown;
-} | {
-    type: "tool-output-error";
-    toolCallId?: string;
-    errorText?: string;
 } | {
     type: string;
     [key: string]: unknown;
@@ -57,7 +42,6 @@ export declare function useThread<Context = unknown, Item = Record<string, unkno
     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

@@ -21,7 +21,6 @@ export function useThread(options) {
     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)
@@ -54,26 +53,15 @@ export function useThread(options) {
     const applyChunk = useCallback((chunk) => {
         if (!chunk || typeof chunk !== "object")
             return;
-        if (chunk.type === "data-context-id") {
+        if (typeof chunk.type === "string" && chunk.type.startsWith("data-context.")) {
             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;
+                : 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(() => {
@@ -94,7 +82,6 @@ export function useThread(options) {
         refresh,
         setData,
         contextId,
-        substateKey,
         applyChunk,
         url,
     };

package/dist/reactors/ai-sdk.chunk-map.d.ts

@@ -0,0 +1,12 @@
+import type { UIMessageChunk } from "ai";
+import type { ChunkEmittedEvent } from "../thread.stream.js";
+export type MapAiSdkChunkToThreadEventParams = {
+    chunk: UIMessageChunk | Record<string, unknown>;
+    contextId: string;
+    executionId?: string;
+    stepId?: string;
+    itemId?: string;
+    provider?: string;
+    sequence: number;
+};
+export declare function mapAiSdkChunkToThreadEvent(params: MapAiSdkChunkToThreadEventParams): ChunkEmittedEvent;

package/dist/reactors/ai-sdk.chunk-map.js

@@ -0,0 +1,143 @@
+const REDACT_KEY = /token|authorization|cookie|secret|api[_-]?key|password/i;
+function asRecord(value) {
+    if (!value || typeof value !== "object")
+        return {};
+    return value;
+}
+function readString(record, key) {
+    const value = record[key];
+    return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+function toJsonSafe(value) {
+    if (typeof value === "undefined")
+        return undefined;
+    try {
+        return JSON.parse(JSON.stringify(value));
+    }
+    catch {
+        return undefined;
+    }
+}
+function sanitizeRaw(value) {
+    const seen = new WeakSet();
+    try {
+        return JSON.parse(JSON.stringify(value, (key, currentValue) => {
+            if (REDACT_KEY.test(key))
+                return "[redacted]";
+            if (typeof currentValue === "string" && currentValue.length > 20000) {
+                return "[truncated-string]";
+            }
+            if (currentValue && typeof currentValue === "object") {
+                if (seen.has(currentValue))
+                    return "[circular]";
+                seen.add(currentValue);
+            }
+            return currentValue;
+        }));
+    }
+    catch {
+        return undefined;
+    }
+}
+function mapAiSdkChunkType(providerChunkType) {
+    switch (providerChunkType) {
+        case "start":
+        case "stream-start":
+            return "chunk.start";
+        case "start-step":
+            return "chunk.start_step";
+        case "finish-step":
+            return "chunk.finish_step";
+        case "finish":
+            return "chunk.finish";
+        case "text-start":
+            return "chunk.text_start";
+        case "text-delta":
+            return "chunk.text_delta";
+        case "text-end":
+            return "chunk.text_end";
+        case "reasoning-start":
+            return "chunk.reasoning_start";
+        case "reasoning-delta":
+            return "chunk.reasoning_delta";
+        case "reasoning-end":
+            return "chunk.reasoning_end";
+        case "tool-input-start":
+        case "tool-call-start":
+            return "chunk.action_input_start";
+        case "tool-input-delta":
+        case "tool-call-delta":
+            return "chunk.action_input_delta";
+        case "tool-input-available":
+        case "tool-input-end":
+        case "tool-call":
+        case "tool-call-end":
+            return "chunk.action_input_available";
+        case "tool-output-available":
+            return "chunk.action_output_available";
+        case "tool-output-error":
+            return "chunk.action_output_error";
+        case "source-url":
+            return "chunk.source_url";
+        case "source-document":
+            return "chunk.source_document";
+        case "file":
+            return "chunk.file";
+        case "message-metadata":
+            return "chunk.message_metadata";
+        case "response-metadata":
+            return "chunk.response_metadata";
+        case "error":
+            return "chunk.error";
+        default:
+            return "chunk.unknown";
+    }
+}
+function buildNormalizedData(chunk) {
+    const normalized = {};
+    const fields = [
+        "id",
+        "text",
+        "delta",
+        "state",
+        "toolName",
+        "toolCallId",
+        "finishReason",
+        "url",
+        "title",
+        "name",
+        "mimeType",
+    ];
+    for (const field of fields) {
+        const value = chunk[field];
+        if (typeof value !== "undefined") {
+            normalized[field] = value;
+        }
+    }
+    if (Object.keys(normalized).length === 0) {
+        return {};
+    }
+    return toJsonSafe(normalized) ?? {};
+}
+export function mapAiSdkChunkToThreadEvent(params) {
+    const chunk = asRecord(params.chunk);
+    const providerChunkType = readString(chunk, "type") ?? "unknown";
+    const chunkType = mapAiSdkChunkType(providerChunkType);
+    const actionRef = readString(chunk, "toolCallId") ??
+        readString(chunk, "id");
+    return {
+        type: "chunk.emitted",
+        at: new Date().toISOString(),
+        chunkType,
+        contextId: params.contextId,
+        executionId: params.executionId,
+        stepId: params.stepId,
+        itemId: params.itemId,
+        actionRef: chunkType.startsWith("chunk.action_") ? actionRef : undefined,
+        provider: params.provider,
+        providerChunkType,
+        sequence: params.sequence,
+        data: buildNormalizedData(chunk),
+        raw: sanitizeRaw(chunk),
+    };
+}

package/dist/reactors/ai-sdk.reactor.js

@@ -57,7 +57,11 @@ export function createAiSdkReactor(options) {
         });
         return {
             assistantEvent: result.assistantEvent,
-            toolCalls: result.toolCalls,
+            actionRequests: result.toolCalls.map((entry) => ({
+                actionRef: String(entry.toolCallId),
+                actionName: String(entry.toolName),
+                input: entry.args,
+            })),
             messagesForModel: result.messagesForModel,
             llm: result.llm,
         };

package/dist/reactors/scripted.reactor.d.ts

@@ -1,10 +1,10 @@
 import type { ModelMessage } from "ai";
 import type { ThreadEnvironment } from "../thread.config.js";
 import type { ThreadItem } from "../thread.store.js";
-import type { ThreadReactionLLM, ThreadReactionToolCall, ThreadReactor, ThreadReactorParams } from "./types.js";
+import type { ThreadReactionLLM, ThreadActionRequest, ThreadReactor, ThreadReactorParams } from "./types.js";
 type ScriptedReactionPayload = {
     assistantEvent?: Partial<ThreadItem>;
-    toolCalls?: ThreadReactionToolCall[];
+    actionRequests?: ThreadActionRequest[];
     messagesForModel?: ModelMessage[];
     llm?: ThreadReactionLLM;
 };

package/dist/reactors/scripted.reactor.js

@@ -1,7 +1,8 @@
+import { OUTPUT_ITEM_TYPE } from "../thread.events.js";
 function normalizeScriptedAssistantEvent(params, assistantEvent) {
     const fallback = {
         id: params.eventId,
-        type: "output_text",
+        type: OUTPUT_ITEM_TYPE,
         channel: params.triggerEvent.channel,
         createdAt: new Date().toISOString(),
         content: { parts: [] },
@@ -46,7 +47,7 @@ export function createScriptedReactor(options) {
             : scriptedStep;
         return {
             assistantEvent: normalizeScriptedAssistantEvent(params, payload.assistantEvent),
-            toolCalls: Array.isArray(payload.toolCalls) ? payload.toolCalls : [],
+            actionRequests: Array.isArray(payload.actionRequests) ? payload.actionRequests : [],
             messagesForModel: Array.isArray(payload.messagesForModel)
                 ? payload.messagesForModel
                 : [],

package/dist/reactors/types.d.ts

@@ -3,10 +3,10 @@ import type { ThreadEnvironment } from "../thread.config.js";
 import type { ThreadModelInit } from "../thread.engine.js";
 import type { ContextIdentifier, StoredContext, ThreadItem } from "../thread.store.js";
 import type { SerializableToolForModel } from "../tools-to-model-tools.js";
-export type ThreadReactionToolCall = {
-    toolCallId: string;
-    toolName: string;
-    args: unknown;
+export type ThreadActionRequest = {
+    actionRef: string;
+    actionName: string;
+    input: unknown;
 };
 export type ThreadReactionLLM = {
     provider?: string;
@@ -22,7 +22,7 @@ export type ThreadReactionLLM = {
 };
 export type ThreadReactionResult = {
     assistantEvent: ThreadItem;
-    toolCalls: ThreadReactionToolCall[];
+    actionRequests: ThreadActionRequest[];
     messagesForModel: ModelMessage[];
     llm?: ThreadReactionLLM;
 };

package/dist/schema.js

@@ -8,14 +8,14 @@ export const threadDomain = domain("thread")
             updatedAt: i.date().optional(),
             key: i.string().optional().indexed().unique(),
             name: i.string().optional(),
-            status: i.string().optional().indexed(), // open | streaming | closed | failed
+            status: i.string().optional().indexed(), // idle | streaming
         }),
         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
+            status: i.string().optional().indexed(), // open | closed
             content: i.any().optional(),
         }),
         thread_items: i.entity({
@@ -36,13 +36,14 @@ export const threadDomain = domain("thread")
             updatedAt: i.date().optional(),
             status: i.string().optional().indexed(), // running | completed | failed
             iteration: i.number().indexed(),
-            // Deterministic ids generated in step runtime; stored for convenience/debugging
-            executionId: i.string().indexed(),
-            triggerEventId: i.string().indexed().optional(),
-            reactionEventId: i.string().indexed().optional(),
-            eventId: i.string().indexed(),
-            toolCalls: i.any().optional(),
-            toolExecutionResults: i.any().optional(),
+            // Deterministic ids generated in step runtime; linked to execution/item entities.
+            kind: i.string().optional().indexed(), // message | action_execute | action_result
+            actionName: i.string().optional().indexed(),
+            actionInput: i.any().optional(),
+            actionOutput: i.any().optional(),
+            actionError: i.string().optional(),
+            actionRequests: i.any().optional(),
+            actionResults: i.any().optional(),
             continueLoop: i.boolean().optional(),
             errorText: i.string().optional(),
         }),

package/dist/steps/do-thread-stream-step.d.ts

@@ -7,7 +7,7 @@ import type { ThreadModelInit } from "../thread.engine.js";
  *
  * - Performs the provider/network call in a step (Node/runtime allowed).
  * - Pipes AI SDK UI message chunks into the workflow-owned writable stream.
- * - Returns the assistant event + extracted tool calls for the workflow loop.
+ * - Returns the assistant event + extracted action requests for the workflow loop.
  */
 export declare function doThreadStreamStep(params: {
     model: ThreadModelInit;
@@ -26,5 +26,9 @@ export declare function doThreadStreamStep(params: {
     sendStart?: boolean;
 }): Promise<{
     assistantEvent: ThreadItem;
-    toolCalls: import("../thread.toolcalls.js").ToolCall[];
+    actionRequests: {
+        actionRef: string;
+        actionName: string;
+        input: any;
+    }[];
 }>;

package/dist/steps/do-thread-stream-step.js

@@ -1,10 +1,10 @@
-import { OUTPUT_TEXT_ITEM_TYPE } from "../thread.events.js";
+import { OUTPUT_ITEM_TYPE } from "../thread.events.js";
 /**
  * Runs a single LLM streaming step as a Workflow step.
  *
  * - Performs the provider/network call in a step (Node/runtime allowed).
  * - Pipes AI SDK UI message chunks into the workflow-owned writable stream.
- * - Returns the assistant event + extracted tool calls for the workflow loop.
+ * - Returns the assistant event + extracted action requests for the workflow loop.
  */
 export async function doThreadStreamStep(params) {
     "use step";
@@ -62,7 +62,7 @@ export async function doThreadStreamStep(params) {
             const lastMessage = messages[messages.length - 1];
             const event = {
                 id: params.eventId,
-                type: OUTPUT_TEXT_ITEM_TYPE,
+                type: OUTPUT_ITEM_TYPE,
                 channel: "web",
                 createdAt: new Date().toISOString(),
                 content: { parts: lastMessage?.parts ?? [] },
@@ -84,9 +84,13 @@ export async function doThreadStreamStep(params) {
     }));
     await uiStream.pipeTo(writable, { preventClose: true });
     const assistantEvent = await finishPromise;
-    const toolCalls = extractToolCallsFromParts(assistantEvent?.content?.parts);
+    const actionRequests = extractToolCallsFromParts(assistantEvent?.content?.parts).map((entry) => ({
+        actionRef: String(entry.toolCallId),
+        actionName: String(entry.toolName),
+        input: entry.args,
+    }));
     return {
         assistantEvent,
-        toolCalls,
+        actionRequests,
     };
 }

package/dist/steps/reaction.steps.js

@@ -1,4 +1,5 @@
-import { OUTPUT_TEXT_ITEM_TYPE } from "../thread.events.js";
+import { OUTPUT_ITEM_TYPE } from "../thread.events.js";
+import { mapAiSdkChunkToThreadEvent } from "../reactors/ai-sdk.chunk-map.js";
 import { writeThreadTraceEvents } from "./trace.steps.js";
 async function readWorkflowMetadata() {
     try {
@@ -10,19 +11,17 @@ async function readWorkflowMetadata() {
     }
 }
 async function resolveWorkflowRunId(env, executionId) {
-    const meta = await readWorkflowMetadata();
-    let runId = meta && meta.workflowRunId !== undefined && meta.workflowRunId !== null
-        ? String(meta.workflowRunId)
+    const envRunId = env?.workflowRunId;
+    let runId = typeof envRunId === "string" && envRunId.trim()
+        ? envRunId.trim()
         : "";
-    if (!runId) {
-        const envRunId = 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 && executionId) {
         try {
-            const { getThreadRuntime } = await import("@ekairos/thread/runtime");
+            const { getThreadRuntime } = await import("../runtime.js");
             const runtime = await getThreadRuntime(env);
             const db = runtime?.db;
             if (db) {
@@ -82,7 +81,7 @@ function safeErrorJson(error) {
  */
 export async function executeReaction(params) {
     "use step";
-    const { getThreadRuntime } = await import("@ekairos/thread/runtime");
+    const { getThreadRuntime } = await import("../runtime.js");
     const { store } = await getThreadRuntime(params.env);
     let events;
     try {
@@ -132,10 +131,13 @@ export async function executeReaction(params) {
     result.consumeStream();
     let resolveFinish;
     let rejectFinish;
+    let chunkSequence = 0;
     const finishPromise = new Promise((resolve, reject) => {
         resolveFinish = resolve;
         rejectFinish = reject;
     });
+    const modelId = typeof params.model === "string" ? params.model : "";
+    const mappedProvider = modelId.includes("/") ? modelId.split("/")[0] : undefined;
     const uiStream = result
         .toUIMessageStream({
         sendStart: Boolean(params.sendStart),
@@ -147,7 +149,7 @@ export async function executeReaction(params) {
             const lastMessage = messages[messages.length - 1];
             const event = {
                 id: params.eventId,
-                type: OUTPUT_TEXT_ITEM_TYPE,
+                type: OUTPUT_ITEM_TYPE,
                 channel: "web",
                 createdAt: new Date().toISOString(),
                 content: { parts: lastMessage?.parts ?? [] },
@@ -162,6 +164,24 @@ export async function executeReaction(params) {
         // Filter out per-step finish boundary. Workflow will emit a single finish.
         .pipeThrough(new TransformStream({
         transform(chunk, controller) {
+            const contextId = typeof params.contextId === "string" && params.contextId.length > 0
+                ? params.contextId
+                : undefined;
+            if (contextId) {
+                const mapped = mapAiSdkChunkToThreadEvent({
+                    chunk,
+                    contextId,
+                    executionId: params.executionId,
+                    stepId: params.stepId,
+                    itemId: params.eventId,
+                    provider: mappedProvider,
+                    sequence: ++chunkSequence,
+                });
+                controller.enqueue({
+                    type: "data-chunk.emitted",
+                    data: mapped,
+                });
+            }
             if (chunk.type === "finish")
                 return;
             controller.enqueue(chunk);
@@ -209,7 +229,6 @@ export async function executeReaction(params) {
     const usageJson = toPlainJson(usage);
     const providerMetadataJson = toPlainJson(providerMetadata);
     // Derive provider/model from gateway id when available.
-    const modelId = typeof params.model === "string" ? params.model : "";
     const provider = modelId.includes("/") ? modelId.split("/")[0] : providerMetadata?.provider;
     const model = modelId.includes("/") ? modelId.split("/").slice(1).join("/") : providerMetadata?.model;
     // Token accounting: attempt to read cached prompt tokens from OpenAI-like usage shapes.

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;
     };