@ekairos/events 1.22.49-beta.development.0 → 1.22.51-beta.development.0

package/dist/context.engine.d.ts

@@ -93,6 +93,7 @@ export type ContextReactParams<Env extends ContextEnvironment = ContextEnvironme
         trigger: ContextItem;
         reaction: ContextItem;
         execution: ContextExecution;
+        returnValueHookToken?: string | null;
     };
     __benchmark?: ContextBenchmarkRecorder;
 };
@@ -114,6 +115,10 @@ export type ContextWorkflowRun<Context = any> = {
     runId: string;
     status: Promise<"pending" | "running" | "completed" | "failed" | "cancelled">;
     returnValue: Promise<ContextReactFinalResult<Context>>;
+    returnValueHook?: {
+        token: string;
+        parentWorkflowRunId: string;
+    } | null;
 };
 export type ContextReactRun<Context = any> = ContextWorkflowRun<Context> | ContextDirectRun<Context>;
 export type ContextReactResult<Context = any, Run extends ContextReactRun<Context> = ContextReactRun<Context>> = ContextReactBase<Context> & {

package/dist/context.engine.js

@@ -4,7 +4,8 @@ import { applyToolExecutionResultToParts } from "./context.toolcalls.js";
 import { isContextPartEnvelope, normalizePartsForPersistence, } from "./context.parts.js";
 import { createAiSdkReactor, } from "./context.reactor.js";
 import { abortPersistedContextStepStream, closeContextStream, createPersistedContextStepStreamForRuntime, finalizePersistedContextStepStreamForRuntime, writeActionResultPartChunks, } from "./steps/stream.steps.js";
-import { completeExecution, createContextStep, finalizeReactionStep, getContextItems, initializeContext, openReactionStep, saveTriggerAndCreateExecution, saveContextPartsAndUpdateReaction, saveContextPartsStep, updateContextContent, updateContextReactor, updateContextStatus, updateItem, updateContextStep, } from "./steps/store.steps.js";
+import { completeExecution, createContextStep, finalizeReactionStep, getContextItems, initializeContext, openReactionStep, saveTriggerAndCreateExecution, saveContextPartsAndUpdateReaction, saveContextPartsStep, updateContextContent, updateContextReactor, updateContextStatus, updateItem, updateContextStep, updateExecutionWorkflowRun, } from "./steps/store.steps.js";
+import { readContextDurableWorkflowReturnValue, readContextDurableWorkflowStatus, resumeContextReturnValueHook, startContextDurableWorkflow, } from "./steps/durable.steps.js";
 import { getClientResumeHookUrl, toolApprovalHookToken, toolApprovalWebhookToken, } from "./context.hooks.js";
 import { getContextDurableWorkflow } from "./context.durable.js";
 export async function runContextReactionDirect(context, triggerEvent, params) {
@@ -101,6 +102,30 @@ async function readActiveWorkflowRunId() {
         return null;
     }
 }
+function serializeContextReturnValueError(error) {
+    if (error instanceof Error) {
+        return {
+            name: error.name,
+            message: error.message,
+            stack: error.stack,
+        };
+    }
+    return {
+        message: String(error),
+    };
+}
+function unwrapContextReturnValueHookPayload(payload) {
+    if (payload.ok)
+        return payload.result;
+    const error = new Error(payload.error.message);
+    if (payload.error.name) {
+        error.name = payload.error.name;
+    }
+    if (payload.error.stack) {
+        error.stack = payload.error.stack;
+    }
+    throw error;
+}
 async function createRuntimeOps(runtimeHandle, benchmark) {
     const runtime = await getContextRuntimeServices(runtimeHandle);
     const { db } = runtime;
@@ -461,47 +486,73 @@ export class ContextEngine {
         }
         const workflow = getContextDurableWorkflow();
         if (typeof workflow !== "function") {
-            throw new Error("ContextEngine.react: durable workflow is not configured. Call configureContextDurableWorkflow(...) in runtime bootstrap.");
+            const contextKeyLabel = 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: ${contextKeyLabel}.`,
+            ].join(" "));
         }
         const shell = await ContextEngine.prepareExecutionShell(story, triggerEvent, params);
         let run;
         try {
-            const [{ start }] = await measureBenchmark(params.__benchmark, "react.durable.importWorkflowApiMs", async () => await Promise.all([
-                import("workflow/api"),
-            ]));
-            const startedRun = await measureBenchmark(params.__benchmark, "react.durable.startWorkflowMs", async () => await start(workflow, [
-                {
-                    contextKey,
-                    runtime: runtimeHandle,
-                    context: params.context ?? null,
-                    triggerEvent,
-                    options: {
-                        maxIterations: params.options?.maxIterations,
-                        maxModelSteps: params.options?.maxModelSteps,
-                        preventClose: params.options?.preventClose,
-                        sendFinish: params.options?.sendFinish,
-                        silent: params.options?.silent,
-                    },
-                    bootstrap: {
+            const parentWorkflowRunId = await readActiveWorkflowRunId();
+            let returnValueHook = null;
+            let returnValueHookPromise = null;
+            if (parentWorkflowRunId) {
+                const { createHook } = await import("workflow");
+                const hook = createHook({
+                    token: `context:return:${shell.execution.id}`,
+                    metadata: {
+                        kind: "context.returnValue",
                         contextId: shell.currentContext.id,
-                        trigger: shell.trigger,
-                        reaction: shell.reaction,
-                        execution: shell.execution,
+                        executionId: shell.execution.id,
+                        parentWorkflowRunId,
                     },
+                });
+                returnValueHook = {
+                    token: hook.token,
+                    parentWorkflowRunId,
+                };
+                returnValueHookPromise = Promise.resolve(hook);
+            }
+            const payload = {
+                contextKey,
+                runtime: runtimeHandle,
+                context: params.context ?? null,
+                triggerEvent,
+                options: {
+                    maxIterations: params.options?.maxIterations,
+                    maxModelSteps: params.options?.maxModelSteps,
+                    preventClose: params.options?.preventClose,
+                    sendFinish: params.options?.sendFinish,
+                    silent: params.options?.silent,
+                },
+                bootstrap: {
+                    contextId: shell.currentContext.id,
+                    trigger: shell.trigger,
+                    reaction: shell.reaction,
+                    execution: shell.execution,
+                    returnValueHookToken: returnValueHook?.token ?? null,
                 },
-            ]));
+            };
+            const startedRun = await measureBenchmark(params.__benchmark, "react.durable.startWorkflowMs", async () => await startContextDurableWorkflow({ payload }));
             run = {
                 runId: String(startedRun.runId),
-                status: startedRun.status,
-                returnValue: startedRun.returnValue,
+                status: readContextDurableWorkflowStatus({ runId: String(startedRun.runId) }),
+                returnValue: returnValueHookPromise
+                    ? returnValueHookPromise.then(unwrapContextReturnValueHookPayload)
+                    : readContextDurableWorkflowReturnValue({
+                        runId: String(startedRun.runId),
+                    }),
+                returnValueHook,
             };
-            const runtime = await measureBenchmark(params.__benchmark, "react.durable.resolveRuntimeOpsMs", async () => await createRuntimeOps(runtimeHandle, params.__benchmark));
-            await measureBenchmark(params.__benchmark, "react.durable.persistWorkflowRunIdMs", async () => await runtime.db.transact([
-                runtime.db.tx.event_executions[shell.execution.id].update({
-                    workflowRunId: startedRun.runId,
-                    updatedAt: new Date(),
-                }),
-            ]));
+            await measureBenchmark(params.__benchmark, "react.durable.persistWorkflowRunIdMs", async () => await updateExecutionWorkflowRun({
+                runtime: runtimeHandle,
+                executionId: shell.execution.id,
+                workflowRunId: String(startedRun.runId),
+            }));
         }
         catch (error) {
             const ops = await getContextEngineOps(runtimeHandle, params.__benchmark);
@@ -547,6 +598,15 @@ export class ContextEngine {
         const silent = params.options?.silent ?? false;
         const writable = params.options?.writable;
         const bootstrapped = params.__bootstrap;
+        const returnValueHookToken = bootstrapped?.returnValueHookToken ?? null;
+        const resumeReturnValueHook = async (payload) => {
+            if (!returnValueHookToken)
+                return;
+            await resumeContextReturnValueHook({
+                token: returnValueHookToken,
+                payload,
+            });
+        };
         const shell = bootstrapped
             ? {
                 contextSelector: { id: String(bootstrapped.contextId) },
@@ -880,12 +940,14 @@ export class ContextEngine {
                         if (!silent) {
                             await closeContextStream({ preventClose, sendFinish, writable });
                         }
-                        return {
+                        const result = {
                             context: updatedContext,
                             trigger,
                             reaction: reactionEvent,
                             execution,
                         };
+                        await resumeReturnValueHook({ ok: true, result });
+                        return result;
                     }
                 }
                 // Execute actions (workflow context; action implementations decide step vs workflow)
@@ -1115,12 +1177,14 @@ export class ContextEngine {
                     if (!silent) {
                         await closeContextStream({ preventClose, sendFinish, writable });
                     }
-                    return {
+                    const result = {
                         context: updatedContext,
                         trigger,
                         reaction: reactionEvent,
                         execution,
                     };
+                    await resumeReturnValueHook({ ok: true, result });
+                    return result;
                 }
             }
             throw new Error(`ContextEngine: maxIterations reached (${maxIterations}) without completion`);
@@ -1174,6 +1238,10 @@ export class ContextEngine {
                 }
             }
             await failExecution();
+            await resumeReturnValueHook({
+                ok: false,
+                error: serializeContextReturnValueError(error),
+            }).catch(() => null);
             throw error;
         }
     }

package/dist/schema.d.ts

@@ -221,7 +221,7 @@ export declare const eventsDomain: import("@ekairos/domain").DomainSchemaResult<
             readonly label: "stream";
         };
         readonly reverse: {
-            readonly on: any;
+            readonly on: "$streams";
             readonly has: "many";
             readonly label: "step";
         };
@@ -233,7 +233,7 @@ export declare const eventsDomain: import("@ekairos/domain").DomainSchemaResult<
             readonly label: "activeStream";
         };
         readonly reverse: {
-            readonly on: any;
+            readonly on: "$streams";
             readonly has: "many";
             readonly label: "activeOf";
         };
@@ -245,7 +245,7 @@ export declare const eventsDomain: import("@ekairos/domain").DomainSchemaResult<
             readonly label: "lastStream";
         };
         readonly reverse: {
-            readonly on: any;
+            readonly on: "$streams";
             readonly has: "many";
             readonly label: "lastOf";
         };

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ekairos/events",
-  "version": "1.22.49-beta.development.0",
+  "version": "1.22.51-beta.development.0",
   "description": "Ekairos Events - Context-first workflow runtime",
   "type": "module",
   "main": "dist/index.js",
@@ -127,7 +127,7 @@
   },
   "dependencies": {
     "@ai-sdk/openai": "^2.0.52",
-    "@ekairos/domain": "^1.22.49-beta.development.0",
+    "@ekairos/domain": "^1.22.51-beta.development.0",
     "@instantdb/admin": "0.22.158",
     "@instantdb/core": "0.22.142",
     "@vercel/mcp-adapter": "^1.0.0",