@nocobase/plugin-ai 1.9.33 → 1.9.34

package/dist/node_modules/@langchain/core/dist/runnables/types.d.ts

@@ -1,7 +1,7 @@
-import type { z } from "zod";
 import type { SerializableInterface } from "../load/serializable.js";
 import type { BaseCallbackConfig } from "../callbacks/manager.js";
 import type { IterableReadableStreamInterface } from "../types/_internal.js";
+import { InteropZodType } from "../utils/types/zod.js";
 export type RunnableBatchOptions = {
     /** @deprecated Pass in via the standard runnable config object instead */
     maxConcurrency?: number;
@@ -9,7 +9,7 @@ export type RunnableBatchOptions = {
 };
 export type RunnableIOSchema = {
     name?: string;
-    schema: z.ZodType;
+    schema: InteropZodType;
 };
 /**
  * Base interface implemented by all runnables.

package/dist/node_modules/@langchain/core/dist/runnables/utils.cjs

@@ -1,11 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports._RootEventFilter = exports.isRunnableInterface = void 0;
+exports._RootEventFilter = void 0;
+exports.isRunnableInterface = isRunnableInterface;
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 function isRunnableInterface(thing) {
     return thing ? thing.lc_runnable : false;
 }
-exports.isRunnableInterface = isRunnableInterface;
 /**
  * Utility to filter the root event in the streamEvents implementation.
  * This is simply binding the arguments to the namespace to make save on

package/dist/node_modules/@langchain/core/dist/runnables/wrappers.cjs

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.convertToHttpEventStream = void 0;
+exports.convertToHttpEventStream = convertToHttpEventStream;
 const stream_js_1 = require("../utils/stream.cjs");
 function convertToHttpEventStream(stream) {
     const encoder = new TextEncoder();
@@ -15,4 +15,3 @@ function convertToHttpEventStream(stream) {
     });
     return stream_js_1.IterableReadableStream.fromReadableStream(finalStream);
 }
-exports.convertToHttpEventStream = convertToHttpEventStream;

package/dist/node_modules/@langchain/core/dist/runnables/wrappers.d.ts

@@ -1,2 +1,2 @@
 import { IterableReadableStream } from "../utils/stream.js";
-export declare function convertToHttpEventStream(stream: AsyncGenerator): IterableReadableStream<Uint8Array>;
+export declare function convertToHttpEventStream(stream: AsyncGenerator): IterableReadableStream<Uint8Array<ArrayBufferLike>>;

package/dist/node_modules/@langchain/core/dist/singletons/async_local_storage/context.cjs

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.registerConfigureHook = exports._getConfigureHooks = exports.getContextVariable = exports.setContextVariable = void 0;
+exports.registerConfigureHook = exports._getConfigureHooks = void 0;
+exports.setContextVariable = setContextVariable;
+exports.getContextVariable = getContextVariable;
 const run_trees_1 = require("langsmith/run_trees");
 const globals_js_1 = require("./globals.cjs");
 /**
@@ -71,7 +73,6 @@ function setContextVariable(name, value) {
     newValue[globals_js_1._CONTEXT_VARIABLES_KEY] = contextVars;
     asyncLocalStorageInstance.enterWith(newValue);
 }
-exports.setContextVariable = setContextVariable;
 /**
  * Get the value of a previously set context variable. Context variables
  * are scoped to any child runnables called by the current runnable,
@@ -131,7 +132,6 @@ function getContextVariable(name) {
     const runTree = asyncLocalStorageInstance.getStore();
     return runTree?.[globals_js_1._CONTEXT_VARIABLES_KEY]?.[name];
 }
-exports.getContextVariable = getContextVariable;
 const LC_CONFIGURE_HOOKS_KEY = Symbol("lc:configure_hooks");
 const _getConfigureHooks = () => getContextVariable(LC_CONFIGURE_HOOKS_KEY) || [];
 exports._getConfigureHooks = _getConfigureHooks;

package/dist/node_modules/@langchain/core/dist/singletons/async_local_storage/index.cjs

@@ -38,7 +38,7 @@ class AsyncLocalStorageProvider {
         const langChainTracer = callbackManager?.handlers?.find((handler) => handler?.name === "langchain_tracer");
         let runTree;
         if (langChainTracer && parentRunId) {
-            runTree = langChainTracer.convertToRunTree(parentRunId);
+            runTree = langChainTracer.getRunTreeWithTracingConfig(parentRunId);
         }
         else if (!avoidCreatingRootRunTree) {
             runTree = new langsmith_1.RunTree({

package/dist/node_modules/@langchain/core/dist/singletons/async_local_storage/index.js

@@ -34,7 +34,7 @@ class AsyncLocalStorageProvider {
         const langChainTracer = callbackManager?.handlers?.find((handler) => handler?.name === "langchain_tracer");
         let runTree;
         if (langChainTracer && parentRunId) {
-            runTree = langChainTracer.convertToRunTree(parentRunId);
+            runTree = langChainTracer.getRunTreeWithTracingConfig(parentRunId);
         }
         else if (!avoidCreatingRootRunTree) {
             runTree = new RunTree({

package/dist/node_modules/@langchain/core/dist/singletons/callbacks.cjs

@@ -4,9 +4,12 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.awaitAllCallbacks = exports.consumeCallback = exports.getQueue = void 0;
+exports.getQueue = getQueue;
+exports.consumeCallback = consumeCallback;
+exports.awaitAllCallbacks = awaitAllCallbacks;
 const p_queue_1 = __importDefault(require("p-queue"));
 const globals_js_1 = require("./async_local_storage/globals.cjs");
+const tracer_js_1 = require("./tracer.cjs");
 let queue;
 /**
  * Creates a queue using the p-queue library. The queue is configured to
@@ -26,7 +29,6 @@ function getQueue() {
     }
     return queue;
 }
-exports.getQueue = getQueue;
 /**
  * Consume a promise, either adding it to the queue or waiting for it to resolve
  * @param promiseFn Promise to consume
@@ -57,12 +59,14 @@ async function consumeCallback(promiseFn, wait) {
         });
     }
 }
-exports.consumeCallback = consumeCallback;
 /**
  * Waits for all promises in the queue to resolve. If the queue is
  * undefined, it immediately resolves a promise.
  */
-function awaitAllCallbacks() {
-    return typeof queue !== "undefined" ? queue.onIdle() : Promise.resolve();
+async function awaitAllCallbacks() {
+    const defaultClient = (0, tracer_js_1.getDefaultLangChainClientSingleton)();
+    await Promise.allSettled([
+        typeof queue !== "undefined" ? queue.onIdle() : Promise.resolve(),
+        defaultClient.awaitPendingTraceBatches(),
+    ]);
 }
-exports.awaitAllCallbacks = awaitAllCallbacks;

package/dist/node_modules/@langchain/core/dist/singletons/callbacks.d.ts

@@ -1,5 +1,5 @@
 import PQueueMod from "p-queue";
-export declare function getQueue(): PQueueMod.default<any, any>;
+export declare function getQueue(): PQueueMod<any, any>;
 /**
  * Consume a promise, either adding it to the queue or waiting for it to resolve
  * @param promiseFn Promise to consume

package/dist/node_modules/@langchain/core/dist/singletons/callbacks.js

@@ -1,6 +1,7 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import PQueueMod from "p-queue";
 import { getGlobalAsyncLocalStorageInstance } from "./async_local_storage/globals.js";
+import { getDefaultLangChainClientSingleton } from "./tracer.js";
 let queue;
 /**
  * Creates a queue using the p-queue library. The queue is configured to
@@ -54,6 +55,10 @@ export async function consumeCallback(promiseFn, wait) {
  * Waits for all promises in the queue to resolve. If the queue is
  * undefined, it immediately resolves a promise.
  */
-export function awaitAllCallbacks() {
-    return typeof queue !== "undefined" ? queue.onIdle() : Promise.resolve();
+export async function awaitAllCallbacks() {
+    const defaultClient = getDefaultLangChainClientSingleton();
+    await Promise.allSettled([
+        typeof queue !== "undefined" ? queue.onIdle() : Promise.resolve(),
+        defaultClient.awaitPendingTraceBatches(),
+    ]);
 }

package/dist/node_modules/@langchain/core/dist/structured_query/utils.cjs

@@ -1,6 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.castValue = exports.isBoolean = exports.isString = exports.isFloat = exports.isInt = exports.isFilterEmpty = exports.isObject = void 0;
+exports.isObject = isObject;
+exports.isFilterEmpty = isFilterEmpty;
+exports.isInt = isInt;
+exports.isFloat = isFloat;
+exports.isString = isString;
+exports.isBoolean = isBoolean;
+exports.castValue = castValue;
 /**
  * Checks if the provided argument is an object and not an array.
  */
@@ -8,7 +14,6 @@ exports.castValue = exports.isBoolean = exports.isString = exports.isFloat = exp
 function isObject(obj) {
     return obj && typeof obj === "object" && !Array.isArray(obj);
 }
-exports.isObject = isObject;
 /**
  * Checks if a provided filter is empty. The filter can be a function, an
  * object, a string, or undefined.
@@ -27,7 +32,6 @@ filter) {
     }
     return isObject(filter) && Object.keys(filter).length === 0;
 }
-exports.isFilterEmpty = isFilterEmpty;
 /**
  * Checks if the provided value is an integer.
  */
@@ -43,7 +47,6 @@ function isInt(value) {
     }
     return false;
 }
-exports.isInt = isInt;
 /**
  * Checks if the provided value is a floating-point number.
  */
@@ -59,7 +62,6 @@ function isFloat(value) {
     }
     return false;
 }
-exports.isFloat = isFloat;
 /**
  * Checks if the provided value is a string that cannot be parsed into a
  * number.
@@ -68,14 +70,12 @@ function isString(value) {
     return (typeof value === "string" &&
         (Number.isNaN(parseFloat(value)) || parseFloat(value).toString() !== value));
 }
-exports.isString = isString;
 /**
  * Checks if the provided value is a boolean.
  */
 function isBoolean(value) {
     return typeof value === "boolean";
 }
-exports.isBoolean = isBoolean;
 /**
  * Casts a value that might be string or number to actual string or number.
  * Since LLM might return back an integer/float as a string, we need to cast
@@ -101,4 +101,3 @@ function castValue(input) {
     }
     return value;
 }
-exports.castValue = castValue;

package/dist/node_modules/@langchain/core/dist/tools/index.cjs

@@ -1,7 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.tool = exports.BaseToolkit = exports.DynamicStructuredTool = exports.DynamicTool = exports.Tool = exports.StructuredTool = exports.ToolInputParsingException = void 0;
-const zod_1 = require("zod");
+exports.BaseToolkit = exports.DynamicStructuredTool = exports.DynamicTool = exports.Tool = exports.StructuredTool = exports.ToolInputParsingException = exports.isStructuredToolParams = exports.isStructuredTool = exports.isRunnableToolLike = exports.isLangChainTool = void 0;
+exports.tool = tool;
+const v3_1 = require("zod/v3");
+const json_schema_1 = require("@cfworker/json-schema");
 const manager_js_1 = require("../callbacks/manager.cjs");
 const base_js_1 = require("../language_models/base.cjs");
 const config_js_1 = require("../runnables/config.cjs");
@@ -9,7 +11,13 @@ const tool_js_1 = require("../messages/tool.cjs");
 const index_js_1 = require("../singletons/index.cjs");
 const utils_js_1 = require("./utils.cjs");
 Object.defineProperty(exports, "ToolInputParsingException", { enumerable: true, get: function () { return utils_js_1.ToolInputParsingException; } });
-const is_zod_schema_js_1 = require("../utils/types/is_zod_schema.cjs");
+const zod_js_1 = require("../utils/types/zod.cjs");
+const json_schema_js_1 = require("../utils/json_schema.cjs");
+var types_js_1 = require("./types.cjs");
+Object.defineProperty(exports, "isLangChainTool", { enumerable: true, get: function () { return types_js_1.isLangChainTool; } });
+Object.defineProperty(exports, "isRunnableToolLike", { enumerable: true, get: function () { return types_js_1.isRunnableToolLike; } });
+Object.defineProperty(exports, "isStructuredTool", { enumerable: true, get: function () { return types_js_1.isStructuredTool; } });
+Object.defineProperty(exports, "isStructuredToolParams", { enumerable: true, get: function () { return types_js_1.isStructuredToolParams; } });
 /**
  * Base class for Tools that accept input of any shape defined by a Zod schema.
  */
@@ -52,30 +60,35 @@ class StructuredTool extends base_js_1.BaseLangChain {
             writable: true,
             value: "content"
         });
