@ekairos/thread 1.21.88-beta.0

package/dist/story.hooks.d.ts

@@ -0,0 +1,21 @@
+export declare function getClientResumeHookUrl(): string | undefined;
+/**
+ * Deterministic hook token for approving an `auto: false` tool call.
+ *
+ * External systems can resume the hook with:
+ * `resumeHook(toolApprovalHookToken({ executionId, toolCallId }), { approved: true })`
+ */
+export declare function toolApprovalHookToken(params: {
+    executionId: string;
+    toolCallId: string;
+}): string;
+/**
+ * Deterministic webhook token for approving an `auto: false` tool call.
+ *
+ * When using Workflow DevKit, the webhook is available at:
+ * `/.well-known/workflow/v1/webhook/:token`
+ */
+export declare function toolApprovalWebhookToken(params: {
+    executionId: string;
+    toolCallId: string;
+}): string;

package/dist/story.hooks.js

@@ -0,0 +1,31 @@
+function stripTrailingSlash(value) {
+    return value.replace(/\/$/, "");
+}
+export function getClientResumeHookUrl() {
+    const direct = process.env.EKAIROS_CLIENT_RESUME_HOOK_URL;
+    if (typeof direct === "string" && direct.trim())
+        return direct.trim();
+    const base = process.env.EKAIROS_CLIENT_BASE_URL;
+    if (typeof base === "string" && base.trim()) {
+        return `${stripTrailingSlash(base.trim())}/api/ekairos/resume-hook`;
+    }
+    return undefined;
+}
+/**
+ * Deterministic hook token for approving an `auto: false` tool call.
+ *
+ * External systems can resume the hook with:
+ * `resumeHook(toolApprovalHookToken({ executionId, toolCallId }), { approved: true })`
+ */
+export function toolApprovalHookToken(params) {
+    return `ekairos_story:tool-approval:${params.executionId}:${params.toolCallId}`;
+}
+/**
+ * Deterministic webhook token for approving an `auto: false` tool call.
+ *
+ * When using Workflow DevKit, the webhook is available at:
+ * `/.well-known/workflow/v1/webhook/:token`
+ */
+export function toolApprovalWebhookToken(params) {
+    return `ekairos_story:tool-approval-webhook:${params.executionId}:${params.toolCallId}`;
+}

package/dist/story.js

@@ -0,0 +1,6 @@
+export { 
+// engine
+Story, } from "./story.engine.js";
+export { 
+// builder
+story, createStory, } from "./story.builder.js";

package/dist/story.registry.d.ts

@@ -0,0 +1,21 @@
+import type { StoryEnvironment } from "./story.config.js";
+import type { StoryInstance } from "./story.builder.js";
+/**
+ * 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.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.store.d.ts

@@ -0,0 +1,107 @@
+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 type StoryStepStatus = "running" | "completed" | "failed";
+export type StoryStep = {
+    id: string;
+    createdAt: Date;
+    updatedAt?: Date;
+    status: StoryStepStatus;
+    iteration: number;
+    executionId: string;
+    triggerEventId?: string;
+    reactionEventId?: string;
+    eventId: string;
+    toolCalls?: any;
+    toolExecutionResults?: any;
+    continueLoop?: boolean;
+    errorText?: string;
+};
+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>;
+    /**
+     * Creates a persisted story step (intended: one per story loop iteration).
+     *
+     * IMPORTANT: IDs should be generated inside the store boundary (step runtime) to remain replay-safe.
+     */
+    createStep(params: {
+        executionId: string;
+        iteration: number;
+    }): Promise<{
+        id: string;
+        eventId: string;
+    }>;
+    /**
+     * Updates a persisted story step with completion metadata (tools, errors, continue signal, etc).
+     */
+    updateStep(stepId: string, patch: Partial<Pick<StoryStep, "status" | "toolCalls" | "toolExecutionResults" | "continueLoop" | "errorText" | "updatedAt">>): Promise<void>;
+    /**
+     * Persists normalized parts for a given step (parts-first).
+     * The event keeps `content.parts` for back-compat, but the source-of-truth can be `story_parts`.
+     */
+    saveStepParts(params: {
+        stepId: string;
+        parts: any[];
+    }): Promise<void>;
+    /**
+     * Links an event to an execution so consumers can traverse:
+     * `event -> execution -> steps`
+     */
+    linkEventToExecution(params: {
+        eventId: string;
+        executionId: string;
+    }): 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.js

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

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.js";
+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.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("-").slice(1).join("-");
+            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/thread.builder.d.ts

