@ekairos/events 1.22.39-beta.development.0 → 1.22.40-beta.development.0

package/dist/context.engine.js

@@ -2,38 +2,18 @@ import { getContextRuntimeServices } from "./context.runtime.js";
 import { OUTPUT_ITEM_TYPE, WEB_CHANNEL } from "./context.events.js";
 import { applyToolExecutionResultToParts } from "./context.toolcalls.js";
 import { isContextPartEnvelope, normalizePartsForPersistence, } from "./context.parts.js";
-import { actionsToActionSpecs } from "./tools-to-model-tools.js";
 import { createAiSdkReactor, } from "./context.reactor.js";
-import { abortPersistedContextStepStream, closePersistedContextStepStream, createPersistedContextStepStream, closeContextStream, } from "./steps/stream.steps.js";
-import { completeExecution, createContextStep, getContextItems, initializeContext, saveTriggerAndCreateExecution, saveContextPartsStep, updateContextContent, updateContextReactor, updateContextStatus, updateItem, updateContextStep, } from "./steps/store.steps.js";
+import { abortPersistedContextStepStream, closeContextStream, createPersistedContextStepStreamForRuntime, finalizePersistedContextStepStreamForRuntime, } from "./steps/stream.steps.js";
+import { completeExecution, createContextStep, finalizeReactionStep, getContextItems, initializeContext, openReactionStep, saveTriggerAndCreateExecution, saveContextPartsAndUpdateReaction, saveContextPartsStep, updateContextContent, updateContextReactor, updateContextStatus, updateItem, updateContextStep, } from "./steps/store.steps.js";
 import { getClientResumeHookUrl, toolApprovalHookToken, toolApprovalWebhookToken, } from "./context.hooks.js";
 import { getContextDurableWorkflow } from "./context.durable.js";
 export async function runContextReactionDirect(context, triggerEvent, params) {
     return await ContextEngine.runDirect(context, triggerEvent, params);
 }
