@ekairos/story 1.21.41-beta.0 → 1.21.52-beta.0

package/dist/ekairos.config.js

@@ -1,15 +1,4 @@
 import { configureStoryRuntime, configureStoryRuntimeBootstrap, isStoryRuntimeConfigured, } from "./story.config";
-const GLOBAL_EKAIROS_CONFIG = Symbol.for("@ekairos/story.ekairosConfig");
-function setGlobalEkairosConfig(config) {
-    try {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        ;
-        globalThis[GLOBAL_EKAIROS_CONFIG] = config;
-    }
-    catch {
-        // ignore
-    }
-}
 /**
  * Creates a small "framework-style" config object that can be executed in the step runtime.
  *
@@ -18,7 +7,7 @@ function setGlobalEkairosConfig(config) {
  */
 export function createEkairosConfig(params) {
     const stories = params.stories ?? [];
-    const config = {
+    return {
         stories,
         runtime: params.runtime,
         setup() {
@@ -34,8 +23,4 @@ export function createEkairosConfig(params) {
                 s.register();
         },
     };
-    // Register globally (process-level) so libraries/steps can access it transparently.
-    // Note: This does NOT call `setup()` (no runtime side-effects).
-    setGlobalEkairosConfig(config);
-    return config;
 }

package/dist/index.d.ts

@@ -1,6 +1,6 @@
-export { story, createStory, type StoryConfig, type StoryInstance, type StoryOptions, type StoryStreamOptions, Story, type RegistrableStoryBuilder, } from "./story";
-export type { StoryStore, ContextIdentifier, StoredContext, ContextEvent, } from "./story.store";
-export { registerStory, getStory, getStoryFactory, hasStory, listStories, type StoryKey, } from "./story.registry";
-export { storyDomain } from "./schema";
-export { didToolExecute } from "./story.toolcalls";
-export { USER_MESSAGE_TYPE, ASSISTANT_MESSAGE_TYPE, SYSTEM_MESSAGE_TYPE, WEB_CHANNEL, AGENT_CHANNEL, EMAIL_CHANNEL, createUserEventFromUIMessages, createAssistantEventFromUIMessages, convertToUIMessage, convertEventToModelMessages, convertEventsToModelMessages, convertModelMessageToEvent, type ResponseMessage, } from "./events";
+export { story, createStory, type StoryConfig, type StoryInstance, type StoryOptions, type StoryStreamOptions, Story, type RegistrableStoryBuilder, } from "./story.js";
+export type { StoryStore, ContextIdentifier, StoredContext, ContextEvent, } from "./story.store.js";
+export { registerStory, getStory, getStoryFactory, hasStory, listStories, type StoryKey, } from "./story.registry.js";
+export { storyDomain } from "./schema.js";
+export { didToolExecute } from "./story.toolcalls.js";
+export { USER_MESSAGE_TYPE, ASSISTANT_MESSAGE_TYPE, SYSTEM_MESSAGE_TYPE, WEB_CHANNEL, AGENT_CHANNEL, EMAIL_CHANNEL, createUserEventFromUIMessages, createAssistantEventFromUIMessages, convertToUIMessage, convertEventToModelMessages, convertEventsToModelMessages, convertModelMessageToEvent, type ResponseMessage, } from "./events.js";

package/dist/index.js

@@ -1,7 +1,7 @@
 export { 
 // Story API
-story, createStory, Story, } from "./story";
-export { registerStory, getStory, getStoryFactory, hasStory, listStories, } from "./story.registry";
-export { storyDomain } from "./schema";
-export { didToolExecute } from "./story.toolcalls";
-export { USER_MESSAGE_TYPE, ASSISTANT_MESSAGE_TYPE, SYSTEM_MESSAGE_TYPE, WEB_CHANNEL, AGENT_CHANNEL, EMAIL_CHANNEL, createUserEventFromUIMessages, createAssistantEventFromUIMessages, convertToUIMessage, convertEventToModelMessages, convertEventsToModelMessages, convertModelMessageToEvent, } from "./events";
+story, createStory, Story, } from "./story.js";
+export { registerStory, getStory, getStoryFactory, hasStory, listStories, } from "./story.registry.js";
+export { storyDomain } from "./schema.js";
+export { didToolExecute } from "./story.toolcalls.js";
+export { USER_MESSAGE_TYPE, ASSISTANT_MESSAGE_TYPE, SYSTEM_MESSAGE_TYPE, WEB_CHANNEL, AGENT_CHANNEL, EMAIL_CHANNEL, createUserEventFromUIMessages, createAssistantEventFromUIMessages, convertToUIMessage, convertEventToModelMessages, convertEventsToModelMessages, convertModelMessageToEvent, } from "./events.js";

package/dist/runtime.d.ts

@@ -8,6 +8,5 @@
  * - Do NOT import this entrypoint from client/browser code.
  * - Keep `@ekairos/story` main entrypoint safe to import from schema/domain modules.
  */
-export { configureStoryRuntime, configureStoryRuntimeBootstrap, getEkairosConfig, isStoryRuntimeConfigured, resolveStoryRuntime, type StoryEnvironment, type StoryRuntime, type StoryRuntimeResolver, } from "./story.config";
+export { configureStoryRuntime, configureStoryRuntimeBootstrap, isStoryRuntimeConfigured, resolveStoryRuntime, type StoryEnvironment, type StoryRuntime, type StoryRuntimeResolver, } from "./story.config";
 export { createEkairosConfig, type EkairosConfig, type RegistrableStory, } from "./ekairos.config";
-export { withEkairosRuntime } from "./next";

package/dist/runtime.js

@@ -8,6 +8,5 @@
  * - Do NOT import this entrypoint from client/browser code.
  * - Keep `@ekairos/story` main entrypoint safe to import from schema/domain modules.
  */
-export { configureStoryRuntime, configureStoryRuntimeBootstrap, getEkairosConfig, isStoryRuntimeConfigured, resolveStoryRuntime, } from "./story.config";
+export { configureStoryRuntime, configureStoryRuntimeBootstrap, isStoryRuntimeConfigured, resolveStoryRuntime, } from "./story.config";
 export { createEkairosConfig, } from "./ekairos.config";
-export { withEkairosRuntime } from "./next";

package/dist/steps/reaction.steps.d.ts

@@ -0,0 +1,26 @@
+import { type ModelMessage } from "ai";
+import type { StoryEnvironment } from "../story.config";
+import type { ContextEvent, ContextIdentifier } from "../story.store";
+import type { SerializableToolForModel } from "../tools-to-model-tools";
+/**
+ * Executes a full "reaction" inside a single workflow step:
+ * - load events from store
+ * - convert events to model messages
+ * - run the streaming model call and emit chunks
+ * - extract tool calls from the resulting assistant event
+ */
+export declare function executeReaction(params: {
+    env: StoryEnvironment;
+    contextIdentifier: ContextIdentifier;
+    model: any;
+    system: string;
+    tools: Record<string, SerializableToolForModel>;
+    eventId: string;
+    maxSteps: number;
+    sendStart?: boolean;
+    silent?: boolean;
+}): Promise<{
+    assistantEvent: ContextEvent;
+    toolCalls: any[];
+    messagesForModel: ModelMessage[];
+}>;

package/dist/steps/reaction.steps.js

@@ -0,0 +1,137 @@
+import { jsonSchema, gateway, smoothStream, stepCountIs, streamText, } from "ai";
+import { getWritable } from "workflow";
+import { resolveStoryRuntime } from "../story.config";
+import { extractToolCallsFromParts } from "../story.toolcalls";
+function safeErrorJson(error) {
+    const seen = new WeakSet();
+    const redactKey = (k) => /token|authorization|cookie|secret|api[_-]?key|password/i.test(k);
+    const err = error;
+    const payload = {
+        name: err?.name,
+        message: err?.message,
+        status: err?.status,
+        body: err?.body,
+        data: err?.data,
+        stack: err?.stack,
+    };
+    try {
+        return JSON.stringify(payload, (k, v) => {
+            if (redactKey(k))
+                return "[redacted]";
+            if (typeof v === "string" && v.length > 5000)
+                return "[truncated-string]";
+            if (typeof v === "object" && v !== null) {
+                if (seen.has(v))
+                    return "[circular]";
+                seen.add(v);
+            }
+            return v;
+        });
+    }
+    catch {
+        return JSON.stringify({ message: String(err?.message ?? "error") });
+    }
+}
+/**
+ * Executes a full "reaction" inside a single workflow step:
+ * - load events from store
+ * - convert events to model messages
+ * - run the streaming model call and emit chunks
+ * - extract tool calls from the resulting assistant event
+ */
+export async function executeReaction(params) {
+    "use step";
+    const { store } = await resolveStoryRuntime(params.env);
+    console.log("[ekairos/story] reaction.step executeReaction begin");
+    let events;
+    try {
+        console.log("[ekairos/story] reaction.step store.getEvents begin");
+        events = await store.getEvents(params.contextIdentifier);
+        console.log("[ekairos/story] reaction.step store.getEvents ok");
+    }
+    catch (error) {
+        console.error("[ekairos/story] reaction.step store.getEvents failed");
+        throw error;
+    }
+    let messagesForModel;
+    try {
+        console.log("[ekairos/story] reaction.step store.eventsToModelMessages begin");
+        messagesForModel = (await store.eventsToModelMessages(events));
+        console.log("[ekairos/story] reaction.step store.eventsToModelMessages ok");
+    }
+    catch (error) {
+        console.error("[ekairos/story] reaction.step store.eventsToModelMessages failed", safeErrorJson(error));
+        throw error;
+    }
+    const writable = params.silent
+        ? new WritableStream({ write() { } })
+        : getWritable();
+    // Match DurableAgent-style model init behavior:
+    const resolvedModel = typeof params.model === "string"
+        ? gateway(params.model)
+        : typeof params.model === "function"
+            ? await params.model()
+            : params.model;
+    // Wrap plain JSON Schema objects so the AI SDK doesn't 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),
+        };
+    }
+    console.log("[ekairos/story] reaction.step streamText begin");
+    const result = streamText({
+        model: resolvedModel,
+        system: params.system,
+        messages: messagesForModel,
+        tools: toolsForStreamText,
+        toolChoice: "required",
+        stopWhen: stepCountIs(params.maxSteps),
+        experimental_transform: smoothStream({ delayInMs: 30, chunking: "word" }),
+    });
+    console.log("[ekairos/story] reaction.step streamText ok");
+    // 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({
+        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: "assistant.message",
+                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 toolCalls = extractToolCallsFromParts(assistantEvent?.content?.parts);
+    return { assistantEvent, toolCalls, messagesForModel };
+}

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

