@ekairos/events 1.22.81-beta.development.0 → 1.22.83-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,4 +1,4 @@
-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";
@@ -8,7 +8,7 @@ import type { ContextReactor } from "./context.reactor.js";
 import type { ContextItem, StoredContext } 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 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;
@@ -23,25 +23,25 @@ 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 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>;
@@ -63,10 +63,10 @@ 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> = {
     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.engine.d.ts

@@ -1,5 +1,5 @@
 import type { ModelMessage, UIMessageChunk } from "ai";
-import type { DomainSchemaResult } from "@ekairos/domain";
+import type { DomainLike } from "@ekairos/domain";
 import type { ContextEnvironment } from "./context.config.js";
 import type { ContextTool } from "./context.action.js";
 import type { ContextRuntime, ContextRuntimeHandleForDomain, ContextRuntimeForDomain } from "./context.runtime.js";
@@ -8,7 +8,7 @@ import type { ContextExecution, ContextItem, ContextIdentifier, StoredContext }
 import type { ContextSkillPackage } from "./context.skill.js";
 import { type ContextReactor } from "./context.reactor.js";
 import { getClientResumeHookUrl, toolApprovalHookToken, toolApprovalWebhookToken } from "./context.hooks.js";
-export interface ContextOptions<Context = any, Env extends ContextEnvironment = ContextEnvironment, RequiredDomain extends DomainSchemaResult = typeof eventsDomain> {
+export interface ContextOptions<Context = any, Env extends ContextEnvironment = ContextEnvironment, RequiredDomain extends DomainLike = typeof eventsDomain> {
     onContextCreated?: (args: {
         env: Env;
         runtime: ContextRuntimeHandleForDomain<Env, RequiredDomain>;
@@ -28,7 +28,7 @@ type ContextBenchmarkRecorder = {
     add?(name: string, value: number): void;
     getCurrentStage?(): string | undefined;
 };
-export declare function runContextReactionDirect<Context, Env extends ContextEnvironment = ContextEnvironment, RequiredDomain extends DomainSchemaResult = typeof eventsDomain, Runtime extends ContextRuntime<Env> = ContextRuntime<Env>>(context: ContextEngine<Context, Env, RequiredDomain>, triggerEvent: ContextItem, params: ContextReactParams<Env, RequiredDomain, Runtime>): Promise<ContextReactResult<Context>>;
+export declare function runContextReactionDirect<Context, Env extends ContextEnvironment = ContextEnvironment, RequiredDomain extends DomainLike = typeof eventsDomain, Runtime extends ContextRuntime<Env> = ContextRuntime<Env>>(context: ContextEngine<Context, Env, RequiredDomain>, triggerEvent: ContextItem, params: ContextReactParams<Env, RequiredDomain, Runtime>): Promise<ContextReactResult<Context>>;
 export interface ContextStreamOptions {
     /**
      * Maximum loop iterations (LLM call → tool execution → repeat).
@@ -73,7 +73,7 @@ export interface ContextStreamOptions {
  *   be a `"use-step"` function (so it can be serialized by reference).
  */
 export type ContextModelInit = string | (() => Promise<any>);
-export type ContextReactParams<Env extends ContextEnvironment = ContextEnvironment, RequiredDomain extends DomainSchemaResult = typeof eventsDomain, Runtime extends ContextRuntime<Env> = ContextRuntime<Env>> = {
+export type ContextReactParams<Env extends ContextEnvironment = ContextEnvironment, RequiredDomain extends DomainLike = typeof eventsDomain, Runtime extends ContextRuntime<Env> = ContextRuntime<Env>> = {
     runtime: ContextRuntimeForDomain<Runtime, RequiredDomain>;
     /**
      * Context selector (exclusive: `{ id }` OR `{ key }`).
@@ -98,10 +98,10 @@ export type ContextReactParams<Env extends ContextEnvironment = ContextEnvironme
     __initialContent?: unknown;
     __benchmark?: ContextBenchmarkRecorder;
 };
-export type ContextDurableReactParams<Env extends ContextEnvironment = ContextEnvironment, RequiredDomain extends DomainSchemaResult = typeof eventsDomain, Runtime extends ContextRuntime<Env> = ContextRuntime<Env>> = Omit<ContextReactParams<Env, RequiredDomain, Runtime>, "durable"> & {
+export type ContextDurableReactParams<Env extends ContextEnvironment = ContextEnvironment, RequiredDomain extends DomainLike = typeof eventsDomain, Runtime extends ContextRuntime<Env> = ContextRuntime<Env>> = Omit<ContextReactParams<Env, RequiredDomain, Runtime>, "durable"> & {
     durable?: true | undefined;
 };
-export type ContextDirectReactParams<Env extends ContextEnvironment = ContextEnvironment, RequiredDomain extends DomainSchemaResult = typeof eventsDomain, Runtime extends ContextRuntime<Env> = ContextRuntime<Env>> = Omit<ContextReactParams<Env, RequiredDomain, Runtime>, "durable"> & {
+export type ContextDirectReactParams<Env extends ContextEnvironment = ContextEnvironment, RequiredDomain extends DomainLike = typeof eventsDomain, Runtime extends ContextRuntime<Env> = ContextRuntime<Env>> = Omit<ContextReactParams<Env, RequiredDomain, Runtime>, "durable"> & {
     durable: false;
 };
 export type ContextReactBase<Context = any> = {
@@ -125,7 +125,7 @@ export type ContextReactRun<Context = any> = ContextWorkflowRun<Context> | Conte
 export type ContextReactResult<Context = any, Run extends ContextReactRun<Context> = ContextReactRun<Context>> = ContextReactBase<Context> & {
     run?: Run;
 };
-export type ContextDurableWorkflowPayload<Env extends ContextEnvironment = ContextEnvironment, RequiredDomain extends DomainSchemaResult = typeof eventsDomain, Runtime extends ContextRuntime<Env> = ContextRuntime<Env>> = {
+export type ContextDurableWorkflowPayload<Env extends ContextEnvironment = ContextEnvironment, RequiredDomain extends DomainLike = typeof eventsDomain, Runtime extends ContextRuntime<Env> = ContextRuntime<Env>> = {
     contextKey: string;
     runtime: ContextRuntimeForDomain<Runtime, RequiredDomain>;
     context?: ContextIdentifier | null;
@@ -133,8 +133,8 @@ export type ContextDurableWorkflowPayload<Env extends ContextEnvironment = Conte
     options?: Omit<ContextStreamOptions, "writable">;
     bootstrap: NonNullable<ContextReactParams<Env, RequiredDomain, Runtime>["__bootstrap"]>;
 };
-export type ContextDurableWorkflowFunction<Context = any, Env extends ContextEnvironment = ContextEnvironment, RequiredDomain extends DomainSchemaResult = typeof eventsDomain, Runtime extends ContextRuntime<Env> = ContextRuntime<Env>> = (payload: ContextDurableWorkflowPayload<Env, RequiredDomain, Runtime>) => Promise<ContextReactFinalResult<Context>>;
-export type ContextToolExecuteContext<Context = any, Env extends ContextEnvironment = ContextEnvironment, RequiredDomain extends DomainSchemaResult = typeof eventsDomain, Runtime extends ContextRuntime<Env> = ContextRuntime<Env>> = {
+export type ContextDurableWorkflowFunction<Context = any, Env extends ContextEnvironment = ContextEnvironment, RequiredDomain extends DomainLike = typeof eventsDomain, Runtime extends ContextRuntime<Env> = ContextRuntime<Env>> = (payload: ContextDurableWorkflowPayload<Env, RequiredDomain, Runtime>) => Promise<ContextReactFinalResult<Context>>;
+export type ContextToolExecuteContext<Context = any, Env extends ContextEnvironment = ContextEnvironment, RequiredDomain extends DomainLike = typeof eventsDomain, Runtime extends ContextRuntime<Env> = ContextRuntime<Env>> = {
     runtime: ContextRuntimeForDomain<Runtime, RequiredDomain>;
     context: StoredContext<Context>;
     contextIdentifier: ContextIdentifier;
@@ -168,7 +168,7 @@ export { toolApprovalHookToken, toolApprovalWebhookToken, getClientResumeHookUrl
  * (No imports required in callers.)
  */
 export type ShouldContinue = boolean;
-export type ContextShouldContinueArgs<Context = any, Env extends ContextEnvironment = ContextEnvironment, RequiredDomain extends DomainSchemaResult = typeof eventsDomain> = {
+export type ContextShouldContinueArgs<Context = any, Env extends ContextEnvironment = ContextEnvironment, RequiredDomain extends DomainLike = typeof eventsDomain> = {
     env: Env;
     runtime: ContextRuntimeHandleForDomain<Env, RequiredDomain>;
     context: StoredContext<Context>;
@@ -199,7 +199,7 @@ export type ContextShouldContinueArgs<Context = any, Env extends ContextEnvironm
         errorText?: string;
     }>;
 };
-export declare abstract class ContextEngine<Context, Env extends ContextEnvironment = ContextEnvironment, RequiredDomain extends DomainSchemaResult = typeof eventsDomain> {
+export declare abstract class ContextEngine<Context, Env extends ContextEnvironment = ContextEnvironment, RequiredDomain extends DomainLike = typeof eventsDomain> {
     protected readonly opts: ContextOptions<Context, Env, RequiredDomain>;
     private readonly reactor;
     constructor(opts?: ContextOptions<Context, Env, RequiredDomain>, reactor?: ContextReactor<Context, Env, RequiredDomain>);
@@ -241,7 +241,7 @@ export declare abstract class ContextEngine<Context, Env extends ContextEnvironm
     react<Runtime extends ContextRuntime<Env>>(triggerEvent: ContextItem, params: ContextReactParams<Env, RequiredDomain, Runtime>): Promise<ContextReactResult<Context>>;
     private static prepareExecutionShell;
     private static startDurable;
-    static runDirect<Context, Env extends ContextEnvironment, RequiredDomain extends DomainSchemaResult, Runtime extends ContextRuntime<Env>>(story: ContextEngine<Context, Env, RequiredDomain>, triggerEvent: ContextItem, params: ContextReactParams<Env, RequiredDomain, Runtime>): Promise<ContextReactResult<Context, ContextDirectRun<Context>>>;
+    static runDirect<Context, Env extends ContextEnvironment, RequiredDomain extends DomainLike, Runtime extends ContextRuntime<Env>>(story: ContextEngine<Context, Env, RequiredDomain>, triggerEvent: ContextItem, params: ContextReactParams<Env, RequiredDomain, Runtime>): Promise<ContextReactResult<Context, ContextDirectRun<Context>>>;
     /**
      * @deprecated Use `react()` instead. Kept for backwards compatibility.
      */

package/dist/context.engine.js

@@ -1,6 +1,6 @@
 import { getContextRuntimeServices } from "./context.runtime.js";
 import { OUTPUT_ITEM_TYPE, WEB_CHANNEL } from "./context.events.js";
-import { applyToolExecutionResultToParts } from "./context.toolcalls.js";
+import { applyActionExecutionResultToParts } from "./context.action-calls.js";
 import { isContextPartEnvelope, normalizePartsForPersistence, } from "./context.parts.js";
 import { createAiSdkReactor, } from "./context.reactor.js";
 import { abortPersistedContextStepStream, closeContextStream, createPersistedContextStepStreamForRuntime, finalizePersistedContextStepStreamForRuntime, writeActionResultPartChunksToSession, } from "./steps/stream.steps.js";
@@ -706,6 +706,13 @@ export class ContextEngine {
         try {
             for (let iter = 0; iter < maxIterations; iter++) {
                 const stagePrefix = `react.iteration.${iter}`;
+                runtimeHandle.__ekairosContextRun = {
+                    contextId: currentContext.id,
+                    executionId,
+                    triggerEventId,
+                    reactionEventId,
+                    iteration: iter,
+                };
                 // Hook: Context DSL `context()` (implemented by subclasses via `initialize()`)
                 const nextContent = await measureBenchmark(params.__benchmark, `${stagePrefix}.contextMs`, async () => await story.initialize(updatedContext, env, runtimeHandle));
                 const openedStep = await measureBenchmark(params.__benchmark, `${stagePrefix}.openExecutionStepMs`, async () => await ops.openExecutionStep({
@@ -1057,9 +1064,9 @@ export class ContextEngine {
                 // Merge action results into step parts so the next reaction can see them.
                 let finalizedStepParts = Array.isArray(stepParts) ? [...stepParts] : [];
                 for (const r of actionResults) {
-                    finalizedStepParts = applyToolExecutionResultToParts(finalizedStepParts, {
-                        toolCallId: r.actionRequest.actionRef,
-                        toolName: r.actionRequest.actionName,
+                    finalizedStepParts = applyActionExecutionResultToParts(finalizedStepParts, {
+                        actionCallId: r.actionRequest.actionRef,
+                        actionName: r.actionRequest.actionName,
                     }, {
                         success: Boolean(r.success),
                         result: r.output,

package/dist/context.parts.js

@@ -216,6 +216,58 @@ function normalizeFileContentBlock(value) {
         fileId: typeof value.fileId === "string" ? value.fileId : undefined,
     }));
 }
+function normalizeInlineContentBlock(value) {
+    const record = asRecord(value);
+    if (!record || typeof record.type !== "string")
+        return null;
+    if (record.type === "text" && typeof record.text === "string") {
+        return contextInlineContentSchema.parse({ type: "text", text: record.text });
+    }
+    if (record.type === "json") {
+        return contextInlineContentSchema.parse({ type: "json", value: record.value });
+    }
+    if (record.type === "file" || record.type === "image-data") {
+        return normalizeFileContentBlock(record);
+    }
+    return null;
+}
+function normalizeInlineContentBlocks(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value
+        .map((block) => normalizeInlineContentBlock(block))
+        .filter((block) => Boolean(block));
+}
+function contentBlocksToActionValue(blocks) {
+    if (blocks.length === 0)
+        return undefined;
+    if (blocks.length === 1) {
+        const [first] = blocks;
+        if (first.type === "json")
+            return first.value;
+        if (first.type === "text")
+            return first.text;
+        if (first.type === "file")
+            return first;
+    }
+    return {
+        type: "content",
+        value: blocks,
+    };
+}
+function contentBlocksToErrorMessage(blocks) {
+    const text = blocks
+        .filter((block) => block.type === "text")
+        .map((block) => block.text)
+        .join("\n\n")
+        .trim();
+    if (text)
+        return text;
+    const jsonBlock = blocks.find((block) => block.type === "json");
+    if (jsonBlock)
+        return JSON.stringify(jsonBlock.value, null, 2);
+    return "";
+}
 function readReactorMetadata(record) {
     const parsed = reactorMetadataSchema.safeParse(record.reactorMetadata);
     return parsed.success ? parsed.data : undefined;
@@ -239,6 +291,62 @@ function messageFromBlocks(blocks, reactorMetadata) {
         })),
     ];
 }
+function normalizeExternalToolCallPart(record, reactorMetadata) {
+    const actionName = typeof record.toolName === "string" && record.toolName.length > 0
+        ? record.toolName
+        : "";
+    const actionCallId = typeof record.toolCallId === "string" && record.toolCallId.length > 0
+        ? record.toolCallId
+        : "";
+    if (!actionName || !actionCallId)
+        return [];
+    const blocks = normalizeInlineContentBlocks(record.content);
+    return [
+        contextActionPartSchema.parse(cleanRecord({
+            type: "action",
+            content: {
+                status: "started",
+                actionName,
+                actionCallId,
+                input: contentBlocksToActionValue(blocks),
+            },
+            reactorMetadata,
+        })),
+    ];
+}
+function normalizeExternalToolResultPart(record, reactorMetadata) {
+    const actionName = typeof record.toolName === "string" && record.toolName.length > 0
+        ? record.toolName
+        : "";
+    const actionCallId = typeof record.toolCallId === "string" && record.toolCallId.length > 0
+        ? record.toolCallId
+        : "";
+    if (!actionName || !actionCallId)
+        return [];
+    const blocks = normalizeInlineContentBlocks(record.content);
+    const failed = record.state === "output-error";
+    return [
+        contextActionPartSchema.parse(cleanRecord({
+            type: "action",
+            content: failed
+                ? {
+                    status: "failed",
+                    actionName,
+                    actionCallId,
+                    error: {
+                        message: contentBlocksToErrorMessage(blocks) || "Action execution failed.",
+                    },
+                }
+                : {
+                    status: "completed",
+                    actionName,
+                    actionCallId,
+                    output: contentBlocksToActionValue(blocks),
+                },
+            reactorMetadata,
+        })),
+    ];
+}
 export function normalizeUiPartToContextPartEnvelopes(value) {
     const record = asRecord(value);
     if (!record || typeof record.type !== "string") {
@@ -307,6 +415,12 @@ export function normalizeUiPartToContextPartEnvelopes(value) {
     if (record.type.startsWith("data-")) {
         return messageFromBlocks([{ type: "json", value: record.data }], reactorMetadata);
     }
+    if (record.type === "tool-call") {
+        return normalizeExternalToolCallPart(record, reactorMetadata);
+    }
+    if (record.type === "tool-result") {
+        return normalizeExternalToolResultPart(record, reactorMetadata);
+    }
     if (record.type.startsWith("tool-")) {
         const actionName = record.type.slice("tool-".length);
         const actionCallId = typeof record.toolCallId === "string" ? record.toolCallId : "";

package/dist/context.runtime.d.ts

@@ -1,4 +1,4 @@
-import type { ActiveDomain, ConcreteDomain, DomainSchemaResult } from "@ekairos/domain";
+import type { ConcreteDomain, DomainLike } from "@ekairos/domain";
 import type { EkairosRuntime, RuntimeForDomain, RuntimeResolveOptions } from "@ekairos/domain/runtime";
 import type { ContextEnvironment } from "./context.config.js";
 import type { ContextStore } from "./context.store.js";
@@ -9,10 +9,10 @@ export type ContextRuntimeServiceHandle = {
     resolve?: (...args: any[]) => Promise<any> | any;
     meta?: (...args: any[]) => Record<string, unknown> | undefined;
 };
-export type ContextRuntimeHandleForDomain<Env extends ContextEnvironment = ContextEnvironment, RequiredDomain extends DomainSchemaResult = typeof eventsDomain> = ContextRuntimeServiceHandle & {
-    use<Subdomain extends typeof eventsDomain | RequiredDomain>(subdomain: Subdomain, options?: RuntimeResolveOptions): Promise<Omit<ActiveDomain<Subdomain, Env>, "env">>;
+export type ContextRuntimeHandleForDomain<Env extends ContextEnvironment = ContextEnvironment, RequiredDomain extends DomainLike = typeof eventsDomain> = ContextRuntimeServiceHandle & {
+    use<Subdomain extends typeof eventsDomain | RequiredDomain>(subdomain: Subdomain, options?: RuntimeResolveOptions): Promise<unknown>;
 };
-export type ContextRuntimeForDomain<Runtime extends ContextRuntime<any>, RequiredDomain extends DomainSchemaResult = typeof eventsDomain> = RuntimeForDomain<Runtime, typeof eventsDomain> & RuntimeForDomain<Runtime, RequiredDomain>;
+export type ContextRuntimeForDomain<Runtime extends ContextRuntime<any>, RequiredDomain extends DomainLike = typeof eventsDomain> = RuntimeForDomain<Runtime, typeof eventsDomain> & RuntimeForDomain<Runtime, RequiredDomain>;
 export type ContextRuntimeServices = {
     db: any;
     store: ContextStore;

package/dist/index.d.ts

@@ -3,7 +3,7 @@ export type { ContextStore, ContextIdentifier, StoredContext, ContextItem, Conte
 export type { WireDate, ContextMirrorContext, ContextMirrorExecution, ContextMirrorWrite, ContextMirrorRequest, } from "./mirror.js";
 export { registerContext, getContext, getContextFactory, hasContext, listContexts, type ContextKey, } from "./context.registry.js";
 export { eventsDomain } from "./schema.js";
-export { didToolExecute, extractToolCallsFromParts } from "./context.toolcalls.js";
+export { didActionExecute, extractActionCallsFromParts, type ContextActionCall, } from "./context.action-calls.js";
 export { actionsToActionSpecs, actionSpecToAiSdkTool, type SerializableActionSpec, type SerializableFunctionActionSpec, type SerializableProviderDefinedActionSpec, } from "./tools-to-model-tools.js";
 export { reactorMetadataSchema, contextPartSchema, contextPartEnvelopeSchema, contextPartContentSchema, contextMessagePartSchema, contextReasoningPartSchema, contextSourcePartSchema, contextActionPartSchema, contextEnginePartSchema, createContextPartSchema, parseContextPart, isContextPartEnvelope, parseContextPartEnvelope, normalizePartsForPersistence, } from "./context.parts.js";
 export type { ReactorMetadata, ContextEnginePart, ContextActionPart, ContextActionStartedPart, ContextActionCompletedPart, ContextActionFailedPart, ContextPartActionMap, ContextPart, ContextPartEnvelope, ContextPartContent, ContextInlineContent, } from "./context.parts.js";

package/dist/index.js

@@ -1,7 +1,7 @@
 export { context, createContext, createAiSdkReactor, createScriptedReactor, ContextEngine, defineAction, action, runContextReactionDirect, } from "./context.js";
 export { registerContext, getContext, getContextFactory, hasContext, listContexts, } from "./context.registry.js";
 export { eventsDomain } from "./schema.js";
-export { didToolExecute, extractToolCallsFromParts } from "./context.toolcalls.js";
+export { didActionExecute, extractActionCallsFromParts, } from "./context.action-calls.js";
 export { actionsToActionSpecs, actionSpecToAiSdkTool, } from "./tools-to-model-tools.js";
 export { reactorMetadataSchema, contextPartSchema, contextPartEnvelopeSchema, contextPartContentSchema, contextMessagePartSchema, contextReasoningPartSchema, contextSourcePartSchema, contextActionPartSchema, contextEnginePartSchema, createContextPartSchema, parseContextPart, isContextPartEnvelope, parseContextPartEnvelope, normalizePartsForPersistence, } from "./context.parts.js";
 export { INPUT_ITEM_TYPE, INPUT_TEXT_ITEM_TYPE, OUTPUT_ITEM_TYPE, WEB_CHANNEL, AGENT_CHANNEL, EMAIL_CHANNEL, createUserItemFromUIMessages, createAssistantItemFromUIMessages, convertToUIMessage, convertItemToModelMessages, convertItemsToModelMessages, convertModelMessageToItem, isContextOutputPart, normalizeContextOutputPart, } from "./context.events.js";

package/dist/react.step-stream.js

@@ -71,6 +71,72 @@ function parseActionInputText(value) {
         return value;
     }
 }
+function firstString(...values) {
+    for (const value of values) {
+        const text = asString(value).trim();
+        if (text)
+            return text;
+    }
+    return "";
+}
+function firstDefined(...values) {
+    for (const value of values) {
+        if (value !== undefined)
+            return value;
+    }
+    return undefined;
+}
+function parseMaybeJsonValue(value) {
+    if (typeof value !== "string")
+        return value;
+    return parseActionInputText(value);
+}
+function providerContentItemsToValue(value) {
+    if (!Array.isArray(value)) {
+        const record = asRecord(value);
+        if (Array.isArray(record.contentItems))
+            return providerContentItemsToValue(record.contentItems);
+        if (record.output !== undefined)
+            return parseMaybeJsonValue(record.output);
+        return parseMaybeJsonValue(value);
+    }
+    const blocks = value
+        .map((entry) => {
+        const record = asRecord(entry);
+        if (record.type === "inputText" ||
+            record.type === "outputText" ||
+            record.type === "text" ||
+            record.type === "input_text") {
+            const text = asString(record.text || record.input_text);
+            return text ? parseMaybeJsonValue(text) : undefined;
+        }
+        return Object.keys(record).length > 0 ? record : undefined;
+    })
+        .filter((entry) => entry !== undefined);
+    if (blocks.length === 0)
+        return undefined;
+    if (blocks.length === 1)
+        return blocks[0];
+    return { type: "content", value: blocks };
+}
+function readProviderActionDetails(params) {
+    const result = asRecord(params.rawParams.result);
+    const rawError = asRecord(params.rawParams.error);
+    const resultError = asRecord(result.error);
+    const rawItemError = asRecord(params.rawItem.error);
+    const actionCallId = firstString(params.data.actionCallId, params.raw.actionCallId, params.rawParams.actionCallId, params.data.toolCallId, params.rawParams.callId, params.rawParams.toolCallId, params.rawParams.itemId, params.rawParams.id, params.rawItem.callId, params.rawItem.toolCallId, params.rawItem.itemId, params.rawItem.id, params.raw.toolCallId, params.raw.id);
+    const actionName = firstString(params.data.actionName, params.raw.actionName, params.rawParams.actionName, params.rawParams.tool, params.rawParams.toolName, params.rawParams.name, params.rawItem.actionName, params.rawItem.tool, params.rawItem.toolName, params.rawItem.name, params.raw.toolName, params.raw.name);
+    const input = parseMaybeJsonValue(firstDefined(params.data.input, params.data.arguments, params.raw.input, params.raw.args, params.raw.arguments, params.rawParams.arguments, params.rawParams.input, params.rawParams.args, params.rawItem.arguments, params.rawItem.input, params.rawItem.args));
+    const output = providerContentItemsToValue(firstDefined(params.data.output, params.data.result, params.rawParams.output, result.output, result.value, result.contentItems, params.raw.output, params.raw.result, params.rawItem.output, params.rawItem.result));
+    const errorText = firstString(params.data.error, asRecord(params.data.error).message, params.rawParams.errorText, params.rawParams.error, rawError.message, result.errorText, result.error, resultError.message, params.rawItem.errorText, params.rawItem.error, rawItemError.message, asRecord(params.raw.error).message);
+    return {
+        actionCallId,
+        actionName,
+        input,
+        output,
+        errorText,
+    };
+}
 function readActionInputDelta(params) {
     return (asString(params.chunk.text) ||
         asString(params.data.text) ||
@@ -278,28 +344,19 @@ export function buildLiveEventFromStepChunks(params) {
             const raw = asRecord(chunk.raw);
             const rawParams = asRecord(raw.params);
             const rawItem = asRecord(rawParams.item);
+            const providerAction = readProviderActionDetails({
+                data,
+                raw,
+                rawParams,
+                rawItem,
+            });
             const actionRef = asString(chunk.actionRef) ||
                 asString(chunk.providerPartId) ||
-                asString(data.actionCallId) ||
-                asString(data.toolCallId) ||
-                asString(data.callId) ||
-                asString(data.itemId) ||
-                asString(data.id) ||
-                asString(rawParams.callId) ||
-                asString(rawParams.itemId) ||
-                asString(rawItem.id) ||
-                asString(raw.toolCallId) ||
-                asString(raw.id);
+                providerAction.actionCallId;
             if (!actionRef)
                 continue;
-            const toolName = asString(data.actionName) ||
-                asString(data.toolName) ||
-                asString(rawParams.tool) ||
-                asString(rawItem.command ? "sandbox_run_command" : "") ||
-                asString(raw.actionName) ||
-                asString(raw.toolName) ||
-                asString(raw.name) ||
-                actionParts.get(actionRef)?.toolName ||
+            const actionName = providerAction.actionName ||
+                actionParts.get(actionRef)?.actionName ||
                 "reactorAction";
             const previous = actionParts.get(actionRef);
             const inputDeltaText = readActionInputDelta({
@@ -318,22 +375,13 @@ export function buildLiveEventFromStepChunks(params) {
                 ? `${previous?.inputDeltaText ?? ""}${inputDeltaText}`
                 : previous?.inputDeltaText ?? "";
             const parsedInputDelta = parseActionInputText(nextInputDeltaText);
-            const input = data.input ??
-                data.arguments ??
-                raw.input ??
-                raw.args ??
-                raw.arguments ??
-                rawParams.arguments ??
+            const input = providerAction.input ??
                 (nextInputDeltaText ? parsedInputDelta : undefined) ??
                 previous?.input;
             const nextOutputDeltaText = chunkType === "chunk.action_completed" && outputDeltaText
                 ? `${previous?.outputDeltaText ?? ""}${outputDeltaText}`
                 : previous?.outputDeltaText ?? "";
-            const output = data.output ??
-                data.result ??
-                rawParams.result ??
-                raw.output ??
-                raw.result ??
+            const output = providerAction.output ??
                 (nextOutputDeltaText
                     ? {
                         text: nextOutputDeltaText,
@@ -348,7 +396,7 @@ export function buildLiveEventFromStepChunks(params) {
                     chunkType === "chunk.action_failed"
                     ? sequence
                     : previous?.terminalSequence,
-                toolName,
+                actionName,
                 hasStarted: previous?.hasStarted ||
                     chunkType === "chunk.action_started" ||
                     chunkType === "chunk.action_input_delta",
@@ -365,11 +413,7 @@ export function buildLiveEventFromStepChunks(params) {
                 errorText: chunkType === "chunk.action_failed"
                     ? asString(chunk.text) ||
                         asString(data.text) ||
-                        asString(data.error) ||
-                        asString(asRecord(data.error).message) ||
-                        asString(rawParams.error) ||
-                        asString(asRecord(rawParams.error).message) ||
-                        asString(asRecord(raw.error).message) ||
+                        providerAction.errorText ||
                         undefined
                     : previous?.errorText,
                 terminalStatus: chunkType === "chunk.action_failed"
@@ -415,7 +459,7 @@ export function buildLiveEventFromStepChunks(params) {
                     type: "action",
                     content: {
                         status: "started",
-                        actionName: action.toolName,
+                        actionName: action.actionName,
                         actionCallId: toolCallId,
                         input: action.input ?? {},
                     },
@@ -429,7 +473,7 @@ export function buildLiveEventFromStepChunks(params) {
                     type: "action",
                     content: {
                         status: "completed",
-                        actionName: action.toolName,
+                        actionName: action.actionName,
                         actionCallId: toolCallId,
                         output: action.output ?? {},
                     },
@@ -443,7 +487,7 @@ export function buildLiveEventFromStepChunks(params) {
                     type: "action",
                     content: {
                         status: "failed",
-                        actionName: action.toolName,
+                        actionName: action.actionName,
                         actionCallId: toolCallId,
                         error: {
                             message: action.errorText || "Action failed.",

package/dist/reactors/ai-sdk.reactor.d.ts

@@ -1,11 +1,11 @@
 import type { ContextEnvironment } from "../context.config.js";
-import type { DomainSchemaResult } from "@ekairos/domain";
+import type { DomainLike } from "@ekairos/domain";
 import type { ContextRuntime, ContextRuntimeHandleForDomain } from "../context.runtime.js";
 import type { ContextModelInit } from "../context.engine.js";
 import type { ContextIdentifier, StoredContext, ContextItem } from "../context.store.js";
 import { eventsDomain } from "../schema.js";
 import type { ContextReactor } from "./types.js";
-export type CreateAiSdkReactorOptions<Context = unknown, Env extends ContextEnvironment = ContextEnvironment, RequiredDomain extends DomainSchemaResult = typeof eventsDomain, Runtime extends ContextRuntime<Env> = ContextRuntime<Env>, Config = unknown> = {
+export type CreateAiSdkReactorOptions<Context = unknown, Env extends ContextEnvironment = ContextEnvironment, RequiredDomain extends DomainLike = typeof eventsDomain, Runtime extends ContextRuntime<Env> = ContextRuntime<Env>, Config = unknown> = {
     resolveConfig?: (params: {
         runtime: ContextRuntimeHandleForDomain<Env, RequiredDomain>;
         context: StoredContext<Context>;
@@ -33,4 +33,4 @@ export type CreateAiSdkReactorOptions<Context = unknown, Env extends ContextEnvi
         config: Config;
     }) => Promise<number> | number;
 };
-export declare function createAiSdkReactor<Context = unknown, Env extends ContextEnvironment = ContextEnvironment, RequiredDomain extends DomainSchemaResult = typeof eventsDomain, Runtime extends ContextRuntime<Env> = ContextRuntime<Env>, Config = unknown>(options?: CreateAiSdkReactorOptions<Context, Env, RequiredDomain, Runtime, Config>): ContextReactor<Context, Env, RequiredDomain, Runtime>;
+export declare function createAiSdkReactor<Context = unknown, Env extends ContextEnvironment = ContextEnvironment, RequiredDomain extends DomainLike = typeof eventsDomain, Runtime extends ContextRuntime<Env> = ContextRuntime<Env>, Config = unknown>(options?: CreateAiSdkReactorOptions<Context, Env, RequiredDomain, Runtime, Config>): ContextReactor<Context, Env, RequiredDomain, Runtime>;

package/dist/reactors/ai-sdk.reactor.js

@@ -55,9 +55,9 @@ export function createAiSdkReactor(options) {
         });
         return {
             assistantEvent: result.assistantEvent,
-            actionRequests: result.toolCalls.map((entry) => ({
-                actionRef: String(entry.toolCallId),
-                actionName: String(entry.toolName),
+            actionRequests: result.actionCalls.map((entry) => ({
+                actionRef: String(entry.actionCallId),
+                actionName: String(entry.actionName),
                 input: entry.args,
             })),
             messagesForModel: result.messagesForModel,

package/dist/reactors/ai-sdk.step.d.ts

@@ -32,7 +32,7 @@ export declare function executeAiSdkReaction<Env extends ContextEnvironment = Co
     stepId?: string;
 }): Promise<{
     assistantEvent: ContextItem;
-    toolCalls: any[];
+    actionCalls: any[];
     messagesForModel: ModelMessage[];
     llm?: {
         provider?: string;

package/dist/reactors/ai-sdk.step.js

@@ -102,7 +102,7 @@ export async function executeAiSdkReaction(params) {
         throw error;
     }
     const { jsonSchema, gateway, smoothStream, stepCountIs, streamText } = await import("ai");
-    const { extractToolCallsFromParts } = await import("../context.toolcalls.js");
+    const { extractActionCallsFromParts } = await import("../context.action-calls.js");
     const resolvedModel = typeof params.model === "string"
         ? gateway(params.model)
         : typeof params.model === "function"
@@ -233,7 +233,7 @@ export async function executeAiSdkReaction(params) {
     }
     const assistantEvent = await finishPromise;
     const finishedAtMs = Date.now();
-    const toolCalls = extractToolCallsFromParts(assistantEvent?.content?.parts);
+    const actionCalls = extractActionCallsFromParts(assistantEvent?.content?.parts);
     const latencyMs = Math.max(0, finishedAtMs - startedAtMs);
     let usage = undefined;
     let providerMetadata = undefined;
@@ -347,5 +347,5 @@ export async function executeAiSdkReaction(params) {
     catch {
         // tracing must not break reaction
     }
-    return { assistantEvent, toolCalls, messagesForModel, llm };
+    return { assistantEvent, actionCalls, messagesForModel, llm };
 }

package/dist/reactors/scripted.reactor.d.ts

@@ -1,5 +1,5 @@
 import type { ModelMessage } from "ai";
-import type { DomainSchemaResult } from "@ekairos/domain";
+import type { DomainLike } from "@ekairos/domain";
 import type { ContextEnvironment } from "../context.config.js";
 import type { ContextRuntime } from "../context.runtime.js";
 import type { ContextItem } from "../context.store.js";
@@ -11,10 +11,10 @@ type ScriptedReactionPayload = {
     messagesForModel?: ModelMessage[];
     llm?: ContextReactionLLM;
 };
-export type ScriptedReactorStep<Context = unknown, Env extends ContextEnvironment = ContextEnvironment, RequiredDomain extends DomainSchemaResult = typeof eventsDomain, Runtime extends ContextRuntime<Env> = ContextRuntime<Env>> = ScriptedReactionPayload | ((params: ContextReactorParams<Context, Env, RequiredDomain, Runtime>) => Promise<ScriptedReactionPayload> | ScriptedReactionPayload);
-export type CreateScriptedReactorOptions<Context = unknown, Env extends ContextEnvironment = ContextEnvironment, RequiredDomain extends DomainSchemaResult = typeof eventsDomain, Runtime extends ContextRuntime<Env> = ContextRuntime<Env>> = {
+export type ScriptedReactorStep<Context = unknown, Env extends ContextEnvironment = ContextEnvironment, RequiredDomain extends DomainLike = typeof eventsDomain, Runtime extends ContextRuntime<Env> = ContextRuntime<Env>> = ScriptedReactionPayload | ((params: ContextReactorParams<Context, Env, RequiredDomain, Runtime>) => Promise<ScriptedReactionPayload> | ScriptedReactionPayload);
+export type CreateScriptedReactorOptions<Context = unknown, Env extends ContextEnvironment = ContextEnvironment, RequiredDomain extends DomainLike = typeof eventsDomain, Runtime extends ContextRuntime<Env> = ContextRuntime<Env>> = {
     steps: ScriptedReactorStep<Context, Env, RequiredDomain, Runtime>[];
     repeatLast?: boolean;
 };
-export declare function createScriptedReactor<Context = unknown, Env extends ContextEnvironment = ContextEnvironment, RequiredDomain extends DomainSchemaResult = typeof eventsDomain, Runtime extends ContextRuntime<Env> = ContextRuntime<Env>>(options: CreateScriptedReactorOptions<Context, Env, RequiredDomain, Runtime>): ContextReactor<Context, Env, RequiredDomain, Runtime>;
+export declare function createScriptedReactor<Context = unknown, Env extends ContextEnvironment = ContextEnvironment, RequiredDomain extends DomainLike = typeof eventsDomain, Runtime extends ContextRuntime<Env> = ContextRuntime<Env>>(options: CreateScriptedReactorOptions<Context, Env, RequiredDomain, Runtime>): ContextReactor<Context, Env, RequiredDomain, Runtime>;
 export {};

package/dist/reactors/types.d.ts

@@ -1,5 +1,5 @@
 import type { ModelMessage, UIMessageChunk } from "ai";
-import type { DomainSchemaResult } from "@ekairos/domain";
+import type { DomainLike } from "@ekairos/domain";
 import type { ContextEnvironment } from "../context.config.js";
 import type { ContextTool } from "../context.action.js";
 import type { ContextRuntime, ContextRuntimeHandleForDomain } from "../context.runtime.js";
@@ -34,7 +34,7 @@ export type ContextReactionResult = {
         state?: Record<string, unknown> | null;
     };
 };
-export type ContextReactorParams<Context = unknown, Env extends ContextEnvironment = ContextEnvironment, RequiredDomain extends DomainSchemaResult = typeof eventsDomain, Runtime extends ContextRuntime<Env> = any> = {
+export type ContextReactorParams<Context = unknown, Env extends ContextEnvironment = ContextEnvironment, RequiredDomain extends DomainLike = typeof eventsDomain, Runtime extends ContextRuntime<Env> = any> = {
     runtime: ContextRuntimeHandleForDomain<Env, RequiredDomain>;
     context: StoredContext<Context>;
     contextIdentifier: ContextIdentifier;
@@ -64,4 +64,4 @@ export type ContextReactorParams<Context = unknown, Env extends ContextEnvironme
     writable?: WritableStream<UIMessageChunk>;
     persistReactionParts?: (parts: any[]) => Promise<void>;
 };
-export type ContextReactor<Context = unknown, Env extends ContextEnvironment = ContextEnvironment, RequiredDomain extends DomainSchemaResult = typeof eventsDomain, Runtime extends ContextRuntime<Env> = any> = (params: ContextReactorParams<Context, Env, RequiredDomain, Runtime>) => Promise<ContextReactionResult>;
+export type ContextReactor<Context = unknown, Env extends ContextEnvironment = ContextEnvironment, RequiredDomain extends DomainLike = typeof eventsDomain, Runtime extends ContextRuntime<Env> = any> = (params: ContextReactorParams<Context, Env, RequiredDomain, Runtime>) => Promise<ContextReactionResult>;

package/dist/steps/do-context-stream-step.js

@@ -12,7 +12,7 @@ export async function doContextStreamStep(params) {
     const { getWritable } = await import("workflow");
     const writable = getWritable();
     const { jsonSchema, gateway, smoothStream, stepCountIs, streamText } = await import("ai");
-    const { extractToolCallsFromParts } = await import("../context.toolcalls.js");
+    const { extractActionCallsFromParts } = await import("../context.action-calls.js");
     // Match DurableAgent's model init behavior:
     // - string => AI Gateway model id, resolved via `gateway(...)` in the step runtime
     // - function => model factory (should be a `"use step"` function for workflow serialization)
@@ -82,9 +82,9 @@ export async function doContextStreamStep(params) {
     }));
     await uiStream.pipeTo(writable, { preventClose: true });
     const assistantEvent = await finishPromise;
-    const actionRequests = extractToolCallsFromParts(assistantEvent?.content?.parts).map((entry) => ({
-        actionRef: String(entry.toolCallId),
-        actionName: String(entry.toolName),
+    const actionRequests = extractActionCallsFromParts(assistantEvent?.content?.parts).map((entry) => ({
+        actionRef: String(entry.actionCallId),
+        actionName: String(entry.actionName),
         input: entry.args,
     }));
     return {

package/dist/stores/instant.store.d.ts

@@ -1,5 +1,5 @@
 import "../polyfills/dom-events.js";
-import type { DomainSchemaResult } from "@ekairos/domain";
+import type { DomainLike } from "@ekairos/domain";
 import type { ModelMessage } from "ai";
 import type { ContextItem, ContextIdentifier, ContextStatus, StoredContext, ContextStore } from "../context.store.js";
 export { parseAndStoreDocument } from "./instant.document-parser.js";
@@ -54,7 +54,7 @@ export declare class InstantStore implements ContextStore {
 export declare function createInstantStoreRuntime(params: {
     getDb: (orgId: string) => Promise<InstantStoreDb> | InstantStoreDb;
     getOrgId?: (env: Record<string, unknown>) => string;
-    domain?: DomainSchemaResult;
+    domain?: DomainLike;
 }): (env: Record<string, unknown>) => Promise<{
     store: InstantStore;
     db: InstantStoreDb;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ekairos/events",
-  "version": "1.22.81-beta.development.0",
+  "version": "1.22.83-beta.development.0",
   "description": "Ekairos Events - Context-first workflow runtime",
   "type": "module",
   "main": "dist/index.js",
@@ -127,7 +127,7 @@
   },
   "dependencies": {
     "@ai-sdk/openai": "^2.0.52",
-    "@ekairos/domain": "^1.22.81-beta.development.0",
+    "@ekairos/domain": "^1.22.83-beta.development.0",
     "@instantdb/admin": "0.22.158",
     "@instantdb/core": "0.22.142",
     "@vercel/mcp-adapter": "^1.0.0",
@@ -138,7 +138,7 @@
     "llamaindex": "^0.12.0",
     "partial-json": "^0.1.7",
     "react": "^19.2.0",
-    "workflow": "5.0.0-beta.1",
+    "workflow": "5.0.0-beta.5",
     "xmlbuilder2": "^3.1.1",
     "zod": "^4.3.6"
   },
@@ -147,8 +147,8 @@
     "@ekairos/tsconfig": "workspace:*",
     "@types/node": "^24.5.0",
     "@types/react": "^19.2.2",
-    "@workflow/serde": "5.0.0-beta.0",
-    "@workflow/vitest": "5.0.0-beta.1",
+    "@workflow/serde": "5.0.0-beta.1",
+    "@workflow/vitest": "5.0.0-beta.5",
     "dotenv": "^17.2.3",
     "typescript": "^5.9.2",
     "vitest": "^4.0.8"