@@ -0,0 +1,118 @@
+import type { ThreadEnvironment } from "./thread.config.js";
+import { Thread, type ThreadModelInit, type ThreadOptions, type ThreadTool, type ShouldContinue, type ThreadShouldContinueArgs, type ThreadReactParams } from "./thread.engine.js";
+import type { ThreadReactor } from "./thread.reactor.js";
+import type { ThreadItem, StoredContext } from "./thread.store.js";
+import { type ThreadKey } from "./thread.registry.js";
+export interface ThreadConfig<Context, Env extends ThreadEnvironment = ThreadEnvironment> {
+    context: (context: StoredContext<Context>, env: Env) => Promise<Context> | Context;
+    /**
+     * Event expansion stage (first-class; executed by the engine on every loop iteration).
+     *
+     * Runs inside the Thread loop after events are loaded from the store and before
+     * they are converted into model messages.
+     *
+     * This is the intended place to do "document expansion" (turn file references
+     * into text parts) using LlamaCloud/Reducto/etc.
+     *
+     * 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.
+     */
+    expandEvents?: (events: ThreadItem[], context: StoredContext<Context>, env: Env) => Promise<ThreadItem[]> | ThreadItem[];
+    /**
+     * Thread-first "system" message for the model for this Thread run.
+     */
+    narrative: (context: StoredContext<Context>, env: Env) => Promise<string> | string;
+    /**
+     * Actions available to the model (aka "tools" in AI SDK terminology).
+     */
+    actions: (context: StoredContext<Context>, env: Env) => Promise<Record<string, ThreadTool>> | Record<string, ThreadTool>;
+    /**
+     * @deprecated Use `actions()` instead.
+     */
+    tools?: (context: StoredContext<Context>, env: Env) => Promise<Record<string, ThreadTool>> | Record<string, ThreadTool>;
+    /**
+     * 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
+     *   so it can be serialized by reference.
+     * - `(context, env) => ...`: dynamic selection based on current context/env (runs in workflow context).
+     */
+    model?: ThreadModelInit | ((context: StoredContext<Context>, env: Env) => ThreadModelInit);
+    reactor?: ThreadReactor<Context, Env>;
+    /**
+     * Called after each streamed model "reaction" and subsequent tool executions.
+     *
+     * Use this to decide whether the Thread loop should continue.
+     *
+     * - `true`  => continue looping
+     * - `false` => finalize the Thread run
+     */
+    shouldContinue?: (args: ThreadShouldContinueArgs<Context, Env>) => Promise<ShouldContinue> | ShouldContinue;
+    opts?: ThreadOptions<Context, Env>;
+}
+export type ThreadInstance<Context, Env extends ThreadEnvironment = ThreadEnvironment> = Thread<Context, Env> & {
+    readonly __config: ThreadConfig<Context, Env>;
+};
+export declare function thread<Context, Env extends ThreadEnvironment = ThreadEnvironment>(config: ThreadConfig<Context, Env>): ThreadInstance<Context, Env>;
+type AnyContextInitializer<Env extends ThreadEnvironment> = (context: StoredContext<any>, env: Env) => Promise<any> | any;
+type InferContextFromInitializer<I extends AnyContextInitializer<any>> = Awaited<ReturnType<I>>;
+type BuilderSystemPrompt<Context, Env extends ThreadEnvironment> = (context: StoredContext<Context>, env: Env) => Promise<string> | string;
+type BuilderTools<Context, Env extends ThreadEnvironment> = (context: StoredContext<Context>, env: Env) => Promise<Record<string, ThreadTool>> | Record<string, ThreadTool>;
+type BuilderExpandEvents<Context, Env extends ThreadEnvironment> = (events: ThreadItem[], context: StoredContext<Context>, env: Env) => Promise<ThreadItem[]> | ThreadItem[];
+type BuilderShouldContinue<Context, Env extends ThreadEnvironment> = (args: ThreadShouldContinueArgs<Context, Env>) => Promise<ShouldContinue> | ShouldContinue;
+type BuilderModel<Context, Env extends ThreadEnvironment> = ThreadModelInit | ((context: StoredContext<Context>, env: Env) => ThreadModelInit);
+export type RegistrableThreadBuilder = {
+    key: ThreadKey;
+    register: () => void;
+};
+type FluentThreadBuilder<Context, Env extends ThreadEnvironment> = {
+    key: ThreadKey;
+    expandEvents(fn: BuilderExpandEvents<Context, Env>): FluentThreadBuilder<Context, Env>;
+    narrative(fn: BuilderSystemPrompt<Context, Env>): FluentThreadBuilder<Context, Env>;
+    /**
+     * "System" facade (AI SDK terminology).
+     */
+    system(fn: BuilderSystemPrompt<Context, Env>): FluentThreadBuilder<Context, Env>;
+    actions(fn: BuilderTools<Context, Env>): FluentThreadBuilder<Context, Env>;
+    /**
+     * @deprecated Use `actions()` instead.
+     */
+    tools(fn: BuilderTools<Context, Env>): FluentThreadBuilder<Context, Env>;
+    model(model: BuilderModel<Context, Env>): FluentThreadBuilder<Context, Env>;
+    reactor(reactor: ThreadReactor<Context, Env>): FluentThreadBuilder<Context, Env>;
+    /**
+     * Stop/continue hook (DurableAgent-like stop condition).
+     */
+    shouldContinue(fn: BuilderShouldContinue<Context, Env>): FluentThreadBuilder<Context, Env>;
+    opts(opts: ThreadOptions<Context, Env>): FluentThreadBuilder<Context, Env>;
+    /**
+     * Convenience: react to an incoming event without requiring an explicit `.build()`.
+     *
+     * This still validates the config is complete (same as `.build()`), then delegates to the
+     * underlying `Thread.react(...)`.
+     */
+    react(triggerEvent: ThreadItem, params: ThreadReactParams<Env>): ReturnType<Thread<Context, Env>["react"]>;
+    /**
+     * @deprecated Use `react()` instead. Kept for backwards compatibility.
+     */
+    stream(triggerEvent: ThreadItem, params: ThreadReactParams<Env>): ReturnType<Thread<Context, Env>["react"]>;
+    /**
+     * Registers this Thread definition in the global registry under `key`.
+     *
+     * This is intended to be called at module load / boot time so durable workflows
+     * can resume and still resolve the Thread by key without requiring an endpoint
+     * to call `.build()` again.
+     */
+    register(): void;
+    config(): ThreadConfig<Context, Env>;
+    build(): ThreadInstance<Context, Env>;
+};
+type CreateThreadEntry<Env extends ThreadEnvironment> = {
+    context<Initializer extends AnyContextInitializer<Env>>(initializer: Initializer): FluentThreadBuilder<InferContextFromInitializer<Initializer>, Env>;
+    initialize<Initializer extends AnyContextInitializer<Env>>(initializer: Initializer): FluentThreadBuilder<InferContextFromInitializer<Initializer>, Env>;
+};
+export declare function createThread<Env extends ThreadEnvironment = ThreadEnvironment>(key: ThreadKey): CreateThreadEntry<Env>;
+export {};

