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

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 {};

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 ContextDurableWorkflowPayload, type ContextDurableWorkflowFunction, type ContextModelInit, type ContextTool, 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";