@dawn-ai/langchain 0.1.8 → 0.3.0

package/dist/index.js

@@ -1,6 +1,16 @@
-export { executeAgent, streamAgent } from "./agent-adapter.js";
+export { Command } from "@langchain/langgraph";
+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 { buildOffloadFileName, OffloadStore } from "./offload/offload-store.js";
+export { offloadToolOutput } from "./offload/offload-tool-output.js";
+export { buildStub } from "./offload/stub.js";
 export { isRetryableError, withRetry } from "./retry.js";
 export { materializeStateSchema } from "./state-adapter.js";
+export { createSubagentStreamContext, dispatchSubagent, MAX_SUBAGENT_DEPTH, } from "./subagent-dispatcher.js";
+export { bridgeSubagentTool } from "./subagent-tool-bridge.js";
+export * from "./summarization/index.js";
 export { convertToolToLangChain } from "./tool-converter.js";
 export { executeWithToolLoop } from "./tool-loop.js";
+export { unwrapToolResult } from "./unwrap-tool-result.js";

package/dist/model-provider-resolver.d.ts

@@ -0,0 +1,8 @@
+import type { BuiltInModelProviderId, ModelProviderId } from "@dawn-ai/sdk";
+export declare const SUPPORTED_AGENT_PROVIDERS: readonly ["openai", "anthropic", "google", "mistral", "groq", "ollama", "xai", "openrouter"];
+export declare function inferProvider(model: string): BuiltInModelProviderId | undefined;
+export declare function resolveProvider(options: {
+    readonly model: string;
+    readonly provider?: ModelProviderId;
+}): BuiltInModelProviderId;
+//# sourceMappingURL=model-provider-resolver.d.ts.map

package/dist/model-provider-resolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"model-provider-resolver.d.ts","sourceRoot":"","sources":["../src/model-provider-resolver.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,sBAAsB,EAAE,eAAe,EAAE,MAAM,cAAc,CAAA;AAE3E,eAAO,MAAM,yBAAyB,8FASgB,CAAA;AAItD,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,sBAAsB,GAAG,SAAS,CAgB/E;AAED,wBAAgB,eAAe,CAAC,OAAO,EAAE;IACvC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB,QAAQ,CAAC,QAAQ,CAAC,EAAE,eAAe,CAAA;CACpC,GAAG,sBAAsB,CAgBzB"}

package/dist/model-provider-resolver.js

@@ -0,0 +1,40 @@
+export const SUPPORTED_AGENT_PROVIDERS = [
+    "openai",
+    "anthropic",
+    "google",
+    "mistral",
+    "groq",
+    "ollama",
+    "xai",
+    "openrouter",
+];
+const supportedProviderSet = new Set(SUPPORTED_AGENT_PROVIDERS);
+export function inferProvider(model) {
+    const normalized = model.trim().toLowerCase();
+    if (/^(gpt-|o3|o4)/.test(normalized))
+        return "openai";
+    if (normalized.startsWith("claude-"))
+        return "anthropic";
+    if (normalized.startsWith("gemini-"))
+        return "google";
+    if (normalized.startsWith("mistral-") ||
+        normalized.startsWith("mixtral-") ||
+        normalized.startsWith("codestral-")) {
+        return "mistral";
+    }
+    if (normalized.startsWith("grok-"))
+        return "xai";
+    return undefined;
+}
+export function resolveProvider(options) {
+    if (options.provider !== undefined) {
+        if (supportedProviderSet.has(options.provider)) {
+            return options.provider;
+        }
+        throw new Error(`Unsupported agent provider "${options.provider}". Supported providers: ${SUPPORTED_AGENT_PROVIDERS.join(", ")}.`);
+    }
+    const inferred = inferProvider(options.model);
+    if (inferred)
+        return inferred;
+    throw new Error(`Could not infer a LangChain provider for model "${options.model}". Set provider explicitly on agent({ provider: "...", model: "${options.model}", ... }).`);
+}

package/dist/offload/offload-store.d.ts

