langchain 1.0.0-alpha.7 → 1.0.0-alpha.9

package/dist/agents/middleware/modelFallback.cjs

@@ -0,0 +1,74 @@
+const require_chat_models_universal = require('../../chat_models/universal.cjs');
+const require_middleware = require('../middleware.cjs');
+
+//#region src/agents/middleware/modelFallback.ts
+/**
+* Middleware that provides automatic model fallback on errors.
+*
+* This middleware attempts to retry failed model calls with alternative models
+* in sequence. When a model call fails, it tries the next model in the fallback
+* list until either a call succeeds or all models have been exhausted.
+*
+* @example
+* ```ts
+* import { createAgent, modelFallbackMiddleware } from "langchain";
+*
+* // Create middleware with fallback models (not including primary)
+* const fallback = modelFallbackMiddleware({
+*   "openai:gpt-4o-mini",  // First fallback
+*   "anthropic:claude-3-5-sonnet-20241022",  // Second fallback
+* });
+*
+* const agent = createAgent({
+*   model: "openai:gpt-4o",  // Primary model
+*   middleware: [fallback],
+*   tools: [],
+* });
+*
+* // If gpt-4o fails, automatically tries gpt-4o-mini, then claude
+* const result = await agent.invoke({
+*   messages: [{ role: "user", content: "Hello" }]
+* });
+* ```
+*
+* @param fallbackModels - The fallback models to try, in order.
+* @returns A middleware instance that handles model failures with fallbacks
+*/
+function modelFallbackMiddleware(...fallbackModels) {
+	return require_middleware.createMiddleware({
+		name: "modelFallbackMiddleware",
+		wrapModelCall: async (request, handler) => {
+			/**
+			* Try the primary model first
+			*/
+			try {
+				return await handler(request);
+			} catch (error) {
+				/**
+				* If primary model fails, try fallback models in sequence
+				*/
+				for (let i = 0; i < fallbackModels.length; i++) try {
+					const fallbackModel = fallbackModels[i];
+					const model = typeof fallbackModel === "string" ? await require_chat_models_universal.initChatModel(fallbackModel) : fallbackModel;
+					return await handler({
+						...request,
+						model
+					});
+				} catch (fallbackError) {
+					/**
+					* If this is the last fallback, throw the error
+					*/
+					if (i === fallbackModels.length - 1) throw fallbackError;
+				}
+				/**
+				* If no fallbacks were provided, re-throw the original error
+				*/
+				throw error;
+			}
+		}
+	});
+}
+
+//#endregion
+exports.modelFallbackMiddleware = modelFallbackMiddleware;
+//# sourceMappingURL=modelFallback.cjs.map

package/dist/agents/middleware/modelFallback.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"modelFallback.cjs","names":["createMiddleware","initChatModel"],"sources":["../../../src/agents/middleware/modelFallback.ts"],"sourcesContent":["import type { LanguageModelLike } from \"@langchain/core/language_models/base\";\nimport { initChatModel } from \"../../chat_models/universal.js\";\nimport type { AgentMiddleware } from \"./types.js\";\nimport { createMiddleware } from \"../middleware.js\";\n\n/**\n * Middleware that provides automatic model fallback on errors.\n *\n * This middleware attempts to retry failed model calls with alternative models\n * in sequence. When a model call fails, it tries the next model in the fallback\n * list until either a call succeeds or all models have been exhausted.\n *\n * @example\n * ```ts\n * import { createAgent, modelFallbackMiddleware } from \"langchain\";\n *\n * // Create middleware with fallback models (not including primary)\n * const fallback = modelFallbackMiddleware({\n *   \"openai:gpt-4o-mini\",  // First fallback\n *   \"anthropic:claude-3-5-sonnet-20241022\",  // Second fallback\n * });\n *\n * const agent = createAgent({\n *   model: \"openai:gpt-4o\",  // Primary model\n *   middleware: [fallback],\n *   tools: [],\n * });\n *\n * // If gpt-4o fails, automatically tries gpt-4o-mini, then claude\n * const result = await agent.invoke({\n *   messages: [{ role: \"user\", content: \"Hello\" }]\n * });\n * ```\n *\n * @param fallbackModels - The fallback models to try, in order.\n * @returns A middleware instance that handles model failures with fallbacks\n */\nexport function modelFallbackMiddleware(\n  /**\n   * The fallback models to try, in order.\n   */\n  ...fallbackModels: (string | LanguageModelLike)[]\n): AgentMiddleware {\n  return createMiddleware({\n    name: \"modelFallbackMiddleware\",\n    wrapModelCall: async (request, handler) => {\n      /**\n       * Try the primary model first\n       */\n      try {\n        return await handler(request);\n      } catch (error) {\n        /**\n         * If primary model fails, try fallback models in sequence\n         */\n        for (let i = 0; i < fallbackModels.length; i++) {\n          try {\n            const fallbackModel = fallbackModels[i];\n            const model =\n              typeof fallbackModel === \"string\"\n                ? await initChatModel(fallbackModel)\n                : fallbackModel;\n\n            return await handler({\n              ...request,\n              model,\n            });\n          } catch (fallbackError) {\n            /**\n             * If this is the last fallback, throw the error\n             */\n            if (i === fallbackModels.length - 1) {\n              throw fallbackError;\n            }\n            // Otherwise, continue to next fallback\n          }\n        }\n        /**\n         * If no fallbacks were provided, re-throw the original error\n         */\n        throw error;\n      }\n    },\n  });\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqCA,SAAgB,wBAId,GAAG,gBACc;AACjB,QAAOA,oCAAiB;EACtB,MAAM;EACN,eAAe,OAAO,SAAS,YAAY;;;;AAIzC,OAAI;AACF,WAAO,MAAM,QAAQ,QAAQ;GAC9B,SAAQ,OAAO;;;;AAId,SAAK,IAAI,IAAI,GAAG,IAAI,eAAe,QAAQ,IACzC,KAAI;KACF,MAAM,gBAAgB,eAAe;KACrC,MAAM,QACJ,OAAO,kBAAkB,WACrB,MAAMC,4CAAc,cAAc,GAClC;AAEN,YAAO,MAAM,QAAQ;MACnB,GAAG;MACH;KACD,EAAC;IACH,SAAQ,eAAe;;;;AAItB,SAAI,MAAM,eAAe,SAAS,EAChC,OAAM;IAGT;;;;AAKH,UAAM;GACP;EACF;CACF,EAAC;AACH"}

