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

package/dist/context.parts.js

@@ -1,5 +1,13 @@
 import { z } from "zod";
-const metadataSchema = z.record(z.string(), z.unknown()).optional();
+export const reactorMetadataSchema = z
+    .object({
+    reactorKind: z.string().min(1),
+    executionId: z.string().optional(),
+    itemId: z.string().optional(),
+    eventName: z.string().optional(),
+    actionCallId: z.string().optional(),
+})
+    .catchall(z.unknown());
 const textContentSchema = z.object({
     type: z.literal("text"),
     text: z.string(),
@@ -45,63 +53,87 @@ export const contextPartContentSchema = z.discriminatedUnion("type", [
     sourceUrlContentSchema,
     sourceDocumentContentSchema,
 ]);
-const contextInlineContentSchema = z.discriminatedUnion("type", [
+export const contextInlineContentSchema = z.discriminatedUnion("type", [
     textContentSchema,
     fileContentSchema,
     jsonContentSchema,
 ]);
-const contextContentPartSchema = z.object({
-    type: z.literal("content"),
-    content: z.array(contextInlineContentSchema),
-    state: z.enum(["streaming", "done"]).optional(),
+const messageContentSchema = z
+    .object({
+    text: z.string().optional(),
+    blocks: z.array(contextInlineContentSchema).optional(),
+})
+    .superRefine((value, ctx) => {
+    const hasText = typeof value.text === "string" && value.text.length > 0;
+    const hasBlocks = Array.isArray(value.blocks) && value.blocks.length > 0;
+    if (!hasText && !hasBlocks) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "message content requires text or blocks",
+        });
+    }
+});
+export const contextMessagePartSchema = z.object({
+    type: z.literal("message"),
+    content: messageContentSchema,
+    reactorMetadata: reactorMetadataSchema.optional(),
 });
-const contextReasoningPartSchema = z.object({
+export const contextReasoningPartSchema = z.object({
     type: z.literal("reasoning"),
-    content: z.array(textContentSchema),
-    state: z.enum(["streaming", "done"]).optional(),
+    content: z.object({
+        text: z.string(),
+        state: z.enum(["streaming", "done"]).optional(),
+    }),
+    reactorMetadata: reactorMetadataSchema.optional(),
 });
-const contextSourcePartSchema = z.object({
+export const contextSourcePartSchema = z.object({
     type: z.literal("source"),
-    content: z.array(z.discriminatedUnion("type", [sourceUrlContentSchema, sourceDocumentContentSchema])),
+    content: z.object({
+        sources: z.array(z.discriminatedUnion("type", [sourceUrlContentSchema, sourceDocumentContentSchema])),
+    }),
+    reactorMetadata: reactorMetadataSchema.optional(),
 });
-const contextToolCallPartSchema = z.object({
-    type: z.literal("tool-call"),
-    toolCallId: z.string().min(1),
-    toolName: z.string().min(1),
-    content: z.array(contextInlineContentSchema),
-    state: z.enum(["input-streaming", "input-available"]).optional(),
+const contextActionErrorSchema = z.object({
+    message: z.string(),
+    code: z.string().optional(),
+    details: z.unknown().optional(),
 });
-const contextToolResultPartSchema = z.object({
-    type: z.literal("tool-result"),
-    toolCallId: z.string().min(1),
-    toolName: z.string().min(1),
-    content: z.array(contextInlineContentSchema),
-    state: z.enum(["output-available", "output-error"]).optional(),
+export const contextActionPartSchema = z.object({
+    type: z.literal("action"),
+    content: z.discriminatedUnion("status", [
+        z.object({
+            status: z.literal("started"),
+            actionName: z.string().min(1),
+            actionCallId: z.string().min(1),
+            input: z.unknown(),
+        }),
+        z.object({
+            status: z.literal("completed"),
+            actionName: z.string().min(1),
+            actionCallId: z.string().min(1),
+            output: z.unknown(),
+        }),
+        z.object({
+            status: z.literal("failed"),
+            actionName: z.string().min(1),
+            actionCallId: z.string().min(1),
+            error: contextActionErrorSchema,
+        }),
+    ]),
+    reactorMetadata: reactorMetadataSchema.optional(),
 });
-export const contextPartSchema = z.discriminatedUnion("type", [
-    contextContentPartSchema,
+export const contextEnginePartSchema = z.discriminatedUnion("type", [
+    contextMessagePartSchema,
     contextReasoningPartSchema,
     contextSourcePartSchema,
-    contextToolCallPartSchema,
-    contextToolResultPartSchema,
 ]);
-export const contextPartEnvelopeSchema = z.discriminatedUnion("type", [
-    contextContentPartSchema.extend({
-        metadata: metadataSchema,
-    }),
-    contextReasoningPartSchema.extend({
-        metadata: metadataSchema,
-    }),
-    contextSourcePartSchema.extend({
-        metadata: metadataSchema,
-    }),
-    contextToolCallPartSchema.extend({
-        metadata: metadataSchema,
-    }),
-    contextToolResultPartSchema.extend({
-        metadata: metadataSchema,
-    }),
+export const contextPartSchema = z.discriminatedUnion("type", [
+    contextMessagePartSchema,
+    contextReasoningPartSchema,
+    contextSourcePartSchema,
+    contextActionPartSchema,
 ]);
+export const contextPartEnvelopeSchema = contextPartSchema;
 function asRecord(value) {
     if (!value || typeof value !== "object")
         return null;
@@ -110,10 +142,54 @@ function asRecord(value) {
 function cleanRecord(value) {
     return Object.fromEntries(Object.entries(value).filter(([, item]) => item !== undefined));
 }
-function normalizeMetadata(value) {
-    if (!value || typeof value !== "object")
-        return undefined;
-    return value;
+function createContextActionPartSchemas(actions) {
+    const schemas = [];
+    for (const [actionName, action] of Object.entries(actions)) {
+        schemas.push(z.object({
+            type: z.literal("action"),
+            content: z.object({
+                status: z.literal("started"),
+                actionName: z.literal(actionName),
+                actionCallId: z.string().min(1),
+                input: action.input,
+            }),
+            reactorMetadata: reactorMetadataSchema.optional(),
+        }), z.object({
+            type: z.literal("action"),
+            content: z.object({
+                status: z.literal("completed"),
+                actionName: z.literal(actionName),
+                actionCallId: z.string().min(1),
+                output: action.output,
+            }),
+            reactorMetadata: reactorMetadataSchema.optional(),
+        }), z.object({
+            type: z.literal("action"),
+            content: z.object({
+                status: z.literal("failed"),
+                actionName: z.literal(actionName),
+                actionCallId: z.string().min(1),
+                error: contextActionErrorSchema,
+            }),
+            reactorMetadata: reactorMetadataSchema.optional(),
+        }));
+    }
+    return schemas;
+}
+export function createContextPartSchema(actions) {
+    const actionSchemas = actions ? createContextActionPartSchemas(actions) : [];
+    if (actionSchemas.length === 0) {
+        return contextEnginePartSchema;
+    }
+    return z.union([
+        contextMessagePartSchema,
+        contextReasoningPartSchema,
+        contextSourcePartSchema,
+        ...actionSchemas,
+    ]);
+}
+export function parseContextPart(actions, value) {
+    return createContextPartSchema(actions).parse(value);
 }
 export function isContextPartEnvelope(value) {
     return contextPartEnvelopeSchema.safeParse(value).success;
@@ -122,17 +198,13 @@ export function parseContextPartEnvelope(value) {
     return contextPartEnvelopeSchema.parse(value);
 }
 export function splitContextPartEnvelope(value) {
-    const { metadata, ...part } = value;
     return {
-        part,
-        metadata,
+        part: parseContextPartEnvelope(value),
+        metadata: undefined,
     };
 }
 export function mergeContextPartEnvelope(params) {
-    return parseContextPartEnvelope({
-        ...(asRecord(params.part) ?? {}),
-        metadata: normalizeMetadata(params.metadata),
-    });
+    return parseContextPartEnvelope(params.part);
 }
 function normalizeFileContentBlock(value) {
     return contextInlineContentSchema.parse(cleanRecord({
@@ -144,217 +216,156 @@ function normalizeFileContentBlock(value) {
         fileId: typeof value.fileId === "string" ? value.fileId : undefined,
     }));
 }
-export function normalizeToolResultContentToBlocks(value) {
-    if (value === undefined || value === null) {
-        return [];
-    }
-    if (typeof value === "string") {
-        return [{ type: "text", text: value }];
-    }
-    const record = asRecord(value);
-    if (!record) {
-        return [{ type: "json", value }];
-    }
-    if (record.type === "json") {
-        return [{ type: "json", value: record.value }];
-    }
-    if (record.type === "content" && Array.isArray(record.value)) {
-        const blocks = [];
-        for (const entry of record.value) {
-            const contentRecord = asRecord(entry);
-            if (!contentRecord || typeof contentRecord.type !== "string") {
-                blocks.push({ type: "json", value: entry });
-                continue;
-            }
-            if (contentRecord.type === "text" && typeof contentRecord.text === "string") {
-                blocks.push({ type: "text", text: contentRecord.text });
-                continue;
-            }
-            if (contentRecord.type === "image-data") {
-                blocks.push(cleanRecord({
-                    type: "file",
-                    mediaType: typeof contentRecord.mediaType === "string"
-                        ? contentRecord.mediaType
-                        : "application/octet-stream",
-                    filename: typeof contentRecord.filename === "string"
-                        ? contentRecord.filename
-                        : undefined,
-                    data: typeof contentRecord.data === "string" ? contentRecord.data : undefined,
-                }));
-                continue;
-            }
-            if (contentRecord.type === "file") {
-                blocks.push(normalizeFileContentBlock(contentRecord));
-                continue;
-            }
-            blocks.push({ type: "json", value: entry });
-        }
-        return blocks;
-    }
-    if (record.type === "file") {
-        return [normalizeFileContentBlock(record)];
-    }
-    return [{ type: "json", value }];
+function readReactorMetadata(record) {
+    const parsed = reactorMetadataSchema.safeParse(record.reactorMetadata);
+    return parsed.success ? parsed.data : undefined;
 }
-function metadataFromUiPart(part) {
-    const metadata = cleanRecord({
-        provider: normalizeMetadata(part.providerMetadata),
-        providerCall: normalizeMetadata(part.callProviderMetadata),
-    });
-    return Object.keys(metadata).length > 0 ? metadata : undefined;
+function messageFromBlocks(blocks, reactorMetadata) {
+    if (blocks.length === 0)
+        return [];
+    const text = blocks
+        .filter((block) => block.type === "text")
+        .map((block) => block.text)
+        .join("\n");
+    const hasNonText = blocks.some((block) => block.type !== "text");
+    return [
+        contextMessagePartSchema.parse(cleanRecord({
+            type: "message",
+            content: cleanRecord({
+                text: text || undefined,
+                blocks: hasNonText ? blocks : undefined,
+            }),
+            reactorMetadata,
+        })),
+    ];
 }
 export function normalizeUiPartToContextPartEnvelopes(value) {
     const record = asRecord(value);
     if (!record || typeof record.type !== "string") {
         return [];
     }
-    const metadata = metadataFromUiPart(record);
+    const reactorMetadata = readReactorMetadata(record);
     if (record.type === "text" && typeof record.text === "string") {
-        return [
-            {
-                type: "content",
-                content: [{ type: "text", text: record.text }],
-                state: record.state === "streaming" ? "streaming" : "done",
-                metadata,
-            },
-        ];
+        return messageFromBlocks([{ type: "text", text: record.text }], reactorMetadata);
     }
     if (record.type === "reasoning" && typeof record.text === "string") {
         return [
-            {
+            contextReasoningPartSchema.parse(cleanRecord({
                 type: "reasoning",
-                content: [{ type: "text", text: record.text }],
-                state: record.state === "streaming" ? "streaming" : "done",
-                metadata,
-            },
+                content: cleanRecord({
+                    text: record.text,
+                    state: record.state === "streaming" ? "streaming" : "done",
+                }),
+                reactorMetadata,
+            })),
         ];
     }
     if (record.type === "file") {
-        return [
-            {
-                type: "content",
-                content: [
-                    cleanRecord({
-                        type: "file",
-                        mediaType: typeof record.mediaType === "string"
-                            ? record.mediaType
-                            : "application/octet-stream",
-                        filename: typeof record.filename === "string" ? record.filename : undefined,
-                        url: typeof record.url === "string" ? record.url : undefined,
-                        data: typeof record.data === "string" ? record.data : undefined,
-                        fileId: typeof record.fileId === "string" ? record.fileId : undefined,
-                    }),
-                ],
-                metadata,
-            },
-        ];
+        return messageFromBlocks([normalizeFileContentBlock(record)], reactorMetadata);
     }
     if (record.type === "source-url") {
         return [
-            {
+            contextSourcePartSchema.parse(cleanRecord({
                 type: "source",
-                content: [
-                    {
-                        type: "source-url",
-                        sourceId: typeof record.sourceId === "string" ? record.sourceId : "source-url",
-                        url: typeof record.url === "string" ? record.url : "",
-                        title: typeof record.title === "string" ? record.title : undefined,
-                    },
-                ],
-                metadata,
-            },
+                content: {
+                    sources: [
+                        cleanRecord({
+                            type: "source-url",
+                            sourceId: typeof record.sourceId === "string" ? record.sourceId : "source-url",
+                            url: typeof record.url === "string" ? record.url : "",
+                            title: typeof record.title === "string" ? record.title : undefined,
+                        }),
+                    ],
+                },
+                reactorMetadata,
+            })),
         ];
     }
     if (record.type === "source-document") {
         return [
-            {
+            contextSourcePartSchema.parse(cleanRecord({
                 type: "source",
-                content: [
-                    {
-                        type: "source-document",
-                        sourceId: typeof record.sourceId === "string"
-                            ? record.sourceId
-                            : "source-document",
-                        mediaType: typeof record.mediaType === "string"
-                            ? record.mediaType
-                            : "application/octet-stream",
-                        title: typeof record.title === "string" ? record.title : "Document",
-                        filename: typeof record.filename === "string" ? record.filename : undefined,
-                    },
-                ],
-                metadata,
-            },
+                content: {
+                    sources: [
+                        cleanRecord({
+                            type: "source-document",
+                            sourceId: typeof record.sourceId === "string"
+                                ? record.sourceId
+                                : "source-document",
+                            mediaType: typeof record.mediaType === "string"
+                                ? record.mediaType
+                                : "application/octet-stream",
+                            title: typeof record.title === "string" ? record.title : "Document",
+                            filename: typeof record.filename === "string" ? record.filename : undefined,
+                        }),
+                    ],
+                },
+                reactorMetadata,
+            })),
         ];
     }
     if (record.type.startsWith("data-")) {
-        return [
-            {
-                type: "content",
-                content: [
-                    {
-                        type: "json",
-                        value: record.data,
-                    },
-                ],
-                metadata: cleanRecord({
-                    ...(metadata ?? {}),
-                    app: {
-                        dataPartType: record.type.slice("data-".length),
-                    },
-                }),
-            },
-        ];
+        return messageFromBlocks([{ type: "json", value: record.data }], reactorMetadata);
     }
     if (record.type.startsWith("tool-")) {
-        const toolName = record.type.slice("tool-".length);
-        const toolCallId = typeof record.toolCallId === "string" ? record.toolCallId : "";
-        if (!toolName || !toolCallId) {
+        const actionName = record.type.slice("tool-".length);
+        const actionCallId = typeof record.toolCallId === "string" ? record.toolCallId : "";
+        if (!actionName || !actionCallId) {
             return [];
         }
-        const callPart = {
-            type: "tool-call",
-            toolCallId,
-            toolName,
-            state: record.state === "input-streaming"
-                ? "input-streaming"
-                : "input-available",
-            content: "input" in record && record.input !== undefined
-                ? [{ type: "json", value: record.input }]
-                : [],
-            metadata,
-        };
-        if (record.state === "output-available" || record.state === "output-error") {
+        const startedPart = contextActionPartSchema.parse(cleanRecord({
+            type: "action",
+            content: cleanRecord({
+                status: "started",
+                actionName,
+                actionCallId,
+                input: "input" in record ? record.input : undefined,
+            }),
+            reactorMetadata,
+        }));
+        if (record.state === "output-available") {
             return [
-                callPart,
-                {
-                    type: "tool-result",
-                    toolCallId,
-                    toolName,
-                    state: record.state,
-                    content: record.state === "output-error"
-                        ? [
-                            {
-                                type: "text",
-                                text: typeof record.errorText === "string" && record.errorText.length > 0
-                                    ? record.errorText
-                                    : "Tool execution failed.",
-                            },
-                        ]
-                        : normalizeToolResultContentToBlocks(record.output),
-                    metadata,
-                },
+                startedPart,
+                contextActionPartSchema.parse(cleanRecord({
+                    type: "action",
+                    content: {
+                        status: "completed",
+                        actionName,
+                        actionCallId,
+                        output: record.output,
+                    },
+                    reactorMetadata,
+                })),
+            ];
+        }
+        if (record.state === "output-error") {
+            return [
+                startedPart,
+                contextActionPartSchema.parse(cleanRecord({
+                    type: "action",
+                    content: {
+                        status: "failed",
+                        actionName,
+                        actionCallId,
+                        error: {
+                            message: typeof record.errorText === "string" && record.errorText.length > 0
+                                ? record.errorText
+                                : "Action execution failed.",
+                        },
+                    },
+                    reactorMetadata,
+                })),
             ];
         }
-        return [callPart];
+        return [startedPart];
     }
     return [];
 }
 export function normalizePartsForPersistence(parts) {
-    const normalized = parts.flatMap((part) => {
+    return parts.flatMap((part) => {
         if (isContextPartEnvelope(part)) {
             return [parseContextPartEnvelope(part)];
         }
         return normalizeUiPartToContextPartEnvelopes(part);
     });
-    return normalized;
 }

package/dist/context.registry.d.ts

@@ -1,7 +1,7 @@
 import type { ContextEnvironment } from "./context.config.js";
 import type { ContextInstance } from "./context.builder.js";
 export type ContextKey = string;
-type AnyContext = ContextInstance<any, any>;
+type AnyContext = ContextInstance<any, any, any>;
 export type ContextFactory = () => AnyContext;
 export declare function registerContext(key: ContextKey, factory: ContextFactory): void;
 export declare function hasContext(key: ContextKey): boolean;

package/dist/context.runtime.d.ts

@@ -1,11 +1,17 @@
-import type { ConcreteDomain } from "@ekairos/domain";
-import type { ExplicitRuntimeLike } from "@ekairos/domain/runtime";
+import type { ActiveDomain, ConcreteDomain, DomainSchemaResult } from "@ekairos/domain";
+import type { EkairosRuntime, RuntimeForDomain, RuntimeResolveOptions } from "@ekairos/domain/runtime";
 import type { ContextEnvironment } from "./context.config.js";
 import type { ContextStore } from "./context.store.js";
-export type ContextRuntime<Env extends ContextEnvironment = ContextEnvironment> = ExplicitRuntimeLike<Env, any, any>;
+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 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">>;
+};
+export type ContextRuntimeForDomain<Runtime extends ContextRuntime<any>, RequiredDomain extends DomainSchemaResult = typeof eventsDomain> = RuntimeForDomain<Runtime, typeof eventsDomain> & RuntimeForDomain<Runtime, RequiredDomain>;
 export type ContextRuntimeServices = {
     db: any;
     store: ContextStore;
     domain?: ConcreteDomain<any, any>;
 };
-export declare function getContextRuntimeServices(runtime: ContextRuntime<any>): Promise<ContextRuntimeServices>;
+export declare function getContextRuntimeServices(runtime: ContextRuntimeServiceHandle): Promise<ContextRuntimeServices>;

package/dist/context.runtime.js

@@ -1,4 +1,7 @@
 const storeByDb = new WeakMap();
+function asRecord(value) {
+    return value && typeof value === "object" ? value : {};
+}
 export async function getContextRuntimeServices(runtime) {
     const db = await runtime.db();
     if (!db) {
@@ -13,9 +16,12 @@ export async function getContextRuntimeServices(runtime) {
         }
     }
     const resolved = await runtime.resolve();
+    const resolvedMeta = asRecord(resolved).meta;
+    const meta = typeof resolvedMeta === "function" ? resolvedMeta() : undefined;
+    const domain = asRecord(meta).domain;
     return {
         db,
         store,
-        domain: typeof resolved === "object" && resolved !== null ? resolved.meta?.()?.domain : undefined,
+        domain: domain,
     };
 }

package/dist/context.step-stream.d.ts

@@ -5,22 +5,36 @@ export type ContextStepStreamChunk = {
     at: string;
     sequence: number;
     chunkType: ContextStreamChunkType;
+    partId?: string;
+    providerPartId?: string;
+    partType?: string;
+    partSlot?: string;
     provider?: string;
     providerChunkType?: string;
     actionRef?: string;
     data?: unknown;
     raw?: unknown;
 };
+export type ContextStepStreamChunkValidationOptions = {
+    stepId?: string;
+    label?: string;
+};
 export declare function createContextStepStreamChunk(params: {
     at?: string;
     sequence: number;
     chunkType: ContextStreamChunkType;
+    stepId?: string;
+    partId?: string;
+    providerPartId?: string;
+    partType?: string;
+    partSlot?: string;
     provider?: string;
     providerChunkType?: string;
     actionRef?: string;
     data?: unknown;
     raw?: unknown;
 }): ContextStepStreamChunk;
-export declare function parseContextStepStreamChunk(value: string | unknown): ContextStepStreamChunk;
-export declare function encodeContextStepStreamChunk(chunk: ContextStepStreamChunk): string;
+export declare function validateContextStepStreamChunk(value: unknown, options?: ContextStepStreamChunkValidationOptions): asserts value is ContextStepStreamChunk;
+export declare function parseContextStepStreamChunk(value: string | unknown, options?: ContextStepStreamChunkValidationOptions): ContextStepStreamChunk;
+export declare function encodeContextStepStreamChunk(chunk: ContextStepStreamChunk, options?: ContextStepStreamChunkValidationOptions): string;
 export declare function contextStreamByteLength(value: string): number;