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

package/dist/context.builder.js

@@ -1,43 +1,95 @@
 import { ContextEngine, } from "./context.engine.js";
 import { registerContext } from "./context.registry.js";
+import { eventsDomain } from "./schema.js";
 function isDynamicModelSelector(model) {
     return typeof model === "function" && model.length >= 1;
 }
+function stringifyContextContent(content) {
+    try {
+        return JSON.stringify(content ?? null, null, 2);
+    }
+    catch {
+        return String(content);
+    }
+}
+function buildDefaultContextPrompt(params) {
+    const sections = [];
+    sections.push(`Content:\n${stringifyContextContent(params.content)}`);
+    if (params.resources?.length) {
+        sections.push(`Resources:\n${stringifyContextContent(params.resources)}`);
+    }
+    if (params.description) {
+        sections.push(`Description:\n${params.description}`);
+    }
+    if (params.goal) {
+        sections.push(`Goal:\n${params.goal}`);
+    }
+    return sections.join("\n\n");
+}
 export function context(config) {
     class FunctionalContext extends ContextEngine {
         constructor() {
             super(config.opts, config.reactor);
             this.__config = config;
         }
-        async initialize(contextValue, env) {
-            return config.context(contextValue, env);
+        async initialize(contextValue, env, runtime) {
+            return config.context(contextValue, env, runtime);
         }
-        async expandEvents(events, contextValue, env) {
+        async expandEvents(events, contextValue, env, runtime) {
             if (config.expandEvents)
-                return config.expandEvents(events, contextValue, env);
-            return super.expandEvents(events, contextValue, env);
+                return config.expandEvents(events, contextValue, env, runtime);
+            return super.expandEvents(events, contextValue, env, runtime);
         }
-        async buildSystemPrompt(contextValue, env) {
+        async buildSystemPrompt(contextValue, env, runtime) {
             if (config.narrative)
-                return config.narrative(contextValue, env);
-            throw new Error("Context config is missing narrative()");
+                return config.narrative(contextValue, env, runtime);
+            const content = contextValue.content;
+            const description = contextValue.description ??
+                (config.description
+                    ? await config.description(content, contextValue, env, runtime)
+                    : null);
+            const goal = contextValue.goal ??
+                (config.goal
+                    ? await config.goal(content, contextValue, env, runtime)
+                    : null);
+            return buildDefaultContextPrompt({
+                content,
+                resources: contextValue.resources ?? [],
+                description,
+                goal,
+            });
+        }
+        async describeContext(content, contextValue, env, runtime) {
+            if (!config.description)
+                return null;
+            return config.description(content, contextValue, env, runtime);
+        }
+        async defineGoal(content, contextValue, env, runtime) {
+            if (!config.goal)
+                return null;
+            return config.goal(content, contextValue, env, runtime);
         }
-        async buildSkills(contextValue, env) {
+        async defineResources(content, contextValue, env, runtime) {
+            if (!config.resources)
+                return [];
+            return config.resources({ content, context: contextValue, env, runtime });
+        }
+        async buildSkills(contextValue, env, runtime) {
             if (config.skills)
-                return config.skills(contextValue, env);
+                return config.skills(contextValue, env, runtime);
             return [];
         }
-        async buildTools(contextValue, env) {
+        async buildTools(contextValue, env, runtime) {
             if (config.actions)
-                return config.actions(contextValue, env);
+                return config.actions(contextValue, env, runtime);
             if (config.tools)
-                return config.tools(contextValue, env);
+                return config.tools(contextValue, env, runtime);
             throw new Error("Context config is missing actions()");
         }
-        getModel(contextValue, env) {
+        getModel(contextValue, env, runtime) {
             if (isDynamicModelSelector(config.model))
-                return config.model(contextValue, env);
-            return config.model ?? super.getModel(contextValue, env);
+                return config.model(contextValue, env, runtime);
+            return config.model ?? super.getModel(contextValue, env, runtime);
         }
         async shouldContinue(args) {
             if (config.shouldContinue)
@@ -50,27 +102,49 @@ export function context(config) {
 }
 function assertConfigComplete(config) {
     if (!config.context) {
-        throw new Error("createContext: you must define context() before building the Context.");
+        throw new Error("createContext: you must define content() before building the Context.");
     }
-    if (!config.narrative) {
-        throw new Error("createContext: you must define narrative() before building the Context.");
+    if (!config.narrative && (!config.description || !config.goal)) {
+        throw new Error("createContext: you must define description() and goal() before building the Context.");
     }
     if (!config.actions && !config.tools) {
         throw new Error("createContext: you must define actions() before building the Context.");
     }
 }
-export function createContext(key) {
+export function createContext(keyOrDomain, maybeKey) {
+    const requiredDomain = typeof keyOrDomain === "string" ? eventsDomain : keyOrDomain;
+    const key = typeof keyOrDomain === "string" ? keyOrDomain : maybeKey;
+    if (!key) {
+        throw new Error("createContext: key is required.");
+    }
     const initializeBuilder = (initializer) => {
-        const typedInitializer = (ctx, env) => initializer(ctx, env);
+        const typedInitializer = (ctx, env, runtime) => initializer(ctx, env, runtime);
         const fluentState = {
             context: typedInitializer,
         };
+        const resourceFactories = [];
+        const refreshResourcesConfig = () => {
+            fluentState.resources = async (params) => {
+                const resources = [];
+                for (const factory of resourceFactories) {
+                    const result = await factory(params);
+                    if (!result)
+                        continue;
+                    const list = Array.isArray(result) ? result : [result];
+                    resources.push(...list);
+                }
+                return resources;
+            };
+        };
         let cached = null;
         const getOrBuild = () => {
             assertConfigComplete(fluentState);
             if (!cached) {
                 const config = fluentState;
-                cached = Object.assign(context(config), { __contextKey: key });
+                cached = Object.assign(context(config), {
+                    __contextKey: key,
+                    __contextDomain: requiredDomain,
+                });
                 registerContext(key, () => cached);
             }
             return cached;
@@ -89,6 +163,30 @@ export function createContext(key) {
                 fluentState.narrative = system;
                 return builder;
             },
+            description(description) {
+                fluentState.description = description;
+                return builder;
+            },
+            goal(goal) {
+                fluentState.goal = goal;
+                return builder;
+            },
+            resources(resources) {
+                resourceFactories.push(resources);
+                refreshResourcesConfig();
+                return builder;
+            },
+            resource(resource) {
+                resourceFactories.push(async (params) => {
+                    if (typeof resource === "function") {
+                        const resolved = await resource(params);
+                        return resolved ? [resolved] : [];
+                    }
+                    return [resource];
+                });
+                refreshResourcesConfig();
+                return builder;
+            },
             skills(skillsFactory) {
                 fluentState.skills = skillsFactory;
                 return builder;
@@ -117,12 +215,8 @@ export function createContext(key) {
                 fluentState.opts = options;
                 return builder;
             },
-            react(triggerEvent, params) {
-                return getOrBuild().react(triggerEvent, params);
-            },
-            stream(triggerEvent, params) {
-                return builder.react(triggerEvent, params);
-            },
+            react: ((triggerEvent, params) => getOrBuild().react(triggerEvent, params)),
+            stream: ((triggerEvent, params) => builder.react(triggerEvent, params)),
             register() {
                 getOrBuild();
             },
@@ -137,6 +231,7 @@ export function createContext(key) {
         return builder;
     };
     return {
+        content: initializeBuilder,
         context: initializeBuilder,
         initialize: initializeBuilder,
     };

package/dist/context.config.d.ts

@@ -4,6 +4,7 @@ export type ContextEnvironment = Record<string, unknown>;
 export type ContextRuntime = {
     store: ContextStore;
     db: any;
+    env?: ContextEnvironment;
     domain?: ConcreteDomain<any, any>;
 };
-export declare function coerceContextRuntime(value: any): Promise<ContextRuntime>;
+export declare function coerceContextRuntime(value: any, env?: ContextEnvironment): Promise<ContextRuntime>;

package/dist/context.config.js

@@ -1,10 +1,14 @@
 const runtimeByDb = new WeakMap();
-export async function coerceContextRuntime(value) {
+export async function coerceContextRuntime(value, env) {
     if (!value) {
         throw new Error("Context runtime resolver returned no value.");
     }
+    const resolvedEnv = env ??
+        (typeof value === "object" && value !== null
+            ? value.env
+            : undefined);
     if (typeof value === "object" && value.store) {
-        return value;
+        return resolvedEnv ? { ...value, env: resolvedEnv } : value;
     }
     const dbCandidate = typeof value === "object" && value !== null && "db" in value
         ? value.db
@@ -15,12 +19,13 @@ export async function coerceContextRuntime(value) {
     if (typeof dbCandidate === "object" && dbCandidate !== null) {
         const cached = runtimeByDb.get(dbCandidate);
         if (cached)
-            return cached;
+            return resolvedEnv ? { ...cached, env: resolvedEnv } : cached;
     }
     const { InstantStore } = await import("./stores/instant.store.js");
     const runtime = {
         store: new InstantStore(dbCandidate),
         db: dbCandidate,
+        env: resolvedEnv,
         domain: typeof value === "object" ? value.domain : undefined,
     };
     if (typeof dbCandidate === "object" && dbCandidate !== null) {

package/dist/context.contract.d.ts

@@ -8,8 +8,6 @@ export declare const EXECUTION_STATUSES: readonly ["executing", "completed", "fa
 export type ExecutionStatus = (typeof EXECUTION_STATUSES)[number];
 export declare const STEP_STATUSES: readonly ["running", "completed", "failed"];
 export type StepStatus = (typeof STEP_STATUSES)[number];
-export declare const STEP_KINDS: readonly ["message", "action_execute", "action_result"];
-export type StepKind = (typeof STEP_KINDS)[number];
 export declare const ITEM_STATUSES: readonly ["stored", "pending", "completed"];
 export type ItemStatus = (typeof ITEM_STATUSES)[number];
 export declare const ITEM_TYPES: readonly ["input", "output"];
@@ -21,11 +19,11 @@ export type TraceEventKind = (typeof TRACE_EVENT_KINDS)[number];
 export declare const STREAM_LIFECYCLE_CHUNK_TYPES: readonly ["chunk.start", "chunk.start_step", "chunk.finish_step", "chunk.finish"];
 export declare const STREAM_TEXT_CHUNK_TYPES: readonly ["chunk.text_start", "chunk.text_delta", "chunk.text_end"];
 export declare const STREAM_REASONING_CHUNK_TYPES: readonly ["chunk.reasoning_start", "chunk.reasoning_delta", "chunk.reasoning_end"];
-export declare const STREAM_ACTION_CHUNK_TYPES: readonly ["chunk.action_input_start", "chunk.action_input_delta", "chunk.action_input_available", "chunk.action_output_available", "chunk.action_output_error"];
+export declare const STREAM_ACTION_CHUNK_TYPES: readonly ["chunk.action_started", "chunk.action_input_delta", "chunk.action_completed", "chunk.action_failed"];
 export declare const STREAM_SOURCE_CHUNK_TYPES: readonly ["chunk.source_url", "chunk.source_document", "chunk.file"];
 export declare const STREAM_METADATA_CHUNK_TYPES: readonly ["chunk.message_metadata", "chunk.response_metadata"];
 export declare const STREAM_ERROR_CHUNK_TYPES: readonly ["chunk.error", "chunk.unknown"];
-export declare const CONTEXT_STREAM_CHUNK_TYPES: readonly ["chunk.start", "chunk.start_step", "chunk.finish_step", "chunk.finish", "chunk.text_start", "chunk.text_delta", "chunk.text_end", "chunk.reasoning_start", "chunk.reasoning_delta", "chunk.reasoning_end", "chunk.action_input_start", "chunk.action_input_delta", "chunk.action_input_available", "chunk.action_output_available", "chunk.action_output_error", "chunk.source_url", "chunk.source_document", "chunk.file", "chunk.message_metadata", "chunk.response_metadata", "chunk.error", "chunk.unknown"];
+export declare const CONTEXT_STREAM_CHUNK_TYPES: readonly ["chunk.start", "chunk.start_step", "chunk.finish_step", "chunk.finish", "chunk.text_start", "chunk.text_delta", "chunk.text_end", "chunk.reasoning_start", "chunk.reasoning_delta", "chunk.reasoning_end", "chunk.action_started", "chunk.action_input_delta", "chunk.action_completed", "chunk.action_failed", "chunk.source_url", "chunk.source_document", "chunk.file", "chunk.message_metadata", "chunk.response_metadata", "chunk.error", "chunk.unknown"];
 export type ContextStreamChunkType = (typeof CONTEXT_STREAM_CHUNK_TYPES)[number];
 export declare function isContextStreamChunkType(value: string): value is ContextStreamChunkType;
 export type ContextTransition = Transition<"open_idle" | "open_streaming" | "closed", "open_idle" | "open_streaming" | "closed">;

package/dist/context.contract.js

@@ -1,11 +1,6 @@
 export const CONTEXT_STATUSES = ["open_idle", "open_streaming", "closed"];
 export const EXECUTION_STATUSES = ["executing", "completed", "failed"];
 export const STEP_STATUSES = ["running", "completed", "failed"];
-export const STEP_KINDS = [
-    "message",
-    "action_execute",
-    "action_result",
-];
 export const ITEM_STATUSES = ["stored", "pending", "completed"];
 export const ITEM_TYPES = [
     "input",
@@ -41,11 +36,10 @@ export const STREAM_REASONING_CHUNK_TYPES = [
     "chunk.reasoning_end",
 ];
 export const STREAM_ACTION_CHUNK_TYPES = [
-    "chunk.action_input_start",
+    "chunk.action_started",
     "chunk.action_input_delta",
-    "chunk.action_input_available",
-    "chunk.action_output_available",
-    "chunk.action_output_error",
+    "chunk.action_completed",
+    "chunk.action_failed",
 ];
 export const STREAM_SOURCE_CHUNK_TYPES = [
     "chunk.source_url",

package/dist/context.d.ts

@@ -1,4 +1,5 @@
-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 { ContextEngine, type ContextOptions, type ContextStreamOptions, type ShouldContinue, type ContextShouldContinueArgs, type ContextReactParams, type ContextDirectReactParams, type ContextDurableReactParams, type ContextReactResult, type ContextReactBase, type ContextReactFinalResult, type ContextDirectRun, type ContextReactRun, type ContextWorkflowRun, type ContextDurableWorkflowPayload, type ContextDurableWorkflowFunction, type ContextModelInit, type ContextToolExecuteContext, runContextReactionDirect, } from "./context.engine.js";
+export { context, createContext, type ContextConfig, type ContextInstance, type ContextResourcesParams, type RegistrableContextBuilder, } from "./context.builder.js";
+export { defineAction, action, type ContextAction, type ContextActionBase, type ContextActionExecuteParams, type AnyContextAction, type ContextActionDefinition, type ContextActionExecute, type DefineContextActionDefinition, type DefineContextActionExecute, type LegacyContextActionDefinition, type LegacyContextActionExecute, type ContextActionInput, type ContextActionOutput, type ContextProviderDefinedAction, type ContextActionSchema, type ContextTool, } from "./context.action.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,17 +1,22 @@
-import type { ModelMessage, Tool, UIMessageChunk } from "ai";
+import type { ModelMessage, UIMessageChunk } from "ai";
+import type { DomainLike } from "@ekairos/domain";
 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 { ContextTool } from "./context.action.js";
+import type { ContextRuntime, ContextRuntimeHandleForDomain, ContextRuntimeForDomain } from "./context.runtime.js";
+import { eventsDomain } from "./schema.js";
+import type { ContextExecution, ContextItem, ContextIdentifier, ContextResource, StoredContext } from "./context.store.js";
 import type { ContextSkillPackage } from "./context.skill.js";
 import { type ContextReactor } from "./context.reactor.js";
 import { getClientResumeHookUrl, toolApprovalHookToken, toolApprovalWebhookToken } from "./context.hooks.js";
-export interface ContextOptions<Context = any, Env extends ContextEnvironment = ContextEnvironment> {
+export interface ContextOptions<Context = any, Env extends ContextEnvironment = ContextEnvironment, RequiredDomain extends DomainLike = typeof eventsDomain> {
     onContextCreated?: (args: {
         env: Env;
+        runtime: ContextRuntimeHandleForDomain<Env, RequiredDomain>;
         context: StoredContext<Context>;
     }) => void | Promise<void>;
     onContextUpdated?: (args: {
         env: Env;
+        runtime: ContextRuntimeHandleForDomain<Env, RequiredDomain>;
         context: StoredContext<Context>;
     }) => void | Promise<void>;
     onEventCreated?: (event: ContextItem) => void | Promise<void>;
@@ -23,7 +28,7 @@ type ContextBenchmarkRecorder = {
     add?(name: string, value: number): void;
     getCurrentStage?(): string | undefined;
 };
-export declare function runContextReactionDirect<Context, Env extends ContextEnvironment = ContextEnvironment>(context: ContextEngine<Context, Env>, triggerEvent: ContextItem, params: ContextReactParams<Env>): Promise<ContextReactResult<Context>>;
+export declare function runContextReactionDirect<Context, Env extends ContextEnvironment = ContextEnvironment, RequiredDomain extends DomainLike = typeof eventsDomain, Runtime extends ContextRuntime<Env> = ContextRuntime<Env>>(context: ContextEngine<Context, Env, RequiredDomain>, triggerEvent: ContextItem, params: ContextReactParams<Env, RequiredDomain, Runtime>): Promise<ContextReactResult<Context>>;
 export interface ContextStreamOptions {
     /**
      * Maximum loop iterations (LLM call → tool execution → repeat).
@@ -45,14 +50,6 @@ export interface ContextStreamOptions {
      * Default: true.
      */
     sendFinish?: boolean;
-    /**
-     * If true, the story loop runs silently (no UI streaming output).
-     *
-     * Persistence (contexts/events/executions) still happens normally.
-     *
-     * Default: false.
-     */
-    silent?: boolean;
     /**
      * Optional writable stream used by direct/non-durable execution.
      *
@@ -68,8 +65,8 @@ export interface ContextStreamOptions {
  *   be a `"use-step"` function (so it can be serialized by reference).
  */
 export type ContextModelInit = string | (() => Promise<any>);
-export type ContextReactParams<Env extends ContextEnvironment = ContextEnvironment> = {
-    runtime: ContextRuntime<Env>;
+export type ContextReactParams<Env extends ContextEnvironment = ContextEnvironment, RequiredDomain extends DomainLike = typeof eventsDomain, Runtime extends ContextRuntime<Env> = ContextRuntime<Env>> = {
+    runtime: ContextRuntimeForDomain<Runtime, RequiredDomain>;
     /**
      * Context selector (exclusive: `{ id }` OR `{ key }`).
      * - `{ id }` resolves a concrete context id.
@@ -88,33 +85,49 @@ export type ContextReactParams<Env extends ContextEnvironment = ContextEnvironme
         trigger: ContextItem;
         reaction: ContextItem;
         execution: ContextExecution;
+        returnValueHookToken?: string | null;
     };
+    __initialContent?: unknown;
     __benchmark?: ContextBenchmarkRecorder;
 };
-export type ContextReactResult<Context = any> = {
+export type ContextDurableReactParams<Env extends ContextEnvironment = ContextEnvironment, RequiredDomain extends DomainLike = typeof eventsDomain, Runtime extends ContextRuntime<Env> = ContextRuntime<Env>> = Omit<ContextReactParams<Env, RequiredDomain, Runtime>, "durable"> & {
+    durable?: true | undefined;
+};
+export type ContextDirectReactParams<Env extends ContextEnvironment = ContextEnvironment, RequiredDomain extends DomainLike = typeof eventsDomain, Runtime extends ContextRuntime<Env> = ContextRuntime<Env>> = Omit<ContextReactParams<Env, RequiredDomain, Runtime>, "durable"> & {
+    durable: false;
+};
+export type ContextReactBase<Context = any> = {
     context: StoredContext<Context>;
     trigger: ContextItem;
     reaction: ContextItem;
     execution: ContextExecution;
-    run?: ContextWorkflowRun<Context>;
 };
+export type ContextReactFinalResult<Context = any> = ContextReactBase<Context>;
+export type ContextDirectRun<Context = any> = Promise<ContextReactFinalResult<Context>>;
 export type ContextWorkflowRun<Context = any> = {
     runId: string;
     status: Promise<"pending" | "running" | "completed" | "failed" | "cancelled">;
-    returnValue: Promise<ContextReactResult<Context>>;
+    returnValue: Promise<ContextReactFinalResult<Context>>;
+    returnValueHook?: {
+        token: string;
+        parentWorkflowRunId: string;
+    } | null;
 };
-export type ContextDurableWorkflowPayload<Env extends ContextEnvironment = ContextEnvironment> = {
+export type ContextReactRun<Context = any> = ContextWorkflowRun<Context> | ContextDirectRun<Context>;
+export type ContextReactResult<Context = any, Run extends ContextReactRun<Context> = ContextReactRun<Context>> = ContextReactBase<Context> & {
+    run?: Run;
+};
+export type ContextDurableWorkflowPayload<Env extends ContextEnvironment = ContextEnvironment, RequiredDomain extends DomainLike = typeof eventsDomain, Runtime extends ContextRuntime<Env> = ContextRuntime<Env>> = {
     contextKey: string;
-    runtime: ContextRuntime<Env>;
+    runtime: ContextRuntimeForDomain<Runtime, RequiredDomain>;
     context?: ContextIdentifier | null;
     triggerEvent: ContextItem;
     options?: Omit<ContextStreamOptions, "writable">;
-    bootstrap: NonNullable<ContextReactParams<Env>["__bootstrap"]>;
+    bootstrap: NonNullable<ContextReactParams<Env, RequiredDomain, Runtime>["__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;
+export type ContextDurableWorkflowFunction<Context = any, Env extends ContextEnvironment = ContextEnvironment, RequiredDomain extends DomainLike = typeof eventsDomain, Runtime extends ContextRuntime<Env> = ContextRuntime<Env>> = (payload: ContextDurableWorkflowPayload<Env, RequiredDomain, Runtime>) => Promise<ContextReactFinalResult<Context>>;
+export type ContextToolExecuteContext<Context = any, Env extends ContextEnvironment = ContextEnvironment, RequiredDomain extends DomainLike = typeof eventsDomain, Runtime extends ContextRuntime<Env> = ContextRuntime<Env>> = {
+    runtime: ContextRuntimeForDomain<Runtime, RequiredDomain>;
     context: StoredContext<Context>;
     contextIdentifier: ContextIdentifier;
     toolCallId: string;
@@ -125,6 +138,7 @@ export type ContextToolExecuteContext<Context = any, Env extends ContextEnvironm
     contextId: string;
     stepId: string;
     iteration: number;
+    contextStepStream?: WritableStream<string>;
 };
 export { toolApprovalHookToken, toolApprovalWebhookToken, getClientResumeHookUrl };
 /**
@@ -135,13 +149,6 @@ export { toolApprovalHookToken, toolApprovalWebhookToken, getClientResumeHookUrl
  *
  * Default behavior when omitted: `auto === true`.
  */
-export type ContextTool = Tool & {
-    /**
-     * If `false`, this action is not intended for automatic execution by the engine.
-     * (Validation/enforcement can be added by callers; default is `true`.)
-     */
-    auto?: boolean;
-};
 /**
  * ## Context loop continuation signal
  *
@@ -153,8 +160,9 @@ export type ContextTool = Tool & {
  * (No imports required in callers.)
  */
 export type ShouldContinue = boolean;
-export type ContextShouldContinueArgs<Context = any, Env extends ContextEnvironment = ContextEnvironment> = {
+export type ContextShouldContinueArgs<Context = any, Env extends ContextEnvironment = ContextEnvironment, RequiredDomain extends DomainLike = typeof eventsDomain> = {
     env: Env;
+    runtime: ContextRuntimeHandleForDomain<Env, RequiredDomain>;
     context: StoredContext<Context>;
     /**
      * The persisted reaction event **so far** for the current streaming run.
@@ -183,14 +191,17 @@ export type ContextShouldContinueArgs<Context = any, Env extends ContextEnvironm
         errorText?: string;
     }>;
 };
-export declare abstract class ContextEngine<Context, Env extends ContextEnvironment = ContextEnvironment> {
-    protected readonly opts: ContextOptions<Context, Env>;
+export declare abstract class ContextEngine<Context, Env extends ContextEnvironment = ContextEnvironment, RequiredDomain extends DomainLike = typeof eventsDomain> {
+    protected readonly opts: ContextOptions<Context, Env, RequiredDomain>;
     private readonly reactor;
-    constructor(opts?: ContextOptions<Context, Env>, reactor?: ContextReactor<Context, Env>);
-    protected abstract initialize(context: StoredContext<Context>, env: Env): Promise<Context> | Context;
-    protected abstract buildSystemPrompt(context: StoredContext<Context>, env: Env): Promise<string> | string;
-    protected abstract buildTools(context: StoredContext<Context>, env: Env): Promise<Record<string, ContextTool>> | Record<string, ContextTool>;
-    protected buildSkills(_context: StoredContext<Context>, _env: Env): Promise<ContextSkillPackage[]>;
+    constructor(opts?: ContextOptions<Context, Env, RequiredDomain>, reactor?: ContextReactor<Context, Env, RequiredDomain>);
+    protected abstract initialize(context: StoredContext<Context>, env: Env, runtime: ContextRuntimeHandleForDomain<Env, RequiredDomain>): Promise<Context> | Context;
+    protected abstract buildSystemPrompt(context: StoredContext<Context>, env: Env, runtime: ContextRuntimeHandleForDomain<Env, RequiredDomain>): Promise<string> | string;
+    protected describeContext(_content: Context, _context: StoredContext<Context>, _env: Env, _runtime: ContextRuntimeHandleForDomain<Env, RequiredDomain>): Promise<string | null>;
+    protected defineGoal(_content: Context, _context: StoredContext<Context>, _env: Env, _runtime: ContextRuntimeHandleForDomain<Env, RequiredDomain>): Promise<string | null>;
+    protected defineResources(_content: Context, _context: StoredContext<Context>, _env: Env, _runtime: ContextRuntimeHandleForDomain<Env, RequiredDomain>): Promise<ContextResource[]>;
+    protected abstract buildTools(context: StoredContext<Context>, env: Env, runtime: ContextRuntimeHandleForDomain<Env, RequiredDomain>): Promise<Record<string, ContextTool<Context, Env, RequiredDomain>>> | Record<string, ContextTool<Context, Env, RequiredDomain>>;
+    protected buildSkills(_context: StoredContext<Context>, _env: Env, _runtime: ContextRuntimeHandleForDomain<Env, RequiredDomain>): Promise<ContextSkillPackage[]>;
     /**
      * First-class event expansion stage (runs on every iteration of the durable loop).
      *
@@ -208,9 +219,9 @@ export declare abstract class ContextEngine<Context, Env extends ContextEnvironm
      *   the builder) so results are durable and replay-safe.
      * - If it’s pure/deterministic, it can run in workflow context.
      */
-    protected expandEvents(events: ContextItem[], _context: StoredContext<Context>, _env: Env): Promise<ContextItem[]>;
-    protected getModel(_context: StoredContext<Context>, _env: Env): ContextModelInit;
-    protected getReactor(_context: StoredContext<Context>, _env: Env): ContextReactor<Context, Env>;
+    protected expandEvents(events: ContextItem[], _context: StoredContext<Context>, _env: Env, _runtime: ContextRuntimeHandleForDomain<Env, RequiredDomain>): Promise<ContextItem[]>;
+    protected getModel(_context: StoredContext<Context>, _env: Env, _runtime: ContextRuntimeHandleForDomain<Env, RequiredDomain>): ContextModelInit;
+    protected getReactor(_context: StoredContext<Context>, _env: Env, _runtime: ContextRuntimeHandleForDomain<Env, RequiredDomain>): ContextReactor<Context, Env, RequiredDomain>;
     /**
      * Context stop/continue hook.
      *
@@ -219,19 +230,16 @@ export declare abstract class ContextEngine<Context, Env extends ContextEnvironm
      *
      * Default: `true` (continue).
      */
-    protected shouldContinue(_args: ContextShouldContinueArgs<Context, Env>): Promise<ShouldContinue>;
-    react(triggerEvent: ContextItem, params: ContextReactParams<Env>): Promise<ContextReactResult<Context>>;
+    protected shouldContinue(_args: ContextShouldContinueArgs<Context, Env, RequiredDomain>): Promise<ShouldContinue>;
+    react<Runtime extends ContextRuntime<Env>>(triggerEvent: ContextItem, params: ContextDurableReactParams<Env, RequiredDomain, Runtime>): Promise<ContextReactResult<Context, ContextWorkflowRun<Context>>>;
+    react<Runtime extends ContextRuntime<Env>>(triggerEvent: ContextItem, params: ContextDirectReactParams<Env, RequiredDomain, Runtime>): Promise<ContextReactResult<Context, ContextDirectRun<Context>>>;
+    react<Runtime extends ContextRuntime<Env>>(triggerEvent: ContextItem, params: ContextReactParams<Env, RequiredDomain, Runtime>): Promise<ContextReactResult<Context>>;
     private static prepareExecutionShell;
     private static startDurable;
-    static runDirect<Context, Env extends ContextEnvironment>(story: ContextEngine<Context, Env>, triggerEvent: ContextItem, params: ContextReactParams<Env>): Promise<{
-        context: StoredContext<Context>;
-        trigger: ContextItem;
-        reaction: ContextItem;
-        execution: ContextExecution;
-    }>;
+    static runDirect<Context, Env extends ContextEnvironment, RequiredDomain extends DomainLike, Runtime extends ContextRuntime<Env>>(story: ContextEngine<Context, Env, RequiredDomain>, triggerEvent: ContextItem, params: ContextReactParams<Env, RequiredDomain, Runtime>): Promise<ContextReactResult<Context, ContextDirectRun<Context>>>;
     /**
      * @deprecated Use `react()` instead. Kept for backwards compatibility.
      */
-    stream(triggerEvent: ContextItem, params: ContextReactParams<Env>): Promise<ContextReactResult<Context>>;
+    stream<Runtime extends ContextRuntime<Env>>(triggerEvent: ContextItem, params: ContextReactParams<Env, RequiredDomain, Runtime>): Promise<ContextReactResult<Context, ContextWorkflowRun<Context>>>;
     private callOnEnd;
 }