@ekairos/events 1.22.4-beta.development.0

package/dist/schema.js

@@ -0,0 +1,191 @@
+import { i } from "@instantdb/core";
+import { domain } from "@ekairos/domain";
+export const eventsDomain = domain("events")
+    .schema({
+    entities: {
+        event_contexts: i.entity({
+            createdAt: i.date(),
+            updatedAt: i.date().optional(),
+            key: i.string().optional().indexed().unique(),
+            name: i.string().optional(),
+            status: i.string().optional().indexed(), // open_idle | open_streaming | closed
+            content: i.any().optional(),
+        }),
+        event_items: i.entity({
+            channel: i.string().indexed(),
+            createdAt: i.date().indexed(),
+            type: i.string().optional().indexed(),
+            content: i.any().optional(),
+            status: i.string().optional().indexed(),
+        }),
+        event_executions: i.entity({
+            createdAt: i.date(),
+            updatedAt: i.date().optional(),
+            status: i.string().optional().indexed(), // executing | completed | failed
+            workflowRunId: i.string().optional().indexed(),
+            activeStreamId: i.string().optional().indexed(),
+            activeStreamClientId: i.string().optional().indexed(),
+            lastStreamId: i.string().optional().indexed(),
+            lastStreamClientId: i.string().optional().indexed(),
+        }),
+        event_steps: i.entity({
+            createdAt: i.date().indexed(),
+            updatedAt: i.date().optional(),
+            status: i.string().optional().indexed(), // running | completed | failed
+            iteration: i.number().indexed(),
+            kind: i.string().optional().indexed(), // message | action_execute | action_result
+            actionName: i.string().optional().indexed(),
+            actionInput: i.any().optional(),
+            actionOutput: i.any().optional(),
+            actionError: i.string().optional(),
+            actionRequests: i.any().optional(),
+            actionResults: i.any().optional(),
+            continueLoop: i.boolean().optional(),
+            errorText: i.string().optional(),
+            streamId: i.string().optional().indexed(),
+            streamClientId: i.string().optional().indexed(),
+            streamStartedAt: i.date().optional().indexed(),
+            streamFinishedAt: i.date().optional().indexed(),
+            streamAbortReason: i.string().optional(),
+        }),
+        event_parts: i.entity({
+            key: i.string().unique().indexed(), // `${stepId}:${idx}`
+            stepId: i.string().indexed(),
+            idx: i.number().indexed(),
+            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({
+            key: i.string().unique().indexed(), // `${workflowRunId}:${eventId}`
+            workflowRunId: i.string().indexed(),
+            seq: i.number().indexed(),
+            eventId: i.string().indexed(),
+            eventKind: i.string().indexed(),
+            eventAt: i.date().optional(),
+            ingestedAt: i.date().optional(),
+            orgId: i.string().optional().indexed(),
+            projectId: i.string().optional().indexed(),
+            contextKey: i.string().optional().indexed(),
+            contextId: i.string().optional().indexed(),
+            executionId: i.string().optional().indexed(),
+            stepId: i.string().optional().indexed(),
+            contextEventId: i.string().optional().indexed(),
+            toolCallId: i.string().optional().indexed(),
+            partKey: i.string().optional().indexed(),
+            partIdx: i.number().optional().indexed(),
+            spanId: i.string().optional().indexed(),
+            parentSpanId: i.string().optional().indexed(),
+            isDeleted: i.boolean().optional(),
+            aiProvider: i.string().optional().indexed(),
+            aiModel: i.string().optional().indexed(),
+            promptTokens: i.number().optional(),
+            promptTokensCached: i.number().optional(),
+            promptTokensUncached: i.number().optional(),
+            completionTokens: i.number().optional(),
+            totalTokens: i.number().optional(),
+            latencyMs: i.number().optional(),
+            cacheCostUsd: i.number().optional(),
+            computeCostUsd: i.number().optional(),
+            costUsd: i.number().optional(),
+            payload: i.any().optional(),
+        }),
+        event_trace_runs: i.entity({
+            workflowRunId: i.string().unique().indexed(),
+            orgId: i.string().optional().indexed(),
+            projectId: i.string().optional().indexed(),
+            firstEventAt: i.date().optional().indexed(),
+            lastEventAt: i.date().optional().indexed(),
+            lastIngestedAt: i.date().optional().indexed(),
+            eventsCount: i.number().optional(),
+            status: i.string().optional().indexed(),
+            payload: i.any().optional(),
+        }),
+        event_trace_spans: i.entity({
+            spanId: i.string().unique().indexed(),
+            parentSpanId: i.string().optional().indexed(),
+            workflowRunId: i.string().indexed(),
+            executionId: i.string().optional().indexed(),
+            stepId: i.string().optional().indexed(),
+            kind: i.string().optional().indexed(),
+            name: i.string().optional().indexed(),
+            status: i.string().optional().indexed(),
+            startedAt: i.date().optional().indexed(),
+            endedAt: i.date().optional().indexed(),
+            durationMs: i.number().optional(),
+            payload: i.any().optional(),
+        }),
+        document_documents: i.entity({
+            name: i.string().optional().indexed(),
+            mimeType: i.string().optional(),
+            size: i.number().optional(),
+            ownerId: i.string().optional().indexed(),
+            orgId: i.string().optional().indexed(),
+            createdAt: i.date().optional().indexed(),
+            processedAt: i.date().optional().indexed(),
+            updatedAt: i.date().optional(),
+            lastJobId: i.string().optional(),
+            content: i.json().optional(),
+        }),
+    },
+    links: {
+        contextItemsContext: {
+            forward: { on: "event_items", has: "one", label: "context" },
+            reverse: { on: "event_contexts", has: "many", label: "items" },
+        },
+        contextExecutionsContext: {
+            forward: { on: "event_executions", has: "one", label: "context" },
+            reverse: { on: "event_contexts", has: "many", label: "executions" },
+        },
+        contextCurrentExecution: {
+            forward: { on: "event_contexts", has: "one", label: "currentExecution" },
+            reverse: { on: "event_executions", has: "one", label: "currentOf" },
+        },
+        contextExecutionsTrigger: {
+            forward: { on: "event_executions", has: "one", label: "trigger" },
+            reverse: { on: "event_items", has: "many", label: "executionsAsTrigger" },
+        },
+        contextExecutionsReaction: {
+            forward: { on: "event_executions", has: "one", label: "reaction" },
+            reverse: { on: "event_items", has: "many", label: "executionsAsReaction" },
+        },
+        contextStepsExecution: {
+            forward: { on: "event_steps", has: "one", label: "execution" },
+            reverse: { on: "event_executions", has: "many", label: "steps" },
+        },
+        contextExecutionItems: {
+            forward: { on: "event_items", has: "one", label: "execution" },
+            reverse: { on: "event_executions", has: "many", label: "items" },
+        },
+        contextPartsStep: {
+            forward: { on: "event_parts", has: "one", label: "step" },
+            reverse: { on: "event_steps", has: "many", label: "parts" },
+        },
+        contextStepStream: {
+            forward: { on: "event_steps", has: "one", label: "stream" },
+            reverse: { on: "$streams", has: "many", label: "step" },
+        },
+        contextExecutionActiveStream: {
+            forward: { on: "event_executions", has: "one", label: "activeStream" },
+            reverse: { on: "$streams", has: "many", label: "activeOf" },
+        },
+        contextExecutionLastStream: {
+            forward: { on: "event_executions", has: "one", label: "lastStream" },
+            reverse: { on: "$streams", has: "many", label: "lastOf" },
+        },
+        documentFile: {
+            forward: {
+                on: "document_documents",
+                has: "one",
+                label: "file",
+            },
+            reverse: {
+                on: "$files",
+                has: "one",
+                label: "document",
+            },
+        },
+    },
+    rooms: {},
+});

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

@@ -0,0 +1,34 @@
+import type { ModelMessage } from "ai";
+import type { ContextItem } from "../context.store.js";
+import type { SerializableToolForModel } from "../tools-to-model-tools.js";
+import type { ContextModelInit } from "../context.engine.js";
+/**
+ * Runs a single LLM streaming step as a Workflow step.
+ *
+ * - Performs the provider/network call in a step (Node/runtime allowed).
+ * - Pipes AI SDK UI message chunks into the workflow-owned writable stream.
+ * - Returns the assistant event + extracted action requests for the workflow loop.
+ */
+export declare function doContextStreamStep(params: {
+    model: ContextModelInit;
+    system: string;
+    messages: ModelMessage[];
+    tools: Record<string, SerializableToolForModel>;
+    eventId: string;
+    maxSteps: number;
+    /**
+     * Whether to emit a `start` chunk for this streamed assistant message.
+     *
+     * IMPORTANT:
+     * Our context loop may call the model multiple times within a single "turn" while continuing
+     * to append to the same `eventId`. In that case, `start` must only be sent once.
+     */
+    sendStart?: boolean;
+}): Promise<{
+    assistantEvent: ContextItem;
+    actionRequests: {
+        actionRef: string;
+        actionName: string;
+        input: any;
+    }[];
+}>;

package/dist/steps/do-context-stream-step.js

@@ -0,0 +1,96 @@
+import { OUTPUT_ITEM_TYPE } from "../context.events.js";
+/**
+ * Runs a single LLM streaming step as a Workflow step.
+ *
+ * - Performs the provider/network call in a step (Node/runtime allowed).
+ * - Pipes AI SDK UI message chunks into the workflow-owned writable stream.
+ * - Returns the assistant event + extracted action requests for the workflow loop.
+ */
+export async function doContextStreamStep(params) {
+    "use step";
+    const { getWritable } = await import("workflow");
+    const writable = getWritable();
+    const { jsonSchema, gateway, smoothStream, stepCountIs, streamText } = await import("ai");
+    const { extractToolCallsFromParts } = await import("../context.toolcalls.js");
+    // Match DurableAgent's model init behavior:
+    // - string => AI Gateway model id, resolved via `gateway(...)` in the step runtime
+    // - function => model factory (should be a `"use step"` function for workflow serialization)
+    const resolvedModel = typeof params.model === "string"
+        ? gateway(params.model)
+        : typeof params.model === "function"
+            ? await params.model()
+            : (() => {
+                throw new Error("Invalid model init passed to doContextStreamStep. Expected a model id string or an async model factory.");
+            })();
+    // IMPORTANT:
+    // `streamText` expects tools in the AI SDK ToolSet shape, where `inputSchema` is a Schema-like value.
+    // We pass plain JSON schema objects across the step boundary (serializable), then wrap them here with
+    // `jsonSchema(...)` so the AI SDK does not attempt Zod conversion at runtime.
+    const toolsForStreamText = {};
+    for (const [name, t] of Object.entries(params.tools)) {
+        toolsForStreamText[name] = {
+            description: t?.description,
+            inputSchema: jsonSchema(t.inputSchema),
+        };
+    }
+    const result = streamText({
+        model: resolvedModel,
+        system: params.system,
+        messages: params.messages,
+        tools: toolsForStreamText,
+        toolChoice: "required",
+        stopWhen: stepCountIs(params.maxSteps),
+        experimental_transform: smoothStream({ delayInMs: 30, chunking: "word" }),
+    });
+    // Ensure the underlying stream is consumed (AI SDK requirement)
+    result.consumeStream();
+    let resolveFinish;
+    let rejectFinish;
+    const finishPromise = new Promise((resolve, reject) => {
+        resolveFinish = resolve;
+        rejectFinish = reject;
+    });
+    const uiStream = result
+        .toUIMessageStream({
+        // Emit `start` only when the engine says so (typically once per turn).
+        sendStart: Boolean(params.sendStart),
+        generateMessageId: () => params.eventId,
+        messageMetadata() {
+            return { eventId: params.eventId };
+        },
+        onFinish: ({ messages }) => {
+            const lastMessage = messages[messages.length - 1];
+            const event = {
+                id: params.eventId,
+                type: OUTPUT_ITEM_TYPE,
+                channel: "web",
+                createdAt: new Date().toISOString(),
+                content: { parts: lastMessage?.parts ?? [] },
+            };
+            resolveFinish(event);
+        },
+        onError: (e) => {
+            rejectFinish(e);
+            return e instanceof Error ? e.message : String(e);
+        },
+    })
+        // Filter out per-step finish boundary. Workflow will emit a single finish.
+        .pipeThrough(new TransformStream({
+        transform(chunk, controller) {
+            if (chunk.type === "finish")
+                return;
+            controller.enqueue(chunk);
+        },
+    }));
+    await uiStream.pipeTo(writable, { preventClose: true });
+    const assistantEvent = await finishPromise;
+    const actionRequests = extractToolCallsFromParts(assistantEvent?.content?.parts).map((entry) => ({
+        actionRef: String(entry.toolCallId),
+        actionName: String(entry.toolName),
+        input: entry.args,
+    }));
+    return {
+        assistantEvent,
+        actionRequests,
+    };
+}

package/dist/steps/mirror.steps.d.ts

@@ -0,0 +1,6 @@
+import type { ContextEnvironment } from "../context.config.js";
+import type { ContextMirrorWrite } from "../mirror.js";
+export declare function mirrorContextWrites(params: {
+    env: ContextEnvironment;
+    writes: ContextMirrorWrite[];
+}): Promise<void>;

package/dist/steps/mirror.steps.js

@@ -0,0 +1,48 @@
+function requireOrgId(env) {
+    const orgId = env?.orgId;
+    if (typeof orgId !== "string" || !orgId) {
+        throw new Error("[context/mirror] Missing env.orgId");
+    }
+    return orgId;
+}
+function requireBaseUrl() {
+    const baseUrl = process.env.EKAIROS_CORE_BASE_URL ||
+        process.env.EKAIROS_MIRROR_BASE_URL ||
+        process.env.EKAIROS_BASE_URL;
+    if (!baseUrl) {
+        throw new Error("[context/mirror] Missing EKAIROS_CORE_BASE_URL (or EKAIROS_MIRROR_BASE_URL)");
+    }
+    return baseUrl.replace(/\/$/, "");
+}
+function requireToken() {
+    // Preferred: Clerk org API key (opaque token) for ekairos-core.
+    const apiKey = process.env.EKAIROS_CLERK_API_KEY;
+    if (apiKey)
+        return apiKey;
+    // Fallback: shared secret token.
+    const token = process.env.EKAIROS_CONTEXT_MIRROR_TOKEN;
+    if (token)
+        return token;
+    throw new Error("[context/mirror] Missing EKAIROS_CLERK_API_KEY (or EKAIROS_CONTEXT_MIRROR_TOKEN fallback)");
+}
+export async function mirrorContextWrites(params) {
+    "use step";
+    if (!params.writes?.length)
+        return;
+    const orgId = requireOrgId(params.env);
+    const baseUrl = requireBaseUrl();
+    const token = requireToken();
+    const body = { orgId, writes: params.writes };
+    const res = await fetch(`${baseUrl}/api/context`, {
+        method: "POST",
+        headers: {
+            "content-type": "application/json",
+            authorization: `Bearer ${token}`,
+        },
+        body: JSON.stringify(body),
+    });
+    if (!res.ok) {
+        const text = await res.text().catch(() => "");
+        throw new Error(`[context/mirror] ekairos-core write failed (${res.status}): ${text}`);
+    }
+}

package/dist/steps/store.steps.d.ts

@@ -0,0 +1,96 @@
+import type { UIMessageChunk } from "ai";
+import type { ContextEnvironment } from "../context.config.js";
+import type { ContextExecution, ContextItem, ContextIdentifier, StoredContext, ContextStatus } from "../context.store.js";
+export type ContextReviewRequest = {
+    toolCallId: string;
+    toolName?: string;
+};
+/**
+ * Initializes/ensures the story context exists.
+ *
+ * This is the "context init" boundary for the story engine.
+ */
+export declare function initializeContext<C>(env: ContextEnvironment, contextIdentifier: ContextIdentifier | null, opts?: {
+    silent?: boolean;
+    writable?: WritableStream<UIMessageChunk>;
+}): Promise<{
+    context: StoredContext<C>;
+    isNew: boolean;
+}>;
+export declare function updateContextContent<C>(env: ContextEnvironment, contextIdentifier: ContextIdentifier, content: C): Promise<StoredContext<C>>;
+export declare function updateContextStatus(env: ContextEnvironment, contextIdentifier: ContextIdentifier, status: ContextStatus): Promise<void>;
+export declare function saveTriggerItem(env: ContextEnvironment, contextIdentifier: ContextIdentifier, event: ContextItem): Promise<ContextItem>;
+export declare function saveTriggerAndCreateExecution(params: {
+    env: ContextEnvironment;
+    contextIdentifier: ContextIdentifier;
+    triggerEvent: ContextItem;
+}): Promise<{
+    triggerEvent: ContextItem;
+    reactionEvent: ContextItem;
+    execution: ContextExecution;
+}>;
+export declare function saveReactionItem(env: ContextEnvironment, contextIdentifier: ContextIdentifier, event: ContextItem, opts?: {
+    executionId?: string;
+    contextId?: string;
+    reviewRequests?: ContextReviewRequest[];
+}): Promise<ContextItem>;
+export declare function updateItem(env: ContextEnvironment, eventId: string, event: ContextItem, opts?: {
+    executionId?: string;
+    contextId?: string;
+}): Promise<ContextItem>;
+export declare function createExecution(env: ContextEnvironment, contextIdentifier: ContextIdentifier, triggerEventId: string, reactionEventId: string): Promise<{
+    id: string;
+}>;
+export declare function createReactionItem(params: {
+    env: ContextEnvironment;
+    contextIdentifier: ContextIdentifier;
+    triggerEventId: string;
+}): Promise<{
+    reactionEventId: string;
+    executionId: string;
+}>;
+export declare function completeExecution(env: ContextEnvironment, contextIdentifier: ContextIdentifier, executionId: string, status: "completed" | "failed"): Promise<void>;
+export declare function updateExecutionWorkflowRun(params: {
+    env: ContextEnvironment;
+    executionId: string;
+    workflowRunId: string;
+}): Promise<void>;
+export declare function createContextStep(params: {
+    env: ContextEnvironment;
+    executionId: string;
+    iteration: number;
+}): Promise<{
+    stepId: string;
+}>;
+export declare function updateContextStep(params: {
+    env: ContextEnvironment;
+    stepId: string;
+    executionId?: string;
+    contextId?: string;
+    iteration?: number;
+    patch: {
+        status?: "running" | "completed" | "failed";
+        kind?: "message" | "action_execute" | "action_result";
+        actionName?: string;
+        actionInput?: unknown;
+        actionOutput?: unknown;
+        actionError?: string;
+        actionRequests?: any;
+        actionResults?: any;
+        continueLoop?: boolean;
+        errorText?: string;
+    };
+}): Promise<void>;
+export declare function linkItemToExecutionStep(params: {
+    env: ContextEnvironment;
+    itemId: string;
+    executionId: string;
+}): Promise<void>;
+export declare function saveContextPartsStep(params: {
+    env: ContextEnvironment;
+    stepId: string;
+    executionId?: string;
+    contextId?: string;
+    iteration?: number;
+    parts: any[];
+}): Promise<void>;