@ekairos/story 1.21.30-beta.0 → 1.21.32-beta.0

package/dist/story.legacy.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Legacy entrypoint.
+ *
+ * Este archivo existe únicamente para compatibilidad hacia atrás.
+ * No exporta nada más que `createAgent`.
+ */
+import { createStory } from "./story.builder";
+/**
+ * @deprecated Use `createStory()` from the main entrypoint.
+ */
+export declare const createAgent: typeof createStory;
+//# sourceMappingURL=story.legacy.d.ts.map

package/dist/story.legacy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"story.legacy.d.ts","sourceRoot":"","sources":["../src/story.legacy.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAA;AAE7C;;GAEG;AACH,eAAO,MAAM,WAAW,oBAAc,CAAA"}

package/dist/story.legacy.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAgent = void 0;
+/**
+ * Legacy entrypoint.
+ *
+ * Este archivo existe únicamente para compatibilidad hacia atrás.
+ * No exporta nada más que `createAgent`.
+ */
+const story_builder_1 = require("./story.builder");
+/**
+ * @deprecated Use `createStory()` from the main entrypoint.
+ */
+exports.createAgent = story_builder_1.createStory;
+//# sourceMappingURL=story.legacy.js.map

package/dist/story.legacy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"story.legacy.js","sourceRoot":"","sources":["../src/story.legacy.ts"],"names":[],"mappings":";;;AAAA;;;;;GAKG;AACH,mDAA6C;AAE7C;;GAEG;AACU,QAAA,WAAW,GAAG,2BAAW,CAAA","sourcesContent":["/**\n * Legacy entrypoint.\n *\n * Este archivo existe únicamente para compatibilidad hacia atrás.\n * No exporta nada más que `createAgent`.\n */\nimport { createStory } from \"./story.builder\"\n\n/**\n * @deprecated Use `createStory()` from the main entrypoint.\n */\nexport const createAgent = createStory\n"]}

package/dist/story.registry.d.ts

@@ -0,0 +1,21 @@
+import type { StoryEnvironment } from "./story.config";
+import type { StoryInstance } from "./story.builder";
+/**
+ * Global registry for stories, similar to Inngest's function registry.
+ *
+ * Goals:
+ * - `createStory("key")` can be called many times (module reloads, tests, etc.)
+ * - Execution resolves a story by key (`getStory("key")`) instead of importing the module directly.
+ * - Registration is intentionally **runtime-local** (per process / per serverless instance).
+ */
+export type StoryKey = string;
+type AnyStory = StoryInstance<any, any>;
+export type StoryFactory = () => AnyStory;
+export declare function registerStory(key: StoryKey, factory: StoryFactory): void;
+export declare function hasStory(key: StoryKey): boolean;
+export declare function getStory<Env extends StoryEnvironment = StoryEnvironment>(key: StoryKey): AnyStory & {
+    __config: {};
+};
+export declare function getStoryFactory(key: StoryKey): StoryFactory;
+export declare function listStories(): string[];
+export {};

package/dist/story.registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"story.registry.d.ts","sourceRoot":"","sources":["../src/story.registry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAA;AACtD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAA;AAEpD;;;;;;;GAOG;AAEH,MAAM,MAAM,QAAQ,GAAG,MAAM,CAAA;AAE7B,KAAK,QAAQ,GAAG,aAAa,CAAC,GAAG,EAAE,GAAG,CAAC,CAAA;AAEvC,MAAM,MAAM,YAAY,GAAG,MAAM,QAAQ,CAAA;AAIzC,wBAAgB,aAAa,CAAC,GAAG,EAAE,QAAQ,EAAE,OAAO,EAAE,YAAY,QAQjE;AAED,wBAAgB,QAAQ,CAAC,GAAG,EAAE,QAAQ,WAErC;AAED,wBAAgB,QAAQ,CAAC,GAAG,SAAS,gBAAgB,GAAG,gBAAgB,EAAE,GAAG,EAAE,QAAQ,GAOtD,QAAQ,GAAG;IAAE,QAAQ,EAAE,EAA6B,CAAA;CAAE,CACtF;AAED,wBAAgB,eAAe,CAAC,GAAG,EAAE,QAAQ,gBAQ5C;AAED,wBAAgB,WAAW,aAE1B"}

package/dist/story.registry.js

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

