@dawn-ai/langchain 0.1.8 → 0.2.0

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2026 Dawn contributors
+Copyright (c) Brian Love
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -4,9 +4,23 @@
 
 # @dawn-ai/langchain
 
-LangChain backend adapters Dawn uses to materialize `chain` and `agent` routes (tool conversion, streaming, retry).
+LangChain backend adapters Dawn uses to materialize `chain` routes and provider-aware `agent` routes (tool conversion, streaming, retry).
 
-This is an internal Dawn workspace package. For Dawn documentation, see <https://dawn-ai.org>.
+`agent()` materialization resolves a LangChain chat model from the route descriptor. Dawn includes `@langchain/openai` for the default/backcompat path and lazy-loads optional provider packages when an agent selects or infers another provider.
+
+Install optional provider integrations in applications as needed:
+
+```bash
+pnpm add @langchain/anthropic     # anthropic
+pnpm add @langchain/google-genai  # google
+pnpm add @langchain/mistralai     # mistral
+pnpm add @langchain/groq          # groq
+pnpm add @langchain/ollama        # ollama
+pnpm add @langchain/xai           # xai
+pnpm add @langchain/openrouter    # openrouter
+```
+
+This is an internal Dawn workspace package. For Dawn documentation, see <https://github.com/cacheplane/dawnai/tree/main/apps/web/content/docs>.
 
 ## License
 

package/dist/agent-adapter.d.ts

@@ -1,6 +1,11 @@
-import type { RetryConfig } from "@dawn-ai/sdk";
+import type { PromptFragment, StreamTransformer } from "@dawn-ai/core";
+import type { DawnAgent, RetryConfig } from "@dawn-ai/sdk";
+import { type BaseMessageLike } from "@langchain/core/messages";
+import type { BaseCheckpointSaver } from "@langchain/langgraph-checkpoint";
 import { type ResolvedStateField } from "./state-adapter.js";
