@ekairos/events 1.22.4-beta.development.0 → 1.22.5-beta.development.0

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

@@ -1,6 +1,10 @@
 import type { UIMessageChunk } from "ai";
 import type { ContextEnvironment } from "../context.config.js";
+import type { ContextRuntime } from "../context.runtime.js";
 import type { ContextExecution, ContextItem, ContextIdentifier, StoredContext, ContextStatus } from "../context.store.js";
+type RuntimeParams<Env extends ContextEnvironment = ContextEnvironment> = {
+    runtime: ContextRuntime<Env>;
+};
 export type ContextReviewRequest = {
     toolCallId: string;
     toolName?: string;
@@ -10,18 +14,30 @@ export type ContextReviewRequest = {
  *
  * 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;
+    opts?: {
+        silent?: boolean;
+        writable?: WritableStream<UIMessageChunk>;
+    };
 }): 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 updateContextContent<C>(params: RuntimeParams & {
+    contextIdentifier: ContextIdentifier;
+    content: C;
+}): 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 saveTriggerAndCreateExecution(params: {
-    env: ContextEnvironment;
+    runtime: ContextRuntime<ContextEnvironment>;
     contextIdentifier: ContextIdentifier;
     triggerEvent: ContextItem;
 }): Promise<{
@@ -29,41 +45,57 @@ 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 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";
+}): Promise<void>;
 export declare function updateExecutionWorkflowRun(params: {
-    env: ContextEnvironment;
+    runtime: ContextRuntime<ContextEnvironment>;
     executionId: string;
     workflowRunId: string;
 }): Promise<void>;
 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;
@@ -82,15 +114,16 @@ export declare function updateContextStep(params: {
     };
 }): Promise<void>;
 export declare function linkItemToExecutionStep(params: {
-    env: ContextEnvironment;
+    runtime: ContextRuntime<ContextEnvironment>;
     itemId: string;
     executionId: string;
 }): Promise<void>;
 export declare function saveContextPartsStep(params: {
-    env: ContextEnvironment;
+    runtime: ContextRuntime<ContextEnvironment>;
     stepId: string;
     executionId?: string;
     contextId?: string;
     iteration?: number;
     parts: any[];
 }): Promise<void>;
+export {};

package/dist/steps/store.steps.js

@@ -1,6 +1,12 @@
+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";
+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 +98,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,29 +137,24 @@ 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 updateContextStatus(params) {
     "use step";
-    const { getContextRuntime } = await import("../runtime.js");
-    const { store } = await getContextRuntime(env);
-    await store.updateContextStatus(contextIdentifier, status);
+    const { runtime } = await getRuntimeAndEnv(params);
+    await runtime.store.updateContextStatus(params.contextIdentifier, params.status);
 }
-export async function saveTriggerItem(env, contextIdentifier, event) {
+export async function saveTriggerItem(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.saveItem(params.contextIdentifier, params.event);
 }
 export async function saveTriggerAndCreateExecution(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", {
         contextIdentifier: summarizeContextIdentifierForLog(params.contextIdentifier),
@@ -241,7 +241,7 @@ export async function saveTriggerAndCreateExecution(params) {
         throw error;
     }
     const { runId, meta } = await resolveWorkflowRunId({
-        env: params.env,
+        env,
         db,
         executionId: execution.id,
     });
@@ -329,7 +329,7 @@ export async function saveTriggerAndCreateExecution(params) {
                 },
             },
         ];
-        await maybeWriteTraceEvents(params.env, events);
+        await maybeWriteTraceEvents(env, events);
     }
     return {
         triggerEvent: saved,
@@ -340,26 +340,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 +368,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 +376,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 +412,15 @@ export async function saveReactionItem(env, contextIdentifier, event, opts) {
     }
     return saved;
 }