package/dist/story.registry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"story.registry.js","sourceRoot":"","sources":["../src/story.registry.ts"],"names":[],"mappings":"AAkBA,MAAM,QAAQ,GAAG,IAAI,GAAG,EAA0B,CAAA;AAElD,MAAM,UAAU,aAAa,CAAC,GAAa,EAAE,OAAqB;IAChE,IAAI,CAAC,GAAG,IAAI,OAAO,GAAG,KAAK,QAAQ,EAAE,CAAC;QACpC,MAAM,IAAI,KAAK,CAAC,+CAA+C,CAAC,CAAA;IAClE,CAAC;IACD,IAAI,OAAO,OAAO,KAAK,UAAU,EAAE,CAAC;QAClC,MAAM,IAAI,KAAK,CAAC,2CAA2C,CAAC,CAAA;IAC9D,CAAC;IACD,QAAQ,CAAC,GAAG,CAAC,GAAG,EAAE,OAAO,CAAC,CAAA;AAC5B,CAAC;AAED,MAAM,UAAU,QAAQ,CAAC,GAAa;IACpC,OAAO,QAAQ,CAAC,GAAG,CAAC,GAAG,CAAC,CAAA;AAC1B,CAAC;AAED,MAAM,UAAU,QAAQ,CAAkD,GAAa;IACrF,MAAM,OAAO,GAAG,QAAQ,CAAC,GAAG,CAAC,GAAG,CAAC,CAAA;IACjC,IAAI,CAAC,OAAO,EAAE,CAAC;QACb,MAAM,IAAI,KAAK,CACb,UAAU,GAAG,kEAAkE,GAAG,6BAA6B,CAChH,CAAA;IACH,CAAC;IACD,OAAO,OAAO,EAAuE,CAAA;AACvF,CAAC;AAED,MAAM,UAAU,eAAe,CAAC,GAAa;IAC3C,MAAM,OAAO,GAAG,QAAQ,CAAC,GAAG,CAAC,GAAG,CAAC,CAAA;IACjC,IAAI,CAAC,OAAO,EAAE,CAAC;QACb,MAAM,IAAI,KAAK,CACb,UAAU,GAAG,kEAAkE,GAAG,6BAA6B,CAChH,CAAA;IACH,CAAC;IACD,OAAO,OAAO,CAAA;AAChB,CAAC;AAED,MAAM,UAAU,WAAW;IACzB,OAAO,KAAK,CAAC,IAAI,CAAC,QAAQ,CAAC,IAAI,EAAE,CAAC,CAAA;AACpC,CAAC","sourcesContent":["import type { StoryEnvironment } from \"./story.config\"\nimport type { StoryInstance } from \"./story.builder\"\n\n/**\n * Global registry for stories, similar to Inngest's function registry.\n *\n * Goals:\n * - `createStory(\"key\")` can be called many times (module reloads, tests, etc.)\n * - Execution resolves a story by key (`getStory(\"key\")`) instead of importing the module directly.\n * - Registration is intentionally **runtime-local** (per process / per serverless instance).\n */\n\nexport type StoryKey = string\n\ntype AnyStory = StoryInstance<any, any>\n\nexport type StoryFactory = () => AnyStory\n\nconst registry = new Map<StoryKey, StoryFactory>()\n\nexport function registerStory(key: StoryKey, factory: StoryFactory) {\n  if (!key || typeof key !== \"string\") {\n    throw new Error(\"registerStory: key must be a non-empty string\")\n  }\n  if (typeof factory !== \"function\") {\n    throw new Error(\"registerStory: factory must be a function\")\n  }\n  registry.set(key, factory)\n}\n\nexport function hasStory(key: StoryKey) {\n  return registry.has(key)\n}\n\nexport function getStory<Env extends StoryEnvironment = StoryEnvironment>(key: StoryKey) {\n  const factory = registry.get(key)\n  if (!factory) {\n    throw new Error(\n      `Story \"${key}\" is not registered. Ensure the module that calls createStory(\"${key}\") is imported during boot.`,\n    )\n  }\n  return factory() as unknown as AnyStory & { __config: { /* keep typings stable */ } }\n}\n\nexport function getStoryFactory(key: StoryKey) {\n  const factory = registry.get(key)\n  if (!factory) {\n    throw new Error(\n      `Story \"${key}\" is not registered. Ensure the module that calls createStory(\"${key}\") is imported during boot.`,\n    )\n  }\n  return factory\n}\n\nexport function listStories() {\n  return Array.from(registry.keys())\n}\n\n\n"]}

package/dist/story.store.d.ts

@@ -0,0 +1,59 @@
+import type { ModelMessage } from "ai";
+/**
+ * ## story.store.ts
+ *
+ * A `StoryStore` is the persistence boundary for stories.
+ *
+ * Workflow DevKit constraints mean **workflows must be deterministic** and all I/O must happen
+ * in steps. This library therefore models persistence as a pluggable store that can be
+ * instantiated *inside steps* (InstantDB, Postgres, etc.).
+ *
+ * The core engine should depend only on this interface (not on a specific database).
+ */
+export type ContextIdentifier = {
+    id: string;
+    key?: never;
+} | {
+    key: string;
+    id?: never;
+};
+export type ContextStatus = "open" | "streaming" | "closed";
+export type StoredContext<Context> = {
+    id: string;
+    key: string | null;
+    status: ContextStatus;
+    createdAt: Date;
+    updatedAt?: Date;
+    content: Context | null;
+};
+export type ContextEvent = {
+    id: string;
+    type: string;
+    channel: string;
+    createdAt: string;
+    status?: string;
+    content: any;
+};
+export type ExecutionStatus = "executing" | "completed" | "failed";
+export interface StoryStore {
+    getOrCreateContext<C>(contextIdentifier: ContextIdentifier | null): Promise<StoredContext<C>>;
+    getContext<C>(contextIdentifier: ContextIdentifier): Promise<StoredContext<C> | null>;
+    updateContextContent<C>(contextIdentifier: ContextIdentifier, content: C): Promise<StoredContext<C>>;
+    updateContextStatus(contextIdentifier: ContextIdentifier, status: ContextStatus): Promise<void>;
+    saveEvent(contextIdentifier: ContextIdentifier, event: ContextEvent): Promise<ContextEvent>;
+    updateEvent(eventId: string, event: ContextEvent): Promise<ContextEvent>;
+    getEvent(eventId: string): Promise<ContextEvent | null>;
+    getEvents(contextIdentifier: ContextIdentifier): Promise<ContextEvent[]>;
+    createExecution(contextIdentifier: ContextIdentifier, triggerEventId: string, reactionEventId: string): Promise<{
+        id: string;
+    }>;
+    completeExecution(contextIdentifier: ContextIdentifier, executionId: string, status: Exclude<ExecutionStatus, "executing">): Promise<void>;
+    /**
+     * Converts events to model messages for the next LLM call.
+     *
+     * NOTE:
+     * - Attachment/document expansion should happen earlier in the Story loop via `expandEvents(...)`.
+     * - This method should stay focused on converting already-normalized event parts into `ModelMessage[]`.
+     */
+    eventsToModelMessages(events: ContextEvent[]): Promise<ModelMessage[]>;
+}