-async function legacyRuntimeFromEnv(env) {
-    const { getContextRuntime } = await import("./runtime.step.js");
-    const legacy = (await getContextRuntime(env));
-    return {
-        env,
-        db: async () => legacy.db,
-        resolve: async () => ({
-            db: legacy.db,
-            meta: () => ({
-                domain: legacy.domain,
-            }),
-        }),
-        meta: () => ({
-            domain: legacy.domain,
-        }),
-    };
-}
 async function resolveReactRuntime(params) {
     if (params.runtime)
         return params.runtime;
-    if (params.env)
-        return await legacyRuntimeFromEnv(params.env);
-    throw new Error("ContextEngine.react requires either runtime or env.");
+    throw new Error("ContextEngine.react requires runtime.");
 }
 export { toolApprovalHookToken, toolApprovalWebhookToken, getClientResumeHookUrl };
 function nowIso() {
@@ -48,13 +28,21 @@ function summarizePartPreview(part) {
     if (!part || typeof part !== "object")
         return {};
     if (isContextPartEnvelope(part)) {
-        const preview = part.content[0]?.type === "text"
-            ? part.content[0].text
-            : JSON.stringify(part.content[0] ?? part);
-        const state = "state" in part && typeof part.state === "string" ? part.state : undefined;
-        const toolCallId = "toolCallId" in part && typeof part.toolCallId === "string"
-            ? part.toolCallId
-            : undefined;
+        const preview = part.type === "message"
+            ? part.content.text ?? JSON.stringify(part.content.blocks?.[0] ?? part)
+            : part.type === "reasoning"
+                ? part.content.text
+                : part.type === "source"
+                    ? JSON.stringify(part.content.sources[0] ?? part)
+                    : part.content.status === "failed"
+                        ? part.content.error.message
+                        : JSON.stringify(part.content);
+        const state = part.type === "reasoning"
+            ? part.content.state
+            : part.type === "action"
+                ? part.content.status
+                : undefined;
+        const toolCallId = part.type === "action" ? part.content.actionCallId : undefined;
         return {
             partPreview: preview ? clipPreview(preview) : undefined,
             partState: state,
@@ -233,6 +221,31 @@ async function createRuntimeOps(runtimeHandle, benchmark) {
                 },
             };
         },
+        openReactionStep: async ({ contextIdentifier, content, executionId, iteration }) => {
+            const stepId = makeRuntimeId();
+            const now = new Date();
+            await instrumentedDb.transact([
+                instrumentedDb.tx.event_steps[stepId].create({
+                    createdAt: now,
+                    updatedAt: now,
+                    status: "running",
+                    iteration,
+                }),
+                instrumentedDb.tx.event_steps[stepId].link({ execution: executionId }),
+            ]);
+            const stream = await createPersistedContextStepStreamForRuntime({ db: instrumentedDb }, {
+                executionId,
+                stepId,
+            });
+            const context = await store.updateContextContent(contextIdentifier, content);
+            const events = await store.getItems(contextIdentifier);
+            return {
+                stepId,
+                stream,
+                context,
+                events,
+            };
+        },
         createContextStep: async ({ executionId, iteration }) => {
             const stepId = makeRuntimeId();
             await instrumentedDb.transact([
@@ -254,9 +267,48 @@ async function createRuntimeOps(runtimeHandle, benchmark) {
                 }),
             ]);
         },
+        finalizeReactionStep: async (params) => {
+            if (params.session) {
+                await finalizePersistedContextStepStreamForRuntime({
+                    runtime: { db: instrumentedDb },
+                    session: params.session,
+                    mode: "close",
+                });
+            }
+            await instrumentedDb.transact([
+                instrumentedDb.tx.event_steps[params.stepId].update({
+                    ...params.patch,
+                    updatedAt: new Date(),
+                }),
+            ]);
+            if (!params.reactionEventId || !params.reactionEvent) {
+                return {};
+            }
+            await instrumentedDb.transact([
+                instrumentedDb.tx.event_items[params.reactionEventId].update(params.reactionEvent),
+            ]);
+            return {
+                reactionEvent: {
+                    ...params.reactionEvent,
+                    id: params.reactionEventId,
+                },
+            };
+        },
         saveContextPartsStep: async (params) => {
             await store.saveStepParts({ stepId: params.stepId, parts: params.parts });
         },
+        saveContextPartsAndUpdateReaction: async (params) => {
+            await store.saveStepParts({ stepId: params.stepId, parts: params.parts });
+            await instrumentedDb.transact([
+                instrumentedDb.tx.event_items[params.reactionEventId].update(params.reactionEvent),
+            ]);
+            return {
+                reactionEvent: {
+                    ...params.reactionEvent,
+                    id: params.reactionEventId,
+                },
+            };
+        },
         getItems: async (contextIdentifier) => await store.getItems(contextIdentifier),
         updateItem: async (itemId, item) => {
             await instrumentedDb.transact([instrumentedDb.tx.event_items[itemId].update(item)]);
@@ -288,9 +340,12 @@ async function createWorkflowOps(runtime) {
         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 }),
         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 }),
         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 }),
