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

package/dist/schema.d.ts

@@ -1,2 +1,268 @@
-import { type DomainSchemaResult } from "@ekairos/domain";
-export declare const eventsDomain: DomainSchemaResult;
+export declare const eventsDomain: import("@ekairos/domain").DomainSchemaResult<{
+    event_contexts: import("@instantdb/core").EntityDef<{
+        createdAt: import("@instantdb/core").DataAttrDef<Date, true, false, false>;
+        updatedAt: import("@instantdb/core").DataAttrDef<Date, false, false, false>;
+        key: import("@instantdb/core").DataAttrDef<string, false, true, true>;
+        name: import("@instantdb/core").DataAttrDef<string, false, false, false>;
+        status: import("@instantdb/core").DataAttrDef<string, false, true, false>;
+        content: import("@instantdb/core").DataAttrDef<any, false, false, false>;
+        description: import("@instantdb/core").DataAttrDef<string, false, false, false>;
+        goal: import("@instantdb/core").DataAttrDef<string, false, false, false>;
+        resources: import("@instantdb/core").DataAttrDef<any, false, false, false>;
+        reactor: import("@instantdb/core").DataAttrDef<any, false, false, false>;
+    }, {}, unknown>;
+    event_items: import("@instantdb/core").EntityDef<{
+        channel: import("@instantdb/core").DataAttrDef<string, true, true, false>;
+        createdAt: import("@instantdb/core").DataAttrDef<Date, true, true, false>;
+        type: import("@instantdb/core").DataAttrDef<string, false, true, false>;
+        content: import("@instantdb/core").DataAttrDef<any, false, false, false>;
+        status: import("@instantdb/core").DataAttrDef<string, false, true, false>;
+    }, {}, unknown>;
+    event_executions: import("@instantdb/core").EntityDef<{
+        createdAt: import("@instantdb/core").DataAttrDef<Date, true, false, false>;
+        updatedAt: import("@instantdb/core").DataAttrDef<Date, false, false, false>;
+        status: import("@instantdb/core").DataAttrDef<string, false, true, false>;
+        workflowRunId: import("@instantdb/core").DataAttrDef<string, false, true, false>;
+        activeStreamId: import("@instantdb/core").DataAttrDef<string, false, true, false>;
+        activeStreamClientId: import("@instantdb/core").DataAttrDef<string, false, true, false>;
+        lastStreamId: import("@instantdb/core").DataAttrDef<string, false, true, false>;
+        lastStreamClientId: import("@instantdb/core").DataAttrDef<string, false, true, false>;
+    }, {}, unknown>;
+    event_steps: import("@instantdb/core").EntityDef<{
+        createdAt: import("@instantdb/core").DataAttrDef<Date, true, true, false>;
+        updatedAt: import("@instantdb/core").DataAttrDef<Date, false, false, false>;
+        status: import("@instantdb/core").DataAttrDef<string, false, true, false>;
+        iteration: import("@instantdb/core").DataAttrDef<number, true, true, false>;
+        errorText: import("@instantdb/core").DataAttrDef<string, false, false, false>;
+        streamId: import("@instantdb/core").DataAttrDef<string, false, true, false>;
+        streamClientId: import("@instantdb/core").DataAttrDef<string, false, true, false>;
+        streamStartedAt: import("@instantdb/core").DataAttrDef<Date, false, true, false>;
+        streamFinishedAt: import("@instantdb/core").DataAttrDef<Date, false, true, false>;
+        streamAbortReason: import("@instantdb/core").DataAttrDef<string, false, false, false>;
+    }, {}, unknown>;
+    event_parts: import("@instantdb/core").EntityDef<{
+        key: import("@instantdb/core").DataAttrDef<string, true, true, true>;
+        stepId: import("@instantdb/core").DataAttrDef<string, true, true, false>;
+        idx: import("@instantdb/core").DataAttrDef<number, true, true, false>;
+        type: import("@instantdb/core").DataAttrDef<string, false, true, false>;
+        part: import("@instantdb/core").DataAttrDef<any, false, false, false>;
+        metadata: import("@instantdb/core").DataAttrDef<any, false, false, false>;
+        updatedAt: import("@instantdb/core").DataAttrDef<Date, false, false, false>;
+    }, {}, unknown>;
+    event_trace_events: import("@instantdb/core").EntityDef<{
+        key: import("@instantdb/core").DataAttrDef<string, true, true, true>;
+        workflowRunId: import("@instantdb/core").DataAttrDef<string, true, true, false>;
+        seq: import("@instantdb/core").DataAttrDef<number, true, true, false>;
+        eventId: import("@instantdb/core").DataAttrDef<string, true, true, false>;
+        eventKind: import("@instantdb/core").DataAttrDef<string, true, true, false>;
+        eventAt: import("@instantdb/core").DataAttrDef<Date, false, false, false>;
+        ingestedAt: import("@instantdb/core").DataAttrDef<Date, false, false, false>;
+        orgId: import("@instantdb/core").DataAttrDef<string, false, true, false>;
+        projectId: import("@instantdb/core").DataAttrDef<string, false, true, false>;
+        contextKey: import("@instantdb/core").DataAttrDef<string, false, true, false>;
+        contextId: import("@instantdb/core").DataAttrDef<string, false, true, false>;
+        executionId: import("@instantdb/core").DataAttrDef<string, false, true, false>;
+        stepId: import("@instantdb/core").DataAttrDef<string, false, true, false>;
+        contextEventId: import("@instantdb/core").DataAttrDef<string, false, true, false>;
+        toolCallId: import("@instantdb/core").DataAttrDef<string, false, true, false>;
+        partKey: import("@instantdb/core").DataAttrDef<string, false, true, false>;
+        partIdx: import("@instantdb/core").DataAttrDef<number, false, true, false>;
+        spanId: import("@instantdb/core").DataAttrDef<string, false, true, false>;
+        parentSpanId: import("@instantdb/core").DataAttrDef<string, false, true, false>;
+        isDeleted: import("@instantdb/core").DataAttrDef<boolean, false, false, false>;
+        aiProvider: import("@instantdb/core").DataAttrDef<string, false, true, false>;
+        aiModel: import("@instantdb/core").DataAttrDef<string, false, true, false>;
+        promptTokens: import("@instantdb/core").DataAttrDef<number, false, false, false>;
+        promptTokensCached: import("@instantdb/core").DataAttrDef<number, false, false, false>;
+        promptTokensUncached: import("@instantdb/core").DataAttrDef<number, false, false, false>;
+        completionTokens: import("@instantdb/core").DataAttrDef<number, false, false, false>;
+        totalTokens: import("@instantdb/core").DataAttrDef<number, false, false, false>;
+        latencyMs: import("@instantdb/core").DataAttrDef<number, false, false, false>;
+        cacheCostUsd: import("@instantdb/core").DataAttrDef<number, false, false, false>;
+        computeCostUsd: import("@instantdb/core").DataAttrDef<number, false, false, false>;
+        costUsd: import("@instantdb/core").DataAttrDef<number, false, false, false>;
+        payload: import("@instantdb/core").DataAttrDef<any, false, false, false>;
+    }, {}, unknown>;
+    event_trace_runs: import("@instantdb/core").EntityDef<{
+        workflowRunId: import("@instantdb/core").DataAttrDef<string, true, true, true>;
+        orgId: import("@instantdb/core").DataAttrDef<string, false, true, false>;
+        projectId: import("@instantdb/core").DataAttrDef<string, false, true, false>;
+        firstEventAt: import("@instantdb/core").DataAttrDef<Date, false, true, false>;
+        lastEventAt: import("@instantdb/core").DataAttrDef<Date, false, true, false>;
+        lastIngestedAt: import("@instantdb/core").DataAttrDef<Date, false, true, false>;
+        eventsCount: import("@instantdb/core").DataAttrDef<number, false, false, false>;
+        status: import("@instantdb/core").DataAttrDef<string, false, true, false>;
+        payload: import("@instantdb/core").DataAttrDef<any, false, false, false>;
+    }, {}, unknown>;
+    event_trace_spans: import("@instantdb/core").EntityDef<{
+        spanId: import("@instantdb/core").DataAttrDef<string, true, true, true>;
+        parentSpanId: import("@instantdb/core").DataAttrDef<string, false, true, false>;
+        workflowRunId: import("@instantdb/core").DataAttrDef<string, true, true, false>;
+        executionId: import("@instantdb/core").DataAttrDef<string, false, true, false>;
+        stepId: import("@instantdb/core").DataAttrDef<string, false, true, false>;
+        kind: import("@instantdb/core").DataAttrDef<string, false, true, false>;
+        name: import("@instantdb/core").DataAttrDef<string, false, true, false>;
+        status: import("@instantdb/core").DataAttrDef<string, false, true, false>;
+        startedAt: import("@instantdb/core").DataAttrDef<Date, false, true, false>;
+        endedAt: import("@instantdb/core").DataAttrDef<Date, false, true, false>;
+        durationMs: import("@instantdb/core").DataAttrDef<number, false, false, false>;
+        payload: import("@instantdb/core").DataAttrDef<any, false, false, false>;
+    }, {}, unknown>;
+    document_documents: import("@instantdb/core").EntityDef<{
+        name: import("@instantdb/core").DataAttrDef<string, false, true, false>;
+        mimeType: import("@instantdb/core").DataAttrDef<string, false, false, false>;
+        size: import("@instantdb/core").DataAttrDef<number, false, false, false>;
+        ownerId: import("@instantdb/core").DataAttrDef<string, false, true, false>;
+        orgId: import("@instantdb/core").DataAttrDef<string, false, true, false>;
+        createdAt: import("@instantdb/core").DataAttrDef<Date, false, true, false>;
+        processedAt: import("@instantdb/core").DataAttrDef<Date, false, true, false>;
+        updatedAt: import("@instantdb/core").DataAttrDef<Date, false, false, false>;
+        lastJobId: import("@instantdb/core").DataAttrDef<string, false, false, false>;
+        content: import("@instantdb/core").DataAttrDef<any, false, false, false>;
+    }, {}, unknown>;
+}, {
+    contextItemsContext: {
+        readonly forward: {
+            readonly on: "event_items";
+            readonly has: "one";
+            readonly label: "context";
+        };
+        readonly reverse: {
+            readonly on: "event_contexts";
+            readonly has: "many";
+            readonly label: "items";
+        };
+    };
+    contextExecutionsContext: {
+        readonly forward: {
+            readonly on: "event_executions";
+            readonly has: "one";
+            readonly label: "context";
+        };
+        readonly reverse: {
+            readonly on: "event_contexts";
+            readonly has: "many";
+            readonly label: "executions";
+        };
+    };
+    contextCurrentExecution: {
+        readonly forward: {
+            readonly on: "event_contexts";
+            readonly has: "one";
+            readonly label: "currentExecution";
+        };
+        readonly reverse: {
+            readonly on: "event_executions";
+            readonly has: "one";
+            readonly label: "currentOf";
+        };
+    };
+    contextExecutionsTrigger: {
+        readonly forward: {
+            readonly on: "event_executions";
+            readonly has: "one";
+            readonly label: "trigger";
+        };
+        readonly reverse: {
+            readonly on: "event_items";
+            readonly has: "many";
+            readonly label: "executionsAsTrigger";
+        };
+    };
+    contextExecutionsReaction: {
+        readonly forward: {
+            readonly on: "event_executions";
+            readonly has: "one";
+            readonly label: "reaction";
+        };
+        readonly reverse: {
+            readonly on: "event_items";
+            readonly has: "many";
+            readonly label: "executionsAsReaction";
+        };
+    };
+    contextStepsExecution: {
+        readonly forward: {
+            readonly on: "event_steps";
+            readonly has: "one";
+            readonly label: "execution";
+        };
+        readonly reverse: {
+            readonly on: "event_executions";
+            readonly has: "many";
+            readonly label: "steps";
+        };
+    };
+    contextExecutionItems: {
+        readonly forward: {
+            readonly on: "event_items";
+            readonly has: "one";
+            readonly label: "execution";
+        };
+        readonly reverse: {
+            readonly on: "event_executions";
+            readonly has: "many";
+            readonly label: "items";
+        };
+    };
+    contextPartsStep: {
+        readonly forward: {
+            readonly on: "event_parts";
+            readonly has: "one";
+            readonly label: "step";
+        };
+        readonly reverse: {
+            readonly on: "event_steps";
+            readonly has: "many";
+            readonly label: "parts";
+        };
+    };
+    contextStepStream: {
+        readonly forward: {
+            readonly on: "event_steps";
+            readonly has: "one";
+            readonly label: "stream";
+        };
+        readonly reverse: {
+            readonly on: "$streams";
+            readonly has: "many";
+            readonly label: "step";
+        };
+    };
+    contextExecutionActiveStream: {
+        readonly forward: {
+            readonly on: "event_executions";
+            readonly has: "one";
+            readonly label: "activeStream";
+        };
+        readonly reverse: {
+            readonly on: "$streams";
+            readonly has: "many";
+            readonly label: "activeOf";
+        };
+    };
+    contextExecutionLastStream: {
+        readonly forward: {
+            readonly on: "event_executions";
+            readonly has: "one";
+            readonly label: "lastStream";
+        };
+        readonly reverse: {
+            readonly on: "$streams";
+            readonly has: "many";
+            readonly label: "lastOf";
+        };
+    };
+    documentFile: {
+        readonly forward: {
+            readonly on: "document_documents";
+            readonly has: "one";
+            readonly label: "file";
+        };
+        readonly reverse: {
+            readonly on: "$files";
+            readonly has: "one";
+            readonly label: "document";
+        };
+    };
+}, import("@instantdb/core").RoomsDef, {}, "events", "events">;

