@ekairos/events 1.22.4-beta.development.0

package/dist/stores/instant.store.js

@@ -0,0 +1,575 @@
+import "../polyfills/dom-events.js";
+import { id, lookup } from "@instantdb/admin";
+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" ||
+        process.env.PLAYWRIGHT_TEST === "1");
+}
+function clipText(value, max = 500) {
+    if (value.length <= max)
+        return value;
+    return `${value.slice(0, max)}...<truncated:${value.length - max}>`;
+}
+function simplifyForLog(value, depth = 0) {
+    if (value === null || value === undefined)
+        return value;
+    if (typeof value === "string")
+        return clipText(value);
+    if (typeof value === "number" || typeof value === "boolean")
+        return value;
+    if (value instanceof Date)
+        return value.toISOString();
+    if (depth >= 2)
+        return "[max-depth]";
+    if (Array.isArray(value)) {
+        const maxItems = 8;
+        const items = value
+            .slice(0, maxItems)
+            .map((item) => simplifyForLog(item, depth + 1));
+        if (value.length > maxItems) {
+            items.push(`...+${value.length - maxItems} more`);
+        }
+        return items;
+    }
+    if (typeof value === "object") {
+        const entries = Object.entries(value);
+        const maxEntries = 16;
+        const out = {};
+        for (const [key, entryValue] of entries.slice(0, maxEntries)) {
+            out[key] = simplifyForLog(entryValue, depth + 1);
+        }
+        if (entries.length > maxEntries) {
+            out.__truncatedKeys = entries.length - maxEntries;
+        }
+        return out;
+    }
+    return String(value);
+}
+function summarizeError(error) {
+    const err = error;
+    return {
+        name: err?.name,
+        message: err?.message,
+        code: err?.code,
+        status: err?.status ?? err?.statusCode,
+        details: simplifyForLog(err?.details ?? err?.body ?? err?.response ?? err?.data),
+        stack: typeof err?.stack === "string"
+            ? clipText(err.stack, 1500)
+            : undefined,
+    };
+}
+function ensureValidEntityId(value, label) {
+    const normalized = typeof value === "string" ? value.trim() : "";
+    if (!normalized) {
+        throw new Error(`InstantStore: ${label} is required`);
+    }
+    return normalized;
+}
+function logInstantTransactFailure(params) {
+    if (!shouldDebugInstantStore())
+        return;
+    const payload = {
+        action: params.action,
+        meta: simplifyForLog(params.meta ?? {}),
+        txs: simplifyForLog(params.txs),
+        error: summarizeError(params.error),
+    };
+    // eslint-disable-next-line no-console
+    console.error("[context][instant.store] transact failed", payload);
+}
+function sortItems(items) {
+    const toEpoch = (value) => {
+        if (value instanceof Date)
+            return value.getTime();
+        if (typeof value === "string" || typeof value === "number") {
+            const ms = new Date(value).getTime();
+            return Number.isFinite(ms) ? ms : 0;
+        }
+        return 0;
+    };
+    return [...items].sort((a, b) => {
+        const ta = toEpoch(a?.createdAt ?? a?.updatedAt);
+        const tb = toEpoch(b?.createdAt ?? b?.updatedAt);
+        if (ta !== tb)
+            return ta - tb;
+        return String(a?.id ?? "").localeCompare(String(b?.id ?? ""));
+    });
+}
+export class InstantStore {
+    constructor(db) {
+        this.db = db;
+    }
+    normalizeContext(row) {
+        return {
+            id: String(row?.id ?? ""),
+            key: typeof row?.key === "string" && row.key.length > 0 ? row.key : null,
+            name: typeof row?.name === "string" ? row.name : null,
+            status: (typeof row?.status === "string" ? row.status : "open_idle"),
+            createdAt: row?.createdAt instanceof Date ? row.createdAt : new Date(row?.createdAt ?? Date.now()),
+            updatedAt: row?.updatedAt instanceof Date
+                ? row.updatedAt
+                : row?.updatedAt
+                    ? new Date(row.updatedAt)
+                    : undefined,
+            content: row?.content ?? null,
+        };
+    }
+    async ensureContextKey(context, expectedKey) {
+        if (!expectedKey)
+            return context;
+        if (context.key === expectedKey)
+            return context;
+        await this.db.transact([
+            this.db.tx.event_contexts[context.id].update({
+                key: expectedKey,
+                updatedAt: new Date(),
+            }),
+        ]);
+        const refreshed = await this.getContext({ id: context.id });
+        return refreshed ?? { ...context, key: expectedKey };
+    }
+    async createContextRecord(contextIdentifier) {
+        const contextId = contextIdentifier && "id" in contextIdentifier ? String(contextIdentifier.id) : id();
+        const key = contextIdentifier && "key" in contextIdentifier ? contextIdentifier.key : undefined;
+        await this.db.transact([
+            this.db.tx.event_contexts[contextId].create({
+                createdAt: new Date(),
+                updatedAt: new Date(),
+                key,
+                status: "open_idle",
+                content: {},
+            }),
+        ]);
+        const context = await this.getContext({ id: contextId });
+        if (!context) {
+            throw new Error("InstantStore: failed to create context");
+        }
+        return context;
+    }
+    async getOrCreateContext(contextIdentifier) {
+        if (!contextIdentifier) {
+            return await this.createContextRecord(null);
+        }
+        const existing = await this.getContext(contextIdentifier);
+        if (existing) {
+            if ("key" in contextIdentifier) {
+                return await this.ensureContextKey(existing, contextIdentifier.key);
+            }
+            return existing;
+        }
+        return await this.createContextRecord(contextIdentifier);
+    }
+    async getContext(contextIdentifier) {
+        try {
+            if ("id" in contextIdentifier) {
+                const res = await this.db.query({
+                    event_contexts: {
+                        $: { where: { id: contextIdentifier.id }, limit: 1 },
+                    },
+                });
+                const row = res?.event_contexts?.[0];
+                return row ? this.normalizeContext(row) : null;
+            }
+            const res = await this.db.query({
+                event_contexts: {
+                    $: { where: { key: contextIdentifier.key }, limit: 1 },
+                },
+            });
+            const row = res?.event_contexts?.[0];
+            return row ? this.normalizeContext(row) : null;
+        }
+        catch (error) {
+            throw new Error("InstantStore: Error getting context: " + error.message);
+        }
+    }
+    async updateContextContent(contextIdentifier, content) {
+        const context = await this.getContext(contextIdentifier);
+        if (!context?.id)
+            throw new Error("InstantStore: context not found");
+        await this.db.transact([
+            this.db.tx.event_contexts[context.id].update({
+                content: content,
+                updatedAt: new Date(),
+            }),
+        ]);
+        const updated = await this.getContext({ id: context.id });
+        if (!updated)
+            throw new Error("InstantStore: context not found after update");
+        return updated;
+    }
+    async updateContextStatus(contextIdentifier, status) {
+        const context = await this.getContext(contextIdentifier);
+        if (!context?.id)
+            throw new Error("InstantStore: context not found");
+        if (context.status !== status) {
+            assertContextTransition(context.status, status);
+        }
+        await this.db.transact([
+            this.db.tx.event_contexts[context.id].update({
+                status,
+                updatedAt: new Date(),
+            }),
+        ]);
+    }
+    async resolveContext(contextIdentifier) {
+        const context = await this.getContext(contextIdentifier);
+        if (!context?.id)
+            throw new Error("InstantStore: context not found");
+        return context;
+    }
+    async saveItem(contextIdentifier, event) {
+        const eventId = ensureValidEntityId(event?.id, "event.id");
+        const context = await this.resolveContext(contextIdentifier);
+        const existing = await this.getItem(eventId);
+        if (existing?.status && existing.status !== "stored") {
+            assertItemTransition(existing.status, "stored");
+        }
+        const txs = [
+            this.db.tx.event_items[eventId].update({
+                ...event,
+                id: eventId,
+                status: "stored",
+            }),
+            this.db.tx.event_items[eventId].link({ context: context.id }),
+        ];
+        try {
+            await this.db.transact(txs);
+        }
+        catch (error) {
+            logInstantTransactFailure({
+                action: "saveItem",
+                meta: {
+                    contextIdentifier: simplifyForLog(contextIdentifier),
+                    contextId: context.id,
+                    eventId,
+                    eventType: event?.type,
+                    eventChannel: event?.channel,
+                    eventCreatedAt: event?.createdAt,
+                },
+                txs,
+                error,
+            });
+            throw error;
+        }
+        return {
+            ...event,
+            id: eventId,
+            status: "stored",
+        };
+    }
+    async updateItem(eventId, event) {
+        const current = await this.getItem(eventId);
+        if (current?.status && event.status && current.status !== event.status) {
+            assertItemTransition(current.status, event.status);
+        }
+        await this.db.transact([this.db.tx.event_items[eventId].update(event)]);
+        return {
+            ...current,
+            ...event,
+            id: eventId,
+        };
+    }
+    async getItem(eventId) {
+        const res = await this.db.query({
+            event_items: {
+                $: { where: { id: eventId } },
+            },
+        });
+        return res.event_items?.[0] ?? null;
+    }
+    async getItems(contextIdentifier) {
+        const context = await this.resolveContext(contextIdentifier);
+        let res;
+        try {
+            res = await this.db.query({
+                event_items: {
+                    $: {
+                        where: { context: context.id },
+                        limit: 1000,
+                    },
+                },
+            });
+        }
+        catch {
+            res = await this.db.query({
+                event_items: {
+                    $: {
+                        where: { "context.id": context.id },
+                        limit: 1000,
+                    },
+                },
+            });
+        }
+        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");
+        const context = await this.resolveContext(contextIdentifier);
+        const executionId = id();
+        const currentStatus = context.status;
+        if (currentStatus === "closed") {
+            throw new Error("InstantStore: context must be reopened before creating an execution");
+        }
+        if (currentStatus !== "open_streaming") {
+            assertContextTransition(currentStatus, "open_streaming");
+        }
+        const txs = [
+            this.db.tx.event_executions[executionId].create({
+                createdAt: new Date(),
+                status: "executing",
+            }),
+            this.db.tx.event_contexts[context.id].update({
+                status: "open_streaming",
+                updatedAt: new Date(),
+            }),
+            this.db.tx.event_executions[executionId].link({ context: context.id }),
+            this.db.tx.event_contexts[context.id].link({ currentExecution: executionId }),
+            this.db.tx.event_executions[executionId].link({ trigger: normalizedTriggerEventId }),
+            this.db.tx.event_executions[executionId].link({ reaction: normalizedReactionEventId }),
+        ];
+        try {
+            await this.db.transact(txs);
+        }
+        catch (error) {
+            logInstantTransactFailure({
+                action: "createExecution",
+                meta: {
+                    contextIdentifier: simplifyForLog(contextIdentifier),
+                    contextId: context.id,
+                    executionId,
+                    triggerEventId: normalizedTriggerEventId,
+                    reactionEventId: normalizedReactionEventId,
+                },
+                txs,
+                error,
+            });
+            throw error;
+        }
+        return { id: executionId };
+    }
+    async completeExecution(contextIdentifier, executionId, status) {
+        const context = await this.resolveContext(contextIdentifier);
+        const executionResult = await this.db.query({
+            event_executions: {
+                $: { where: { id: executionId }, limit: 1 },
+            },
+        });
+        const executionRow = executionResult?.event_executions?.[0];
+        if (!executionRow)
+            throw new Error("InstantStore: execution not found");
+        const currentExecutionStatus = String(executionRow.status ?? "executing");
+        if (currentExecutionStatus !== status) {
+            assertExecutionTransition(currentExecutionStatus, status);
+        }
+        if (context.status !== "closed") {
+            assertContextTransition(context.status, "closed");
+        }
+        await this.db.transact([
+            this.db.tx.event_executions[executionId].update({ status, updatedAt: new Date() }),
+            this.db.tx.event_contexts[context.id].update({
+                status: "closed",
+                updatedAt: new Date(),
+            }),
+        ]);
+    }
+    async createStep(params) {
+        const stepId = id();
+        const txs = [
+            this.db.tx.event_steps[stepId].create({
+                createdAt: new Date(),
+                status: "running",
+                iteration: params.iteration,
+            }),
+            this.db.tx.event_steps[stepId].link({ execution: params.executionId }),
+        ];
+        try {
+            await this.db.transact(txs);
+        }
+        catch (error) {
+            logInstantTransactFailure({
+                action: "createStep",
+                meta: {
+                    executionId: params.executionId,
+                    iteration: params.iteration,
+                    stepId,
+                },
+                txs,
+                error,
+            });
+            throw error;
+        }
+        return { id: stepId };
+    }
+    async updateStep(stepId, patch) {
+        if (patch.status) {
+            const stepResult = await this.db.query({
+                event_steps: {
+                    $: { where: { id: stepId }, limit: 1 },
+                },
+            });
+            const stepRow = stepResult?.event_steps?.[0];
+            if (!stepRow)
+                throw new Error("InstantStore: step not found");
+            const currentStepStatus = String(stepRow.status ?? "running");
+            if (currentStepStatus !== patch.status) {
+                assertStepTransition(currentStepStatus, patch.status);
+            }
+        }
+        const update = {
+            ...patch,
+            updatedAt: patch.updatedAt ?? new Date(),
+        };
+        await this.db.transact([this.db.tx.event_steps[stepId].update(update)]);
+    }
+    async linkItemToExecution(params) {
+        await this.db.transact([
+            this.db.tx.event_items[params.itemId].link({ execution: params.executionId }),
+        ]);
+    }
+    async saveStepParts(params) {
+        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 split.part?.type === "string" ? String(split.part.type) : undefined,
+                part: split.part,
+                metadata: split.metadata,
+                updatedAt: new Date(),
+            })
+                .link({ step: params.stepId });
+        });
+        await this.db.transact(txs);
+    }
+    async itemsToModelMessages(events) {
+        const expanded = await expandEventsWithInstantDocuments({
+            db: this.db,
+            events,
+            derivedEventType: "output",
+        });
+        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) {
+    const storesByOrg = new Map();
+    return async (env) => {
+        const orgId = params.getOrgId?.(env) ??
+            (typeof env?.orgId === "string" ? String(env.orgId) : "");
+        if (!orgId) {
+            throw new Error("[instant] Missing orgId in env. Provide env.orgId (or customize getOrgId).");
+        }
+        const cached = storesByOrg.get(orgId);
+        if (cached)
+            return cached;
+        const db = await params.getDb(orgId);
+        const store = new InstantStore(db);
+        const concreteDomain = params.domain?.fromDB ? params.domain.fromDB(db) : undefined;
+        const runtime = { store, db, domain: concreteDomain };
+        storesByOrg.set(orgId, runtime);
+        return runtime;
+    };
+}

