@ekairos/events 1.22.41-beta.development.0 → 1.22.42-beta.development.0

package/dist/context.engine.js

@@ -4,6 +4,8 @@ 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 { 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";
@@ -86,6 +88,112 @@ 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_output_available"
+                : "chunk.action_output_error";
+            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_output_available"
+                    : "action_output_error",
+                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_output_available"
+                    : "action_output_error",
+                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();
@@ -960,6 +1068,15 @@ export class ContextEngine {
                         };
                     }
                 })));
+                await measureBenchmark(params.__benchmark, `${stagePrefix}.writeActionResultPartChunksMs`, async () => await writeActionResultPartChunks({
+                    session: currentStepStream,
+                    writable,
+                    silent,
+                    contextId: String(currentContext.id),
+                    executionId,
+                    itemId: reactionEventId,
+                    actionResults: actionResults,
+                }));
                 // 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/package.json

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