@@ -0,0 +1,30 @@
+import type { FilesystemBackend } from "@dawn-ai/workspace";
+/**
+ * Deterministic offload filename. Keyed on the tool_call_id when present
+ * (unique per call in production; fixture-controlled in replay tests). Falls
+ * back to a content hash when no id is available — still deterministic and
+ * reproducible, since the caller controls the content.
+ */
+export declare function buildOffloadFileName(toolName: string, content: string, toolCallId?: string): string;
+export interface OffloadStoreOptions {
+    readonly backend: FilesystemBackend;
+    readonly workspaceRoot: string;
+    readonly signal: AbortSignal;
+    readonly maxBytes: number;
+    readonly ttlMs: number;
+    readonly gcThrottleMs: number;
+    /** Injectable clock for tests. Defaults to Date.now. */
+    readonly now?: () => number;
+}
+export declare class OffloadStore {
+    private readonly opts;
+    private lastGcAt;
+    constructor(opts: OffloadStoreOptions);
+    private get ctx();
+    private now;
+    /** Persist full content; returns the workspace-relative path. Runs throttled GC. */
+    write(toolName: string, content: string, toolCallId?: string): Promise<string>;
+    private maybeGc;
+    private safeRemove;
+}
+//# sourceMappingURL=offload-store.d.ts.map

package/dist/offload/offload-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"offload-store.d.ts","sourceRoot":"","sources":["../../src/offload/offload-store.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAA;AAS3D;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,MAAM,EACf,UAAU,CAAC,EAAE,MAAM,GAClB,MAAM,CAOR;AAED,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,OAAO,EAAE,iBAAiB,CAAA;IACnC,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAA;IAC9B,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAA;IAC5B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;IACzB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAA;IAC7B,wDAAwD;IACxD,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,MAAM,CAAA;CAC5B;AAED,qBAAa,YAAY;IAEX,OAAO,CAAC,QAAQ,CAAC,IAAI;IADjC,OAAO,CAAC,QAAQ,CAAQ;gBACK,IAAI,EAAE,mBAAmB;IAItD,OAAO,KAAK,GAAG,GAEd;IACD,OAAO,CAAC,GAAG;IAIX,oFAAoF;IAC9E,KAAK,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;YAWtE,OAAO;YA+CP,UAAU;CAQzB"}

package/dist/offload/offload-store.js

