@dawn-ai/langchain 0.1.5 → 0.1.7

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Dawn contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,10 +1,13 @@
+<p>
+  <img src="https://raw.githubusercontent.com/cacheplane/dawnai/main/docs/brand/dawn-logo-horizontal-black-on-white.png" alt="Dawn" width="180" />
+</p>
+
 # @dawn-ai/langchain
 
-LangChain backend adapter for Dawn `chain` route kind.
+LangChain backend adapters Dawn uses to materialize `chain` and `agent` routes (tool conversion, streaming, retry).
+
+This is an internal Dawn workspace package. For Dawn documentation, see <https://dawn-ai.org>.
 
-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)
+## License
 
-This package enables Dawn routes to use LangChain LCEL chains with filesystem-driven tool discovery and Dawn-owned execution semantics.
+MIT

package/dist/agent-adapter.d.ts

@@ -1,8 +1,10 @@
+import type { RetryConfig } from "@dawn-ai/sdk";
 import { type ResolvedStateField } from "./state-adapter.js";
 interface DawnToolDefinition {
     readonly description?: string;
     readonly name: string;
     readonly run: (input: unknown, context: {
+        readonly middleware?: Readonly<Record<string, unknown>>;
         readonly signal: AbortSignal;
     }) => Promise<unknown> | unknown;
     readonly schema?: unknown;
@@ -14,6 +16,8 @@ export interface AgentStreamChunk {
 export interface AgentOptions {
     readonly entry: unknown;
     readonly input: unknown;
+    readonly middlewareContext?: Readonly<Record<string, unknown>>;
+    readonly retry?: RetryConfig;
     readonly routeParamNames: readonly string[];
     readonly signal: AbortSignal;
     readonly stateFields?: readonly ResolvedStateField[];

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

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

package/dist/agent-adapter.js

@@ -1,5 +1,6 @@
 import { isDawnAgent } from "@dawn-ai/sdk";
 import { HumanMessage } from "@langchain/core/messages";
+import { isRetryableError, withRetry } from "./retry.js";
 import { materializeStateSchema } from "./state-adapter.js";
 import { convertToolToLangChain } from "./tool-converter.js";
 function assertAgentLike(entry) {
@@ -11,14 +12,14 @@ function assertAgentLike(entry) {
     }
 }
 const materializedAgents = new WeakMap();
-async function materializeAgent(descriptor, tools, stateFields) {
+async function materializeAgent(descriptor, tools, stateFields, middlewareContext) {
     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));
+    const langchainTools = tools.map((tool) => convertToolToLangChain(tool, middlewareContext));
     const llm = new ChatOpenAI({
         model: descriptor.model,
     });
@@ -49,17 +50,18 @@ export async function* streamAgent(options) {
     const messages = extractMessages(agentInput);
     // DawnAgent descriptor path — materialize on first use
     if (isDawnAgent(options.entry)) {
-        const materializedAgent = await materializeAgent(options.entry, options.tools, options.stateFields);
-        yield* streamFromRunnable(materializedAgent, { messages }, config);
+        const materializedAgent = await materializeAgent(options.entry, options.tools, options.stateFields, options.middlewareContext);
+        const retryConfig = options.entry.retry;
+        yield* streamFromRunnable(materializedAgent, { messages }, config, retryConfig);
         return;
     }
     // Legacy path — raw Runnable with .invoke()
     assertAgentLike(options.entry);
-    const langchainTools = options.tools.map((tool) => convertToolToLangChain(tool));
+    const langchainTools = options.tools.map((tool) => convertToolToLangChain(tool, options.middlewareContext));
     if (langchainTools.length > 0) {
         config.tools = langchainTools;
     }
-    yield* streamFromRunnable(options.entry, { messages }, config);
+    yield* streamFromRunnable(options.entry, { messages }, config, options.retry);
 }
 function prepareAgentCall(options) {
     const inputRecord = (options.input ?? {});
@@ -81,44 +83,83 @@ function prepareAgentCall(options) {
     }
     return { agentInput, config };
 }
-async function* streamFromRunnable(runnable, input, config) {
+async function* streamFromRunnable(runnable, input, config, retryConfig) {
     const streamable = runnable;
     if (typeof streamable.streamEvents !== "function") {
-        // Fallback: invoke and emit a single done event
-        const result = await runnable.invoke(input, config);
+        // Fallback: invoke with retry and emit a single done event
+        const signal = config.signal;
+        const retryOptions = {
+            ...(retryConfig?.maxAttempts ? { maxAttempts: retryConfig.maxAttempts } : {}),
+            ...(retryConfig?.baseDelay ? { baseDelayMs: retryConfig.baseDelay } : {}),
+            ...(signal ? { signal } : {}),
+        };
+        const result = await withRetry(() => runnable.invoke(input, config), Object.keys(retryOptions).length > 0 ? retryOptions : undefined);
         yield { type: "done", data: result };
         return;
     }
     let finalOutput;
-    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) {
-                    yield { type: "token", data: content };
+    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) {
+                            hasYielded = true;
+                            yield { type: "token", data: content };
+                        }
+                        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;
+                        }
+                        break;
+                    }
                 }
-                break;
             }
