@ekairos/events 1.22.4-beta.development.0

package/dist/context.parts.d.ts

@@ -0,0 +1,241 @@
+import { z } from "zod";
+export declare const contextPartContentSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"text">;
+    text: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"file">;
+    mediaType: z.ZodString;
+    filename: z.ZodOptional<z.ZodString>;
+    data: z.ZodOptional<z.ZodString>;
+    url: z.ZodOptional<z.ZodString>;
+    fileId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"json">;
+    value: z.ZodUnknown;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"source-url">;
+    sourceId: z.ZodString;
+    url: z.ZodString;
+    title: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"source-document">;
+    sourceId: z.ZodString;
+    mediaType: z.ZodString;
+    title: z.ZodString;
+    filename: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>], "type">;
+declare const contextInlineContentSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"text">;
+    text: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"file">;
+    mediaType: z.ZodString;
+    filename: z.ZodOptional<z.ZodString>;
+    data: z.ZodOptional<z.ZodString>;
+    url: z.ZodOptional<z.ZodString>;
+    fileId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"json">;
+    value: z.ZodUnknown;
+}, z.core.$strip>], "type">;
+export declare const contextPartSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"content">;
+    content: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"text">;
+        text: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"file">;
+        mediaType: z.ZodString;
+        filename: z.ZodOptional<z.ZodString>;
+        data: z.ZodOptional<z.ZodString>;
+        url: z.ZodOptional<z.ZodString>;
+        fileId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"json">;
+        value: z.ZodUnknown;
+    }, z.core.$strip>], "type">>;
+    state: z.ZodOptional<z.ZodEnum<{
+        streaming: "streaming";
+        done: "done";
+    }>>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"reasoning">;
+    content: z.ZodArray<z.ZodObject<{
+        type: z.ZodLiteral<"text">;
+        text: z.ZodString;
+    }, z.core.$strip>>;
+    state: z.ZodOptional<z.ZodEnum<{
+        streaming: "streaming";
+        done: "done";
+    }>>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"source">;
+    content: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"source-url">;
+        sourceId: z.ZodString;
+        url: z.ZodString;
+        title: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"source-document">;
+        sourceId: z.ZodString;
+        mediaType: z.ZodString;
+        title: z.ZodString;
+        filename: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>], "type">>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"tool-call">;
+    toolCallId: z.ZodString;
+    toolName: z.ZodString;
+    content: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"text">;
+        text: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"file">;
+        mediaType: z.ZodString;
+        filename: z.ZodOptional<z.ZodString>;
+        data: z.ZodOptional<z.ZodString>;
+        url: z.ZodOptional<z.ZodString>;
+        fileId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"json">;
+        value: z.ZodUnknown;
+    }, z.core.$strip>], "type">>;
+    state: z.ZodOptional<z.ZodEnum<{
+        "input-streaming": "input-streaming";
+        "input-available": "input-available";
+    }>>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"tool-result">;
+    toolCallId: z.ZodString;
+    toolName: z.ZodString;
+    content: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"text">;
+        text: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"file">;
+        mediaType: z.ZodString;
+        filename: z.ZodOptional<z.ZodString>;
+        data: z.ZodOptional<z.ZodString>;
+        url: z.ZodOptional<z.ZodString>;
+        fileId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"json">;
+        value: z.ZodUnknown;
+    }, z.core.$strip>], "type">>;
+    state: z.ZodOptional<z.ZodEnum<{
+        "output-available": "output-available";
+        "output-error": "output-error";
+    }>>;
+}, z.core.$strip>], "type">;
+export declare const contextPartEnvelopeSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"content">;
+    content: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"text">;
+        text: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"file">;
+        mediaType: z.ZodString;
+        filename: z.ZodOptional<z.ZodString>;
+        data: z.ZodOptional<z.ZodString>;
+        url: z.ZodOptional<z.ZodString>;
+        fileId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"json">;
+        value: z.ZodUnknown;
+    }, z.core.$strip>], "type">>;
+    state: z.ZodOptional<z.ZodEnum<{
+        streaming: "streaming";
+        done: "done";
+    }>>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"reasoning">;
+    content: z.ZodArray<z.ZodObject<{
+        type: z.ZodLiteral<"text">;
+        text: z.ZodString;
+    }, z.core.$strip>>;
+    state: z.ZodOptional<z.ZodEnum<{
+        streaming: "streaming";
+        done: "done";
+    }>>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"source">;
+    content: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"source-url">;
+        sourceId: z.ZodString;
+        url: z.ZodString;
+        title: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"source-document">;
+        sourceId: z.ZodString;
+        mediaType: z.ZodString;
+        title: z.ZodString;
+        filename: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>], "type">>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"tool-call">;
+    toolCallId: z.ZodString;
+    toolName: z.ZodString;
+    content: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"text">;
+        text: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"file">;
+        mediaType: z.ZodString;
+        filename: z.ZodOptional<z.ZodString>;
+        data: z.ZodOptional<z.ZodString>;
+        url: z.ZodOptional<z.ZodString>;
+        fileId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"json">;
+        value: z.ZodUnknown;
+    }, z.core.$strip>], "type">>;
+    state: z.ZodOptional<z.ZodEnum<{
+        "input-streaming": "input-streaming";
+        "input-available": "input-available";
+    }>>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"tool-result">;
+    toolCallId: z.ZodString;
+    toolName: z.ZodString;
+    content: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"text">;
+        text: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"file">;
+        mediaType: z.ZodString;
+        filename: z.ZodOptional<z.ZodString>;
+        data: z.ZodOptional<z.ZodString>;
+        url: z.ZodOptional<z.ZodString>;
+        fileId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"json">;
+        value: z.ZodUnknown;
+    }, z.core.$strip>], "type">>;
+    state: z.ZodOptional<z.ZodEnum<{
+        "output-available": "output-available";
+        "output-error": "output-error";
+    }>>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>], "type">;
+export type ContextPartContent = z.infer<typeof contextPartContentSchema>;
+export type ContextInlineContent = z.infer<typeof contextInlineContentSchema>;
+export type ContextPart = z.infer<typeof contextPartSchema>;
+export type ContextPartEnvelope = z.infer<typeof contextPartEnvelopeSchema>;
+export declare function isContextPartEnvelope(value: unknown): value is ContextPartEnvelope;
+export declare function parseContextPartEnvelope(value: unknown): ContextPartEnvelope;
+export declare function splitContextPartEnvelope(value: ContextPartEnvelope): {
+    part: ContextPart;
+    metadata?: Record<string, unknown>;
+};
+export declare function mergeContextPartEnvelope(params: {
+    part: unknown;
+    metadata?: unknown;
+}): ContextPartEnvelope;
+export declare function normalizeToolResultContentToBlocks(value: unknown): ContextInlineContent[];
+export declare function normalizeUiPartToContextPartEnvelopes(value: unknown): ContextPartEnvelope[];
+export declare function normalizePartsForPersistence(parts: unknown[]): ContextPartEnvelope[];
+export {};