package/dist/story.store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"story.store.d.ts","sourceRoot":"","sources":["../src/story.store.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,IAAI,CAAA;AAEtC;;;;;;;;;;GAUG;AAEH,MAAM,MAAM,iBAAiB,GAAG;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,GAAG,CAAC,EAAE,KAAK,CAAA;CAAE,GAAG;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,EAAE,CAAC,EAAE,KAAK,CAAA;CAAE,CAAA;AAEzF,MAAM,MAAM,aAAa,GAAG,MAAM,GAAG,WAAW,GAAG,QAAQ,CAAA;AAE3D,MAAM,MAAM,aAAa,CAAC,OAAO,IAAI;IACnC,EAAE,EAAE,MAAM,CAAA;IACV,GAAG,EAAE,MAAM,GAAG,IAAI,CAAA;IAClB,MAAM,EAAE,aAAa,CAAA;IACrB,SAAS,EAAE,IAAI,CAAA;IACf,SAAS,CAAC,EAAE,IAAI,CAAA;IAChB,OAAO,EAAE,OAAO,GAAG,IAAI,CAAA;CACxB,CAAA;AAED,MAAM,MAAM,YAAY,GAAG;IACzB,EAAE,EAAE,MAAM,CAAA;IACV,IAAI,EAAE,MAAM,CAAA;IACZ,OAAO,EAAE,MAAM,CAAA;IACf,SAAS,EAAE,MAAM,CAAA;IACjB,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,OAAO,EAAE,GAAG,CAAA;CACb,CAAA;AAED,MAAM,MAAM,eAAe,GAAG,WAAW,GAAG,WAAW,GAAG,QAAQ,CAAA;AAElE,MAAM,WAAW,UAAU;IACzB,kBAAkB,CAAC,CAAC,EAAE,iBAAiB,EAAE,iBAAiB,GAAG,IAAI,GAAG,OAAO,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,CAAA;IAC7F,UAAU,CAAC,CAAC,EAAE,iBAAiB,EAAE,iBAAiB,GAAG,OAAO,CAAC,aAAa,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,CAAA;IACrF,oBAAoB,CAAC,CAAC,EAAE,iBAAiB,EAAE,iBAAiB,EAAE,OAAO,EAAE,CAAC,GAAG,OAAO,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,CAAA;IACpG,mBAAmB,CAAC,iBAAiB,EAAE,iBAAiB,EAAE,MAAM,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IAE/F,SAAS,CAAC,iBAAiB,EAAE,iBAAiB,EAAE,KAAK,EAAE,YAAY,GAAG,OAAO,CAAC,YAAY,CAAC,CAAA;IAC3F,WAAW,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,YAAY,GAAG,OAAO,CAAC,YAAY,CAAC,CAAA;IACxE,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,GAAG,IAAI,CAAC,CAAA;IACvD,SAAS,CAAC,iBAAiB,EAAE,iBAAiB,GAAG,OAAO,CAAC,YAAY,EAAE,CAAC,CAAA;IAExE,eAAe,CACb,iBAAiB,EAAE,iBAAiB,EACpC,cAAc,EAAE,MAAM,EACtB,eAAe,EAAE,MAAM,GACtB,OAAO,CAAC;QAAE,EAAE,EAAE,MAAM,CAAA;KAAE,CAAC,CAAA;IAE1B,iBAAiB,CACf,iBAAiB,EAAE,iBAAiB,EACpC,WAAW,EAAE,MAAM,EACnB,MAAM,EAAE,OAAO,CAAC,eAAe,EAAE,WAAW,CAAC,GAC5C,OAAO,CAAC,IAAI,CAAC,CAAA;IAEhB;;;;;;OAMG;IACH,qBAAqB,CAAC,MAAM,EAAE,YAAY,EAAE,GAAG,OAAO,CAAC,YAAY,EAAE,CAAC,CAAA;CACvE"}

package/dist/story.store.js

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

package/dist/story.store.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"story.store.js","sourceRoot":"","sources":["../src/story.store.ts"],"names":[],"mappings":"","sourcesContent":["import type { ModelMessage } from \"ai\"\r\n\r\n/**\r\n * ## story.store.ts\r\n *\r\n * A `StoryStore` is the persistence boundary for stories.\r\n *\r\n * Workflow DevKit constraints mean **workflows must be deterministic** and all I/O must happen\r\n * in steps. This library therefore models persistence as a pluggable store that can be\r\n * instantiated *inside steps* (InstantDB, Postgres, etc.).\r\n *\r\n * The core engine should depend only on this interface (not on a specific database).\r\n */\r\n\r\nexport type ContextIdentifier = { id: string; key?: never } | { key: string; id?: never }\r\n\r\nexport type ContextStatus = \"open\" | \"streaming\" | \"closed\"\r\n\r\nexport type StoredContext<Context> = {\r\n  id: string\r\n  key: string | null\r\n  status: ContextStatus\r\n  createdAt: Date\r\n  updatedAt?: Date\r\n  content: Context | null\r\n}\r\n\r\nexport type ContextEvent = {\r\n  id: string\r\n  type: string\r\n  channel: string\r\n  createdAt: string\r\n  status?: string\r\n  content: any\r\n}\r\n\r\nexport type ExecutionStatus = \"executing\" | \"completed\" | \"failed\"\r\n\r\nexport interface StoryStore {\r\n  getOrCreateContext<C>(contextIdentifier: ContextIdentifier | null): Promise<StoredContext<C>>\r\n  getContext<C>(contextIdentifier: ContextIdentifier): Promise<StoredContext<C> | null>\r\n  updateContextContent<C>(contextIdentifier: ContextIdentifier, content: C): Promise<StoredContext<C>>\r\n  updateContextStatus(contextIdentifier: ContextIdentifier, status: ContextStatus): Promise<void>\r\n\r\n  saveEvent(contextIdentifier: ContextIdentifier, event: ContextEvent): Promise<ContextEvent>\r\n  updateEvent(eventId: string, event: ContextEvent): Promise<ContextEvent>\r\n  getEvent(eventId: string): Promise<ContextEvent | null>\r\n  getEvents(contextIdentifier: ContextIdentifier): Promise<ContextEvent[]>\r\n\r\n  createExecution(\r\n    contextIdentifier: ContextIdentifier,\r\n    triggerEventId: string,\r\n    reactionEventId: string,\r\n  ): Promise<{ id: string }>\r\n\r\n  completeExecution(\r\n    contextIdentifier: ContextIdentifier,\r\n    executionId: string,\r\n    status: Exclude<ExecutionStatus, \"executing\">,\r\n  ): Promise<void>\r\n\r\n  /**\r\n   * Converts events to model messages for the next LLM call.\r\n   *\r\n   * NOTE:\r\n   * - Attachment/document expansion should happen earlier in the Story loop via `expandEvents(...)`.\r\n   * - This method should stay focused on converting already-normalized event parts into `ModelMessage[]`.\r\n   */\r\n  eventsToModelMessages(events: ContextEvent[]): Promise<ModelMessage[]>\r\n}\r\n\r\n\r\n\r\n"]}

package/dist/story.streams.d.ts