package/dist/thread.builder.js

@@ -0,0 +1,134 @@
+import { Thread, } from "./thread.engine.js";
+import { registerThread } from "./thread.registry.js";
+export function thread(config) {
+    class FunctionalThread extends Thread {
+        constructor() {
+            super(config.opts, config.reactor);
+            this.__config = config;
+        }
+        async initialize(context, env) {
+            return config.context(context, env);
+        }
+        async expandEvents(events, context, env) {
+            if (config.expandEvents)
+                return config.expandEvents(events, context, env);
+            return super.expandEvents(events, context, env);
+        }
+        async buildSystemPrompt(context, env) {
+            if (config.narrative)
+                return config.narrative(context, env);
+            throw new Error("Thread config is missing narrative()");
+        }
+        async buildTools(context, env) {
+            // Back-compat: accept `tools` in old configs.
+            if (config.actions)
+                return config.actions(context, env);
+            if (config.tools)
+                return config.tools(context, env);
+            throw new Error("Thread config is missing actions()");
+        }
+        getModel(context, env) {
+            if (typeof config.model === "function")
+                return config.model(context, env);
+            return config.model ?? super.getModel(context, env);
+        }
+        async shouldContinue(args) {
+            if (config.shouldContinue)
+                return config.shouldContinue(args);
+            return true;
+        }
+    }
+    const instance = new FunctionalThread();
+    return Object.assign(instance, { __config: config });
+}
+function assertConfigComplete(config) {
+    if (!config.context) {
+        throw new Error("createThread: you must define context() before building the Thread.");
+    }
+    if (!config.narrative) {
+        throw new Error("createThread: you must define narrative() before building the Thread.");
+    }
+    if (!config.actions && !config.tools) {
+        throw new Error("createThread: you must define actions() before building the Thread.");
+    }
+}
+export function createThread(key) {
+    const initializeBuilder = (initializer) => {
+        const typedInitializer = (ctx, env) => initializer(ctx, env);
+        const fluentState = {
+            context: typedInitializer,
+        };
+        let cached = null;
+        const builder = {
+            key,
+            expandEvents(fn) {
+                fluentState.expandEvents = fn;
+                return builder;
+            },
+            narrative(narrative) {
+                fluentState.narrative = narrative;
+                return builder;
+            },
+            system(system) {
+                // Facade alias.
+                fluentState.narrative = system;
+                return builder;
+            },
+            actions(actionsFactory) {
+                fluentState.actions = actionsFactory;
+                return builder;
+            },
+            tools(toolsFactory) {
+                // Back-compat alias.
+                fluentState.actions = toolsFactory;
+                return builder;
+            },
+            model(model) {
+                fluentState.model = model;
+                return builder;
+            },
+            reactor(reactor) {
+                fluentState.reactor = reactor;
+                return builder;
+            },
+            shouldContinue(fn) {
+                fluentState.shouldContinue = fn;
+                return builder;
+            },
+            opts(options) {
+                fluentState.opts = options;
+                return builder;
+            },
+            react(triggerEvent, params) {
+                assertConfigComplete(fluentState);
+                if (!cached) {
+                    const config = fluentState;
+                    cached = thread(config);
+                }
+                return cached.react(triggerEvent, params);
+            },
+            stream(triggerEvent, params) {
+                return builder.react(triggerEvent, params);
+            },
+            register() {
+                assertConfigComplete(fluentState);
+                const config = fluentState;
+                registerThread(key, () => thread(config));
+            },
+            config() {
+                assertConfigComplete(fluentState);
+                return fluentState;
+            },
+            build() {
+                assertConfigComplete(fluentState);
+                const config = fluentState;
+                return thread(config);
+            },
+        };
+        return builder;
+    };
+    return {
+        context: initializeBuilder,
+        initialize: initializeBuilder,
+    };
+}

