@ekairos/events 1.22.44-beta.development.0 → 1.22.46-beta.development.0

package/dist/context.engine.js

@@ -3,9 +3,7 @@ import { OUTPUT_ITEM_TYPE, WEB_CHANNEL } from "./context.events.js";
 import { applyToolExecutionResultToParts } from "./context.toolcalls.js";
 import { isContextPartEnvelope, normalizePartsForPersistence, } from "./context.parts.js";
 import { createAiSdkReactor, } from "./context.reactor.js";
-import { abortPersistedContextStepStream, closeContextStream, createPersistedContextStepStreamForRuntime, finalizePersistedContextStepStreamForRuntime, } from "./steps/stream.steps.js";
-import { createContextStepStreamChunk, encodeContextStepStreamChunk, } from "./context.step-stream.js";
-import { resolveContextPartChunkIdentity } from "./context.part-identity.js";
+import { abortPersistedContextStepStream, closeContextStream, createPersistedContextStepStreamForRuntime, finalizePersistedContextStepStreamForRuntime, writeActionResultPartChunks, } from "./steps/stream.steps.js";
 import { completeExecution, createContextStep, finalizeReactionStep, getContextItems, initializeContext, openReactionStep, saveTriggerAndCreateExecution, saveContextPartsAndUpdateReaction, 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";
@@ -88,112 +86,6 @@ function summarizePartPreview(part) {
 async function emitContextEvents(params) {
     void params;
 }
-function toJsonSafeRecord(value) {
-    if (typeof value === "undefined")
-        return undefined;
-    try {
-        const json = JSON.parse(JSON.stringify(value));
-        return json && typeof json === "object"
-            ? json
-            : { value: json };
-    }
-    catch {
-        return undefined;
-    }
-}
-async function writeActionResultPartChunks(params) {
-    if (!params.session || params.actionResults.length === 0)
-        return;
-    const writer = params.session.stream.getWriter();
-    const events = [];
-    const sequenceBase = Date.now();
-    try {
-        for (let index = 0; index < params.actionResults.length; index += 1) {
-            const result = params.actionResults[index];
-            const actionRef = String(result.actionRequest.actionRef || "");
-            const actionName = String(result.actionRequest.actionName || "");
-            if (!actionRef || !actionName)
-                continue;
-            const chunkType = result.success
-                ? "chunk.action_completed"
-                : "chunk.action_failed";
-            const identity = resolveContextPartChunkIdentity({
-                stepId: params.session.stepId,
-                provider: "ekairos",
-                providerPartId: actionRef,
-                chunkType,
-            });
-            if (!identity)
-                continue;
-            const data = result.success
-                ? {
-                    toolCallId: actionRef,
-                    toolName: actionName,
-                    output: toJsonSafeRecord(result.output),
-                }
-                : {
-                    toolCallId: actionRef,
-                    toolName: actionName,
-                    error: {
-                        message: String(result.errorText || "Action failed."),
-                    },
-                };
-            const at = nowIso();
-            const sequence = sequenceBase + index;
-            const persistedChunk = createContextStepStreamChunk({
-                at,
-                sequence,
-                chunkType,
-                stepId: params.session.stepId,
-                partId: identity.partId,
-                providerPartId: identity.providerPartId,
-                partType: identity.partType,
-                partSlot: identity.partSlot,
-                provider: "ekairos",
-                providerChunkType: result.success
-                    ? "action_completed"
-                    : "action_failed",
-                actionRef,
-                data,
-            });
-            await writer.write(encodeContextStepStreamChunk(persistedChunk, {
-                stepId: params.session.stepId,
-            }));
-            events.push({
-                type: "chunk.emitted",
-                at,
-                chunkType,
-                contextId: params.contextId,
-                executionId: params.executionId,
-                stepId: params.session.stepId,
-                itemId: params.itemId,
-                sequence,
-                provider: "ekairos",
-                providerChunkType: result.success
-                    ? "action_completed"
-                    : "action_failed",
-                actionRef,
-                partId: identity.partId,
-                providerPartId: identity.providerPartId,
-                partType: identity.partType,
-                partSlot: identity.partSlot,
-                data,
-            });
-        }
-    }
-    finally {
-        if (typeof writer?.releaseLock === "function") {
-            writer.releaseLock();
-        }
-    }
-    if (events.length > 0) {
-        await emitContextEvents({
-            silent: params.silent ?? false,
-            writable: params.writable,
-            events,
-        });
-    }
-}
 async function measureBenchmark(benchmark, name, run) {
     if (!benchmark)
         return await run();
@@ -1062,15 +954,18 @@ export class ContextEngine {
                         };
                     }
                 })));