package/dist/agents/middleware/modelFallback.d.cts

@@ -0,0 +1,45 @@
+import { AgentMiddleware } from "./types.cjs";
+import { LanguageModelLike } from "@langchain/core/language_models/base";
+
+//#region src/agents/middleware/modelFallback.d.ts
+
+/**
+ * Middleware that provides automatic model fallback on errors.
+ *
+ * This middleware attempts to retry failed model calls with alternative models
+ * in sequence. When a model call fails, it tries the next model in the fallback
+ * list until either a call succeeds or all models have been exhausted.
+ *
+ * @example
+ * ```ts
+ * import { createAgent, modelFallbackMiddleware } from "langchain";
+ *
+ * // Create middleware with fallback models (not including primary)
+ * const fallback = modelFallbackMiddleware({
+ *   "openai:gpt-4o-mini",  // First fallback
+ *   "anthropic:claude-3-5-sonnet-20241022",  // Second fallback
+ * });
+ *
+ * const agent = createAgent({
+ *   model: "openai:gpt-4o",  // Primary model
+ *   middleware: [fallback],
+ *   tools: [],
+ * });
+ *
+ * // If gpt-4o fails, automatically tries gpt-4o-mini, then claude
+ * const result = await agent.invoke({
+ *   messages: [{ role: "user", content: "Hello" }]
+ * });
+ * ```
+ *
+ * @param fallbackModels - The fallback models to try, in order.
+ * @returns A middleware instance that handles model failures with fallbacks
+ */
+declare function modelFallbackMiddleware(
+/**
+ * The fallback models to try, in order.
+ */
+...fallbackModels: (string | LanguageModelLike)[]): AgentMiddleware;
+//#endregion
+export { modelFallbackMiddleware };
+//# sourceMappingURL=modelFallback.d.cts.map

package/dist/agents/middleware/modelFallback.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"modelFallback.d.cts","names":["LanguageModelLike","AgentMiddleware","modelFallbackMiddleware"],"sources":["../../../src/agents/middleware/modelFallback.d.ts"],"sourcesContent":["import type { LanguageModelLike } from \"@langchain/core/language_models/base\";\nimport type { AgentMiddleware } from \"./types.js\";\n/**\n * Middleware that provides automatic model fallback on errors.\n *\n * This middleware attempts to retry failed model calls with alternative models\n * in sequence. When a model call fails, it tries the next model in the fallback\n * list until either a call succeeds or all models have been exhausted.\n *\n * @example\n * ```ts\n * import { createAgent, modelFallbackMiddleware } from \"langchain\";\n *\n * // Create middleware with fallback models (not including primary)\n * const fallback = modelFallbackMiddleware({\n *   \"openai:gpt-4o-mini\",  // First fallback\n *   \"anthropic:claude-3-5-sonnet-20241022\",  // Second fallback\n * });\n *\n * const agent = createAgent({\n *   model: \"openai:gpt-4o\",  // Primary model\n *   middleware: [fallback],\n *   tools: [],\n * });\n *\n * // If gpt-4o fails, automatically tries gpt-4o-mini, then claude\n * const result = await agent.invoke({\n *   messages: [{ role: \"user\", content: \"Hello\" }]\n * });\n * ```\n *\n * @param fallbackModels - The fallback models to try, in order.\n * @returns A middleware instance that handles model failures with fallbacks\n */\nexport declare function modelFallbackMiddleware(\n/**\n * The fallback models to try, in order.\n */\n...fallbackModels: (string | LanguageModelLike)[]): AgentMiddleware;\n"],"mappings":";;;;;;;AAkCA;;;;AAImE;;;;;;;;;;;;;;;;;;;;;;;;;;iBAJ3CE,uBAAAA;;;;6BAIKF,uBAAuBC"}

package/dist/agents/middleware/modelFallback.d.ts

@@ -0,0 +1,45 @@
+import { AgentMiddleware } from "./types.js";
+import { LanguageModelLike } from "@langchain/core/language_models/base";
+
+//#region src/agents/middleware/modelFallback.d.ts
+
+/**
+ * Middleware that provides automatic model fallback on errors.
+ *
+ * This middleware attempts to retry failed model calls with alternative models
+ * in sequence. When a model call fails, it tries the next model in the fallback
+ * list until either a call succeeds or all models have been exhausted.
+ *
+ * @example
+ * ```ts
+ * import { createAgent, modelFallbackMiddleware } from "langchain";
+ *
+ * // Create middleware with fallback models (not including primary)
+ * const fallback = modelFallbackMiddleware({
+ *   "openai:gpt-4o-mini",  // First fallback
+ *   "anthropic:claude-3-5-sonnet-20241022",  // Second fallback
+ * });
+ *
+ * const agent = createAgent({
+ *   model: "openai:gpt-4o",  // Primary model
+ *   middleware: [fallback],
+ *   tools: [],
+ * });
+ *
+ * // If gpt-4o fails, automatically tries gpt-4o-mini, then claude
+ * const result = await agent.invoke({
+ *   messages: [{ role: "user", content: "Hello" }]
+ * });
+ * ```
+ *
+ * @param fallbackModels - The fallback models to try, in order.
+ * @returns A middleware instance that handles model failures with fallbacks
+ */
+declare function modelFallbackMiddleware(
+/**
+ * The fallback models to try, in order.
+ */
+...fallbackModels: (string | LanguageModelLike)[]): AgentMiddleware;
+//#endregion
+export { modelFallbackMiddleware };
+//# sourceMappingURL=modelFallback.d.ts.map

