@ekairos/events 1.22.79-beta.development.0 → 1.22.80-beta.development.0

package/dist/context.engine.js

@@ -3,8 +3,8 @@ import { OUTPUT_ITEM_TYPE, WEB_CHANNEL } from "./context.events.js";
 import { applyToolExecutionResultToParts } from "./context.toolcalls.js";
 import { isContextPartEnvelope, normalizePartsForPersistence, } from "./context.parts.js";
 import { createAiSdkReactor, } from "./context.reactor.js";
-import { abortPersistedContextStepStream, closeContextStream, createPersistedContextStepStreamForRuntime, finalizePersistedContextStepStreamForRuntime, writeActionResultPartChunks, } from "./steps/stream.steps.js";
-import { completeExecution, createContextStep, finalizeReactionStep, getContextItems, initializeContext, openReactionStep, saveTriggerAndCreateExecution, saveContextPartsAndUpdateReaction, saveContextPartsStep, updateContextContent, updateContextReactor, updateContextStatus, updateItem, updateContextStep, updateExecutionWorkflowRun, } from "./steps/store.steps.js";
+import { abortPersistedContextStepStream, closeContextStream, createPersistedContextStepStreamForRuntime, finalizePersistedContextStepStreamForRuntime, writeActionResultPartChunksToSession, } from "./steps/stream.steps.js";
+import { completeExecution, completeExecutionStep, createContextStep, getContextItems, initializeContext, openExecutionStep, openExecution, saveExecutionStepOutput, updateContextContent, updateContextReactor, updateContextStatus, updateItem, updateContextStep, updateExecutionWorkflowRun, } from "./steps/store.steps.js";
 import { readContextDurableWorkflowReturnValue, readContextDurableWorkflowStatus, resumeContextReturnValueHook, startContextDurableWorkflow, } from "./steps/durable.steps.js";
 import { getClientResumeHookUrl, toolApprovalHookToken, toolApprovalWebhookToken, } from "./context.hooks.js";
 import { getContextDurableWorkflow } from "./context.durable.js";
@@ -195,7 +195,7 @@ async function createRuntimeOps(runtimeHandle, benchmark) {
                 updatedAt: new Date(),
             }),
         ]),
-        saveTriggerAndCreateExecution: async ({ contextIdentifier, triggerEvent }) => {
+        openExecution: async ({ contextIdentifier, triggerEvent }) => {
             const contextId = requireContextId(contextIdentifier);
             const triggerId = String(triggerEvent.id);
             const reactionId = makeRuntimeId();
@@ -253,7 +253,7 @@ async function createRuntimeOps(runtimeHandle, benchmark) {
                 },
             };
         },