@@ -0,0 +1,55 @@
+import type { DataStreamWriter } from "./story.engine";
+/**
+ * Filters internal chunks from the AI SDK stream that we use for loop control.
+ *
+ * In the engine, when we do `result.toUIMessageStream(...).pipeThrough(...)`,
+ * this filter prevents the final consumer from seeing events like:
+ * - `start-step` / `finish-step`: iteration control
+ * - `start` / `finish`: underlying stream control
+ *
+ * Note: we *do* keep emitting other custom chunks (e.g. `event-start`,
+ * `tool-output-*`, `data-context-id`) because they are useful for UI/observability.
+ */
+export declare function createInternalChunkFilter(): TransformStream<any, any>;
+/**
+ * Normalizes the start of the stream so the consumer receives a `start` with a
+ * consistent `messageId`.
+ *
+ * - Filters the original AI SDK `start` chunk (if it appears).
+ * - Converts our internal `event-start` chunk into:
+ *   `{ type: "start", messageId: <eventId> }`
+ *
+ * This allows the UI to associate the stream to a stable “reaction event” ID
+ * (created by the engine) instead of relying on IDs generated by the SDK.
+ */
+export declare function createStreamStartNormalizer(): TransformStream<any, any>;
+/**
+ * Helpers for writing control/metadata chunks.
+ *
+ * These helpers encapsulate the exact chunk shapes so that:
+ * - `story.engine.ts` reads like orchestration (“what”) instead of plumbing (“how”),
+ * - we can evolve chunk formats in a single place if the SDK/UI changes.
+ */
+export declare const StreamWriter: {
+    /**
+     * Internal signal: “reaction event started”.
+     * Later used by `createStreamStartNormalizer()` to emit `start/messageId`.
+     */
+    writeEventStart(dataStream: DataStreamWriter, eventId: string): void;
+    /** Internal signal: start of a loop iteration. */
+    writeStartStep(dataStream: DataStreamWriter): void;
+    /** Internal signal: end of a loop iteration. */
+    writeFinishStep(dataStream: DataStreamWriter): void;
+    /** Useful metadata for UI/observability: current `contextId`. */
+    writeContextId(dataStream: DataStreamWriter, contextId: string): void;
+    /** Successful tool result, associated to `toolCallId`. */
+    writeToolOutputAvailable(dataStream: DataStreamWriter, toolCallId: string, output: unknown): void;
+    /** Failed tool result, associated to `toolCallId`. */
+    writeToolOutputError(dataStream: DataStreamWriter, toolCallId: string, errorText: string): void;
+    /**
+     * Internal signal: terminate the stream/loop.
+     * `override=true` is used when we want to cut immediately.
+     */
+    writeFinish(dataStream: DataStreamWriter, override?: boolean): void;
+};
+//# sourceMappingURL=story.streams.d.ts.map

package/dist/story.streams.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"story.streams.d.ts","sourceRoot":"","sources":["../src/story.streams.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAA;AAyCtD;;;;;;;;;;GAUG;AACH,wBAAgB,yBAAyB,8BAOxC;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,2BAA2B,8BAW1C;AAED;;;;;;GAMG;AACH,eAAO,MAAM,YAAY;IACvB;;;OAGG;gCACyB,gBAAgB,WAAW,MAAM;IAG7D,kDAAkD;+BACvB,gBAAgB;IAG3C,gDAAgD;gCACpB,gBAAgB;IAG5C,iEAAiE;+BACtC,gBAAgB,aAAa,MAAM;IAG9D,0DAA0D;yCACrB,gBAAgB,cAAc,MAAM,UAAU,OAAO;IAK1F,sDAAsD;qCACrB,gBAAgB,cAAc,MAAM,aAAa,MAAM;IAGxF;;;OAGG;4BACqB,gBAAgB;CAGzC,CAAA"}

package/dist/story.streams.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StreamWriter = void 0;
+exports.createInternalChunkFilter = createInternalChunkFilter;
+exports.createStreamStartNormalizer = createStreamStartNormalizer;
+const INTERNAL_CHUNK_TYPES = [
+    "start",
+    "finish-step",
+    "start-step",
+    "finish",
+];
+/**
+ * Filters internal chunks from the AI SDK stream that we use for loop control.
+ *
+ * In the engine, when we do `result.toUIMessageStream(...).pipeThrough(...)`,
+ * this filter prevents the final consumer from seeing events like:
+ * - `start-step` / `finish-step`: iteration control
+ * - `start` / `finish`: underlying stream control
+ *
+ * Note: we *do* keep emitting other custom chunks (e.g. `event-start`,
+ * `tool-output-*`, `data-context-id`) because they are useful for UI/observability.
+ */
+function createInternalChunkFilter() {
+    return new TransformStream({
+        transform(chunk, controller) {
+            if (INTERNAL_CHUNK_TYPES.includes(chunk.type))
+                return;
+            controller.enqueue(chunk);
+        },
+    });
+}
+/**
+ * Normalizes the start of the stream so the consumer receives a `start` with a
+ * consistent `messageId`.
+ *
+ * - Filters the original AI SDK `start` chunk (if it appears).
+ * - Converts our internal `event-start` chunk into:
+ *   `{ type: "start", messageId: <eventId> }`
+ *
+ * This allows the UI to associate the stream to a stable “reaction event” ID
+ * (created by the engine) instead of relying on IDs generated by the SDK.
+ */
+function createStreamStartNormalizer() {
+    return new TransformStream({
+        transform(chunk, controller) {
+            if (chunk.type === "start")
+                return;
+            if (chunk.type === "event-start") {
+                controller.enqueue({ type: "start", messageId: chunk.data.eventId });
+                return;
+            }
+            controller.enqueue(chunk);
+        },
+    });
+}
+/**
+ * Helpers for writing control/metadata chunks.
+ *
+ * These helpers encapsulate the exact chunk shapes so that:
+ * - `story.engine.ts` reads like orchestration (“what”) instead of plumbing (“how”),
+ * - we can evolve chunk formats in a single place if the SDK/UI changes.
+ */
+exports.StreamWriter = {
+    /**
+     * Internal signal: “reaction event started”.
+     * Later used by `createStreamStartNormalizer()` to emit `start/messageId`.
+     */
+    writeEventStart(dataStream, eventId) {
+        dataStream.write({ type: "event-start", data: { eventId } });
+    },
+    /** Internal signal: start of a loop iteration. */
+    writeStartStep(dataStream) {
+        dataStream.write({ type: "start-step" });
+    },
+    /** Internal signal: end of a loop iteration. */
+    writeFinishStep(dataStream) {
+        dataStream.write({ type: "finish-step" });
+    },
+    /** Useful metadata for UI/observability: current `contextId`. */
+    writeContextId(dataStream, contextId) {
+        dataStream.write({ type: "data-context-id", data: { contextId } });
+    },
+    /** Successful tool result, associated to `toolCallId`. */
+    writeToolOutputAvailable(dataStream, toolCallId, output) {
+        dataStream.write({ type: "tool-output-available", toolCallId, output });
+    },
+    /** Failed tool result, associated to `toolCallId`. */
+    writeToolOutputError(dataStream, toolCallId, errorText) {
+        dataStream.write({ type: "tool-output-error", toolCallId, errorText });
+    },
+    /**
+     * Internal signal: terminate the stream/loop.
+     * `override=true` is used when we want to cut immediately.
+     */
+    writeFinish(dataStream, override = false) {
+        dataStream.write({ type: "finish", override });
+    },
+};
+//# sourceMappingURL=story.streams.js.map

