@dawn-ai/langchain 0.1.8 → 0.2.0

package/dist/chat-model-factory.js

@@ -0,0 +1,49 @@
+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;
+    }
+    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,19 @@
-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 { 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 { 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 { 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,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,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,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"}

package/dist/index.js

@@ -1,6 +1,12 @@
-export { executeAgent, streamAgent } from "./agent-adapter.js";
+export { Command } from "@langchain/langgraph";
+export { 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 { 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 { 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/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/tool-converter.d.ts

@@ -1,4 +1,6 @@
+import type { JsonSchemaProperty } from "@dawn-ai/core";
 import { DynamicStructuredTool } from "@langchain/core/tools";
+import { z } from "zod";
 interface DawnToolDefinition {
     readonly description?: string;
     readonly name: string;
@@ -9,5 +11,6 @@ interface DawnToolDefinition {
     readonly schema?: unknown;
 }
 export declare function convertToolToLangChain(tool: DawnToolDefinition, middlewareContext?: Readonly<Record<string, unknown>>): DynamicStructuredTool;
+export declare function jsonSchemaToZod(schema: JsonSchemaProperty): z.ZodObject<z.ZodRawShape>;
 export {};
 //# sourceMappingURL=tool-converter.d.ts.map

package/dist/tool-converter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tool-converter.d.ts","sourceRoot":"","sources":["../src/tool-converter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAAE,MAAM,uBAAuB,CAAA;AAG7D,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;AAED,wBAAgB,sBAAsB,CACpC,IAAI,EAAE,kBAAkB,EACxB,iBAAiB,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GACpD,qBAAqB,CAkBvB"}
+{"version":3,"file":"tool-converter.d.ts","sourceRoot":"","sources":["../src/tool-converter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAA;AAEvD,OAAO,EAAE,qBAAqB,EAAE,MAAM,uBAAuB,CAAA;AAE7D,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAGvB,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;AAED,wBAAgB,sBAAsB,CACpC,IAAI,EAAE,kBAAkB,EACxB,iBAAiB,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GACpD,qBAAqB,CAkCvB;AA6BD,wBAAgB,eAAe,CAAC,MAAM,EAAE,kBAAkB,GAAG,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,WAAW,CAAC,CAEtF"}

package/dist/tool-converter.js

@@ -1,20 +1,37 @@
+import { ToolMessage } from "@langchain/core/messages";
 import { DynamicStructuredTool } from "@langchain/core/tools";
+import { Command } from "@langchain/langgraph";
 import { z } from "zod";
+import { unwrapToolResult } from "./unwrap-tool-result.js";
 export function convertToolToLangChain(tool, middlewareContext) {
     const schema = toZodSchema(tool.schema);
-    // Cast through unknown to bridge the dual-Zod version type incompatibility
-    // (package uses zod@3.24.4; @langchain/core uses zod@3.25.x — structurally identical at runtime)
     return new DynamicStructuredTool({
         name: tool.name,
         description: tool.description ?? "",
-        schema: schema,
+        schema,
         func: async (input, _runManager, config) => {
             const signal = config?.signal ?? new AbortController().signal;
-            const result = await tool.run(input, {
+            const rawResult = await tool.run(input, {
                 ...(middlewareContext ? { middleware: middlewareContext } : {}),
                 signal,
             });
-            return JSON.stringify(result);
+            const { content, stateUpdates } = unwrapToolResult(rawResult);
+            if (stateUpdates) {
+                const toolCallId = extractToolCallId(config);
+                return new Command({
+                    update: {
+                        ...stateUpdates,
+                        messages: [
+                            new ToolMessage({
+                                content,
+                                tool_call_id: toolCallId,
+                                name: tool.name,
+                            }),
+                        ],
+                    },
+                });
+            }
+            return content;
         },
     });
 }
@@ -38,22 +55,42 @@ function isJsonSchemaObject(value) {
         value.type === "object" &&
         typeof value.properties === "object");
 }
-function jsonSchemaToZod(schema) {
+const MAX_ZOD_DEPTH = 8;
+export function jsonSchemaToZod(schema) {
+    return objectToZod(schema, 0);
+}
+function objectToZod(prop, depth) {
+    // Record<string,T>: schema-valued additionalProperties and no named properties.
+    if (typeof prop.additionalProperties === "object" &&
+        prop.additionalProperties !== null &&
+        (!prop.properties || Object.keys(prop.properties).length === 0)) {
+        return z.record(z.string(), jsonSchemaFieldToZod(prop.additionalProperties, depth + 1));
+    }
     const shape = {};
-    const required = new Set(schema.required ?? []);
-    for (const [key, prop] of Object.entries(schema.properties ?? {})) {
-        let field = jsonSchemaFieldToZod(prop);
-        if (!required.has(key)) {
+    const required = new Set(prop.required ?? []);
+    for (const [key, sub] of Object.entries(prop.properties ?? {})) {
+        let field = jsonSchemaFieldToZod(sub, depth + 1);
+        if (!required.has(key))
             field = field.optional();
-        }
         shape[key] = field;
     }
     return z.object(shape);
 }
-function jsonSchemaFieldToZod(prop) {
+function jsonSchemaFieldToZod(prop, depth = 0) {
+    if (depth > MAX_ZOD_DEPTH)
+        return z.string();
+    // Object unions are emitted as anyOf (no `type`); map to z.union.
+    if (prop.anyOf && prop.anyOf.length > 0) {
+        const members = prop.anyOf.map((m) => jsonSchemaFieldToZod(m, depth + 1));
+        if (members.length === 1)
+            return members[0] ?? z.unknown();
+        return z.union(members);
+    }
     switch (prop.type) {
         case "string":
-            return z.string();
+            return prop.enum && prop.enum.length > 0
+                ? z.enum([...prop.enum])
+                : z.string();
         case "number":
         case "integer":
             return z.number();
@@ -61,15 +98,28 @@ function jsonSchemaFieldToZod(prop) {
             return z.boolean();
         case "array": {
             const items = prop.items;
-            if (items?.type === "string")
-                return z.array(z.string());
-            if (items?.type === "number" || items?.type === "integer")
-                return z.array(z.number());
-            if (items?.type === "boolean")
-                return z.array(z.boolean());
-            return z.array(z.unknown());
+            return items ? z.array(jsonSchemaFieldToZod(items, depth + 1)) : z.array(z.unknown());
         }
+        case "object":
+            return objectToZod(prop, depth);
         default:
             return z.unknown();
     }
 }
+function extractToolCallId(config) {
+    if (typeof config !== "object" || config === null)
+        return "";
+    const c = config;
+    // LangGraph 1.x exposes the tool call id in different ways depending on
+    // the calling code path; try the most likely locations.
+    const direct = c.toolCall?.id;
+    if (typeof direct === "string")
+        return direct;
+    const configurable = c.configurable;
+    if (typeof configurable?.toolCallId === "string")
+        return configurable.toolCallId;
+    const metadata = c.metadata;
+    if (typeof metadata?.tool_call_id === "string")
+        return metadata.tool_call_id;
+    return "";
+}

package/dist/unwrap-tool-result.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Result of unwrapping a tool's return value.
+ *
+ * - `content` is the string that becomes the ToolMessage content the agent sees.
+ *   Built rules:
+ *     • If the tool returned a wrapped `{result}` shape and `result` is a string,
+ *       `content` is that string verbatim (no JSON quoting).
+ *     • If `result` is any other value, `content` is `JSON.stringify(result)`.
+ *     • If the tool returned a plain value (no wrapper), `content` is
+ *       `JSON.stringify(value)`.
+ *
+ * - `stateUpdates` is the partial state-channel update object to apply, or
+ *   undefined if the tool didn't request any state mutation.
+ */
+export interface UnwrappedToolResult {
+    readonly content: string;
+    readonly stateUpdates: Record<string, unknown> | undefined;
+}
+/**
+ * Detect whether a tool's return value uses the Dawn wrapper shape
+ * `{result, state?}` and split it into the agent-facing `content` and the
+ * optional `stateUpdates` for the route's state channels.
+ *
+ * The wrapper shape is recognized strictly: the value must be a non-null
+ * plain object whose own enumerable keys are exactly `result`, or exactly
+ * `result` and `state`. Any other shape (including objects with extra keys,
+ * missing `result`, or arrays) falls through to plain-return handling.
+ *
+ * Edge case: if a tool returns `{result: undefined}`, the wrapper IS detected
+ * structurally but the resulting `content` would be the string "undefined"
+ * (JSON.stringify(undefined) === undefined). We treat this as plain — capability
+ * authors should never return undefined as the agent-facing result.
+ */
+export declare function unwrapToolResult(value: unknown): UnwrappedToolResult;
+//# sourceMappingURL=unwrap-tool-result.d.ts.map

package/dist/unwrap-tool-result.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unwrap-tool-result.d.ts","sourceRoot":"","sources":["../src/unwrap-tool-result.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IACxB,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,CAAA;CAC3D;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,OAAO,GAAG,mBAAmB,CAoBpE"}