@ekairos/events 1.22.34-beta.development.0 → 1.22.35

package/dist/steps/store.steps.js

@@ -1,6 +1,13 @@
+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, writeActionResultPartChunksToSession, } from "./stream.steps.js";
+async function getRuntimeAndEnv(params) {
+    const env = params.runtime.env;
+    const runtime = await getContextRuntimeServices(params.runtime);
+    return { runtime, env };
+}
 async function maybeWriteTraceEvents(env, traceEvents) {
     if (!traceEvents?.length)
         return;
@@ -92,24 +99,23 @@ function logStepDebug(message, payload) {
  *
  * This is the "context init" boundary for the story engine.
  */
-export async function initializeContext(env, contextIdentifier, opts) {
+export async function initializeContext(params) {
     "use step";
-    const { getContextRuntime } = await import("../runtime.js");
-    const runtime = await getContextRuntime(env);
+    const { runtime, env } = await getRuntimeAndEnv(params);
     const { store, db } = runtime;
     // Detect creation explicitly so the engine can run onContextCreated hooks.
     let result;
-    if (!contextIdentifier) {
+    if (!params.contextIdentifier) {
         const context = await store.getOrCreateContext(null);
         result = { context, isNew: true };
     }
     else {
-        const existing = await store.getContext(contextIdentifier);
+        const existing = await store.getContext(params.contextIdentifier);
         if (existing) {
             result = { context: existing, isNew: false };
         }
         else {
-            const created = await store.getOrCreateContext(contextIdentifier);
+            const created = await store.getOrCreateContext(params.contextIdentifier);
             result = { context: created, isNew: true };
         }
     }
@@ -132,31 +138,41 @@ export async function initializeContext(env, contextIdentifier, opts) {
     }
     return result;
 }
-export async function updateContextContent(env, contextIdentifier, content) {
+export async function updateContextContent(params) {
     "use step";
-    const { getContextRuntime } = await import("../runtime.js");
-    const { store } = await getContextRuntime(env);
-    return await store.updateContextContent(contextIdentifier, content);
+    const { runtime } = await getRuntimeAndEnv(params);
+    return await runtime.store.updateContextContent(params.contextIdentifier, params.content);
 }
-export async function updateContextStatus(env, contextIdentifier, status) {
+export async function updateContextDefinition(params) {
     "use step";
-    const { getContextRuntime } = await import("../runtime.js");
-    const { store } = await getContextRuntime(env);
-    await store.updateContextStatus(contextIdentifier, status);
+    const { runtime } = await getRuntimeAndEnv(params);
+    return await runtime.store.updateContextDefinition(params.contextIdentifier, params.definition);
 }
-export async function saveTriggerItem(env, contextIdentifier, event) {
+export async function upsertContextResources(params) {
     "use step";
-    const { getContextRuntime } = await import("../runtime.js");
-    const { store } = await getContextRuntime(env);
-    const saved = await store.saveItem(contextIdentifier, event);
-    return saved;
+    const { runtime } = await getRuntimeAndEnv(params);
+    return await runtime.store.upsertContextResources(params.contextIdentifier, params.resources);
+}
+export async function updateContextReactor(params) {
+    "use step";
+    const { runtime } = await getRuntimeAndEnv(params);
+    return await runtime.store.updateContextReactor(params.contextIdentifier, params.reactor);
+}
+export async function updateContextStatus(params) {
+    "use step";
+    const { runtime } = await getRuntimeAndEnv(params);
+    await runtime.store.updateContextStatus(params.contextIdentifier, params.status);
+}
+export async function saveTriggerItem(params) {
+    "use step";
+    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 { getContextRuntime } = await import("../runtime.js");
-    const runtime = await getContextRuntime(params.env);
+    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,
@@ -168,7 +184,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),
@@ -200,7 +216,7 @@ export async function saveTriggerAndCreateExecution(params) {
         });
     }
     catch (error) {
-        logStepDebug("saveTriggerAndCreateExecution:saveReaction:error", {
+        logStepDebug("openExecution:saveReaction:error", {
             contextIdentifier: summarizeContextIdentifierForLog(params.contextIdentifier),
             reactionEventId,
             error: summarizeStepError(error),
@@ -212,7 +228,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,
@@ -231,7 +247,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,
@@ -241,7 +257,7 @@ export async function saveTriggerAndCreateExecution(params) {
         throw error;
     }
     const { runId, meta } = await resolveWorkflowRunId({
-        env: params.env,
+        env,
         db,
         executionId: execution.id,
     });
@@ -329,7 +345,7 @@ export async function saveTriggerAndCreateExecution(params) {
                 },
             },
         ];
-        await maybeWriteTraceEvents(params.env, events);
+        await maybeWriteTraceEvents(env, events);
     }
     return {
         triggerEvent: saved,
@@ -340,26 +356,25 @@ export async function saveTriggerAndCreateExecution(params) {
         },
     };
 }
-export async function saveReactionItem(env, contextIdentifier, event, opts) {
+export async function saveReactionItem(params) {
     "use step";
-    const { getContextRuntime } = await import("../runtime.js");
-    const runtime = await getContextRuntime(env);
+    const { runtime, env } = await getRuntimeAndEnv(params);
     const { store, db } = runtime;
-    const saved = await store.saveItem(contextIdentifier, event);
-    if (opts?.executionId) {
+    const saved = await store.saveItem(params.contextIdentifier, params.event);
+    if (params.opts?.executionId) {
         await store.linkItemToExecution({
             itemId: saved.id,
-            executionId: opts.executionId,
+            executionId: params.opts.executionId,
         });
     }
-    const contextId = opts?.contextId ??
-        (typeof contextIdentifier?.id === "string"
-            ? String(contextIdentifier.id)
+    const contextId = params.opts?.contextId ??
+        (typeof params.contextIdentifier?.id === "string"
+            ? String(params.contextIdentifier.id)
             : undefined);
     const { runId, meta } = await resolveWorkflowRunId({
         env,
         db,
-        executionId: opts?.executionId,
+        executionId: params.opts?.executionId,
     });
     if (runId) {
         const events = [
@@ -369,7 +384,7 @@ export async function saveReactionItem(env, contextIdentifier, event, opts) {
                 eventKind: "context.item",
                 eventAt: new Date().toISOString(),
                 contextId,
-                executionId: opts?.executionId,
+                executionId: params.opts?.executionId,
                 contextEventId: String(saved.id),
                 payload: {
                     ...saved,
@@ -377,30 +392,30 @@ export async function saveReactionItem(env, contextIdentifier, event, opts) {
                 },
             },
         ];
-        if (opts?.executionId && opts.reviewRequests?.length) {
+        if (params.opts?.executionId && params.opts.reviewRequests?.length) {
             const resumeHookUrl = getClientResumeHookUrl();
             const workflowUrl = meta && typeof meta.url === "string" && meta.url.trim()
                 ? String(meta.url)
                 : undefined;
-            for (const rr of opts.reviewRequests) {
+            for (const rr of params.opts.reviewRequests) {
                 const toolCallId = String(rr.toolCallId);
                 events.push({
                     workflowRunId: runId,
-                    eventId: `context_review:${String(opts.executionId)}:${toolCallId}`,
+                    eventId: `context_review:${String(params.opts.executionId)}:${toolCallId}`,
                     eventKind: "context.review",
                     eventAt: new Date().toISOString(),
                     contextId,
-                    executionId: String(opts.executionId),
+                    executionId: String(params.opts.executionId),
                     toolCallId,
                     payload: {
                         status: "in_review",
                         toolName: rr.toolName ?? "",
                         hookToken: toolApprovalHookToken({
-                            executionId: String(opts.executionId),
+                            executionId: String(params.opts.executionId),
                             toolCallId,
                         }),
                         webhookToken: toolApprovalWebhookToken({
-                            executionId: String(opts.executionId),
+                            executionId: String(params.opts.executionId),
                             toolCallId,
                         }),
                         resumeHookUrl,
@@ -413,16 +428,20 @@ export async function saveReactionItem(env, contextIdentifier, event, opts) {
     }
     return saved;
 }
-export async function updateItem(env, eventId, event, opts) {
+export async function getContextItems(params) {
+    "use step";
+    const { runtime } = await getRuntimeAndEnv(params);
+    return await runtime.store.getItems(params.contextIdentifier);
+}
+export async function updateItem(params) {
     "use step";
-    const { getContextRuntime } = await import("../runtime.js");
-    const runtime = await getContextRuntime(env);
+    const { runtime, env } = await getRuntimeAndEnv(params);
     const { store, db } = runtime;
-    const saved = await store.updateItem(eventId, event);
+    const saved = await store.updateItem(params.eventId, params.event);
     const { runId } = await resolveWorkflowRunId({
         env,
         db,
-        executionId: opts?.executionId,
+        executionId: params.opts?.executionId,
     });
     if (runId) {
         await maybeWriteTraceEvents(env, [
@@ -431,8 +450,8 @@ export async function updateItem(env, eventId, event, opts) {
                 eventId: `context_item:${String(saved.id)}`,
                 eventKind: "context.item",
                 eventAt: new Date().toISOString(),
-                contextId: opts?.contextId,
-                executionId: opts?.executionId,
+                contextId: params.opts?.contextId,
+                executionId: params.opts?.executionId,
                 contextEventId: String(saved.id),
                 payload: {
                     ...saved,
@@ -443,16 +462,15 @@ export async function updateItem(env, eventId, event, opts) {
     }
     return saved;
 }
-export async function createExecution(env, contextIdentifier, triggerEventId, reactionEventId) {
+export async function createExecution(params) {
     "use step";
-    const { getContextRuntime } = await import("../runtime.js");
-    const { store } = await getContextRuntime(env);
-    return await store.createExecution(contextIdentifier, triggerEventId, reactionEventId);
+    const { runtime } = await getRuntimeAndEnv(params);
+    return await runtime.store.createExecution(params.contextIdentifier, params.triggerEventId, params.reactionEventId);
 }
 export async function createReactionItem(params) {
     "use step";
-    const { getContextRuntime } = await import("../runtime.js");
-    const { store } = await getContextRuntime(params.env);
+    const { runtime } = await getRuntimeAndEnv(params);
+    const { store } = runtime;
     // Generate a new reaction event id inside the step boundary.
     const uuid = globalThis.crypto?.randomUUID?.();
     const reactionEventId = typeof uuid === "string"
@@ -461,41 +479,62 @@ export async function createReactionItem(params) {
     const execution = await store.createExecution(params.contextIdentifier, params.triggerEventId, reactionEventId);
     return { reactionEventId, executionId: execution.id };
 }
-export async function completeExecution(env, contextIdentifier, executionId, status) {
+export async function completeExecution(params) {
     "use step";
-    const { getContextRuntime } = await import("../runtime.js");
-    const runtime = await getContextRuntime(env);
+    const { runtime, env } = await getRuntimeAndEnv(params);
     const { store, db } = runtime;
-    await store.completeExecution(contextIdentifier, executionId, status);
-    const contextId = typeof contextIdentifier?.id === "string"
-        ? String(contextIdentifier.id)
-        : undefined;
+    await store.completeExecution(params.contextIdentifier, params.executionId, params.status);
+    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,
+        executionId: params.executionId,
     });
     if (runId) {
-        await maybeWriteTraceEvents(env, [
+        const events = [
             {
                 workflowRunId: runId,
-                eventId: `context_execution:${String(executionId)}:${status}`,
+                eventId: `context_execution:${String(params.executionId)}:${params.status}`,
                 eventKind: "context.execution",
                 eventAt: new Date().toISOString(),
                 contextId,
-                executionId: String(executionId),
+                executionId: String(params.executionId),
                 payload: {
-                    status,
+                    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";
-    const { getContextRuntime } = await import("../runtime.js");
-    const runtime = await getContextRuntime(params.env);
-    const db = runtime?.db;
+    const { runtime } = await getRuntimeAndEnv(params);
+    const db = runtime.db;
     if (db) {
         await db.transact([
             db.tx.event_executions[params.executionId].update({
@@ -505,10 +544,31 @@ export async function updateExecutionWorkflowRun(params) {
         ]);
     }
 }
+export async function openExecutionStep(params) {
+    "use step";
+    const { runtime } = await getRuntimeAndEnv(params);
+    const { store } = runtime;
+    const step = await store.createStep({
+        executionId: params.executionId,
+        iteration: params.iteration,
+    });
+    const stream = await createPersistedContextStepStreamForRuntime(runtime, {
+        executionId: params.executionId,
+        stepId: step.id,
+    });
+    const context = await store.updateContextContent(params.contextIdentifier, params.content);
+    const events = await store.getItems(params.contextIdentifier);
+    return {
+        stepId: step.id,
+        stream,
+        context,
+        events,
+    };
+}
 export async function createContextStep(params) {
     "use step";
-    const { getContextRuntime } = await import("../runtime.js");
-    const { store } = await getContextRuntime(params.env);
+    const { runtime } = await getRuntimeAndEnv(params);
+    const { store } = runtime;
     const res = await store.createStep({
         executionId: params.executionId,
         iteration: params.iteration,
@@ -517,20 +577,19 @@ export async function createContextStep(params) {
 }
 export async function updateContextStep(params) {
     "use step";
-    const { getContextRuntime } = await import("../runtime.js");
-    const runtime = await getContextRuntime(params.env);
+    const { runtime, env } = await getRuntimeAndEnv(params);
     const { store, db } = runtime;
     await store.updateStep(params.stepId, {
         ...params.patch,
         updatedAt: new Date(),
     });
     const { runId } = await resolveWorkflowRunId({
-        env: params.env,
+        env,
         db,
         executionId: params.executionId,
     });
     if (runId) {
-        await maybeWriteTraceEvents(params.env, [
+        await maybeWriteTraceEvents(env, [
             {
                 workflowRunId: runId,
                 eventId: `context_step:${String(params.stepId)}`,
@@ -541,55 +600,151 @@ export async function updateContextStep(params) {
                 stepId: String(params.stepId),
                 payload: {
                     status: params.patch.status,
-                    kind: params.patch.kind,
-                    actionName: params.patch.actionName,
-                    actionInput: params.patch.actionInput,
-                    actionOutput: params.patch.actionOutput,
-                    actionError: params.patch.actionError,
                     iteration: params.iteration,
-                    actionRequests: params.patch.actionRequests,
-                    actionResults: params.patch.actionResults,
-                    continueLoop: params.patch.continueLoop,
                     errorText: params.patch.errorText,
                 },
             },
         ]);
     }
 }
-export async function linkItemToExecutionStep(params) {
-    "use step";
-    const { getContextRuntime } = await import("../runtime.js");
-    const { store } = await getContextRuntime(params.env);
-    await store.linkItemToExecution({ itemId: params.itemId, executionId: params.executionId });
-}
-export async function saveContextPartsStep(params) {
+export async function completeExecutionStep(params) {
     "use step";
-    const { getContextRuntime } = await import("../runtime.js");
-    const runtime = await getContextRuntime(params.env);
+    const { runtime, env } = await getRuntimeAndEnv(params);
     const { store, db } = runtime;
-    await store.saveStepParts({ stepId: params.stepId, parts: params.parts });
+    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,
+            session: params.session,
+            mode: "close",
+        });
+    }
+    await store.updateStep(params.stepId, {
+        status: params.stepStatus ?? "completed",
+        ...(params.errorText !== undefined ? { errorText: params.errorText } : {}),
+        updatedAt: new Date(),
+    });
+    let savedReaction;
+    if (params.reactionEventId && params.reactionEvent) {
+        savedReaction = await store.updateItem(params.reactionEventId, params.reactionEvent);
+    }
     const { runId } = await resolveWorkflowRunId({
-        env: params.env,
+        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({
+    if (runId) {
+        const events = [
+            {
                 workflowRunId: runId,
-                eventId: `context_part:${String(params.stepId)}:${idx}`,
-                eventKind: "context.part",
+                eventId: `context_step:${String(params.stepId)}`,
+                eventKind: "context.step",
                 eventAt: new Date().toISOString(),
                 contextId: params.contextId,
                 executionId: params.executionId,
                 stepId: String(params.stepId),
-                partKey: `${String(params.stepId)}:${idx}`,
-                partIdx: idx,
-                payload: part,
+                payload: {
+                    status: params.stepStatus ?? "completed",
+                    iteration: params.iteration,
+                    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,
+                eventId: `context_item:${String(savedReaction.id)}`,
+                eventKind: "context.item",
+                eventAt: new Date().toISOString(),
+                contextId: params.contextId,
+                executionId: params.executionId,
+                contextEventId: String(savedReaction.id),
+                payload: {
+                    ...savedReaction,
+                    direction: inferDirection(savedReaction),
+                },
             });
         }
-        await maybeWriteTraceEvents(params.env, events);
+        await maybeWriteTraceEvents(env, events);
+    }
+    return { reactionEvent: savedReaction, actionResultChunkEvents };
+}
+export async function linkItemToExecutionStep(params) {
+    "use step";
+    const { runtime } = await getRuntimeAndEnv(params);
+    const { store } = runtime;
+    await store.linkItemToExecution({ itemId: params.itemId, executionId: params.executionId });
+}
+export async function saveExecutionStepOutput(params) {
+    "use step";
+    const { runtime, env } = await getRuntimeAndEnv(params);
+    const { store, db } = runtime;
+    await store.saveStepParts({ stepId: params.stepId, parts: params.parts });
+    const savedReaction = await store.updateItem(params.reactionEventId, params.reactionEvent);
+    const { runId } = await resolveWorkflowRunId({
+        env,
+        db,
+        executionId: params.executionId,
+    });
+    if (runId) {
+        const events = [];
+        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,
+                });
+            }
+        }
+        events.push({
+            workflowRunId: runId,
+            eventId: `context_item:${String(savedReaction.id)}`,
+            eventKind: "context.item",
+            eventAt: new Date().toISOString(),
+            contextId: params.contextId,
+            executionId: params.executionId,
+            contextEventId: String(savedReaction.id),
+            payload: {
+                ...savedReaction,
+                direction: inferDirection(savedReaction),
+            },
+        });
+        await maybeWriteTraceEvents(env, events);
     }
+    return { reactionEvent: savedReaction };
 }

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

@@ -1,5 +1,6 @@
 import type { UIMessageChunk } from "ai";
 import type { ContextEnvironment } from "../context.config.js";
+import type { ContextRuntime } from "../context.runtime.js";
 import { type ContextStepStreamChunk } from "../context.step-stream.js";
 import type { ContextStreamEvent } from "../context.stream.js";
 export declare function writeContextEvents(params: {
@@ -19,21 +20,53 @@ export type PersistedContextStepStreamSession = {
     executionId: string;
     stepId: string;
 };
+export declare function createPersistedContextStepStreamForRuntime(runtime: {
+    db?: any;
+}, params: {
+    executionId: string;
+    stepId: string;
+    clientId?: string;
+}): Promise<PersistedContextStepStreamSession>;
 export declare function createPersistedContextStepStream(params: {
-    env: ContextEnvironment;
+    runtime: ContextRuntime<ContextEnvironment>;
     executionId: string;
     stepId: string;
     clientId?: string;
 }): Promise<PersistedContextStepStreamSession>;
+export declare function finalizePersistedContextStepStreamForRuntime(params: {
+    runtime: {
+        db?: any;
+    };
+    session: PersistedContextStepStreamSession;
+    mode: "close" | "abort";
+    abortReason?: string | null;
+}): Promise<void>;
 export declare function closePersistedContextStepStream(params: {
-    env: ContextEnvironment;
+    runtime: ContextRuntime<ContextEnvironment>;
     session: PersistedContextStepStreamSession;
 }): Promise<void>;
 export declare function abortPersistedContextStepStream(params: {
-    env: ContextEnvironment;
+    runtime: ContextRuntime<ContextEnvironment>;
     session: PersistedContextStepStreamSession;
     reason?: string | null;
 }): Promise<void>;
+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: ContextActionResultForStream[];
+}): Promise<ContextStreamEvent[]>;
 export declare function readPersistedContextStepStream(params: {
     db: any;
     clientId?: string;