@ekairos/story 1.21.54-beta.0 → 1.21.57-beta.0

package/dist/next.js

@@ -4,8 +4,12 @@ import { dirname, relative, resolve } from "node:path";
 function patchWorkflowStepRouteToImportBootstrap(bootstrapModule) {
     const cwd = process.cwd();
     const candidates = [
+        // legacy app-dir without /src
         resolve(cwd, "app/.well-known/workflow/v1/step/route.js"),
+        resolve(cwd, "app/.well-known/workflow/v1/step/route.ts"),
+        // app-dir under /src
         resolve(cwd, "src/app/.well-known/workflow/v1/step/route.js"),
+        resolve(cwd, "src/app/.well-known/workflow/v1/step/route.ts"),
     ];
     const bootstrapAbs = resolve(cwd, bootstrapModule);
     for (const routeFile of candidates) {
@@ -24,10 +28,14 @@ function patchWorkflowStepRouteToImportBootstrap(bootstrapModule) {
         if (contents.includes(importLine))
             continue;
         const lines = contents.split(/\r?\n/);
+        // Insert the import above the first real statement (skip comments/empty lines).
         let insertAt = 0;
         for (let i = 0; i < lines.length; i++) {
             const t = lines[i].trim();
-            const isComment = t.startsWith("//") || t.startsWith("/*") || t.startsWith("*") || t.startsWith("*/");
+            const isComment = t.startsWith("//") ||
+                t.startsWith("/*") ||
+                t.startsWith("*") ||
+                t.startsWith("*/");
             if (t === "" || isComment)
                 continue;
             insertAt = i;
@@ -90,9 +98,7 @@ export function withEkairosRuntime(nextConfigOrFn, opts) {
                 const req = createRequire(import.meta.url);
                 const contextDir = (out && out.context) || process.cwd();
                 // Resolve relative to the app project (webpack context), not to this package.
-                const resolvedBootstrap = req.resolve(bootstrapModule, {
-                    paths: [contextDir],
-                });
+                const resolvedBootstrap = req.resolve(bootstrapModule, { paths: [contextDir] });
                 const originalEntry = out.entry;
                 out.entry = async () => {
                     const entries = typeof originalEntry === "function" ? await originalEntry() : originalEntry;
@@ -104,7 +110,7 @@ export function withEkairosRuntime(nextConfigOrFn, opts) {
         };
     };
     // Critical path for Vercel/Turbopack:
-    // `@workflow/next` generates `src/app/.well-known/workflow/v1/step/route.js` inside its config function.
+    // `@workflow/next` generates `.well-known/workflow/.../route.(ts|js)` inside its config function.
     // So we must patch AFTER that function runs (not inside webpack).
     if (typeof nextConfigOrFn === "function") {
         return async (phase, ctx) => {

package/dist/runtime.step.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Internal helper to resolve Story runtime from within workflow steps.
+ *
+ * Why dynamic import?
+ * - Some bundlers (notably Turbopack step bundles) can drop/hoist static imports in "use-step" modules,
+ *   causing `ReferenceError: resolveStoryRuntime is not defined`.
+ * - Using a dynamic import keeps the symbol resolution local to the step runtime.
+ */
+import type { StoryEnvironment, StoryRuntime } from "./story.config";
+export declare function getStoryRuntime(env: StoryEnvironment): Promise<StoryRuntime>;

package/dist/runtime.step.js

@@ -0,0 +1,4 @@
+export async function getStoryRuntime(env) {
+    const { resolveStoryRuntime } = await import("@ekairos/story/runtime");
+    return await resolveStoryRuntime(env);
+}

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

@@ -1,4 +1,4 @@
-import { type ModelMessage } from "ai";
+import type { ModelMessage } from "ai";
 import type { ContextEvent } from "../story.store";
 import type { SerializableToolForModel } from "../tools-to-model-tools";
 /**

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

@@ -1,6 +1,3 @@
-import { jsonSchema, gateway, smoothStream, stepCountIs, streamText, } from "ai";
-import { getWritable } from "workflow";
-import { extractToolCallsFromParts } from "../story.toolcalls";
 /**
  * Runs a single LLM streaming step as a Workflow step.
  *
@@ -10,7 +7,10 @@ import { extractToolCallsFromParts } from "../story.toolcalls";
  */
 export async function doStoryStreamStep(params) {
     "use step";
+    const { getWritable } = await import("workflow");
     const writable = getWritable();
+    const { jsonSchema, gateway, smoothStream, stepCountIs, streamText } = await import("ai");
+    const { extractToolCallsFromParts } = await import("../story.toolcalls");
     // 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)

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

@@ -1,4 +1,4 @@
-import { type ModelMessage } from "ai";
+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";

package/dist/steps/reaction.steps.js

@@ -1,7 +1,3 @@
-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);
@@ -41,6 +37,7 @@ function safeErrorJson(error) {
  */
 export async function executeReaction(params) {
     "use step";
+    const { resolveStoryRuntime } = await import("@ekairos/story/runtime");
     const { store } = await resolveStoryRuntime(params.env);
     console.log("[ekairos/story] reaction.step executeReaction begin");
     let events;
@@ -65,7 +62,9 @@ export async function executeReaction(params) {
     }
     const writable = params.silent
         ? new WritableStream({ write() { } })
-        : getWritable();
+        : (await import("workflow")).getWritable();
+    const { jsonSchema, gateway, smoothStream, stepCountIs, streamText } = await import("ai");
+    const { extractToolCallsFromParts } = await import("../story.toolcalls");
     // Match DurableAgent-style model init behavior:
     const resolvedModel = typeof params.model === "string"
         ? gateway(params.model)

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

@@ -1,4 +1,4 @@
-import { type StoryEnvironment } from "../story.config";
+import type { StoryEnvironment } from "../story.config";
 import type { ContextEvent, ContextIdentifier, StoredContext } from "../story.store";
 /**
  * Initializes/ensures the story context exists and emits a single `data-context-id` chunk.

package/dist/steps/store.steps.js

@@ -1,5 +1,3 @@
-import { getWritable } from "workflow";
-import { resolveStoryRuntime } from "../story.config";
 /**
  * Initializes/ensures the story context exists and emits a single `data-context-id` chunk.
  *
@@ -7,6 +5,7 @@ import { resolveStoryRuntime } from "../story.config";
  */
 export async function initializeContext(env, contextIdentifier, opts) {
     "use step";
+    const { resolveStoryRuntime } = await import("@ekairos/story/runtime");
     const { store } = await resolveStoryRuntime(env);
     // Detect creation explicitly so the engine can run onContextCreated hooks.
     let result;
@@ -27,6 +26,7 @@ export async function initializeContext(env, contextIdentifier, opts) {
     // 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 { getWritable } = await import("workflow");
         const writable = getWritable();
         const writer = writable.getWriter();
         try {
@@ -44,36 +44,43 @@ export async function initializeContext(env, contextIdentifier, opts) {
 }
 export async function updateContextContent(env, contextIdentifier, content) {
     "use step";
+    const { resolveStoryRuntime } = await import("@ekairos/story/runtime");
     const { store } = await resolveStoryRuntime(env);
     return await store.updateContextContent(contextIdentifier, content);
 }
 export async function updateContextStatus(env, contextIdentifier, status) {
     "use step";
+    const { resolveStoryRuntime } = await import("@ekairos/story/runtime");
     const { store } = await resolveStoryRuntime(env);
     await store.updateContextStatus(contextIdentifier, status);
 }
 export async function saveTriggerEvent(env, contextIdentifier, event) {
     "use step";
+    const { resolveStoryRuntime } = await import("@ekairos/story/runtime");
     const { store } = await resolveStoryRuntime(env);
     return await store.saveEvent(contextIdentifier, event);
 }
 export async function saveReactionEvent(env, contextIdentifier, event) {
     "use step";
+    const { resolveStoryRuntime } = await import("@ekairos/story/runtime");
     const { store } = await resolveStoryRuntime(env);
     return await store.saveEvent(contextIdentifier, event);
 }
 export async function updateEvent(env, eventId, event) {
     "use step";
+    const { resolveStoryRuntime } = await import("@ekairos/story/runtime");
     const { store } = await resolveStoryRuntime(env);
     return await store.updateEvent(eventId, event);
 }
 export async function createExecution(env, contextIdentifier, triggerEventId, reactionEventId) {
     "use step";
+    const { resolveStoryRuntime } = await import("@ekairos/story/runtime");
     const { store } = await resolveStoryRuntime(env);
     return await store.createExecution(contextIdentifier, triggerEventId, reactionEventId);
 }
 export async function createReactionEvent(params) {
     "use step";
+    const { resolveStoryRuntime } = await import("@ekairos/story/runtime");
     const { store } = await resolveStoryRuntime(params.env);
     // Generate a new reaction event id inside the step boundary.
     const uuid = globalThis.crypto?.randomUUID?.();
@@ -86,6 +93,7 @@ export async function createReactionEvent(params) {
 }
 export async function completeExecution(env, contextIdentifier, executionId, status) {
     "use step";
+    const { resolveStoryRuntime } = await import("@ekairos/story/runtime");
     const { store } = await resolveStoryRuntime(env);
     await store.completeExecution(contextIdentifier, executionId, status);
 }

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

@@ -1,3 +1,8 @@
+export declare function writeStoryLog(params: {
+    level?: "info" | "debug" | "warn" | "error";
+    message: string;
+    args?: Array<string | number | boolean | null>;
+}): Promise<void>;
 export declare function writeContextSubstate(params: {
     /**
      * Ephemeral substate key for the UI (story engine internal state).

package/dist/steps/stream.steps.js

@@ -1,6 +1,18 @@
-import { getWritable } from "workflow";
+export async function writeStoryLog(params) {
+    "use step";
+    const level = params.level ?? "info";
+    const fn = level === "debug"
+        ? console.debug
+        : level === "warn"
+            ? console.warn
+            : level === "error"
+                ? console.error
+                : console.log;
+    fn(params.message, ...(params.args ?? []));
+}
 export async function writeContextSubstate(params) {
     "use step";
+    const { getWritable } = await import("workflow");
     const writable = getWritable();
     const writer = writable.getWriter();
     try {
@@ -16,6 +28,7 @@ export async function writeContextSubstate(params) {
 }
 export async function writeContextIdChunk(params) {
     "use step";
+    const { getWritable } = await import("workflow");
     const writable = getWritable();
     const writer = writable.getWriter();
     try {
@@ -31,6 +44,7 @@ export async function writeContextIdChunk(params) {
 }
 export async function writeStoryPing(params) {
     "use step";
+    const { getWritable } = await import("workflow");
     const writable = getWritable();
     const writer = writable.getWriter();
     try {
@@ -46,6 +60,7 @@ export async function writeStoryPing(params) {
 }
 export async function writeToolOutputs(params) {
     "use step";
+    const { getWritable } = await import("workflow");
     const writable = getWritable();
     const writer = writable.getWriter();
     try {
@@ -74,6 +89,7 @@ export async function closeStoryStream(params) {
     "use step";
     const sendFinish = params.sendFinish ?? true;
     const preventClose = params.preventClose ?? false;
+    const { getWritable } = await import("workflow");
     const writable = getWritable();
     if (sendFinish) {
         const writer = writable.getWriter();

package/dist/story.builder.d.ts

@@ -17,7 +17,7 @@ export interface StoryConfig<Context, Env extends StoryEnvironment = StoryEnviro
      * If you do not provide an implementation, the default is an identity transform
      * (events pass through unchanged).
      *
-     * If you do I/O here, implement it as a `"use step"` function.
+     * If you do I/O here, implement it as a `"use-step"` function.
      */
     expandEvents?: (events: ContextEvent[], context: StoredContext<Context>, env: Env) => Promise<ContextEvent[]> | ContextEvent[];
     /**
@@ -36,7 +36,7 @@ export interface StoryConfig<Context, Env extends StoryEnvironment = StoryEnviro
      * Model configuration (DurableAgent-style).
      *
      * - `string`: AI Gateway model id, resolved in the LLM step (e.g. `"openai/gpt-5.1-thinking"`).
-     * - `() => Promise<model>`: model factory. For Workflow compatibility, provide a `"use step"` function
+     * - `() => Promise<model>`: model factory. For Workflow compatibility, provide a `"use-step"` function
      *   so it can be serialized by reference.
      * - `(context, env) => ...`: dynamic selection based on current context/env (runs in workflow context).
      */

package/dist/story.engine.d.ts

@@ -53,7 +53,7 @@ export interface StoryStreamOptions {
  *
  * - `string`: Vercel AI Gateway model id (e.g. `"openai/gpt-5"`), resolved inside the LLM step.
  * - `function`: a function that returns a model instance. For Workflow compatibility, this should
- *   be a `"use step"` function (so it can be serialized by reference).
+ *   be a `"use-step"` function (so it can be serialized by reference).
  */
 export type StoryModelInit = string | (() => Promise<any>) | any;
 export type StoryReactParams<Env extends StoryEnvironment = StoryEnvironment> = {
@@ -117,7 +117,7 @@ export declare abstract class Story<Context, Env extends StoryEnvironment = Stor
      * - This stage is ALWAYS executed by the engine.
      * - If you don't provide an implementation, the default behavior is an identity transform
      *   (events pass through unchanged).
-     * - If your implementation performs I/O, implement it as a `"use step"` function (provided via
+     * - If your implementation performs I/O, implement it as a `"use-step"` function (provided via
      *   the builder) so results are durable and replay-safe.
      * - If it’s pure/deterministic, it can run in workflow context.
      */

package/dist/story.engine.js

@@ -1,15 +1,49 @@
 import { applyToolExecutionResultToParts } from "./story.toolcalls.js";
 import { executeReaction } from "./steps/reaction.steps.js";
 import { toolsToModelTools } from "./tools-to-model-tools.js";
-import { closeStoryStream, writeContextSubstate, writeStoryPing, writeToolOutputs } from "./steps/stream.steps.js";
+import { closeStoryStream, writeContextSubstate, writeStoryLog, writeStoryPing, writeToolOutputs, } from "./steps/stream.steps.js";
 import { completeExecution, createReactionEvent, initializeContext, saveReactionEvent, saveTriggerEvent, updateContextContent, updateContextStatus, updateEvent, } from "./steps/store.steps.js";
-function storyEngineInfo(message, ...args) {
+function safeLogArg(value) {
+    if (value === null)
+        return null;
+    if (value === undefined)
+        return null;
+    const t = typeof value;
+    if (t === "string" || t === "number" || t === "boolean")
+        return value;
+    if (t === "bigint")
+        return String(value);
+    try {
+        const seen = new WeakSet();
+        return JSON.stringify(value, (_k, v) => {
+            if (typeof v === "bigint")
+                return String(v);
+            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;
+        }, 2);
+    }
+    catch {
+        try {
+            return String(value);
+        }
+        catch {
+            return "[unserializable]";
+        }
+    }
+}
+async function storyEngineInfo(message, ...args) {
     // CRITICAL: static string log messages only. Dynamic values go in args.
-    console.log(message, ...args);
+    await writeStoryLog({ level: "info", message, args: args.map(safeLogArg) });
 }
-function storyEngineDebug(message, ...args) {
+async function storyEngineDebug(message, ...args) {
     // CRITICAL: static string log messages only. Dynamic values go in args.
-    console.debug(message, ...args);
+    await writeStoryLog({ level: "debug", message, args: args.map(safeLogArg) });
 }
 export class Story {
     constructor(opts = {}) {
@@ -28,7 +62,7 @@ export class Story {
      * - This stage is ALWAYS executed by the engine.
      * - If you don't provide an implementation, the default behavior is an identity transform
      *   (events pass through unchanged).
-     * - If your implementation performs I/O, implement it as a `"use step"` function (provided via
+     * - If your implementation performs I/O, implement it as a `"use-step"` function (provided via
      *   the builder) so results are durable and replay-safe.
      * - If it’s pure/deterministic, it can run in workflow context.
      */
@@ -67,17 +101,17 @@ export class Story {
         const preventClose = params.options?.preventClose ?? false;
         const sendFinish = params.options?.sendFinish ?? true;
         const silent = params.options?.silent ?? false;
-        storyEngineInfo("[ekairos/story] story.engine react begin");
-        storyEngineInfo("[ekairos/story] story.engine react contextIdentifier", params.contextIdentifier);
-        storyEngineInfo("[ekairos/story] story.engine react maxIterations", maxIterations);
-        storyEngineInfo("[ekairos/story] story.engine react maxModelSteps", maxModelSteps);
-        storyEngineInfo("[ekairos/story] story.engine react silent", silent);
+        await storyEngineInfo("[ekairos/story] story.engine react begin");
+        await storyEngineInfo("[ekairos/story] story.engine react contextIdentifier", params.contextIdentifier);
+        await storyEngineInfo("[ekairos/story] story.engine react maxIterations", maxIterations);
+        await storyEngineInfo("[ekairos/story] story.engine react maxModelSteps", maxModelSteps);
+        await storyEngineInfo("[ekairos/story] story.engine react silent", silent);
         // 1) Ensure context exists (step)
         const ctxResult = await initializeContext(params.env, params.contextIdentifier, { silent });
         const currentContext = ctxResult.context;
-        storyEngineInfo("[ekairos/story] story.engine initializeContext ok");
-        storyEngineInfo("[ekairos/story] story.engine initializeContext contextId", currentContext.id);
-        storyEngineInfo("[ekairos/story] story.engine initializeContext isNew", ctxResult.isNew);
+        await storyEngineInfo("[ekairos/story] story.engine initializeContext ok");
+        await storyEngineInfo("[ekairos/story] story.engine initializeContext contextId", currentContext.id);
+        await storyEngineInfo("[ekairos/story] story.engine initializeContext isNew", ctxResult.isNew);
         const contextSelector = params.contextIdentifier?.id
             ? { id: String(params.contextIdentifier.id) }
             : params.contextIdentifier?.key
@@ -89,16 +123,16 @@ export class Story {
         // 2) Persist trigger event + create execution shell (steps)
         const persistedTriggerEvent = await saveTriggerEvent(params.env, contextSelector, triggerEvent);
         const triggerEventId = persistedTriggerEvent.id;
-        storyEngineInfo("[ekairos/story] story.engine saveTriggerEvent ok");
-        storyEngineInfo("[ekairos/story] story.engine saveTriggerEvent triggerEventId", triggerEventId);
+        await storyEngineInfo("[ekairos/story] story.engine saveTriggerEvent ok");
+        await storyEngineInfo("[ekairos/story] story.engine saveTriggerEvent triggerEventId", triggerEventId);
         const { reactionEventId, executionId } = await createReactionEvent({
             env: params.env,
             contextIdentifier: contextSelector,
             triggerEventId,
         });
-        storyEngineInfo("[ekairos/story] story.engine createReactionEvent ok");
-        storyEngineInfo("[ekairos/story] story.engine createReactionEvent reactionEventId", reactionEventId);
-        storyEngineInfo("[ekairos/story] story.engine createReactionEvent executionId", executionId);
+        await storyEngineInfo("[ekairos/story] story.engine createReactionEvent ok");
+        await storyEngineInfo("[ekairos/story] story.engine createReactionEvent reactionEventId", reactionEventId);
+        await storyEngineInfo("[ekairos/story] story.engine createReactionEvent executionId", executionId);
         // Emit a simple ping chunk early so clients can validate that streaming works end-to-end.
         // This should be ignored safely by clients that don't care about it.
         if (!silent) {
@@ -125,22 +159,22 @@ export class Story {
         };
         try {
             for (let iter = 0; iter < maxIterations; iter++) {
-                storyEngineInfo("[ekairos/story] story.engine === LOOP ITERATION ===", iter);
+                await storyEngineInfo("[ekairos/story] story.engine === LOOP ITERATION ===", iter);
                 // Hook: Story DSL `context()` (implemented by subclasses via `initialize()`)
-                storyEngineInfo("[ekairos/story] >>> HOOK context() BEGIN", iter);
+                await storyEngineInfo("[ekairos/story] >>> HOOK context() BEGIN", iter);
                 const nextContent = await this.initialize(updatedContext, params.env);
-                storyEngineInfo("[ekairos/story] <<< HOOK context() END", iter);
+                await storyEngineInfo("[ekairos/story] <<< HOOK context() END", iter);
                 updatedContext = await updateContextContent(params.env, contextSelector, nextContent);
-                storyEngineInfo("[ekairos/story] story.engine updateContextContent ok");
+                await storyEngineInfo("[ekairos/story] story.engine updateContextContent ok");
                 await this.opts.onContextUpdated?.({ env: params.env, context: updatedContext });
                 // Hook: Story DSL `narrative()` (implemented by subclasses via `buildSystemPrompt()`)
-                storyEngineInfo("[ekairos/story] >>> HOOK narrative() BEGIN", iter);
+                await storyEngineInfo("[ekairos/story] >>> HOOK narrative() BEGIN", iter);
                 const systemPrompt = await this.buildSystemPrompt(updatedContext, params.env);
-                storyEngineInfo("[ekairos/story] <<< HOOK narrative() END", iter);
+                await storyEngineInfo("[ekairos/story] <<< HOOK narrative() END", iter);
                 // Hook: Story DSL `actions()` (implemented by subclasses via `buildTools()`)
-                storyEngineInfo("[ekairos/story] >>> HOOK actions() BEGIN", iter);
+                await storyEngineInfo("[ekairos/story] >>> HOOK actions() BEGIN", iter);
                 const toolsAll = await this.buildTools(updatedContext, params.env);
-                storyEngineInfo("[ekairos/story] <<< HOOK actions() END", iter);
+                await storyEngineInfo("[ekairos/story] <<< HOOK actions() END", iter);
                 // IMPORTANT: step args must be serializable.
                 // Match DurableAgent behavior: convert tool input schemas to plain JSON Schema in workflow context.
                 const toolsForModel = toolsToModelTools(toolsAll);
@@ -156,11 +190,11 @@ export class Story {
                     sendStart: !silent && iter === 0 && reactionEvent === null,
                     silent,
                 });
-                storyEngineInfo("[ekairos/story] story.engine executeReaction ok");
-                storyEngineInfo("[ekairos/story] story.engine executeReaction toolCallsCount", toolCalls.length);
+                await storyEngineInfo("[ekairos/story] story.engine executeReaction ok");
+                await storyEngineInfo("[ekairos/story] story.engine executeReaction toolCallsCount", toolCalls.length);
                 if (toolCalls.length) {
-                    storyEngineInfo("[ekairos/story] >>> TOOL_CALLS requested", toolCalls.map((tc) => tc?.toolName).filter(Boolean));
-                    storyEngineDebug("[ekairos/story] >>> TOOL_CALLS payload", toolCalls);
+                    await storyEngineInfo("[ekairos/story] >>> TOOL_CALLS requested", toolCalls.map((tc) => tc?.toolName).filter(Boolean));
+                    await storyEngineDebug("[ekairos/story] >>> TOOL_CALLS payload", toolCalls);
                 }
                 // Persist/append the assistant event for this iteration
                 if (!reactionEvent) {
@@ -168,7 +202,7 @@ export class Story {
                         ...assistantEvent,
                         status: "pending",
                     });
-                    storyEngineInfo("[ekairos/story] story.engine saveReactionEvent ok");
+                    await storyEngineInfo("[ekairos/story] story.engine saveReactionEvent ok");
                 }
                 else {
                     reactionEvent = await updateEvent(params.env, reactionEvent.id, {
@@ -181,14 +215,14 @@ export class Story {
                         },
                         status: "pending",
                     });
-                    storyEngineInfo("[ekairos/story] story.engine updateEvent appendAssistantParts ok");
+                    await storyEngineInfo("[ekairos/story] story.engine updateEvent appendAssistantParts ok");
                 }
                 this.opts.onEventCreated?.(assistantEvent);
                 // Done: no tool calls requested by the model
                 if (!toolCalls.length) {
-                    storyEngineInfo("[ekairos/story] >>> HOOK onEnd() BEGIN", iter);
+                    await storyEngineInfo("[ekairos/story] >>> HOOK onEnd() BEGIN", iter);
                     const endResult = await this.callOnEnd(assistantEvent);
-                    storyEngineInfo("[ekairos/story] <<< HOOK onEnd() END", iter, endResult);
+                    await storyEngineInfo("[ekairos/story] <<< HOOK onEnd() END", iter, endResult);
                     if (endResult) {
                         // Mark reaction event completed
                         await updateEvent(params.env, reactionEventId, {
@@ -216,7 +250,7 @@ export class Story {
                 const executionResults = await Promise.all(toolCalls.map(async (tc) => {
                     const toolDef = toolsAll[tc.toolName];
                     if (!toolDef || typeof toolDef.execute !== "function") {
-                        storyEngineInfo("[ekairos/story] story.engine toolExecution missingTool", tc?.toolName);
+                        await storyEngineInfo("[ekairos/story] story.engine toolExecution missingTool", tc?.toolName);
                         return {
                             tc,
                             success: false,
@@ -224,8 +258,8 @@ export class Story {
                             errorText: `Tool "${tc.toolName}" not found or has no execute().`,
                         };
                     }
-                    storyEngineInfo("[ekairos/story] >>> TOOL_EXEC BEGIN", tc?.toolName, tc?.toolCallId);
-                    storyEngineDebug("[ekairos/story] >>> TOOL_EXEC input", tc?.toolName, tc?.toolCallId, tc?.args);
+                    await storyEngineInfo("[ekairos/story] >>> TOOL_EXEC BEGIN", tc?.toolName, tc?.toolCallId);
+                    await storyEngineDebug("[ekairos/story] >>> TOOL_EXEC input", tc?.toolName, tc?.toolCallId, tc?.args);
                     try {
                         const output = await toolDef.execute(tc.args, {
                             toolCallId: tc.toolCallId,
@@ -235,13 +269,13 @@ export class Story {
                             triggerEventId,
                             contextId: currentContext.id,
                         });
-                        storyEngineInfo("[ekairos/story] <<< TOOL_EXEC OK", tc?.toolName, tc?.toolCallId);
-                        storyEngineDebug("[ekairos/story] <<< TOOL_EXEC output", tc?.toolName, tc?.toolCallId, output);
+                        await storyEngineInfo("[ekairos/story] <<< TOOL_EXEC OK", tc?.toolName, tc?.toolCallId);
+                        await storyEngineDebug("[ekairos/story] <<< TOOL_EXEC output", tc?.toolName, tc?.toolCallId, output);
                         return { tc, success: true, output };
                     }
                     catch (e) {
-                        storyEngineInfo("[ekairos/story] <<< TOOL_EXEC FAILED", tc?.toolName, tc?.toolCallId);
-                        storyEngineDebug("[ekairos/story] <<< TOOL_EXEC error", tc?.toolName, tc?.toolCallId, e instanceof Error ? e.message : String(e));
+                        await storyEngineInfo("[ekairos/story] <<< TOOL_EXEC FAILED", tc?.toolName, tc?.toolCallId);
+                        await storyEngineDebug("[ekairos/story] <<< TOOL_EXEC error", tc?.toolName, tc?.toolCallId, e instanceof Error ? e.message : String(e));
                         return {
                             tc,
                             success: false,
@@ -250,7 +284,7 @@ export class Story {
                         };
                     }
                 }));
-                storyEngineInfo("[ekairos/story] story.engine toolExecution resultsCount", executionResults.length);
+                await storyEngineInfo("[ekairos/story] story.engine toolExecution resultsCount", executionResults.length);
                 // Emit tool outputs to the workflow stream (step)
                 if (!silent) {
                     await writeToolOutputs({
@@ -282,7 +316,7 @@ export class Story {
                         content: { parts },
                         status: "pending",
                     });
-                    storyEngineInfo("[ekairos/story] story.engine updateEvent mergeToolResults ok");
+                    await storyEngineInfo("[ekairos/story] story.engine updateEvent mergeToolResults ok");
                 }
                 // Callback for observability/integration
                 for (const r of executionResults) {
@@ -298,7 +332,7 @@ export class Story {
                 // Stop/continue boundary: allow the Story to decide if the loop should continue.
                 // IMPORTANT: we call this after tool results have been merged into the persisted `reactionEvent`,
                 // so stories can inspect `reactionEvent.content.parts` deterministically.
-                storyEngineInfo("[ekairos/story] >>> HOOK shouldContinue() BEGIN", iter);
+                await storyEngineInfo("[ekairos/story] >>> HOOK shouldContinue() BEGIN", iter);
                 const continueLoop = await this.shouldContinue({
                     env: params.env,
                     context: updatedContext,
@@ -307,7 +341,7 @@ export class Story {
                     toolCalls,
                     toolExecutionResults: executionResults,
                 });
-                storyEngineInfo("[ekairos/story] <<< HOOK shouldContinue() END", iter, continueLoop);
+                await storyEngineInfo("[ekairos/story] <<< HOOK shouldContinue() END", iter, continueLoop);
                 if (continueLoop === false) {
                     await updateEvent(params.env, reactionEventId, {
                         ...reactionEvent,

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

@@ -11,7 +11,7 @@ export type SerializableToolForModel = {
     inputSchema: unknown;
 };
 /**
- * Convert AI SDK tools to a serializable representation that can be passed to `"use step"` functions.
+ * 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`

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

@@ -1,6 +1,6 @@
 import { asSchema } from "ai";
 /**
- * Convert AI SDK tools to a serializable representation that can be passed to `"use step"` functions.
+ * 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`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ekairos/story",
-  "version": "1.21.54-beta.0",
+  "version": "1.21.57-beta.0",
   "description": "Pulzar Story - Workflow-based AI Stories",
   "type": "module",
   "main": "dist/index.js",
@@ -24,6 +24,11 @@
       "require": "./dist/index.js",
       "default": "./dist/index.js"
     },
+    "./schema": {
+      "types": "./dist/schema.d.ts",
+      "import": "./dist/schema.js",
+      "default": "./dist/schema.js"
+    },
     "./runtime": {
       "types": "./dist/runtime.d.ts",
       "import": "./dist/runtime.js",
@@ -42,6 +47,9 @@
   },
   "typesVersions": {
     "*": {
+      "schema": [
+        "dist/schema.d.ts"
+      ],
       "runtime": [
         "dist/runtime.d.ts"
       ],
@@ -62,14 +70,14 @@
   },
   "dependencies": {
     "@ai-sdk/openai": "^2.0.52",
-    "@ekairos/domain": "^1.21.54-beta.0",
+    "@ekairos/domain": "^1.21.57-beta.0",
     "@instantdb/admin": "^0.22.13",
     "@instantdb/core": "^0.22.13",
     "@vercel/sandbox": "^0.0.23",
     "ai": "^5.0.95",
     "ajv": "^8.17.1",
     "llamaindex": "^0.12.0",
-    "workflow": "4.0.1-beta.13",
+    "workflow": "4.0.1-beta.41",
     "xmlbuilder2": "^3.1.1",
     "zod": "^4.1.8"
   },