@ekairos/events 1.22.45-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/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.45-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.45-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",