package/dist/agents/middleware/modelFallback.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"modelFallback.d.ts","names":["LanguageModelLike","AgentMiddleware","modelFallbackMiddleware"],"sources":["../../../src/agents/middleware/modelFallback.d.ts"],"sourcesContent":["import type { LanguageModelLike } from \"@langchain/core/language_models/base\";\nimport type { AgentMiddleware } from \"./types.js\";\n/**\n * Middleware that provides automatic model fallback on errors.\n *\n * This middleware attempts to retry failed model calls with alternative models\n * in sequence. When a model call fails, it tries the next model in the fallback\n * list until either a call succeeds or all models have been exhausted.\n *\n * @example\n * ```ts\n * import { createAgent, modelFallbackMiddleware } from \"langchain\";\n *\n * // Create middleware with fallback models (not including primary)\n * const fallback = modelFallbackMiddleware({\n *   \"openai:gpt-4o-mini\",  // First fallback\n *   \"anthropic:claude-3-5-sonnet-20241022\",  // Second fallback\n * });\n *\n * const agent = createAgent({\n *   model: \"openai:gpt-4o\",  // Primary model\n *   middleware: [fallback],\n *   tools: [],\n * });\n *\n * // If gpt-4o fails, automatically tries gpt-4o-mini, then claude\n * const result = await agent.invoke({\n *   messages: [{ role: \"user\", content: \"Hello\" }]\n * });\n * ```\n *\n * @param fallbackModels - The fallback models to try, in order.\n * @returns A middleware instance that handles model failures with fallbacks\n */\nexport declare function modelFallbackMiddleware(\n/**\n * The fallback models to try, in order.\n */\n...fallbackModels: (string | LanguageModelLike)[]): AgentMiddleware;\n"],"mappings":";;;;;;;AAkCA;;;;AAImE;;;;;;;;;;;;;;;;;;;;;;;;;;iBAJ3CE,uBAAAA;;;;6BAIKF,uBAAuBC"}

package/dist/agents/middleware/modelFallback.js

@@ -0,0 +1,74 @@
+import { initChatModel } from "../../chat_models/universal.js";
+import { createMiddleware } from "../middleware.js";
+
+//#region src/agents/middleware/modelFallback.ts
+/**
+* Middleware that provides automatic model fallback on errors.
+*
+* This middleware attempts to retry failed model calls with alternative models
+* in sequence. When a model call fails, it tries the next model in the fallback
+* list until either a call succeeds or all models have been exhausted.
+*
+* @example
+* ```ts
+* import { createAgent, modelFallbackMiddleware } from "langchain";
+*
+* // Create middleware with fallback models (not including primary)
+* const fallback = modelFallbackMiddleware({
+*   "openai:gpt-4o-mini",  // First fallback
+*   "anthropic:claude-3-5-sonnet-20241022",  // Second fallback
+* });
+*
+* const agent = createAgent({
+*   model: "openai:gpt-4o",  // Primary model
+*   middleware: [fallback],
+*   tools: [],
+* });
+*
+* // If gpt-4o fails, automatically tries gpt-4o-mini, then claude
+* const result = await agent.invoke({
+*   messages: [{ role: "user", content: "Hello" }]
+* });
+* ```
+*
+* @param fallbackModels - The fallback models to try, in order.
+* @returns A middleware instance that handles model failures with fallbacks
+*/
+function modelFallbackMiddleware(...fallbackModels) {
+	return createMiddleware({
+		name: "modelFallbackMiddleware",
+		wrapModelCall: async (request, handler) => {
+			/**
+			* Try the primary model first
+			*/
+			try {
+				return await handler(request);
+			} catch (error) {
+				/**
+				* If primary model fails, try fallback models in sequence
+				*/
+				for (let i = 0; i < fallbackModels.length; i++) try {
+					const fallbackModel = fallbackModels[i];
+					const model = typeof fallbackModel === "string" ? await initChatModel(fallbackModel) : fallbackModel;
+					return await handler({
+						...request,
+						model
+					});
+				} catch (fallbackError) {
+					/**
+					* If this is the last fallback, throw the error
+					*/
+					if (i === fallbackModels.length - 1) throw fallbackError;
+				}
+				/**
+				* If no fallbacks were provided, re-throw the original error
+				*/
+				throw error;
+			}
+		}
+	});
+}
+
+//#endregion
+export { modelFallbackMiddleware };
+//# sourceMappingURL=modelFallback.js.map

package/dist/agents/middleware/modelFallback.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"modelFallback.js","names":[],"sources":["../../../src/agents/middleware/modelFallback.ts"],"sourcesContent":["import type { LanguageModelLike } from \"@langchain/core/language_models/base\";\nimport { initChatModel } from \"../../chat_models/universal.js\";\nimport type { AgentMiddleware } from \"./types.js\";\nimport { createMiddleware } from \"../middleware.js\";\n\n/**\n * Middleware that provides automatic model fallback on errors.\n *\n * This middleware attempts to retry failed model calls with alternative models\n * in sequence. When a model call fails, it tries the next model in the fallback\n * list until either a call succeeds or all models have been exhausted.\n *\n * @example\n * ```ts\n * import { createAgent, modelFallbackMiddleware } from \"langchain\";\n *\n * // Create middleware with fallback models (not including primary)\n * const fallback = modelFallbackMiddleware({\n *   \"openai:gpt-4o-mini\",  // First fallback\n *   \"anthropic:claude-3-5-sonnet-20241022\",  // Second fallback\n * });\n *\n * const agent = createAgent({\n *   model: \"openai:gpt-4o\",  // Primary model\n *   middleware: [fallback],\n *   tools: [],\n * });\n *\n * // If gpt-4o fails, automatically tries gpt-4o-mini, then claude\n * const result = await agent.invoke({\n *   messages: [{ role: \"user\", content: \"Hello\" }]\n * });\n * ```\n *\n * @param fallbackModels - The fallback models to try, in order.\n * @returns A middleware instance that handles model failures with fallbacks\n */\nexport function modelFallbackMiddleware(\n  /**\n   * The fallback models to try, in order.\n   */\n  ...fallbackModels: (string | LanguageModelLike)[]\n): AgentMiddleware {\n  return createMiddleware({\n    name: \"modelFallbackMiddleware\",\n    wrapModelCall: async (request, handler) => {\n      /**\n       * Try the primary model first\n       */\n      try {\n        return await handler(request);\n      } catch (error) {\n        /**\n         * If primary model fails, try fallback models in sequence\n         */\n        for (let i = 0; i < fallbackModels.length; i++) {\n          try {\n            const fallbackModel = fallbackModels[i];\n            const model =\n              typeof fallbackModel === \"string\"\n                ? await initChatModel(fallbackModel)\n                : fallbackModel;\n\n            return await handler({\n              ...request,\n              model,\n            });\n          } catch (fallbackError) {\n            /**\n             * If this is the last fallback, throw the error\n             */\n            if (i === fallbackModels.length - 1) {\n              throw fallbackError;\n            }\n            // Otherwise, continue to next fallback\n          }\n        }\n        /**\n         * If no fallbacks were provided, re-throw the original error\n         */\n        throw error;\n      }\n    },\n  });\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqCA,SAAgB,wBAId,GAAG,gBACc;AACjB,QAAO,iBAAiB;EACtB,MAAM;EACN,eAAe,OAAO,SAAS,YAAY;;;;AAIzC,OAAI;AACF,WAAO,MAAM,QAAQ,QAAQ;GAC9B,SAAQ,OAAO;;;;AAId,SAAK,IAAI,IAAI,GAAG,IAAI,eAAe,QAAQ,IACzC,KAAI;KACF,MAAM,gBAAgB,eAAe;KACrC,MAAM,QACJ,OAAO,kBAAkB,WACrB,MAAM,cAAc,cAAc,GAClC;AAEN,YAAO,MAAM,QAAQ;MACnB,GAAG;MACH;KACD,EAAC;IACH,SAAQ,eAAe;;;;AAItB,SAAI,MAAM,eAAe,SAAS,EAChC,OAAM;IAGT;;;;AAKH,UAAM;GACP;EACF;CACF,EAAC;AACH"}

