@ekairos/events 1.22.82-beta.development.0 → 1.22.84-beta.development.0

package/dist/codex.js

@@ -1,6 +1,6 @@
 import { z } from "zod";
 import { createContext, defineAction } from "./context.js";
-import { didToolExecute } from "./context.toolcalls.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({
@@ -54,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;
@@ -66,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)

package/dist/{context.toolcalls.d.ts → context.action-calls.d.ts}

@@ -1,9 +1,9 @@
 /**
- * ## context.toolcalls.ts
+ * ## context.action-calls.ts
  *
  * This module isolates the **action-call plumbing** used by `context.engine.ts`.
  *
- * In our runtime, model tool calls are normalized into semantic `action` event parts.
+ * 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.
@@ -12,9 +12,9 @@
  * these transformations testable and reusable.
  */
 import type { ContextItem } from "./context.store.js";
-export type ToolCall = {
-    toolCallId: string;
-    toolName: string;
+export type ContextActionCall = {
+    actionCallId: string;
+    actionName: string;
     args: any;
 };
 /**
@@ -22,7 +22,7 @@ export type ToolCall = {
  *
  * Also accepts raw AI SDK tool UI parts before persistence normalization.
  */
-export declare function extractToolCallsFromParts(parts: any[] | undefined | null): ToolCall[];
+export declare function extractActionCallsFromParts(parts: any[] | undefined | null): ContextActionCall[];
 /**
  * Applies an action execution outcome to the matching action part.
  *
@@ -30,19 +30,19 @@ export declare function extractToolCallsFromParts(parts: any[] | undefined | nul
  *
  * We match by action name and action call id.
  */
-export declare function applyToolExecutionResultToParts(parts: any[], toolCall: Pick<ToolCall, "toolCallId" | "toolName">, execution: {
+export declare function applyActionExecutionResultToParts(parts: any[], actionCall: Pick<ContextActionCall, "actionCallId" | "actionName">, execution: {
     success: boolean;
     result: any;
     message?: string;
 }): any[];
 /**
- * Returns `true` when a given tool has a **settled** execution result in an event's parts.
+ * Returns `true` when a given action has a **settled** execution result in an event's parts.
  *
- * We treat a tool part as "executed" once it has either:
+ * 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 didToolExecute(event: Pick<ContextItem, "content">, toolName: string): boolean;
+export declare function didActionExecute(event: Pick<ContextItem, "content">, actionName: string): boolean;

package/dist/{context.toolcalls.js → context.action-calls.js}

@@ -1,9 +1,9 @@
 /**
- * ## context.toolcalls.ts
+ * ## context.action-calls.ts
  *
  * This module isolates the **action-call plumbing** used by `context.engine.ts`.
  *
- * In our runtime, model tool calls are normalized into semantic `action` event parts.
+ * 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.
@@ -17,20 +17,20 @@ import { isContextPartEnvelope, normalizePartsForPersistence, } from "./context.
  *
  * Also accepts raw AI SDK tool UI parts before persistence normalization.
  */
-export function extractToolCallsFromParts(parts) {
+export function extractActionCallsFromParts(parts) {
     const safeParts = parts ?? [];
     return safeParts.reduce((acc, p) => {
         if (isContextPartEnvelope(p) && p.type === "action" && p.content.status === "started") {
             acc.push({
-                toolCallId: p.content.actionCallId,
-                toolName: p.content.actionName,
+                actionCallId: p.content.actionCallId,
+                actionName: p.content.actionName,
                 args: p.content.input,
             });
             return acc;
         }
         if (typeof p?.type === "string" && p.type.startsWith("tool-")) {
-            const toolName = p.type.split("-").slice(1).join("-");
-            acc.push({ toolCallId: p.toolCallId, toolName, args: p.input });
+            const actionName = p.type.split("-").slice(1).join("-");
+            acc.push({ actionCallId: p.toolCallId, actionName, args: p.input });
         }
         return acc;
     }, []);
@@ -42,7 +42,7 @@ export function extractToolCallsFromParts(parts) {
  *
  * We match by action name and action call id.
  */
-export function applyToolExecutionResultToParts(parts, toolCall, execution) {
+export function applyActionExecutionResultToParts(parts, actionCall, execution) {
     const normalized = normalizePartsForPersistence(parts);
     const next = [];
     let insertedResult = false;
@@ -51,8 +51,8 @@ export function applyToolExecutionResultToParts(parts, toolCall, execution) {
         if (part.type !== "action" || part.content.status !== "started") {
             continue;
         }
-        if (part.content.actionCallId !== toolCall.toolCallId ||
-            part.content.actionName !== toolCall.toolName) {
+        if (part.content.actionCallId !== actionCall.actionCallId ||
+            part.content.actionName !== actionCall.actionName) {
             continue;
         }
         next.push(execution.success
@@ -60,8 +60,8 @@ export function applyToolExecutionResultToParts(parts, toolCall, execution) {
                 type: "action",
                 content: {
                     status: "completed",
-                    actionCallId: toolCall.toolCallId,
-                    actionName: toolCall.toolName,
+                    actionCallId: actionCall.actionCallId,
+                    actionName: actionCall.actionName,
                     output: execution.result,
                 },
             }
@@ -69,8 +69,8 @@ export function applyToolExecutionResultToParts(parts, toolCall, execution) {
                 type: "action",
                 content: {
                     status: "failed",
-                    actionCallId: toolCall.toolCallId,
-                    actionName: toolCall.toolName,
+                    actionCallId: actionCall.actionCallId,
+                    actionName: actionCall.actionName,
                     error: {
                         message: String(execution.message || "Error"),
                     },
@@ -84,8 +84,8 @@ export function applyToolExecutionResultToParts(parts, toolCall, execution) {
                 type: "action",
                 content: {
                     status: "completed",
-                    actionCallId: toolCall.toolCallId,
-                    actionName: toolCall.toolName,
+                    actionCallId: actionCall.actionCallId,
+                    actionName: actionCall.actionName,
                     output: execution.result,
                 },
             }
@@ -93,8 +93,8 @@ export function applyToolExecutionResultToParts(parts, toolCall, execution) {
                 type: "action",
                 content: {
                     status: "failed",
-                    actionCallId: toolCall.toolCallId,
-                    actionName: toolCall.toolName,
+                    actionCallId: actionCall.actionCallId,
+                    actionName: actionCall.actionName,
                     error: {
                         message: String(execution.message || "Error"),
                     },
@@ -104,20 +104,20 @@ export function applyToolExecutionResultToParts(parts, toolCall, execution) {
     return next;
 }
 /**
- * Returns `true` when a given tool has a **settled** execution result in an event's parts.
+ * Returns `true` when a given action has a **settled** execution result in an event's parts.
  *
- * We treat a tool part as "executed" once it has either:
+ * 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 didToolExecute(event, toolName) {
+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 === toolName &&
+        p.content.actionName === actionName &&
         (p.content.status === "completed" || p.content.status === "failed")) ||
-        (p.type === `tool-${toolName}` &&
+        (p.type === `tool-${actionName}` &&
             (p.state === "output-available" || p.state === "output-error")));
 }

package/dist/context.action.d.ts

@@ -1,4 +1,4 @@
-import type { DomainSchemaResult } from "@ekairos/domain";
+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";
@@ -19,24 +19,24 @@ export type ContextProviderDefinedAction = {
     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> & {
+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 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 & {
+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 DomainSchemaResult = typeof eventsDomain, Runtime extends ContextRuntime<Env> = ContextRuntime<Env>> = ContextActionBase & {
+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 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 & {
+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;
@@ -44,12 +44,12 @@ export type ContextAction<TInput extends ContextActionSchema = ContextActionSche
     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 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 DomainSchemaResult = typeof eventsDomain, Runtime extends ContextRuntime<Env> = ContextRuntime<Env>>(definition: DefineContextActionDefinition<TInput, TOutput, Context, Env, RequiredDomain, Runtime>): ContextAction<TInput, TOutput, Context, Env, RequiredDomain, Runtime>;
+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 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 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.builder.d.ts

@@ -1,17 +1,26 @@
-import type { DomainSchemaResult } from "@ekairos/domain";
+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 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";
 import { eventsDomain } from "./schema.js";
-export interface ContextConfig<Context, Env extends ContextEnvironment = ContextEnvironment, RequiredDomain extends DomainSchemaResult = typeof eventsDomain> {
+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;
+    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>>;
     /**
@@ -23,29 +32,37 @@ export interface ContextConfig<Context, Env extends ContextEnvironment = Context
     shouldContinue?: (args: ContextShouldContinueArgs<Context, Env, RequiredDomain>) => Promise<ShouldContinue> | ShouldContinue;
     opts?: ContextOptions<Context, Env, RequiredDomain>;
 }
-export type ContextInstance<Context, Env extends ContextEnvironment = ContextEnvironment, RequiredDomain extends DomainSchemaResult = typeof eventsDomain> = ContextEngine<Context, Env, RequiredDomain> & {
+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, 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;
+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 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);
+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, RequiredDomain extends DomainSchemaResult> = {
+type FluentContextBuilder<Context, Env extends ContextEnvironment, RequiredDomain extends DomainLike> = {
     key: ContextKey;
     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>;
@@ -63,10 +80,11 @@ type FluentContextBuilder<Context, Env extends ContextEnvironment, RequiredDomai
     config(): ContextConfig<Context, Env, RequiredDomain>;
     build(): ContextInstance<Context, Env, RequiredDomain>;
 };
-type CreateContextEntry<Env extends ContextEnvironment, RequiredDomain extends DomainSchemaResult> = {
+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, RequiredDomain extends DomainSchemaResult = DomainSchemaResult>(domain: RequiredDomain, key: ContextKey): CreateContextEntry<Env, RequiredDomain>;
+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

@@ -4,6 +4,28 @@ 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() {
@@ -21,7 +43,36 @@ export function context(config) {
         async buildSystemPrompt(contextValue, env, runtime) {
             if (config.narrative)
                 return config.narrative(contextValue, env, runtime);
-            throw new Error("Context config is missing narrative()");
+            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 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)
@@ -51,10 +102,10 @@ 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.");
@@ -71,6 +122,20 @@ export function createContext(keyOrDomain, maybeKey) {
         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);
@@ -98,6 +163,30 @@ export function createContext(keyOrDomain, maybeKey) {
                 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;
@@ -142,6 +231,7 @@ export function createContext(keyOrDomain, maybeKey) {
         return builder;
     };
     return {
+        content: initializeBuilder,
         context: initializeBuilder,
         initialize: initializeBuilder,
     };

package/dist/context.d.ts

@@ -1,5 +1,5 @@
 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 { 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";