@dawn-ai/langchain 0.0.2

package/README.md

@@ -0,0 +1,10 @@
+# @dawn-ai/langchain
+
+LangChain backend adapter for Dawn `chain` route kind.
+
+Public surface:
+- `ChainAdapter` — `BackendAdapter` implementation for LCEL runnables
+- `convertTools()` — converts Dawn tools to LangChain `DynamicStructuredTool`
+- `toolLoop()` — Dawn-owned ReAct tool execution loop (no AgentExecutor dependency)
+
+This package enables Dawn routes to use LangChain LCEL chains with filesystem-driven tool discovery and Dawn-owned execution semantics.

package/dist/chain-adapter.d.ts

@@ -0,0 +1,3 @@
+import type { BackendAdapter } from "@dawn-ai/sdk";
+export declare const chainAdapter: BackendAdapter;
+//# sourceMappingURL=chain-adapter.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"chain-adapter.d.ts","sourceRoot":"","sources":["../src/chain-adapter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,cAAc,CAAA;AAqBlD,eAAO,MAAM,YAAY,EAAE,cA+B1B,CAAA"}

package/dist/chain-adapter.js

@@ -0,0 +1,27 @@
+function assertRunnableLike(entry) {
+    if (typeof entry !== "object" ||
+        entry === null ||
+        !("invoke" in entry) ||
+        typeof entry.invoke !== "function") {
+        throw new Error("Chain entry must expose invoke(input) — expected a LangChain Runnable");
+    }
+}
+export const chainAdapter = {
+    kind: "chain",
+    async execute(entry, input, context) {
+        assertRunnableLike(entry);
+        return await entry.invoke(input, { signal: context.signal });
+    },
+    async *stream(entry, input, context) {
+        assertRunnableLike(entry);
+        if (typeof entry.stream !== "function") {
+            yield await entry.invoke(input, { signal: context.signal });
+            return;
+        }
+        const streamResult = entry.stream(input, { signal: context.signal });
+        const iterable = streamResult instanceof Promise ? await streamResult : streamResult;
+        for await (const chunk of iterable) {
+            yield chunk;
+        }
+    },
+};

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export { chainAdapter } from "./chain-adapter.js";
+export { convertToolToLangChain } from "./tool-converter.js";
+export { executeWithToolLoop } from "./tool-loop.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAA;AACjD,OAAO,EAAE,sBAAsB,EAAE,MAAM,qBAAqB,CAAA;AAC5D,OAAO,EAAE,mBAAmB,EAAE,MAAM,gBAAgB,CAAA"}

package/dist/index.js

@@ -0,0 +1,3 @@
+export { chainAdapter } from "./chain-adapter.js";
+export { convertToolToLangChain } from "./tool-converter.js";
+export { executeWithToolLoop } from "./tool-loop.js";

package/dist/tool-converter.d.ts

@@ -0,0 +1,12 @@
+import { DynamicStructuredTool } from "@langchain/core/tools";
+interface DawnToolDefinition {
+    readonly description?: string;
+    readonly name: string;
+    readonly run: (input: unknown, context: {
+        readonly signal: AbortSignal;
+    }) => Promise<unknown> | unknown;
+    readonly schema?: unknown;
+}
+export declare function convertToolToLangChain(tool: DawnToolDefinition): DynamicStructuredTool;
+export {};
+//# sourceMappingURL=tool-converter.d.ts.map

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

@@ -0,0 +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;QAAE,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAA;KAAE,KACtC,OAAO,CAAC,OAAO,CAAC,GAAG,OAAO,CAAA;IAC/B,QAAQ,CAAC,MAAM,CAAC,EAAE,OAAO,CAAA;CAC1B;AAED,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,kBAAkB,GAAG,qBAAqB,CAetF"}

package/dist/tool-converter.js

@@ -0,0 +1,24 @@
+import { DynamicStructuredTool } from "@langchain/core/tools";
+import { z } from "zod";
+export function convertToolToLangChain(tool) {
+    const schema = isZodObject(tool.schema) ? tool.schema : z.record(z.string(), z.unknown());
+    // 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,
+        func: async (input, _runManager, config) => {
+            const signal = config?.signal ?? new AbortController().signal;
+            const result = await tool.run(input, { signal });
+            return JSON.stringify(result);
+        },
+    });
+}
+function isZodObject(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        "_def" in value &&
+        typeof value._def === "object" &&
+        value._def !== null);
+}

package/dist/tool-loop.d.ts