package/dist/story.streams.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"story.streams.js","sourceRoot":"","sources":["../src/story.streams.ts"],"names":[],"mappings":";;;AAoDA,8DAOC;AAaD,kEAWC;AAjDD,MAAM,oBAAoB,GAAwB;IAChD,OAAO;IACP,aAAa;IACb,YAAY;IACZ,QAAQ;CACT,CAAA;AAED;;;;;;;;;;GAUG;AACH,SAAgB,yBAAyB;IACvC,OAAO,IAAI,eAAe,CAAC;QACzB,SAAS,CAAC,KAAU,EAAE,UAAe;YACnC,IAAI,oBAAoB,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAyB,CAAC;gBAAE,OAAM;YAC1E,UAAU,CAAC,OAAO,CAAC,KAAY,CAAC,CAAA;QAClC,CAAC;KACF,CAAC,CAAA;AACJ,CAAC;AAED;;;;;;;;;;GAUG;AACH,SAAgB,2BAA2B;IACzC,OAAO,IAAI,eAAe,CAAC;QACzB,SAAS,CAAC,KAAU,EAAE,UAAe;YACnC,IAAI,KAAK,CAAC,IAAI,KAAK,OAAO;gBAAE,OAAM;YAClC,IAAI,KAAK,CAAC,IAAI,KAAK,aAAa,EAAE,CAAC;gBACjC,UAAU,CAAC,OAAO,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,SAAS,EAAE,KAAK,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC,CAAA;gBACpE,OAAM;YACR,CAAC;YACD,UAAU,CAAC,OAAO,CAAC,KAAY,CAAC,CAAA;QAClC,CAAC;KACF,CAAC,CAAA;AACJ,CAAC;AAED;;;;;;GAMG;AACU,QAAA,YAAY,GAAG;IAC1B;;;OAGG;IACH,eAAe,CAAC,UAA4B,EAAE,OAAe;QAC3D,UAAU,CAAC,KAAK,CAAC,EAAE,IAAI,EAAE,aAAa,EAAE,IAAI,EAAE,EAAE,OAAO,EAAE,EAAS,CAAC,CAAA;IACrE,CAAC;IACD,kDAAkD;IAClD,cAAc,CAAC,UAA4B;QACzC,UAAU,CAAC,KAAK,CAAC,EAAE,IAAI,EAAE,YAAY,EAAS,CAAC,CAAA;IACjD,CAAC;IACD,gDAAgD;IAChD,eAAe,CAAC,UAA4B;QAC1C,UAAU,CAAC,KAAK,CAAC,EAAE,IAAI,EAAE,aAAa,EAAS,CAAC,CAAA;IAClD,CAAC;IACD,iEAAiE;IACjE,cAAc,CAAC,UAA4B,EAAE,SAAiB;QAC5D,UAAU,CAAC,KAAK,CAAC,EAAE,IAAI,EAAE,iBAAiB,EAAE,IAAI,EAAE,EAAE,SAAS,EAAE,EAAS,CAAC,CAAA;IAC3E,CAAC;IACD,0DAA0D;IAC1D,wBAAwB,CAAC,UAA4B,EAAE,UAAkB,EAAE,MAAe;QACxF,UAAU,CAAC,KAAK,CACd,EAAE,IAAI,EAAE,uBAAuB,EAAE,UAAU,EAAE,MAAM,EAAS,CAC7D,CAAA;IACH,CAAC;IACD,sDAAsD;IACtD,oBAAoB,CAAC,UAA4B,EAAE,UAAkB,EAAE,SAAiB;QACtF,UAAU,CAAC,KAAK,CAAC,EAAE,IAAI,EAAE,mBAAmB,EAAE,UAAU,EAAE,SAAS,EAAS,CAAC,CAAA;IAC/E,CAAC;IACD;;;OAGG;IACH,WAAW,CAAC,UAA4B,EAAE,QAAQ,GAAG,KAAK;QACxD,UAAU,CAAC,KAAK,CAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,QAAQ,EAAS,CAAC,CAAA;IACvD,CAAC;CACF,CAAA","sourcesContent":["import type { DataStreamWriter } from \"./story.engine\"\r\n\r\n/**\r\n * ## story.streams.ts\r\n *\r\n * This module exists to **intercept** the stream produced by `ai` (AI SDK)\r\n * (`toUIMessageStream()` / `createUIMessageStream()`) and **extend it** with\r\n * control chunks that allow us to **orchestrate an execution loop**\r\n * (multiple steps with tools) without “polluting” the public stream that clients consume.\r\n *\r\n * ### What problem does it solve?\r\n * In `story.engine.ts` we need to:\r\n * - Keep the output stream “clean” (only user-relevant tokens/messages).\r\n * - While still emitting internal signals to:\r\n *   - mark the start of a “reaction event” (a stable messageId),\r\n *   - mark the start/end of each loop iteration,\r\n *   - publish metadata (e.g. `contextId`),\r\n *   - publish tool results (`tool-output-*`),\r\n *   - terminate the loop and/or the stream at the right time.\r\n *\r\n * To achieve this, we **write internal chunks** into the `DataStreamWriter` and then:\r\n * - filter control-only chunks before exposing the stream,\r\n * - normalize “start” so the consumer receives a consistent `messageId`.\r\n *\r\n * ### Stream mental model\r\n * - **Internal stream**: AI SDK chunks + our internal chunks mixed together.\r\n * - **Public stream**: internal stream piped through transforms (filter + normalization).\r\n *\r\n * > Important: this is deliberately “thin”. It doesn't decide anything about the loop;\r\n * > it only provides utilities to *instrument* the stream.\r\n */\r\n\r\ntype InternalChunkType = \"start\" | \"finish-step\" | \"start-step\" | \"finish\"\r\n\r\nconst INTERNAL_CHUNK_TYPES: InternalChunkType[] = [\r\n  \"start\",\r\n  \"finish-step\",\r\n  \"start-step\",\r\n  \"finish\",\r\n]\r\n\r\n/**\r\n * Filters internal chunks from the AI SDK stream that we use for loop control.\r\n *\r\n * In the engine, when we do `result.toUIMessageStream(...).pipeThrough(...)`,\r\n * this filter prevents the final consumer from seeing events like:\r\n * - `start-step` / `finish-step`: iteration control\r\n * - `start` / `finish`: underlying stream control\r\n *\r\n * Note: we *do* keep emitting other custom chunks (e.g. `event-start`,\r\n * `tool-output-*`, `data-context-id`) because they are useful for UI/observability.\r\n */\r\nexport function createInternalChunkFilter() {\r\n  return new TransformStream({\r\n    transform(chunk: any, controller: any) {\r\n      if (INTERNAL_CHUNK_TYPES.includes(chunk.type as InternalChunkType)) return\r\n      controller.enqueue(chunk as any)\r\n    },\r\n  })\r\n}\r\n\r\n/**\r\n * Normalizes the start of the stream so the consumer receives a `start` with a\r\n * consistent `messageId`.\r\n *\r\n * - Filters the original AI SDK `start` chunk (if it appears).\r\n * - Converts our internal `event-start` chunk into:\r\n *   `{ type: \"start\", messageId: <eventId> }`\r\n *\r\n * This allows the UI to associate the stream to a stable “reaction event” ID\r\n * (created by the engine) instead of relying on IDs generated by the SDK.\r\n */\r\nexport function createStreamStartNormalizer() {\r\n  return new TransformStream({\r\n    transform(chunk: any, controller: any) {\r\n      if (chunk.type === \"start\") return\r\n      if (chunk.type === \"event-start\") {\r\n        controller.enqueue({ type: \"start\", messageId: chunk.data.eventId })\r\n        return\r\n      }\r\n      controller.enqueue(chunk as any)\r\n    },\r\n  })\r\n}\r\n\r\n/**\r\n * Helpers for writing control/metadata chunks.\r\n *\r\n * These helpers encapsulate the exact chunk shapes so that:\r\n * - `story.engine.ts` reads like orchestration (“what”) instead of plumbing (“how”),\r\n * - we can evolve chunk formats in a single place if the SDK/UI changes.\r\n */\r\nexport const StreamWriter = {\r\n  /**\r\n   * Internal signal: “reaction event started”.\r\n   * Later used by `createStreamStartNormalizer()` to emit `start/messageId`.\r\n   */\r\n  writeEventStart(dataStream: DataStreamWriter, eventId: string) {\r\n    dataStream.write({ type: \"event-start\", data: { eventId } } as any)\r\n  },\r\n  /** Internal signal: start of a loop iteration. */\r\n  writeStartStep(dataStream: DataStreamWriter) {\r\n    dataStream.write({ type: \"start-step\" } as any)\r\n  },\r\n  /** Internal signal: end of a loop iteration. */\r\n  writeFinishStep(dataStream: DataStreamWriter) {\r\n    dataStream.write({ type: \"finish-step\" } as any)\r\n  },\r\n  /** Useful metadata for UI/observability: current `contextId`. */\r\n  writeContextId(dataStream: DataStreamWriter, contextId: string) {\r\n    dataStream.write({ type: \"data-context-id\", data: { contextId } } as any)\r\n  },\r\n  /** Successful tool result, associated to `toolCallId`. */\r\n  writeToolOutputAvailable(dataStream: DataStreamWriter, toolCallId: string, output: unknown) {\r\n    dataStream.write(\r\n      { type: \"tool-output-available\", toolCallId, output } as any,\r\n    )\r\n  },\r\n  /** Failed tool result, associated to `toolCallId`. */\r\n  writeToolOutputError(dataStream: DataStreamWriter, toolCallId: string, errorText: string) {\r\n    dataStream.write({ type: \"tool-output-error\", toolCallId, errorText } as any)\r\n  },\r\n  /**\r\n   * Internal signal: terminate the stream/loop.\r\n   * `override=true` is used when we want to cut immediately.\r\n   */\r\n  writeFinish(dataStream: DataStreamWriter, override = false) {\r\n    dataStream.write({ type: \"finish\", override } as any)\r\n  },\r\n}\r\n\r\n\r\n"]}