package/dist/context.parts.js

@@ -0,0 +1,360 @@
+import { z } from "zod";
+const metadataSchema = z.record(z.string(), z.unknown()).optional();
+const textContentSchema = z.object({
+    type: z.literal("text"),
+    text: z.string(),
+});
+const fileContentSchema = z
+    .object({
+    type: z.literal("file"),
+    mediaType: z.string().min(1),
+    filename: z.string().optional(),
+    data: z.string().optional(),
+    url: z.string().optional(),
+    fileId: z.string().optional(),
+})
+    .superRefine((value, ctx) => {
+    if (!value.data && !value.url && !value.fileId) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "file content requires one of data, url, or fileId",
+        });
+    }
+});
+const jsonContentSchema = z.object({
+    type: z.literal("json"),
+    value: z.unknown(),
+});
+const sourceUrlContentSchema = z.object({
+    type: z.literal("source-url"),
+    sourceId: z.string(),
+    url: z.string().min(1),
+    title: z.string().optional(),
+});
+const sourceDocumentContentSchema = z.object({
+    type: z.literal("source-document"),
+    sourceId: z.string(),
+    mediaType: z.string().min(1),
+    title: z.string().min(1),
+    filename: z.string().optional(),
+});
+export const contextPartContentSchema = z.discriminatedUnion("type", [
+    textContentSchema,
+    fileContentSchema,
+    jsonContentSchema,
+    sourceUrlContentSchema,
+    sourceDocumentContentSchema,
+]);
+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 contextReasoningPartSchema = z.object({
+    type: z.literal("reasoning"),
+    content: z.array(textContentSchema),
+    state: z.enum(["streaming", "done"]).optional(),
+});
+const contextSourcePartSchema = z.object({
+    type: z.literal("source"),
+    content: z.array(z.discriminatedUnion("type", [sourceUrlContentSchema, sourceDocumentContentSchema])),
+});
+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 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 contextPartSchema = z.discriminatedUnion("type", [
+    contextContentPartSchema,
+    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,
+    }),
+]);
+function asRecord(value) {
+    if (!value || typeof value !== "object")
+        return null;
+    return 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;
+}
+export function isContextPartEnvelope(value) {
+    return contextPartEnvelopeSchema.safeParse(value).success;
+}
+export function parseContextPartEnvelope(value) {
+    return contextPartEnvelopeSchema.parse(value);
+}
+export function splitContextPartEnvelope(value) {
+    const { metadata, ...part } = value;
+    return {
+        part,
+        metadata,
+    };
+}
+export function mergeContextPartEnvelope(params) {
+    return parseContextPartEnvelope({
+        ...(asRecord(params.part) ?? {}),
+        metadata: normalizeMetadata(params.metadata),
+    });
+}
+function normalizeFileContentBlock(value) {
+    return contextInlineContentSchema.parse(cleanRecord({
+        type: "file",
+        mediaType: typeof value.mediaType === "string" ? value.mediaType : "application/octet-stream",
+        filename: typeof value.filename === "string" ? value.filename : undefined,
+        data: typeof value.data === "string" ? value.data : undefined,
+        url: typeof value.url === "string" ? value.url : undefined,
+        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 metadataFromUiPart(part) {
+    const metadata = cleanRecord({
+        provider: normalizeMetadata(part.providerMetadata),
+        providerCall: normalizeMetadata(part.callProviderMetadata),
+    });
+    return Object.keys(metadata).length > 0 ? metadata : undefined;
+}
+export function normalizeUiPartToContextPartEnvelopes(value) {
+    const record = asRecord(value);
+    if (!record || typeof record.type !== "string") {
+        return [];
+    }
+    const metadata = metadataFromUiPart(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,
+            },
+        ];
+    }
+    if (record.type === "reasoning" && typeof record.text === "string") {
+        return [
+            {
+                type: "reasoning",
+                content: [{ type: "text", text: record.text }],
+                state: record.state === "streaming" ? "streaming" : "done",
+                metadata,
+            },
+        ];
+    }
+    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,
+            },
+        ];
+    }
+    if (record.type === "source-url") {
+        return [
+            {
+                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,
+            },
+        ];
+    }
+    if (record.type === "source-document") {
+        return [
+            {
+                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,
+            },
+        ];
+    }
+    if (record.type.startsWith("data-")) {
+        return [
+            {
+                type: "content",
+                content: [
+                    {
+                        type: "json",
+                        value: record.data,
+                    },
+                ],
+                metadata: cleanRecord({
+                    ...(metadata ?? {}),
+                    app: {
+                        dataPartType: record.type.slice("data-".length),
+                    },
+                }),
+            },
+        ];
+    }
+    if (record.type.startsWith("tool-")) {
+        const toolName = record.type.slice("tool-".length);
+        const toolCallId = typeof record.toolCallId === "string" ? record.toolCallId : "";
+        if (!toolName || !toolCallId) {
+            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") {
+            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,
+                },
+            ];
+        }
+        return [callPart];
+    }
+    return [];
+}
+export function normalizePartsForPersistence(parts) {
+    const normalized = parts.flatMap((part) => {
+        if (isContextPartEnvelope(part)) {
+            return [parseContextPartEnvelope(part)];
+        }
+        return normalizeUiPartToContextPartEnvelopes(part);
+    });
+    return normalized;
+}