@@ -0,0 +1,18 @@
+interface ToolExecutor {
+    readonly name: string;
+    readonly run: (input: unknown, context: {
+        readonly signal: AbortSignal;
+    }) => Promise<unknown> | unknown;
+}
+export interface ExecuteWithToolLoopOptions {
+    readonly chain: {
+        readonly invoke: (input: unknown) => Promise<unknown>;
+    };
+    readonly input: unknown;
+    readonly tools: readonly ToolExecutor[];
+    readonly signal: AbortSignal;
+    readonly maxIterations?: number;
+}
+export declare function executeWithToolLoop(options: ExecuteWithToolLoopOptions): Promise<unknown>;
+export {};
+//# sourceMappingURL=tool-loop.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tool-loop.d.ts","sourceRoot":"","sources":["../src/tool-loop.ts"],"names":[],"mappings":"AAIA,UAAU,YAAY;IACpB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,GAAG,EAAE,CACZ,KAAK,EAAE,OAAO,EACd,OAAO,EAAE;QAAE,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAA;KAAE,KACtC,OAAO,CAAC,OAAO,CAAC,GAAG,OAAO,CAAA;CAChC;AAED,MAAM,WAAW,0BAA0B;IACzC,QAAQ,CAAC,KAAK,EAAE;QAAE,QAAQ,CAAC,MAAM,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,OAAO,CAAC,OAAO,CAAC,CAAA;KAAE,CAAA;IACzE,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAA;IACvB,QAAQ,CAAC,KAAK,EAAE,SAAS,YAAY,EAAE,CAAA;IACvC,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAA;IAC5B,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAA;CAChC;AAED,wBAAsB,mBAAmB,CAAC,OAAO,EAAE,0BAA0B,GAAG,OAAO,CAAC,OAAO,CAAC,CA8C/F"}

package/dist/tool-loop.js

@@ -0,0 +1,48 @@
+import { AIMessage, ToolMessage } from "@langchain/core/messages";
+const DEFAULT_MAX_ITERATIONS = 10;
+export async function executeWithToolLoop(options) {
+    const { chain, input, tools, signal, maxIterations = DEFAULT_MAX_ITERATIONS } = options;
+    const toolMap = new Map(tools.map((t) => [t.name, t]));
+    let currentInput = input;
+    for (let i = 0; i < maxIterations; i++) {
+        const result = await chain.invoke(currentInput);
+        if (!isAIMessageWithToolCalls(result)) {
+            return result;
+        }
+        const toolMessages = await Promise.all(result.tool_calls.map(async (call) => {
+            const tool = toolMap.get(call.name);
+            if (!tool) {
+                return new ToolMessage({
+                    content: JSON.stringify({ error: `Unknown tool: ${call.name}` }),
+                    tool_call_id: call.id ?? "",
+                });
+            }
+            try {
+                const output = await tool.run(call.args, { signal });
+                return new ToolMessage({
+                    content: JSON.stringify(output),
+                    tool_call_id: call.id ?? "",
+                });
+            }
+            catch (error) {
+                return new ToolMessage({
+                    content: JSON.stringify({
+                        error: error instanceof Error ? error.message : String(error),
+                    }),
+                    tool_call_id: call.id ?? "",
+                });
+            }
+        }));
+        currentInput = [
+            ...(Array.isArray(currentInput) ? currentInput : []),
+            result,
+            ...toolMessages,
+        ];
+    }
+    throw new Error(`Tool execution loop exceeded maximum ${maxIterations} iterations`);
+}
+function isAIMessageWithToolCalls(value) {
+    return (value instanceof AIMessage &&
+        Array.isArray(value.tool_calls) &&
+        value.tool_calls.length > 0);
+}

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@dawn-ai/langchain",
+  "version": "0.0.2",
+  "private": false,
+  "type": "module",
+  "license": "MIT",
+  "homepage": "https://github.com/cacheplane/dawnai/tree/main/packages/langchain#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/cacheplane/dawnai.git",
+    "directory": "packages/langchain"
+  },
+  "bugs": {
+    "url": "https://github.com/cacheplane/dawnai/issues"
+  },
+  "engines": {
+    "node": ">=22.12.0"
+  },
+  "files": [
+    "dist"
+  ],
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@dawn-ai/sdk": "0.0.2"
+  },
+  "peerDependencies": {
+    "@langchain/core": ">=0.3.0"
+  },
+  "devDependencies": {
+    "@langchain/core": "0.3.62",
+    "@types/node": "25.6.0",
+    "zod": "3.24.4",
+    "@dawn-ai/config-typescript": "0.0.2"
+  },
+  "scripts": {
+    "build": "tsc -b tsconfig.json",
+    "lint": "biome check --config-path ../config-biome/biome.json package.json src test tsconfig.json vitest.config.ts",
+    "test": "vitest --run --config vitest.config.ts",
+    "typecheck": "tsc --noEmit"
+  }
+}