package/dist/story.toolcalls.d.ts

@@ -0,0 +1,60 @@
+/**
+ * ## story.toolcalls.ts
+ *
+ * This module isolates the **tool-call plumbing** used by `story.engine.ts`.
+ *
+ * In our runtime, tool calls are represented as **event parts** produced by the AI SDK.
+ * The engine needs to:
+ * - extract a normalized list of tool calls from `event.content.parts`, and
+ * - merge tool execution outcomes back into those parts (so the persisted event reflects
+ *   `output-available` / `output-error`, etc.).
+ *
+ * Keeping this logic here helps `story.engine.ts` read like orchestration, and keeps
+ * these transformations testable and reusable.
+ */
+import type { ContextEvent } from "./story.store";
+export type ToolCall = {
+    toolCallId: string;
+    toolName: string;
+    args: any;
+};
+/**
+ * Extracts tool calls from an event's `parts` array.
+ *
+ * Expected part shape (loosely):
+ * - `type`: string like `"tool-<toolName>"`
+ * - `toolCallId`: string
+ * - `input`: any (tool args)
+ *
+ * We intentionally treat the input as `any` because the part schema is produced by the AI SDK.
+ */
+export declare function extractToolCallsFromParts(parts: any[] | undefined | null): ToolCall[];
+/**
+ * Applies a tool execution outcome to the matching tool part.
+ *
+ * This does not mutate `parts` — it returns a new array.
+ *
+ * We match the tool part by:
+ * - `type === "tool-<toolName>"` and
+ * - `toolCallId` equality
+ *
+ * Then we set:
+ * - on success: `{ state: "output-available", output: <result> }`
+ * - on failure: `{ state: "output-error", errorText: <message> }`
+ */
+export declare function applyToolExecutionResultToParts(parts: any[], toolCall: Pick<ToolCall, "toolCallId" | "toolName">, execution: {
+    success: boolean;
+    result: any;
+    message?: string;
+}): any[];
+/**
+ * Returns `true` when a given tool has a **settled** execution result in an event's parts.
+ *
+ * We treat a tool part as "executed" once it has either:
+ * - `state: "output-available"` (success), or
+ * - `state: "output-error"` (failure).
+ *
+ * This is useful for stop/continue logic in `story.shouldContinue(...)` where you want to
+ * decide based on the persisted `reactionEvent` (not ephemeral in-memory arrays).
+ */
+export declare function didToolExecute(event: Pick<ContextEvent, "content">, toolName: string): boolean;

