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

package/README.md

@@ -2,114 +2,87 @@
 
 Context-first durable execution runtime for Ekairos.
 
-## Surface
+## What this package does
 
-- `createContext`, `context`, `ContextEngine`
-- `createAiSdkReactor`, `createScriptedReactor`
-- `useContext`
+- creates durable contexts with `createContext(...)`
+- persists executions, steps, parts, and items
+- runs direct or durable `react(...)` loops
+- adapts model/tool output into canonical `event_parts`
+
+## Main APIs
+
+- `createContext`
+- `ContextEngine`
+- `createAiSdkReactor`
+- `createScriptedReactor`
+- `runContextReactionDirect`
 - `eventsDomain`
-- `getContextRuntime`, `getContextEnv`, `registerContextEnv`
 
 ## Runtime model
 
+Canonical entities:
+
 - `event_contexts`
 - `event_items`
 - `event_executions`
 - `event_steps`
 - `event_parts`
-- `event_trace_events`
-- `event_trace_runs`
-- `event_trace_spans`
-
-The aggregate is `context`. Executions, steps, parts, and items are scoped to a context.
-
-## Canonical Parts
+- `event_trace_*`
 
-`event_parts` is the canonical content model for produced output.
+`event_parts` is the source of truth for replay.
 
-Rules:
-
-- `event_parts.part` is the source of truth for replay and inspection.
-- `event_items.content.parts` on output items is maintained as a compatibility mirror and is deprecated as a replay source.
-- Provider/model-specific values must live under `metadata`, never as first-class semantic fields.
-
-Canonical part kinds:
-
-- `content`
-- `reasoning`
-- `source`
-- `tool-call`
-- `tool-result`
+## Example
 
-Each canonical part stores a `content` array. The entries inside that array define the payload type:
+```ts
+import { createContext } from "@ekairos/events";
 
-- `text`
-- `file`
-- `json`
-- `source-url`
-- `source-document`
+const supportContext = createContext<{ orgId: string }>("support.agent")
+  .context((stored, env) => ({
+    ...stored.content,
+    orgId: env.orgId,
+  }))
+  .narrative(() => "You are a precise assistant.")
+  .actions(() => ({}))
+  .build();
+```
 
-Example tool result:
+Run directly:
 
 ```ts
-{
-  type: "tool-result",
-  toolCallId: "call_123",
-  toolName: "inspectCanvasRegion",
-  state: "output-available",
-  content: [
-    {
-      type: "text",
-      text: "Zoomed crop of the requested region.",
-    },
-    {
-      type: "file",
-      mediaType: "image/png",
-      filename: "inspect-region.png",
-      data: "iVBORw0KGgoAAAANSUhEUgAA...",
-    },
-  ],
-  metadata: {
-    provider: {
-      itemId: "fc_041cb...",
-    },
-  },
-}
+await supportContext.react(triggerEvent, {
+  runtime,
+  context: { key: "support:org_123" },
+});
 ```
 
-The AI SDK bridge projects canonical parts to:
+Run durably:
 
-- assistant messages with text/file/reasoning/source/tool-call parts
-- tool messages with `tool-result` or `tool-error`
-
-That means multipart tool outputs are replayed from `event_parts` instead of relying on the deprecated output-item mirror.
-
-## Install
+```ts
+const shell = await supportContext.react(triggerEvent, {
+  runtime,
+  context: { key: "support:org_123" },
+  durable: true,
+});
 
-```bash
-pnpm add @ekairos/events
+const final = await shell.run?.returnValue;
 ```
 
-## Example
+## Tool execution model
 
-```ts
-import { createContext, createAiSdkReactor } from "@ekairos/events";
-
-type Env = { orgId: string };
+Context tools now receive runtime-aware execution context.
+That lets a tool do this inside `"use step"`:
 