package/dist/schema.js

@@ -1,7 +1,7 @@
 import { i } from "@instantdb/core";
 import { domain } from "@ekairos/domain";
 export const eventsDomain = domain("events")
-    .schema({
+    .withSchema({
     entities: {
         event_contexts: i.entity({
             createdAt: i.date(),
@@ -10,6 +10,10 @@ export const eventsDomain = domain("events")
             name: i.string().optional(),
             status: i.string().optional().indexed(), // open_idle | open_streaming | closed
             content: i.any().optional(),
+            description: i.string().optional(),
+            goal: i.string().optional(),
+            resources: i.any().optional(),
+            reactor: i.json().optional(),
         }),
         event_items: i.entity({
             channel: i.string().indexed(),
@@ -33,14 +37,6 @@ export const eventsDomain = domain("events")
             updatedAt: i.date().optional(),
             status: i.string().optional().indexed(), // running | completed | failed
             iteration: i.number().indexed(),
-            kind: i.string().optional().indexed(), // message | action_execute | action_result
-            actionName: i.string().optional().indexed(),
-            actionInput: i.any().optional(),
-            actionOutput: i.any().optional(),
-            actionError: i.string().optional(),
-            actionRequests: i.any().optional(),
-            actionResults: i.any().optional(),
-            continueLoop: i.boolean().optional(),
             errorText: i.string().optional(),
             streamId: i.string().optional().indexed(),
             streamClientId: i.string().optional().indexed(),

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

@@ -1,6 +1,6 @@
 import type { ModelMessage } from "ai";
 import type { ContextItem } from "../context.store.js";
-import type { SerializableToolForModel } from "../tools-to-model-tools.js";
+import { type SerializableActionSpec } from "../tools-to-model-tools.js";
 import type { ContextModelInit } from "../context.engine.js";
 /**
  * Runs a single LLM streaming step as a Workflow step.
@@ -13,7 +13,7 @@ export declare function doContextStreamStep(params: {
     model: ContextModelInit;
     system: string;
     messages: ModelMessage[];
-    tools: Record<string, SerializableToolForModel>;
+    tools: Record<string, SerializableActionSpec>;
     eventId: string;
     maxSteps: number;
     /**

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

@@ -1,4 +1,5 @@
 import { OUTPUT_ITEM_TYPE } from "../context.events.js";
+import { actionSpecToAiSdkTool, } from "../tools-to-model-tools.js";
 /**
  * Runs a single LLM streaming step as a Workflow step.
  *
@@ -11,7 +12,7 @@ export async function doContextStreamStep(params) {
     const { getWritable } = await import("workflow");
     const writable = getWritable();
     const { jsonSchema, gateway, smoothStream, stepCountIs, streamText } = await import("ai");
-    const { extractToolCallsFromParts } = await import("../context.toolcalls.js");
+    const { extractActionCallsFromParts } = await import("../context.action-calls.js");
     // Match DurableAgent's model init behavior:
     // - string => AI Gateway model id, resolved via `gateway(...)` in the step runtime
     // - function => model factory (should be a `"use step"` function for workflow serialization)
@@ -28,10 +29,7 @@ export async function doContextStreamStep(params) {
     // `jsonSchema(...)` so the AI SDK does not attempt Zod conversion at runtime.
     const toolsForStreamText = {};
     for (const [name, t] of Object.entries(params.tools)) {
-        toolsForStreamText[name] = {
-            description: t?.description,
-            inputSchema: jsonSchema(t.inputSchema),
-        };
+        toolsForStreamText[name] = actionSpecToAiSdkTool(name, t, jsonSchema);
     }
     const result = streamText({
         model: resolvedModel,
@@ -84,9 +82,9 @@ export async function doContextStreamStep(params) {
     }));
     await uiStream.pipeTo(writable, { preventClose: true });
     const assistantEvent = await finishPromise;
-    const actionRequests = extractToolCallsFromParts(assistantEvent?.content?.parts).map((entry) => ({
-        actionRef: String(entry.toolCallId),
-        actionName: String(entry.toolName),
+    const actionRequests = extractActionCallsFromParts(assistantEvent?.content?.parts).map((entry) => ({
+        actionRef: String(entry.actionCallId),
+        actionName: String(entry.actionName),
         input: entry.args,
     }));
     return {

package/dist/steps/durable.steps.d.ts

@@ -0,0 +1,28 @@
+import type { ContextDurableWorkflowPayload, ContextReactFinalResult } from "../context.engine.js";
+export type ContextDurableWorkflowStatus = "pending" | "running" | "completed" | "failed" | "cancelled";
+export type ContextReturnValueHookPayload<Context = any> = {
+    ok: true;
+    result: ContextReactFinalResult<Context>;
+} | {
+    ok: false;
+    error: {
+        name?: string;
+        message: string;
+        stack?: string;
+    };
+};
+export declare function startContextDurableWorkflow(params: {
+    payload: ContextDurableWorkflowPayload<any, any, any>;
+}): Promise<{
+    runId: string;
+}>;
+export declare function readContextDurableWorkflowStatus(params: {
+    runId: string;
+}): Promise<ContextDurableWorkflowStatus>;
+export declare function readContextDurableWorkflowReturnValue(params: {
+    runId: string;
+}): Promise<ContextReactFinalResult<any>>;
+export declare function resumeContextReturnValueHook(params: {
+    token: string;
+    payload: ContextReturnValueHookPayload;
+}): Promise<void>;

package/dist/steps/durable.steps.js

@@ -0,0 +1,34 @@
+import { getContextDurableWorkflow } from "../context.durable.js";
+export async function startContextDurableWorkflow(params) {
+    "use step";
+    const workflow = getContextDurableWorkflow();
+    if (typeof workflow !== "function") {
+        const contextKey = String(params.payload.contextKey || "(missing)");
+        throw new Error([
+            "ContextEngine.react(..., { durable: true }) needs a registered durable context workflow.",
+            "Call configureContextDurableWorkflow(contextDurableWorkflow) during server/workflow bootstrap.",
+            "If you want inline execution inside the current workflow step, pass durable: false.",
+            `Context key: ${contextKey}.`,
+        ].join(" "));
+    }
+    const { start } = await import("workflow/api");
+    const run = await start(workflow, [params.payload]);
+    return { runId: String(run.runId) };
+}
+export async function readContextDurableWorkflowStatus(params) {
+    "use step";
+    const { getRun } = await import("workflow/api");
+    const run = getRun(params.runId);
+    return (await run.status);
+}
+export async function readContextDurableWorkflowReturnValue(params) {
+    "use step";
+    const { getRun } = await import("workflow/api");
+    const run = getRun(params.runId);
+    return (await run.returnValue);
+}
+export async function resumeContextReturnValueHook(params) {
+    "use step";
+    const { resumeHook } = await import("workflow/api");
+    await resumeHook(params.token, params.payload);
+}

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

@@ -1,27 +1,62 @@
-import type { UIMessageChunk } from "ai";
 import type { ContextEnvironment } from "../context.config.js";
-import type { ContextExecution, ContextItem, ContextIdentifier, StoredContext, ContextStatus } from "../context.store.js";
+import type { ContextRuntime } from "../context.runtime.js";
+import type { ContextExecution, ContextItem, ContextIdentifier, ContextResource, StoredContextResource, StoredContext, ContextStatus } from "../context.store.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>;
+};
 export type ContextReviewRequest = {
     toolCallId: string;
     toolName?: string;
 };
+type ContextStepPatch = {
+    status?: "running" | "completed" | "failed";
+    errorText?: string;
+};
 /**
  * Initializes/ensures the story context exists.
  *
  * This is the "context init" boundary for the story engine.
  */
-export declare function initializeContext<C>(env: ContextEnvironment, contextIdentifier: ContextIdentifier | null, opts?: {
-    silent?: boolean;
-    writable?: WritableStream<UIMessageChunk>;
+export declare function initializeContext<C>(params: RuntimeParams & {
+    contextIdentifier: ContextIdentifier | null;
 }): Promise<{
     context: StoredContext<C>;
     isNew: boolean;
 }>;
-export declare function updateContextContent<C>(env: ContextEnvironment, contextIdentifier: ContextIdentifier, content: C): Promise<StoredContext<C>>;
-export declare function updateContextStatus(env: ContextEnvironment, contextIdentifier: ContextIdentifier, status: ContextStatus): Promise<void>;
-export declare function saveTriggerItem(env: ContextEnvironment, contextIdentifier: ContextIdentifier, event: ContextItem): Promise<ContextItem>;
-export declare function saveTriggerAndCreateExecution(params: {
-    env: ContextEnvironment;
+export declare function updateContextContent<C>(params: RuntimeParams & {
+    contextIdentifier: ContextIdentifier;
+    content: C;
+}): Promise<StoredContext<C>>;
+export declare function updateContextDefinition<C>(params: RuntimeParams & {
+    contextIdentifier: ContextIdentifier;
+    definition: {
+        description?: string | null;
+        goal?: string | null;
+    };
+}): Promise<StoredContext<C>>;
+export declare function upsertContextResources(params: RuntimeParams & {
+    contextIdentifier: ContextIdentifier;
+    resources: ContextResource[];
+}): Promise<StoredContextResource[]>;
+export declare function updateContextReactor<C>(params: RuntimeParams & {
+    contextIdentifier: ContextIdentifier;
+    reactor: {
+        kind: string;
+        state?: Record<string, unknown> | null;
+    };
+}): Promise<StoredContext<C>>;
+export declare function updateContextStatus(params: RuntimeParams & {
+    contextIdentifier: ContextIdentifier;
+    status: ContextStatus;
+}): Promise<void>;
+export declare function saveTriggerItem(params: RuntimeParams & {
+    contextIdentifier: ContextIdentifier;
+    event: ContextItem;
+}): Promise<ContextItem>;
+export declare function openExecution(params: {
+    runtime: ContextRuntime<ContextEnvironment>;
     contextIdentifier: ContextIdentifier;
     triggerEvent: ContextItem;
 }): Promise<{
@@ -29,68 +64,115 @@ export declare function saveTriggerAndCreateExecution(params: {
     reactionEvent: ContextItem;
     execution: ContextExecution;
 }>;
-export declare function saveReactionItem(env: ContextEnvironment, contextIdentifier: ContextIdentifier, event: ContextItem, opts?: {
-    executionId?: string;
-    contextId?: string;
-    reviewRequests?: ContextReviewRequest[];
+export declare function saveReactionItem(params: RuntimeParams & {
+    contextIdentifier: ContextIdentifier;
+    event: ContextItem;
+    opts?: {
+        executionId?: string;
+        contextId?: string;
+        reviewRequests?: ContextReviewRequest[];
+    };
 }): Promise<ContextItem>;
-export declare function updateItem(env: ContextEnvironment, eventId: string, event: ContextItem, opts?: {
-    executionId?: string;
-    contextId?: string;
+export declare function getContextItems(params: RuntimeParams & {
+    contextIdentifier: ContextIdentifier;
+}): Promise<ContextItem[]>;
+export declare function updateItem(params: RuntimeParams & {
+    eventId: string;
+    event: ContextItem;
+    opts?: {
+        executionId?: string;
+        contextId?: string;
+    };
 }): Promise<ContextItem>;
-export declare function createExecution(env: ContextEnvironment, contextIdentifier: ContextIdentifier, triggerEventId: string, reactionEventId: string): Promise<{
+export declare function createExecution(params: RuntimeParams & {
+    contextIdentifier: ContextIdentifier;
+    triggerEventId: string;
+    reactionEventId: string;
+}): Promise<{
     id: string;
 }>;
 export declare function createReactionItem(params: {
-    env: ContextEnvironment;
+    runtime: ContextRuntime<ContextEnvironment>;
     contextIdentifier: ContextIdentifier;
     triggerEventId: string;
 }): Promise<{
     reactionEventId: string;
     executionId: string;
 }>;
-export declare function completeExecution(env: ContextEnvironment, contextIdentifier: ContextIdentifier, executionId: string, status: "completed" | "failed"): Promise<void>;
+export declare function completeExecution(params: RuntimeParams & {
+    contextIdentifier: ContextIdentifier;
+    executionId: string;
+    status: "completed" | "failed";
+    contextId?: string;
+    reactionEventId?: string;
+    reactionEvent?: ContextItem;
+}): Promise<{
+    reactionEvent?: ContextItem;
+}>;
 export declare function updateExecutionWorkflowRun(params: {
-    env: ContextEnvironment;
+    runtime: ContextRuntime<ContextEnvironment>;
     executionId: string;
     workflowRunId: string;
 }): Promise<void>;
+export declare function openExecutionStep<C>(params: {
+    runtime: ContextRuntime<ContextEnvironment>;
+    contextIdentifier: ContextIdentifier;
+    content: C;
+    executionId: string;
+    iteration: number;
+}): Promise<{
+    stepId: string;
+    stream: PersistedContextStepStreamSession;
+    context: StoredContext<C>;
+    events: ContextItem[];
+}>;
 export declare function createContextStep(params: {
-    env: ContextEnvironment;
+    runtime: ContextRuntime<ContextEnvironment>;
     executionId: string;
     iteration: number;
 }): Promise<{
     stepId: string;
 }>;
 export declare function updateContextStep(params: {
-    env: ContextEnvironment;
+    runtime: ContextRuntime<ContextEnvironment>;
     stepId: string;
     executionId?: string;
     contextId?: string;
     iteration?: number;
-    patch: {
-        status?: "running" | "completed" | "failed";
-        kind?: "message" | "action_execute" | "action_result";
-        actionName?: string;
-        actionInput?: unknown;
-        actionOutput?: unknown;
-        actionError?: string;
-        actionRequests?: any;
-        actionResults?: any;
-        continueLoop?: boolean;
-        errorText?: string;
-    };
+    patch: ContextStepPatch;
 }): Promise<void>;
+export declare function completeExecutionStep(params: {
+    runtime: ContextRuntime<ContextEnvironment>;
+    session?: PersistedContextStepStreamSession | null;
+    stepId: string;
+    executionId?: string;
+    contextId?: string;
+    iteration?: number;
+    parts?: any[];
+    actionResults?: ContextActionResultForStream[];
+    stepStatus?: ContextStepPatch["status"];
+    errorText?: string;
+    reactionEventId?: string;
+    reactionEvent?: ContextItem;
+}): Promise<{
+    reactionEvent?: ContextItem;
+    actionResultChunkEvents: ContextStreamEvent[];
+}>;
 export declare function linkItemToExecutionStep(params: {
-    env: ContextEnvironment;
+    runtime: ContextRuntime<ContextEnvironment>;
     itemId: string;
     executionId: string;
 }): Promise<void>;
-export declare function saveContextPartsStep(params: {
-    env: ContextEnvironment;
+export declare function saveExecutionStepOutput(params: {
+    runtime: ContextRuntime<ContextEnvironment>;
     stepId: string;
     executionId?: string;
     contextId?: string;
     iteration?: number;
     parts: any[];
-}): Promise<void>;
+    reactionEventId: string;
+    reactionEvent: ContextItem;
+}): Promise<{
+    reactionEvent: ContextItem;
+}>;
+export {};