package/dist/context.reactor.d.ts

@@ -0,0 +1,3 @@
+export { createAiSdkReactor, type CreateAiSdkReactorOptions, } from "./reactors/ai-sdk.reactor.js";
+export { createScriptedReactor, type CreateScriptedReactorOptions, type ScriptedReactorStep, } from "./reactors/scripted.reactor.js";
+export type { ContextReactor, ContextReactorParams, ContextReactionResult, ContextActionRequest, ContextReactionLLM, } from "./reactors/types.js";

package/dist/context.reactor.js

@@ -0,0 +1,2 @@
+export { createAiSdkReactor, } from "./reactors/ai-sdk.reactor.js";
+export { createScriptedReactor, } from "./reactors/scripted.reactor.js";

package/dist/context.registry.d.ts

@@ -0,0 +1,13 @@
+import type { ContextEnvironment } from "./context.config.js";
+import type { ContextInstance } from "./context.builder.js";
+export type ContextKey = string;
+type AnyContext = ContextInstance<any, any>;
+export type ContextFactory = () => AnyContext;
+export declare function registerContext(key: ContextKey, factory: ContextFactory): void;
+export declare function hasContext(key: ContextKey): boolean;
+export declare function getContext<Env extends ContextEnvironment = ContextEnvironment>(key: ContextKey): AnyContext & {
+    __config: {};
+};
+export declare function getContextFactory(key: ContextKey): ContextFactory;
+export declare function listContexts(): string[];
+export {};

package/dist/context.registry.js

@@ -0,0 +1,30 @@
+const registry = new Map();
+export function registerContext(key, factory) {
+    if (!key || typeof key !== "string") {
+        throw new Error("registerContext: key must be a non-empty string");
+    }
+    if (typeof factory !== "function") {
+        throw new Error("registerContext: factory must be a function");
+    }
+    registry.set(key, factory);
+}
+export function hasContext(key) {
+    return registry.has(key);
+}
+export function getContext(key) {
+    const factory = registry.get(key);
+    if (!factory) {
+        throw new Error(`Context "${key}" is not registered. Ensure the module that calls createContext("${key}") is imported during boot.`);
+    }
+    return factory();
+}
+export function getContextFactory(key) {
+    const factory = registry.get(key);
+    if (!factory) {
+        throw new Error(`Context "${key}" is not registered. Ensure the module that calls createContext("${key}") is imported during boot.`);
+    }
+    return factory;
+}
+export function listContexts() {
+    return Array.from(registry.keys());
+}

package/dist/context.skill.d.ts

@@ -0,0 +1,9 @@
+export type ContextSkillPackageFile = {
+    path: string;
+    contentBase64: string;
+};
+export type ContextSkillPackage = {
+    name: string;
+    description?: string;
+    files: ContextSkillPackageFile[];
+};

package/dist/context.skill.js

@@ -0,0 +1 @@
+export {};