@ekairos/events 1.22.39-beta.development.0 → 1.22.41-beta.development.0

package/README.md

@@ -49,10 +49,13 @@ const supportContext = createContext<{ orgId: string }>("support.agent")
 Run directly:
 
 ```ts
-await supportContext.react(triggerEvent, {
+const shell = await supportContext.react(triggerEvent, {
   runtime,
   context: { key: "support:org_123" },
+  durable: false,
 });
+
+const final = await shell.run!;
 ```
 
 Run durably:
@@ -61,10 +64,9 @@ Run durably:
 const shell = await supportContext.react(triggerEvent, {
   runtime,
   context: { key: "support:org_123" },
-  durable: true,
 });
 
-const final = await shell.run?.returnValue;
+const final = await shell.run!.returnValue;
 ```
 
 ## Tool execution model

package/dist/codex.d.ts

@@ -1,6 +1,7 @@
 import { z } from "zod";
 import type { ContextEnvironment } from "./context.config.js";
-import type { ContextModelInit, ContextOptions, ContextReactParams, ContextShouldContinueArgs, ContextTool } from "./context.engine.js";
+import type { ContextModelInit, ContextOptions, ContextReactParams, ContextShouldContinueArgs } from "./context.engine.js";
+import type { ContextTool } from "./context.action.js";
 import type { ContextKey } from "./context.registry.js";
 import type { StoredContext, ContextItem } from "./context.store.js";
 import type { ContextInstance } from "./context.js";
@@ -49,6 +50,14 @@ export declare const codexToolInputSchema: z.ZodObject<{
         fileId: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>>;
 }, z.core.$strip>;
+export declare const codexToolOutputSchema: z.ZodObject<{
+    contextId: z.ZodString;
+    turnId: z.ZodString;
+    assistantText: z.ZodString;
+    reasoningText: z.ZodString;
+    diff: z.ZodString;
+    toolParts: z.ZodArray<z.ZodAny>;
+}, z.core.$strip>;
 export type CodexExecuteArgs<Context, Env extends CodexContextEnv = CodexContextEnv> = {
     context: StoredContext<Context>;
     env: Env;
@@ -61,7 +70,7 @@ export type CodexContextBuilderConfig<Context, Env extends CodexContextEnv = Cod
     executeCodex: (args: CodexExecuteArgs<Context, Env>) => Promise<CodexToolOutput>;
     narrative?: (context: StoredContext<Context>, env: Env) => Promise<string> | string;
     system?: (context: StoredContext<Context>, env: Env) => Promise<string> | string;
-    actions?: (context: StoredContext<Context>, env: Env) => Promise<Record<string, ContextTool>> | Record<string, ContextTool>;
+    actions?: (context: StoredContext<Context>, env: Env) => Promise<Record<string, ContextTool<Context, Env>>> | Record<string, ContextTool<Context, Env>>;
     model?: ContextModelInit | ((context: StoredContext<Context>, env: Env) => ContextModelInit);
     shouldContinue?: (args: ContextShouldContinueArgs<Context, Env>) => Promise<boolean> | boolean;
     toolName?: string;

package/dist/codex.js

@@ -1,6 +1,5 @@
-import { tool } from "ai";
 import { z } from "zod";
-import { createContext } from "./context.js";
+import { createContext, defineAction } from "./context.js";
 import { didToolExecute } from "./context.toolcalls.js";
 export const DEFAULT_CODEX_TOOL_NAME = "codex";
 export const DEFAULT_CODEX_MODEL = "openai/gpt-5.2";
@@ -17,6 +16,14 @@ export const codexToolInputSchema = z.object({
     }))
         .optional(),
 });
+export const codexToolOutputSchema = z.object({
+    contextId: z.string(),
+    turnId: z.string(),
+    assistantText: z.string(),
+    reasoningText: z.string(),
+    diff: z.string(),
+    toolParts: z.array(z.any()),
+});
 function toRecord(value) {
     if (!value || typeof value !== "object")
         return {};
@@ -70,10 +77,11 @@ export function createCodexContextBuilder(config) {
         }
         return {
             ...additional,
-            [toolName]: tool({
+            [toolName]: defineAction({
                 description: toolDescription,
-                inputSchema: codexToolInputSchema,
-                execute: async (input) => await config.executeCodex({
+                input: codexToolInputSchema,
+                output: codexToolOutputSchema,
+                execute: async ({ input }) => await config.executeCodex({
                     context: ctx,
                     env,
                     input,

package/dist/context.action.d.ts

@@ -0,0 +1,55 @@
+import type { DomainSchemaResult } from "@ekairos/domain";
+import type { z } from "zod";
+import type { ContextEnvironment } from "./context.config.js";
+import type { ContextToolExecuteContext } from "./context.engine.js";
+import type { ContextRuntime } from "./context.runtime.js";
+import { eventsDomain } from "./schema.js";
+type MaybePromise<T> = T | Promise<T>;
+export type ContextActionSchema = z.ZodType;
+export type ContextActionBase = {
+    type?: "function";
+    description?: string;
+    providerOptions?: unknown;
+    auto?: boolean;
+};
+export type ContextProviderDefinedAction = {
+    type: "provider-defined";
+    id: string;
+    name?: string;
+    args?: Record<string, unknown>;
+    auto?: boolean;
+};
+export type ContextActionExecuteParams<TInput extends ContextActionSchema, Context = any, Env extends ContextEnvironment = ContextEnvironment, RequiredDomain extends DomainSchemaResult = typeof eventsDomain, Runtime extends ContextRuntime<Env> = ContextRuntime<Env>> = ContextToolExecuteContext<Context, Env, RequiredDomain, Runtime> & {
+    input: z.output<TInput>;
+};
+export type DefineContextActionExecute<TInput extends ContextActionSchema, TOutput extends ContextActionSchema, Context = any, Env extends ContextEnvironment = ContextEnvironment, RequiredDomain extends DomainSchemaResult = typeof eventsDomain, Runtime extends ContextRuntime<Env> = ContextRuntime<Env>> = (params: ContextActionExecuteParams<TInput, Context, Env, RequiredDomain, Runtime>) => MaybePromise<z.output<TOutput>>;
+export type ContextActionExecute<TInput extends ContextActionSchema, TOutput extends ContextActionSchema, Context = any, Env extends ContextEnvironment = ContextEnvironment, RequiredDomain extends DomainSchemaResult = typeof eventsDomain, Runtime extends ContextRuntime<Env> = ContextRuntime<Env>> = DefineContextActionExecute<TInput, TOutput, Context, Env, RequiredDomain, Runtime>;
+export type LegacyContextActionExecute<TInput extends ContextActionSchema, TOutput extends ContextActionSchema, Context = any, Env extends ContextEnvironment = ContextEnvironment, RequiredDomain extends DomainSchemaResult = typeof eventsDomain, Runtime extends ContextRuntime<Env> = ContextRuntime<Env>> = (input: z.output<TInput>, context: ContextToolExecuteContext<Context, Env, RequiredDomain, Runtime>) => MaybePromise<z.output<TOutput>>;
+export type DefineContextActionDefinition<TInput extends ContextActionSchema, TOutput extends ContextActionSchema, Context = any, Env extends ContextEnvironment = ContextEnvironment, RequiredDomain extends DomainSchemaResult = typeof eventsDomain, Runtime extends ContextRuntime<Env> = ContextRuntime<Env>> = ContextActionBase & {
+    input: TInput;
+    output: TOutput;
+    execute: DefineContextActionExecute<TInput, TOutput, Context, Env, RequiredDomain, Runtime>;
+};
+export type LegacyContextActionDefinition<TInput extends ContextActionSchema, TOutput extends ContextActionSchema, Context = any, Env extends ContextEnvironment = ContextEnvironment, RequiredDomain extends DomainSchemaResult = typeof eventsDomain, Runtime extends ContextRuntime<Env> = ContextRuntime<Env>> = ContextActionBase & {
+    input: TInput;
+    output: TOutput;
+    execute: LegacyContextActionExecute<TInput, TOutput, Context, Env, RequiredDomain, Runtime>;
+};
+export type ContextActionDefinition<TInput extends ContextActionSchema, TOutput extends ContextActionSchema, Context = any, Env extends ContextEnvironment = ContextEnvironment, RequiredDomain extends DomainSchemaResult = typeof eventsDomain, Runtime extends ContextRuntime<Env> = ContextRuntime<Env>> = DefineContextActionDefinition<TInput, TOutput, Context, Env, RequiredDomain, Runtime>;
+export type ContextAction<TInput extends ContextActionSchema = ContextActionSchema, TOutput extends ContextActionSchema = ContextActionSchema, Context = any, Env extends ContextEnvironment = ContextEnvironment, RequiredDomain extends DomainSchemaResult = typeof eventsDomain, Runtime extends ContextRuntime<Env> = ContextRuntime<Env>> = ContextActionBase & {
+    input: TInput;
+    output: TOutput;
+    inputSchema: TInput;
+    outputSchema: TOutput;
+    execute: LegacyContextActionExecute<TInput, TOutput, Context, Env, RequiredDomain, Runtime>;
+};
+export type AnyContextAction = ContextAction<ContextActionSchema, ContextActionSchema, any, any, any, any>;
+export type ContextTool<Context = any, Env extends ContextEnvironment = ContextEnvironment, RequiredDomain extends DomainSchemaResult = typeof eventsDomain, Runtime extends ContextRuntime<Env> = ContextRuntime<Env>> = ContextAction<ContextActionSchema, ContextActionSchema, Context, Env, RequiredDomain, Runtime> | ContextProviderDefinedAction;
+export type ContextActionInput<TAction> = TAction extends ContextAction<infer TInput, any, any, any> ? z.output<TInput> : never;
+export type ContextActionOutput<TAction> = TAction extends ContextAction<any, infer TOutput, any, any> ? z.output<TOutput> : never;
+export declare function defineAction<TInput extends ContextActionSchema, TOutput extends ContextActionSchema, Context = any, Env extends ContextEnvironment = ContextEnvironment, RequiredDomain extends DomainSchemaResult = typeof eventsDomain, Runtime extends ContextRuntime<Env> = ContextRuntime<Env>>(definition: DefineContextActionDefinition<TInput, TOutput, Context, Env, RequiredDomain, Runtime>): ContextAction<TInput, TOutput, Context, Env, RequiredDomain, Runtime>;
+/**
+ * @deprecated Use defineAction().
+ */
+export declare function action<TInput extends ContextActionSchema, TOutput extends ContextActionSchema, Context = any, Env extends ContextEnvironment = ContextEnvironment, RequiredDomain extends DomainSchemaResult = typeof eventsDomain, Runtime extends ContextRuntime<Env> = ContextRuntime<Env>>(definition: LegacyContextActionDefinition<TInput, TOutput, Context, Env, RequiredDomain, Runtime>): ContextAction<TInput, TOutput, Context, Env, RequiredDomain, Runtime>;
+export {};

package/dist/context.action.js

@@ -0,0 +1,25 @@
+function createContextAction(definition, invoke) {
+    const execute = async (input, context) => {
+        const parsedInput = definition.input.parse(input);
+        const result = await invoke(parsedInput, context);
+        return definition.output.parse(result);
+    };
+    return {
+        ...definition,
+        inputSchema: definition.input,
+        outputSchema: definition.output,
+        execute,
+    };
+}
+export function defineAction(definition) {
+    return createContextAction(definition, async (input, context) => await definition.execute({
+        ...context,
+        input,
+    }));
+}
+/**
+ * @deprecated Use defineAction().
+ */
+export function action(definition) {
+    return createContextAction(definition, async (input, context) => await definition.execute(input, context));
+}

package/dist/context.builder.d.ts

@@ -1,62 +1,72 @@
+import type { DomainSchemaResult } from "@ekairos/domain";
 import type { ContextEnvironment } from "./context.config.js";
 import type { ContextSkillPackage } from "./context.skill.js";
-import { ContextEngine, type ContextModelInit, type ContextOptions, type ContextTool, type ShouldContinue, type ContextShouldContinueArgs, type ContextReactParams } from "./context.engine.js";
+import { ContextEngine, type ContextModelInit, type ContextOptions, type ShouldContinue, type ContextShouldContinueArgs, type ContextReactParams, type ContextDirectReactParams, type ContextDurableReactParams, type ContextReactResult, type ContextDirectRun, type ContextWorkflowRun } from "./context.engine.js";
+import type { ContextTool } from "./context.action.js";
+import type { ContextRuntime, ContextRuntimeHandleForDomain } from "./context.runtime.js";
 import type { ContextReactor } from "./context.reactor.js";
 import type { ContextItem, StoredContext } from "./context.store.js";
 import { type ContextKey } from "./context.registry.js";
-export interface ContextConfig<Context, Env extends ContextEnvironment = ContextEnvironment> {
-    context: (context: StoredContext<Context>, env: Env) => Promise<Context> | Context;
-    expandEvents?: (events: ContextItem[], context: StoredContext<Context>, env: Env) => Promise<ContextItem[]> | ContextItem[];
-    narrative: (context: StoredContext<Context>, env: Env) => Promise<string> | string;
-    skills?: (context: StoredContext<Context>, env: Env) => Promise<ContextSkillPackage[]> | ContextSkillPackage[];
-    actions: (context: StoredContext<Context>, env: Env) => Promise<Record<string, ContextTool>> | Record<string, ContextTool>;
+import { eventsDomain } from "./schema.js";
+export interface ContextConfig<Context, Env extends ContextEnvironment = ContextEnvironment, RequiredDomain extends DomainSchemaResult = typeof eventsDomain> {
+    context: (context: StoredContext<Context>, env: Env, runtime: ContextRuntimeHandleForDomain<Env, RequiredDomain>) => Promise<Context> | Context;
+    expandEvents?: (events: ContextItem[], context: StoredContext<Context>, env: Env, runtime: ContextRuntimeHandleForDomain<Env, RequiredDomain>) => Promise<ContextItem[]> | ContextItem[];
+    narrative: (context: StoredContext<Context>, env: Env, runtime: ContextRuntimeHandleForDomain<Env, RequiredDomain>) => Promise<string> | string;
+    skills?: (context: StoredContext<Context>, env: Env, runtime: ContextRuntimeHandleForDomain<Env, RequiredDomain>) => Promise<ContextSkillPackage[]> | ContextSkillPackage[];
+    actions: (context: StoredContext<Context>, env: Env, runtime: ContextRuntimeHandleForDomain<Env, RequiredDomain>) => Promise<Record<string, ContextTool<Context, Env, RequiredDomain>>> | Record<string, ContextTool<Context, Env, RequiredDomain>>;
     /**
      * @deprecated Use `actions()` instead.
      */
-    tools?: (context: StoredContext<Context>, env: Env) => Promise<Record<string, ContextTool>> | Record<string, ContextTool>;
-    model?: ContextModelInit | ((context: StoredContext<Context>, env: Env) => ContextModelInit);
-    reactor?: ContextReactor<Context, Env>;
-    shouldContinue?: (args: ContextShouldContinueArgs<Context, Env>) => Promise<ShouldContinue> | ShouldContinue;
-    opts?: ContextOptions<Context, Env>;
+    tools?: (context: StoredContext<Context>, env: Env, runtime: ContextRuntimeHandleForDomain<Env, RequiredDomain>) => Promise<Record<string, ContextTool<Context, Env, RequiredDomain>>> | Record<string, ContextTool<Context, Env, RequiredDomain>>;
+    model?: ContextModelInit | ((context: StoredContext<Context>, env: Env, runtime: ContextRuntimeHandleForDomain<Env, RequiredDomain>) => ContextModelInit);
+    reactor?: ContextReactor<Context, Env, RequiredDomain>;
+    shouldContinue?: (args: ContextShouldContinueArgs<Context, Env, RequiredDomain>) => Promise<ShouldContinue> | ShouldContinue;
+    opts?: ContextOptions<Context, Env, RequiredDomain>;
 }
-export type ContextInstance<Context, Env extends ContextEnvironment = ContextEnvironment> = ContextEngine<Context, Env> & {
-    readonly __config: ContextConfig<Context, Env>;
+export type ContextInstance<Context, Env extends ContextEnvironment = ContextEnvironment, RequiredDomain extends DomainSchemaResult = typeof eventsDomain> = ContextEngine<Context, Env, RequiredDomain> & {
+    readonly __config: ContextConfig<Context, Env, RequiredDomain>;
     readonly __contextKey?: ContextKey;
+    readonly __contextDomain?: RequiredDomain;
 };
-export declare function context<Context, Env extends ContextEnvironment = ContextEnvironment>(config: ContextConfig<Context, Env>): ContextInstance<Context, Env>;
-type AnyContextInitializer<Env extends ContextEnvironment> = (context: StoredContext<any>, env: Env) => Promise<any> | any;
-type InferContextFromInitializer<I extends AnyContextInitializer<any>> = Awaited<ReturnType<I>>;
-type BuilderSystemPrompt<Context, Env extends ContextEnvironment> = (context: StoredContext<Context>, env: Env) => Promise<string> | string;
-type BuilderSkills<Context, Env extends ContextEnvironment> = (context: StoredContext<Context>, env: Env) => Promise<ContextSkillPackage[]> | ContextSkillPackage[];
-type BuilderTools<Context, Env extends ContextEnvironment> = (context: StoredContext<Context>, env: Env) => Promise<Record<string, ContextTool>> | Record<string, ContextTool>;
-type BuilderExpandEvents<Context, Env extends ContextEnvironment> = (events: ContextItem[], context: StoredContext<Context>, env: Env) => Promise<ContextItem[]> | ContextItem[];
-type BuilderShouldContinue<Context, Env extends ContextEnvironment> = (args: ContextShouldContinueArgs<Context, Env>) => Promise<ShouldContinue> | ShouldContinue;
-type BuilderModel<Context, Env extends ContextEnvironment> = ContextModelInit | ((context: StoredContext<Context>, env: Env) => ContextModelInit);
+export declare function context<Context, Env extends ContextEnvironment = ContextEnvironment, RequiredDomain extends DomainSchemaResult = typeof eventsDomain>(config: ContextConfig<Context, Env, RequiredDomain>): ContextInstance<Context, Env, RequiredDomain>;
+type AnyContextInitializer<Env extends ContextEnvironment, RequiredDomain extends DomainSchemaResult> = (context: StoredContext<any>, env: Env, runtime: ContextRuntimeHandleForDomain<Env, RequiredDomain>) => Promise<any> | any;
+type InferContextFromInitializer<I extends AnyContextInitializer<any, any>> = Awaited<ReturnType<I>>;
+type BuilderSystemPrompt<Context, Env extends ContextEnvironment, RequiredDomain extends DomainSchemaResult> = (context: StoredContext<Context>, env: Env, runtime: ContextRuntimeHandleForDomain<Env, RequiredDomain>) => Promise<string> | string;
+type BuilderSkills<Context, Env extends ContextEnvironment, RequiredDomain extends DomainSchemaResult> = (context: StoredContext<Context>, env: Env, runtime: ContextRuntimeHandleForDomain<Env, RequiredDomain>) => Promise<ContextSkillPackage[]> | ContextSkillPackage[];
+type BuilderTools<Context, Env extends ContextEnvironment, RequiredDomain extends DomainSchemaResult> = (context: StoredContext<Context>, env: Env, runtime: ContextRuntimeHandleForDomain<Env, RequiredDomain>) => Promise<Record<string, ContextTool<Context, Env, RequiredDomain>>> | Record<string, ContextTool<Context, Env, RequiredDomain>>;
+type BuilderExpandEvents<Context, Env extends ContextEnvironment, RequiredDomain extends DomainSchemaResult> = (events: ContextItem[], context: StoredContext<Context>, env: Env, runtime: ContextRuntimeHandleForDomain<Env, RequiredDomain>) => Promise<ContextItem[]> | ContextItem[];
+type BuilderShouldContinue<Context, Env extends ContextEnvironment, RequiredDomain extends DomainSchemaResult> = (args: ContextShouldContinueArgs<Context, Env, RequiredDomain>) => Promise<ShouldContinue> | ShouldContinue;
+type BuilderModel<Context, Env extends ContextEnvironment, RequiredDomain extends DomainSchemaResult> = ContextModelInit | ((context: StoredContext<Context>, env: Env, runtime: ContextRuntimeHandleForDomain<Env, RequiredDomain>) => ContextModelInit);
 export type RegistrableContextBuilder = {
     key: ContextKey;
     register: () => void;
 };
-type FluentContextBuilder<Context, Env extends ContextEnvironment> = {
+type FluentContextBuilder<Context, Env extends ContextEnvironment, RequiredDomain extends DomainSchemaResult> = {
     key: ContextKey;
-    expandEvents(fn: BuilderExpandEvents<Context, Env>): FluentContextBuilder<Context, Env>;
-    narrative(fn: BuilderSystemPrompt<Context, Env>): FluentContextBuilder<Context, Env>;
-    system(fn: BuilderSystemPrompt<Context, Env>): FluentContextBuilder<Context, Env>;
-    skills(fn: BuilderSkills<Context, Env>): FluentContextBuilder<Context, Env>;
-    actions(fn: BuilderTools<Context, Env>): FluentContextBuilder<Context, Env>;
-    tools(fn: BuilderTools<Context, Env>): FluentContextBuilder<Context, Env>;
-    model(model: BuilderModel<Context, Env>): FluentContextBuilder<Context, Env>;
-    reactor(reactor: ContextReactor<Context, Env>): FluentContextBuilder<Context, Env>;
-    shouldContinue(fn: BuilderShouldContinue<Context, Env>): FluentContextBuilder<Context, Env>;
-    opts(opts: ContextOptions<Context, Env>): FluentContextBuilder<Context, Env>;
-    react(triggerEvent: ContextItem, params: ContextReactParams<Env>): ReturnType<ContextEngine<Context, Env>["react"]>;
-    stream(triggerEvent: ContextItem, params: ContextReactParams<Env>): ReturnType<ContextEngine<Context, Env>["react"]>;
+    expandEvents(fn: BuilderExpandEvents<Context, Env, RequiredDomain>): FluentContextBuilder<Context, Env, RequiredDomain>;
+    narrative(fn: BuilderSystemPrompt<Context, Env, RequiredDomain>): FluentContextBuilder<Context, Env, RequiredDomain>;
+    system(fn: BuilderSystemPrompt<Context, Env, RequiredDomain>): FluentContextBuilder<Context, Env, RequiredDomain>;
+    skills(fn: BuilderSkills<Context, Env, RequiredDomain>): FluentContextBuilder<Context, Env, RequiredDomain>;
+    actions(fn: BuilderTools<Context, Env, RequiredDomain>): FluentContextBuilder<Context, Env, RequiredDomain>;
+    tools(fn: BuilderTools<Context, Env, RequiredDomain>): FluentContextBuilder<Context, Env, RequiredDomain>;
+    model(model: BuilderModel<Context, Env, RequiredDomain>): FluentContextBuilder<Context, Env, RequiredDomain>;
+    reactor(reactor: ContextReactor<Context, Env, RequiredDomain>): FluentContextBuilder<Context, Env, RequiredDomain>;
+    shouldContinue(fn: BuilderShouldContinue<Context, Env, RequiredDomain>): FluentContextBuilder<Context, Env, RequiredDomain>;
+    opts(opts: ContextOptions<Context, Env, RequiredDomain>): FluentContextBuilder<Context, Env, RequiredDomain>;
+    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>): ReturnType<ContextEngine<Context, Env, RequiredDomain>["react"]>;
+    stream<Runtime extends ContextRuntime<Env>>(triggerEvent: ContextItem, params: ContextDurableReactParams<Env, RequiredDomain, Runtime>): Promise<ContextReactResult<Context, ContextWorkflowRun<Context>>>;
+    stream<Runtime extends ContextRuntime<Env>>(triggerEvent: ContextItem, params: ContextDirectReactParams<Env, RequiredDomain, Runtime>): Promise<ContextReactResult<Context, ContextDirectRun<Context>>>;
+    stream<Runtime extends ContextRuntime<Env>>(triggerEvent: ContextItem, params: ContextReactParams<Env, RequiredDomain, Runtime>): ReturnType<ContextEngine<Context, Env, RequiredDomain>["react"]>;
     register(): void;
-    config(): ContextConfig<Context, Env>;
-    build(): ContextInstance<Context, Env>;
+    config(): ContextConfig<Context, Env, RequiredDomain>;
+    build(): ContextInstance<Context, Env, RequiredDomain>;
 };
-type CreateContextEntry<Env extends ContextEnvironment> = {
-    context<Initializer extends AnyContextInitializer<Env>>(initializer: Initializer): FluentContextBuilder<InferContextFromInitializer<Initializer>, Env>;
-    initialize<Initializer extends AnyContextInitializer<Env>>(initializer: Initializer): FluentContextBuilder<InferContextFromInitializer<Initializer>, Env>;
+type CreateContextEntry<Env extends ContextEnvironment, RequiredDomain extends DomainSchemaResult> = {
+    context<Initializer extends AnyContextInitializer<Env, RequiredDomain>>(initializer: Initializer): FluentContextBuilder<InferContextFromInitializer<Initializer>, Env, RequiredDomain>;
+    initialize<Initializer extends AnyContextInitializer<Env, RequiredDomain>>(initializer: Initializer): FluentContextBuilder<InferContextFromInitializer<Initializer>, Env, RequiredDomain>;
 };
-export declare function createContext<Env extends ContextEnvironment = ContextEnvironment>(key: ContextKey): CreateContextEntry<Env>;
+export declare function createContext<Env extends ContextEnvironment = ContextEnvironment, RequiredDomain extends DomainSchemaResult = DomainSchemaResult>(domain: RequiredDomain, key: ContextKey): CreateContextEntry<Env, RequiredDomain>;
+export declare function createContext<Env extends ContextEnvironment = ContextEnvironment>(key: ContextKey): CreateContextEntry<Env, typeof eventsDomain>;
 export {};

package/dist/context.builder.js

@@ -1,5 +1,6 @@
 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;
 }
@@ -9,35 +10,35 @@ export function context(config) {
             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);
+                return config.narrative(contextValue, env, runtime);
             throw new Error("Context config is missing narrative()");
         }
-        async buildSkills(contextValue, env) {
+        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)
@@ -59,9 +60,14 @@ function assertConfigComplete(config) {
         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,
         };
@@ -70,7 +76,10 @@ export function createContext(key) {
             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;
@@ -117,12 +126,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();
             },

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 { 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 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 { DomainSchemaResult } from "@ekairos/domain";
 import type { ContextEnvironment } from "./context.config.js";
-import type { ContextRuntime } from "./context.runtime.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, 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 DomainSchemaResult = 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 DomainSchemaResult = 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).
@@ -68,12 +73,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>;
-    /**
-     * Backward-compatible runtime selector. New callers should pass `runtime`.
-     */
-    env?: Env;
+export type ContextReactParams<Env extends ContextEnvironment = ContextEnvironment, RequiredDomain extends DomainSchemaResult = typeof eventsDomain, Runtime extends ContextRuntime<Env> = ContextRuntime<Env>> = {
+    runtime: ContextRuntimeForDomain<Runtime, RequiredDomain>;
     /**
      * Context selector (exclusive: `{ id }` OR `{ key }`).
      * - `{ id }` resolves a concrete context id.
@@ -95,30 +96,40 @@ export type ContextReactParams<Env extends ContextEnvironment = ContextEnvironme
     };
     __benchmark?: ContextBenchmarkRecorder;
 };
-export type ContextReactResult<Context = any> = {
+export type ContextDurableReactParams<Env extends ContextEnvironment = ContextEnvironment, RequiredDomain extends DomainSchemaResult = 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 DomainSchemaResult = 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>>;
 };
-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 DomainSchemaResult = 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 DomainSchemaResult = 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 DomainSchemaResult = typeof eventsDomain, Runtime extends ContextRuntime<Env> = ContextRuntime<Env>> = {
+    runtime: ContextRuntimeForDomain<Runtime, RequiredDomain>;
     context: StoredContext<Context>;
     contextIdentifier: ContextIdentifier;
     toolCallId: string;
@@ -129,6 +140,7 @@ export type ContextToolExecuteContext<Context = any, Env extends ContextEnvironm
     contextId: string;
     stepId: string;
     iteration: number;
+    contextStepStream?: WritableStream<string>;
 };
 export { toolApprovalHookToken, toolApprovalWebhookToken, getClientResumeHookUrl };
 /**
@@ -139,13 +151,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
  *
@@ -157,8 +162,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 DomainSchemaResult = typeof eventsDomain> = {
     env: Env;
+    runtime: ContextRuntimeHandleForDomain<Env, RequiredDomain>;
     context: StoredContext<Context>;
     /**
      * The persisted reaction event **so far** for the current streaming run.
@@ -187,14 +193,14 @@ 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 DomainSchemaResult = 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 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).
      *
@@ -212,9 +218,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.
      *
@@ -223,19 +229,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 DomainSchemaResult, 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;
 }