@@ -1,43 +1,30 @@
-import type { ModelMessage } from "ai";
 import { type StoryEnvironment } from "../story.config";
 import type { ContextEvent, ContextIdentifier, StoredContext } from "../story.store";
-export declare function generateId(): Promise<string>;
-export declare function getOrCreateContext<C>(env: StoryEnvironment, contextIdentifier: ContextIdentifier | null): Promise<{
-    context: StoredContext<C>;
-    isNew: boolean;
-}>;
 /**
- * Ensures a context exists and emits a single `data-context-id` chunk to the workflow stream.
+ * Initializes/ensures the story context exists and emits a single `data-context-id` chunk.
  *
- * Why this exists:
- * - `getOrCreateContext(...)` and `writeContextIdChunk(...)` are semantically coupled.
- * - Keeping them in a single step reduces step invocations per run (cheaper) without changing behavior.
+ * This is the "context init" boundary for the story engine.
  */
-export declare function ensureContextAndEmitContextId<C>(env: StoryEnvironment, contextIdentifier: ContextIdentifier | null): Promise<{
+export declare function initializeContext<C>(env: StoryEnvironment, contextIdentifier: ContextIdentifier | null, opts?: {
+    silent?: boolean;
+}): Promise<{
     context: StoredContext<C>;
     isNew: boolean;
 }>;
-export declare function getContext<C>(env: StoryEnvironment, contextIdentifier: ContextIdentifier): Promise<StoredContext<C> | null>;
-/**
- * Loads the state needed for a single Story loop iteration.
- *
- * This is a "read aggregation" step: it groups read-only store calls into a single workflow step
- * invocation to reduce step overhead (cheaper) without changing behavior.
- */
-export declare function loadTurnState<C>(params: {
-    env: StoryEnvironment;
-    contextIdentifier: ContextIdentifier;
-}): Promise<{
-    context: StoredContext<C> | null;
-    events: ContextEvent[];
-}>;
 export declare function updateContextContent<C>(env: StoryEnvironment, contextIdentifier: ContextIdentifier, content: C): Promise<StoredContext<C>>;
 export declare function updateContextStatus(env: StoryEnvironment, contextIdentifier: ContextIdentifier, status: "open" | "streaming" | "closed"): Promise<void>;
-export declare function saveEvent(env: StoryEnvironment, contextIdentifier: ContextIdentifier, event: ContextEvent): Promise<ContextEvent>;
+export declare function saveTriggerEvent(env: StoryEnvironment, contextIdentifier: ContextIdentifier, event: ContextEvent): Promise<ContextEvent>;
+export declare function saveReactionEvent(env: StoryEnvironment, contextIdentifier: ContextIdentifier, event: ContextEvent): Promise<ContextEvent>;
 export declare function updateEvent(env: StoryEnvironment, eventId: string, event: ContextEvent): Promise<ContextEvent>;
-export declare function getEvents(env: StoryEnvironment, contextIdentifier: ContextIdentifier): Promise<ContextEvent[]>;
 export declare function createExecution(env: StoryEnvironment, contextIdentifier: ContextIdentifier, triggerEventId: string, reactionEventId: string): Promise<{
     id: string;
 }>;
+export declare function createReactionEvent(params: {
+    env: StoryEnvironment;
+    contextIdentifier: ContextIdentifier;
+    triggerEventId: string;
+}): Promise<{
+    reactionEventId: string;
+    executionId: string;
+}>;
 export declare function completeExecution(env: StoryEnvironment, contextIdentifier: ContextIdentifier, executionId: string, status: "completed" | "failed"): Promise<void>;
-export declare function eventsToModelMessages(env: StoryEnvironment, events: ContextEvent[]): Promise<ModelMessage[]>;

package/dist/steps/store.steps.js

@@ -1,36 +1,11 @@
 import { getWritable } from "workflow";
 import { resolveStoryRuntime } from "../story.config";
-export async function generateId() {
-    "use step";
-    // Use crypto.randomUUID when available (Node 18+)
-    const uuid = globalThis.crypto?.randomUUID?.();
-    if (uuid)
-        return uuid;
-    // Fallback
-    return `${Date.now()}-${Math.random().toString(16).slice(2)}`;
-}
-export async function getOrCreateContext(env, contextIdentifier) {
-    "use step";
-    const { store } = await resolveStoryRuntime(env);
-    // Detect creation explicitly so the engine can run onContextCreated hooks.
-    if (!contextIdentifier) {
-        const context = await store.getOrCreateContext(null);
-        return { context, isNew: true };
-    }
-    const existing = await store.getContext(contextIdentifier);
-    if (existing)
-        return { context: existing, isNew: false };
-    const created = await store.getOrCreateContext(contextIdentifier);
-    return { context: created, isNew: true };
-}
 /**
- * Ensures a context exists and emits a single `data-context-id` chunk to the workflow stream.
+ * Initializes/ensures the story context exists and emits a single `data-context-id` chunk.
  *
- * Why this exists:
- * - `getOrCreateContext(...)` and `writeContextIdChunk(...)` are semantically coupled.
- * - Keeping them in a single step reduces step invocations per run (cheaper) without changing behavior.
+ * This is the "context init" boundary for the story engine.
  */
-export async function ensureContextAndEmitContextId(env, contextIdentifier) {
+export async function initializeContext(env, contextIdentifier, opts) {
     "use step";
     const { store } = await resolveStoryRuntime(env);
     // Detect creation explicitly so the engine can run onContextCreated hooks.
@@ -49,38 +24,24 @@ export async function ensureContextAndEmitContextId(env, contextIdentifier) {
             result = { context: created, isNew: true };
         }
     }
-    const writable = getWritable();
-    const writer = writable.getWriter();
-    try {
-        await writer.write({
-            type: "data-context-id",
-            id: String(result.context.id),
-            data: { contextId: String(result.context.id) },
-        });
-    }
-    finally {
-        writer.releaseLock();
+    // If we're running in a non-streaming context (e.g. tests or headless usage),
+    // we skip writing stream chunks entirely.
+    if (!opts?.silent) {
+        const writable = getWritable();
+        const writer = writable.getWriter();
+        try {
+            await writer.write({
+                type: "data-context-id",
+                id: String(result.context.id),
+                data: { contextId: String(result.context.id) },
+            });
+        }
+        finally {
+            writer.releaseLock();
+        }
     }
     return result;
 }
-export async function getContext(env, contextIdentifier) {
-    "use step";
-    const { store } = await resolveStoryRuntime(env);
-    return await store.getContext(contextIdentifier);
-}
-/**
- * Loads the state needed for a single Story loop iteration.
- *
- * This is a "read aggregation" step: it groups read-only store calls into a single workflow step
- * invocation to reduce step overhead (cheaper) without changing behavior.
- */
-export async function loadTurnState(params) {
-    "use step";
-    const { store } = await resolveStoryRuntime(params.env);
-    const context = await store.getContext(params.contextIdentifier);
-    const events = await store.getEvents(params.contextIdentifier);
-    return { context, events };
-}
 export async function updateContextContent(env, contextIdentifier, content) {
     "use step";
     const { store } = await resolveStoryRuntime(env);
@@ -91,33 +52,40 @@ export async function updateContextStatus(env, contextIdentifier, status) {
     const { store } = await resolveStoryRuntime(env);
     await store.updateContextStatus(contextIdentifier, status);
 }
-export async function saveEvent(env, contextIdentifier, event) {
+export async function saveTriggerEvent(env, contextIdentifier, event) {
     "use step";
     const { store } = await resolveStoryRuntime(env);
     return await store.saveEvent(contextIdentifier, event);
 }
-export async function updateEvent(env, eventId, event) {
+export async function saveReactionEvent(env, contextIdentifier, event) {
     "use step";
     const { store } = await resolveStoryRuntime(env);
-    return await store.updateEvent(eventId, event);
+    return await store.saveEvent(contextIdentifier, event);
 }
-export async function getEvents(env, contextIdentifier) {
+export async function updateEvent(env, eventId, event) {
     "use step";
     const { store } = await resolveStoryRuntime(env);
-    return await store.getEvents(contextIdentifier);
+    return await store.updateEvent(eventId, event);
 }
 export async function createExecution(env, contextIdentifier, triggerEventId, reactionEventId) {
     "use step";
     const { store } = await resolveStoryRuntime(env);
     return await store.createExecution(contextIdentifier, triggerEventId, reactionEventId);
 }
-export async function completeExecution(env, contextIdentifier, executionId, status) {
+export async function createReactionEvent(params) {
     "use step";
-    const { store } = await resolveStoryRuntime(env);
-    await store.completeExecution(contextIdentifier, executionId, status);
+    const { store } = await resolveStoryRuntime(params.env);
+    // Generate a new reaction event id inside the step boundary.
+    const uuid = globalThis.crypto?.randomUUID?.();
+    const reactionEventId = typeof uuid === "string"
+        ? uuid
+        : `${Date.now()}-${Math.random().toString(16).slice(2)}`;
+    await store.updateContextStatus(params.contextIdentifier, "streaming");
+    const execution = await store.createExecution(params.contextIdentifier, params.triggerEventId, reactionEventId);
+    return { reactionEventId, executionId: execution.id };
 }
-export async function eventsToModelMessages(env, events) {
+export async function completeExecution(env, contextIdentifier, executionId, status) {
     "use step";
     const { store } = await resolveStoryRuntime(env);
-    return await store.eventsToModelMessages(events);
+    await store.completeExecution(contextIdentifier, executionId, status);
 }

package/dist/steps/stream.steps.d.ts

@@ -11,6 +11,13 @@ export declare function writeContextSubstate(params: {
 export declare function writeContextIdChunk(params: {
     contextId: string;
 }): Promise<void>;
+export declare function writeStoryPing(params: {
+    /**
+     * Simple ping event to validate that the workflow stream is alive.
+     * This is intentionally generic so clients can ignore it safely.
+     */
+    label?: string;
+}): Promise<void>;
 export declare function writeToolOutputs(params: {
     results: Array<{
         toolCallId: string;

package/dist/steps/stream.steps.js

@@ -29,6 +29,21 @@ export async function writeContextIdChunk(params) {
         writer.releaseLock();
     }
 }
+export async function writeStoryPing(params) {
+    "use step";
+    const writable = getWritable();
+    const writer = writable.getWriter();
+    try {
+        await writer.write({
+            type: "data-story-ping",
+            data: { label: params.label ?? "story-ping" },
+            transient: true,
+        });
+    }
+    finally {
+        writer.releaseLock();
+    }
+}
 export async function writeToolOutputs(params) {
     "use step";
     const writable = getWritable();

package/dist/stores/instant.document-parser.d.ts

@@ -2,4 +2,4 @@
  * Parses a document with LlamaParse and stores it in InstantDB (document_documents + link to file).
  * Returns the created documentId.
  */
-export declare function parseAndStoreDocument(db: any, buffer: Buffer, fileName: string, path: string, fileId: string): Promise<string>;
+export declare function parseAndStoreDocument(db: any, buffer: Buffer, fileName: string, fileId: string): Promise<string>;