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

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

@@ -1,9 +1,11 @@
 import type { ContextEnvironment } from "../context.config.js";
+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 { ContextReactor } from "./types.js";
 export type CreateAiSdkReactorOptions<Context = unknown, Env extends ContextEnvironment = ContextEnvironment, Config = unknown> = {
     resolveConfig?: (params: {
+        runtime: ContextRuntime<Env>;
         env: Env;
         context: StoredContext<Context>;
         contextIdentifier: ContextIdentifier;
@@ -16,6 +18,7 @@ export type CreateAiSdkReactorOptions<Context = unknown, Env extends ContextEnvi
         iteration: number;
     }) => Promise<Config> | Config;
     selectModel?: (params: {
+        runtime: ContextRuntime<Env>;
         env: Env;
         context: StoredContext<Context>;
         triggerEvent: ContextItem;
@@ -23,6 +26,7 @@ export type CreateAiSdkReactorOptions<Context = unknown, Env extends ContextEnvi
         config: Config;
     }) => Promise<ContextModelInit> | ContextModelInit;
     selectMaxModelSteps?: (params: {
+        runtime: ContextRuntime<Env>;
         env: Env;
         context: StoredContext<Context>;
         triggerEvent: ContextItem;

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

@@ -4,6 +4,7 @@ export function createAiSdkReactor(options) {
         let config;
         if (options?.resolveConfig) {
             config = await options.resolveConfig({
+                runtime: params.runtime,
                 env: params.env,
                 context: params.context,
                 contextIdentifier: params.contextIdentifier,
@@ -18,6 +19,7 @@ export function createAiSdkReactor(options) {
         }
         const model = options?.selectModel && config !== undefined
             ? await options.selectModel({
+                runtime: params.runtime,
                 env: params.env,
                 context: params.context,
                 triggerEvent: params.triggerEvent,
@@ -27,6 +29,7 @@ export function createAiSdkReactor(options) {
             : params.model;
         const maxSteps = options?.selectMaxModelSteps && config !== undefined
             ? await options.selectMaxModelSteps({
+                runtime: params.runtime,
                 env: params.env,
                 context: params.context,
                 triggerEvent: params.triggerEvent,
@@ -35,11 +38,12 @@ export function createAiSdkReactor(options) {
             })
             : params.maxModelSteps;
         const result = await executeAiSdkReaction({
+            runtime: params.runtime,
             env: params.env,
             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.
  *
@@ -14,11 +14,12 @@ import type { SerializableToolForModel } from "../tools-to-model-tools.js";
  * - emit UI chunks and persist step stream chunks
  */
 export declare function executeAiSdkReaction(params: {
+    runtime: import("../context.runtime.js").ContextRuntime<ContextEnvironment>;
     env: ContextEnvironment;
     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

@@ -1,6 +1,8 @@
+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 {
@@ -82,8 +84,7 @@ function safeErrorJson(error) {
  */
 export async function executeAiSdkReaction(params) {
     "use step";
-    const { getContextRuntime } = await import("../runtime.js");
-    const { store } = await getContextRuntime(params.env);
+    const { store } = await getContextRuntimeServices(params.runtime);
     let events;
     try {
         events = await store.getItems(params.contextIdentifier);
@@ -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({
@@ -221,7 +219,10 @@ export async function executeAiSdkReaction(params) {
         }
     }
     finally {
-        contextStepStreamWriter?.releaseLock();
+        const streamWriter = contextStepStreamWriter;
+        if (typeof streamWriter?.releaseLock === "function") {
+            streamWriter.releaseLock();
+        }
     }
     const assistantEvent = await finishPromise;
     const finishedAtMs = Date.now();

package/dist/reactors/types.d.ts

@@ -1,9 +1,10 @@
 import type { ModelMessage, UIMessageChunk } from "ai";
 import type { ContextEnvironment } from "../context.config.js";
+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;
@@ -26,8 +27,13 @@ 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>;
     env: Env;
     context: StoredContext<Context>;
     contextIdentifier: ContextIdentifier;
@@ -35,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/runtime.step.js

@@ -1,7 +1,7 @@
 import { coerceContextRuntime } from "./context.config.js";
 import { eventsDomain } from "./schema.js";
 export async function getContextRuntime(env) {
-    const { resolveRuntime } = await import("@ekairos/domain/runtime-step");
+    const { resolveRuntime } = await import("@ekairos/domain/runtime");
     const resolved = await resolveRuntime(eventsDomain, env);
     return await coerceContextRuntime(resolved);
 }

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

@@ -1,6 +1,10 @@
 import type { UIMessageChunk } from "ai";
 import type { ContextEnvironment } from "../context.config.js";
+import type { ContextRuntime } from "../context.runtime.js";
 import type { ContextExecution, ContextItem, ContextIdentifier, StoredContext, ContextStatus } from "../context.store.js";
+type RuntimeParams<Env extends ContextEnvironment = ContextEnvironment> = {
+    runtime: ContextRuntime<Env>;
+};
 export type ContextReviewRequest = {
     toolCallId: string;
     toolName?: string;
@@ -10,18 +14,37 @@ export type ContextReviewRequest = {
  *
  * This is the "context init" boundary for the story engine.
  */
-export declare function initializeContext<C>(env: ContextEnvironment, contextIdentifier: ContextIdentifier | null, opts?: {
-    silent?: boolean;
-    writable?: WritableStream<UIMessageChunk>;
+export declare function initializeContext<C>(params: RuntimeParams & {
+    contextIdentifier: ContextIdentifier | null;
+    opts?: {
+        silent?: boolean;
+        writable?: WritableStream<UIMessageChunk>;
+    };
 }): Promise<{
     context: StoredContext<C>;
     isNew: boolean;
 }>;
-export declare function updateContextContent<C>(env: ContextEnvironment, contextIdentifier: ContextIdentifier, content: C): Promise<StoredContext<C>>;
-export declare function updateContextStatus(env: ContextEnvironment, contextIdentifier: ContextIdentifier, status: ContextStatus): Promise<void>;
-export declare function saveTriggerItem(env: ContextEnvironment, contextIdentifier: ContextIdentifier, event: ContextItem): Promise<ContextItem>;
+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;
+}): Promise<void>;
+export declare function saveTriggerItem(params: RuntimeParams & {
+    contextIdentifier: ContextIdentifier;
+    event: ContextItem;
+}): Promise<ContextItem>;
 export declare function saveTriggerAndCreateExecution(params: {
-    env: ContextEnvironment;
+    runtime: ContextRuntime<ContextEnvironment>;
     contextIdentifier: ContextIdentifier;
     triggerEvent: ContextItem;
 }): Promise<{
@@ -29,41 +52,57 @@ export declare function saveTriggerAndCreateExecution(params: {
     reactionEvent: ContextItem;
     execution: ContextExecution;
 }>;
-export declare function saveReactionItem(env: ContextEnvironment, contextIdentifier: ContextIdentifier, event: ContextItem, opts?: {
-    executionId?: string;
-    contextId?: string;
-    reviewRequests?: ContextReviewRequest[];
+export declare function saveReactionItem(params: RuntimeParams & {
+    contextIdentifier: ContextIdentifier;
+    event: ContextItem;
+    opts?: {
+        executionId?: string;
+        contextId?: string;
+        reviewRequests?: ContextReviewRequest[];
+    };
 }): Promise<ContextItem>;
-export declare function updateItem(env: ContextEnvironment, eventId: string, event: ContextItem, opts?: {
-    executionId?: string;
-    contextId?: string;
+export declare function updateItem(params: RuntimeParams & {
+    eventId: string;
+    event: ContextItem;
+    opts?: {
+        executionId?: string;
+        contextId?: string;
+    };
 }): Promise<ContextItem>;
-export declare function createExecution(env: ContextEnvironment, contextIdentifier: ContextIdentifier, triggerEventId: string, reactionEventId: string): Promise<{
+export declare function createExecution(params: RuntimeParams & {
+    contextIdentifier: ContextIdentifier;
+    triggerEventId: string;
+    reactionEventId: string;
+}): Promise<{
     id: string;
 }>;
 export declare function createReactionItem(params: {
-    env: ContextEnvironment;
+    runtime: ContextRuntime<ContextEnvironment>;
     contextIdentifier: ContextIdentifier;
     triggerEventId: string;
 }): Promise<{
     reactionEventId: string;
     executionId: string;
 }>;
-export declare function completeExecution(env: ContextEnvironment, contextIdentifier: ContextIdentifier, executionId: string, status: "completed" | "failed"): Promise<void>;
+export declare function completeExecution(params: RuntimeParams & {
+    contextIdentifier: ContextIdentifier;
+    executionId: string;
+    status: "completed" | "failed";
+}): Promise<void>;
 export declare function updateExecutionWorkflowRun(params: {
-    env: ContextEnvironment;
+    runtime: ContextRuntime<ContextEnvironment>;
     executionId: string;
     workflowRunId: string;
 }): Promise<void>;
 export declare function createContextStep(params: {
-    env: ContextEnvironment;
+    runtime: ContextRuntime<ContextEnvironment>;
     executionId: string;
     iteration: number;
 }): Promise<{
     stepId: string;
 }>;
 export declare function updateContextStep(params: {
-    env: ContextEnvironment;
+    runtime: ContextRuntime<ContextEnvironment>;
     stepId: string;
     executionId?: string;
     contextId?: string;
@@ -82,15 +121,16 @@ export declare function updateContextStep(params: {
     };
 }): Promise<void>;
 export declare function linkItemToExecutionStep(params: {
-    env: ContextEnvironment;
+    runtime: ContextRuntime<ContextEnvironment>;
     itemId: string;
     executionId: string;
 }): Promise<void>;
 export declare function saveContextPartsStep(params: {
-    env: ContextEnvironment;
+    runtime: ContextRuntime<ContextEnvironment>;
     stepId: string;
     executionId?: string;
     contextId?: string;
     iteration?: number;
     parts: any[];
 }): Promise<void>;
+export {};