-                await measureBenchmark(params.__benchmark, `${stagePrefix}.writeActionResultPartChunksMs`, async () => await writeActionResultPartChunks({
+                const actionResultChunkEvents = await measureBenchmark(params.__benchmark, `${stagePrefix}.writeActionResultPartChunksMs`, async () => await writeActionResultPartChunks({
                     session: currentStepStream,
-                    writable,
-                    silent,
                     contextId: String(currentContext.id),
                     executionId,
                     itemId: reactionEventId,
                     actionResults: actionResults,
                 }));
+                await emitContextEvents({
+                    silent,
+                    writable,
+                    events: actionResultChunkEvents,
+                });
                 // Merge action results into persisted parts (so next LLM call can see them)
                 let finalizedStepParts = Array.isArray(stepParts) ? [...stepParts] : [];
                 for (const r of actionResults) {

package/dist/context.part-identity.js

@@ -248,8 +248,11 @@ export function assertValidContextPartChunkIdentity(input) {
     if (!isActionChunk && typeof input.actionRef !== "undefined") {
         throw new Error(`Invalid ${fieldLabel(label, "actionRef")}: only action chunks can carry actionRef.`);
     }
-    if (isActionChunk && typeof input.actionRef !== "undefined") {
-        assertPartIdentityString(input.actionRef, fieldLabel(label, "actionRef"));
+    if (isActionChunk) {
+        const actionRef = assertPartIdentityString(input.actionRef, fieldLabel(label, "actionRef"));
+        if (actionRef !== providerPartId) {
+            throw new Error(`Invalid ${fieldLabel(label, "actionRef")}: action chunks require actionRef to match providerPartId.`);
+        }
     }
     const stepId = normalizeIdentityField(input.stepId);
     if (!stepId)

package/dist/reactors/ai-sdk.chunk-map.d.ts

@@ -8,5 +8,6 @@ export type MapAiSdkChunkToContextEventParams = {
     itemId?: string;
     provider?: string;
     sequence: number;
+    actionNameByRef?: Map<string, string>;
 };
 export declare function mapAiSdkChunkToContextEvent(params: MapAiSdkChunkToContextEventParams): ChunkEmittedEvent;

package/dist/reactors/ai-sdk.chunk-map.js

@@ -103,6 +103,7 @@ function buildNormalizedData(chunk) {
         "inputTextDelta",
         "outputTextDelta",
         "state",
+        "actionName",
         "toolName",
         "toolCallId",
         "input",
@@ -153,6 +154,24 @@ export function mapAiSdkChunkToContextEvent(params) {
     });
     const actionRef = readString(chunk, "toolCallId") ??
         readString(chunk, "id");
+    let data = buildNormalizedData(chunk);
+    if (chunkType.startsWith("chunk.action_") && actionRef) {
+        const observedActionName = readString(chunk, "actionName") ??
+            readString(chunk, "toolName") ??
+            readString(data, "actionName") ??
+            readString(data, "toolName");
+        if (observedActionName) {
+            params.actionNameByRef?.set(actionRef, observedActionName);
+        }
+        const knownActionName = observedActionName ?? params.actionNameByRef?.get(actionRef);
+        if (knownActionName) {
+            data = {
+                ...data,
+                actionName: readString(data, "actionName") ?? knownActionName,
+                toolName: readString(data, "toolName") ?? knownActionName,
+            };
+        }
+    }
     return {
         type: "chunk.emitted",
         at: new Date().toISOString(),
@@ -169,7 +188,7 @@ export function mapAiSdkChunkToContextEvent(params) {
         provider: params.provider,
         providerChunkType,
         sequence: params.sequence,
-        data: buildNormalizedData(chunk),
+        data,
         raw: sanitizeRaw(chunk),
     };
 }

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

@@ -135,6 +135,7 @@ export async function executeAiSdkReaction(params) {
     const modelId = typeof params.model === "string" ? params.model : "";
     const mappedProvider = modelId.includes("/") ? modelId.split("/")[0] || "ai-sdk" : "ai-sdk";
     const contextStepStreamWriter = params.contextStepStream?.getWriter();
+    const actionNameByRef = new Map();
     try {
         const uiStream = result
             .toUIMessageStream({
@@ -173,6 +174,7 @@ export async function executeAiSdkReaction(params) {
                         itemId: params.eventId,
                         provider: mappedProvider,
                         sequence: ++chunkSequence,
+                        actionNameByRef,
                     });
                     const persistedChunk = createContextStepStreamChunk({
                         at: mapped.at,

package/dist/steps/stream.steps.d.ts

@@ -50,6 +50,22 @@ export declare function abortPersistedContextStepStream(params: {
     session: PersistedContextStepStreamSession;
     reason?: string | null;
 }): Promise<void>;
+export declare function writeActionResultPartChunks(params: {
+    session?: PersistedContextStepStreamSession | null;
+    contextId: string;
+    executionId: string;
+    itemId: string;
+    actionResults: Array<{
+        actionRequest: {
+            actionRef: string;
+            actionName: string;
+            input: unknown;
+        };
+        success: boolean;
+        output: unknown;
+        errorText?: string;
+    }>;
+}): Promise<ContextStreamEvent[]>;
 export declare function readPersistedContextStepStream(params: {
     db: any;
     clientId?: string;

package/dist/steps/stream.steps.js

@@ -1,5 +1,6 @@
 import { getContextRuntimeServices } from "../context.runtime.js";
-import { contextStreamByteLength, parseContextStepStreamChunk, } from "../context.step-stream.js";
+import { createContextStepStreamChunk, contextStreamByteLength, encodeContextStepStreamChunk, parseContextStepStreamChunk, } from "../context.step-stream.js";
+import { resolveContextPartChunkIdentity } from "../context.part-identity.js";
 export async function writeContextEvents(params) {
     "use step";
     const writable = params.writable;
@@ -48,6 +49,19 @@ function asRecord(value) {
 function asString(value) {
     return typeof value === "string" ? value.trim() : "";
 }
+function toJsonSafeRecord(value) {
+    if (typeof value === "undefined")
+        return undefined;
+    try {
+        const json = JSON.parse(JSON.stringify(value));
+        return json && typeof json === "object"
+            ? json
+            : { value: json };
+    }
+    catch {
+        return undefined;
+    }
+}
 function createUnsetStreamLinkTx(db, executionId, label, streamId) {
     try {
         return db.tx.event_executions[executionId].unlink({ [label]: streamId });
@@ -169,6 +183,100 @@ export async function abortPersistedContextStepStream(params) {
         abortReason: params.reason,
     });
 }
+export async function writeActionResultPartChunks(params) {
+    "use step";
+    if (!params.session || params.actionResults.length === 0)
+        return [];
+    const writer = params.session.stream.getWriter();
+    const events = [];
+    const sequenceBase = Date.now();
+    try {
+        for (let index = 0; index < params.actionResults.length; index += 1) {
+            const result = params.actionResults[index];
+            const actionRef = String(result.actionRequest.actionRef || "");
+            const actionName = String(result.actionRequest.actionName || "");
+            if (!actionRef || !actionName)
+                continue;
+            const chunkType = result.success
+                ? "chunk.action_completed"
+                : "chunk.action_failed";
+            const identity = resolveContextPartChunkIdentity({
+                stepId: params.session.stepId,
+                provider: "ekairos",
+                providerPartId: actionRef,
+                chunkType,
+            });
+            if (!identity)
+                continue;
+            const data = result.success
+                ? {
+                    actionRef,
+                    actionCallId: actionRef,
+                    actionName,
+                    toolCallId: actionRef,
+                    toolName: actionName,
+                    output: toJsonSafeRecord(result.output),
+                }
+                : {
+                    actionRef,
+                    actionCallId: actionRef,
+                    actionName,
+                    toolCallId: actionRef,
+                    toolName: actionName,
+                    error: {
+                        message: String(result.errorText || "Action failed."),
+                    },
+                };
+            const at = new Date().toISOString();
+            const sequence = sequenceBase + index;
+            const persistedChunk = createContextStepStreamChunk({
+                at,
+                sequence,
+                chunkType,
+                stepId: params.session.stepId,
+                partId: identity.partId,
+                providerPartId: identity.providerPartId,
+                partType: identity.partType,
+                partSlot: identity.partSlot,
+                provider: "ekairos",
+                providerChunkType: result.success
+                    ? "action_completed"
+                    : "action_failed",
+                actionRef,
+                data,
+            });
+            await writer.write(encodeContextStepStreamChunk(persistedChunk, {
+                stepId: params.session.stepId,
+            }));
+            events.push({
+                type: "chunk.emitted",
+                at,
+                chunkType,
+                contextId: params.contextId,
+                executionId: params.executionId,
+                stepId: params.session.stepId,
+                itemId: params.itemId,
+                sequence,
+                provider: "ekairos",
+                providerChunkType: result.success
+                    ? "action_completed"
+                    : "action_failed",
+                actionRef,
+                partId: identity.partId,
+                providerPartId: identity.providerPartId,
+                partType: identity.partType,
+                partSlot: identity.partSlot,
+                data,
+            });
+        }
+    }
+    finally {
+        if (typeof writer?.releaseLock === "function") {
+            writer.releaseLock();
+        }
+    }
+    return events;
+}
 export async function readPersistedContextStepStream(params) {
     if (!params.db?.streams?.createReadStream) {
         throw new Error("InstantDB streams are not available on the provided runtime.");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ekairos/events",
-  "version": "1.22.44-beta.development.0",
+  "version": "1.22.46-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.44-beta.development.0",
+    "@ekairos/domain": "^1.22.46-beta.development.0",
     "@instantdb/admin": "0.22.158",
     "@instantdb/core": "0.22.142",
     "@vercel/mcp-adapter": "^1.0.0",