package/dist/story.toolcalls.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"story.toolcalls.d.ts","sourceRoot":"","sources":["../src/story.toolcalls.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,MAAM,MAAM,QAAQ,GAAG;IACrB,UAAU,EAAE,MAAM,CAAA;IAClB,QAAQ,EAAE,MAAM,CAAA;IAChB,IAAI,EAAE,GAAG,CAAA;CACV,CAAA;AAED;;;;;;;;;GASG;AACH,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,GAAG,EAAE,GAAG,SAAS,GAAG,IAAI,GAAG,QAAQ,EAAE,CASrF;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,+BAA+B,CAC7C,KAAK,EAAE,GAAG,EAAE,EACZ,QAAQ,EAAE,IAAI,CAAC,QAAQ,EAAE,YAAY,GAAG,UAAU,CAAC,EACnD,SAAS,EAAE;IAAE,OAAO,EAAE,OAAO,CAAC;IAAC,MAAM,EAAE,GAAG,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAA;CAAE,GAC7D,GAAG,EAAE,CAUP"}

package/dist/story.toolcalls.js

@@ -0,0 +1,73 @@
+/**
+ * ## story.toolcalls.ts
+ *
+ * This module isolates the **tool-call plumbing** used by `story.engine.ts`.
+ *
+ * In our runtime, tool calls are represented as **event parts** produced by the AI SDK.
+ * The engine needs to:
+ * - extract a normalized list of tool calls from `event.content.parts`, and
+ * - merge tool execution outcomes back into those parts (so the persisted event reflects
+ *   `output-available` / `output-error`, etc.).
+ *
+ * Keeping this logic here helps `story.engine.ts` read like orchestration, and keeps
+ * these transformations testable and reusable.
+ */
+/**
+ * Extracts tool calls from an event's `parts` array.
+ *
+ * Expected part shape (loosely):
+ * - `type`: string like `"tool-<toolName>"`
+ * - `toolCallId`: string
+ * - `input`: any (tool args)
+ *
+ * We intentionally treat the input as `any` because the part schema is produced by the AI SDK.
+ */
+export function extractToolCallsFromParts(parts) {
+    const safeParts = parts ?? [];
+    return safeParts.reduce((acc, p) => {
+        if (typeof p?.type === "string" && p.type.startsWith("tool-")) {
+            const toolName = p.type.split("-")[1];
+            acc.push({ toolCallId: p.toolCallId, toolName, args: p.input });
+        }
+        return acc;
+    }, []);
+}
+/**
+ * Applies a tool execution outcome to the matching tool part.
+ *
+ * This does not mutate `parts` — it returns a new array.
+ *
+ * We match the tool part by:
+ * - `type === "tool-<toolName>"` and
+ * - `toolCallId` equality
+ *
+ * Then we set:
+ * - on success: `{ state: "output-available", output: <result> }`
+ * - on failure: `{ state: "output-error", errorText: <message> }`
+ */
+export function applyToolExecutionResultToParts(parts, toolCall, execution) {
+    return parts.map((p) => {
+        if (p?.type === `tool-${toolCall.toolName}` && p.toolCallId === toolCall.toolCallId) {
+            if (execution.success) {
+                return { ...p, state: "output-available", output: execution.result };
+            }
+            return { ...p, state: "output-error", errorText: String(execution.message || "Error") };
+        }
+        return p;
+    });
+}
+/**
+ * Returns `true` when a given tool has a **settled** execution result in an event's parts.
+ *
+ * We treat a tool part as "executed" once it has either:
+ * - `state: "output-available"` (success), or
+ * - `state: "output-error"` (failure).
+ *
+ * This is useful for stop/continue logic in `story.shouldContinue(...)` where you want to
+ * decide based on the persisted `reactionEvent` (not ephemeral in-memory arrays).
+ */
+export function didToolExecute(event, toolName) {
+    const parts = event.content.parts;
+    return parts.some((p) => p.type === `tool-${toolName}` &&
+        (p.state === "output-available" || p.state === "output-error"));
+}