-        openReactionStep: async ({ contextIdentifier, content, executionId, iteration }) => {
+        openExecutionStep: async ({ contextIdentifier, content, executionId, iteration }) => {
             const stepId = makeRuntimeId();
             const now = new Date();
             await instrumentedDb.transact([
@@ -301,7 +301,17 @@ async function createRuntimeOps(runtimeHandle, benchmark) {
                 instrumentedDb.tx.event_steps[params.stepId].update(update),
             ]);
         },
-        finalizeReactionStep: async (params) => {
+        completeExecutionStep: async (params) => {
+            const actionResultChunkEvents = await writeActionResultPartChunksToSession({
+                session: params.session,
+                contextId: String(params.contextId ?? ""),
+                executionId: String(params.executionId ?? ""),
+                itemId: String(params.reactionEventId ?? ""),
+                actionResults: params.actionResults ?? [],
+            });
+            if (params.parts) {
+                await store.saveStepParts({ stepId: params.stepId, parts: params.parts });
+            }
             if (params.session) {
                 await finalizePersistedContextStepStreamForRuntime({
                     runtime: { db: instrumentedDb },
@@ -310,15 +320,14 @@ async function createRuntimeOps(runtimeHandle, benchmark) {
                 });
             }
             const update = { updatedAt: new Date() };
-            if (params.patch.status !== undefined)
-                update.status = params.patch.status;
-            if (params.patch.errorText !== undefined)
-                update.errorText = params.patch.errorText;
+            update.status = params.stepStatus ?? "completed";
+            if (params.errorText !== undefined)
+                update.errorText = params.errorText;
             await instrumentedDb.transact([
                 instrumentedDb.tx.event_steps[params.stepId].update(update),
             ]);
             if (!params.reactionEventId || !params.reactionEvent) {
-                return {};
+                return { actionResultChunkEvents };
             }
             await instrumentedDb.transact([
                 instrumentedDb.tx.event_items[params.reactionEventId].update(params.reactionEvent),
@@ -328,12 +337,10 @@ async function createRuntimeOps(runtimeHandle, benchmark) {
                     ...params.reactionEvent,
                     id: params.reactionEventId,
                 },
+                actionResultChunkEvents,
             };
         },
-        saveContextPartsStep: async (params) => {
-            await store.saveStepParts({ stepId: params.stepId, parts: params.parts });
-        },
-        saveContextPartsAndUpdateReaction: async (params) => {
+        saveExecutionStepOutput: async (params) => {
             await store.saveStepParts({ stepId: params.stepId, parts: params.parts });
             await instrumentedDb.transact([
                 instrumentedDb.tx.event_items[params.reactionEventId].update(params.reactionEvent),
@@ -353,9 +360,9 @@ async function createRuntimeOps(runtimeHandle, benchmark) {
                 id: itemId,
             };
         },
-        completeExecution: async (contextIdentifier, executionId, status) => {
+        completeExecution: async (contextIdentifier, executionId, status, opts) => {
             const contextId = requireContextId(contextIdentifier);
-            await instrumentedDb.transact([
+            const txs = [
                 instrumentedDb.tx.event_executions[executionId].update({
                     status,
                     updatedAt: new Date(),
@@ -364,7 +371,19 @@ async function createRuntimeOps(runtimeHandle, benchmark) {
                     status: "closed",
                     updatedAt: new Date(),
                 }),
-            ]);
+            ];
+            if (opts?.reactionEventId && opts.reactionEvent) {
+                txs.push(instrumentedDb.tx.event_items[opts.reactionEventId].update(opts.reactionEvent));
+            }
+            await instrumentedDb.transact(txs);
+            return opts?.reactionEventId && opts.reactionEvent
+                ? {
+                    reactionEvent: {
+                        ...opts.reactionEvent,
+                        id: opts.reactionEventId,
+                    },
+                }
+                : {};
         },
     };
 }
@@ -375,16 +394,15 @@ async function createWorkflowOps(runtime) {
         updateContextContent: async (contextIdentifier, content) => await updateContextContent({ runtime, contextIdentifier, content }),
         updateContextReactor: async (contextIdentifier, reactor) => await updateContextReactor({ runtime, contextIdentifier, reactor }),
         updateContextStatus: async (contextIdentifier, status) => await updateContextStatus({ runtime, contextIdentifier, status }),
-        saveTriggerAndCreateExecution: async ({ contextIdentifier, triggerEvent }) => await saveTriggerAndCreateExecution({ runtime, contextIdentifier, triggerEvent }),
-        openReactionStep: async (params) => await openReactionStep({ runtime, ...params }),
+        openExecution: async ({ contextIdentifier, triggerEvent }) => await openExecution({ runtime, contextIdentifier, triggerEvent }),
+        openExecutionStep: async (params) => await openExecutionStep({ runtime, ...params }),
         createContextStep: async ({ executionId, iteration }) => await createContextStep({ runtime, executionId, iteration }),
         updateContextStep: async (params) => await updateContextStep({ runtime, ...params }),
-        finalizeReactionStep: async (params) => await finalizeReactionStep({ runtime, ...params }),
-        saveContextPartsStep: async (params) => await saveContextPartsStep({ runtime, ...params }),
-        saveContextPartsAndUpdateReaction: async (params) => await saveContextPartsAndUpdateReaction({ runtime, ...params }),
+        completeExecutionStep: async (params) => await completeExecutionStep({ runtime, ...params }),
+        saveExecutionStepOutput: async (params) => await saveExecutionStepOutput({ runtime, ...params }),
         getItems: async (contextIdentifier) => await getContextItems({ runtime, contextIdentifier }),
         updateItem: async (itemId, item, opts) => await updateItem({ runtime, eventId: itemId, event: item, opts }),
-        completeExecution: async (contextIdentifier, executionId, status) => await completeExecution({ runtime, contextIdentifier, executionId, status }),
+        completeExecution: async (contextIdentifier, executionId, status, opts) => await completeExecution({ runtime, contextIdentifier, executionId, status, ...opts }),
     };
 }
 async function getContextEngineOps(runtime, benchmark) {
@@ -467,7 +485,7 @@ export class ContextEngine {
             await measureBenchmark(params.__benchmark, "react.reopenClosedContextMs", async () => await ops.updateContextStatus(contextSelector, "open_idle"));
             currentContext = { ...currentContext, status: "open_idle" };
         }
-        const shell = await measureBenchmark(params.__benchmark, "react.bootstrapShellMs", async () => await ops.saveTriggerAndCreateExecution({
+        const shell = await measureBenchmark(params.__benchmark, "react.openExecutionMs", async () => await ops.openExecution({
             contextIdentifier: contextSelector,
             triggerEvent,
         }));
@@ -690,7 +708,7 @@ export class ContextEngine {
                 const stagePrefix = `react.iteration.${iter}`;
                 // Hook: Context DSL `context()` (implemented by subclasses via `initialize()`)
                 const nextContent = await measureBenchmark(params.__benchmark, `${stagePrefix}.contextMs`, async () => await story.initialize(updatedContext, env, runtimeHandle));
-                const openedStep = await measureBenchmark(params.__benchmark, `${stagePrefix}.openReactionStepMs`, async () => await ops.openReactionStep({
+                const openedStep = await measureBenchmark(params.__benchmark, `${stagePrefix}.openExecutionStepMs`, async () => await ops.openExecutionStep({
                     contextIdentifier: activeContextSelector,
                     content: nextContent,
                     executionId,
@@ -748,7 +766,7 @@ export class ContextEngine {
                     if (nextSignature === persistedReactionPartsSignature)
                         return;
                     persistedReactionPartsSignature = nextSignature;
-                    const saved = await ops.saveContextPartsAndUpdateReaction({
+                    const saved = await ops.saveExecutionStepOutput({
                         stepId: openedStep.stepId,
                         parts: normalizedParts,
                         reactionEventId: reactionEvent.id,
@@ -829,7 +847,7 @@ export class ContextEngine {
                     },
                     status: "pending",
                 };
-                const appendedReactorOutput = await measureBenchmark(params.__benchmark, `${stagePrefix}.appendReactorOutputMs`, async () => await ops.saveContextPartsAndUpdateReaction({
+                const appendedReactorOutput = await measureBenchmark(params.__benchmark, `${stagePrefix}.saveExecutionStepOutputMs`, async () => await ops.saveExecutionStepOutput({
                     stepId: openedStep.stepId,
                     parts: stepParts,
                     reactionEventId: reactionEvent.id,
@@ -886,12 +904,10 @@ export class ContextEngine {
                             ...reactionEvent,
                             status: "completed",
                         };
-                        const finalized = await measureBenchmark(params.__benchmark, `${stagePrefix}.finalizeReactionStepMs`, async () => await ops.finalizeReactionStep({
+                        const finalized = await measureBenchmark(params.__benchmark, `${stagePrefix}.completeExecutionStepMs`, async () => await ops.completeExecutionStep({
                             session: currentStepStream,
                             stepId: openedStep.stepId,
-                            patch: {
-                                status: "completed",
-                            },
+                            stepStatus: "completed",
                             reactionEventId,
                             reactionEvent: completedReactionEvent,
                             executionId,
@@ -899,6 +915,7 @@ export class ContextEngine {
                             iteration: iter,
                         }));
                         currentStepStream = null;
+                        currentStepId = null;
                         reactionEvent = finalized.reactionEvent ?? completedReactionEvent;
                         await emitContextEvents({
                             silent,
@@ -1037,19 +1054,7 @@ export class ContextEngine {
                         };
                     }
                 })));
-                const actionResultChunkEvents = await measureBenchmark(params.__benchmark, `${stagePrefix}.writeActionResultPartChunksMs`, async () => await writeActionResultPartChunks({
-                    session: currentStepStream,
-                    contextId: String(currentContext.id),
-                    executionId,
-                    itemId: reactionEventId,
-                    actionResults: actionResults,
-                }));
-                await emitContextEvents({
-                    silent,
-                    writable,
-                    events: actionResultChunkEvents,
-                });
-                // Merge action results into persisted parts (so next LLM call can see them)
+                // Merge action results into step parts so the next reaction can see them.
                 let finalizedStepParts = Array.isArray(stepParts) ? [...stepParts] : [];
                 for (const r of actionResults) {
                     finalizedStepParts = applyToolExecutionResultToParts(finalizedStepParts, {
@@ -1061,14 +1066,7 @@ export class ContextEngine {
                         message: r.errorText,
                     });
                 }
-                await measureBenchmark(params.__benchmark, `${stagePrefix}.saveFinalStepPartsMs`, async () => await ops.saveContextPartsStep({
-                    stepId: openedStep.stepId,
-                    parts: finalizedStepParts,
-                    executionId,
-                    contextId: String(currentContext.id),
-                    iteration: iter,
-                }));
-                reactionEvent = {
+                const pendingReactionEvent = {
                     ...reactionEvent,
                     content: {
                         ...reactionEvent.content,
@@ -1078,48 +1076,26 @@ export class ContextEngine {
                     },
                     status: "pending",
                 };
-                // Callback for observability/integration
-                for (const r of actionResults) {
-                    await story.opts.onActionExecuted?.({
-                        actionRequest: r.actionRequest,
-                        success: r.success,
-                        output: r.output,
-                        errorText: r.errorText,
-                        eventId: reactionEventId,
-                        executionId,
-                    });
-                }
-                // Stop/continue boundary: allow the Context to decide if the loop should continue.
-                // IMPORTANT: we call this after tool results have been merged into the persisted `reactionEvent`,
-                // so stories can inspect `reactionEvent.content.parts` deterministically.
-                const continueLoop = await measureBenchmark(params.__benchmark, `${stagePrefix}.shouldContinueMs`, async () => await story.shouldContinue({
-                    env,
-                    runtime: runtimeHandle,
-                    context: updatedContext,
-                    reactionEvent,
-                    assistantEvent: assistantEventEffective,
-                    actionRequests,
-                    actionResults: actionResults,
-                }));
-                const finalizedReactionStatus = continueLoop === false ? "completed" : "pending";
-                const finalizedReactionEvent = {
-                    ...reactionEvent,
-                    status: finalizedReactionStatus,
-                };
-                const finalizedStep = await measureBenchmark(params.__benchmark, `${stagePrefix}.finalizeReactionStepMs`, async () => await ops.finalizeReactionStep({
+                const completedStep = await measureBenchmark(params.__benchmark, `${stagePrefix}.completeExecutionStepMs`, async () => await ops.completeExecutionStep({
                     session: currentStepStream,
                     stepId: openedStep.stepId,
-                    patch: {
-                        status: "completed",
-                    },
+                    parts: finalizedStepParts,
+                    actionResults: actionResults,
+                    stepStatus: "completed",
                     reactionEventId,
-                    reactionEvent: finalizedReactionEvent,
+                    reactionEvent: pendingReactionEvent,
                     executionId,
                     contextId: String(currentContext.id),
                     iteration: iter,
                 }));
                 currentStepStream = null;
-                reactionEvent = finalizedStep.reactionEvent ?? finalizedReactionEvent;
+                currentStepId = null;
+                reactionEvent = completedStep.reactionEvent ?? pendingReactionEvent;
+                await emitContextEvents({
+                    silent,
+                    writable,
+                    events: completedStep.actionResultChunkEvents,
+                });
                 await emitContextEvents({
                     silent,
                     writable,
@@ -1142,6 +1118,28 @@ export class ContextEngine {
                         },
                     ],
                 });
+                // Callback for observability/integration
+                for (const r of actionResults) {
+                    await story.opts.onActionExecuted?.({
+                        actionRequest: r.actionRequest,
+                        success: r.success,
+                        output: r.output,
+                        errorText: r.errorText,
+                        eventId: reactionEventId,
+                        executionId,
+                    });
+                }
+                // Stop/continue boundary: allow the Context to decide if the loop should continue.
+                // Tool results are already persisted in the completed reaction step here.
+                const continueLoop = await measureBenchmark(params.__benchmark, `${stagePrefix}.shouldContinueMs`, async () => await story.shouldContinue({
+                    env,
+                    runtime: runtimeHandle,
+                    context: updatedContext,
+                    reactionEvent,
+                    assistantEvent: assistantEventEffective,
+                    actionRequests,
+                    actionResults: actionResults,
+                }));
                 if (continueLoop !== false) {
                     await emitContextEvents({
                         silent,
@@ -1159,6 +1157,10 @@ export class ContextEngine {
                     });
                 }
                 if (continueLoop === false) {
+                    reactionEvent = {
+                        ...reactionEvent,
+                        status: "completed",
+                    };
                     await emitContextEvents({
                         silent,
                         writable,
@@ -1173,7 +1175,11 @@ export class ContextEngine {
                             },
                         ],
                     });
-                    await measureBenchmark(params.__benchmark, `${stagePrefix}.completeExecutionMs`, async () => await ops.completeExecution(activeContextSelector, executionId, "completed"));
+                    await measureBenchmark(params.__benchmark, `${stagePrefix}.completeExecutionMs`, async () => await ops.completeExecution(activeContextSelector, executionId, "completed", {
+                        contextId: String(currentContext.id),
+                        reactionEventId,
+                        reactionEvent,
+                    }));
                     execution = { ...execution, status: "completed" };
                     updatedContext = { ...updatedContext, status: "closed" };
                     await emitContextEvents({

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

@@ -2,7 +2,8 @@ import type { UIMessageChunk } from "ai";
 import type { ContextEnvironment } from "../context.config.js";
 import type { ContextRuntime } from "../context.runtime.js";
 import type { ContextExecution, ContextItem, ContextIdentifier, StoredContext, ContextStatus } from "../context.store.js";
-import { type PersistedContextStepStreamSession } from "./stream.steps.js";
+import type { ContextStreamEvent } from "../context.stream.js";
+import { type ContextActionResultForStream, type PersistedContextStepStreamSession } from "./stream.steps.js";
 type RuntimeParams<Env extends ContextEnvironment = ContextEnvironment> = {
     runtime: ContextRuntime<Env>;
 };
@@ -48,7 +49,7 @@ export declare function saveTriggerItem(params: RuntimeParams & {
     contextIdentifier: ContextIdentifier;
     event: ContextItem;
 }): Promise<ContextItem>;
-export declare function saveTriggerAndCreateExecution(params: {
+export declare function openExecution(params: {
     runtime: ContextRuntime<ContextEnvironment>;
     contextIdentifier: ContextIdentifier;
     triggerEvent: ContextItem;
@@ -96,13 +97,18 @@ export declare function completeExecution(params: RuntimeParams & {
     contextIdentifier: ContextIdentifier;
     executionId: string;
     status: "completed" | "failed";
-}): Promise<void>;
+    contextId?: string;
+    reactionEventId?: string;
+    reactionEvent?: ContextItem;
+}): Promise<{
+    reactionEvent?: ContextItem;
+}>;
 export declare function updateExecutionWorkflowRun(params: {
     runtime: ContextRuntime<ContextEnvironment>;
     executionId: string;
     workflowRunId: string;
 }): Promise<void>;
-export declare function openReactionStep<C>(params: {
+export declare function openExecutionStep<C>(params: {
     runtime: ContextRuntime<ContextEnvironment>;
     contextIdentifier: ContextIdentifier;
     content: C;
@@ -129,33 +135,29 @@ export declare function updateContextStep(params: {
     iteration?: number;
     patch: ContextStepPatch;
 }): Promise<void>;
-export declare function finalizeReactionStep(params: {
+export declare function completeExecutionStep(params: {
     runtime: ContextRuntime<ContextEnvironment>;
     session?: PersistedContextStepStreamSession | null;
     stepId: string;
     executionId?: string;
     contextId?: string;
     iteration?: number;
-    patch: ContextStepPatch;
+    parts?: any[];
+    actionResults?: ContextActionResultForStream[];
+    stepStatus?: ContextStepPatch["status"];
+    errorText?: string;
     reactionEventId?: string;
     reactionEvent?: ContextItem;
 }): Promise<{
     reactionEvent?: ContextItem;
+    actionResultChunkEvents: ContextStreamEvent[];
 }>;
 export declare function linkItemToExecutionStep(params: {
     runtime: ContextRuntime<ContextEnvironment>;
     itemId: string;
     executionId: string;
 }): Promise<void>;
-export declare function saveContextPartsStep(params: {
-    runtime: ContextRuntime<ContextEnvironment>;
-    stepId: string;
-    executionId?: string;
-    contextId?: string;
-    iteration?: number;
-    parts: any[];
-}): Promise<void>;
-export declare function saveContextPartsAndUpdateReaction(params: {
+export declare function saveExecutionStepOutput(params: {
     runtime: ContextRuntime<ContextEnvironment>;
     stepId: string;
     executionId?: string;

package/dist/steps/store.steps.js

@@ -2,7 +2,7 @@ import { getContextRuntimeServices } from "../context.runtime.js";
 import { OUTPUT_ITEM_TYPE, WEB_CHANNEL } from "../context.events.js";
 import { writeContextTraceEvents } from "./trace.steps.js";
 import { getClientResumeHookUrl, toolApprovalHookToken, toolApprovalWebhookToken, } from "../context.hooks.js";
-import { createPersistedContextStepStreamForRuntime, finalizePersistedContextStepStreamForRuntime, } from "./stream.steps.js";
+import { createPersistedContextStepStreamForRuntime, finalizePersistedContextStepStreamForRuntime, writeActionResultPartChunksToSession, } from "./stream.steps.js";
 async function getRuntimeAndEnv(params) {
     const env = params.runtime.env;
     const runtime = await getContextRuntimeServices(params.runtime);
@@ -158,11 +158,11 @@ export async function saveTriggerItem(params) {
     const { runtime } = await getRuntimeAndEnv(params);
     return await runtime.store.saveItem(params.contextIdentifier, params.event);
 }
-export async function saveTriggerAndCreateExecution(params) {
+export async function openExecution(params) {
     "use step";
     const { runtime, env } = await getRuntimeAndEnv(params);
     const { store, db } = runtime;
-    logStepDebug("saveTriggerAndCreateExecution:start", {
+    logStepDebug("openExecution:start", {
         contextIdentifier: summarizeContextIdentifierForLog(params.contextIdentifier),
         triggerEventId: params.triggerEvent?.id,
         triggerEventType: params.triggerEvent?.type,
@@ -174,7 +174,7 @@ export async function saveTriggerAndCreateExecution(params) {
         saved = await store.saveItem(params.contextIdentifier, params.triggerEvent);
     }
     catch (error) {
-        logStepDebug("saveTriggerAndCreateExecution:saveItem:error", {
+        logStepDebug("openExecution:saveItem:error", {
             contextIdentifier: summarizeContextIdentifierForLog(params.contextIdentifier),
             triggerEventId: params.triggerEvent?.id,
             error: summarizeStepError(error),
@@ -206,7 +206,7 @@ export async function saveTriggerAndCreateExecution(params) {
         });
     }
     catch (error) {
-        logStepDebug("saveTriggerAndCreateExecution:saveReaction:error", {
+        logStepDebug("openExecution:saveReaction:error", {
             contextIdentifier: summarizeContextIdentifierForLog(params.contextIdentifier),
             reactionEventId,
             error: summarizeStepError(error),
@@ -218,7 +218,7 @@ export async function saveTriggerAndCreateExecution(params) {
         execution = await store.createExecution(params.contextIdentifier, saved.id, savedReaction.id);
     }
     catch (error) {
-        logStepDebug("saveTriggerAndCreateExecution:createExecution:error", {
+        logStepDebug("openExecution:createExecution:error", {
             contextIdentifier: summarizeContextIdentifierForLog(params.contextIdentifier),
             triggerEventId: saved.id,
             reactionEventId: savedReaction.id,
@@ -237,7 +237,7 @@ export async function saveTriggerAndCreateExecution(params) {
         });
     }
     catch (error) {
-        logStepDebug("saveTriggerAndCreateExecution:linkItemsToExecution:error", {
+        logStepDebug("openExecution:linkItemsToExecution:error", {
             contextIdentifier: summarizeContextIdentifierForLog(params.contextIdentifier),
             triggerEventId: saved.id,
             reactionEventId: savedReaction.id,
@@ -474,16 +474,22 @@ export async function completeExecution(params) {
     const { runtime, env } = await getRuntimeAndEnv(params);
     const { store, db } = runtime;
     await store.completeExecution(params.contextIdentifier, params.executionId, params.status);
-    const contextId = typeof params.contextIdentifier?.id === "string"
-        ? String(params.contextIdentifier.id)
-        : undefined;
+    let savedReaction;
+    if (params.reactionEventId && params.reactionEvent) {
+        savedReaction = await store.updateItem(params.reactionEventId, params.reactionEvent);
+    }
+    const contextId = typeof params.contextId === "string"
+        ? params.contextId
+        : typeof params.contextIdentifier?.id === "string"
+            ? String(params.contextIdentifier.id)
+            : undefined;
     const { runId } = await resolveWorkflowRunId({
         env,
         db,
         executionId: params.executionId,
     });
     if (runId) {
-        await maybeWriteTraceEvents(env, [
+        const events = [
             {
                 workflowRunId: runId,
                 eventId: `context_execution:${String(params.executionId)}:${params.status}`,
@@ -495,8 +501,25 @@ export async function completeExecution(params) {
                     status: params.status,
                 },
             },
-        ]);
+        ];
+        if (savedReaction) {
+            events.push({
+                workflowRunId: runId,
+                eventId: `context_item:${String(savedReaction.id)}`,
+                eventKind: "context.item",
+                eventAt: new Date().toISOString(),
+                contextId,
+                executionId: String(params.executionId),
+                contextEventId: String(savedReaction.id),
+                payload: {
+                    ...savedReaction,
+                    direction: inferDirection(savedReaction),
+                },
+            });
+        }
+        await maybeWriteTraceEvents(env, events);
     }
+    return { reactionEvent: savedReaction };
 }
 export async function updateExecutionWorkflowRun(params) {
     "use step";
@@ -511,7 +534,7 @@ export async function updateExecutionWorkflowRun(params) {
         ]);
     }
 }
-export async function openReactionStep(params) {
+export async function openExecutionStep(params) {
     "use step";
     const { runtime } = await getRuntimeAndEnv(params);
     const { store } = runtime;
@@ -574,10 +597,20 @@ export async function updateContextStep(params) {
         ]);
     }
 }
-export async function finalizeReactionStep(params) {
+export async function completeExecutionStep(params) {
     "use step";
     const { runtime, env } = await getRuntimeAndEnv(params);
     const { store, db } = runtime;
+    const actionResultChunkEvents = await writeActionResultPartChunksToSession({
+        session: params.session,
+        contextId: String(params.contextId ?? ""),
+        executionId: String(params.executionId ?? ""),
+        itemId: String(params.reactionEventId ?? ""),
+        actionResults: params.actionResults ?? [],
+    });
+    if (params.parts) {
+        await store.saveStepParts({ stepId: params.stepId, parts: params.parts });
+    }
     if (params.session) {
         await finalizePersistedContextStepStreamForRuntime({
             runtime,
@@ -586,7 +619,8 @@ export async function finalizeReactionStep(params) {
         });
     }
     await store.updateStep(params.stepId, {
-        ...params.patch,
+        status: params.stepStatus ?? "completed",
+        ...(params.errorText !== undefined ? { errorText: params.errorText } : {}),
         updatedAt: new Date(),
     });
     let savedReaction;
@@ -609,12 +643,29 @@ export async function finalizeReactionStep(params) {
                 executionId: params.executionId,
                 stepId: String(params.stepId),
                 payload: {
-                    status: params.patch.status,
+                    status: params.stepStatus ?? "completed",
                     iteration: params.iteration,
-                    errorText: params.patch.errorText,
+                    errorText: params.errorText,
                 },
             },
         ];
+        if (params.parts?.length) {
+            for (let idx = 0; idx < params.parts.length; idx += 1) {
+                const part = params.parts[idx];
+                events.push({
+                    workflowRunId: runId,
+                    eventId: `context_part:${String(params.stepId)}:${idx}`,
+                    eventKind: "context.part",
+                    eventAt: new Date().toISOString(),
+                    contextId: params.contextId,
+                    executionId: params.executionId,
+                    stepId: String(params.stepId),
+                    partKey: `${String(params.stepId)}:${idx}`,
+                    partIdx: idx,
+                    payload: part,
+                });
+            }
+        }
         if (savedReaction) {
             events.push({
                 workflowRunId: runId,
@@ -632,7 +683,7 @@ export async function finalizeReactionStep(params) {
         }
         await maybeWriteTraceEvents(env, events);
     }
-    return { reactionEvent: savedReaction };
+    return { reactionEvent: savedReaction, actionResultChunkEvents };
 }
 export async function linkItemToExecutionStep(params) {
     "use step";
@@ -640,37 +691,7 @@ export async function linkItemToExecutionStep(params) {
     const { store } = runtime;
     await store.linkItemToExecution({ itemId: params.itemId, executionId: params.executionId });
 }
-export async function saveContextPartsStep(params) {
-    "use step";
-    const { runtime, env } = await getRuntimeAndEnv(params);
-    const { store, db } = runtime;
-    await store.saveStepParts({ stepId: params.stepId, parts: params.parts });
-    const { runId } = await resolveWorkflowRunId({
-        env,
-        db,
-        executionId: params.executionId,
-    });
-    if (runId && params.parts?.length) {
-        const events = [];
-        for (let idx = 0; idx < params.parts.length; idx += 1) {
-            const part = params.parts[idx];
-            events.push({
-                workflowRunId: runId,
-                eventId: `context_part:${String(params.stepId)}:${idx}`,
-                eventKind: "context.part",
-                eventAt: new Date().toISOString(),
-                contextId: params.contextId,
-                executionId: params.executionId,
-                stepId: String(params.stepId),
-                partKey: `${String(params.stepId)}:${idx}`,
-                partIdx: idx,
-                payload: part,
-            });
-        }
-        await maybeWriteTraceEvents(env, events);
-    }
-}
-export async function saveContextPartsAndUpdateReaction(params) {
+export async function saveExecutionStepOutput(params) {
     "use step";
     const { runtime, env } = await getRuntimeAndEnv(params);
     const { store, db } = runtime;

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

@@ -50,21 +50,22 @@ export declare function abortPersistedContextStepStream(params: {
     session: PersistedContextStepStreamSession;
     reason?: string | null;
 }): Promise<void>;
-export declare function writeActionResultPartChunks(params: {
+export type ContextActionResultForStream = {
+    actionRequest: {
+        actionRef: string;
+        actionName: string;
+        input: unknown;
+    };
+    success: boolean;
+    output: unknown;
+    errorText?: string;
+};
+export declare function writeActionResultPartChunksToSession(params: {
     session?: PersistedContextStepStreamSession | null;
     contextId: string;
     executionId: string;
     itemId: string;
-    actionResults: Array<{
-        actionRequest: {
-            actionRef: string;
-            actionName: string;
-            input: unknown;
-        };
-        success: boolean;
-        output: unknown;
-        errorText?: string;
-    }>;
+    actionResults: ContextActionResultForStream[];
 }): Promise<ContextStreamEvent[]>;
 export declare function readPersistedContextStepStream(params: {
     db: any;

package/dist/steps/stream.steps.js

@@ -183,8 +183,7 @@ export async function abortPersistedContextStepStream(params) {
         abortReason: params.reason,
     });
 }
-export async function writeActionResultPartChunks(params) {
-    "use step";
+export async function writeActionResultPartChunksToSession(params) {
     if (!params.session || params.actionResults.length === 0)
         return [];
     const writer = params.session.stream.getWriter();

package/dist/stores/instant.store.js

@@ -71,6 +71,43 @@ function ensureValidEntityId(value, label) {
     }
     return normalized;
 }
+function sanitizeInstantString(value) {
+    return value.includes("\u0000") ? value.replace(/\u0000/g, "") : value;
+}
+function isOpaqueJsonValue(value) {
+    return (value instanceof Date ||
+        value instanceof ArrayBuffer ||
+        ArrayBuffer.isView(value));
+}
+function sanitizeInstantValue(value, seen = new WeakMap()) {
+    if (typeof value === "string") {
+        return sanitizeInstantString(value);
+    }
+    if (value === null || value === undefined || typeof value !== "object") {
+        return value;
+    }
+    if (isOpaqueJsonValue(value)) {
+        return value;
+    }
+    const cached = seen.get(value);
+    if (cached) {
+        return cached;
+    }
+    if (Array.isArray(value)) {
+        const out = [];
+        seen.set(value, out);
+        for (const item of value) {
+            out.push(sanitizeInstantValue(item, seen));
+        }
+        return out;
+    }
+    const out = {};
+    seen.set(value, out);
+    for (const [key, entryValue] of Object.entries(value)) {
+        out[sanitizeInstantString(key)] = sanitizeInstantValue(entryValue, seen);
+    }
+    return out;
+}
 function logInstantTransactFailure(params) {
     if (!shouldDebugInstantStore())
         return;
@@ -244,6 +281,7 @@ export class InstantStore {
     }
     async saveItem(contextIdentifier, event) {
         const eventId = ensureValidEntityId(event?.id, "event.id");
+        const sanitizedEvent = sanitizeInstantValue(event);
         const context = await this.resolveContext(contextIdentifier);
         const existing = await this.getItem(eventId);
         if (existing?.status && existing.status !== "stored") {
@@ -251,7 +289,7 @@ export class InstantStore {
         }
         const txs = [
             this.db.tx.event_items[eventId].update({
-                ...event,
+                ...sanitizedEvent,
                 id: eventId,
                 status: "stored",
             }),
@@ -277,7 +315,7 @@ export class InstantStore {
             throw error;
         }
         return {
-            ...event,
+            ...sanitizedEvent,
             id: eventId,
             status: "stored",
         };
@@ -287,10 +325,11 @@ export class InstantStore {
         if (current?.status && event.status && current.status !== event.status) {
             assertItemTransition(current.status, event.status);
         }
-        await this.db.transact([this.db.tx.event_items[eventId].update(event)]);
+        const sanitizedEvent = sanitizeInstantValue(event);
+        await this.db.transact([this.db.tx.event_items[eventId].update(sanitizedEvent)]);
         return {
             ...current,
-            ...event,
+            ...sanitizedEvent,
             id: eventId,
         };
     }
@@ -531,7 +570,7 @@ export class InstantStore {
         ]);
     }
     async saveStepParts(params) {
-        const parts = normalizePartsForPersistence(Array.isArray(params.parts) ? params.parts : []);
+        const parts = sanitizeInstantValue(normalizePartsForPersistence(Array.isArray(params.parts) ? params.parts : []));
         if (parts.length === 0)
             return;
         const txs = parts.map((part, idx) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ekairos/events",
-  "version": "1.22.79-beta.development.0",
+  "version": "1.22.80-beta.development.0",
   "description": "Ekairos Events - Context-first workflow runtime",
   "type": "module",
   "main": "dist/index.js",
@@ -127,7 +127,7 @@
   },
   "dependencies": {
     "@ai-sdk/openai": "^2.0.52",
-    "@ekairos/domain": "^1.22.79-beta.development.0",
+    "@ekairos/domain": "^1.22.80-beta.development.0",
     "@instantdb/admin": "0.22.158",
     "@instantdb/core": "0.22.142",
     "@vercel/mcp-adapter": "^1.0.0",