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

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

@@ -8,5 +8,6 @@ export type MapAiSdkChunkToContextEventParams = {
     itemId?: string;
     provider?: string;
     sequence: number;
+    actionNameByRef?: Map<string, string>;
 };
 export declare function mapAiSdkChunkToContextEvent(params: MapAiSdkChunkToContextEventParams): ChunkEmittedEvent;

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

@@ -1,3 +1,4 @@
+import { resolveContextPartChunkIdentity } from "../context.part-identity.js";
 const REDACT_KEY = /token|authorization|cookie|secret|api[_-]?key|password/i;
 function asRecord(value) {
     if (!value || typeof value !== "object")
@@ -64,7 +65,7 @@ function mapAiSdkChunkType(providerChunkType) {
             return "chunk.reasoning_end";
         case "tool-input-start":
         case "tool-call-start":
-            return "chunk.action_input_start";
+            return "chunk.action_started";
         case "tool-input-delta":
         case "tool-call-delta":
             return "chunk.action_input_delta";
@@ -72,11 +73,11 @@ function mapAiSdkChunkType(providerChunkType) {
         case "tool-input-end":
         case "tool-call":
         case "tool-call-end":
-            return "chunk.action_input_available";
+            return "chunk.action_started";
         case "tool-output-available":
-            return "chunk.action_output_available";
+            return "chunk.action_completed";
         case "tool-output-error":
-            return "chunk.action_output_error";
+            return "chunk.action_failed";
         case "source-url":
             return "chunk.source_url";
         case "source-document":
@@ -99,9 +100,15 @@ function buildNormalizedData(chunk) {
         "id",
         "text",
         "delta",
+        "inputTextDelta",
+        "outputTextDelta",
         "state",
+        "actionName",
         "toolName",
         "toolCallId",
+        "input",
+        "output",
+        "error",
         "finishReason",
         "url",
         "title",
@@ -119,12 +126,52 @@ function buildNormalizedData(chunk) {
     }
     return toJsonSafe(normalized) ?? {};
 }
+function readProviderPartId(chunk, chunkType) {
+    if (chunkType.startsWith("chunk.action_")) {
+        return readString(chunk, "toolCallId") ?? readString(chunk, "id");
+    }
+    if (chunkType.startsWith("chunk.text_") || chunkType.startsWith("chunk.reasoning_")) {
+        return readString(chunk, "id");
+    }
+    if (chunkType.startsWith("chunk.source_")) {
+        return readString(chunk, "sourceId");
+    }
+    if (chunkType === "chunk.file") {
+        return readString(chunk, "id") ?? readString(chunk, "url");
+    }
+    return undefined;
+}
 export function mapAiSdkChunkToContextEvent(params) {
     const chunk = asRecord(params.chunk);
     const providerChunkType = readString(chunk, "type") ?? "unknown";
     const chunkType = mapAiSdkChunkType(providerChunkType);
+    const providerPartId = readProviderPartId(chunk, chunkType);
+    const identity = resolveContextPartChunkIdentity({
+        stepId: params.stepId,
+        provider: params.provider ?? "ai-sdk",
+        providerPartId,
+        chunkType,
+    });
     const actionRef = readString(chunk, "toolCallId") ??
         readString(chunk, "id");
+    let data = buildNormalizedData(chunk);
+    if (chunkType.startsWith("chunk.action_") && actionRef) {
+        const observedActionName = readString(chunk, "actionName") ??
+            readString(chunk, "toolName") ??
+            readString(data, "actionName") ??
+            readString(data, "toolName");
+        if (observedActionName) {
+            params.actionNameByRef?.set(actionRef, observedActionName);
+        }
+        const knownActionName = observedActionName ?? params.actionNameByRef?.get(actionRef);
+        if (knownActionName) {
+            data = {
+                ...data,
+                actionName: readString(data, "actionName") ?? knownActionName,
+                toolName: readString(data, "toolName") ?? knownActionName,
+            };
+        }
+    }
     return {
         type: "chunk.emitted",
         at: new Date().toISOString(),
@@ -133,11 +180,15 @@ export function mapAiSdkChunkToContextEvent(params) {
         executionId: params.executionId,
         stepId: params.stepId,
         itemId: params.itemId,
+        partId: identity?.partId,
+        providerPartId: identity?.providerPartId,
+        partType: identity?.partType,
+        partSlot: identity?.partSlot,
         actionRef: chunkType.startsWith("chunk.action_") ? actionRef : undefined,
         provider: params.provider,
         providerChunkType,
         sequence: params.sequence,
-        data: buildNormalizedData(chunk),
+        data,
         raw: sanitizeRaw(chunk),
     };
 }

package/dist/reactors/ai-sdk.reactor.d.ts

@@ -1,10 +1,13 @@
 import type { ContextEnvironment } from "../context.config.js";
+import type { DomainLike } from "@ekairos/domain";
+import type { ContextRuntime, ContextRuntimeHandleForDomain } from "../context.runtime.js";
 import type { ContextModelInit } from "../context.engine.js";
 import type { ContextIdentifier, StoredContext, ContextItem } from "../context.store.js";
+import { eventsDomain } from "../schema.js";
 import type { ContextReactor } from "./types.js";
-export type CreateAiSdkReactorOptions<Context = unknown, Env extends ContextEnvironment = ContextEnvironment, Config = unknown> = {
+export type CreateAiSdkReactorOptions<Context = unknown, Env extends ContextEnvironment = ContextEnvironment, RequiredDomain extends DomainLike = typeof eventsDomain, Runtime extends ContextRuntime<Env> = ContextRuntime<Env>, Config = unknown> = {
     resolveConfig?: (params: {
-        env: Env;
+        runtime: ContextRuntimeHandleForDomain<Env, RequiredDomain>;
         context: StoredContext<Context>;
         contextIdentifier: ContextIdentifier;
         triggerEvent: ContextItem;
@@ -16,18 +19,18 @@ export type CreateAiSdkReactorOptions<Context = unknown, Env extends ContextEnvi
         iteration: number;
     }) => Promise<Config> | Config;
     selectModel?: (params: {
-        env: Env;
+        runtime: ContextRuntimeHandleForDomain<Env, RequiredDomain>;
         context: StoredContext<Context>;
         triggerEvent: ContextItem;
         baseModel: ContextModelInit;
         config: Config;
     }) => Promise<ContextModelInit> | ContextModelInit;
     selectMaxModelSteps?: (params: {
-        env: Env;
+        runtime: ContextRuntimeHandleForDomain<Env, RequiredDomain>;
         context: StoredContext<Context>;
         triggerEvent: ContextItem;
         baseMaxModelSteps: number;
         config: Config;
     }) => Promise<number> | number;
 };
-export declare function createAiSdkReactor<Context = unknown, Env extends ContextEnvironment = ContextEnvironment, Config = unknown>(options?: CreateAiSdkReactorOptions<Context, Env, Config>): ContextReactor<Context, Env>;
+export declare function createAiSdkReactor<Context = unknown, Env extends ContextEnvironment = ContextEnvironment, RequiredDomain extends DomainLike = typeof eventsDomain, Runtime extends ContextRuntime<Env> = ContextRuntime<Env>, Config = unknown>(options?: CreateAiSdkReactorOptions<Context, Env, RequiredDomain, Runtime, Config>): ContextReactor<Context, Env, RequiredDomain, Runtime>;

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

@@ -1,10 +1,11 @@
 import { executeAiSdkReaction } from "./ai-sdk.step.js";
+import { actionsToActionSpecs } from "../tools-to-model-tools.js";
 export function createAiSdkReactor(options) {
     return async (params) => {
         let config;
         if (options?.resolveConfig) {
             config = await options.resolveConfig({
-                env: params.env,
+                runtime: params.runtime,
                 context: params.context,
                 contextIdentifier: params.contextIdentifier,
                 triggerEvent: params.triggerEvent,
@@ -18,7 +19,7 @@ export function createAiSdkReactor(options) {
         }
         const model = options?.selectModel && config !== undefined
             ? await options.selectModel({
-                env: params.env,
+                runtime: params.runtime,
                 context: params.context,
                 triggerEvent: params.triggerEvent,
                 baseModel: params.model,
@@ -27,7 +28,7 @@ export function createAiSdkReactor(options) {
             : params.model;
         const maxSteps = options?.selectMaxModelSteps && config !== undefined
             ? await options.selectMaxModelSteps({
-                env: params.env,
+                runtime: params.runtime,
                 context: params.context,
                 triggerEvent: params.triggerEvent,
                 baseMaxModelSteps: params.maxModelSteps,
@@ -35,16 +36,16 @@ export function createAiSdkReactor(options) {
             })
             : params.maxModelSteps;
         const result = await executeAiSdkReaction({
-            env: params.env,
+            runtime: params.runtime,
             contextIdentifier: params.contextIdentifier,
+            events: params.events,
             model,
             system: params.systemPrompt,
-            tools: params.toolsForModel,
+            tools: actionsToActionSpecs(params.actions),
             eventId: params.eventId,
             iteration: params.iteration,
             maxSteps,
             sendStart: params.sendStart,
-            silent: params.silent,
             contextStepStream: params.contextStepStream,
             writable: params.writable,
             executionId: params.executionId,
@@ -53,9 +54,9 @@ export function createAiSdkReactor(options) {
         });
         return {
             assistantEvent: result.assistantEvent,
-            actionRequests: result.toolCalls.map((entry) => ({
-                actionRef: String(entry.toolCallId),
-                actionName: String(entry.toolName),
+            actionRequests: result.actionCalls.map((entry) => ({
+                actionRef: String(entry.actionCallId),
+                actionName: String(entry.actionName),
                 input: entry.args,
             })),
             messagesForModel: result.messagesForModel,

package/dist/reactors/ai-sdk.step.d.ts

@@ -2,7 +2,7 @@ import type { ModelMessage, UIMessageChunk } from "ai";
 import type { ContextEnvironment } from "../context.config.js";
 import type { ContextModelInit } from "../context.engine.js";
 import type { ContextItem, ContextIdentifier } from "../context.store.js";
-import type { SerializableToolForModel } from "../tools-to-model-tools.js";
+import { type SerializableActionSpec } from "../tools-to-model-tools.js";
 /**
  * AI SDK-backed reaction execution inside a single workflow step.
  *
@@ -13,17 +13,17 @@ import type { SerializableToolForModel } from "../tools-to-model-tools.js";
  * - map provider chunks to the Context stream contract
  * - emit UI chunks and persist step stream chunks
  */
-export declare function executeAiSdkReaction(params: {
-    env: ContextEnvironment;
+export declare function executeAiSdkReaction<Env extends ContextEnvironment = ContextEnvironment>(params: {
+    runtime: import("../context.runtime.js").ContextRuntimeServiceHandle;
     contextIdentifier: ContextIdentifier;
+    events?: ContextItem[];
     model: ContextModelInit;
     system: string;
-    tools: Record<string, SerializableToolForModel>;
+    tools: Record<string, SerializableActionSpec>;
     eventId: string;
     iteration?: number;
     maxSteps: number;
     sendStart?: boolean;
-    silent?: boolean;
     contextStepStream?: WritableStream<string>;
     writable?: WritableStream<UIMessageChunk>;
     executionId?: string;
@@ -31,7 +31,7 @@ export declare function executeAiSdkReaction(params: {
     stepId?: string;
 }): Promise<{
     assistantEvent: ContextItem;
-    toolCalls: any[];
+    actionCalls: any[];
     messagesForModel: ModelMessage[];
     llm?: {
         provider?: string;

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

@@ -1,6 +1,8 @@
+import { getContextRuntimeServices } from "../context.runtime.js";
 import { OUTPUT_ITEM_TYPE } from "../context.events.js";
 import { createContextStepStreamChunk, encodeContextStepStreamChunk, } from "../context.step-stream.js";
 import { mapAiSdkChunkToContextEvent } from "./ai-sdk.chunk-map.js";
+import { actionSpecToAiSdkTool, } from "../tools-to-model-tools.js";
 import { writeContextTraceEvents } from "../steps/trace.steps.js";
 async function readWorkflowMetadata() {
     try {
@@ -11,7 +13,7 @@ async function readWorkflowMetadata() {
         return null;
     }
 }
-async function resolveWorkflowRunId(env, executionId) {
+async function resolveWorkflowRunId(runtime, executionId) {
     let runId = "";
     const meta = await readWorkflowMetadata();
     if (meta && meta.workflowRunId !== undefined && meta.workflowRunId !== null) {
@@ -19,9 +21,7 @@ async function resolveWorkflowRunId(env, executionId) {
     }
     if (!runId && executionId) {
         try {
-            const { getContextRuntime } = await import("../runtime.js");
-            const runtime = await getContextRuntime(env);
-            const db = runtime?.db;
+            const db = await runtime.db();
             if (db) {
                 const q = await db.query({
                     event_executions: {
@@ -82,15 +82,16 @@ function safeErrorJson(error) {
  */
 export async function executeAiSdkReaction(params) {
     "use step";
-    const { getContextRuntime } = await import("../runtime.js");
-    const { store } = await getContextRuntime(params.env);
-    let events;
-    try {
-        events = await store.getItems(params.contextIdentifier);
-    }
-    catch (error) {
-        console.error("[ekairos/story] ai-sdk.step store.getItems failed");
-        throw error;
+    const { store } = await getContextRuntimeServices(params.runtime);
+    let events = Array.isArray(params.events) ? params.events : [];
+    if (events.length === 0) {
+        try {
+            events = await store.getItems(params.contextIdentifier);
+        }
+        catch (error) {
+            console.error("[ekairos/story] ai-sdk.step store.getItems failed");
+            throw error;
+        }
     }
     let messagesForModel;
     try {
@@ -101,7 +102,7 @@ export async function executeAiSdkReaction(params) {
         throw error;
     }
     const { jsonSchema, gateway, smoothStream, stepCountIs, streamText } = await import("ai");
-    const { extractToolCallsFromParts } = await import("../context.toolcalls.js");
+    const { extractActionCallsFromParts } = await import("../context.action-calls.js");
     const resolvedModel = typeof params.model === "string"
         ? gateway(params.model)
         : typeof params.model === "function"
@@ -111,10 +112,7 @@ export async function executeAiSdkReaction(params) {
             })();
     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 startedAtMs = Date.now();
     const result = streamText({
@@ -135,8 +133,9 @@ export async function executeAiSdkReaction(params) {
         rejectFinish = reject;
     });
     const modelId = typeof params.model === "string" ? params.model : "";
-    const mappedProvider = modelId.includes("/") ? modelId.split("/")[0] : undefined;
+    const mappedProvider = modelId.includes("/") ? modelId.split("/")[0] || "ai-sdk" : "ai-sdk";
     const contextStepStreamWriter = params.contextStepStream?.getWriter();
+    const actionNameByRef = new Map();
     try {
         const uiStream = result
             .toUIMessageStream({
@@ -175,11 +174,17 @@ export async function executeAiSdkReaction(params) {
                         itemId: params.eventId,
                         provider: mappedProvider,
                         sequence: ++chunkSequence,
+                        actionNameByRef,
                     });
                     const persistedChunk = createContextStepStreamChunk({
                         at: mapped.at,
                         sequence: mapped.sequence,
                         chunkType: mapped.chunkType,
+                        stepId: params.stepId,
+                        partId: mapped.partId,
+                        providerPartId: mapped.providerPartId,
+                        partType: mapped.partType,
+                        partSlot: mapped.partSlot,
                         provider: mapped.provider,
                         providerChunkType: mapped.providerChunkType,
                         actionRef: mapped.actionRef,
@@ -221,11 +226,14 @@ export async function executeAiSdkReaction(params) {
         }
     }
     finally {
-        contextStepStreamWriter?.releaseLock();
+        const streamWriter = contextStepStreamWriter;
+        if (typeof streamWriter?.releaseLock === "function") {
+            streamWriter.releaseLock();
+        }
     }
     const assistantEvent = await finishPromise;
     const finishedAtMs = Date.now();
-    const toolCalls = extractToolCallsFromParts(assistantEvent?.content?.parts);
+    const actionCalls = extractActionCallsFromParts(assistantEvent?.content?.parts);
     const latencyMs = Math.max(0, finishedAtMs - startedAtMs);
     let usage = undefined;
     let providerMetadata = undefined;
@@ -291,10 +299,10 @@ export async function executeAiSdkReaction(params) {
             rawProviderMetadata: providerMetadataJson,
         };
     try {
-        const runId = await resolveWorkflowRunId(params.env, params.executionId);
+        const runId = await resolveWorkflowRunId(params.runtime, params.executionId);
         if (runId && llm) {
             await writeContextTraceEvents({
-                env: params.env,
+                runtime: params.runtime,
                 events: [
                     {
                         workflowRunId: runId,
@@ -339,5 +347,5 @@ export async function executeAiSdkReaction(params) {
     catch {
         // tracing must not break reaction
     }
-    return { assistantEvent, toolCalls, messagesForModel, llm };
+    return { assistantEvent, actionCalls, messagesForModel, llm };
 }

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

@@ -1,6 +1,9 @@
 import type { ModelMessage } from "ai";
+import type { DomainLike } from "@ekairos/domain";
 import type { ContextEnvironment } from "../context.config.js";
+import type { ContextRuntime } from "../context.runtime.js";
 import type { ContextItem } from "../context.store.js";
+import { eventsDomain } from "../schema.js";
 import type { ContextReactionLLM, ContextActionRequest, ContextReactor, ContextReactorParams } from "./types.js";
 type ScriptedReactionPayload = {
     assistantEvent?: Partial<ContextItem>;
@@ -8,10 +11,10 @@ type ScriptedReactionPayload = {
     messagesForModel?: ModelMessage[];
     llm?: ContextReactionLLM;
 };
-export type ScriptedReactorStep<Context = unknown, Env extends ContextEnvironment = ContextEnvironment> = ScriptedReactionPayload | ((params: ContextReactorParams<Context, Env>) => Promise<ScriptedReactionPayload> | ScriptedReactionPayload);
-export type CreateScriptedReactorOptions<Context = unknown, Env extends ContextEnvironment = ContextEnvironment> = {
-    steps: ScriptedReactorStep<Context, Env>[];
+export type ScriptedReactorStep<Context = unknown, Env extends ContextEnvironment = ContextEnvironment, RequiredDomain extends DomainLike = typeof eventsDomain, Runtime extends ContextRuntime<Env> = ContextRuntime<Env>> = ScriptedReactionPayload | ((params: ContextReactorParams<Context, Env, RequiredDomain, Runtime>) => Promise<ScriptedReactionPayload> | ScriptedReactionPayload);
+export type CreateScriptedReactorOptions<Context = unknown, Env extends ContextEnvironment = ContextEnvironment, RequiredDomain extends DomainLike = typeof eventsDomain, Runtime extends ContextRuntime<Env> = ContextRuntime<Env>> = {
+    steps: ScriptedReactorStep<Context, Env, RequiredDomain, Runtime>[];
     repeatLast?: boolean;
 };
-export declare function createScriptedReactor<Context = unknown, Env extends ContextEnvironment = ContextEnvironment>(options: CreateScriptedReactorOptions<Context, Env>): ContextReactor<Context, Env>;
+export declare function createScriptedReactor<Context = unknown, Env extends ContextEnvironment = ContextEnvironment, RequiredDomain extends DomainLike = typeof eventsDomain, Runtime extends ContextRuntime<Env> = ContextRuntime<Env>>(options: CreateScriptedReactorOptions<Context, Env, RequiredDomain, Runtime>): ContextReactor<Context, Env, RequiredDomain, Runtime>;
 export {};

package/dist/reactors/types.d.ts

@@ -1,9 +1,12 @@
 import type { ModelMessage, UIMessageChunk } from "ai";
+import type { DomainLike } from "@ekairos/domain";
 import type { ContextEnvironment } from "../context.config.js";
+import type { ContextTool } from "../context.action.js";
+import type { ContextRuntime, ContextRuntimeHandleForDomain } from "../context.runtime.js";
 import type { ContextModelInit } from "../context.engine.js";
-import type { ContextIdentifier, StoredContext, ContextItem } from "../context.store.js";
+import type { ContextIdentifier, StoredContext, StoredContextResource, ContextItem } from "../context.store.js";
 import type { ContextSkillPackage } from "../context.skill.js";
-import type { SerializableToolForModel } from "../tools-to-model-tools.js";
+import { eventsDomain } from "../schema.js";
 export type ContextActionRequest = {
     actionRef: string;
     actionName: string;
@@ -26,16 +29,29 @@ export type ContextReactionResult = {
     actionRequests: ContextActionRequest[];
     messagesForModel: ModelMessage[];
     llm?: ContextReactionLLM;
+    reactor?: {
+        kind: string;
+        state?: Record<string, unknown> | null;
+    };
 };
-export type ContextReactorParams<Context = unknown, Env extends ContextEnvironment = ContextEnvironment> = {
-    env: Env;
+export type ContextReactorParams<Context = unknown, Env extends ContextEnvironment = ContextEnvironment, RequiredDomain extends DomainLike = typeof eventsDomain, Runtime extends ContextRuntime<Env> = any> = {
+    runtime: ContextRuntimeHandleForDomain<Env, RequiredDomain>;
     context: StoredContext<Context>;
     contextIdentifier: ContextIdentifier;
+    resources: StoredContextResource[];
+    /**
+     * Context items after the engine-level expansion stage.
+     *
+     * Reactors should prefer these over fetching raw items when constructing
+     * model/runtime input. Expanders must return regular ContextItems whose
+     * parts follow the shared context part contract, so this is not tied to any
+     * specific model provider.
+     */
+    events: ContextItem[];
     triggerEvent: ContextItem;
     model: ContextModelInit;
     systemPrompt: string;
-    actions: Record<string, unknown>;
-    toolsForModel: Record<string, SerializableToolForModel>;
+    actions: Record<string, ContextTool<Context, Env, RequiredDomain, Runtime>>;
     skills: ContextSkillPackage[];
     eventId: string;
     executionId: string;
@@ -44,9 +60,8 @@ export type ContextReactorParams<Context = unknown, Env extends ContextEnvironme
     iteration: number;
     maxModelSteps: number;
     sendStart: boolean;
-    silent: boolean;
     contextStepStream?: WritableStream<string>;
     writable?: WritableStream<UIMessageChunk>;
     persistReactionParts?: (parts: any[]) => Promise<void>;
 };
-export type ContextReactor<Context = unknown, Env extends ContextEnvironment = ContextEnvironment> = (params: ContextReactorParams<Context, Env>) => Promise<ContextReactionResult>;
+export type ContextReactor<Context = unknown, Env extends ContextEnvironment = ContextEnvironment, RequiredDomain extends DomainLike = typeof eventsDomain, Runtime extends ContextRuntime<Env> = any> = (params: ContextReactorParams<Context, Env, RequiredDomain, Runtime>) => Promise<ContextReactionResult>;

package/dist/runtime.d.ts

@@ -8,6 +8,12 @@
  * - Do NOT import this entrypoint from client/browser code.
  * - Keep `@ekairos/events` main entrypoint safe to import from schema/domain modules.
  */
+import "./reactors/ai-sdk.step.js";
+import "./runtime.step.js";
+import "./steps/durable.steps.js";
+import "./steps/store.steps.js";
+import "./steps/stream.steps.js";
+import "./steps/trace.steps.js";
 export { getContextRuntime, } from "./runtime.step.js";
 export { createContextStepStreamClientId, createPersistedContextStepStream, readPersistedContextStepStream, resolveContextExecutionStreamPointer, waitForContextExecutionStreamPointer, } from "./steps/stream.steps.js";
 export type { ContextEnvironment, ContextRuntime } from "./context.config.js";

package/dist/runtime.js

@@ -20,6 +20,15 @@ if (typeof globalThis.Event === "undefined") {
     ;
     globalThis.Event = NodeEvent;
 }
+// Workflow bundles only register `use step` functions that are reachable from a
+// workflow/runtime entrypoint. Keep the internal context steps reachable whenever
+// apps import `@ekairos/events/runtime` to configure durable context execution.
+import "./reactors/ai-sdk.step.js";
+import "./runtime.step.js";
+import "./steps/durable.steps.js";
+import "./steps/store.steps.js";
+import "./steps/stream.steps.js";
+import "./steps/trace.steps.js";
 export { getContextRuntime, } from "./runtime.step.js";
 export { createContextStepStreamClientId, createPersistedContextStepStream, readPersistedContextStepStream, resolveContextExecutionStreamPointer, waitForContextExecutionStreamPointer, } from "./steps/stream.steps.js";
 export { registerContextEnv, getContextEnv } from "./env.js";

package/dist/runtime.step.js

@@ -1,7 +1,7 @@
 import { coerceContextRuntime } from "./context.config.js";
 import { eventsDomain } from "./schema.js";
 export async function getContextRuntime(env) {
-    const { resolveRuntime } = await import("@ekairos/domain/runtime-step");
+    const { resolveRuntime } = await import("@ekairos/domain/runtime");
     const resolved = await resolveRuntime(eventsDomain, env);
-    return await coerceContextRuntime(resolved);
+    return await coerceContextRuntime(resolved, env);
 }