package/dist/story.toolcalls.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"story.toolcalls.js","sourceRoot":"","sources":["../src/story.toolcalls.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAQH;;;;;;;;;GASG;AACH,MAAM,UAAU,yBAAyB,CAAC,KAA+B;IACvE,MAAM,SAAS,GAAG,KAAK,IAAI,EAAE,CAAA;IAC7B,OAAO,SAAS,CAAC,MAAM,CAAC,CAAC,GAAe,EAAE,CAAM,EAAE,EAAE;QAClD,IAAI,OAAO,CAAC,EAAE,IAAI,KAAK,QAAQ,IAAI,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,EAAE,CAAC;YAC9D,MAAM,QAAQ,GAAG,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAA;YACrC,GAAG,CAAC,IAAI,CAAC,EAAE,UAAU,EAAE,CAAC,CAAC,UAAU,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC,CAAC,KAAK,EAAE,CAAC,CAAA;QACjE,CAAC;QACD,OAAO,GAAG,CAAA;IACZ,CAAC,EAAE,EAAE,CAAC,CAAA;AACR,CAAC;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,+BAA+B,CAC7C,KAAY,EACZ,QAAmD,EACnD,SAA8D;IAE9D,OAAO,KAAK,CAAC,GAAG,CAAC,CAAC,CAAM,EAAE,EAAE;QAC1B,IAAI,CAAC,EAAE,IAAI,KAAK,QAAQ,QAAQ,CAAC,QAAQ,EAAE,IAAI,CAAC,CAAC,UAAU,KAAK,QAAQ,CAAC,UAAU,EAAE,CAAC;YACpF,IAAI,SAAS,CAAC,OAAO,EAAE,CAAC;gBACtB,OAAO,EAAE,GAAG,CAAC,EAAE,KAAK,EAAE,kBAAkB,EAAE,MAAM,EAAE,SAAS,CAAC,MAAM,EAAE,CAAA;YACtE,CAAC;YACD,OAAO,EAAE,GAAG,CAAC,EAAE,KAAK,EAAE,cAAc,EAAE,SAAS,EAAE,MAAM,CAAC,SAAS,CAAC,OAAO,IAAI,OAAO,CAAC,EAAE,CAAA;QACzF,CAAC;QACD,OAAO,CAAC,CAAA;IACV,CAAC,CAAC,CAAA;AACJ,CAAC","sourcesContent":["/**\n * ## story.toolcalls.ts\n *\n * This module isolates the **tool-call plumbing** used by `story.engine.ts`.\n *\n * In our runtime, tool calls are represented as **event parts** produced by the AI SDK.\n * The engine needs to:\n * - extract a normalized list of tool calls from `event.content.parts`, and\n * - merge tool execution outcomes back into those parts (so the persisted event reflects\n *   `output-available` / `output-error`, etc.).\n *\n * Keeping this logic here helps `story.engine.ts` read like orchestration, and keeps\n * these transformations testable and reusable.\n */\n\nexport type ToolCall = {\n  toolCallId: string\n  toolName: string\n  args: any\n}\n\n/**\n * Extracts tool calls from an event's `parts` array.\n *\n * Expected part shape (loosely):\n * - `type`: string like `\"tool-<toolName>\"`\n * - `toolCallId`: string\n * - `input`: any (tool args)\n *\n * We intentionally treat the input as `any` because the part schema is produced by the AI SDK.\n */\nexport function extractToolCallsFromParts(parts: any[] | undefined | null): ToolCall[] {\n  const safeParts = parts ?? []\n  return safeParts.reduce((acc: ToolCall[], p: any) => {\n    if (typeof p?.type === \"string\" && p.type.startsWith(\"tool-\")) {\n      const toolName = p.type.split(\"-\")[1]\n      acc.push({ toolCallId: p.toolCallId, toolName, args: p.input })\n    }\n    return acc\n  }, [])\n}\n\n/**\n * Applies a tool execution outcome to the matching tool part.\n *\n * This does not mutate `parts` — it returns a new array.\n *\n * We match the tool part by:\n * - `type === \"tool-<toolName>\"` and\n * - `toolCallId` equality\n *\n * Then we set:\n * - on success: `{ state: \"output-available\", output: <result> }`\n * - on failure: `{ state: \"output-error\", errorText: <message> }`\n */\nexport function applyToolExecutionResultToParts(\n  parts: any[],\n  toolCall: Pick<ToolCall, \"toolCallId\" | \"toolName\">,\n  execution: { success: boolean; result: any; message?: string },\n): any[] {\n  return parts.map((p: any) => {\n    if (p?.type === `tool-${toolCall.toolName}` && p.toolCallId === toolCall.toolCallId) {\n      if (execution.success) {\n        return { ...p, state: \"output-available\", output: execution.result }\n      }\n      return { ...p, state: \"output-error\", errorText: String(execution.message || \"Error\") }\n    }\n    return p\n  })\n}\n\n\n"]}

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(`Story: tool "${name}" is missing inputSchema (required for model tool calls)`);
+        }
+        out[name] = {
+            description: tool?.description,
+            inputSchema: asSchema(inputSchema).jsonSchema,
+        };
+    }
+    return out;
+}

package/dist/workflow.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Workflow DevKit interop helper.
+ *
+ * In some environments / TS setups, the `workflow` package is typed/exported as a default export,
+ * even though runtime usage expects `getWritable()` to exist.
+ *
+ * We centralize that interop here so the rest of the codebase can just do:
+ * `import { getWritable } from "./workflow"`.
+ */
+export declare function getWritable<W = any>(): WritableStream<W>;
+/**
+ * Typed wrapper around Workflow DevKit's `getWritable()`.
+ *
+ * Why:
+ * - The `workflow` package typing in some environments is surfaced as a default export,
+ *   which makes `import { getWritable } from "workflow"` fail typechecking.
+ * - `@ekairos/story` wants to call `getWritable()` inside `"use step"` functions without
+ *   leaking import quirks across the codebase.
+ */
+export declare const getWritable: <W = any>() => WritableStream<W>;

package/dist/workflow.js

@@ -0,0 +1,27 @@
+import workflow from "workflow";
+/**
+ * Workflow DevKit interop helper.
+ *
+ * In some environments / TS setups, the `workflow` package is typed/exported as a default export,
+ * even though runtime usage expects `getWritable()` to exist.
+ *
+ * We centralize that interop here so the rest of the codebase can just do:
+ * `import { getWritable } from "./workflow"`.
+ */
+export function getWritable() {
+    const fn = workflow.getWritable ?? workflow.default?.getWritable;
+    if (typeof fn !== "function") {
+        throw new Error("workflow.getWritable is not available in this runtime");
+    }
+    return fn();
+}
+/**
+ * Typed wrapper around Workflow DevKit's `getWritable()`.
+ *
+ * Why:
+ * - The `workflow` package typing in some environments is surfaced as a default export,
+ *   which makes `import { getWritable } from "workflow"` fail typechecking.
+ * - `@ekairos/story` wants to call `getWritable()` inside `"use step"` functions without
+ *   leaking import quirks across the codebase.
+ */
+export const getWritable = workflow.getWritable;

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@ekairos/story",
-  "version": "1.21.30-beta.0",
+  "version": "1.21.32-beta.0",
   "description": "Pulzar Story - Workflow-based AI Stories",
-  "type": "commonjs",
+  "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "files": [
@@ -20,8 +20,18 @@
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
-      "require": "./dist/index.js",
+      "import": "./dist/index.js",
       "default": "./dist/index.js"
+    },
+    "./runtime": {
+      "types": "./dist/runtime.d.ts",
+      "import": "./dist/runtime.js",
+      "default": "./dist/runtime.js"
+    },
+    "./instant": {
+      "types": "./dist/stores/instant.store.d.ts",
+      "import": "./dist/stores/instant.store.js",
+      "default": "./dist/stores/instant.store.js"
     }
   },
   "scripts": {
@@ -33,7 +43,7 @@
   },
   "dependencies": {
     "@ai-sdk/openai": "^2.0.52",
-    "@ekairos/domain": "^1.21.30-beta.0",
+    "@ekairos/domain": "^1.21.32-beta.0",
     "@instantdb/admin": "^0.22.13",
     "@instantdb/core": "^0.22.13",
     "@vercel/sandbox": "^0.0.23",
@@ -41,6 +51,7 @@
     "ajv": "^8.17.1",
     "braintrust": "^0.3.7",
     "llamaindex": "^0.12.0",
+    "workflow": "4.0.1-beta.13",
     "xmlbuilder2": "^3.1.1",
     "zod": "^4.1.8"
   },