@ekairos/events 1.22.32-beta.development.0 → 1.22.33-beta.development.0

package/dist/context.toolcalls.js

@@ -12,6 +12,7 @@
  * Keeping this logic here helps `context.engine.ts` read like orchestration, and keeps
  * these transformations testable and reusable.
  */
+import { isContextPartEnvelope, normalizePartsForPersistence, normalizeToolResultContentToBlocks, } from "./context.parts.js";
 /**
  * Extracts tool calls from an event's `parts` array.
  *
@@ -25,6 +26,16 @@
 export function extractToolCallsFromParts(parts) {
     const safeParts = parts ?? [];
     return safeParts.reduce((acc, p) => {
+        if (isContextPartEnvelope(p) && p.type === "tool-call") {
+            const firstContent = Array.isArray(p.content) ? p.content[0] : undefined;
+            const args = firstContent && firstContent.type === "json" ? firstContent.value : p.content;
+            acc.push({
+                toolCallId: p.toolCallId,
+                toolName: p.toolName,
+                args,
+            });
+            return acc;
+        }
         if (typeof p?.type === "string" && p.type.startsWith("tool-")) {
             const toolName = p.type.split("-").slice(1).join("-");
             acc.push({ toolCallId: p.toolCallId, toolName, args: p.input });
@@ -46,15 +57,45 @@ export function extractToolCallsFromParts(parts) {
  * - on failure: `{ state: "output-error", errorText: <message> }`
  */
 export function applyToolExecutionResultToParts(parts, toolCall, execution) {
-    return parts.map((p) => {
-        if (p?.type === `tool-${toolCall.toolName}` && p.toolCallId === toolCall.toolCallId) {
-            if (execution.success) {
-                return { ...p, state: "output-available", output: execution.result };
-            }
-            return { ...p, state: "output-error", errorText: String(execution.message || "Error") };
+    const normalized = normalizePartsForPersistence(parts);
+    const next = [];
+    let insertedResult = false;
+    const resultContent = execution.success
+        ? normalizeToolResultContentToBlocks(execution.result)
+        : [
+            {
+                type: "text",
+                text: String(execution.message || "Error"),
+            },
+        ];
+    for (const part of normalized) {
+        next.push(part);
+        if (part.type !== "tool-call") {
+            continue;
+        }
+        if (part.toolCallId !== toolCall.toolCallId ||
+            part.toolName !== toolCall.toolName) {
+            continue;
         }
-        return p;
-    });
+        next.push({
+            type: "tool-result",
+            toolCallId: toolCall.toolCallId,
+            toolName: toolCall.toolName,
+            state: execution.success ? "output-available" : "output-error",
+            content: resultContent,
+        });
+        insertedResult = true;
+    }
+    if (!insertedResult) {
+        next.push({
+            type: "tool-result",
+            toolCallId: toolCall.toolCallId,
+            toolName: toolCall.toolName,
+            state: execution.success ? "output-available" : "output-error",
+            content: resultContent,
+        });
+    }
+    return next;
 }
 /**
  * Returns `true` when a given tool has a **settled** execution result in an event's parts.
@@ -67,7 +108,10 @@ export function applyToolExecutionResultToParts(parts, toolCall, execution) {
  * decide based on the persisted `reactionEvent` (not ephemeral in-memory arrays).
  */
 export function didToolExecute(event, toolName) {
-    const parts = event.content.parts;
-    return parts.some((p) => p.type === `tool-${toolName}` &&
-        (p.state === "output-available" || p.state === "output-error"));
+    const parts = (event.content.parts ?? []).flatMap((part) => isContextPartEnvelope(part) ? [part] : normalizePartsForPersistence([part]));
+    return parts.some((p) => (p.type === "tool-result" &&
+        p.toolName === toolName &&
+        (p.state === "output-available" || p.state === "output-error")) ||
+        (p.type === `tool-${toolName}` &&
+            (p.state === "output-available" || p.state === "output-error")));
 }

package/dist/index.d.ts

@@ -4,7 +4,9 @@ export type { WireDate, ContextMirrorContext, ContextMirrorExecution, ContextMir
 export { registerContext, getContext, getContextFactory, hasContext, listContexts, type ContextKey, } from "./context.registry.js";
 export { eventsDomain } from "./schema.js";
 export { didToolExecute, extractToolCallsFromParts } from "./context.toolcalls.js";
-export { INPUT_ITEM_TYPE, INPUT_TEXT_ITEM_TYPE, OUTPUT_ITEM_TYPE, WEB_CHANNEL, AGENT_CHANNEL, EMAIL_CHANNEL, createUserItemFromUIMessages, createAssistantItemFromUIMessages, convertToUIMessage, convertItemToModelMessages, convertItemsToModelMessages, convertModelMessageToItem, type ResponseMessage, } from "./context.events.js";
+export { contextPartSchema, contextPartEnvelopeSchema, contextPartContentSchema, isContextPartEnvelope, parseContextPartEnvelope, normalizePartsForPersistence, } from "./context.parts.js";
+export type { ContextPart, ContextPartEnvelope, ContextPartContent, } from "./context.parts.js";
+export { INPUT_ITEM_TYPE, INPUT_TEXT_ITEM_TYPE, OUTPUT_ITEM_TYPE, WEB_CHANNEL, AGENT_CHANNEL, EMAIL_CHANNEL, createUserItemFromUIMessages, createAssistantItemFromUIMessages, convertToUIMessage, convertItemToModelMessages, convertItemsToModelMessages, convertModelMessageToItem, isContextOutputPart, normalizeContextOutputPart, type ResponseMessage, type ContextOutputPart, type ContextOutputContentPart, } from "./context.events.js";
 export { CONTEXT_STATUSES, EXECUTION_STATUSES, STEP_STATUSES, STEP_KINDS, ITEM_STATUSES, ITEM_TYPES, CHANNELS, TRACE_EVENT_KINDS, CONTEXT_STREAM_CHUNK_TYPES, STREAM_LIFECYCLE_CHUNK_TYPES, STREAM_TEXT_CHUNK_TYPES, STREAM_REASONING_CHUNK_TYPES, STREAM_ACTION_CHUNK_TYPES, STREAM_SOURCE_CHUNK_TYPES, STREAM_METADATA_CHUNK_TYPES, STREAM_ERROR_CHUNK_TYPES, CONTEXT_TRANSITIONS, EXECUTION_TRANSITIONS, STEP_TRANSITIONS, ITEM_TRANSITIONS, canContextTransition, canExecutionTransition, canStepTransition, canItemTransition, assertContextTransition, assertExecutionTransition, assertStepTransition, assertItemTransition, isContextStreamChunkType, assertContextPartKey, } from "./context.contract.js";
 export type { Transition, ContextStatus, ExecutionStatus, StepStatus, StepKind, ItemStatus, ItemType, Channel, TraceEventKind, ContextStreamChunkType, ContextTransition, ExecutionTransition, StepTransition, ItemTransition, } from "./context.contract.js";
 export { DEFAULT_CODEX_TOOL_NAME, DEFAULT_CODEX_MODEL, codexToolInputSchema, buildDefaultCodexNarrative, didCodexToolExecute, createCodexContextBuilder, type CodexContextRuntimeMode, type CodexContextReasoningLevel, type CodexContextRuntime, type CodexContextEnv, type CodexToolInput, type CodexToolOutput, type CodexExecuteArgs, type CodexContextBuilderConfig, type CodexContextBuilder, } from "./codex.js";

package/dist/index.js

@@ -2,7 +2,8 @@ export { context, createContext, createAiSdkReactor, createScriptedReactor, Cont
 export { registerContext, getContext, getContextFactory, hasContext, listContexts, } from "./context.registry.js";
 export { eventsDomain } from "./schema.js";
 export { didToolExecute, extractToolCallsFromParts } from "./context.toolcalls.js";
-export { INPUT_ITEM_TYPE, INPUT_TEXT_ITEM_TYPE, OUTPUT_ITEM_TYPE, WEB_CHANNEL, AGENT_CHANNEL, EMAIL_CHANNEL, createUserItemFromUIMessages, createAssistantItemFromUIMessages, convertToUIMessage, convertItemToModelMessages, convertItemsToModelMessages, convertModelMessageToItem, } from "./context.events.js";
+export { contextPartSchema, contextPartEnvelopeSchema, contextPartContentSchema, isContextPartEnvelope, parseContextPartEnvelope, normalizePartsForPersistence, } from "./context.parts.js";
+export { INPUT_ITEM_TYPE, INPUT_TEXT_ITEM_TYPE, OUTPUT_ITEM_TYPE, WEB_CHANNEL, AGENT_CHANNEL, EMAIL_CHANNEL, createUserItemFromUIMessages, createAssistantItemFromUIMessages, convertToUIMessage, convertItemToModelMessages, convertItemsToModelMessages, convertModelMessageToItem, isContextOutputPart, normalizeContextOutputPart, } from "./context.events.js";
 export { CONTEXT_STATUSES, EXECUTION_STATUSES, STEP_STATUSES, STEP_KINDS, ITEM_STATUSES, ITEM_TYPES, CHANNELS, TRACE_EVENT_KINDS, CONTEXT_STREAM_CHUNK_TYPES, STREAM_LIFECYCLE_CHUNK_TYPES, STREAM_TEXT_CHUNK_TYPES, STREAM_REASONING_CHUNK_TYPES, STREAM_ACTION_CHUNK_TYPES, STREAM_SOURCE_CHUNK_TYPES, STREAM_METADATA_CHUNK_TYPES, STREAM_ERROR_CHUNK_TYPES, CONTEXT_TRANSITIONS, EXECUTION_TRANSITIONS, STEP_TRANSITIONS, ITEM_TRANSITIONS, canContextTransition, canExecutionTransition, canStepTransition, canItemTransition, assertContextTransition, assertExecutionTransition, assertStepTransition, assertItemTransition, isContextStreamChunkType, assertContextPartKey, } from "./context.contract.js";
 export { DEFAULT_CODEX_TOOL_NAME, DEFAULT_CODEX_MODEL, codexToolInputSchema, buildDefaultCodexNarrative, didCodexToolExecute, createCodexContextBuilder, } from "./codex.js";
 export { useContext, } from "./react.js";

package/dist/schema.js

@@ -52,8 +52,9 @@ export const eventsDomain = domain("events")
             key: i.string().unique().indexed(), // `${stepId}:${idx}`
             stepId: i.string().indexed(),
             idx: i.number().indexed(),
-            type: i.string().optional().indexed(),
-            part: i.any().optional(),
+            type: i.string().optional().indexed(), // canonical part.type
+            part: i.json().optional(),
+            metadata: i.json().optional(), // provider/model/runtime metadata only
             updatedAt: i.date().optional(),
         }),
         event_trace_events: i.entity({

package/dist/stores/instant.store.d.ts

@@ -20,6 +20,8 @@ export declare class InstantStore implements ContextStore {
     updateItem(eventId: string, event: ContextItem): Promise<ContextItem>;
     getItem(eventId: string): Promise<ContextItem | null>;
     getItems(contextIdentifier: ContextIdentifier): Promise<ContextItem[]>;
+    private getExecutionIdForItem;
+    private getProjectedPartsForOutputItem;
     createExecution(contextIdentifier: ContextIdentifier, triggerEventId: string, reactionEventId: string): Promise<{
         id: string;
     }>;

package/dist/stores/instant.store.js

@@ -1,10 +1,11 @@
 import "../polyfills/dom-events.js";
 import { id, lookup } from "@instantdb/admin";
-import { convertItemsToModelMessages } from "../context.events.js";
+import { convertItemToModelMessages } from "../context.events.js";
 import { assertContextTransition, assertExecutionTransition, assertItemTransition, assertStepTransition, } from "../context.contract.js";
 export { parseAndStoreDocument } from "./instant.document-parser.js";
 import { expandEventsWithInstantDocuments } from "./instant.documents.js";
 export { coerceDocumentTextPages, expandEventsWithInstantDocuments, } from "./instant.documents.js";
+import { mergeContextPartEnvelope, normalizePartsForPersistence, splitContextPartEnvelope, } from "../context.parts.js";
 function shouldDebugInstantStore() {
     return (process.env.EKAIROS_CONTEXT_DEBUG === "1" ||
         process.env.EKAIROS_CONTEXT_DEBUG === "1" ||
@@ -307,6 +308,81 @@ export class InstantStore {
         }
         return sortItems((res.event_items ?? []));
     }
+    async getExecutionIdForItem(itemId) {
+        const directResult = await this.db.query({
+            event_items: {
+                $: { where: { id: itemId }, limit: 1 },
+                execution: {},
+            },
+        });
+        const directRow = directResult?.event_items?.[0];
+        const directExecutionId = directRow?.execution?.id;
+        if (typeof directExecutionId === "string" &&
+            directExecutionId.trim().length > 0) {
+            return directExecutionId;
+        }
+        const reverseResult = await this.db.query({
+            event_executions: {
+                $: { where: { "reaction.id": itemId }, limit: 1 },
+            },
+        });
+        const reverseRow = reverseResult?.event_executions?.[0];
+        const reverseExecutionId = reverseRow?.id;
+        return typeof reverseExecutionId === "string" && reverseExecutionId.trim().length > 0
+            ? reverseExecutionId
+            : null;
+    }
+    async getProjectedPartsForOutputItem(itemId) {
+        const executionId = await this.getExecutionIdForItem(itemId);
+        if (!executionId) {
+            return null;
+        }
+        const stepResult = await this.db.query({
+            event_steps: {
+                $: {
+                    where: { "execution.id": executionId },
+                    limit: 200,
+                },
+            },
+        });
+        const steps = sortItems((stepResult?.event_steps ?? [])).sort((a, b) => {
+            const ai = typeof a?.iteration === "number" ? a.iteration : 0;
+            const bi = typeof b?.iteration === "number" ? b.iteration : 0;
+            if (ai !== bi)
+                return ai - bi;
+            return String(a?.id ?? "").localeCompare(String(b?.id ?? ""));
+        });
+        if (steps.length === 0) {
+            return null;
+        }
+        const projectedParts = [];
+        for (const step of steps) {
+            const stepId = typeof step?.id === "string" ? step.id : "";
+            if (!stepId)
+                continue;
+            const partResult = await this.db.query({
+                event_parts: {
+                    $: {
+                        where: { stepId: stepId },
+                        limit: 500,
+                        order: { idx: "asc" },
+                    },
+                },
+            });
+            const partRows = (partResult?.event_parts ?? []).sort((a, b) => {
+                const ai = typeof a?.idx === "number" ? a.idx : 0;
+                const bi = typeof b?.idx === "number" ? b.idx : 0;
+                if (ai !== bi)
+                    return ai - bi;
+                return 0;
+            });
+            projectedParts.push(...partRows.map((row) => mergeContextPartEnvelope({
+                part: row?.part,
+                metadata: row?.metadata,
+            })));
+        }
+        return projectedParts;
+    }
     async createExecution(contextIdentifier, triggerEventId, reactionEventId) {
         const normalizedTriggerEventId = ensureValidEntityId(triggerEventId, "triggerEventId");
         const normalizedReactionEventId = ensureValidEntityId(reactionEventId, "reactionEventId");
@@ -433,17 +509,19 @@ export class InstantStore {
         ]);
     }
     async saveStepParts(params) {
-        const parts = Array.isArray(params.parts) ? params.parts : [];
+        const parts = normalizePartsForPersistence(Array.isArray(params.parts) ? params.parts : []);
         if (parts.length === 0)
             return;
         const txs = parts.map((part, idx) => {
             const key = `${params.stepId}:${idx}`;
+            const split = splitContextPartEnvelope(part);
             return this.db.tx.event_parts[lookup("key", key)]
                 .update({
                 stepId: params.stepId,
                 idx,
-                type: typeof part?.type === "string" ? String(part.type) : undefined,
-                part,
+                type: typeof split.part?.type === "string" ? String(split.part.type) : undefined,
+                part: split.part,
+                metadata: split.metadata,
                 updatedAt: new Date(),
             })
                 .link({ step: params.stepId });
@@ -456,7 +534,24 @@ export class InstantStore {
             events,
             derivedEventType: "output",
         });
-        return await convertItemsToModelMessages(expanded);
+        const messages = [];
+        for (const event of expanded) {
+            const isOutputItem = event?.type === "output";
+            const projectedParts = isOutputItem
+                ? await this.getProjectedPartsForOutputItem(String(event?.id ?? ""))
+                : null;
+            const projectedEvent = projectedParts && projectedParts.length > 0
+                ? {
+                    ...event,
+                    content: {
+                        ...(event?.content ?? {}),
+                        parts: projectedParts,
+                    },
+                }
+                : event;
+            messages.push(await convertItemToModelMessages(projectedEvent));
+        }
+        return messages.flat();
     }
 }
 export function createInstantStoreRuntime(params) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ekairos/events",
-  "version": "1.22.32-beta.development.0",
+  "version": "1.22.33-beta.development.0",
   "description": "Ekairos Events - Context-first workflow runtime",
   "type": "module",
   "main": "dist/index.js",
@@ -116,7 +116,7 @@
   },
   "dependencies": {
     "@ai-sdk/openai": "^2.0.52",
-    "@ekairos/domain": "^1.22.32-beta.development.0",
+    "@ekairos/domain": "^1.22.33-beta.development.0",
     "@instantdb/admin": "0.22.158",
     "@instantdb/core": "0.22.142",
     "@vercel/mcp-adapter": "^1.0.0",