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

package/dist/steps/store.steps.js

@@ -2,6 +2,7 @@ import { getContextRuntimeServices } from "../context.runtime.js";
 import { OUTPUT_ITEM_TYPE, WEB_CHANNEL } from "../context.events.js";
 import { writeContextTraceEvents } from "./trace.steps.js";
 import { getClientResumeHookUrl, toolApprovalHookToken, toolApprovalWebhookToken, } from "../context.hooks.js";
+import { createPersistedContextStepStreamForRuntime, finalizePersistedContextStepStreamForRuntime, writeActionResultPartChunksToSession, } from "./stream.steps.js";
 async function getRuntimeAndEnv(params) {
     const env = params.runtime.env;
     const runtime = await getContextRuntimeServices(params.runtime);
@@ -142,6 +143,16 @@ export async function updateContextContent(params) {
     const { runtime } = await getRuntimeAndEnv(params);
     return await runtime.store.updateContextContent(params.contextIdentifier, params.content);
 }
+export async function updateContextDefinition(params) {
+    "use step";
+    const { runtime } = await getRuntimeAndEnv(params);
+    return await runtime.store.updateContextDefinition(params.contextIdentifier, params.definition);
+}
+export async function upsertContextResources(params) {
+    "use step";
+    const { runtime } = await getRuntimeAndEnv(params);
+    return await runtime.store.upsertContextResources(params.contextIdentifier, params.resources);
+}
 export async function updateContextReactor(params) {
     "use step";
     const { runtime } = await getRuntimeAndEnv(params);
@@ -157,11 +168,11 @@ export async function saveTriggerItem(params) {
     const { runtime } = await getRuntimeAndEnv(params);
     return await runtime.store.saveItem(params.contextIdentifier, params.event);
 }
-export async function saveTriggerAndCreateExecution(params) {
+export async function openExecution(params) {
     "use step";
     const { runtime, env } = await getRuntimeAndEnv(params);
     const { store, db } = runtime;
-    logStepDebug("saveTriggerAndCreateExecution:start", {
+    logStepDebug("openExecution:start", {
         contextIdentifier: summarizeContextIdentifierForLog(params.contextIdentifier),
         triggerEventId: params.triggerEvent?.id,
         triggerEventType: params.triggerEvent?.type,
@@ -173,7 +184,7 @@ export async function saveTriggerAndCreateExecution(params) {
         saved = await store.saveItem(params.contextIdentifier, params.triggerEvent);
     }
     catch (error) {
-        logStepDebug("saveTriggerAndCreateExecution:saveItem:error", {
+        logStepDebug("openExecution:saveItem:error", {
             contextIdentifier: summarizeContextIdentifierForLog(params.contextIdentifier),
             triggerEventId: params.triggerEvent?.id,
             error: summarizeStepError(error),
@@ -205,7 +216,7 @@ export async function saveTriggerAndCreateExecution(params) {
         });
     }
     catch (error) {
-        logStepDebug("saveTriggerAndCreateExecution:saveReaction:error", {
+        logStepDebug("openExecution:saveReaction:error", {
             contextIdentifier: summarizeContextIdentifierForLog(params.contextIdentifier),
             reactionEventId,
             error: summarizeStepError(error),
@@ -217,7 +228,7 @@ export async function saveTriggerAndCreateExecution(params) {
         execution = await store.createExecution(params.contextIdentifier, saved.id, savedReaction.id);
     }
     catch (error) {
-        logStepDebug("saveTriggerAndCreateExecution:createExecution:error", {
+        logStepDebug("openExecution:createExecution:error", {
             contextIdentifier: summarizeContextIdentifierForLog(params.contextIdentifier),
             triggerEventId: saved.id,
             reactionEventId: savedReaction.id,
@@ -236,7 +247,7 @@ export async function saveTriggerAndCreateExecution(params) {
         });
     }
     catch (error) {
-        logStepDebug("saveTriggerAndCreateExecution:linkItemsToExecution:error", {
+        logStepDebug("openExecution:linkItemsToExecution:error", {
             contextIdentifier: summarizeContextIdentifierForLog(params.contextIdentifier),
             triggerEventId: saved.id,
             reactionEventId: savedReaction.id,
@@ -417,6 +428,11 @@ export async function saveReactionItem(params) {
     }
     return saved;
 }
+export async function getContextItems(params) {
+    "use step";
+    const { runtime } = await getRuntimeAndEnv(params);
+    return await runtime.store.getItems(params.contextIdentifier);
+}
 export async function updateItem(params) {
     "use step";
     const { runtime, env } = await getRuntimeAndEnv(params);
@@ -468,16 +484,22 @@ export async function completeExecution(params) {
     const { runtime, env } = await getRuntimeAndEnv(params);
     const { store, db } = runtime;
     await store.completeExecution(params.contextIdentifier, params.executionId, params.status);
-    const contextId = typeof params.contextIdentifier?.id === "string"
-        ? String(params.contextIdentifier.id)
-        : undefined;
+    let savedReaction;
+    if (params.reactionEventId && params.reactionEvent) {
+        savedReaction = await store.updateItem(params.reactionEventId, params.reactionEvent);
+    }
+    const contextId = typeof params.contextId === "string"
+        ? params.contextId
+        : typeof params.contextIdentifier?.id === "string"
+            ? String(params.contextIdentifier.id)
+            : undefined;
     const { runId } = await resolveWorkflowRunId({
         env,
         db,
         executionId: params.executionId,
     });
     if (runId) {
-        await maybeWriteTraceEvents(env, [
+        const events = [
             {
                 workflowRunId: runId,
                 eventId: `context_execution:${String(params.executionId)}:${params.status}`,
@@ -489,8 +511,25 @@ export async function completeExecution(params) {
                     status: params.status,
                 },
             },
-        ]);
+        ];
+        if (savedReaction) {
+            events.push({
+                workflowRunId: runId,
+                eventId: `context_item:${String(savedReaction.id)}`,
+                eventKind: "context.item",
+                eventAt: new Date().toISOString(),
+                contextId,
+                executionId: String(params.executionId),
+                contextEventId: String(savedReaction.id),
+                payload: {
+                    ...savedReaction,
+                    direction: inferDirection(savedReaction),
+                },
+            });
+        }
+        await maybeWriteTraceEvents(env, events);
     }
+    return { reactionEvent: savedReaction };
 }
 export async function updateExecutionWorkflowRun(params) {
     "use step";
@@ -505,6 +544,27 @@ export async function updateExecutionWorkflowRun(params) {
         ]);
     }
 }
+export async function openExecutionStep(params) {
+    "use step";
+    const { runtime } = await getRuntimeAndEnv(params);
+    const { store } = runtime;
+    const step = await store.createStep({
+        executionId: params.executionId,
+        iteration: params.iteration,
+    });
+    const stream = await createPersistedContextStepStreamForRuntime(runtime, {
+        executionId: params.executionId,
+        stepId: step.id,
+    });
+    const context = await store.updateContextContent(params.contextIdentifier, params.content);
+    const events = await store.getItems(params.contextIdentifier);
+    return {
+        stepId: step.id,
+        stream,
+        context,
+        events,
+    };
+}
 export async function createContextStep(params) {
     "use step";
     const { runtime } = await getRuntimeAndEnv(params);
@@ -540,54 +600,151 @@ export async function updateContextStep(params) {
                 stepId: String(params.stepId),
                 payload: {
                     status: params.patch.status,
-                    kind: params.patch.kind,
-                    actionName: params.patch.actionName,
-                    actionInput: params.patch.actionInput,
-                    actionOutput: params.patch.actionOutput,
-                    actionError: params.patch.actionError,
                     iteration: params.iteration,
-                    actionRequests: params.patch.actionRequests,
-                    actionResults: params.patch.actionResults,
-                    continueLoop: params.patch.continueLoop,
                     errorText: params.patch.errorText,
                 },
             },
         ]);
     }
 }
+export async function completeExecutionStep(params) {
+    "use step";
+    const { runtime, env } = await getRuntimeAndEnv(params);
+    const { store, db } = runtime;
+    const actionResultChunkEvents = await writeActionResultPartChunksToSession({
+        session: params.session,
+        contextId: String(params.contextId ?? ""),
+        executionId: String(params.executionId ?? ""),
+        itemId: String(params.reactionEventId ?? ""),
+        actionResults: params.actionResults ?? [],
+    });
+    if (params.parts) {
+        await store.saveStepParts({ stepId: params.stepId, parts: params.parts });
+    }
+    if (params.session) {
+        await finalizePersistedContextStepStreamForRuntime({
+            runtime,
+            session: params.session,
+            mode: "close",
+        });
+    }
+    await store.updateStep(params.stepId, {
+        status: params.stepStatus ?? "completed",
+        ...(params.errorText !== undefined ? { errorText: params.errorText } : {}),
+        updatedAt: new Date(),
+    });
+    let savedReaction;
+    if (params.reactionEventId && params.reactionEvent) {
+        savedReaction = await store.updateItem(params.reactionEventId, params.reactionEvent);
+    }
+    const { runId } = await resolveWorkflowRunId({
+        env,
+        db,
+        executionId: params.executionId,
+    });
+    if (runId) {
+        const events = [
+            {
+                workflowRunId: runId,
+                eventId: `context_step:${String(params.stepId)}`,
+                eventKind: "context.step",
+                eventAt: new Date().toISOString(),
+                contextId: params.contextId,
+                executionId: params.executionId,
+                stepId: String(params.stepId),
+                payload: {
+                    status: params.stepStatus ?? "completed",
+                    iteration: params.iteration,
+                    errorText: params.errorText,
+                },
+            },
+        ];
+        if (params.parts?.length) {
+            for (let idx = 0; idx < params.parts.length; idx += 1) {
+                const part = params.parts[idx];
+                events.push({
+                    workflowRunId: runId,
+                    eventId: `context_part:${String(params.stepId)}:${idx}`,
+                    eventKind: "context.part",
+                    eventAt: new Date().toISOString(),
+                    contextId: params.contextId,
+                    executionId: params.executionId,
+                    stepId: String(params.stepId),
+                    partKey: `${String(params.stepId)}:${idx}`,
+                    partIdx: idx,
+                    payload: part,
+                });
+            }
+        }
+        if (savedReaction) {
+            events.push({
+                workflowRunId: runId,
+                eventId: `context_item:${String(savedReaction.id)}`,
+                eventKind: "context.item",
+                eventAt: new Date().toISOString(),
+                contextId: params.contextId,
+                executionId: params.executionId,
+                contextEventId: String(savedReaction.id),
+                payload: {
+                    ...savedReaction,
+                    direction: inferDirection(savedReaction),
+                },
+            });
+        }
+        await maybeWriteTraceEvents(env, events);
+    }
+    return { reactionEvent: savedReaction, actionResultChunkEvents };
+}
 export async function linkItemToExecutionStep(params) {
     "use step";
     const { runtime } = await getRuntimeAndEnv(params);
     const { store } = runtime;
     await store.linkItemToExecution({ itemId: params.itemId, executionId: params.executionId });
 }
-export async function saveContextPartsStep(params) {
+export async function saveExecutionStepOutput(params) {
     "use step";
     const { runtime, env } = await getRuntimeAndEnv(params);
     const { store, db } = runtime;
     await store.saveStepParts({ stepId: params.stepId, parts: params.parts });
+    const savedReaction = await store.updateItem(params.reactionEventId, params.reactionEvent);
     const { runId } = await resolveWorkflowRunId({
         env,
         db,
         executionId: params.executionId,
     });
-    if (runId && params.parts?.length) {
+    if (runId) {
         const events = [];
-        for (let idx = 0; idx < params.parts.length; idx += 1) {
-            const part = params.parts[idx];
-            events.push({
-                workflowRunId: runId,
-                eventId: `context_part:${String(params.stepId)}:${idx}`,
-                eventKind: "context.part",
-                eventAt: new Date().toISOString(),
-                contextId: params.contextId,
-                executionId: params.executionId,
-                stepId: String(params.stepId),
-                partKey: `${String(params.stepId)}:${idx}`,
-                partIdx: idx,
-                payload: part,
-            });
+        if (params.parts?.length) {
+            for (let idx = 0; idx < params.parts.length; idx += 1) {
+                const part = params.parts[idx];
+                events.push({
+                    workflowRunId: runId,
+                    eventId: `context_part:${String(params.stepId)}:${idx}`,
+                    eventKind: "context.part",
+                    eventAt: new Date().toISOString(),
+                    contextId: params.contextId,
+                    executionId: params.executionId,
+                    stepId: String(params.stepId),
+                    partKey: `${String(params.stepId)}:${idx}`,
+                    partIdx: idx,
+                    payload: part,
+                });
+            }
         }
+        events.push({
+            workflowRunId: runId,
+            eventId: `context_item:${String(savedReaction.id)}`,
+            eventKind: "context.item",
+            eventAt: new Date().toISOString(),
+            contextId: params.contextId,
+            executionId: params.executionId,
+            contextEventId: String(savedReaction.id),
+            payload: {
+                ...savedReaction,
+                direction: inferDirection(savedReaction),
+            },
+        });
         await maybeWriteTraceEvents(env, events);
     }
+    return { reactionEvent: savedReaction };
 }

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

@@ -20,12 +20,27 @@ export type PersistedContextStepStreamSession = {
     executionId: string;
     stepId: string;
 };
+export declare function createPersistedContextStepStreamForRuntime(runtime: {
+    db?: any;
+}, params: {
+    executionId: string;
+    stepId: string;
+    clientId?: string;
+}): Promise<PersistedContextStepStreamSession>;
 export declare function createPersistedContextStepStream(params: {
     runtime: ContextRuntime<ContextEnvironment>;
     executionId: string;
     stepId: string;
     clientId?: string;
 }): Promise<PersistedContextStepStreamSession>;
+export declare function finalizePersistedContextStepStreamForRuntime(params: {
+    runtime: {
+        db?: any;
+    };
+    session: PersistedContextStepStreamSession;
+    mode: "close" | "abort";
+    abortReason?: string | null;
+}): Promise<void>;
 export declare function closePersistedContextStepStream(params: {
     runtime: ContextRuntime<ContextEnvironment>;
     session: PersistedContextStepStreamSession;
@@ -35,6 +50,23 @@ export declare function abortPersistedContextStepStream(params: {
     session: PersistedContextStepStreamSession;
     reason?: string | null;
 }): Promise<void>;
+export type ContextActionResultForStream = {
+    actionRequest: {
+        actionRef: string;
+        actionName: string;
+        input: unknown;
+    };
+    success: boolean;
+    output: unknown;
+    errorText?: string;
+};
+export declare function writeActionResultPartChunksToSession(params: {
+    session?: PersistedContextStepStreamSession | null;
+    contextId: string;
+    executionId: string;
+    itemId: string;
+    actionResults: ContextActionResultForStream[];
+}): 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 });
@@ -63,9 +77,7 @@ export function createContextStepStreamClientId(stepId) {
     }
     return `event-step:${normalized}`;
 }
-export async function createPersistedContextStepStream(params) {
-    "use step";
-    const runtime = await getContextRuntimeServices(params.runtime);
+export async function createPersistedContextStepStreamForRuntime(runtime, params) {
     const db = runtime?.db;
     if (!db?.streams?.createWriteStream) {
         throw new Error("InstantDB streams are not available on the configured runtime. Upgrade @instantdb/admin to a streams-capable version.");
@@ -105,10 +117,13 @@ export async function createPersistedContextStepStream(params) {
         stepId: params.stepId,
     };
 }
-async function finalizePersistedContextStepStream(params) {
+export async function createPersistedContextStepStream(params) {
     "use step";
     const runtime = await getContextRuntimeServices(params.runtime);
-    const db = runtime?.db;
+    return await createPersistedContextStepStreamForRuntime(runtime, params);
+}
+export async function finalizePersistedContextStepStreamForRuntime(params) {
+    const db = params.runtime?.db;
     const writer = params.session.stream.getWriter();
     try {
         if (params.mode === "abort") {
@@ -143,6 +158,16 @@ async function finalizePersistedContextStepStream(params) {
         txs.push(unsetActive);
     await db.transact(txs);
 }
+async function finalizePersistedContextStepStream(params) {
+    "use step";
+    const runtime = await getContextRuntimeServices(params.runtime);
+    return await finalizePersistedContextStepStreamForRuntime({
+        runtime,
+        session: params.session,
+        mode: params.mode,
+        abortReason: params.abortReason,
+    });
+}
 export async function closePersistedContextStepStream(params) {
     return await finalizePersistedContextStepStream({
         runtime: params.runtime,
@@ -158,6 +183,99 @@ export async function abortPersistedContextStepStream(params) {
         abortReason: params.reason,
     });
 }
+export async function writeActionResultPartChunksToSession(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
+                ? {
+                    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/dist/steps/trace.steps.d.ts

@@ -1,6 +1,6 @@
 import "../polyfills/dom-events.js";
 import type { ContextEnvironment } from "../context.config.js";
-import type { ContextRuntime } from "../context.runtime.js";
+import type { ContextRuntimeServiceHandle } from "../context.runtime.js";
 import type { TraceEventKind } from "../context.contract.js";
 export type ContextTraceEventWrite = {
     workflowRunId: string;
@@ -33,8 +33,8 @@ export type ContextTraceEventWrite = {
     payload?: unknown;
     testId?: string;
 };
-export declare function writeContextTraceEvents(params: {
-    runtime?: ContextRuntime<ContextEnvironment>;
-    env: ContextEnvironment;
+export declare function writeContextTraceEvents<Env extends ContextEnvironment = ContextEnvironment>(params: {
+    runtime?: ContextRuntimeServiceHandle;
+    env?: Env;
     events: ContextTraceEventWrite[];
 }): Promise<void>;

package/dist/steps/trace.steps.js

@@ -18,6 +18,20 @@ function requireToken() {
     throw new Error("[context/trace] Missing EKAIROS_CLERK_API_KEY");
 }
 let jwtCache = null;
+function asRecord(value) {
+    return value && typeof value === "object" ? value : {};
+}
+function asTraceEnv(value) {
+    const record = asRecord(value);
+    if (Object.keys(record).length === 0)
+        return undefined;
+    return {
+        baseUrl: typeof record.baseUrl === "string" ? record.baseUrl : undefined,
+        apiKey: typeof record.apiKey === "string" ? record.apiKey : undefined,
+        projectId: typeof record.projectId === "string" ? record.projectId : undefined,
+        strict: record.strict === true,
+    };
+}
 function parseJwtExpMs(token) {
     const parts = token.split(".");
     if (parts.length !== 3)
@@ -47,8 +61,8 @@ async function getTraceAuthHeader(baseUrl, projectId) {
             body: JSON.stringify({ projectId }),
         });
         if (res.ok) {
-            const json = (await res.json());
-            const token = typeof json?.token === "string" ? json.token : "";
+            const json = asRecord(await res.json());
+            const token = typeof json.token === "string" ? json.token : "";
             const expMs = parseJwtExpMs(token) ?? now + 60 * 60 * 1000;
             if (token) {
                 jwtCache = { token, expMs };
@@ -79,7 +93,8 @@ async function readProjectId() {
 export async function writeContextTraceEvents(params) {
     if (!params.events?.length)
         return;
-    const envTrace = params.env?.traces;
+    const envRecord = asRecord(params.env);
+    const envTrace = asTraceEnv(envRecord.traces);
     // Tracing must NEVER break workflows by default.
     // Use EKAIROS_TRACES_STRICT=1 if you want to fail hard.
     const strict = envTrace?.strict === true || process.env.EKAIROS_TRACES_STRICT === "1";
@@ -89,11 +104,11 @@ export async function writeContextTraceEvents(params) {
             throw new Error("[context/trace] runtime is required");
         }
         const runtime = await getContextRuntimeServices(params.runtime);
-        const db = runtime?.db;
+        const db = runtime.db;
         if (db) {
             const now = new Date();
-            const orgId = typeof params.env?.orgId === "string"
-                ? String(params.env.orgId)
+            const orgId = typeof envRecord.orgId === "string"
+                ? String(envRecord.orgId)
                 : "";
             const projectId = await readProjectId();
             const byRun = new Map();