-            case "on_tool_start": {
-                yield {
-                    type: "tool_call",
-                    data: { name: event.name, input: event.data.chunk ?? event.data.output },
-                };
-                break;
-            }
-            case "on_tool_end": {
-                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;
-                }
-                break;
+            // 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;
             }
+            // Backoff before retry
+            const delay = Math.min(1000 * 2 ** attempt + Math.random() * 500, 10_000);
+            await new Promise((resolve) => setTimeout(resolve, delay));
         }
     }
     yield { type: "done", data: finalOutput };

package/dist/index.d.ts

@@ -1,6 +1,8 @@
 export type { AgentStreamChunk } from "./agent-adapter.js";
 export { executeAgent, streamAgent } from "./agent-adapter.js";
 export { chainAdapter } from "./chain-adapter.js";
+export type { RetryOptions } from "./retry.js";
+export { isRetryableError, withRetry } from "./retry.js";
 export { materializeStateSchema } from "./state-adapter.js";
 export { convertToolToLangChain } from "./tool-converter.js";
 export { executeWithToolLoop } from "./tool-loop.js";

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,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,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"}

package/dist/index.js

@@ -1,5 +1,6 @@
 export { executeAgent, streamAgent } from "./agent-adapter.js";
 export { chainAdapter } from "./chain-adapter.js";
+export { isRetryableError, withRetry } from "./retry.js";
 export { materializeStateSchema } from "./state-adapter.js";
 export { convertToolToLangChain } from "./tool-converter.js";
 export { executeWithToolLoop } from "./tool-loop.js";

package/dist/retry.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Retry with exponential backoff for transient LLM and tool failures.
+ */
+export interface RetryOptions {
+    /** Maximum number of retry attempts (default: 3) */
+    readonly maxAttempts?: number;
+    /** Base delay in ms before first retry (default: 1000) */
+    readonly baseDelayMs?: number;
+    /** Maximum delay in ms (default: 10000) */
+    readonly maxDelayMs?: number;
+    /** Abort signal to cancel retries */
+    readonly signal?: AbortSignal;
+}
+/**
+ * Returns true if the error is transient and the operation should be retried.
+ * Retries on: rate limits (429), server errors (5xx), network errors, timeouts.
+ */
+export declare function isRetryableError(error: unknown): boolean;
+/**
+ * Execute an async function with retry and exponential backoff.
+ * Only retries on transient errors (rate limits, server errors, network issues).
+ */
+export declare function withRetry<T>(fn: () => Promise<T>, options?: RetryOptions): Promise<T>;
+//# sourceMappingURL=retry.d.ts.map

package/dist/retry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"retry.d.ts","sourceRoot":"","sources":["../src/retry.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,MAAM,WAAW,YAAY;IAC3B,oDAAoD;IACpD,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAA;IAC7B,0DAA0D;IAC1D,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAA;IAC7B,2CAA2C;IAC3C,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAA;IAC5B,qCAAqC;IACrC,QAAQ,CAAC,MAAM,CAAC,EAAE,WAAW,CAAA;CAC9B;AAMD;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAyBxD;AAED;;;GAGG;AACH,wBAAsB,SAAS,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC,EAAE,YAAY,GAAG,OAAO,CAAC,CAAC,CAAC,CAwC3F"}

package/dist/retry.js

@@ -0,0 +1,71 @@
+/**
+ * Retry with exponential backoff for transient LLM and tool failures.
+ */
+const DEFAULT_MAX_ATTEMPTS = 3;
+const DEFAULT_BASE_DELAY_MS = 1000;
+const DEFAULT_MAX_DELAY_MS = 10_000;
+/**
+ * Returns true if the error is transient and the operation should be retried.
+ * Retries on: rate limits (429), server errors (5xx), network errors, timeouts.
+ */
+export function isRetryableError(error) {
+    if (!(error instanceof Error))
+        return false;
+    const message = error.message.toLowerCase();
+    // Rate limit errors
+    if (message.includes("429") || message.includes("rate limit"))
+        return true;
+    // Server errors (5xx)
+    if (message.includes("500") || message.includes("502") || message.includes("503"))
+        return true;
+    // Network/timeout errors
+    if (message.includes("econnreset") ||
+        message.includes("econnrefused") ||
+        message.includes("etimedout") ||
+        message.includes("timeout") ||
+        message.includes("network"))
+        return true;
+    // OpenAI-specific transient errors
+    if (message.includes("overloaded") || message.includes("server_error"))
+        return true;
+    return false;
+}
+/**
+ * Execute an async function with retry and exponential backoff.
+ * Only retries on transient errors (rate limits, server errors, network issues).
+ */
+export async function withRetry(fn, options) {
+    const maxAttempts = options?.maxAttempts ?? DEFAULT_MAX_ATTEMPTS;
+    const baseDelayMs = options?.baseDelayMs ?? DEFAULT_BASE_DELAY_MS;
+    const maxDelayMs = options?.maxDelayMs ?? DEFAULT_MAX_DELAY_MS;
+    const signal = options?.signal;
+    let lastError;
+    for (let attempt = 0; attempt < maxAttempts; attempt++) {
+        if (signal?.aborted) {
+            throw new Error("Operation aborted");
+        }
+        try {
+            return await fn();
+        }
+        catch (error) {
+            lastError = error instanceof Error ? error : new Error(String(error));
+            // Don't retry non-transient errors or on the last attempt
+            if (!isRetryableError(error) || attempt === maxAttempts - 1) {
+                throw lastError;
+            }
+            // Exponential backoff with jitter
+            const delay = Math.min(baseDelayMs * 2 ** attempt + Math.random() * 500, maxDelayMs);
+            await new Promise((resolve, reject) => {
+                const timeout = setTimeout(resolve, delay);
+                if (signal) {
+                    const onAbort = () => {
+                        clearTimeout(timeout);
+                        reject(new Error("Operation aborted"));
+                    };
+                    signal.addEventListener("abort", onAbort, { once: true });
+                }
+            });
+        }
+    }
+    throw lastError ?? new Error("Retry exhausted");
+}