@@ -0,0 +1,105 @@
+import { createHash } from "node:crypto";
+import { join } from "node:path";
+// NOTE: must match the tool-outputs/ predicate in @dawn-ai/core workspace capability readFile.
+const SUBDIR = "tool-outputs";
+function sanitizeSegment(value) {
+    return value.replace(/[^A-Za-z0-9._-]/g, "_");
+}
+/**
+ * Deterministic offload filename. Keyed on the tool_call_id when present
+ * (unique per call in production; fixture-controlled in replay tests). Falls
+ * back to a content hash when no id is available — still deterministic and
+ * reproducible, since the caller controls the content.
+ */
+export function buildOffloadFileName(toolName, content, toolCallId) {
+    const name = sanitizeSegment(toolName);
+    if (toolCallId && toolCallId.length > 0) {
+        return `${name}-${sanitizeSegment(toolCallId)}.txt`;
+    }
+    const hash = createHash("sha256").update(content).digest("hex").slice(0, 16);
+    return `${name}-${hash}.txt`;
+}
+export class OffloadStore {
+    opts;
+    lastGcAt;
+    constructor(opts) {
+        this.opts = opts;
+        this.lastGcAt = (opts.now ?? Date.now)();
+    }
+    get ctx() {
+        return { signal: this.opts.signal, workspaceRoot: this.opts.workspaceRoot };
+    }
+    now() {
+        return (this.opts.now ?? Date.now)();
+    }
+    /** Persist full content; returns the workspace-relative path. Runs throttled GC. */
+    async write(toolName, content, toolCallId) {
+        const fileName = buildOffloadFileName(toolName, content, toolCallId);
+        const relPath = `${SUBDIR}/${fileName}`;
+        const dirAbs = join(this.opts.workspaceRoot, SUBDIR);
+        await this.opts.backend.mkdir?.(dirAbs, this.ctx);
+        const absPath = join(this.opts.workspaceRoot, relPath);
+        await this.opts.backend.writeFile(absPath, content, this.ctx);
+        await this.maybeGc();
+        return relPath;
+    }
+    async maybeGc() {
+        const now = this.now();
+        if (now - this.lastGcAt < this.opts.gcThrottleMs)
+            return;
+        this.lastGcAt = now;
+        const { backend } = this.opts;
+        if (!backend.statFile || !backend.removeFile)
+            return; // GC unsupported by backend
+        const dirAbs = join(this.opts.workspaceRoot, SUBDIR);
+        let names;
+        try {
+            names = await backend.listDir(dirAbs, this.ctx);
+        }
+        catch {
+            return; // dir not created yet / unreadable
+        }
+        const entries = [];
+        for (const name of names) {
+            const abs = join(dirAbs, name);
+            try {
+                const s = await backend.statFile(abs, this.ctx);
+                entries.push({ abs, size: s.size, mtimeMs: s.mtimeMs });
+            }
+            catch {
+                /* skip unstattable */
+            }
+        }
+        // TTL pass
+        const ttlCutoff = now - this.opts.ttlMs;
+        const survivors = [];
+        for (const e of entries) {
+            if (e.mtimeMs < ttlCutoff) {
+                await this.safeRemove(e.abs);
+            }
+            else {
+                survivors.push(e);
+            }
+        }
+        // Size pass: oldest-first until under maxBytes
+        let total = survivors.reduce((sum, e) => sum + e.size, 0);
+        if (total <= this.opts.maxBytes)
+            return;
+        survivors.sort((a, b) => a.mtimeMs - b.mtimeMs);
+        for (const e of survivors) {
+            if (total <= this.opts.maxBytes)
+                break;
+            if (await this.safeRemove(e.abs))
+                total -= e.size;
+        }
+    }
+    async safeRemove(abs) {
+        try {
+            await this.opts.backend.removeFile?.(abs, this.ctx);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+}

package/dist/offload/offload-tool-output.d.ts

@@ -0,0 +1,10 @@
+import type { OffloadStore } from "./offload-store.js";
+export interface OffloadToolOutputCtx {
+    readonly toolName: string;
+    readonly thresholdChars: number;
+    readonly previewLines: number;
+    readonly store: Pick<OffloadStore, "write">;
+    readonly toolCallId?: string;
+}
+export declare function offloadToolOutput(content: string, ctx: OffloadToolOutputCtx): Promise<string>;
+//# sourceMappingURL=offload-tool-output.d.ts.map

package/dist/offload/offload-tool-output.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"offload-tool-output.d.ts","sourceRoot":"","sources":["../../src/offload/offload-tool-output.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAA;AAGtD,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;IACzB,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAA;IAC/B,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAA;IAC7B,QAAQ,CAAC,KAAK,EAAE,IAAI,CAAC,YAAY,EAAE,OAAO,CAAC,CAAA;IAC3C,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAA;CAC7B;AAED,wBAAsB,iBAAiB,CACrC,OAAO,EAAE,MAAM,EACf,GAAG,EAAE,oBAAoB,GACxB,OAAO,CAAC,MAAM,CAAC,CAcjB"}

package/dist/offload/offload-tool-output.js

@@ -0,0 +1,18 @@
+import { buildStub } from "./stub.js";
+export async function offloadToolOutput(content, ctx) {
+    if (content.length <= ctx.thresholdChars)
+        return content;
+    try {
+        const relPath = await ctx.store.write(ctx.toolName, content, ctx.toolCallId);
+        return buildStub({
+            content,
+            relPath,
+            previewLines: ctx.previewLines,
+            thresholdChars: ctx.thresholdChars,
+        });
+    }
+    catch {
+        // Never break a tool because offloading failed; keep the original content.
+        return content;
+    }
+}

package/dist/offload/stub.d.ts

@@ -0,0 +1,8 @@
+export interface BuildStubArgs {
+    readonly content: string;
+    readonly relPath: string;
+    readonly previewLines: number;
+    readonly thresholdChars: number;
+}
+export declare function buildStub(args: BuildStubArgs): string;
+//# sourceMappingURL=stub.d.ts.map

package/dist/offload/stub.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stub.d.ts","sourceRoot":"","sources":["../../src/offload/stub.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IACxB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IACxB,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAA;IAC7B,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAA;CAChC;AAED,wBAAgB,SAAS,CAAC,IAAI,EAAE,aAAa,GAAG,MAAM,CAarD"}

package/dist/offload/stub.js

@@ -0,0 +1,14 @@
+export function buildStub(args) {
+    const lines = args.content.split("\n").slice(0, args.previewLines);
+    const shown = lines.length;
+    const preview = lines.join("\n");
+    const chars = args.content.length.toLocaleString("en-US");
+    const threshold = args.thresholdChars.toLocaleString("en-US");
+    return [
+        `[Tool output offloaded — ${chars} chars exceeded the ${threshold}-char limit.`,
+        `Full output saved to: ${args.relPath}`,
+        `Preview (first ${shown} lines):`,
+        preview,
+        `Read the full output with the readFile tool at the path above.]`,
+    ].join("\n");
+}

package/dist/subagent-dispatcher.d.ts

@@ -0,0 +1,33 @@
+export interface SubagentEvent {
+    readonly event: string;
+    readonly data: Record<string, unknown>;
+}
+export interface SubagentStreamContext {
+    /**
+     * Active child-run depth. While > 0, the parent's streamFromRunnable should
+     * suppress on_chat_model_stream emissions because those events are firing
+     * for the child run via LangChain v2 streamEvents async-local-storage
+     * tracing. The dispatcher already emits a `subagent.message` envelope for
+     * each child token, so suppressing avoids duplicates on the parent stream.
+     */
+    activeChildRuns: number;
+}
+export declare function createSubagentStreamContext(): SubagentStreamContext;
+export interface DispatchArgs {
+    readonly childGraph: {
+        invoke: (input: unknown, config: unknown) => Promise<unknown>;
+    };
+    readonly input: string;
+    readonly parentConfig: Record<string, unknown>;
+    readonly writer: (event: SubagentEvent) => void;
+    readonly callId: string;
+    readonly childRouteId: string;
+    readonly subagentName: string;
+    readonly streamContext?: SubagentStreamContext;
+}
+export interface DispatchResult {
+    readonly finalText: string;
+}
+export declare const MAX_SUBAGENT_DEPTH = 3;
+export declare function dispatchSubagent(args: DispatchArgs): Promise<DispatchResult>;
+//# sourceMappingURL=subagent-dispatcher.d.ts.map

package/dist/subagent-dispatcher.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"subagent-dispatcher.d.ts","sourceRoot":"","sources":["../src/subagent-dispatcher.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CACvC;AA2BD,MAAM,WAAW,qBAAqB;IACpC;;;;;;OAMG;IACH,eAAe,EAAE,MAAM,CAAA;CACxB;AAED,wBAAgB,2BAA2B,IAAI,qBAAqB,CAEnE;AAED,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,UAAU,EAAE;QAAE,MAAM,EAAE,CAAC,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,KAAK,OAAO,CAAC,OAAO,CAAC,CAAA;KAAE,CAAA;IACtF,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAC9C,QAAQ,CAAC,MAAM,EAAE,CAAC,KAAK,EAAE,aAAa,KAAK,IAAI,CAAA;IAC/C,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAA;IAC7B,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAA;IAC7B,QAAQ,CAAC,aAAa,CAAC,EAAE,qBAAqB,CAAA;CAC/C;AAED,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;CAC3B;AAED,eAAO,MAAM,kBAAkB,IAAI,CAAA;AA4CnC,wBAAsB,gBAAgB,CAAC,IAAI,EAAE,YAAY,GAAG,OAAO,CAAC,cAAc,CAAC,CA4BlF"}

package/dist/subagent-dispatcher.js

@@ -0,0 +1,182 @@
+export function createSubagentStreamContext() {
+    return { activeChildRuns: 0 };
+}
+export const MAX_SUBAGENT_DEPTH = 3;
+function readDepth(config) {
+    const meta = config?.metadata ?? {};
+    const dawn = meta.dawn ?? {};
+    const depth = dawn.subagent_depth;
+    return typeof depth === "number" ? depth : 0;
+}
+function buildChildConfig(parentConfig, nextDepth, callId) {
+    const parentMeta = parentConfig.metadata ?? {};
+    const parentDawn = parentMeta.dawn ?? {};
+    // Build a CLEAN child config: only Dawn metadata + abort signal.
+    // We deliberately omit `callbacks`, `runId`, `tags`, `runName`, etc. that
+    // LangChain's streamEvents v2 uses to propagate child events to the parent
+    // listener. Without this, every child token would also appear as a raw
+    // chunk on the parent stream (duplicating subagent.message envelopes).
+    const childConfig = {
+        metadata: {
+            // Preserve Dawn-namespaced metadata so depth + thread continuity work,
+            // but drop everything else.
+            dawn: { ...parentDawn, subagent_depth: nextDepth, parent_call_id: callId },
+        },
+    };
+    // Forward the abort signal if the parent provided one — the child should
+    // cancel when the parent cancels.
+    if (parentConfig.signal)
+        childConfig.signal = parentConfig.signal;
+    return childConfig;
+}
+function extractFinalText(graphOutput) {
+    const messages = graphOutput?.messages ?? [];
+    for (let i = messages.length - 1; i >= 0; i--) {
+        const m = messages[i];
+        const kind = typeof m.getType === "function" ? m.getType() : m.type;
+        if (kind === "ai" && typeof m.content === "string")
+            return m.content;
+    }
+    return "";
+}
+export async function dispatchSubagent(args) {
+    const currentDepth = readDepth(args.parentConfig);
+    const nextDepth = currentDepth + 1;
+    if (nextDepth > MAX_SUBAGENT_DEPTH) {
+        return {
+            finalText: `subagent_depth_exceeded: cannot dispatch '${args.subagentName}' at depth ${nextDepth} (max ${MAX_SUBAGENT_DEPTH}).`,
+        };
+    }
+    const childConfig = buildChildConfig(args.parentConfig, nextDepth, args.callId);
+    args.writer({
+        event: "subagent.start",
+        data: {
+            call_id: args.callId,
+            subagent: args.subagentName,
+            route_id: args.childRouteId,
+            depth: nextDepth,
+        },
+    });
+    if (args.streamContext)
+        args.streamContext.activeChildRuns++;
+    try {
+        return await runChild(args, childConfig);
+    }
+    finally {
+        if (args.streamContext)
+            args.streamContext.activeChildRuns--;
+    }
+}
+async function runChild(args, childConfig) {
+    let output;
+    try {
+        const streamable = args.childGraph;
+        if (typeof streamable.dawnStream === "function") {
+            for await (const chunk of streamable.dawnStream({ messages: [{ role: "user", content: args.input }] }, childConfig)) {
+                switch (chunk.type) {
+                    case "done":
+                        output = chunk.output;
+                        break;
+                    case "tool_call":
+                        args.writer({
+                            event: "subagent.tool_call",
+                            data: {
+                                call_id: args.callId,
+                                tool: chunk.name,
+                                input: chunk.input,
+                            },
+                        });
+                        break;
+                    case "tool_result":
+                        args.writer({
+                            event: "subagent.tool_result",
+                            data: {
+                                call_id: args.callId,
+                                tool: chunk.name,
+                                output: chunk.output,
+                            },
+                        });
+                        break;
+                    case "chunk": {
+                        const data = chunk.data;
+                        if (typeof data === "string" && data.length > 0) {
+                            args.writer({
+                                event: "subagent.message",
+                                data: { call_id: args.callId, chunk: data },
+                            });
+                        }
+                        break;
+                    }
+                    default: {
+                        // Capability-contributed events (e.g. plan_update). Prefix with
+                        // subagent. and forward the chunk's data payload verbatim,
+                        // attaching call_id.
+                        const data = chunk.data;
+                        args.writer({
+                            event: `subagent.${chunk.type}`,
+                            data: {
+                                call_id: args.callId,
+                                ...(typeof data === "object" && data !== null ? data : { value: data }),
+                            },
+                        });
+                        break;
+                    }
+                }
+            }
+        }
+        else if (typeof streamable.streamEvents === "function") {
+            for await (const event of streamable.streamEvents({ messages: [{ role: "user", content: args.input }] }, { ...childConfig, version: "v2" })) {
+                switch (event.event) {
+                    case "on_tool_start":
+                        args.writer({
+                            event: "subagent.tool_call",
+                            data: {
+                                call_id: args.callId,
+                                tool: event.name,
+                                input: event.data.chunk ?? event.data.output,
+                            },
+                        });
+                        break;
+                    case "on_tool_end":
+                        args.writer({
+                            event: "subagent.tool_result",
+                            data: { call_id: args.callId, tool: event.name, output: event.data.output },
+                        });
+                        break;
+                    case "on_chat_model_stream": {
+                        const content = event.data.chunk?.content;
+                        if (typeof content === "string" && content.length > 0) {
+                            args.writer({
+                                event: "subagent.message",
+                                data: { call_id: args.callId, chunk: content },
+                            });
+                        }
+                        break;
+                    }
+                    case "on_chain_end":
+                        if (event.name === "LangGraph") {
+                            output = event.data.output;
+                        }
+                        break;
+                }
+            }
+        }
+        else {
+            output = await streamable.invoke({ messages: [{ role: "user", content: args.input }] }, childConfig);
+        }
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        args.writer({
+            event: "subagent.end",
+            data: { call_id: args.callId, error: message },
+        });
+        return { finalText: `subagent_failed: ${message}` };
+    }
+    const finalText = extractFinalText(output);
+    args.writer({
+        event: "subagent.end",
+        data: { call_id: args.callId, final_message: finalText },
+    });
+    return { finalText };
+}

package/dist/subagent-tool-bridge.d.ts

@@ -0,0 +1,27 @@
+import { type SubagentEvent, type SubagentStreamContext } from "./subagent-dispatcher.js";
+export interface SubagentResolverResult {
+    readonly routeId: string;
+    readonly graph: {
+        readonly invoke: (input: unknown, config: unknown) => Promise<unknown>;
+        readonly streamEvents?: (input: unknown, options: Record<string, unknown>) => AsyncIterable<unknown>;
+    };
+}
+export interface BridgeOptions {
+    readonly subagentResolver: (leafName: string) => SubagentResolverResult | undefined;
+    readonly writer: (event: SubagentEvent) => void;
+    readonly parentConfig?: Record<string, unknown>;
+    /**
+     * Shared counter that gates the parent's `on_chat_model_stream` emissions
+     * while a child run is active. See `SubagentStreamContext`.
+     */
+    readonly streamContext?: SubagentStreamContext;
+}
+export interface BridgedTaskTool {
+    readonly name: "task";
+    readonly description: string;
+    readonly run: (input: unknown, context: {
+        readonly signal: AbortSignal;
+    }) => Promise<string>;
+}
+export declare function bridgeSubagentTool(options: BridgeOptions): BridgedTaskTool;
+//# sourceMappingURL=subagent-tool-bridge.d.ts.map

package/dist/subagent-tool-bridge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"subagent-tool-bridge.d.ts","sourceRoot":"","sources":["../src/subagent-tool-bridge.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,aAAa,EAClB,KAAK,qBAAqB,EAC3B,MAAM,0BAA0B,CAAA;AAEjC,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IACxB,QAAQ,CAAC,KAAK,EAAE;QACd,QAAQ,CAAC,MAAM,EAAE,CAAC,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,KAAK,OAAO,CAAC,OAAO,CAAC,CAAA;QACtE,QAAQ,CAAC,YAAY,CAAC,EAAE,CACtB,KAAK,EAAE,OAAO,EACd,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAC7B,aAAa,CAAC,OAAO,CAAC,CAAA;KAC5B,CAAA;CACF;AAED,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,gBAAgB,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,sBAAsB,GAAG,SAAS,CAAA;IACnF,QAAQ,CAAC,MAAM,EAAE,CAAC,KAAK,EAAE,aAAa,KAAK,IAAI,CAAA;IAC/C,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAC/C;;;OAGG;IACH,QAAQ,CAAC,aAAa,CAAC,EAAE,qBAAqB,CAAA;CAC/C;AAED,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAA;IAC5B,QAAQ,CAAC,GAAG,EAAE,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE;QAAE,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAA;KAAE,KAAK,OAAO,CAAC,MAAM,CAAC,CAAA;CAC7F;AASD,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,aAAa,GAAG,eAAe,CA0B1E"}

package/dist/subagent-tool-bridge.js

@@ -0,0 +1,32 @@
+import { dispatchSubagent, } from "./subagent-dispatcher.js";
+const TASK_TOOL_DESCRIPTION = "Dispatch a sub-task to a specialized subagent. See the # Subagents section of your system prompt for available agents and when to use each.";
+function generateCallId() {
+    return `task-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+}
+export function bridgeSubagentTool(options) {
+    return {
+        name: "task",
+        description: TASK_TOOL_DESCRIPTION,
+        run: async (input, _ctx) => {
+            const { subagent, input: taskInput } = input;
+            const resolved = options.subagentResolver(subagent);
+            if (!resolved) {
+                return `subagent_unknown: no subagent named '${subagent}' (resolver returned undefined)`;
+            }
+            // Cast through `never`: dispatcher's `childGraph` type expects a `Streamable`-shaped
+            // graph; resolver returns a slightly different shape with optional streamEvents. The
+            // dispatcher narrows internally via its own type guards.
+            const result = await dispatchSubagent({
+                childGraph: resolved.graph,
+                input: taskInput,
+                parentConfig: options.parentConfig ?? {},
+                writer: options.writer,
+                callId: generateCallId(),
+                childRouteId: resolved.routeId,
+                subagentName: subagent,
+                ...(options.streamContext ? { streamContext: options.streamContext } : {}),
+            });
+            return result.finalText;
+        },
+    };
+}

package/dist/summarization/hook.d.ts

@@ -0,0 +1,31 @@
+import { type BaseMessage } from "@langchain/core/messages";
+export interface RunningSummary {
+    readonly summary: string;
+    readonly coveredCount: number;
+}
+export type TokenCounter = (text: string) => number | Promise<number>;
+export type SummarizeFn = (args: {
+    readonly messages: readonly BaseMessage[];
+    readonly model: string;
+    readonly previousSummary?: string;
+    readonly signal: AbortSignal;
+}) => Promise<string>;
+export interface ResolvedSummarizationConfig {
+    readonly maxTokens: number;
+    readonly keepRecentTurns: number;
+    readonly model: string;
+    readonly tokenCounter: TokenCounter;
+    readonly summarize: SummarizeFn;
+}
+export interface PreModelHookState {
+    readonly messages: BaseMessage[];
+    readonly runningSummary?: RunningSummary;
+}
+export interface PreModelHookResult {
+    llmInputMessages?: BaseMessage[];
+    runningSummary?: RunningSummary;
+}
+export declare function buildSummarizationHook(cfg: ResolvedSummarizationConfig): (state: PreModelHookState, nodeConfig?: {
+    readonly signal?: AbortSignal;
+}) => Promise<PreModelHookResult>;
+//# sourceMappingURL=hook.d.ts.map

package/dist/summarization/hook.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hook.d.ts","sourceRoot":"","sources":["../../src/summarization/hook.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,WAAW,EAAiB,MAAM,0BAA0B,CAAA;AAI1E,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IACxB,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAA;CAC9B;AAED,MAAM,MAAM,YAAY,GAAG,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAA;AAErE,MAAM,MAAM,WAAW,GAAG,CAAC,IAAI,EAAE;IAC/B,QAAQ,CAAC,QAAQ,EAAE,SAAS,WAAW,EAAE,CAAA;IACzC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB,QAAQ,CAAC,eAAe,CAAC,EAAE,MAAM,CAAA;IACjC,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAA;CAC7B,KAAK,OAAO,CAAC,MAAM,CAAC,CAAA;AAErB,MAAM,WAAW,2BAA2B;IAC1C,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;IAC1B,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAA;IAChC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB,QAAQ,CAAC,YAAY,EAAE,YAAY,CAAA;IACnC,QAAQ,CAAC,SAAS,EAAE,WAAW,CAAA;CAChC;AAED,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,QAAQ,EAAE,WAAW,EAAE,CAAA;IAChC,QAAQ,CAAC,cAAc,CAAC,EAAE,cAAc,CAAA;CACzC;AAED,MAAM,WAAW,kBAAkB;IACjC,gBAAgB,CAAC,EAAE,WAAW,EAAE,CAAA;IAChC,cAAc,CAAC,EAAE,cAAc,CAAA;CAChC;AAED,wBAAgB,sBAAsB,CAAC,GAAG,EAAE,2BAA2B,IAEnE,OAAO,iBAAiB,EACxB,aAAa;IAAE,QAAQ,CAAC,MAAM,CAAC,EAAE,WAAW,CAAA;CAAE,KAC7C,OAAO,CAAC,kBAAkB,CAAC,CA0C/B"}

package/dist/summarization/hook.js

@@ -0,0 +1,44 @@
+import { SystemMessage } from "@langchain/core/messages";
+import { splitForSummary } from "./split.js";
+import { countMessagesTokens } from "./token-counter.js";
+export function buildSummarizationHook(cfg) {
+    return async (state, nodeConfig) => {
+        const messages = state.messages ?? [];
+        const total = await countMessagesTokens(messages, cfg.tokenCounter);
+        if (total <= cfg.maxTokens)
+            return {};
+        const prev = state.runningSummary;
+        const coveredCount = prev?.coveredCount ?? 0;
+        const { toSummarize, recent } = splitForSummary(messages, cfg.keepRecentTurns);
+        const newlyAged = toSummarize.slice(coveredCount);
+        let summary = prev?.summary ?? "";
+        if (newlyAged.length > 0) {
+            try {
+                summary = await cfg.summarize({
+                    messages: newlyAged,
+                    model: cfg.model,
+                    ...(prev?.summary ? { previousSummary: prev.summary } : {}),
+                    signal: nodeConfig?.signal ?? new AbortController().signal,
+                });
+            }
+            catch (error) {
+                // Summarization failed this turn — fall back to the FULL history.
+                // We must explicitly set llmInputMessages to the full messages (not
+                // return {}), otherwise a stale condensed view from a prior turn would
+                // remain in the channel and the model would answer without the latest
+                // turn's messages.
+                if (process.env.DAWN_DEBUG_SUMMARIZATION === "1") {
+                    console.warn("[dawn] summarization failed — falling back to full history this turn:", error instanceof Error ? error.message : String(error));
+                }
+                return { llmInputMessages: messages };
+            }
+        }
+        if (!summary)
+            return {};
+        const summaryMessage = new SystemMessage(`Summary of earlier conversation:\n${summary}`);
+        return {
+            llmInputMessages: [summaryMessage, ...recent],
+            runningSummary: { summary, coveredCount: toSummarize.length },
+        };
+    };
+}

package/dist/summarization/index.d.ts

@@ -0,0 +1,5 @@
+export { buildSummarizationHook, type PreModelHookResult, type PreModelHookState, type ResolvedSummarizationConfig, type RunningSummary, type SummarizeFn, type TokenCounter, } from "./hook.js";
+export { splitForSummary } from "./split.js";
+export { defaultSummarize } from "./summarize.js";
+export { countMessagesTokens, defaultTokenCounter } from "./token-counter.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/summarization/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/summarization/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,sBAAsB,EACtB,KAAK,kBAAkB,EACvB,KAAK,iBAAiB,EACtB,KAAK,2BAA2B,EAChC,KAAK,cAAc,EACnB,KAAK,WAAW,EAChB,KAAK,YAAY,GAClB,MAAM,WAAW,CAAA;AAClB,OAAO,EAAE,eAAe,EAAE,MAAM,YAAY,CAAA;AAC5C,OAAO,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAA;AACjD,OAAO,EAAE,mBAAmB,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAA"}