package/dist/agents/middleware/piiRedaction.cjs

@@ -0,0 +1,333 @@
+const require_rolldown_runtime = require('../../_virtual/rolldown_runtime.cjs');
+const require_middleware = require('../middleware.cjs');
+const __langchain_core_messages = require_rolldown_runtime.__toESM(require("@langchain/core/messages"));
+const zod_v3 = require_rolldown_runtime.__toESM(require("zod/v3"));
+
+//#region src/agents/middleware/piiRedaction.ts
+/**
+* Configuration schema for the Input Guardrails middleware
+*/
+const contextSchema = zod_v3.z.object({ rules: zod_v3.z.record(zod_v3.z.string(), zod_v3.z.instanceof(RegExp).describe("Regular expression pattern to match PII")).optional() });
+/**
+* Generate a unique ID for a redaction
+*/
+function generateRedactionId() {
+	return Math.random().toString(36).substring(2, 11);
+}
+/**
+* Apply PII detection rules to text with ID tracking
+*/
+function applyPIIRules(text, rules, redactionMap) {
+	let processedText = text;
+	for (const [name, pattern] of Object.entries(rules)) {
+		const replacement = name.toUpperCase().replace(/[^a-zA-Z0-9_-]/g, "");
+		processedText = processedText.replace(pattern, (match) => {
+			const id = generateRedactionId();
+			redactionMap[id] = match;
+			return `[REDACTED_${replacement}_${id}]`;
+		});
+	}
+	return processedText;
+}
+/**
+* Process a single human message for PII detection and redaction
+*/
+async function processMessage(message, config) {
+	/**
+	* handle basic message types
+	*/
+	if (__langchain_core_messages.HumanMessage.isInstance(message) || __langchain_core_messages.ToolMessage.isInstance(message) || __langchain_core_messages.SystemMessage.isInstance(message)) {
+		const content = message.content;
+		const processedContent = await applyPIIRules(content, config.rules, config.redactionMap);
+		if (processedContent !== content) {
+			const MessageConstructor = Object.getPrototypeOf(message).constructor;
+			return new MessageConstructor({
+				...message,
+				content: processedContent
+			});
+		}
+		return message;
+	}
+	/**
+	* Handle AI messages
+	*/
+	if (__langchain_core_messages.AIMessage.isInstance(message)) {
+		const content = typeof message.content === "string" ? message.content : JSON.stringify(message.content);
+		const toolCalls = JSON.stringify(message.tool_calls);
+		const processedContent = await applyPIIRules(content, config.rules, config.redactionMap);
+		const processedToolCalls = await applyPIIRules(toolCalls, config.rules, config.redactionMap);
+		if (processedContent !== content || processedToolCalls !== toolCalls) return new __langchain_core_messages.AIMessage({
+			...message,
+			content: typeof message.content === "string" ? processedContent : JSON.parse(processedContent),
+			tool_calls: JSON.parse(processedToolCalls)
+		});
+		return message;
+	}
+	throw new Error(`Unsupported message type: ${message.type}`);
+}
+/**
+* Restore original values from redacted text using the redaction map
+*/
+function restoreRedactedValues(text, redactionMap) {
+	let restoredText = text;
+	const redactionPattern = /\[REDACTED_[A-Z_]+_(\w+)\]/g;
+	restoredText = restoredText.replace(redactionPattern, (match, id) => {
+		if (redactionMap[id]) return redactionMap[id];
+		return match;
+	});
+	return restoredText;
+}
+/**
+* Restore redacted values in a message (creates a new message object)
+*/
+function restoreMessage(message, redactionMap) {
+	/**
+	* handle basic message types
+	*/
+	if (__langchain_core_messages.HumanMessage.isInstance(message) || __langchain_core_messages.ToolMessage.isInstance(message) || __langchain_core_messages.SystemMessage.isInstance(message)) {
+		const content = message.content;
+		const restoredContent = restoreRedactedValues(content, redactionMap);
+		if (restoredContent !== content) {
+			const MessageConstructor = Object.getPrototypeOf(message).constructor;
+			const newMessage = new MessageConstructor({
+				...message,
+				content: restoredContent
+			});
+			return {
+				message: newMessage,
+				changed: true
+			};
+		}
+		return {
+			message,
+			changed: false
+		};
+	}
+	/**
+	* handle AI messages
+	*/
+	if (__langchain_core_messages.AIMessage.isInstance(message)) {
+		const content = typeof message.content === "string" ? message.content : JSON.stringify(message.content);
+		const toolCalls = JSON.stringify(message.tool_calls);
+		const processedContent = restoreRedactedValues(content, redactionMap);
+		const processedToolCalls = restoreRedactedValues(toolCalls, redactionMap);
+		if (processedContent !== content || processedToolCalls !== toolCalls) return {
+			message: new __langchain_core_messages.AIMessage({
+				...message,
+				content: typeof message.content === "string" ? processedContent : JSON.parse(processedContent),
+				tool_calls: JSON.parse(processedToolCalls)
+			}),
+			changed: true
+		};
+		return {
+			message,
+			changed: false
+		};
+	}
+	throw new Error(`Unsupported message type: ${message.type}`);
+}
+/**
+* Creates a middleware that detects and redacts personally identifiable information (PII)
+* from messages before they are sent to model providers, and restores original values
+* in model responses for tool execution.
+*
+* ## Mechanism
+*
+* The middleware intercepts agent execution at two points:
+*
+* ### Request Phase (`wrapModelCall`)
+* - Applies regex-based pattern matching to all message content (HumanMessage, ToolMessage, SystemMessage, AIMessage)
+* - Processes both message text and AIMessage tool call arguments
+* - Each matched pattern generates:
+*   - Unique identifier: `generateRedactionId()` → `"abc123"`
+*   - Redaction marker: `[REDACTED_{RULE_NAME}_{ID}]` → `"[REDACTED_SSN_abc123]"`
+*   - Redaction map entry: `{ "abc123": "123-45-6789" }`
+* - Returns modified request with redacted message content
+*
+* ### Response Phase (`afterModel`)
+* - Scans AIMessage responses for redaction markers matching pattern: `/\[REDACTED_[A-Z_]+_(\w+)\]/g`
+* - Replaces markers with original values from redaction map
+* - Handles both standard responses and structured output (via tool calls or JSON content)
+* - For structured output, restores values in both the tool call arguments and the `structuredResponse` state field
+* - Returns new message instances via RemoveMessage/AIMessage to update state
+*
+* ## Data Flow
+*
+* ```
+* User Input: "My SSN is 123-45-6789"
+*     ↓ [beforeModel]
+* Model Request: "My SSN is [REDACTED_SSN_abc123]"
+*     ↓ [model invocation]
+* Model Response: tool_call({ "ssn": "[REDACTED_SSN_abc123]" })
+*     ↓ [afterModel]
+* Tool Execution: tool({ "ssn": "123-45-6789" })
+* ```
+*
+* ## Limitations
+*
+* This middleware provides model provider isolation only. PII may still be present in:
+* - LangGraph state checkpoints (memory, databases)
+* - Network traffic between client and application server
+* - Application logs and trace data
+* - Tool execution arguments and responses
+* - Final agent output
+*
+* For comprehensive PII protection, implement additional controls at the application,
+* network, and storage layers.
+*
+* @param options - Configuration options
+* @param options.rules - Record of detection rules mapping rule names to regex patterns.
+*   Rule names are normalized to uppercase and used in redaction markers.
+*   Patterns must use the global flag (`/pattern/g`) to match all occurrences.
+*
+* @returns Middleware instance for use with `createAgent`
+*
+* @example Basic usage with custom rules
+* ```typescript
+* import { piiRedactionMiddleware } from "langchain";
+* import { createAgent } from "langchain";
+* import { tool } from "@langchain/core/tools";
+* import { z } from "zod/v3";
+*
+* const PII_RULES = {
+*   ssn: /\b\d{3}-?\d{2}-?\d{4}\b/g,
+*   email: /\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}\b/g,
+*   phone: /\b\d{3}[-.]?\d{3}[-.]?\d{4}\b/g,
+* };
+*
+* const lookupUser = tool(async ({ ssn }) => {
+*   // Receives original value: "123-45-6789"
+*   return { name: "John Doe", account: "active" };
+* }, {
+*   name: "lookup_user",
+*   description: "Look up user by SSN",
+*   schema: z.object({ ssn: z.string() })
+* });
+*
+* const agent = createAgent({
+*   model: new ChatOpenAI({ model: "gpt-4" }),
+*   tools: [lookupUser],
+*   middleware: [piiRedactionMiddleware({ rules: PII_RULES })]
+* });
+*
+* const result = await agent.invoke({
+*   messages: [new HumanMessage("Look up SSN 123-45-6789")]
+* });
+* // Model request: "Look up SSN [REDACTED_SSN_abc123]"
+* // Model response: tool_call({ "ssn": "[REDACTED_SSN_abc123]" })
+* // Tool receives: { "ssn": "123-45-6789" }
+* ```
+*
+* @example Runtime rule configuration via context
+* ```typescript
+* const agent = createAgent({
+*   model: new ChatOpenAI({ model: "gpt-4" }),
+*   tools: [someTool],
+*   middleware: [piiRedactionMiddleware()]
+* });
+*
+* // Configure rules at runtime via middleware context
+* const result = await agent.invoke(
+*   { messages: [new HumanMessage("...")] },
+*   {
+*     configurable: {
+*       PIIRedactionMiddleware: {
+*         rules: {
+*           ssn: /\b\d{3}-?\d{2}-?\d{4}\b/g,
+*           email: /\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}\b/g,
+*         }
+*       }
+*     }
+*   }
+* );
+* ```
+*
+* @example Custom rule patterns
+* ```typescript
+* const customRules = {
+*   employee_id: /EMP-\d{6}/g,
+*   api_key: /sk-[a-zA-Z0-9]{32}/g,
+*   credit_card: /\b\d{4}[- ]?\d{4}[- ]?\d{4}[- ]?\d{4}\b/g,
+* };
+*
+* const middleware = piiRedactionMiddleware({ rules: customRules });
+* // Generates markers like: [REDACTED_EMPLOYEE_ID_xyz789]
+* ```
+*
+* @public
+*/
+function piiRedactionMiddleware(options = {}) {
+	const redactionMap = {};
+	return require_middleware.createMiddleware({
+		name: "PIIRedactionMiddleware",
+		contextSchema,
+		wrapModelCall: async (request, handler) => {
+			/**
+			* Merge options with context, following bigTool.ts pattern
+			*/
+			const rules = request.runtime.context.rules ?? options.rules ?? {};
+			/**
+			* If no rules are provided, skip processing
+			*/
+			if (Object.keys(rules).length === 0) return handler(request);
+			const processedMessages = await Promise.all(request.state.messages.map((message) => processMessage(message, {
+				rules,
+				redactionMap
+			})));
+			return handler({
+				...request,
+				messages: processedMessages
+			});
+		},
+		afterModel: async (state) => {
+			/**
+			* If no redactions were made, skip processing
+			*/
+			if (Object.keys(redactionMap).length === 0) return;
+			const lastMessage = state.messages.at(-1);
+			if (!__langchain_core_messages.AIMessage.isInstance(lastMessage)) return;
+			/**
+			* In cases where we do structured output via tool calls, we also have to look at the second last message
+			* as we add a custom last message to the messages array.
+			*/
+			const secondLastMessage = state.messages.at(-2);
+			const { message: restoredLastMessage, changed } = restoreMessage(lastMessage, redactionMap);
+			if (!changed) return;
+			/**
+			* Identify if the last message is a structured response and restore the values if so
+			*/
+			let structuredResponse;
+			if (__langchain_core_messages.AIMessage.isInstance(lastMessage) && lastMessage?.tool_calls?.length === 0 && typeof lastMessage.content === "string" && lastMessage.content.startsWith("{") && lastMessage.content.endsWith("}")) try {
+				structuredResponse = JSON.parse(restoreRedactedValues(lastMessage.content, redactionMap));
+			} catch {}
+			/**
+			* Check if the second last message is a structured response tool call
+			*/
+			const isStructuredResponseToolCall = __langchain_core_messages.AIMessage.isInstance(secondLastMessage) && secondLastMessage?.tool_calls?.length !== 0 && secondLastMessage?.tool_calls?.some((call) => call.name.startsWith("extract-"));
+			if (isStructuredResponseToolCall) {
+				const { message: restoredSecondLastMessage, changed: changedSecondLastMessage } = restoreMessage(secondLastMessage, redactionMap);
+				const structuredResponseRedacted = secondLastMessage.tool_calls?.find((call) => call.name.startsWith("extract-"))?.args;
+				const structuredResponse$1 = structuredResponseRedacted ? JSON.parse(restoreRedactedValues(JSON.stringify(structuredResponseRedacted), redactionMap)) : void 0;
+				if (changed || changedSecondLastMessage) return {
+					...state,
+					...structuredResponse$1 ? { structuredResponse: structuredResponse$1 } : {},
+					messages: [
+						new __langchain_core_messages.RemoveMessage({ id: secondLastMessage.id }),
+						new __langchain_core_messages.RemoveMessage({ id: lastMessage.id }),
+						restoredSecondLastMessage,
+						restoredLastMessage
+					]
+				};
+			}
+			return {
+				...state,
+				...structuredResponse ? { structuredResponse } : {},
+				messages: [new __langchain_core_messages.RemoveMessage({ id: lastMessage.id }), restoredLastMessage]
+			};
+		}
+	});
+}
+
+//#endregion
+exports.piiRedactionMiddleware = piiRedactionMiddleware;
+//# sourceMappingURL=piiRedaction.cjs.map