@@ -307,9 +362,11 @@ async function getContextEngineOps(runtime, benchmark) {
 export class ContextEngine {
     constructor(opts = {}, reactor) {
         this.opts = opts;
-        this.reactor = reactor ?? createAiSdkReactor();
+        this.reactor =
+            reactor ??
+                createAiSdkReactor();
     }
-    async buildSkills(_context, _env) {
+    async buildSkills(_context, _env, _runtime) {
         return [];
     }
     /**
@@ -329,13 +386,13 @@ export class ContextEngine {
      *   the builder) so results are durable and replay-safe.
      * - If it’s pure/deterministic, it can run in workflow context.
      */
-    async expandEvents(events, _context, _env) {
+    async expandEvents(events, _context, _env, _runtime) {
         return events;
     }
-    getModel(_context, _env) {
+    getModel(_context, _env, _runtime) {
         return "openai/gpt-5";
     }
-    getReactor(_context, _env) {
+    getReactor(_context, _env, _runtime) {
         return this.reactor;
     }
     /**
@@ -350,10 +407,10 @@ export class ContextEngine {
         return true;
     }
     async react(triggerEvent, params) {
-        if (params.durable) {
-            return await ContextEngine.startDurable(this, triggerEvent, params);
+        if (params.durable === false) {
+            return await ContextEngine.runDirect(this, triggerEvent, params);
         }
-        return await ContextEngine.runDirect(this, triggerEvent, params);
+        return await ContextEngine.startDurable(this, triggerEvent, params);
     }
     static async prepareExecutionShell(story, triggerEvent, params) {
         const runtimeHandle = await resolveReactRuntime(params);
@@ -364,7 +421,11 @@ export class ContextEngine {
         let currentContext = ctxResult.context;
         const contextSelector = { id: String(currentContext.id) };
         if (ctxResult.isNew) {
-            await story.opts.onContextCreated?.({ env, context: currentContext });
+            await story.opts.onContextCreated?.({
+                env,
+                runtime: runtimeHandle,
+                context: currentContext,
+            });
         }
         if (currentContext.status === "closed") {
             await measureBenchmark(params.__benchmark, "react.reopenClosedContextMs", async () => await ops.updateContextStatus(contextSelector, "open_idle"));
@@ -376,6 +437,7 @@ export class ContextEngine {
         }));
         currentContext = { ...currentContext, status: "open_streaming" };
         return {
+            runtimeHandle,
             contextSelector,
             currentContext,
             trigger: shell.triggerEvent,
@@ -400,10 +462,10 @@ export class ContextEngine {
         const shell = await ContextEngine.prepareExecutionShell(story, triggerEvent, params);
         let run;
         try {
-            const [{ start }] = await Promise.all([
+            const [{ start }] = await measureBenchmark(params.__benchmark, "react.durable.importWorkflowApiMs", async () => await Promise.all([
                 import("workflow/api"),
-            ]);
-            const startedRun = await start(workflow, [
+            ]));
+            const startedRun = await measureBenchmark(params.__benchmark, "react.durable.startWorkflowMs", async () => await start(workflow, [
                 {
                     contextKey,
                     runtime: runtimeHandle,
@@ -423,19 +485,19 @@ export class ContextEngine {
                         execution: shell.execution,
                     },
                 },
-            ]);
+            ]));
             run = {
                 runId: String(startedRun.runId),
                 status: startedRun.status,
                 returnValue: startedRun.returnValue,
             };
-            const runtime = await createRuntimeOps(runtimeHandle);
-            await runtime.db.transact([
+            const runtime = await measureBenchmark(params.__benchmark, "react.durable.resolveRuntimeOpsMs", async () => await createRuntimeOps(runtimeHandle, params.__benchmark));
+            await measureBenchmark(params.__benchmark, "react.durable.persistWorkflowRunIdMs", async () => await runtime.db.transact([
                 runtime.db.tx.event_executions[shell.execution.id].update({
                     workflowRunId: startedRun.runId,
                     updatedAt: new Date(),
                 }),
-            ]);
+            ]));
         }
         catch (error) {
             const ops = await getContextEngineOps(runtimeHandle, params.__benchmark);
@@ -451,6 +513,26 @@ export class ContextEngine {
         };
     }
     static async runDirect(story, triggerEvent, params) {
+        if (!params.__bootstrap) {
+            const shell = await ContextEngine.prepareExecutionShell(story, triggerEvent, params);
+            const run = ContextEngine.runDirect(story, triggerEvent, {
+                ...params,
+                runtime: shell.runtimeHandle,
+                __bootstrap: {
+                    contextId: shell.currentContext.id,
+                    trigger: shell.trigger,
+                    reaction: shell.reaction,
+                    execution: shell.execution,
+                },
+            });
+            return {
+                context: shell.currentContext,
+                trigger: shell.trigger,
+                reaction: shell.reaction,
+                execution: shell.execution,
+                run,
+            };
+        }
         const runtimeHandle = await resolveReactRuntime(params);
         const env = runtimeHandle.env;
         const ops = await measureBenchmark(params.__benchmark, "react.resolveOpsMs", async () => await getContextEngineOps(runtimeHandle, params.__benchmark));
@@ -520,18 +602,19 @@ export class ContextEngine {
         };
         try {
             for (let iter = 0; iter < maxIterations; iter++) {
-                // Create a persisted step per iteration (IDs generated in step runtime for replay safety)
                 const stagePrefix = `react.iteration.${iter}`;
-                const stepCreate = await measureBenchmark(params.__benchmark, `${stagePrefix}.createStepMs`, async () => await ops.createContextStep({
+                // 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({
+                    contextIdentifier: activeContextSelector,
+                    content: nextContent,
                     executionId,
                     iteration: iter,
                 }));
-                currentStepId = stepCreate.stepId;
-                currentStepStream = await createPersistedContextStepStream({
-                    runtime: runtimeHandle,
-                    executionId,
-                    stepId: stepCreate.stepId,
-                });
+                currentStepId = openedStep.stepId;
+                currentStepStream = openedStep.stream;
+                updatedContext = openedStep.context;
+                const rawEvents = openedStep.events;
                 await emitContextEvents({
                     silent,
                     writable,
@@ -539,20 +622,11 @@ export class ContextEngine {
                         {
                             type: "step.created",
                             at: nowIso(),
-                            stepId: String(stepCreate.stepId),
+                            stepId: String(openedStep.stepId),
                             executionId,
                             iteration: iter,
                             status: "running",
                         },
-                    ],
-                });
-                // Hook: Context DSL `context()` (implemented by subclasses via `initialize()`)
-                const nextContent = await measureBenchmark(params.__benchmark, `${stagePrefix}.contextMs`, async () => await story.initialize(updatedContext, env));
-                updatedContext = await measureBenchmark(params.__benchmark, `${stagePrefix}.persistContextMs`, async () => await ops.updateContextContent(activeContextSelector, nextContent));
-                await emitContextEvents({
-                    silent,
-                    writable,
-                    events: [
                         {
                             type: "context.content_updated",
                             at: nowIso(),
@@ -560,17 +634,17 @@ export class ContextEngine {
                         },
                     ],
                 });
-                await story.opts.onContextUpdated?.({ env, context: updatedContext });
+                await story.opts.onContextUpdated?.({
+                    env,
+                    runtime: runtimeHandle,
+                    context: updatedContext,
+                });
                 // Hook: Context DSL `narrative()` (implemented by subclasses via `buildSystemPrompt()`)
-                const systemPrompt = await measureBenchmark(params.__benchmark, `${stagePrefix}.narrativeMs`, async () => await story.buildSystemPrompt(updatedContext, env));
+                const systemPrompt = await measureBenchmark(params.__benchmark, `${stagePrefix}.narrativeMs`, async () => await story.buildSystemPrompt(updatedContext, env, runtimeHandle));
                 // Hook: Context DSL `actions()` (implemented by subclasses via `buildTools()`)
-                const toolsAll = await measureBenchmark(params.__benchmark, `${stagePrefix}.actionsMs`, async () => await story.buildTools(updatedContext, env));
-                const skillsAll = await measureBenchmark(params.__benchmark, `${stagePrefix}.skillsMs`, async () => await story.buildSkills(updatedContext, env));
-                const rawEvents = await measureBenchmark(params.__benchmark, `${stagePrefix}.loadEventsMs`, async () => await ops.getItems(activeContextSelector));
-                const expandedEvents = await measureBenchmark(params.__benchmark, `${stagePrefix}.expandEventsMs`, async () => await story.expandEvents(rawEvents, updatedContext, env));
-                // IMPORTANT: step args must be serializable.
-                // Match DurableAgent behavior: convert tool input schemas to plain JSON Schema in workflow context.
-                const actionSpecs = actionsToActionSpecs(toolsAll);
+                const toolsAll = await measureBenchmark(params.__benchmark, `${stagePrefix}.actionsMs`, async () => await story.buildTools(updatedContext, env, runtimeHandle));
+                const skillsAll = await measureBenchmark(params.__benchmark, `${stagePrefix}.skillsMs`, async () => await story.buildSkills(updatedContext, env, runtimeHandle));
+                const expandedEvents = await measureBenchmark(params.__benchmark, `${stagePrefix}.expandEventsMs`, async () => await story.expandEvents(rawEvents, updatedContext, env, runtimeHandle));
                 // Execute model reaction for this iteration using the stable reaction event id.
                 //
                 // IMPORTANT:
@@ -578,7 +652,7 @@ export class ContextEngine {
                 // If we stream with a per-step id, the UI will render an optimistic assistant message
                 // (step id) and then a second persisted assistant message (reaction id) with the same
                 // content once InstantDB updates.
-                const reactor = story.getReactor(updatedContext, env);
+                const reactor = story.getReactor(updatedContext, env, runtimeHandle);
                 const reactionPartsBeforeStep = Array.isArray(reactionEvent.content?.parts)
                     ? [...reactionEvent.content.parts]
                     : [];
@@ -589,38 +663,38 @@ export class ContextEngine {
                     if (nextSignature === persistedReactionPartsSignature)
                         return;
                     persistedReactionPartsSignature = nextSignature;
-                    await ops.saveContextPartsStep({
-                        stepId: stepCreate.stepId,
+                    const saved = await ops.saveContextPartsAndUpdateReaction({
+                        stepId: openedStep.stepId,
                         parts: normalizedParts,
+                        reactionEventId: reactionEvent.id,
+                        reactionEvent: {
+                            ...reactionEvent,
+                            content: {
+                                ...reactionEvent.content,
+                                parts: [...reactionPartsBeforeStep, ...normalizedParts],
+                            },
+                            status: "pending",
+                        },
                         executionId,
                         contextId: String(currentContext.id),
                         iteration: iter,
                     });
-                    reactionEvent = await ops.updateItem(reactionEvent.id, {
-                        ...reactionEvent,
-                        content: {
-                            ...reactionEvent.content,
-                            parts: [...reactionPartsBeforeStep, ...normalizedParts],
-                        },
-                        status: "pending",
-                    }, { executionId, contextId: String(currentContext.id) });
+                    reactionEvent = saved.reactionEvent;
                 };
                 const reactionResult = await measureBenchmark(params.__benchmark, `${stagePrefix}.reactorMs`, async () => await reactor({
                     runtime: runtimeHandle,
-                    env,
                     context: updatedContext,
                     contextIdentifier: activeContextSelector,
                     events: expandedEvents,
                     triggerEvent,
-                    model: story.getModel(updatedContext, env),
+                    model: story.getModel(updatedContext, env, runtimeHandle),
                     systemPrompt,
                     actions: toolsAll,
-                    actionSpecs,
                     skills: skillsAll,
                     eventId: reactionEventId,
                     executionId,
                     contextId: String(currentContext.id),
-                    stepId: String(stepCreate.stepId),
+                    stepId: String(openedStep.stepId),
                     iteration: iter,
                     maxModelSteps,
                     // Only emit a `start` chunk once per story turn.
@@ -659,21 +733,35 @@ export class ContextEngine {
                         parts: stepParts,
                     },
                 };
-                await measureBenchmark(params.__benchmark, `${stagePrefix}.saveStepPartsMs`, async () => await ops.saveContextPartsStep({
-                    stepId: stepCreate.stepId,
+                const nextAssistantParts = Array.isArray(assistantEventEffective.content?.parts)
+                    ? assistantEventEffective.content.parts
+                    : [];
+                const nextReactionEvent = {
+                    ...reactionEvent,
+                    content: {
+                        ...reactionEvent.content,
+                        parts: [...reactionPartsBeforeStep, ...nextAssistantParts],
+                    },
+                    status: "pending",
+                };
+                const appendedReactorOutput = await measureBenchmark(params.__benchmark, `${stagePrefix}.appendReactorOutputMs`, async () => await ops.saveContextPartsAndUpdateReaction({
+                    stepId: openedStep.stepId,
                     parts: stepParts,
+                    reactionEventId: reactionEvent.id,
+                    reactionEvent: nextReactionEvent,
                     executionId,
                     contextId: String(currentContext.id),
                     iteration: iter,
                 }));
+                reactionEvent = appendedReactorOutput.reactionEvent;
                 await emitContextEvents({
                     silent,
                     writable,
                     events: stepParts.map((part, idx) => ({
                         type: "part.created",
                         at: nowIso(),
-                        partKey: `${String(stepCreate.stepId)}:${idx}`,
-                        stepId: String(stepCreate.stepId),
+                        partKey: `${String(openedStep.stepId)}:${idx}`,
+                        stepId: String(openedStep.stepId),
                         idx,
                         partType: part && typeof part.type === "string"
                             ? String(part.type)
@@ -681,19 +769,6 @@ export class ContextEngine {
                         ...summarizePartPreview(part),
                     })),
                 });
-                // Persist/append the aggregated reaction event (stable `reactionEventId` for the execution).
-                const nextAssistantParts = Array.isArray(assistantEventEffective.content?.parts)
-                    ? assistantEventEffective.content.parts
-                    : [];
-                const nextReactionEvent = {
-                    ...reactionEvent,
-                    content: {
-                        ...reactionEvent.content,
-                        parts: [...reactionPartsBeforeStep, ...nextAssistantParts],
-                    },
-                    status: "pending",
-                };
-                reactionEvent = await measureBenchmark(params.__benchmark, `${stagePrefix}.persistAssistantReactionMs`, async () => await ops.updateItem(reactionEvent.id, nextReactionEvent, { executionId, contextId: String(currentContext.id) }));
                 if (reactionResult.reactor?.kind) {
                     updatedContext = await measureBenchmark(params.__benchmark, `${stagePrefix}.persistReactorStateMs`, async () => await ops.updateContextReactor(activeContextSelector, {
                         kind: reactionResult.reactor.kind,
@@ -703,32 +778,8 @@ export class ContextEngine {
                         },
                     }));
                 }
-                if (currentStepStream) {
-                    await closePersistedContextStepStream({
-                        runtime: runtimeHandle,
-                        session: currentStepStream,
-                    });
-                    currentStepStream = null;
-                }
                 story.opts.onEventCreated?.(assistantEventEffective);
                 const firstActionRequest = actionRequests?.[0];
-                await measureBenchmark(params.__benchmark, `${stagePrefix}.markStepRunningMs`, async () => await ops.updateContextStep({
-                    stepId: stepCreate.stepId,
-                    patch: firstActionRequest
-                        ? {
-                            kind: "action_execute",
-                            actionName: typeof firstActionRequest.actionName === "string"
-                                ? firstActionRequest.actionName
-                                : undefined,
-                            actionInput: firstActionRequest.input,
-                        }
-                        : {
-                            kind: "message",
-                        },
-                    executionId,
-                    contextId: String(currentContext.id),
-                    iteration: iter,
-                }));
                 await emitContextEvents({
                     silent,
                     writable,
@@ -736,7 +787,7 @@ export class ContextEngine {
                         {
                             type: "step.updated",
                             at: nowIso(),
-                            stepId: String(stepCreate.stepId),
+                            stepId: String(openedStep.stepId),
                             executionId,
                             iteration: iter,
                             status: "running",
@@ -751,9 +802,13 @@ export class ContextEngine {
                 if (!actionRequests.length) {
                     const endResult = await story.callOnEnd(assistantEventEffective);
                     if (endResult) {
-                        // Mark iteration step completed (no tools)
-                        await measureBenchmark(params.__benchmark, `${stagePrefix}.finalizeMessageStepMs`, async () => await ops.updateContextStep({
-                            stepId: stepCreate.stepId,
+                        const completedReactionEvent = {
+                            ...reactionEvent,
+                            status: "completed",
+                        };
+                        const finalized = await measureBenchmark(params.__benchmark, `${stagePrefix}.finalizeReactionStepMs`, async () => await ops.finalizeReactionStep({
+                            session: currentStepStream,
+                            stepId: openedStep.stepId,
                             patch: {
                                 status: "completed",
                                 kind: "message",
@@ -761,10 +816,14 @@ export class ContextEngine {
                                 actionResults: [],
                                 continueLoop: false,
                             },
+                            reactionEventId,
+                            reactionEvent: completedReactionEvent,
                             executionId,
                             contextId: String(currentContext.id),
                             iteration: iter,
                         }));
+                        currentStepStream = null;
+                        reactionEvent = finalized.reactionEvent ?? completedReactionEvent;
                         await emitContextEvents({
                             silent,
                             writable,
@@ -772,7 +831,7 @@ export class ContextEngine {
                                 {
                                     type: "step.updated",
                                     at: nowIso(),
-                                    stepId: String(stepCreate.stepId),
+                                    stepId: String(openedStep.stepId),
                                     executionId,
                                     iteration: iter,
                                     status: "completed",
@@ -781,18 +840,13 @@ export class ContextEngine {
                                 {
                                     type: "step.completed",
                                     at: nowIso(),
-                                    stepId: String(stepCreate.stepId),
+                                    stepId: String(openedStep.stepId),
                                     executionId,
                                     iteration: iter,
                                     status: "completed",
                                 },
                             ],
                         });
-                        // Mark reaction event completed
-                        await measureBenchmark(params.__benchmark, `${stagePrefix}.completeReactionMs`, async () => await ops.updateItem(reactionEventId, {
-                            ...reactionEvent,
-                            status: "completed",
-                        }, { executionId, contextId: String(currentContext.id) }));
                         await emitContextEvents({
                             silent,
                             writable,
@@ -832,10 +886,6 @@ export class ContextEngine {
                         if (!silent) {
                             await closeContextStream({ preventClose, sendFinish, writable });
                         }
-                        reactionEvent = {
-                            ...reactionEvent,
-                            status: "completed",
-                        };
                         return {
                             context: updatedContext,
                             trigger,
@@ -887,7 +937,6 @@ export class ContextEngine {
                         const executeAction = toolDef.execute;
                         const output = await Reflect.apply(executeAction, undefined, [actionInput, {
                                 runtime: runtimeHandle,
-                                env,
                                 context: updatedContext,
                                 contextIdentifier: activeContextSelector,
                                 toolCallId: actionRequest.actionRef,
@@ -896,8 +945,9 @@ export class ContextEngine {
                                 executionId,
                                 triggerEventId,
                                 contextId: currentContext.id,
-                                stepId: String(stepCreate.stepId),
+                                stepId: String(openedStep.stepId),
                                 iteration: iter,
+                                contextStepStream: currentStepStream?.stream,
                             }]);
                         return { actionRequest, success: true, output };
                     }
@@ -923,7 +973,7 @@ export class ContextEngine {
                     });
                 }
                 await measureBenchmark(params.__benchmark, `${stagePrefix}.saveFinalStepPartsMs`, async () => await ops.saveContextPartsStep({
-                    stepId: stepCreate.stepId,
+                    stepId: openedStep.stepId,
                     parts: finalizedStepParts,
                     executionId,
                     contextId: String(currentContext.id),
@@ -955,36 +1005,47 @@ export class ContextEngine {
                 // 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,
                 }));
-                // Persist per-iteration step outcome (tools + continue signal)
-                await measureBenchmark(params.__benchmark, `${stagePrefix}.completeStepMs`, async () => await ops.updateContextStep({
-                    stepId: stepCreate.stepId,
+                const firstActionResult = actionResults?.[0];
+                const finalizedReactionStatus = continueLoop === false ? "completed" : "pending";
+                const finalizedReactionEvent = {
+                    ...reactionEvent,
+                    status: finalizedReactionStatus,
+                };
+                const finalizedStep = await measureBenchmark(params.__benchmark, `${stagePrefix}.finalizeReactionStepMs`, async () => await ops.finalizeReactionStep({
+                    session: currentStepStream,
+                    stepId: openedStep.stepId,
                     patch: {
                         status: "completed",
                         kind: actionRequests?.length ? "action_result" : "message",
-                        actionName: typeof actionResults?.[0]?.actionRequest?.actionName === "string"
-                            ? actionResults[0].actionRequest.actionName
+                        actionName: typeof firstActionResult?.actionRequest?.actionName === "string"
+                            ? firstActionResult.actionRequest.actionName
                             : undefined,
-                        actionInput: actionResults?.[0]?.actionRequest?.input,
-                        actionOutput: actionResults?.[0]?.success === true
-                            ? actionResults[0]?.output
+                        actionInput: firstActionResult?.actionRequest?.input,
+                        actionOutput: firstActionResult?.success === true
+                            ? firstActionResult?.output
                             : undefined,
-                        actionError: actionResults?.[0]?.success === false
-                            ? String(actionResults[0]?.errorText ?? "action_execution_failed")
+                        actionError: firstActionResult?.success === false
+                            ? String(firstActionResult?.errorText ?? "action_execution_failed")
                             : undefined,
                         actionRequests,
                         actionResults,
                         continueLoop: continueLoop !== false,
                     },
+                    reactionEventId,
+                    reactionEvent: finalizedReactionEvent,
                     executionId,
                     contextId: String(currentContext.id),
                     iteration: iter,
                 }));
+                currentStepStream = null;
+                reactionEvent = finalizedStep.reactionEvent ?? finalizedReactionEvent;
                 await emitContextEvents({
                     silent,
                     writable,
@@ -992,19 +1053,19 @@ export class ContextEngine {
                         {
                             type: "step.updated",
                             at: nowIso(),
-                            stepId: String(stepCreate.stepId),
+                            stepId: String(openedStep.stepId),
                             executionId,
                             iteration: iter,
                             status: "completed",
                             kind: actionRequests?.length ? "action_result" : "message",
-                            actionName: typeof actionResults?.[0]?.actionRequest?.actionName === "string"
-                                ? actionResults[0].actionRequest.actionName
+                            actionName: typeof firstActionResult?.actionRequest?.actionName === "string"
+                                ? firstActionResult.actionRequest.actionName
                                 : undefined,
                         },
                         {
                             type: "step.completed",
                             at: nowIso(),
-                            stepId: String(stepCreate.stepId),
+                            stepId: String(openedStep.stepId),
                             executionId,
                             iteration: iter,
                             status: "completed",
@@ -1012,10 +1073,6 @@ export class ContextEngine {
                     ],
                 });
                 if (continueLoop !== false) {
-                    reactionEvent = await measureBenchmark(params.__benchmark, `${stagePrefix}.persistPendingReactionMs`, async () => await ops.updateItem(reactionEventId, {
-                        ...reactionEvent,
-                        status: "pending",
-                    }, { executionId, contextId: String(currentContext.id) }));
                     await emitContextEvents({
                         silent,
                         writable,
@@ -1032,10 +1089,6 @@ export class ContextEngine {
                     });
                 }
                 if (continueLoop === false) {
-                    await measureBenchmark(params.__benchmark, `${stagePrefix}.completeReactionMs`, async () => await ops.updateItem(reactionEventId, {
-                        ...reactionEvent,
-                        status: "completed",
-                    }, { executionId, contextId: String(currentContext.id) }));
                     await emitContextEvents({
                         silent,
                         writable,
@@ -1075,10 +1128,6 @@ export class ContextEngine {
                     if (!silent) {
                         await closeContextStream({ preventClose, sendFinish, writable });
                     }
-                    reactionEvent = {
-                        ...reactionEvent,
-                        status: "completed",
-                    };
                     return {
                         context: updatedContext,
                         trigger,