-export const supportContext = createContext<Env>("support.agent")
-  .context((stored, env) => ({
-    orgId: env.orgId,
-    ...stored.content,
-  }))
-  .narrative(() => "You are a precise assistant.")
-  .actions(() => ({}))
-  .reactor(createAiSdkReactor())
-  .build();
+```ts
+async function execute(input, ctx) {
+  "use step";
+  const domain = await ctx.runtime.use(myDomain);
+  return await domain.actions.doSomething(input);
+}
 ```
 
-## Notes
+## Tests
 
-- Public continuity is context-based.
-- Provider-specific IDs such as `providerContextId` may still exist when an upstream provider requires them.
-- Runtime wiring for stores lives under `@ekairos/events/runtime`.
+```bash
+pnpm --filter @ekairos/events test
+pnpm --filter @ekairos/events test:workflow
+```

package/dist/context.d.ts

@@ -1,4 +1,4 @@
-export { ContextEngine, type ContextOptions, type ContextStreamOptions, type ShouldContinue, type ContextShouldContinueArgs, type ContextReactParams, type ContextReactResult, type ContextDurableWorkflowPayload, type ContextDurableWorkflowFunction, type ContextModelInit, type ContextTool, runContextReactionDirect, } from "./context.engine.js";
+export { ContextEngine, type ContextOptions, type ContextStreamOptions, type ShouldContinue, type ContextShouldContinueArgs, type ContextReactParams, type ContextReactResult, type ContextWorkflowRun, type ContextDurableWorkflowPayload, type ContextDurableWorkflowFunction, type ContextModelInit, type ContextTool, type ContextToolExecuteContext, runContextReactionDirect, } from "./context.engine.js";
 export { context, createContext, type ContextConfig, type ContextInstance, type RegistrableContextBuilder, } from "./context.builder.js";
 export { createAiSdkReactor, createScriptedReactor, type CreateAiSdkReactorOptions, type CreateScriptedReactorOptions, type ScriptedReactorStep, type ContextReactor, type ContextReactorParams, type ContextReactionResult, type ContextActionRequest, type ContextReactionLLM, } from "./context.reactor.js";
 export type { ContextSkillPackage, ContextSkillPackageFile, } from "./context.skill.js";

package/dist/context.engine.d.ts

@@ -1,5 +1,6 @@
-import type { Tool, UIMessageChunk } from "ai";
+import type { ModelMessage, Tool, UIMessageChunk } from "ai";
 import type { ContextEnvironment } from "./context.config.js";
+import type { ContextRuntime } from "./context.runtime.js";
 import type { ContextExecution, ContextItem, ContextIdentifier, StoredContext } from "./context.store.js";
 import type { ContextSkillPackage } from "./context.skill.js";
 import { type ContextReactor } from "./context.reactor.js";
