@ekairos/events 1.22.45-beta.development.0 → 1.22.47-beta.development.0

package/dist/context.config.d.ts

@@ -4,6 +4,7 @@ export type ContextEnvironment = Record<string, unknown>;
 export type ContextRuntime = {
     store: ContextStore;
     db: any;
+    env?: ContextEnvironment;
     domain?: ConcreteDomain<any, any>;
 };
-export declare function coerceContextRuntime(value: any): Promise<ContextRuntime>;
+export declare function coerceContextRuntime(value: any, env?: ContextEnvironment): Promise<ContextRuntime>;

package/dist/context.config.js

@@ -1,10 +1,14 @@
 const runtimeByDb = new WeakMap();
-export async function coerceContextRuntime(value) {
+export async function coerceContextRuntime(value, env) {
     if (!value) {
         throw new Error("Context runtime resolver returned no value.");
     }
+    const resolvedEnv = env ??
+        (typeof value === "object" && value !== null
+            ? value.env
+            : undefined);
     if (typeof value === "object" && value.store) {
-        return value;
+        return resolvedEnv ? { ...value, env: resolvedEnv } : value;
     }
     const dbCandidate = typeof value === "object" && value !== null && "db" in value
         ? value.db
@@ -15,12 +19,13 @@ export async function coerceContextRuntime(value) {
     if (typeof dbCandidate === "object" && dbCandidate !== null) {
         const cached = runtimeByDb.get(dbCandidate);
         if (cached)
-            return cached;
+            return resolvedEnv ? { ...cached, env: resolvedEnv } : cached;
     }
     const { InstantStore } = await import("./stores/instant.store.js");
     const runtime = {
         store: new InstantStore(dbCandidate),
         db: dbCandidate,
+        env: resolvedEnv,
         domain: typeof value === "object" ? value.domain : undefined,
     };
     if (typeof dbCandidate === "object" && dbCandidate !== null) {

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.runtime.d.ts

@@ -4,7 +4,11 @@ import type { ContextEnvironment } from "./context.config.js";
 import type { ContextStore } from "./context.store.js";
 import { eventsDomain } from "./schema.js";
 export type ContextRuntime<Env extends ContextEnvironment = ContextEnvironment> = EkairosRuntime<Env, any, any>;
-export type ContextRuntimeServiceHandle = Pick<ContextRuntime<any>, "db" | "resolve" | "meta">;
+export type ContextRuntimeServiceHandle = {
+    db: any | ((...args: any[]) => Promise<any> | any);
+    resolve?: (...args: any[]) => Promise<any> | any;
+    meta?: (...args: any[]) => Record<string, unknown> | undefined;
+};
 export type ContextRuntimeHandleForDomain<Env extends ContextEnvironment = ContextEnvironment, RequiredDomain extends DomainSchemaResult = typeof eventsDomain> = ContextRuntimeServiceHandle & {
     use<Subdomain extends typeof eventsDomain | RequiredDomain>(subdomain: Subdomain, options?: RuntimeResolveOptions): Promise<Omit<ActiveDomain<Subdomain, Env>, "env">>;
 };

package/dist/context.runtime.js

@@ -3,7 +3,11 @@ function asRecord(value) {
     return value && typeof value === "object" ? value : {};
 }
 export async function getContextRuntimeServices(runtime) {
-    const db = await runtime.db();
+    const runtimeRecord = asRecord(runtime);
+    const dbMember = runtimeRecord.db;
+    const db = typeof dbMember === "function"
+        ? await dbMember.call(runtime)
+        : dbMember;
     if (!db) {
         throw new Error("Context runtime did not provide a database instance.");
     }
@@ -15,9 +19,17 @@ export async function getContextRuntimeServices(runtime) {
             storeByDb.set(db, store);
         }
     }
-    const resolved = await runtime.resolve();
+    const resolveMember = runtimeRecord.resolve;
+    const resolved = typeof resolveMember === "function"
+        ? await resolveMember.call(runtime)
+        : runtime;
     const resolvedMeta = asRecord(resolved).meta;
-    const meta = typeof resolvedMeta === "function" ? resolvedMeta() : undefined;
+    const ownMeta = runtimeRecord.meta;
+    const meta = typeof resolvedMeta === "function"
+        ? resolvedMeta.call(resolved)
+        : typeof ownMeta === "function"
+            ? ownMeta.call(runtime)
+            : undefined;
     const domain = asRecord(meta).domain;
     return {
         db,

package/dist/runtime.step.js

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

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.47-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.47-beta.development.0",
     "@instantdb/admin": "0.22.158",
     "@instantdb/core": "0.22.142",
     "@vercel/mcp-adapter": "^1.0.0",