package/dist/thread.config.d.ts

@@ -0,0 +1,15 @@
+import type { ThreadStore } from "./thread.store.js";
+import type { ConcreteDomain } from "@ekairos/domain";
+/**
+ * ## thread.config.ts
+ *
+ * Thread runtime is resolved from the app runtime configured in `@ekairos/domain/runtime`.
+ * There is no thread-specific runtime configuration surface.
+ */
+export type ThreadEnvironment = Record<string, unknown>;
+export type ThreadRuntime = {
+    store: ThreadStore;
+    db: any;
+    domain?: ConcreteDomain<any, any>;
+};
+export declare function coerceThreadRuntime(value: any): Promise<ThreadRuntime>;

package/dist/thread.config.js

@@ -0,0 +1,30 @@
+const runtimeByDb = new WeakMap();
+export async function coerceThreadRuntime(value) {
+    if (!value) {
+        throw new Error("Thread runtime resolver returned no value.");
+    }
+    if (typeof value === "object" && value.store) {
+        return value;
+    }
+    const dbCandidate = typeof value === "object" && value !== null && "db" in value
+        ? value.db
+        : value;
+    if (!dbCandidate) {
+        throw new Error("Thread runtime resolver did not provide a database or store.");
+    }
+    if (typeof dbCandidate === "object" && dbCandidate !== null) {
+        const cached = runtimeByDb.get(dbCandidate);
+        if (cached)
+            return cached;
+    }
+    const { InstantStore } = await import("./stores/instant.store.js");
+    const runtime = {
+        store: new InstantStore(dbCandidate),
+        db: dbCandidate,
+        domain: typeof value === "object" ? value.domain : undefined,
+    };
+    if (typeof dbCandidate === "object" && dbCandidate !== null) {
+        runtimeByDb.set(dbCandidate, runtime);
+    }
+    return runtime;
+}

package/dist/thread.d.ts

@@ -0,0 +1,3 @@
+export { Thread, type ThreadOptions, type ThreadStreamOptions, type ShouldContinue, type ThreadShouldContinueArgs, } from "./thread.engine.js";
+export { thread, createThread, type ThreadConfig, type ThreadInstance, type RegistrableThreadBuilder, } from "./thread.builder.js";
+export { createAiSdkReactor, type CreateAiSdkReactorOptions, type ThreadReactor, type ThreadReactorParams, type ThreadReactionResult, type ThreadReactionToolCall, type ThreadReactionLLM, } from "./thread.reactor.js";