+        /**
+         * Default config object for the tool runnable.
+         */
+        Object.defineProperty(this, "defaultConfig", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         this.verboseParsingErrors =
             fields?.verboseParsingErrors ?? this.verboseParsingErrors;
         this.responseFormat = fields?.responseFormat ?? this.responseFormat;
+        this.defaultConfig = fields?.defaultConfig ?? this.defaultConfig;
+        this.metadata = fields?.metadata ?? this.metadata;
     }
     /**
      * Invokes the tool with the provided input and configuration.
      * @param input The input for the tool.
      * @param config Optional configuration for the tool.
-     * @returns A Promise that resolves with a string.
+     * @returns A Promise that resolves with the tool's output.
      */
     async invoke(input, config) {
-        let tool_call_id;
         let toolInput;
-        let enrichedConfig = (0, config_js_1.ensureConfig)(config);
+        let enrichedConfig = (0, config_js_1.ensureConfig)((0, config_js_1.mergeConfigs)(this.defaultConfig, config));
         if ((0, utils_js_1._isToolCall)(input)) {
-            tool_call_id = input.id;
             toolInput = input.args;
             enrichedConfig = {
                 ...enrichedConfig,
                 toolCall: input,
-                configurable: {
-                    ...enrichedConfig.configurable,
-                    tool_call_id,
-                },
             };
         }
         else {
@@ -97,26 +110,50 @@ class StructuredTool extends base_js_1.BaseLangChain {
     async call(arg, configArg, 
     /** @deprecated */
     tags) {
-        let parsed;
-        try {
-            parsed = await this.schema.parseAsync(arg);
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        // Determine the actual input that needs parsing/validation.
+        // If arg is a ToolCall, use its args; otherwise, use arg directly.
+        const inputForValidation = (0, utils_js_1._isToolCall)(arg) ? arg.args : arg;
+        let parsed; // This will hold the successfully parsed input of the expected output type.
+        if ((0, zod_js_1.isInteropZodSchema)(this.schema)) {
+            try {
+                // Validate the inputForValidation - TS needs help here as it can't exclude ToolCall based on the check
+                parsed = await (0, zod_js_1.interopParseAsync)(this.schema, inputForValidation);
+            }
+            catch (e) {
+                let message = `Received tool input did not match expected schema`;
+                if (this.verboseParsingErrors) {
+                    message = `${message}\nDetails: ${e.message}`;
+                }
+                // Pass the original raw input arg to the exception
+                throw new utils_js_1.ToolInputParsingException(message, JSON.stringify(arg));
+            }
         }
-        catch (e) {
-            let message = `Received tool input did not match expected schema`;
-            if (this.verboseParsingErrors) {
-                message = `${message}\nDetails: ${e.message}`;
+        else {
+            const result = (0, json_schema_1.validate)(inputForValidation, this.schema);
+            if (!result.valid) {
+                let message = `Received tool input did not match expected schema`;
+                if (this.verboseParsingErrors) {
+                    message = `${message}\nDetails: ${result.errors
+                        .map((e) => `${e.keywordLocation}: ${e.error}`)
+                        .join("\n")}`;
+                }
+                // Pass the original raw input arg to the exception
+                throw new utils_js_1.ToolInputParsingException(message, JSON.stringify(arg));
             }
-            throw new utils_js_1.ToolInputParsingException(message, JSON.stringify(arg));
+            // Assign the validated input to parsed
+            // We cast here because validate() doesn't narrow the type sufficiently for TS, but we know it's valid.
+            parsed = inputForValidation;
         }
         const config = (0, manager_js_1.parseCallbackConfigArg)(configArg);
         const callbackManager_ = manager_js_1.CallbackManager.configure(config.callbacks, this.callbacks, config.tags || tags, this.tags, config.metadata, this.metadata, { verbose: this.verbose });
-        const runManager = await callbackManager_?.handleToolStart(this.toJSON(), typeof parsed === "string" ? parsed : JSON.stringify(parsed), config.runId, undefined, undefined, undefined, config.runName);
+        const runManager = await callbackManager_?.handleToolStart(this.toJSON(), 
+        // Log the original raw input arg
+        typeof arg === "string" ? arg : JSON.stringify(arg), config.runId, undefined, undefined, undefined, config.runName);
         delete config.runId;
         let result;
         try {
+            // Pass the correctly typed parsed input to _call
             result = await this._call(parsed, runManager, config);
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
         }
         catch (e) {
             await runManager?.handleToolError(e);
@@ -136,15 +173,20 @@ class StructuredTool extends base_js_1.BaseLangChain {
             content = result;
         }
         let toolCallId;
-        if (config && "configurable" in config) {
-            toolCallId = config.configurable
-                .tool_call_id;
+        // Extract toolCallId ONLY if the original arg was a ToolCall
+        if ((0, utils_js_1._isToolCall)(arg)) {
+            toolCallId = arg.id;
+        }
+        // Or if it was provided in the config's toolCall property
+        if (!toolCallId && (0, utils_js_1._configHasToolCallId)(config)) {
+            toolCallId = config.toolCall.id;
         }
         const formattedOutput = _formatToolOutput({
             content,
             artifact,
             toolCallId,
             name: this.name,
+            metadata: this.metadata,
         });
         await runManager?.handleToolEnd(formattedOutput);
         return formattedOutput;
@@ -161,8 +203,8 @@ class Tool extends StructuredTool {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: zod_1.z
-                .object({ input: zod_1.z.string().optional() })
+            value: v3_1.z
+                .object({ input: v3_1.z.string().optional() })
                 .transform((obj) => obj.input)
         });
     }
@@ -175,8 +217,13 @@ class Tool extends StructuredTool {
      * @param callbacks Optional callbacks for the tool.
      * @returns A Promise that resolves with a string.
      */
+    // Match the base class signature including the generics and conditional return type
     call(arg, callbacks) {
-        return super.call(typeof arg === "string" || !arg ? { input: arg } : arg, callbacks);
+        // Prepare the input for the base class call method.
+        // If arg is string or undefined, wrap it; otherwise, pass ToolCall or { input: ... } directly.
+        const structuredArg = typeof arg === "string" || arg == null ? { input: arg } : arg;
+        // Ensure TConfig is passed to super.call
+        return super.call(structuredArg, callbacks);
     }
 }
 exports.Tool = Tool;
@@ -220,10 +267,13 @@ class DynamicTool extends Tool {
         if (config.runName === undefined) {
             config.runName = this.name;
         }
+        // Call the Tool class's call method, passing generics through
+        // Cast config to TConfig to satisfy the super.call signature
         return super.call(arg, config);
     }
     /** @ignore */
-    async _call(input, runManager, parentConfig) {
+    async _call(input, // DynamicTool's _call specifically expects a string after schema transformation
+    runManager, parentConfig) {
         return this.func(input, runManager, parentConfig);
     }
 }
@@ -271,11 +321,12 @@ class DynamicStructuredTool extends StructuredTool {
         this.description = fields.description;
         this.func = fields.func;
         this.returnDirect = fields.returnDirect ?? this.returnDirect;
-        this.schema = ((0, is_zod_schema_js_1.isZodSchema)(fields.schema) ? fields.schema : zod_1.z.object({}).passthrough());
+        this.schema = fields.schema;
     }
     /**
      * @deprecated Use .invoke() instead. Will be removed in 0.3.0.
      */
+    // Match the base class signature
     async call(arg, configArg, 
     /** @deprecated */
     tags) {
@@ -283,10 +334,11 @@ class DynamicStructuredTool extends StructuredTool {
         if (config.runName === undefined) {
             config.runName = this.name;
         }
+        // Call the base class method, passing generics through
+        // Cast config to TConfig to satisfy the super.call signature
         return super.call(arg, config, tags);
     }
     _call(arg, runManager, parentConfig) {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         return this.func(arg, runManager, parentConfig);
     }
 }
@@ -303,14 +355,14 @@ class BaseToolkit {
 }
 exports.BaseToolkit = BaseToolkit;
 function tool(func, fields) {
-    // If the schema is not provided, or it's a string schema, create a DynamicTool
-    if (!fields.schema ||
-        ((0, is_zod_schema_js_1.isZodSchema)(fields.schema) &&
-            (!("shape" in fields.schema) || !fields.schema.shape))) {
+    const isSimpleStringSchema = (0, zod_js_1.isSimpleStringZodSchema)(fields.schema);
+    const isStringJSONSchema = (0, json_schema_js_1.validatesOnlyStrings)(fields.schema);
+    // If the schema is not provided, or it's a simple string schema, create a DynamicTool
+    if (!fields.schema || isSimpleStringSchema || isStringJSONSchema) {
         return new DynamicTool({
             ...fields,
             description: fields.description ??
-                fields.schema?.description ??
+                (fields.schema && (0, zod_js_1.getSchemaDescription)(fields.schema)) ??
                 `${fields.name} tool`,
             func: async (input, runManager, config) => {
                 return new Promise((resolve, reject) => {
@@ -331,13 +383,14 @@ function tool(func, fields) {
             },
         });
     }
-    const description = fields.description ?? fields.schema.description ?? `${fields.name} tool`;
+    const schema = fields.schema;
+    const description = fields.description ??
+        fields.schema.description ??
+        `${fields.name} tool`;
     return new DynamicStructuredTool({
         ...fields,
         description,
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        schema: fields.schema,
-        // TODO: Consider moving into DynamicStructuredTool constructor
+        schema,
         func: async (input, runManager, config) => {
             return new Promise((resolve, reject) => {
                 const childConfig = (0, config_js_1.patchConfig)(config, {
@@ -345,8 +398,6 @@ function tool(func, fields) {
                 });
                 void index_js_1.AsyncLocalStorageProviderSingleton.runWithConfig((0, config_js_1.pickRunnableConfigKeys)(childConfig), async () => {
                     try {
-                        // TS doesn't restrict the type here based on the guard above
-                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
                         resolve(func(input, childConfig));
                     }
                     catch (e) {
@@ -357,26 +408,29 @@ function tool(func, fields) {
         },
     });
 }
-exports.tool = tool;
 function _formatToolOutput(params) {
-    const { content, artifact, toolCallId } = params;
+    const { content, artifact, toolCallId, metadata } = params;
     if (toolCallId && !(0, tool_js_1.isDirectToolOutput)(content)) {
         if (typeof content === "string" ||
             (Array.isArray(content) &&
                 content.every((item) => typeof item === "object"))) {
             return new tool_js_1.ToolMessage({
+                status: "success",
                 content,
                 artifact,
                 tool_call_id: toolCallId,
                 name: params.name,
+                metadata,
             });
         }
         else {
             return new tool_js_1.ToolMessage({
+                status: "success",
                 content: _stringify(content),
                 artifact,
                 tool_call_id: toolCallId,
                 name: params.name,
+                metadata,
             });
         }
     }
@@ -386,7 +440,7 @@ function _formatToolOutput(params) {
 }
 function _stringify(content) {
     try {
-        return JSON.stringify(content, null, 2);
+        return JSON.stringify(content, null, 2) ?? "";
     }
     catch (_noOp) {
         return `${content}`;