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

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,7 +1,6 @@
-import { tool } from "ai";
 import { z } from "zod";
-import { createContext } from "./context.js";
-import { didToolExecute } from "./context.toolcalls.js";
+import { createContext, defineAction } from "./context.js";
+import { didActionExecute } from "./context.action-calls.js";
 export const DEFAULT_CODEX_TOOL_NAME = "codex";
 export const DEFAULT_CODEX_MODEL = "openai/gpt-5.2";
 export const codexToolInputSchema = z.object({
@@ -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 {};
@@ -47,7 +54,7 @@ export function buildDefaultCodexNarrative(content) {
     ].join("\n");
 }
 export function didCodexToolExecute(event, toolName = DEFAULT_CODEX_TOOL_NAME) {
-    return didToolExecute(event, toolName);
+    return didActionExecute(event, toolName);
 }
 export function createCodexContextBuilder(config) {
     const toolName = config.toolName ?? DEFAULT_CODEX_TOOL_NAME;
@@ -59,7 +66,7 @@ export function createCodexContextBuilder(config) {
     const model = config.model ??
         ((_ctx, env) => (typeof env.model === "string" && env.model.trim()) || DEFAULT_CODEX_MODEL);
     const shouldContinue = config.shouldContinue ??
-        ((args) => !didToolExecute(args.reactionEvent, toolName));
+        ((args) => !didActionExecute(args.reactionEvent, toolName));
     let builder = createContext(config.key)
         .context(config.context)
         .narrative(narrative)
@@ -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-calls.d.ts

@@ -0,0 +1,48 @@
+/**
+ * ## context.action-calls.ts
+ *
+ * This module isolates the **action-call plumbing** used by `context.engine.ts`.
+ *
+ * In our runtime, provider tool calls are normalized into semantic `action` event parts.
+ * The engine needs to:
+ * - extract a normalized list of action requests from `event.content.parts`, and
+ * - merge action execution outcomes back into those parts.
+ *
+ * Keeping this logic here helps `context.engine.ts` read like orchestration, and keeps
+ * these transformations testable and reusable.
+ */
+import type { ContextItem } from "./context.store.js";
+export type ContextActionCall = {
+    actionCallId: string;
+    actionName: string;
+    args: any;
+};
+/**
+ * Extracts action requests from an event's `parts` array.
+ *
+ * Also accepts raw AI SDK tool UI parts before persistence normalization.
+ */
+export declare function extractActionCallsFromParts(parts: any[] | undefined | null): ContextActionCall[];
+/**
+ * Applies an action execution outcome to the matching action part.
+ *
+ * This does not mutate `parts` — it returns a new array.
+ *
+ * We match by action name and action call id.
+ */
+export declare function applyActionExecutionResultToParts(parts: any[], actionCall: Pick<ContextActionCall, "actionCallId" | "actionName">, execution: {
+    success: boolean;
+    result: any;
+    message?: string;
+}): any[];
+/**
+ * Returns `true` when a given action has a **settled** execution result in an event's parts.
+ *
+ * We treat an action part as "executed" once it has either:
+ * - `state: "output-available"` (success), or
+ * - `state: "output-error"` (failure).
+ *
+ * This is useful for stop/continue logic in `context.shouldContinue(...)` where you want to
+ * decide based on the persisted `reactionEvent` (not ephemeral in-memory arrays).
+ */
+export declare function didActionExecute(event: Pick<ContextItem, "content">, actionName: string): boolean;

package/dist/context.action-calls.js

@@ -0,0 +1,123 @@
+/**
+ * ## context.action-calls.ts
+ *
+ * This module isolates the **action-call plumbing** used by `context.engine.ts`.
+ *
+ * In our runtime, provider tool calls are normalized into semantic `action` event parts.
+ * The engine needs to:
+ * - extract a normalized list of action requests from `event.content.parts`, and
+ * - merge action execution outcomes back into those parts.
+ *
+ * Keeping this logic here helps `context.engine.ts` read like orchestration, and keeps
+ * these transformations testable and reusable.
+ */
+import { isContextPartEnvelope, normalizePartsForPersistence, } from "./context.parts.js";
+/**
+ * Extracts action requests from an event's `parts` array.
+ *
+ * Also accepts raw AI SDK tool UI parts before persistence normalization.
+ */
+export function extractActionCallsFromParts(parts) {
+    const safeParts = parts ?? [];
+    return safeParts.reduce((acc, p) => {
+        if (isContextPartEnvelope(p) && p.type === "action" && p.content.status === "started") {
+            acc.push({
+                actionCallId: p.content.actionCallId,
+                actionName: p.content.actionName,
+                args: p.content.input,
+            });
+            return acc;
+        }
+        if (typeof p?.type === "string" && p.type.startsWith("tool-")) {
+            const actionName = p.type.split("-").slice(1).join("-");
+            acc.push({ actionCallId: p.toolCallId, actionName, args: p.input });
+        }
+        return acc;
+    }, []);
+}
+/**
+ * Applies an action execution outcome to the matching action part.
+ *
+ * This does not mutate `parts` — it returns a new array.
+ *
+ * We match by action name and action call id.
+ */
+export function applyActionExecutionResultToParts(parts, actionCall, execution) {
+    const normalized = normalizePartsForPersistence(parts);
+    const next = [];
+    let insertedResult = false;
+    for (const part of normalized) {
+        next.push(part);
+        if (part.type !== "action" || part.content.status !== "started") {
+            continue;
+        }
+        if (part.content.actionCallId !== actionCall.actionCallId ||
+            part.content.actionName !== actionCall.actionName) {
+            continue;
+        }
+        next.push(execution.success
+            ? {
+                type: "action",
+                content: {
+                    status: "completed",
+                    actionCallId: actionCall.actionCallId,
+                    actionName: actionCall.actionName,
+                    output: execution.result,
+                },
+            }
+            : {
+                type: "action",
+                content: {
+                    status: "failed",
+                    actionCallId: actionCall.actionCallId,
+                    actionName: actionCall.actionName,
+                    error: {
+                        message: String(execution.message || "Error"),
+                    },
+                },
+            });
+        insertedResult = true;
+    }
+    if (!insertedResult) {
+        next.push(execution.success
+            ? {
+                type: "action",
+                content: {
+                    status: "completed",
+                    actionCallId: actionCall.actionCallId,
+                    actionName: actionCall.actionName,
+                    output: execution.result,
+                },
+            }
+            : {
+                type: "action",
+                content: {
+                    status: "failed",
+                    actionCallId: actionCall.actionCallId,
+                    actionName: actionCall.actionName,
+                    error: {
+                        message: String(execution.message || "Error"),
+                    },
+                },
+            });
+    }
+    return next;
+}
+/**
+ * Returns `true` when a given action has a **settled** execution result in an event's parts.
+ *
+ * We treat an action part as "executed" once it has either:
+ * - `state: "output-available"` (success), or
+ * - `state: "output-error"` (failure).
+ *
+ * This is useful for stop/continue logic in `context.shouldContinue(...)` where you want to
+ * decide based on the persisted `reactionEvent` (not ephemeral in-memory arrays).
+ */
+export function didActionExecute(event, actionName) {
+    const parts = (event.content.parts ?? []).flatMap((part) => isContextPartEnvelope(part) ? [part] : normalizePartsForPersistence([part]));
+    return parts.some((p) => (p.type === "action" &&
+        p.content.actionName === actionName &&
+        (p.content.status === "completed" || p.content.status === "failed")) ||
+        (p.type === `tool-${actionName}` &&
+            (p.state === "output-available" || p.state === "output-error")));
+}

package/dist/context.action.d.ts

@@ -0,0 +1,55 @@
+import type { DomainLike } 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 DomainLike = 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 DomainLike = 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 DomainLike = 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 DomainLike = 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 DomainLike = 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 DomainLike = 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 DomainLike = 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 DomainLike = 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 DomainLike = 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 DomainLike = 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 DomainLike = 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,90 @@
+import type { DomainLike } 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 { ContextItem, ContextResource, StoredContext, StoredContextResource } 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 type ContextResourcesParams<Context, Env extends ContextEnvironment = ContextEnvironment, RequiredDomain extends DomainLike = typeof eventsDomain> = {
+    content: Context;
+    context: StoredContext<Context>;
+    env: Env;
+    runtime: ContextRuntimeHandleForDomain<Env, RequiredDomain>;
+};
+export interface ContextConfig<Context, Env extends ContextEnvironment = ContextEnvironment, RequiredDomain extends DomainLike = 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;
+    description?: (content: Context, context: StoredContext<Context>, env: Env, runtime: ContextRuntimeHandleForDomain<Env, RequiredDomain>) => Promise<string> | string;
+    goal?: (content: Context, context: StoredContext<Context>, env: Env, runtime: ContextRuntimeHandleForDomain<Env, RequiredDomain>) => Promise<string> | string;
+    resources?: (params: ContextResourcesParams<Context, Env, RequiredDomain>) => Promise<ContextResource[] | StoredContextResource[]> | ContextResource[] | StoredContextResource[];
+    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 DomainLike = 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 DomainLike = typeof eventsDomain>(config: ContextConfig<Context, Env, RequiredDomain>): ContextInstance<Context, Env, RequiredDomain>;
+type AnyContextInitializer<Env extends ContextEnvironment, RequiredDomain extends DomainLike> = (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 DomainLike> = (context: StoredContext<Context>, env: Env, runtime: ContextRuntimeHandleForDomain<Env, RequiredDomain>) => Promise<string> | string;
+type BuilderDescription<Context, Env extends ContextEnvironment, RequiredDomain extends DomainLike> = (content: Context, context: StoredContext<Context>, env: Env, runtime: ContextRuntimeHandleForDomain<Env, RequiredDomain>) => Promise<string> | string;
+type BuilderGoal<Context, Env extends ContextEnvironment, RequiredDomain extends DomainLike> = BuilderDescription<Context, Env, RequiredDomain>;
+type BuilderResources<Context, Env extends ContextEnvironment, RequiredDomain extends DomainLike> = (params: ContextResourcesParams<Context, Env, RequiredDomain>) => Promise<ContextResource[] | StoredContextResource[] | null> | ContextResource[] | StoredContextResource[] | null;
+type BuilderResource<Context, Env extends ContextEnvironment, RequiredDomain extends DomainLike> = ContextResource | StoredContextResource | ((params: ContextResourcesParams<Context, Env, RequiredDomain>) => Promise<ContextResource | StoredContextResource | null | undefined> | ContextResource | StoredContextResource | null | undefined);
+type BuilderSkills<Context, Env extends ContextEnvironment, RequiredDomain extends DomainLike> = (context: StoredContext<Context>, env: Env, runtime: ContextRuntimeHandleForDomain<Env, RequiredDomain>) => Promise<ContextSkillPackage[]> | ContextSkillPackage[];
+type BuilderTools<Context, Env extends ContextEnvironment, RequiredDomain extends DomainLike> = (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 DomainLike> = (events: ContextItem[], context: StoredContext<Context>, env: Env, runtime: ContextRuntimeHandleForDomain<Env, RequiredDomain>) => Promise<ContextItem[]> | ContextItem[];
+type BuilderShouldContinue<Context, Env extends ContextEnvironment, RequiredDomain extends DomainLike> = (args: ContextShouldContinueArgs<Context, Env, RequiredDomain>) => Promise<ShouldContinue> | ShouldContinue;
+type BuilderModel<Context, Env extends ContextEnvironment, RequiredDomain extends DomainLike> = 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 DomainLike> = {
     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>;
+    description(fn: BuilderDescription<Context, Env, RequiredDomain>): FluentContextBuilder<Context, Env, RequiredDomain>;
+    goal(fn: BuilderGoal<Context, Env, RequiredDomain>): FluentContextBuilder<Context, Env, RequiredDomain>;
+    resources(fn: BuilderResources<Context, Env, RequiredDomain>): FluentContextBuilder<Context, Env, RequiredDomain>;
+    resource(resource: BuilderResource<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 DomainLike> = {
+    content<Initializer extends AnyContextInitializer<Env, RequiredDomain>>(initializer: Initializer): FluentContextBuilder<InferContextFromInitializer<Initializer>, Env, RequiredDomain>;
+    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 DomainLike = DomainLike>(domain: RequiredDomain, key: ContextKey): CreateContextEntry<Env, RequiredDomain>;
+export declare function createContext<Env extends ContextEnvironment = ContextEnvironment>(key: ContextKey): CreateContextEntry<Env, typeof eventsDomain>;
 export {};