@dawn-ai/langchain 0.1.8 → 0.3.0

package/dist/agent-adapter.js

@@ -1,7 +1,13 @@
 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 { buildSummarizationHook } from "./summarization/index.js";
 import { convertToolToLangChain } from "./tool-converter.js";
 function assertAgentLike(entry) {
     if (typeof entry !== "object" ||
@@ -11,31 +17,202 @@ function assertAgentLike(entry) {
         throw new Error("Agent entry must expose invoke(input) — expected a LangChain agent");
     }
 }
-const materializedAgents = new WeakMap();
-async function materializeAgent(descriptor, tools, stateFields, middlewareContext) {
-    const cached = materializedAgents.get(descriptor);
-    if (cached) {
-        return cached;
+// 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.
+let materializedAgents = new WeakMap();
+/**
+ * Test-only escape hatch: reset the materialized-agents cache so the next
+ * harness run creates a fresh LLM instance (e.g. pointing at a new aimock
+ * port). Exported (and re-exported via `@dawn-ai/cli/runtime`) so the
+ * `@dawn-ai/testing` harness can clear the cache on teardown. Not for
+ * production use; the `__`/`ForTests` name marks it internal-by-convention.
+ */
+export function __resetMaterializedAgentsForTests() {
+    materializedAgents = new WeakMap();
+}
+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, opts = {}) {
+    if (!opts.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 langchainTools = tools.map((tool) => convertToolToLangChain(tool, opts.middlewareContext, opts.offload));
+    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 = opts.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);
+    const runningSummaryField = {
+        name: "runningSummary",
+        reducer: "replace",
+        default: undefined,
+    };
+    const effectiveStateFields = opts.summarization
+        ? [...(opts.stateFields ?? []).filter((f) => f.name !== "runningSummary"), runningSummaryField]
+        : (opts.stateFields ?? []);
+    if (effectiveStateFields.length > 0) {
+        agentOptions.stateSchema = materializeStateSchema(effectiveStateFields);
+    }
+    if (opts.summarization) {
+        agentOptions.preModelHook = buildSummarizationHook(opts.summarization);
     }
     // biome-ignore lint/suspicious/noExplicitAny: dynamically-built options don't satisfy strict StateDefinition type
     const compiled = createReactAgent(agentOptions);
-    materializedAgents.set(descriptor, compiled);
+    if (!opts.bypassCache) {
+        materializedAgents.set(descriptor, compiled);
+    }
     return compiled;
 }
+export async function materializeAgentGraph(options) {
+    return materializeAgent(options.descriptor, options.tools ?? [], options.checkpointer, {
+        ...(options.stateFields ? { stateFields: options.stateFields } : {}),
+        ...(options.promptFragments ? { promptFragments: options.promptFragments } : {}),
+        ...(options.summarization ? { summarization: options.summarization } : {}),
+    });
+}
+/**
+ * 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 +223,73 @@ 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 ? { stateFields: options.stateFields } : {}),
+            ...(options.middlewareContext ? { middlewareContext: options.middlewareContext } : {}),
+            ...(options.promptFragments ? { promptFragments: options.promptFragments } : {}),
+            ...(resolver && hasTaskTool ? { bypassCache: true } : {}),
+            ...(options.offload ? { offload: options.offload } : {}),
+            ...(options.summarization ? { summarization: options.summarization } : {}),
+        });
         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, options.offload));
     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 +306,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 +340,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.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,CAoCnB"}

package/dist/chat-model-factory.js

@@ -0,0 +1,55 @@
+const providerSpecs = {
+    openai: { packageName: "@langchain/openai", exportName: "ChatOpenAI" },
+    anthropic: { packageName: "@langchain/anthropic", exportName: "ChatAnthropic" },
+    // Official LangChain JS docs and current npm availability support this stable package/class.
+    google: { packageName: "@langchain/google-genai", exportName: "ChatGoogleGenerativeAI" },
+    mistral: { packageName: "@langchain/mistralai", exportName: "ChatMistralAI" },
+    groq: { packageName: "@langchain/groq", exportName: "ChatGroq" },
+    ollama: { packageName: "@langchain/ollama", exportName: "ChatOllama" },
+    xai: { packageName: "@langchain/xai", exportName: "ChatXAI" },
+    openrouter: { packageName: "@langchain/openrouter", exportName: "ChatOpenRouter" },
+};
+export function missingProviderPackageMessage(provider, packageName) {
+    return `Provider "${provider}" requires ${packageName}. Install it with: pnpm add ${packageName}`;
+}
+export async function createChatModel(options) {
+    const spec = providerSpecs[options.provider];
+    const importer = options.importer ??
+        ((specifier) => import(specifier));
+    let moduleExports;
+    try {
+        moduleExports = await importer(spec.packageName);
+    }
+    catch (error) {
+        if (isMissingModuleError(error, spec.packageName)) {
+            throw new Error(missingProviderPackageMessage(options.provider, spec.packageName));
+        }
+        throw error;
+    }
+    const Constructor = moduleExports[spec.exportName];
+    if (typeof Constructor !== "function") {
+        throw new Error(`Provider "${options.provider}" package ${spec.packageName} does not export ${spec.exportName}.`);
+    }
+    const constructorOptions = { model: options.model };
+    if (options.provider === "openai" && options.reasoning?.effort) {
+        constructorOptions.reasoningEffort = options.reasoning.effort;
+    }
+    if (options.provider === "openai") {
+        const baseURL = process.env.OPENAI_BASE_URL;
+        if (baseURL) {
+            constructorOptions.configuration = { baseURL };
+        }
+    }
+    return new Constructor(constructorOptions);
+}
+function isMissingModuleError(error, expectedPackageName) {
+    return (error instanceof Error &&
+        ("code" in error ? error.code === "ERR_MODULE_NOT_FOUND" : true) &&
+        referencesPackageSpecifier(error.message, expectedPackageName) &&
+        /Cannot find (package|module)|ERR_MODULE_NOT_FOUND/i.test(error.message));
+}
+function referencesPackageSpecifier(message, packageName) {
+    return (message.includes(`'${packageName}'`) ||
+        message.includes(`"${packageName}"`) ||
+        message.includes(`\`${packageName}\``));
+}

package/dist/index.d.ts

@@ -1,9 +1,26 @@
-export type { AgentStreamChunk } from "./agent-adapter.js";
-export { executeAgent, streamAgent } from "./agent-adapter.js";
+export type { BuiltInModelProviderId, ModelProviderId } from "@dawn-ai/sdk";
+export { Command } from "@langchain/langgraph";
+export type { AgentStreamChunk, DawnToolDefinition, SubagentResolver, } from "./agent-adapter.js";
+export { __resetMaterializedAgentsForTests, executeAgent, materializeAgentGraph, streamAgent, } from "./agent-adapter.js";
 export { chainAdapter } from "./chain-adapter.js";
+export { createChatModel } from "./chat-model-factory.js";
+export { inferProvider, resolveProvider } from "./model-provider-resolver.js";
+export type { OffloadStoreOptions } from "./offload/offload-store.js";
+export { buildOffloadFileName, OffloadStore } from "./offload/offload-store.js";
+export type { OffloadToolOutputCtx } from "./offload/offload-tool-output.js";
+export { offloadToolOutput } from "./offload/offload-tool-output.js";
+export { buildStub } from "./offload/stub.js";
 export type { RetryOptions } from "./retry.js";
 export { isRetryableError, withRetry } from "./retry.js";
 export { materializeStateSchema } from "./state-adapter.js";
+export type { SubagentEvent, SubagentStreamContext, } from "./subagent-dispatcher.js";
+export { createSubagentStreamContext, dispatchSubagent, MAX_SUBAGENT_DEPTH, } from "./subagent-dispatcher.js";
+export type { SubagentResolverResult } from "./subagent-tool-bridge.js";
+export { bridgeSubagentTool } from "./subagent-tool-bridge.js";
+export * from "./summarization/index.js";
+export type { OffloadFn } from "./tool-converter.js";
 export { convertToolToLangChain } from "./tool-converter.js";
 export { executeWithToolLoop } from "./tool-loop.js";
+export type { UnwrappedToolResult } from "./unwrap-tool-result.js";
+export { unwrapToolResult } from "./unwrap-tool-result.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAA;AAC1D,OAAO,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAA;AAC9D,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAA;AACjD,YAAY,EAAE,YAAY,EAAE,MAAM,YAAY,CAAA;AAC9C,OAAO,EAAE,gBAAgB,EAAE,SAAS,EAAE,MAAM,YAAY,CAAA;AACxD,OAAO,EAAE,sBAAsB,EAAE,MAAM,oBAAoB,CAAA;AAC3D,OAAO,EAAE,sBAAsB,EAAE,MAAM,qBAAqB,CAAA;AAC5D,OAAO,EAAE,mBAAmB,EAAE,MAAM,gBAAgB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,sBAAsB,EAAE,eAAe,EAAE,MAAM,cAAc,CAAA;AAC3E,OAAO,EAAE,OAAO,EAAE,MAAM,sBAAsB,CAAA;AAC9C,YAAY,EACV,gBAAgB,EAChB,kBAAkB,EAClB,gBAAgB,GACjB,MAAM,oBAAoB,CAAA;AAC3B,OAAO,EACL,iCAAiC,EACjC,YAAY,EACZ,qBAAqB,EACrB,WAAW,GACZ,MAAM,oBAAoB,CAAA;AAC3B,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAA;AACjD,OAAO,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAA;AACzD,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAA;AAC7E,YAAY,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAA;AACrE,OAAO,EAAE,oBAAoB,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAA;AAC/E,YAAY,EAAE,oBAAoB,EAAE,MAAM,kCAAkC,CAAA;AAC5E,OAAO,EAAE,iBAAiB,EAAE,MAAM,kCAAkC,CAAA;AACpE,OAAO,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAA;AAC7C,YAAY,EAAE,YAAY,EAAE,MAAM,YAAY,CAAA;AAC9C,OAAO,EAAE,gBAAgB,EAAE,SAAS,EAAE,MAAM,YAAY,CAAA;AACxD,OAAO,EAAE,sBAAsB,EAAE,MAAM,oBAAoB,CAAA;AAC3D,YAAY,EACV,aAAa,EACb,qBAAqB,GACtB,MAAM,0BAA0B,CAAA;AACjC,OAAO,EACL,2BAA2B,EAC3B,gBAAgB,EAChB,kBAAkB,GACnB,MAAM,0BAA0B,CAAA;AACjC,YAAY,EAAE,sBAAsB,EAAE,MAAM,2BAA2B,CAAA;AACvE,OAAO,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAA;AAC9D,cAAc,0BAA0B,CAAA;AACxC,YAAY,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAA;AACpD,OAAO,EAAE,sBAAsB,EAAE,MAAM,qBAAqB,CAAA;AAC5D,OAAO,EAAE,mBAAmB,EAAE,MAAM,gBAAgB,CAAA;AACpD,YAAY,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAA;AAClE,OAAO,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAA"}