package/dist/agents/middleware/piiRedaction.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"piiRedaction.cjs","names":["z","text: string","rules: Record<string, RegExp>","redactionMap: RedactionMap","message: BaseMessage","config: ProcessHumanMessageConfig","HumanMessage","ToolMessage","SystemMessage","AIMessage","options: PIIRedactionMiddlewareConfig","createMiddleware","structuredResponse: Record<string, unknown> | undefined","structuredResponse","RemoveMessage"],"sources":["../../../src/agents/middleware/piiRedaction.ts"],"sourcesContent":["import { z } from \"zod/v3\";\nimport {\n  BaseMessage,\n  AIMessage,\n  HumanMessage,\n  ToolMessage,\n  RemoveMessage,\n  SystemMessage,\n} from \"@langchain/core/messages\";\nimport type { InferInteropZodInput } from \"@langchain/core/utils/types\";\n\nimport { createMiddleware } from \"../middleware.js\";\n\n/**\n * Type for the redaction map that stores original values by ID\n */\ntype RedactionMap = Record<string, string>;\n\n/**\n * Configuration schema for the Input Guardrails middleware\n */\nconst contextSchema = z.object({\n  /**\n   * A record of PII detection rules to apply\n   * @default DEFAULT_PII_RULES (with enabled rules only)\n   */\n  rules: z\n    .record(\n      z.string(),\n      z.instanceof(RegExp).describe(\"Regular expression pattern to match PII\")\n    )\n    .optional(),\n});\n\nexport type PIIRedactionMiddlewareConfig = InferInteropZodInput<\n  typeof contextSchema\n>;\n\n/**\n * Generate a unique ID for a redaction\n */\nfunction generateRedactionId(): string {\n  return Math.random().toString(36).substring(2, 11);\n}\n\n/**\n * Apply PII detection rules to text with ID tracking\n */\nfunction applyPIIRules(\n  text: string,\n  rules: Record<string, RegExp>,\n  redactionMap: RedactionMap\n): string {\n  let processedText = text;\n\n  for (const [name, pattern] of Object.entries(rules)) {\n    const replacement = name.toUpperCase().replace(/[^a-zA-Z0-9_-]/g, \"\");\n    processedText = processedText.replace(pattern, (match) => {\n      const id = generateRedactionId();\n      redactionMap[id] = match;\n      // Create a trackable replacement like [REDACTED_SSN_abc123]\n      return `[REDACTED_${replacement}_${id}]`;\n    });\n  }\n\n  return processedText;\n}\n\ninterface ProcessHumanMessageConfig {\n  rules: Record<string, RegExp>;\n  redactionMap: RedactionMap;\n}\n\n/**\n * Process a single human message for PII detection and redaction\n */\nasync function processMessage(\n  message: BaseMessage,\n  config: ProcessHumanMessageConfig\n): Promise<BaseMessage> {\n  /**\n   * handle basic message types\n   */\n  if (\n    HumanMessage.isInstance(message) ||\n    ToolMessage.isInstance(message) ||\n    SystemMessage.isInstance(message)\n  ) {\n    const content = message.content as string;\n    const processedContent = await applyPIIRules(\n      content,\n      config.rules,\n      config.redactionMap\n    );\n\n    if (processedContent !== content) {\n      const MessageConstructor = Object.getPrototypeOf(message).constructor;\n      return new MessageConstructor({\n        ...message,\n        content: processedContent,\n      });\n    }\n\n    return message;\n  }\n\n  /**\n   * Handle AI messages\n   */\n  if (AIMessage.isInstance(message)) {\n    const content =\n      typeof message.content === \"string\"\n        ? message.content\n        : JSON.stringify(message.content);\n    const toolCalls = JSON.stringify(message.tool_calls);\n    const processedContent = await applyPIIRules(\n      content,\n      config.rules,\n      config.redactionMap\n    );\n    const processedToolCalls = await applyPIIRules(\n      toolCalls,\n      config.rules,\n      config.redactionMap\n    );\n\n    if (processedContent !== content || processedToolCalls !== toolCalls) {\n      return new AIMessage({\n        ...message,\n        content:\n          typeof message.content === \"string\"\n            ? processedContent\n            : JSON.parse(processedContent),\n        tool_calls: JSON.parse(processedToolCalls),\n      });\n    }\n\n    return message;\n  }\n\n  throw new Error(`Unsupported message type: ${message.type}`);\n}\n\n/**\n * Restore original values from redacted text using the redaction map\n */\nfunction restoreRedactedValues(\n  text: string,\n  redactionMap: RedactionMap\n): string {\n  let restoredText = text;\n\n  // Pattern to match redacted values like [REDACTED_SSN_abc123]\n  const redactionPattern = /\\[REDACTED_[A-Z_]+_(\\w+)\\]/g;\n\n  restoredText = restoredText.replace(redactionPattern, (match, id) => {\n    if (redactionMap[id]) {\n      return redactionMap[id];\n    }\n    return match; // Keep original if no mapping found\n  });\n\n  return restoredText;\n}\n\n/**\n * Restore redacted values in a message (creates a new message object)\n */\nfunction restoreMessage(\n  message: BaseMessage,\n  redactionMap: RedactionMap\n): { message: BaseMessage; changed: boolean } {\n  /**\n   * handle basic message types\n   */\n  if (\n    HumanMessage.isInstance(message) ||\n    ToolMessage.isInstance(message) ||\n    SystemMessage.isInstance(message)\n  ) {\n    const content = message.content as string;\n    const restoredContent = restoreRedactedValues(content, redactionMap);\n    if (restoredContent !== content) {\n      const MessageConstructor = Object.getPrototypeOf(message).constructor;\n      const newMessage = new MessageConstructor({\n        ...message,\n        content: restoredContent,\n      });\n      return { message: newMessage, changed: true };\n    }\n    return { message, changed: false };\n  }\n\n  /**\n   * handle AI messages\n   */\n  if (AIMessage.isInstance(message)) {\n    const content =\n      typeof message.content === \"string\"\n        ? message.content\n        : JSON.stringify(message.content);\n    const toolCalls = JSON.stringify(message.tool_calls);\n    const processedContent = restoreRedactedValues(content, redactionMap);\n    const processedToolCalls = restoreRedactedValues(toolCalls, redactionMap);\n    if (processedContent !== content || processedToolCalls !== toolCalls) {\n      return {\n        message: new AIMessage({\n          ...message,\n          content:\n            typeof message.content === \"string\"\n              ? processedContent\n              : JSON.parse(processedContent),\n          tool_calls: JSON.parse(processedToolCalls),\n        }),\n        changed: true,\n      };\n    }\n\n    return { message, changed: false };\n  }\n\n  throw new Error(`Unsupported message type: ${message.type}`);\n}\n\n/**\n * Creates a middleware that detects and redacts personally identifiable information (PII)\n * from messages before they are sent to model providers, and restores original values\n * in model responses for tool execution.\n *\n * ## Mechanism\n *\n * The middleware intercepts agent execution at two points:\n *\n * ### Request Phase (`wrapModelCall`)\n * - Applies regex-based pattern matching to all message content (HumanMessage, ToolMessage, SystemMessage, AIMessage)\n * - Processes both message text and AIMessage tool call arguments\n * - Each matched pattern generates:\n *   - Unique identifier: `generateRedactionId()` → `\"abc123\"`\n *   - Redaction marker: `[REDACTED_{RULE_NAME}_{ID}]` → `\"[REDACTED_SSN_abc123]\"`\n *   - Redaction map entry: `{ \"abc123\": \"123-45-6789\" }`\n * - Returns modified request with redacted message content\n *\n * ### Response Phase (`afterModel`)\n * - Scans AIMessage responses for redaction markers matching pattern: `/\\[REDACTED_[A-Z_]+_(\\w+)\\]/g`\n * - Replaces markers with original values from redaction map\n * - Handles both standard responses and structured output (via tool calls or JSON content)\n * - For structured output, restores values in both the tool call arguments and the `structuredResponse` state field\n * - Returns new message instances via RemoveMessage/AIMessage to update state\n *\n * ## Data Flow\n *\n * ```\n * User Input: \"My SSN is 123-45-6789\"\n *     ↓ [beforeModel]\n * Model Request: \"My SSN is [REDACTED_SSN_abc123]\"\n *     ↓ [model invocation]\n * Model Response: tool_call({ \"ssn\": \"[REDACTED_SSN_abc123]\" })\n *     ↓ [afterModel]\n * Tool Execution: tool({ \"ssn\": \"123-45-6789\" })\n * ```\n *\n * ## Limitations\n *\n * This middleware provides model provider isolation only. PII may still be present in:\n * - LangGraph state checkpoints (memory, databases)\n * - Network traffic between client and application server\n * - Application logs and trace data\n * - Tool execution arguments and responses\n * - Final agent output\n *\n * For comprehensive PII protection, implement additional controls at the application,\n * network, and storage layers.\n *\n * @param options - Configuration options\n * @param options.rules - Record of detection rules mapping rule names to regex patterns.\n *   Rule names are normalized to uppercase and used in redaction markers.\n *   Patterns must use the global flag (`/pattern/g`) to match all occurrences.\n *\n * @returns Middleware instance for use with `createAgent`\n *\n * @example Basic usage with custom rules\n * ```typescript\n * import { piiRedactionMiddleware } from \"langchain\";\n * import { createAgent } from \"langchain\";\n * import { tool } from \"@langchain/core/tools\";\n * import { z } from \"zod/v3\";\n *\n * const PII_RULES = {\n *   ssn: /\\b\\d{3}-?\\d{2}-?\\d{4}\\b/g,\n *   email: /\\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\\.[A-Za-z]{2,}\\b/g,\n *   phone: /\\b\\d{3}[-.]?\\d{3}[-.]?\\d{4}\\b/g,\n * };\n *\n * const lookupUser = tool(async ({ ssn }) => {\n *   // Receives original value: \"123-45-6789\"\n *   return { name: \"John Doe\", account: \"active\" };\n * }, {\n *   name: \"lookup_user\",\n *   description: \"Look up user by SSN\",\n *   schema: z.object({ ssn: z.string() })\n * });\n *\n * const agent = createAgent({\n *   model: new ChatOpenAI({ model: \"gpt-4\" }),\n *   tools: [lookupUser],\n *   middleware: [piiRedactionMiddleware({ rules: PII_RULES })]\n * });\n *\n * const result = await agent.invoke({\n *   messages: [new HumanMessage(\"Look up SSN 123-45-6789\")]\n * });\n * // Model request: \"Look up SSN [REDACTED_SSN_abc123]\"\n * // Model response: tool_call({ \"ssn\": \"[REDACTED_SSN_abc123]\" })\n * // Tool receives: { \"ssn\": \"123-45-6789\" }\n * ```\n *\n * @example Runtime rule configuration via context\n * ```typescript\n * const agent = createAgent({\n *   model: new ChatOpenAI({ model: \"gpt-4\" }),\n *   tools: [someTool],\n *   middleware: [piiRedactionMiddleware()]\n * });\n *\n * // Configure rules at runtime via middleware context\n * const result = await agent.invoke(\n *   { messages: [new HumanMessage(\"...\")] },\n *   {\n *     configurable: {\n *       PIIRedactionMiddleware: {\n *         rules: {\n *           ssn: /\\b\\d{3}-?\\d{2}-?\\d{4}\\b/g,\n *           email: /\\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\\.[A-Za-z]{2,}\\b/g,\n *         }\n *       }\n *     }\n *   }\n * );\n * ```\n *\n * @example Custom rule patterns\n * ```typescript\n * const customRules = {\n *   employee_id: /EMP-\\d{6}/g,\n *   api_key: /sk-[a-zA-Z0-9]{32}/g,\n *   credit_card: /\\b\\d{4}[- ]?\\d{4}[- ]?\\d{4}[- ]?\\d{4}\\b/g,\n * };\n *\n * const middleware = piiRedactionMiddleware({ rules: customRules });\n * // Generates markers like: [REDACTED_EMPLOYEE_ID_xyz789]\n * ```\n *\n * @public\n */\nexport function piiRedactionMiddleware(\n  options: PIIRedactionMiddlewareConfig = {}\n): ReturnType<typeof createMiddleware> {\n  const redactionMap: RedactionMap = {};\n\n  return createMiddleware({\n    name: \"PIIRedactionMiddleware\",\n    contextSchema,\n    wrapModelCall: async (request, handler) => {\n      /**\n       * Merge options with context, following bigTool.ts pattern\n       */\n      const rules = request.runtime.context.rules ?? options.rules ?? {};\n\n      /**\n       * If no rules are provided, skip processing\n       */\n      if (Object.keys(rules).length === 0) {\n        return handler(request);\n      }\n\n      const processedMessages = await Promise.all(\n        request.state.messages.map((message: BaseMessage) =>\n          processMessage(message, {\n            rules,\n            redactionMap,\n          })\n        )\n      );\n\n      return handler({\n        ...request,\n        messages: processedMessages,\n      });\n    },\n    afterModel: async (state) => {\n      /**\n       * If no redactions were made, skip processing\n       */\n      if (Object.keys(redactionMap).length === 0) {\n        return;\n      }\n\n      const lastMessage = state.messages.at(-1);\n      if (!AIMessage.isInstance(lastMessage)) {\n        return;\n      }\n\n      /**\n       * In cases where we do structured output via tool calls, we also have to look at the second last message\n       * as we add a custom last message to the messages array.\n       */\n      const secondLastMessage = state.messages.at(-2);\n\n      const { message: restoredLastMessage, changed } = restoreMessage(\n        lastMessage,\n        redactionMap\n      );\n\n      if (!changed) {\n        return;\n      }\n\n      /**\n       * Identify if the last message is a structured response and restore the values if so\n       */\n      let structuredResponse: Record<string, unknown> | undefined;\n      if (\n        AIMessage.isInstance(lastMessage) &&\n        lastMessage?.tool_calls?.length === 0 &&\n        typeof lastMessage.content === \"string\" &&\n        lastMessage.content.startsWith(\"{\") &&\n        lastMessage.content.endsWith(\"}\")\n      ) {\n        try {\n          structuredResponse = JSON.parse(\n            restoreRedactedValues(lastMessage.content, redactionMap)\n          );\n        } catch {\n          // ignore\n        }\n      }\n\n      /**\n       * Check if the second last message is a structured response tool call\n       */\n      const isStructuredResponseToolCall =\n        AIMessage.isInstance(secondLastMessage) &&\n        secondLastMessage?.tool_calls?.length !== 0 &&\n        secondLastMessage?.tool_calls?.some((call) =>\n          call.name.startsWith(\"extract-\")\n        );\n      if (isStructuredResponseToolCall) {\n        const {\n          message: restoredSecondLastMessage,\n          changed: changedSecondLastMessage,\n        } = restoreMessage(secondLastMessage, redactionMap);\n        const structuredResponseRedacted = secondLastMessage.tool_calls?.find(\n          (call) => call.name.startsWith(\"extract-\")\n        )?.args;\n        const structuredResponse = structuredResponseRedacted\n          ? JSON.parse(\n              restoreRedactedValues(\n                JSON.stringify(structuredResponseRedacted),\n                redactionMap\n              )\n            )\n          : undefined;\n        if (changed || changedSecondLastMessage) {\n          return {\n            ...state,\n            ...(structuredResponse ? { structuredResponse } : {}),\n            messages: [\n              new RemoveMessage({ id: secondLastMessage.id as string }),\n              new RemoveMessage({ id: lastMessage.id as string }),\n              restoredSecondLastMessage,\n              restoredLastMessage,\n            ],\n          };\n        }\n      }\n\n      return {\n        ...state,\n        ...(structuredResponse ? { structuredResponse } : {}),\n        messages: [\n          new RemoveMessage({ id: lastMessage.id as string }),\n          restoredLastMessage,\n        ],\n      };\n    },\n  });\n}\n"],"mappings":"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"}