@ekairos/events 1.22.14-beta.development.0 → 1.22.16-beta.development.0

package/dist/context.engine.js

@@ -2,10 +2,10 @@ import { getContextRuntimeServices } from "./context.runtime.js";
 import { OUTPUT_ITEM_TYPE, WEB_CHANNEL } from "./context.events.js";
 import { applyToolExecutionResultToParts } from "./context.toolcalls.js";
 import { isContextPartEnvelope, normalizePartsForPersistence, } from "./context.parts.js";
-import { toolsToModelTools } from "./tools-to-model-tools.js";
+import { actionsToActionSpecs } from "./tools-to-model-tools.js";
 import { createAiSdkReactor, } from "./context.reactor.js";
 import { abortPersistedContextStepStream, closePersistedContextStepStream, createPersistedContextStepStream, closeContextStream, } from "./steps/stream.steps.js";
-import { completeExecution, createContextStep, initializeContext, saveTriggerAndCreateExecution, saveContextPartsStep, updateContextContent, updateContextStatus, updateItem, updateContextStep, } from "./steps/store.steps.js";
+import { completeExecution, createContextStep, initializeContext, saveTriggerAndCreateExecution, saveContextPartsStep, updateContextContent, updateContextReactor, updateContextStatus, updateItem, updateContextStep, } from "./steps/store.steps.js";
 import { getClientResumeHookUrl, toolApprovalHookToken, toolApprovalWebhookToken, } from "./context.hooks.js";
 import { getContextDurableWorkflow } from "./context.durable.js";
 export async function runContextReactionDirect(context, triggerEvent, params) {
@@ -144,6 +144,7 @@ async function createRuntimeOps(runtimeHandle, benchmark) {
             return { context, isNew: true };
         },
         updateContextContent: async (contextIdentifier, content) => await store.updateContextContent(contextIdentifier, content),
+        updateContextReactor: async (contextIdentifier, reactor) => await store.updateContextReactor(contextIdentifier, reactor),
         updateContextStatus: async (contextIdentifier, status) => await instrumentedDb.transact([
             instrumentedDb.tx.event_contexts[requireContextId(contextIdentifier)].update({
                 status,
@@ -259,6 +260,7 @@ async function createWorkflowOps(runtime) {
     return {
         initializeContext: async (contextIdentifier, opts) => await initializeContext({ runtime, contextIdentifier, opts }),
         updateContextContent: async (contextIdentifier, content) => await updateContextContent({ runtime, contextIdentifier, content }),
+        updateContextReactor: async (contextIdentifier, reactor) => await updateContextReactor({ runtime, contextIdentifier, reactor }),
         updateContextStatus: async (contextIdentifier, status) => await updateContextStatus({ runtime, contextIdentifier, status }),
         saveTriggerAndCreateExecution: async ({ contextIdentifier, triggerEvent }) => await saveTriggerAndCreateExecution({ runtime, contextIdentifier, triggerEvent }),
         createContextStep: async ({ executionId, iteration }) => await createContextStep({ runtime, executionId, iteration }),
@@ -537,7 +539,7 @@ export class ContextEngine {
                 const skillsAll = await measureBenchmark(params.__benchmark, `${stagePrefix}.skillsMs`, async () => await story.buildSkills(updatedContext, env));
                 // IMPORTANT: step args must be serializable.
                 // Match DurableAgent behavior: convert tool input schemas to plain JSON Schema in workflow context.
-                const toolsForModel = toolsToModelTools(toolsAll);
+                const actionSpecs = actionsToActionSpecs(toolsAll);
                 // Execute model reaction for this iteration using the stable reaction event id.
                 //
                 // IMPORTANT:
@@ -572,7 +574,7 @@ export class ContextEngine {
                         status: "pending",
                     }, { executionId, contextId: String(currentContext.id) });
                 };
-                const { assistantEvent, actionRequests, messagesForModel } = await measureBenchmark(params.__benchmark, `${stagePrefix}.reactorMs`, async () => await reactor({
+                const reactionResult = await measureBenchmark(params.__benchmark, `${stagePrefix}.reactorMs`, async () => await reactor({
                     runtime: params.runtime,
                     env,
                     context: updatedContext,
@@ -581,7 +583,7 @@ export class ContextEngine {
                     model: story.getModel(updatedContext, env),
                     systemPrompt,
                     actions: toolsAll,
-                    toolsForModel,
+                    actionSpecs,
                     skills: skillsAll,
                     eventId: reactionEventId,
                     executionId,
@@ -596,6 +598,7 @@ export class ContextEngine {
                     writable,
                     persistReactionParts,
                 }));
+                const { assistantEvent, actionRequests, messagesForModel } = reactionResult;
                 const reviewRequests = actionRequests.length > 0
                     ? actionRequests.flatMap((actionRequest) => {
                         const toolDef = toolsAll[actionRequest.actionName];
@@ -659,6 +662,15 @@ export class ContextEngine {
                     status: "pending",
                 };
                 reactionEvent = await measureBenchmark(params.__benchmark, `${stagePrefix}.persistAssistantReactionMs`, async () => await ops.updateItem(reactionEvent.id, nextReactionEvent, { executionId, contextId: String(currentContext.id) }));
+                if (reactionResult.reactor?.kind) {
+                    updatedContext = await measureBenchmark(params.__benchmark, `${stagePrefix}.persistReactorStateMs`, async () => await ops.updateContextReactor(activeContextSelector, {
+                        kind: reactionResult.reactor.kind,
+                        state: {
+                            ...(reactionResult.reactor.state ?? {}),
+                            updatedAt: nowIso(),
+                        },
+                    }));
+                }
                 if (currentStepStream) {
                     await closePersistedContextStepStream({
                         runtime: params.runtime,

package/dist/context.store.d.ts

@@ -16,6 +16,10 @@ export type StoredContext<Context> = {
     createdAt: Date;
     updatedAt?: Date;
     content: Context | null;
+    reactor?: {
+        kind: string;
+        state?: Record<string, unknown> | null;
+    } | null;
 };
 export type ContextItem = {
     id: string;
@@ -57,6 +61,10 @@ export interface ContextStore {
     getOrCreateContext<C>(contextIdentifier: ContextIdentifier | null): Promise<StoredContext<C>>;
     getContext<C>(contextIdentifier: ContextIdentifier): Promise<StoredContext<C> | null>;
     updateContextContent<C>(contextIdentifier: ContextIdentifier, content: C): Promise<StoredContext<C>>;
+    updateContextReactor<C>(contextIdentifier: ContextIdentifier, reactor: {
+        kind: string;
+        state?: Record<string, unknown> | null;
+    }): Promise<StoredContext<C>>;
     updateContextStatus(contextIdentifier: ContextIdentifier, status: ContextStatus): Promise<void>;
     saveItem(contextIdentifier: ContextIdentifier, item: ContextItem): Promise<ContextItem>;
     updateItem(itemId: string, item: ContextItem): Promise<ContextItem>;

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

@@ -43,7 +43,7 @@ export function createAiSdkReactor(options) {
             contextIdentifier: params.contextIdentifier,
             model,
             system: params.systemPrompt,
-            tools: params.toolsForModel,
+            tools: params.actionSpecs,
             eventId: params.eventId,
             iteration: params.iteration,
             maxSteps,

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

@@ -2,7 +2,7 @@ import type { ModelMessage, UIMessageChunk } from "ai";
 import type { ContextEnvironment } from "../context.config.js";
 import type { ContextModelInit } from "../context.engine.js";
 import type { ContextItem, ContextIdentifier } from "../context.store.js";
-import type { SerializableToolForModel } from "../tools-to-model-tools.js";
+import { type SerializableActionSpec } from "../tools-to-model-tools.js";
 /**
  * AI SDK-backed reaction execution inside a single workflow step.
  *
@@ -19,7 +19,7 @@ export declare function executeAiSdkReaction(params: {
     contextIdentifier: ContextIdentifier;
     model: ContextModelInit;
     system: string;
-    tools: Record<string, SerializableToolForModel>;
+    tools: Record<string, SerializableActionSpec>;
     eventId: string;
     iteration?: number;
     maxSteps: number;

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

@@ -2,6 +2,7 @@ import { getContextRuntimeServices } from "../context.runtime.js";
 import { OUTPUT_ITEM_TYPE } from "../context.events.js";
 import { createContextStepStreamChunk, encodeContextStepStreamChunk, } from "../context.step-stream.js";
 import { mapAiSdkChunkToContextEvent } from "./ai-sdk.chunk-map.js";
+import { actionSpecToAiSdkTool, } from "../tools-to-model-tools.js";
 import { writeContextTraceEvents } from "../steps/trace.steps.js";
 async function readWorkflowMetadata() {
     try {
@@ -111,10 +112,7 @@ export async function executeAiSdkReaction(params) {
             })();
     const toolsForStreamText = {};
     for (const [name, t] of Object.entries(params.tools)) {
-        toolsForStreamText[name] = {
-            description: t?.description,
-            inputSchema: jsonSchema(t.inputSchema),
-        };
+        toolsForStreamText[name] = actionSpecToAiSdkTool(name, t, jsonSchema);
     }
     const startedAtMs = Date.now();
     const result = streamText({

package/dist/reactors/types.d.ts

@@ -4,7 +4,7 @@ import type { ContextRuntime } from "../context.runtime.js";
 import type { ContextModelInit } from "../context.engine.js";
 import type { ContextIdentifier, StoredContext, ContextItem } from "../context.store.js";
 import type { ContextSkillPackage } from "../context.skill.js";
-import type { SerializableToolForModel } from "../tools-to-model-tools.js";
+import type { SerializableActionSpec } from "../tools-to-model-tools.js";
 export type ContextActionRequest = {
     actionRef: string;
     actionName: string;
@@ -27,6 +27,10 @@ export type ContextReactionResult = {
     actionRequests: ContextActionRequest[];
     messagesForModel: ModelMessage[];
     llm?: ContextReactionLLM;
+    reactor?: {
+        kind: string;
+        state?: Record<string, unknown> | null;
+    };
 };
 export type ContextReactorParams<Context = unknown, Env extends ContextEnvironment = ContextEnvironment> = {
     runtime: ContextRuntime<Env>;
@@ -37,7 +41,7 @@ export type ContextReactorParams<Context = unknown, Env extends ContextEnvironme
     model: ContextModelInit;
     systemPrompt: string;
     actions: Record<string, unknown>;
-    toolsForModel: Record<string, SerializableToolForModel>;
+    actionSpecs: Record<string, SerializableActionSpec>;
     skills: ContextSkillPackage[];
     eventId: string;
     executionId: string;

package/dist/schema.js

@@ -10,6 +10,7 @@ export const eventsDomain = domain("events")
             name: i.string().optional(),
             status: i.string().optional().indexed(), // open_idle | open_streaming | closed
             content: i.any().optional(),
+            reactor: i.json().optional(),
         }),
         event_items: i.entity({
             channel: i.string().indexed(),

package/dist/steps/do-context-stream-step.d.ts

@@ -1,6 +1,6 @@
 import type { ModelMessage } from "ai";
 import type { ContextItem } from "../context.store.js";
-import type { SerializableToolForModel } from "../tools-to-model-tools.js";
+import { type SerializableActionSpec } from "../tools-to-model-tools.js";
 import type { ContextModelInit } from "../context.engine.js";
 /**
  * Runs a single LLM streaming step as a Workflow step.
@@ -13,7 +13,7 @@ export declare function doContextStreamStep(params: {
     model: ContextModelInit;
     system: string;
     messages: ModelMessage[];
-    tools: Record<string, SerializableToolForModel>;
+    tools: Record<string, SerializableActionSpec>;
     eventId: string;
     maxSteps: number;
     /**

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

@@ -1,4 +1,5 @@
 import { OUTPUT_ITEM_TYPE } from "../context.events.js";
+import { actionSpecToAiSdkTool, } from "../tools-to-model-tools.js";
 /**
  * Runs a single LLM streaming step as a Workflow step.
  *
@@ -28,10 +29,7 @@ export async function doContextStreamStep(params) {
     // `jsonSchema(...)` so the AI SDK does not attempt Zod conversion at runtime.
     const toolsForStreamText = {};
     for (const [name, t] of Object.entries(params.tools)) {
-        toolsForStreamText[name] = {
-            description: t?.description,
-            inputSchema: jsonSchema(t.inputSchema),
-        };
+        toolsForStreamText[name] = actionSpecToAiSdkTool(name, t, jsonSchema);
     }
     const result = streamText({
         model: resolvedModel,

package/dist/steps/store.steps.d.ts

@@ -28,6 +28,13 @@ export declare function updateContextContent<C>(params: RuntimeParams & {
     contextIdentifier: ContextIdentifier;
     content: C;
 }): Promise<StoredContext<C>>;
+export declare function updateContextReactor<C>(params: RuntimeParams & {
+    contextIdentifier: ContextIdentifier;
+    reactor: {
+        kind: string;
+        state?: Record<string, unknown> | null;
+    };
+}): Promise<StoredContext<C>>;
 export declare function updateContextStatus(params: RuntimeParams & {
     contextIdentifier: ContextIdentifier;
     status: ContextStatus;

package/dist/steps/store.steps.js

@@ -142,6 +142,11 @@ export async function updateContextContent(params) {
     const { runtime } = await getRuntimeAndEnv(params);
     return await runtime.store.updateContextContent(params.contextIdentifier, params.content);
 }
+export async function updateContextReactor(params) {
+    "use step";
+    const { runtime } = await getRuntimeAndEnv(params);
+    return await runtime.store.updateContextReactor(params.contextIdentifier, params.reactor);
+}
 export async function updateContextStatus(params) {
     "use step";
     const { runtime } = await getRuntimeAndEnv(params);

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

@@ -14,6 +14,10 @@ export declare class InstantStore implements ContextStore {
     getOrCreateContext<C>(contextIdentifier: ContextIdentifier | null): Promise<StoredContext<C>>;
     getContext<C>(contextIdentifier: ContextIdentifier): Promise<StoredContext<C> | null>;
     updateContextContent<C>(contextIdentifier: ContextIdentifier, content: C): Promise<StoredContext<C>>;
+    updateContextReactor<C>(contextIdentifier: ContextIdentifier, reactor: {
+        kind: string;
+        state?: Record<string, unknown> | null;
+    }): Promise<StoredContext<C>>;
     updateContextStatus(contextIdentifier: ContextIdentifier, status: ContextStatus): Promise<void>;
     private resolveContext;
     saveItem(contextIdentifier: ContextIdentifier, event: ContextItem): Promise<ContextItem>;

package/dist/stores/instant.store.js

@@ -118,6 +118,9 @@ export class InstantStore {
                     ? new Date(row.updatedAt)
                     : undefined,
             content: row?.content ?? null,
+            reactor: row?.reactor && typeof row.reactor === "object"
+                ? row.reactor
+                : null,
         };
     }
     async ensureContextKey(context, expectedKey) {
@@ -144,6 +147,7 @@ export class InstantStore {
                 key,
                 status: "open_idle",
                 content: {},
+                reactor: undefined,
             }),
         ]);
         const context = await this.getContext({ id: contextId });
@@ -203,6 +207,21 @@ export class InstantStore {
             throw new Error("InstantStore: context not found after update");
         return updated;
     }
+    async updateContextReactor(contextIdentifier, reactor) {
+        const context = await this.getContext(contextIdentifier);
+        if (!context?.id)
+            throw new Error("InstantStore: context not found");
+        await this.db.transact([
+            this.db.tx.event_contexts[context.id].update({
+                reactor: reactor,
+                updatedAt: new Date(),
+            }),
+        ]);
+        const updated = await this.getContext({ id: context.id });
+        if (!updated)
+            throw new Error("InstantStore: context not found after reactor update");
+        return updated;
+    }
     async updateContextStatus(contextIdentifier, status) {
         const context = await this.getContext(contextIdentifier);
         if (!context?.id)

package/dist/tools-to-model-tools.d.ts

@@ -6,14 +6,48 @@ import { type Tool } from "ai";
  * - Keep Zod/function values out of step arguments
  * - Convert tool input schemas to plain JSON Schema in workflow context
  */
-export type SerializableToolForModel = {
+export type SerializableFunctionActionSpec = {
+    type?: "function";
     description?: string;
     inputSchema: unknown;
+    providerOptions?: unknown;
 };
+export type SerializableProviderDefinedActionSpec = {
+    type: "provider-defined";
+    id: string;
+    name?: string;
+    args?: Record<string, unknown>;
+};
+export type SerializableActionSpec = SerializableFunctionActionSpec | SerializableProviderDefinedActionSpec;
+/**
+ * @deprecated Use SerializableActionSpec.
+ */
+export type SerializableToolForModel = SerializableActionSpec;
 /**
  * Convert AI SDK tools to a serializable representation that can be passed to `"use-step"` functions.
  *
  * This matches DurableAgent's internal `toolsToModelTools` behavior:
  * `inputSchema: asSchema(tool.inputSchema).jsonSchema`
  */
-export declare function toolsToModelTools(tools: Record<string, Tool>): Record<string, SerializableToolForModel>;
+export declare function actionsToActionSpecs(tools: Record<string, Tool>): Record<string, SerializableActionSpec>;
+export declare function actionSpecToAiSdkTool(name: string, spec: SerializableActionSpec, wrapJsonSchema: (schema: unknown) => unknown): {
+    type: "provider-defined";
+    id: string;
+    name: string;
+    args: Record<string, unknown>;
+    description?: undefined;
+    inputSchema?: undefined;
+    providerOptions?: undefined;
+} | {
+    type: "function";
+    description: string | undefined;
+    inputSchema: unknown;
+    providerOptions: unknown;
+    id?: undefined;
+    name?: undefined;
+    args?: undefined;
+};
+/**
+ * @deprecated Use actionsToActionSpecs.
+ */
+export declare const toolsToModelTools: typeof actionsToActionSpecs;

package/dist/tools-to-model-tools.js

@@ -1,21 +1,59 @@
 import { asSchema } from "ai";
+function isProviderDefinedTool(tool) {
+    return (Boolean(tool) &&
+        typeof tool === "object" &&
+        tool.type === "provider-defined" &&
+        typeof tool.id === "string" &&
+        tool.id.trim().length > 0);
+}
 /**
  * Convert AI SDK tools to a serializable representation that can be passed to `"use-step"` functions.
  *
  * This matches DurableAgent's internal `toolsToModelTools` behavior:
  * `inputSchema: asSchema(tool.inputSchema).jsonSchema`
  */
-export function toolsToModelTools(tools) {
+export function actionsToActionSpecs(tools) {
     const out = {};
     for (const [name, tool] of Object.entries(tools)) {
+        if (isProviderDefinedTool(tool)) {
+            out[name] = {
+                type: "provider-defined",
+                id: tool.id,
+                name: tool.name,
+                args: tool.args,
+            };
+            continue;
+        }
         const inputSchema = tool?.inputSchema;
         if (!inputSchema) {
             throw new Error(`Context: tool "${name}" is missing inputSchema (required for model tool calls)`);
         }
         out[name] = {
+            type: "function",
             description: tool?.description,
             inputSchema: asSchema(inputSchema).jsonSchema,
+            providerOptions: tool?.providerOptions,
         };
     }
     return out;
 }
+export function actionSpecToAiSdkTool(name, spec, wrapJsonSchema) {
+    if (spec.type === "provider-defined") {
+        return {
+            type: "provider-defined",
+            id: spec.id,
+            name: spec.name ?? name,
+            args: spec.args ?? {},
+        };
+    }
+    return {
+        type: "function",
+        description: spec.description,
+        inputSchema: wrapJsonSchema(spec.inputSchema),
+        providerOptions: spec.providerOptions,
+    };
+}
+/**
+ * @deprecated Use actionsToActionSpecs.
+ */
+export const toolsToModelTools = actionsToActionSpecs;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ekairos/events",
-  "version": "1.22.14-beta.development.0",
+  "version": "1.22.16-beta.development.0",
   "description": "Ekairos Events - Context-first workflow runtime",
   "type": "module",
   "main": "dist/index.js",
@@ -117,7 +117,7 @@
   },
   "dependencies": {
     "@ai-sdk/openai": "^2.0.52",
-    "@ekairos/domain": "^1.22.14-beta.development.0",
+    "@ekairos/domain": "^1.22.16-beta.development.0",
     "@instantdb/admin": "0.22.158",
     "@instantdb/core": "0.22.142",
     "@vercel/mcp-adapter": "^1.0.0",