-interface DawnToolDefinition {
+import { type SubagentResolverResult } from "./subagent-tool-bridge.js";
+export type SubagentResolver = (leafName: string) => SubagentResolverResult | undefined;
+export interface DawnToolDefinition {
     readonly description?: string;
     readonly name: string;
     readonly run: (input: unknown, context: {
@@ -9,12 +14,33 @@ interface DawnToolDefinition {
     }) => Promise<unknown> | unknown;
     readonly schema?: unknown;
 }
+export declare function composePromptMessages(systemPrompt: string, promptFragments: readonly PromptFragment[], state: Record<string, unknown>): BaseMessageLike[];
+export declare function materializeAgentGraph(options: {
+    readonly checkpointer: BaseCheckpointSaver;
+    readonly descriptor: DawnAgent;
+    readonly tools?: readonly DawnToolDefinition[];
+    readonly stateFields?: readonly ResolvedStateField[];
+    readonly promptFragments?: readonly PromptFragment[];
+}): Promise<unknown>;
 export interface AgentStreamChunk {
-    readonly type: "token" | "tool_call" | "tool_result" | "done";
+    readonly type: "token" | "tool_call" | "tool_result" | "interrupt" | "done" | (string & {});
     readonly data: unknown;
 }
 export interface AgentOptions {
+    /**
+     * Checkpointer used by LangGraph to park interrupted graph state and replay
+     * from it on resume. Required — the CLI runtime supplies a SQLite-backed
+     * instance by default. If you call agent-adapter directly (e.g. in tests),
+     * pass `new MemorySaver()` from `@langchain/langgraph`.
+     */
+    readonly checkpointer: BaseCheckpointSaver;
     readonly entry: unknown;
+    /**
+     * The agent input. For a normal invocation, this is a record like
+     * `{messages: [...]}`. For a resume invocation (after a parked interrupt),
+     * pass a `Command({resume: decision})` instance directly — the adapter will
+     * forward it verbatim to `streamEvents` instead of wrapping it in messages.
+     */
     readonly input: unknown;
     readonly middlewareContext?: Readonly<Record<string, unknown>>;
     readonly retry?: RetryConfig;
@@ -22,8 +48,25 @@ export interface AgentOptions {
     readonly signal: AbortSignal;
     readonly stateFields?: readonly ResolvedStateField[];
     readonly tools: readonly DawnToolDefinition[];
+    readonly promptFragments?: readonly PromptFragment[];
+    readonly streamTransformers?: readonly StreamTransformer[];
+    /**
+     * Resolves a subagent leaf name to a child graph + routeId. When set, the
+     * `task` tool contributed by the subagents capability marker is intercepted
+     * inside `streamFromRunnable` and replaced with a bridge that dispatches the
+     * call via `dispatchSubagent`. Emitted `subagent.*` events are queued and
+     * drained alongside normal stream chunks (no module-level mutable state).
+     */
+    readonly subagentResolver?: SubagentResolver;
+    /**
+     * Stable per-conversation identifier used as LangGraph's `thread_id`. When
+     * set, the agent-adapter wires it into `config.configurable.thread_id` so
+     * the checkpointer can park interrupted state. Required for resume to work
+     * — without a thread_id, an interrupt ends the stream with no way to
+     * replay.
+     */
+    readonly threadId?: string;
 }
 export declare function executeAgent(options: AgentOptions): Promise<unknown>;
 export declare function streamAgent(options: AgentOptions): AsyncGenerator<AgentStreamChunk>;
-export {};
 //# sourceMappingURL=agent-adapter.d.ts.map

package/dist/agent-adapter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"agent-adapter.d.ts","sourceRoot":"","sources":["../src/agent-adapter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAa,WAAW,EAAE,MAAM,cAAc,CAAA;AAI1D,OAAO,EAA0B,KAAK,kBAAkB,EAAE,MAAM,oBAAoB,CAAA;AAGpF,UAAU,kBAAkB;IAC1B,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAA;IAC7B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,GAAG,EAAE,CACZ,KAAK,EAAE,OAAO,EACd,OAAO,EAAE;QACP,QAAQ,CAAC,UAAU,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAA;QACvD,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAA;KAC7B,KACE,OAAO,CAAC,OAAO,CAAC,GAAG,OAAO,CAAA;IAC/B,QAAQ,CAAC,MAAM,CAAC,EAAE,OAAO,CAAA;CAC1B;AAwDD,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,IAAI,EAAE,OAAO,GAAG,WAAW,GAAG,aAAa,GAAG,MAAM,CAAA;IAC7D,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAA;CACvB;AAED,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAA;IACvB,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAA;IACvB,QAAQ,CAAC,iBAAiB,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAA;IAC9D,QAAQ,CAAC,KAAK,CAAC,EAAE,WAAW,CAAA;IAC5B,QAAQ,CAAC,eAAe,EAAE,SAAS,MAAM,EAAE,CAAA;IAC3C,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAA;IAC5B,QAAQ,CAAC,WAAW,CAAC,EAAE,SAAS,kBAAkB,EAAE,CAAA;IACpD,QAAQ,CAAC,KAAK,EAAE,SAAS,kBAAkB,EAAE,CAAA;CAC9C;AAED,wBAAsB,YAAY,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,OAAO,CAAC,CAQ1E;AAED,wBAAuB,WAAW,CAAC,OAAO,EAAE,YAAY,GAAG,cAAc,CAAC,gBAAgB,CAAC,CA4B1F"}
+{"version":3,"file":"agent-adapter.d.ts","sourceRoot":"","sources":["../src/agent-adapter.ts"],"names":[],"mappings":"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"}

package/dist/agent-adapter.js

@@ -1,7 +1,12 @@
 import { isDawnAgent } from "@dawn-ai/sdk";
 import { HumanMessage } from "@langchain/core/messages";
+import { Command } from "@langchain/langgraph";
+import { createChatModel } from "./chat-model-factory.js";
+import { resolveProvider } from "./model-provider-resolver.js";
 import { isRetryableError, withRetry } from "./retry.js";
 import { materializeStateSchema } from "./state-adapter.js";
+import { createSubagentStreamContext, } from "./subagent-dispatcher.js";
+import { bridgeSubagentTool } from "./subagent-tool-bridge.js";
 import { convertToolToLangChain } from "./tool-converter.js";
 function assertAgentLike(entry) {
     if (typeof entry !== "object" ||
@@ -11,31 +16,177 @@ function assertAgentLike(entry) {
         throw new Error("Agent entry must expose invoke(input) — expected a LangChain agent");
     }
 }
+// Cache keyed on descriptor only. Assumption: a given descriptor is always
+// invoked with the same capability contributions (prompt fragments come from
+// the route directory, which is stable per descriptor). If that assumption
+// changes, the cache key must include a hash of the fragments/transformers.
 const materializedAgents = new WeakMap();
-async function materializeAgent(descriptor, tools, stateFields, middlewareContext) {
-    const cached = materializedAgents.get(descriptor);
-    if (cached) {
-        return cached;
+export function composePromptMessages(systemPrompt, promptFragments, state) {
+    const rendered = promptFragments
+        .filter((f) => f.placement === "after_user_prompt")
+        .map((f) => f.render(state))
+        .filter((s) => s.length > 0);
+    const composed = [systemPrompt, ...rendered].join("\n\n");
+    const messages = Array.isArray(state.messages) ? state.messages : [];
+    return [{ role: "system", content: composed }, ...messages];
+}
+async function materializeAgent(descriptor, tools, checkpointer, stateFields, middlewareContext, promptFragments, options) {
+    if (!options?.bypassCache) {
+        const cached = materializedAgents.get(descriptor);
+        if (cached) {
+            return cached;
+        }
     }
     const { createReactAgent } = await import("@langchain/langgraph/prebuilt");
-    const { ChatOpenAI } = await import("@langchain/openai");
     const langchainTools = tools.map((tool) => convertToolToLangChain(tool, middlewareContext));
-    const llm = new ChatOpenAI({
+    const provider = resolveProvider({
         model: descriptor.model,
+        ...(descriptor.provider !== undefined ? { provider: descriptor.provider } : {}),
     });
+    const llm = await createChatModel({
+        model: descriptor.model,
+        provider,
+        ...(descriptor.reasoning ? { reasoning: descriptor.reasoning } : {}),
+    });
+    const fragments = promptFragments ?? [];
     const agentOptions = {
         llm,
         tools: langchainTools,
-        prompt: descriptor.systemPrompt,
+        // Function-form prompt re-renders fragments on every model turn so they
+        // can reflect live state (e.g., the current todos list).
+        prompt: fragments.length > 0
+            ? (state) => composePromptMessages(descriptor.systemPrompt, fragments, state)
+            : descriptor.systemPrompt,
+        // Required so `interrupt()` can park graph state and `Command({resume})`
+        // can replay it. Paired with `config.configurable.thread_id`.
+        checkpointer,
     };
     if (stateFields && stateFields.length > 0) {
         agentOptions.stateSchema = materializeStateSchema(stateFields);
     }
     // biome-ignore lint/suspicious/noExplicitAny: dynamically-built options don't satisfy strict StateDefinition type
     const compiled = createReactAgent(agentOptions);
-    materializedAgents.set(descriptor, compiled);
+    if (!options?.bypassCache) {
+        materializedAgents.set(descriptor, compiled);
+    }
     return compiled;
 }
+export async function materializeAgentGraph(options) {
+    return materializeAgent(options.descriptor, options.tools ?? [], options.checkpointer, options.stateFields, undefined, options.promptFragments);
+}
+/**
+ * LangGraph 1.x's `interrupt()` throws a `GraphInterrupt` from inside the tool
+ * node. Under `streamEvents` v2 this surfaces as an `on_tool_error` whose
+ * `event.data.error` is the `GraphInterrupt` instance — its `.name` is
+ * `"GraphInterrupt"` and its `.interrupts` array carries the `{ id, value }`
+ * entries we need. The top-level `on_chain_end` for `LangGraph` does NOT
+ * include `__interrupt__` in this code path (that key appears only on the
+ * `invoke`/`stream` return value), so detection must happen at the tool error.
+ *
+ * We still keep the `__interrupt__` extractor for `on_chain_end` as a
+ * defensive fallback in case a future LangGraph version surfaces interrupts
+ * via the chain output too.
+ */
+const INTERRUPT_KEY = "__interrupt__";
+function extractInterrupts(output) {
+    if (!output || typeof output !== "object")
+        return undefined;
+    const maybe = output[INTERRUPT_KEY];
+    if (!Array.isArray(maybe))
+        return undefined;
+    return maybe;
+}
+/**
+ * Detects a thrown `GraphInterrupt` surfaced via `on_tool_error`.
+ *
+ * LangGraph's `interrupt()` throws a `GraphInterrupt` whose `.message` is
+ * `JSON.stringify(interrupts)` and whose `.interrupts` array carries the
+ * `{ id, value }` entries. By the time the error reaches `streamEvents`'
+ * `data.error` it has already been stringified — typically into
+ * `<JSON interrupts>\n\nGraphInterrupt: <JSON interrupts>\n    at ...stack`.
+ *
+ * We handle three shapes defensively:
+ *   - object with `.name === "GraphInterrupt"` and `.interrupts` array
+ *     (in case a future LangGraph version surfaces the live error)
+ *   - object/Error whose stringified message starts with a JSON array
+ *   - bare string with the `GraphInterrupt:` marker
+ */
+function extractInterruptsFromError(error) {
+    if (!error)
+        return undefined;
+    if (typeof error === "object") {
+        const e = error;
+        if (e.name === "GraphInterrupt" && Array.isArray(e.interrupts) && e.interrupts.length > 0) {
+            return e.interrupts;
+        }
+        if (typeof e.message === "string") {
+            const parsed = parseInterruptStringMessage(e.message);
+            if (parsed)
+                return parsed;
+        }
+    }
+    if (typeof error === "string") {
+        const parsed = parseInterruptStringMessage(error);
+        if (parsed)
+            return parsed;
+    }
+    return undefined;
+}
+/**
+ * Parses the stringified form of a GraphInterrupt's message. The string
+ * begins with `JSON.stringify(interrupts, null, 2)` and is followed by
+ * `\n\nGraphInterrupt: ...\n    at ...` stack metadata. We slice the leading
+ * JSON array up to the first `]` followed by a newline + non-JSON sentinel
+ * and parse it.
+ */
+function parseInterruptStringMessage(text) {
+    const trimmed = text.trimStart();
+    if (!trimmed.startsWith("["))
+        return undefined;
+    // Find the matching closing bracket by bracket counting at depth 0 — robust
+    // against nested arrays in the interrupt payloads.
+    let depth = 0;
+    let inString = false;
+    let escaped = false;
+    let end = -1;
+    for (let i = 0; i < trimmed.length; i++) {
+        const ch = trimmed[i];
+        if (escaped) {
+            escaped = false;
+            continue;
+        }
+        if (inString) {
+            if (ch === "\\")
+                escaped = true;
+            else if (ch === '"')
+                inString = false;
+            continue;
+        }
+        if (ch === '"')
+            inString = true;
+        else if (ch === "[")
+            depth++;
+        else if (ch === "]") {
+            depth--;
+            if (depth === 0) {
+                end = i;
+                break;
+            }
+        }
+    }
+    if (end === -1)
+        return undefined;
+    const json = trimmed.slice(0, end + 1);
+    try {
+        const parsed = JSON.parse(json);
+        if (!Array.isArray(parsed) || parsed.length === 0)
+            return undefined;
+        return parsed;
+    }
+    catch {
+        return undefined;
+    }
+}
 export async function executeAgent(options) {
     let result;
     for await (const chunk of streamAgent(options)) {
@@ -46,22 +197,66 @@ export async function executeAgent(options) {
     return result;
 }
 export async function* streamAgent(options) {
+    if (!options.checkpointer) {
+        throw new Error("[dawn] agent-adapter requires a checkpointer in AgentOptions. The CLI runtime instantiates sqliteCheckpointer by default; if you're calling agent-adapter directly, pass one explicitly.");
+    }
+    // If the caller is passing a Command directly (resume path), forward it
+    // verbatim without the usual input preparation and message extraction.
+    const isCommandInput = options.input instanceof Command;
     const { agentInput, config } = prepareAgentCall(options);
-    const messages = extractMessages(agentInput);
+    const messages = isCommandInput ? [] : extractMessages(agentInput);
+    // Per-call subagent event queue. The bridge's writer pushes here; the
+    // streaming generator drains the queue alongside normal stream chunks. This
+    // avoids the module-level mutable-writer anti-pattern: each call has its
+    // own queue scoped to the surrounding generator frame.
+    const subagentEvents = [];
+    const queueWriter = (event) => {
+        subagentEvents.push({
+            type: event.event,
+            data: event.data,
+        });
+    };
+    // Per-call counter shared with the dispatcher. While a child is active, the
+    // parent's on_chat_model_stream events are suppressed (LangChain v2
+    // streamEvents propagates child events to the parent listener via
+    // async-local-storage tracing, so without this gate every child token
+    // appears twice on the parent stream: once as a raw token chunk and once
+    // wrapped in a subagent.message envelope).
+    const streamContext = createSubagentStreamContext();
+    const resolver = options.subagentResolver;
+    const hasTaskTool = options.tools.some((t) => t.name === "task");
+    const effectiveTools = resolver && hasTaskTool
+        ? options.tools.map((t) => t.name === "task"
+            ? {
+                ...t,
+                run: bridgeSubagentTool({
+                    subagentResolver: resolver,
+                    writer: queueWriter,
+                    parentConfig: config,
+                    streamContext,
+                }).run,
+            }
+            : t)
+        : options.tools;
     // DawnAgent descriptor path — materialize on first use
     if (isDawnAgent(options.entry)) {
-        const materializedAgent = await materializeAgent(options.entry, options.tools, options.stateFields, options.middlewareContext);
+        // Bypass the per-descriptor cache when a resolver is wired: the bridged
+        // tool closes over the per-call queue + parent config, so caching would
+        // bind those to a single call.
+        const materializedAgent = await materializeAgent(options.entry, effectiveTools, options.checkpointer, options.stateFields, options.middlewareContext, options.promptFragments, resolver && hasTaskTool ? { bypassCache: true } : undefined);
         const retryConfig = options.entry.retry;
-        yield* streamFromRunnable(materializedAgent, { messages }, config, retryConfig);
+        const runnableInput = isCommandInput ? options.input : { messages };
+        yield* streamFromRunnable(materializedAgent, runnableInput, config, retryConfig, options.streamTransformers, subagentEvents, streamContext);
         return;
     }
     // Legacy path — raw Runnable with .invoke()
     assertAgentLike(options.entry);
-    const langchainTools = options.tools.map((tool) => convertToolToLangChain(tool, options.middlewareContext));
+    const langchainTools = effectiveTools.map((tool) => convertToolToLangChain(tool, options.middlewareContext));
     if (langchainTools.length > 0) {
         config.tools = langchainTools;
     }
-    yield* streamFromRunnable(options.entry, { messages }, config, options.retry);
+    const runnableInput = isCommandInput ? options.input : { messages };
+    yield* streamFromRunnable(options.entry, runnableInput, config, options.retry, options.streamTransformers, subagentEvents, streamContext);
 }
 function prepareAgentCall(options) {
     const inputRecord = (options.input ?? {});
@@ -78,12 +273,27 @@ function prepareAgentCall(options) {
     const config = {
         signal: options.signal,
     };
-    if (Object.keys(params).length > 0) {
-        config.configurable = params;
+    const configurable = { ...params };
+    if (options.threadId !== undefined && options.threadId.length > 0) {
+        configurable.thread_id = options.threadId;
+    }
+    if (Object.keys(configurable).length > 0) {
+        config.configurable = configurable;
     }
     return { agentInput, config };
 }
-async function* streamFromRunnable(runnable, input, config, retryConfig) {
+async function* streamFromRunnable(runnable, input, config, retryConfig, streamTransformers, subagentEvents, streamContext) {
+    // Drains any pending subagent events queued by the bridge. Called before
+    // each normal yield to keep ordering predictable on the single event loop.
+    function* drainSubagentEvents() {
+        if (!subagentEvents)
+            return;
+        while (subagentEvents.length > 0) {
+            const next = subagentEvents.shift();
+            if (next)
+                yield next;
+        }
+    }
     const streamable = runnable;
     if (typeof streamable.streamEvents !== "function") {
         // Fallback: invoke with retry and emit a single done event
@@ -97,72 +307,148 @@ async function* streamFromRunnable(runnable, input, config, retryConfig) {
         yield { type: "done", data: result };
         return;
     }
-    let finalOutput;
-    let hasYielded = false;
-    let lastStreamError;
-    // Retry the entire stream if it fails before producing any output
-    const maxStreamAttempts = retryConfig?.maxAttempts ?? 3;
-    for (let attempt = 0; attempt < maxStreamAttempts; attempt++) {
-        hasYielded = false;
-        lastStreamError = undefined;
-        finalOutput = undefined;
-        try {
-            for await (const event of streamable.streamEvents(input, {
-                ...config,
-                version: "v2",
-            })) {
-                switch (event.event) {
-                    case "on_chat_model_stream": {
-                        const content = event.data.chunk?.content;
-                        if (content && typeof content === "string" && content.length > 0) {
+    // Capture into a typed const so TS narrowing survives across the nested
+    // async-generator closure below. Bind to `streamable` — LangGraph's
+    // Pregel.streamEvents reads `this.config?.recursionLimit`, so calling it
+    // unbound throws "Cannot read properties of undefined (reading 'config')".
+    const streamEventsFn = streamable.streamEvents.bind(streamable);
+    // Process a single streamEvents iterator: yield AgentStreamChunks and
+    // return whatever __interrupt__ entries appeared in the graph's final
+    // on_chain_end output.
+    async function* processEventStream(invocationInput, invocationConfig, allowRetryOnError) {
+        let finalOutput;
+        let capturedInterrupts = [];
+        let hasYielded = false;
+        const maxStreamAttempts = allowRetryOnError ? (retryConfig?.maxAttempts ?? 3) : 1;
+        for (let attempt = 0; attempt < maxStreamAttempts; attempt++) {
+            hasYielded = false;
+            finalOutput = undefined;
+            capturedInterrupts = [];
+            try {
+                for await (const event of streamEventsFn(invocationInput, {
+                    ...invocationConfig,
+                    version: "v2",
+                })) {
+                    yield* drainSubagentEvents();
+                    switch (event.event) {
+                        case "on_chat_model_stream": {
+                            if (streamContext && streamContext.activeChildRuns > 0)
+                                break;
+                            const content = event.data.chunk?.content;
+                            if (content && typeof content === "string" && content.length > 0) {
+                                hasYielded = true;
+                                yield { type: "token", data: content };
+                            }
+                            break;
+                        }
+                        case "on_tool_start": {
                             hasYielded = true;
-                            yield { type: "token", data: content };
+                            yield {
+                                type: "tool_call",
+                                data: {
+                                    name: event.name,
+                                    input: event.data.chunk ?? event.data.output,
+                                },
+                            };
+                            break;
                         }
-                        break;
-                    }
-                    case "on_tool_start": {
-                        hasYielded = true;
-                        yield {
-                            type: "tool_call",
-                            data: {
-                                name: event.name,
-                                input: event.data.chunk ?? event.data.output,
-                            },
-                        };
-                        break;
-                    }
-                    case "on_tool_end": {
-                        hasYielded = true;
-                        yield {
-                            type: "tool_result",
-                            data: { name: event.name, output: event.data.output },
-                        };
-                        break;
-                    }
-                    case "on_chain_end": {
-                        if (event.name === "LangGraph") {
-                            finalOutput = event.data.output;
+                        case "on_tool_end": {
+                            hasYielded = true;
+                            yield {
+                                type: "tool_result",
+                                data: { name: event.name, output: event.data.output },
+                            };
+                            for (const transformer of streamTransformers ?? []) {
+                                if (transformer.observes !== "tool_result")
+                                    continue;
+                                for await (const out of transformer.transform({
+                                    toolName: event.name,
+                                    toolOutput: event.data.output,
+                                })) {
+                                    yield {
+                                        type: out.event,
+                                        data: out.data,
+                                    };
+                                }
+                            }
+                            break;
+                        }
+                        case "on_tool_error": {
+                            // LangGraph's interrupt() throws a GraphInterrupt from inside
+                            // the tool node. The error bubbles through streamEvents as
+                            // on_tool_error with the GraphInterrupt instance on data.error.
+                            // LangGraph itself catches it to park the checkpointer state,
+                            // so the outer iterator continues normally afterwards.
+                            const interrupts = extractInterruptsFromError(event.data.error);
+                            if (interrupts && interrupts.length > 0) {
+                                capturedInterrupts = interrupts;
+                                for (const entry of interrupts) {
+                                    hasYielded = true;
+                                    if (process.env.DAWN_DEBUG_INTERRUPTS === "1") {
+                                        if (!entry.value ||
+                                            typeof entry.value.interruptId !== "string") {
+                                            console.warn("[dawn] interrupt entry.value missing interruptId — capability bug:", JSON.stringify(entry).slice(0, 300));
+                                        }
+                                    }
+                                    yield {
+                                        type: "interrupt",
+                                        // The capability's interrupt() payload is wrapped in
+                                        // entry.value by LangGraph — surface it verbatim so the
+                                        // SSE consumer sees the original {interruptId, kind, ...}
+                                        // envelope the workspace capability emitted.
+                                        data: entry.value,
+                                    };
+                                }
+                            }
+                            break;
+                        }
+                        case "on_chain_end": {
+                            if (event.name === "LangGraph") {
+                                finalOutput = event.data.output;
+                                const interrupts = extractInterrupts(event.data.output);
+                                if (interrupts && interrupts.length > 0) {
+                                    capturedInterrupts = interrupts;
+                                    for (const entry of interrupts) {
+                                        hasYielded = true;
+                                        yield {
+                                            type: "interrupt",
+                                            // The capability's interrupt() payload is wrapped in
+                                            // entry.value by LangGraph — surface it verbatim so the
+                                            // SSE consumer sees the original {interruptId, kind, ...}
+                                            // envelope the workspace capability emitted.
+                                            data: entry.value,
+                                        };
+                                    }
+                                }
+                            }
+                            break;
                         }
-                        break;
                     }
                 }
+                // Stream completed successfully
+                return { finalOutput, interrupts: capturedInterrupts };
             }
-            // Stream completed successfully
-            break;
-        }
-        catch (error) {
-            lastStreamError = error instanceof Error ? error : new Error(String(error));
-            // If we already yielded chunks, we can't retry (client has partial data)
-            // Or if the error isn't retryable, rethrow immediately
-            if (hasYielded || !isRetryableError(error) || attempt === maxStreamAttempts - 1) {
-                throw lastStreamError;
+            catch (error) {
+                const err = error instanceof Error ? error : new Error(String(error));
+                if (hasYielded || !isRetryableError(error) || attempt === maxStreamAttempts - 1) {
+                    throw err;
+                }
+                const delay = Math.min(1000 * 2 ** attempt + Math.random() * 500, 10_000);
+                await new Promise((resolve) => setTimeout(resolve, delay));
             }
-            // Backoff before retry
-            const delay = Math.min(1000 * 2 ** attempt + Math.random() * 500, 10_000);
-            await new Promise((resolve) => setTimeout(resolve, delay));
         }
+        // Unreachable: the loop either returns or throws.
+        return { finalOutput, interrupts: capturedInterrupts };
     }
-    yield { type: "done", data: finalOutput };
+    // Invoke the stream. After yielding any interrupt envelopes, return cleanly.
+    // Resume is state-based: the caller posts to /threads/:id/resume with the
+    // decision, which opens a new SSE stream with Command({resume: decision}) as
+    // input. The adapter does NOT park here waiting for an in-process promise.
+    const pass = yield* processEventStream(input, config, /* allowRetryOnError */ true);
+    // Final drain in case the last tool call was the bridged task tool —
+    // its events would otherwise be stranded after the stream ends.
+    yield* drainSubagentEvents();
+    yield { type: "done", data: pass.finalOutput };
 }
 function isInputMessageArray(value) {
     return (Array.isArray(value) &&

package/dist/chat-model-factory.d.ts

@@ -0,0 +1,11 @@
+import type { BuiltInModelProviderId, ReasoningConfig } from "@dawn-ai/sdk";
+type Importer = (specifier: string) => Promise<Record<string, unknown>>;
+export declare function missingProviderPackageMessage(provider: BuiltInModelProviderId, packageName: string): string;
+export declare function createChatModel(options: {
+    readonly model: string;
+    readonly provider: BuiltInModelProviderId;
+    readonly reasoning?: ReasoningConfig;
+    readonly importer?: Importer;
+}): Promise<unknown>;
+export {};
+//# sourceMappingURL=chat-model-factory.d.ts.map

package/dist/chat-model-factory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chat-model-factory.d.ts","sourceRoot":"","sources":["../src/chat-model-factory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,sBAAsB,EAAE,eAAe,EAAE,MAAM,cAAc,CAAA;AAE3E,KAAK,QAAQ,GAAG,CAAC,SAAS,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAA;AAoBvE,wBAAgB,6BAA6B,CAC3C,QAAQ,EAAE,sBAAsB,EAChC,WAAW,EAAE,MAAM,GAClB,MAAM,CAER;AAED,wBAAsB,eAAe,CAAC,OAAO,EAAE;IAC7C,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB,QAAQ,CAAC,QAAQ,EAAE,sBAAsB,CAAA;IACzC,QAAQ,CAAC,SAAS,CAAC,EAAE,eAAe,CAAA;IACpC,QAAQ,CAAC,QAAQ,CAAC,EAAE,QAAQ,CAAA;CAC7B,GAAG,OAAO,CAAC,OAAO,CAAC,CA6BnB"}