package/dist/tools-to-model-tools.d.ts

@@ -0,0 +1,19 @@
+import { type Tool } from "ai";
+/**
+ * Serializable "tool" shape to pass across the Workflow step boundary.
+ *
+ * Mirrors Workflow DevKit's DurableAgent strategy:
+ * - Keep Zod/function values out of step arguments
+ * - Convert tool input schemas to plain JSON Schema in workflow context
+ */
+export type SerializableToolForModel = {
+    description?: string;
+    inputSchema: unknown;
+};
+/**
+ * Convert AI SDK tools to a serializable representation that can be passed to `"use-step"` functions.
+ *
+ * This matches DurableAgent's internal `toolsToModelTools` behavior:
+ * `inputSchema: asSchema(tool.inputSchema).jsonSchema`
+ */
+export declare function toolsToModelTools(tools: Record<string, Tool>): Record<string, SerializableToolForModel>;

package/dist/tools-to-model-tools.js

@@ -0,0 +1,21 @@
+import { asSchema } from "ai";
+/**
+ * Convert AI SDK tools to a serializable representation that can be passed to `"use-step"` functions.
+ *
+ * This matches DurableAgent's internal `toolsToModelTools` behavior:
+ * `inputSchema: asSchema(tool.inputSchema).jsonSchema`
+ */
+export function toolsToModelTools(tools) {
+    const out = {};
+    for (const [name, tool] of Object.entries(tools)) {
+        const inputSchema = tool?.inputSchema;
+        if (!inputSchema) {
+            throw new Error(`Context: tool "${name}" is missing inputSchema (required for model tool calls)`);
+        }
+        out[name] = {
+            description: tool?.description,
+            inputSchema: asSchema(inputSchema).jsonSchema,
+        };
+    }
+    return out;
+}