-export async function updateItem(env, eventId, event, opts) {
+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 +429,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 +441,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,31 +458,30 @@ 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)
+    await store.completeExecution(params.contextIdentifier, params.executionId, params.status);
+    const 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, [
             {
                 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,
                 },
             },
         ]);
@@ -493,9 +489,8 @@ export async function completeExecution(env, contextIdentifier, executionId, sta
 }
 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({
@@ -507,8 +502,8 @@ export async function updateExecutionWorkflowRun(params) {
 }
 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 +512,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)}`,
@@ -558,18 +552,17 @@ export async function updateContextStep(params) {
 }
 export async function linkItemToExecutionStep(params) {
     "use step";
-    const { getContextRuntime } = await import("../runtime.js");
-    const { store } = await getContextRuntime(params.env);
+    const { runtime } = await getRuntimeAndEnv(params);
+    const { store } = runtime;
     await store.linkItemToExecution({ itemId: params.itemId, executionId: params.executionId });
 }
 export async function saveContextPartsStep(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 { runId } = await resolveWorkflowRunId({
-        env: params.env,
+        env,
         db,
         executionId: params.executionId,
     });
@@ -590,6 +583,6 @@ export async function saveContextPartsStep(params) {
                 payload: part,
             });
         }
-        await maybeWriteTraceEvents(params.env, events);
+        await maybeWriteTraceEvents(env, events);
     }
 }

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: {
@@ -20,17 +21,17 @@ export type PersistedContextStepStreamSession = {
     stepId: string;
 };
 export declare function createPersistedContextStepStream(params: {
-    env: ContextEnvironment;
+    runtime: ContextRuntime<ContextEnvironment>;
     executionId: string;
     stepId: string;
     clientId?: string;
 }): Promise<PersistedContextStepStreamSession>;
 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>;

package/dist/steps/stream.steps.js

@@ -1,3 +1,4 @@
+import { getContextRuntimeServices } from "../context.runtime.js";
 import { contextStreamByteLength, parseContextStepStreamChunk, } from "../context.step-stream.js";
 export async function writeContextEvents(params) {
     "use step";
@@ -14,7 +15,9 @@ export async function writeContextEvents(params) {
         }
     }
     finally {
-        writer.releaseLock();
+        if (typeof writer?.releaseLock === "function") {
+            writer.releaseLock();
+        }
     }
 }
 export async function closeContextStream(params) {
@@ -30,7 +33,9 @@ export async function closeContextStream(params) {
             await writer.write({ type: "finish" });
         }
         finally {
-            writer.releaseLock();
+            if (typeof writer?.releaseLock === "function") {
+                writer.releaseLock();
+            }
         }
     }
     if (!preventClose) {
@@ -60,8 +65,7 @@ export function createContextStepStreamClientId(stepId) {
 }
 export async function createPersistedContextStepStream(params) {
     "use step";
-    const { getContextRuntime } = await import("../runtime.js");
-    const runtime = await getContextRuntime(params.env);
+    const runtime = await getContextRuntimeServices(params.runtime);
     const db = runtime?.db;
     if (!db?.streams?.createWriteStream) {
         throw new Error("InstantDB streams are not available on the configured runtime. Upgrade @instantdb/admin to a streams-capable version.");
@@ -103,8 +107,7 @@ export async function createPersistedContextStepStream(params) {
 }
 async function finalizePersistedContextStepStream(params) {
     "use step";
-    const { getContextRuntime } = await import("../runtime.js");
-    const runtime = await getContextRuntime(params.env);
+    const runtime = await getContextRuntimeServices(params.runtime);
     const db = runtime?.db;
     const writer = params.session.stream.getWriter();
     try {
@@ -116,7 +119,9 @@ async function finalizePersistedContextStepStream(params) {
         }
     }
     finally {
-        writer.releaseLock();
+        if (typeof writer?.releaseLock === "function") {
+            writer.releaseLock();
+        }
     }
     const now = new Date();
     const txs = [
@@ -140,14 +145,14 @@ async function finalizePersistedContextStepStream(params) {
 }
 export async function closePersistedContextStepStream(params) {
     return await finalizePersistedContextStepStream({
-        env: params.env,
+        runtime: params.runtime,
         session: params.session,
         mode: "close",
     });
 }
 export async function abortPersistedContextStepStream(params) {
     return await finalizePersistedContextStepStream({
-        env: params.env,
+        runtime: params.runtime,
         session: params.session,
         mode: "abort",
         abortReason: params.reason,

package/dist/steps/trace.steps.d.ts

@@ -1,5 +1,6 @@
 import "../polyfills/dom-events.js";
 import type { ContextEnvironment } from "../context.config.js";
+import type { ContextRuntime } from "../context.runtime.js";
 import type { TraceEventKind } from "../context.contract.js";
 export type ContextTraceEventWrite = {
     workflowRunId: string;
@@ -33,6 +34,7 @@ export type ContextTraceEventWrite = {
     testId?: string;
 };
 export declare function writeContextTraceEvents(params: {
+    runtime?: ContextRuntime<ContextEnvironment>;
     env: ContextEnvironment;
     events: ContextTraceEventWrite[];
 }): Promise<void>;

package/dist/steps/trace.steps.js

@@ -1,4 +1,5 @@
 import "../polyfills/dom-events.js";
+import { getContextRuntimeServices } from "../context.runtime.js";
 import { lookup } from "@instantdb/admin";
 function requireBaseUrl() {
     const baseUrl = process.env.EKAIROS_CORE_BASE_URL ||
@@ -84,8 +85,10 @@ export async function writeContextTraceEvents(params) {
     const strict = envTrace?.strict === true || process.env.EKAIROS_TRACES_STRICT === "1";
     // 1) Local trace persistence (InstantDB source of truth).
     try {
-        const { getContextRuntime } = await import("../runtime.js");
-        const runtime = await getContextRuntime(params.env);
+        if (!params.runtime) {
+            throw new Error("[context/trace] runtime is required");
+        }
+        const runtime = await getContextRuntimeServices(params.runtime);
         const db = runtime?.db;
         if (db) {
             const now = new Date();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ekairos/events",
-  "version": "1.22.4-beta.development.0",
+  "version": "1.22.5-beta.development.0",
   "description": "Ekairos Events - Context-first workflow runtime",
   "type": "module",
   "main": "dist/index.js",
@@ -108,6 +108,7 @@
     "clean": "node -e \"require('fs').rmSync('dist', {recursive:true, force:true})\"",
     "typecheck": "tsc --noEmit",
     "test": "vitest run -c vitest.config.mts",
+    "test:workflow": "vitest run -c vitest.workflow.config.mts",
     "pretest:ai-sdk-reactor": "pnpm --filter @ekairos/domain build",
     "test:ai-sdk-reactor": "vitest run -c vitest.config.mts src/tests/context.ai-sdk-reactor.instant.test.ts",
     "test:ai-sdk-reactor:real": "vitest run -c vitest.config.mts src/tests/context.ai-sdk-reactor.real.instant.test.ts",
@@ -116,7 +117,7 @@
   },
   "dependencies": {
     "@ai-sdk/openai": "^2.0.52",
-    "@ekairos/domain": "^1.22.4-beta.development.0",
+    "@ekairos/domain": "^1.22.5-beta.development.0",
     "@instantdb/admin": "0.22.158",
     "@instantdb/core": "0.22.142",
     "@vercel/mcp-adapter": "^1.0.0",
@@ -133,6 +134,8 @@
   "devDependencies": {
     "@ekairos/testing": "workspace:*",
     "@ekairos/tsconfig": "workspace:*",
+    "@workflow/serde": "^4.1.0",
+    "@workflow/vitest": "^4.0.1",
     "@types/node": "^24.5.0",
     "@types/react": "^19.2.2",
     "dotenv": "^17.2.3",