@@ -68,7 +69,11 @@ export interface ContextStreamOptions {
  */
 export type ContextModelInit = string | (() => Promise<any>);
 export type ContextReactParams<Env extends ContextEnvironment = ContextEnvironment> = {
-    env: Env;
+    runtime?: ContextRuntime<Env>;
+    /**
+     * Backward-compatible runtime selector. New callers should pass `runtime`.
+     */
+    env?: Env;
     /**
      * Context selector (exclusive: `{ id }` OR `{ key }`).
      * - `{ id }` resolves a concrete context id.
@@ -95,16 +100,36 @@ export type ContextReactResult<Context = any> = {
     trigger: ContextItem;
     reaction: ContextItem;
     execution: ContextExecution;
+    run?: ContextWorkflowRun<Context>;
+};
+export type ContextWorkflowRun<Context = any> = {
+    runId: string;
+    status: Promise<"pending" | "running" | "completed" | "failed" | "cancelled">;
+    returnValue: Promise<ContextReactResult<Context>>;
 };
 export type ContextDurableWorkflowPayload<Env extends ContextEnvironment = ContextEnvironment> = {
     contextKey: string;
-    env: Env;
+    runtime: ContextRuntime<Env>;
     context?: ContextIdentifier | null;
     triggerEvent: ContextItem;
     options?: Omit<ContextStreamOptions, "writable">;
     bootstrap: NonNullable<ContextReactParams<Env>["__bootstrap"]>;
 };
 export type ContextDurableWorkflowFunction<Context = any, Env extends ContextEnvironment = ContextEnvironment> = (payload: ContextDurableWorkflowPayload<Env>) => Promise<ContextReactResult<Context>>;
+export type ContextToolExecuteContext<Context = any, Env extends ContextEnvironment = ContextEnvironment> = {
+    runtime: ContextRuntime<Env>;
+    env: Env;
+    context: StoredContext<Context>;
+    contextIdentifier: ContextIdentifier;
+    toolCallId: string;
+    messages: ModelMessage[];
+    eventId: string;
+    executionId: string;
+    triggerEventId: string;
+    contextId: string;
+    stepId: string;
+    iteration: number;
+};
 export { toolApprovalHookToken, toolApprovalWebhookToken, getClientResumeHookUrl };
 /**
  * Context-level tool type.

package/dist/context.engine.js

@@ -1,16 +1,40 @@
-import { registerContextEnv } from "./env.js";
+import { getContextRuntimeServices } from "./context.runtime.js";
 import { OUTPUT_ITEM_TYPE, WEB_CHANNEL } from "./context.events.js";
 import { applyToolExecutionResultToParts } from "./context.toolcalls.js";
 import { isContextPartEnvelope, normalizePartsForPersistence, } from "./context.parts.js";
-import { toolsToModelTools } from "./tools-to-model-tools.js";
+import { actionsToActionSpecs } from "./tools-to-model-tools.js";
 import { createAiSdkReactor, } from "./context.reactor.js";
 import { abortPersistedContextStepStream, closePersistedContextStepStream, createPersistedContextStepStream, closeContextStream, } from "./steps/stream.steps.js";
-import { completeExecution, createContextStep, initializeContext, saveTriggerAndCreateExecution, saveContextPartsStep, updateContextContent, updateContextStatus, updateItem, updateContextStep, } from "./steps/store.steps.js";
+import { completeExecution, createContextStep, initializeContext, saveTriggerAndCreateExecution, saveContextPartsStep, updateContextContent, updateContextReactor, updateContextStatus, updateItem, updateContextStep, } from "./steps/store.steps.js";
 import { getClientResumeHookUrl, toolApprovalHookToken, toolApprovalWebhookToken, } from "./context.hooks.js";
 import { getContextDurableWorkflow } from "./context.durable.js";
 export async function runContextReactionDirect(context, triggerEvent, params) {
     return await ContextEngine.runDirect(context, triggerEvent, params);
 }
+async function legacyRuntimeFromEnv(env) {
+    const { getContextRuntime } = await import("./runtime.step.js");
+    const legacy = (await getContextRuntime(env));
+    return {
+        env,
+        db: async () => legacy.db,
+        resolve: async () => ({
+            db: legacy.db,
+            meta: () => ({
+                domain: legacy.domain,
+            }),
+        }),
+        meta: () => ({
+            domain: legacy.domain,
+        }),
+    };
+}
+async function resolveReactRuntime(params) {
+    if (params.runtime)
+        return params.runtime;
+    if (params.env)
+        return await legacyRuntimeFromEnv(params.env);
+    throw new Error("ContextEngine.react requires either runtime or env.");
+}
 export { toolApprovalHookToken, toolApprovalWebhookToken, getClientResumeHookUrl };
 function nowIso() {
     return new Date().toISOString();
@@ -89,9 +113,8 @@ async function readActiveWorkflowRunId() {
         return null;
     }
 }
-async function createRuntimeOps(env, benchmark) {
-    const { getContextRuntime } = await import("./runtime.js");
-    const runtime = await getContextRuntime(env);
+async function createRuntimeOps(runtimeHandle, benchmark) {
+    const runtime = await getContextRuntimeServices(runtimeHandle);
     const { db } = runtime;
     const { InstantStore } = await import("./stores/instant.store.js");
     const requireContextId = (contextIdentifier) => {
@@ -145,6 +168,7 @@ async function createRuntimeOps(env, benchmark) {
             return { context, isNew: true };
         },
         updateContextContent: async (contextIdentifier, content) => await store.updateContextContent(contextIdentifier, content),
+        updateContextReactor: async (contextIdentifier, reactor) => await store.updateContextReactor(contextIdentifier, reactor),
         updateContextStatus: async (contextIdentifier, status) => await instrumentedDb.transact([
             instrumentedDb.tx.event_contexts[requireContextId(contextIdentifier)].update({
                 status,
@@ -255,27 +279,28 @@ async function createRuntimeOps(env, benchmark) {
         },
     };
 }
-async function createWorkflowOps(env) {
+async function createWorkflowOps(runtime) {
+    const env = runtime.env;
     return {
-        initializeContext: async (contextIdentifier, opts) => await initializeContext(env, contextIdentifier, opts),
-        updateContextContent: async (contextIdentifier, content) => await updateContextContent(env, contextIdentifier, content),
-        updateContextStatus: async (contextIdentifier, status) => await updateContextStatus(env, contextIdentifier, status),
-        saveTriggerAndCreateExecution: async ({ contextIdentifier, triggerEvent }) => await saveTriggerAndCreateExecution({ env, contextIdentifier, triggerEvent }),
-        createContextStep: async ({ executionId, iteration }) => await createContextStep({ env, executionId, iteration }),
-        updateContextStep: async (params) => await updateContextStep({ env, ...params }),
-        saveContextPartsStep: async (params) => await saveContextPartsStep({ env, ...params }),
-        updateItem: async (itemId, item, opts) => await updateItem(env, itemId, item, opts),
-        completeExecution: async (contextIdentifier, executionId, status) => await completeExecution(env, contextIdentifier, executionId, status),
+        initializeContext: async (contextIdentifier, opts) => await initializeContext({ runtime, contextIdentifier, opts }),
+        updateContextContent: async (contextIdentifier, content) => await updateContextContent({ runtime, contextIdentifier, content }),
+        updateContextReactor: async (contextIdentifier, reactor) => await updateContextReactor({ runtime, contextIdentifier, reactor }),
+        updateContextStatus: async (contextIdentifier, status) => await updateContextStatus({ runtime, contextIdentifier, status }),
+        saveTriggerAndCreateExecution: async ({ contextIdentifier, triggerEvent }) => await saveTriggerAndCreateExecution({ runtime, contextIdentifier, triggerEvent }),
+        createContextStep: async ({ executionId, iteration }) => await createContextStep({ runtime, executionId, iteration }),
+        updateContextStep: async (params) => await updateContextStep({ runtime, ...params }),
+        saveContextPartsStep: async (params) => await saveContextPartsStep({ runtime, ...params }),
+        updateItem: async (itemId, item, opts) => await updateItem({ runtime, eventId: itemId, event: item, opts }),
+        completeExecution: async (contextIdentifier, executionId, status) => await completeExecution({ runtime, contextIdentifier, executionId, status }),
     };
 }
-async function getContextEngineOps(env, benchmark) {
+async function getContextEngineOps(runtime, benchmark) {
+    const env = runtime.env;
     const workflowRunId = await readActiveWorkflowRunId();
     if (workflowRunId) {
-        registerContextEnv(env, workflowRunId);
-        return await createWorkflowOps(env);
+        return await createWorkflowOps(runtime);
     }
-    registerContextEnv(env);
-    return await createRuntimeOps(env, benchmark);
+    return await createRuntimeOps(runtime, benchmark);
 }
 export class ContextEngine {
     constructor(opts = {}, reactor) {
@@ -329,13 +354,15 @@ export class ContextEngine {
         return await ContextEngine.runDirect(this, triggerEvent, params);
     }
     static async prepareExecutionShell(story, triggerEvent, params) {
-        const ops = await measureBenchmark(params.__benchmark, "react.resolveOpsMs", async () => await getContextEngineOps(params.env, params.__benchmark));
+        const runtimeHandle = await resolveReactRuntime(params);
+        const env = runtimeHandle.env;
+        const ops = await measureBenchmark(params.__benchmark, "react.resolveOpsMs", async () => await getContextEngineOps(runtimeHandle, params.__benchmark));
         const silent = params.options?.silent ?? false;
         const ctxResult = await measureBenchmark(params.__benchmark, "react.initializeContextMs", async () => await ops.initializeContext(params.context ?? null, { silent }));
         let currentContext = ctxResult.context;
         const contextSelector = { id: String(currentContext.id) };
         if (ctxResult.isNew) {
-            await story.opts.onContextCreated?.({ env: params.env, context: currentContext });
+            await story.opts.onContextCreated?.({ env, context: currentContext });
         }
         if (currentContext.status === "closed") {
             await measureBenchmark(params.__benchmark, "react.reopenClosedContextMs", async () => await ops.updateContextStatus(contextSelector, "open_idle"));
@@ -355,6 +382,8 @@ export class ContextEngine {
         };
     }
     static async startDurable(story, triggerEvent, params) {
+        const runtimeHandle = await resolveReactRuntime(params);
+        const env = runtimeHandle.env;
         if (params.options?.writable) {
             throw new Error("ContextEngine.react: durable runs manage their own workflow stream");
         }
@@ -367,14 +396,15 @@ export class ContextEngine {
             throw new Error("ContextEngine.react: durable workflow is not configured. Call configureContextDurableWorkflow(...) in runtime bootstrap.");
         }
         const shell = await ContextEngine.prepareExecutionShell(story, triggerEvent, params);
+        let run;
         try {
             const [{ start }] = await Promise.all([
                 import("workflow/api"),
             ]);
-            const run = await start(workflow, [
+            const startedRun = await start(workflow, [
                 {
                     contextKey,
-                    env: params.env,
+                    runtime: runtimeHandle,
                     context: params.context ?? null,
                     triggerEvent,
                     options: {
@@ -392,16 +422,21 @@ export class ContextEngine {
                     },
                 },
             ]);
-            const runtime = await createRuntimeOps(params.env);
+            run = {
+                runId: String(startedRun.runId),
+                status: startedRun.status,
+                returnValue: startedRun.returnValue,
+            };
+            const runtime = await createRuntimeOps(runtimeHandle);
             await runtime.db.transact([
                 runtime.db.tx.event_executions[shell.execution.id].update({
-                    workflowRunId: run.runId,
+                    workflowRunId: startedRun.runId,
                     updatedAt: new Date(),
                 }),
             ]);
         }
         catch (error) {
-            const ops = await getContextEngineOps(params.env, params.__benchmark);
+            const ops = await getContextEngineOps(runtimeHandle, params.__benchmark);
             await ops.completeExecution(shell.contextSelector, shell.execution.id, "failed").catch(() => null);
             throw error;
         }
@@ -410,10 +445,13 @@ export class ContextEngine {
             trigger: shell.trigger,
             reaction: shell.reaction,
             execution: shell.execution,
+            run,
         };
     }
     static async runDirect(story, triggerEvent, params) {
-        const ops = await measureBenchmark(params.__benchmark, "react.resolveOpsMs", async () => await getContextEngineOps(params.env, params.__benchmark));
+        const runtimeHandle = await resolveReactRuntime(params);
+        const env = runtimeHandle.env;
+        const ops = await measureBenchmark(params.__benchmark, "react.resolveOpsMs", async () => await getContextEngineOps(runtimeHandle, params.__benchmark));
         const maxIterations = params.options?.maxIterations ?? 20;
         const maxModelSteps = params.options?.maxModelSteps ?? 1;
         const preventClose = params.options?.preventClose ?? false;
@@ -488,7 +526,7 @@ export class ContextEngine {
                 }));
                 currentStepId = stepCreate.stepId;
                 currentStepStream = await createPersistedContextStepStream({
-                    env: params.env,
+                    runtime: runtimeHandle,
                     executionId,
                     stepId: stepCreate.stepId,
                 });
@@ -507,7 +545,7 @@ export class ContextEngine {
                     ],
                 });
                 // Hook: Context DSL `context()` (implemented by subclasses via `initialize()`)
-                const nextContent = await measureBenchmark(params.__benchmark, `${stagePrefix}.contextMs`, async () => await story.initialize(updatedContext, params.env));
+                const nextContent = await measureBenchmark(params.__benchmark, `${stagePrefix}.contextMs`, async () => await story.initialize(updatedContext, env));
                 updatedContext = await measureBenchmark(params.__benchmark, `${stagePrefix}.persistContextMs`, async () => await ops.updateContextContent(activeContextSelector, nextContent));
                 await emitContextEvents({
                     silent,
@@ -520,15 +558,15 @@ export class ContextEngine {
                         },
                     ],
                 });
-                await story.opts.onContextUpdated?.({ env: params.env, context: updatedContext });
+                await story.opts.onContextUpdated?.({ env, context: updatedContext });
                 // Hook: Context DSL `narrative()` (implemented by subclasses via `buildSystemPrompt()`)
-                const systemPrompt = await measureBenchmark(params.__benchmark, `${stagePrefix}.narrativeMs`, async () => await story.buildSystemPrompt(updatedContext, params.env));
+                const systemPrompt = await measureBenchmark(params.__benchmark, `${stagePrefix}.narrativeMs`, async () => await story.buildSystemPrompt(updatedContext, env));
                 // Hook: Context DSL `actions()` (implemented by subclasses via `buildTools()`)
-                const toolsAll = await measureBenchmark(params.__benchmark, `${stagePrefix}.actionsMs`, async () => await story.buildTools(updatedContext, params.env));
-                const skillsAll = await measureBenchmark(params.__benchmark, `${stagePrefix}.skillsMs`, async () => await story.buildSkills(updatedContext, params.env));
+                const toolsAll = await measureBenchmark(params.__benchmark, `${stagePrefix}.actionsMs`, async () => await story.buildTools(updatedContext, env));
+                const skillsAll = await measureBenchmark(params.__benchmark, `${stagePrefix}.skillsMs`, async () => await story.buildSkills(updatedContext, env));
                 // IMPORTANT: step args must be serializable.
                 // Match DurableAgent behavior: convert tool input schemas to plain JSON Schema in workflow context.
-                const toolsForModel = toolsToModelTools(toolsAll);
+                const actionSpecs = actionsToActionSpecs(toolsAll);
                 // Execute model reaction for this iteration using the stable reaction event id.
                 //
                 // IMPORTANT:
@@ -536,7 +574,7 @@ export class ContextEngine {
                 // If we stream with a per-step id, the UI will render an optimistic assistant message
                 // (step id) and then a second persisted assistant message (reaction id) with the same
                 // content once InstantDB updates.
-                const reactor = story.getReactor(updatedContext, params.env);
+                const reactor = story.getReactor(updatedContext, env);
                 const reactionPartsBeforeStep = Array.isArray(reactionEvent.content?.parts)
                     ? [...reactionEvent.content.parts]
                     : [];
@@ -563,15 +601,16 @@ export class ContextEngine {
                         status: "pending",
                     }, { executionId, contextId: String(currentContext.id) });
                 };
-                const { assistantEvent, actionRequests, messagesForModel } = await measureBenchmark(params.__benchmark, `${stagePrefix}.reactorMs`, async () => await reactor({
-                    env: params.env,
+                const reactionResult = await measureBenchmark(params.__benchmark, `${stagePrefix}.reactorMs`, async () => await reactor({
+                    runtime: runtimeHandle,
+                    env,
                     context: updatedContext,
                     contextIdentifier: activeContextSelector,
                     triggerEvent,
-                    model: story.getModel(updatedContext, params.env),
+                    model: story.getModel(updatedContext, env),
                     systemPrompt,
                     actions: toolsAll,
-                    toolsForModel,
+                    actionSpecs,
                     skills: skillsAll,
                     eventId: reactionEventId,
                     executionId,
@@ -586,6 +625,7 @@ export class ContextEngine {
                     writable,
                     persistReactionParts,
                 }));
+                const { assistantEvent, actionRequests, messagesForModel } = reactionResult;
                 const reviewRequests = actionRequests.length > 0
                     ? actionRequests.flatMap((actionRequest) => {
                         const toolDef = toolsAll[actionRequest.actionName];
@@ -649,9 +689,18 @@ export class ContextEngine {
                     status: "pending",
                 };
                 reactionEvent = await measureBenchmark(params.__benchmark, `${stagePrefix}.persistAssistantReactionMs`, async () => await ops.updateItem(reactionEvent.id, nextReactionEvent, { executionId, contextId: String(currentContext.id) }));
+                if (reactionResult.reactor?.kind) {
+                    updatedContext = await measureBenchmark(params.__benchmark, `${stagePrefix}.persistReactorStateMs`, async () => await ops.updateContextReactor(activeContextSelector, {
+                        kind: reactionResult.reactor.kind,
+                        state: {
+                            ...(reactionResult.reactor.state ?? {}),
+                            updatedAt: nowIso(),
+                        },
+                    }));
+                }
                 if (currentStepStream) {
                     await closePersistedContextStepStream({
-                        env: params.env,
+                        runtime: runtimeHandle,
                         session: currentStepStream,
                     });
                     currentStepStream = null;
@@ -807,9 +856,8 @@ export class ContextEngine {
                             const { createHook, createWebhook } = await import("workflow");
                             const toolCallId = String(actionRequest.actionRef);
                             const hookToken = toolApprovalHookToken({ executionId, toolCallId });
-                            const webhookToken = toolApprovalWebhookToken({ executionId, toolCallId });
                             const hook = createHook({ token: hookToken });
-                            const webhook = createWebhook({ token: webhookToken });
+                            const webhook = createWebhook();
                             const approvalOrRequest = await Promise.race([
                                 hook.then((approval) => ({ source: "hook", approval })),
                                 webhook.then((request) => ({ source: "webhook", request })),
@@ -832,12 +880,18 @@ export class ContextEngine {
                             }
                         }
                         const output = await toolDef.execute(actionInput, {
+                            runtime: runtimeHandle,
+                            env,
+                            context: updatedContext,
+                            contextIdentifier: activeContextSelector,
                             toolCallId: actionRequest.actionRef,
                             messages: messagesForModel,
                             eventId: reactionEventId,
                             executionId,
                             triggerEventId,
                             contextId: currentContext.id,
+                            stepId: String(stepCreate.stepId),
+                            iteration: iter,
                         });
                         return { actionRequest, success: true, output };
                     }
@@ -894,7 +948,7 @@ export class ContextEngine {
                 // IMPORTANT: we call this after tool results have been merged into the persisted `reactionEvent`,
                 // so stories can inspect `reactionEvent.content.parts` deterministically.
                 const continueLoop = await measureBenchmark(params.__benchmark, `${stagePrefix}.shouldContinueMs`, async () => await story.shouldContinue({
-                    env: params.env,
+                    env,
                     context: updatedContext,
                     reactionEvent,
                     assistantEvent: assistantEventEffective,
@@ -1033,7 +1087,7 @@ export class ContextEngine {
             if (currentStepStream) {
                 try {
                     await abortPersistedContextStepStream({
-                        env: params.env,
+                        runtime: runtimeHandle,
                         session: currentStepStream,
                         reason: error instanceof Error ? error.message : String(error),
                     });

package/dist/context.runtime.d.ts

@@ -0,0 +1,11 @@
+import type { ConcreteDomain } from "@ekairos/domain";
+import type { ExplicitRuntimeLike } from "@ekairos/domain/runtime";
+import type { ContextEnvironment } from "./context.config.js";
+import type { ContextStore } from "./context.store.js";
+export type ContextRuntime<Env extends ContextEnvironment = ContextEnvironment> = ExplicitRuntimeLike<Env, any, any>;
+export type ContextRuntimeServices = {
+    db: any;
+    store: ContextStore;
+    domain?: ConcreteDomain<any, any>;
+};
+export declare function getContextRuntimeServices(runtime: ContextRuntime<any>): Promise<ContextRuntimeServices>;

package/dist/context.runtime.js

@@ -0,0 +1,21 @@
+const storeByDb = new WeakMap();
+export async function getContextRuntimeServices(runtime) {
+    const db = await runtime.db();
+    if (!db) {
+        throw new Error("Context runtime did not provide a database instance.");
+    }
+    let store = typeof db === "object" && db !== null ? storeByDb.get(db) : undefined;
+    if (!store) {
+        const { InstantStore } = await import("./stores/instant.store.js");
+        store = new InstantStore(db);
+        if (typeof db === "object" && db !== null) {
+            storeByDb.set(db, store);
+        }
+    }
+    const resolved = await runtime.resolve();
+    return {
+        db,
+        store,
+        domain: typeof resolved === "object" && resolved !== null ? resolved.meta?.()?.domain : undefined,
+    };
+}

package/dist/context.store.d.ts

@@ -16,6 +16,10 @@ export type StoredContext<Context> = {
     createdAt: Date;
     updatedAt?: Date;
     content: Context | null;
+    reactor?: {
+        kind: string;
+        state?: Record<string, unknown> | null;
+    } | null;
 };
 export type ContextItem = {
     id: string;
@@ -57,6 +61,10 @@ export interface ContextStore {
     getOrCreateContext<C>(contextIdentifier: ContextIdentifier | null): Promise<StoredContext<C>>;
     getContext<C>(contextIdentifier: ContextIdentifier): Promise<StoredContext<C> | null>;
     updateContextContent<C>(contextIdentifier: ContextIdentifier, content: C): Promise<StoredContext<C>>;
+    updateContextReactor<C>(contextIdentifier: ContextIdentifier, reactor: {
+        kind: string;
+        state?: Record<string, unknown> | null;
+    }): Promise<StoredContext<C>>;
     updateContextStatus(contextIdentifier: ContextIdentifier, status: ContextStatus): Promise<void>;
     saveItem(contextIdentifier: ContextIdentifier, item: ContextItem): Promise<ContextItem>;
     updateItem(itemId: string, item: ContextItem): Promise<ContextItem>;

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-export { context, createContext, createAiSdkReactor, createScriptedReactor, type CreateAiSdkReactorOptions, type CreateScriptedReactorOptions, type ScriptedReactorStep, type ContextConfig, type ContextInstance, type ContextOptions, type ContextStreamOptions, type ContextReactor, type ContextReactorParams, type ContextReactionResult, type ContextActionRequest, type ContextReactionLLM, ContextEngine, type RegistrableContextBuilder, type ContextReactParams, type ContextReactResult, type ContextDurableWorkflowPayload, type ContextDurableWorkflowFunction, type ContextModelInit, type ContextTool, runContextReactionDirect, } from "./context.js";
+export { context, createContext, createAiSdkReactor, createScriptedReactor, type CreateAiSdkReactorOptions, type CreateScriptedReactorOptions, type ScriptedReactorStep, type ContextConfig, type ContextInstance, type ContextOptions, type ContextStreamOptions, type ContextReactor, type ContextReactorParams, type ContextReactionResult, type ContextActionRequest, type ContextReactionLLM, ContextEngine, type RegistrableContextBuilder, type ContextReactParams, type ContextReactResult, type ContextWorkflowRun, type ContextDurableWorkflowPayload, type ContextDurableWorkflowFunction, type ContextModelInit, type ContextTool, type ContextToolExecuteContext, runContextReactionDirect, } from "./context.js";
 export type { ContextStore, ContextIdentifier, StoredContext, ContextItem, ContextExecution, } from "./context.store.js";
 export type { WireDate, ContextMirrorContext, ContextMirrorExecution, ContextMirrorWrite, ContextMirrorRequest, } from "./mirror.js";
 export { registerContext, getContext, getContextFactory, hasContext, listContexts, type ContextKey, } from "./context.registry.js";