package/dist/tool-converter.d.ts

@@ -3,10 +3,11 @@ interface DawnToolDefinition {
     readonly description?: string;
     readonly name: string;
     readonly run: (input: unknown, context: {
+        readonly middleware?: Readonly<Record<string, unknown>>;
         readonly signal: AbortSignal;
     }) => Promise<unknown> | unknown;
     readonly schema?: unknown;
 }
-export declare function convertToolToLangChain(tool: DawnToolDefinition): DynamicStructuredTool;
+export declare function convertToolToLangChain(tool: DawnToolDefinition, middlewareContext?: Readonly<Record<string, unknown>>): DynamicStructuredTool;
 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;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"}
+{"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"}

package/dist/tool-converter.js

@@ -1,6 +1,6 @@
 import { DynamicStructuredTool } from "@langchain/core/tools";
 import { z } from "zod";
-export function convertToolToLangChain(tool) {
+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)
@@ -10,7 +10,10 @@ export function convertToolToLangChain(tool) {
         schema: schema,
         func: async (input, _runManager, config) => {
             const signal = config?.signal ?? new AbortController().signal;
-            const result = await tool.run(input, { signal });
+            const result = await tool.run(input, {
+                ...(middlewareContext ? { middleware: middlewareContext } : {}),
+                signal,
+            });
             return JSON.stringify(result);
         },
     });

package/dist/tool-loop.d.ts

@@ -1,6 +1,7 @@
 interface ToolExecutor {
     readonly name: string;
     readonly run: (input: unknown, context: {
+        readonly middleware?: Readonly<Record<string, unknown>>;
         readonly signal: AbortSignal;
     }) => Promise<unknown> | unknown;
 }
@@ -9,6 +10,7 @@ export interface ExecuteWithToolLoopOptions {
         readonly invoke: (input: unknown) => Promise<unknown>;
     };
     readonly input: unknown;
+    readonly middlewareContext?: Readonly<Record<string, unknown>>;
     readonly tools: readonly ToolExecutor[];
     readonly signal: AbortSignal;
     readonly maxIterations?: number;

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

@@ -1 +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"}
+{"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;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;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,iBAAiB,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAA;IAC9D,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,CAwD/F"}

package/dist/tool-loop.js

@@ -1,7 +1,7 @@
 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 { chain, input, middlewareContext, 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++) {
@@ -18,7 +18,10 @@ export async function executeWithToolLoop(options) {
                 });
             }
             try {
-                const output = await tool.run(call.args, { signal });
+                const output = await tool.run(call.args, {
+                    ...(middlewareContext ? { middleware: middlewareContext } : {}),
+                    signal,
+                });
                 return new ToolMessage({
                     content: JSON.stringify(output),
                     tool_call_id: call.id ?? "",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dawn-ai/langchain",
-  "version": "0.1.5",
+  "version": "0.1.7",
   "private": false,
   "type": "module",
   "license": "MIT",
@@ -32,7 +32,7 @@
   "dependencies": {
     "@langchain/langgraph": "^0.2.71",
     "@langchain/openai": "^0.3.17",
-    "@dawn-ai/sdk": "0.1.5"
+    "@dawn-ai/sdk": "0.1.7"
   },
   "peerDependencies": {
     "@langchain/core": ">=0.3.0"
@@ -43,7 +43,7 @@
     "@langchain/openai": "0.3.17",
     "@types/node": "25.6.0",
     "zod": "3.24.4",
-    "@dawn-ai/config-typescript": "0.1.5"
+    "@dawn-ai/config-typescript": "0.1.7"
   },
   "scripts": {
     "build": "tsc -b tsconfig.json",