@flutchai/flutch-sdk 0.6.8 → 0.6.11

package/dist/index.cjs

@@ -19,9 +19,7 @@ var LangGraph = require('@langchain/langgraph');
 var async_hooks = require('async_hooks');
 var dispatch = require('@langchain/core/callbacks/dispatch');
 var tools = require('@langchain/core/tools');
-var zod = require('zod');
 var axios2 = require('axios');
-var zodToJsonSchema = require('zod-to-json-schema');
 var manager = require('@langchain/core/callbacks/manager');
 var openai = require('@langchain/openai');
 var aws = require('@langchain/aws');
@@ -2047,6 +2045,29 @@ function createMongoClientAdapter(mongooseClient) {
 }
 __name(createMongoClientAdapter, "createMongoClientAdapter");
 
+// src/utils/redact.utils.ts
+var SECRET_PARAM = /(pass|pwd|secret|token|key|credential)/i;
+function redactConnectionString(value) {
+  if (!value) return "";
+  const match = /^([a-z][a-z0-9+.-]*:\/\/)([^/?#]*)(.*)$/i.exec(value.trim());
+  if (!match) return "[redacted]";
+  const [, scheme, authority, rest] = match;
+  const at = authority.lastIndexOf("@");
+  const hosts = at >= 0 ? `***@${authority.slice(at + 1)}` : authority;
+  const queryStart = rest.indexOf("?");
+  if (queryStart < 0) return `${scheme}${hosts}${rest}`;
+  const path4 = rest.slice(0, queryStart);
+  const [query, fragment] = rest.slice(queryStart + 1).split("#", 2);
+  const params = query.split("&").map((pair) => {
+    const eq = pair.indexOf("=");
+    if (eq < 0) return pair;
+    const key = pair.slice(0, eq);
+    return SECRET_PARAM.test(key) ? `${key}=***` : pair;
+  }).join("&");
+  return `${scheme}${hosts}${path4}?${params}${fragment !== void 0 ? `#${fragment}` : ""}`;
+}
+__name(redactConnectionString, "redactConnectionString");
+
 // src/graph/graph-service.interface.ts
 var GraphServiceTokens = {
   REGISTRY: "GRAPH_SERVICE_REGISTRY",
@@ -6309,7 +6330,7 @@ function buildCheckpointerProviders(options) {
           if (!mongoUri) {
             throw new Error("[UniversalGraphModule] MongoDB checkpointer: provide mongodb.uri or set the MONGODB_URI environment variable.");
           }
-          logger3.log(`Checkpointer: MongoDB (${mongoUri.substring(0, 50)}...)`);
+          logger3.log(`Checkpointer: MongoDB (${redactConnectionString(mongoUri)})`);
           await mongoose__default.default.connect(mongoUri, {
             dbName
           });
@@ -6366,9 +6387,10 @@ exports.UniversalGraphModule = class _UniversalGraphModule {
       // Graph engines
       {
         provide: exports.LangGraphEngine,
-        useFactory: /* @__PURE__ */ __name((eventProcessor) => new exports.LangGraphEngine(eventProcessor, void 0), "useFactory"),
+        useFactory: /* @__PURE__ */ __name((eventProcessor, configService) => new exports.LangGraphEngine(eventProcessor, configService), "useFactory"),
         inject: [
-          exports.EventProcessor
+          exports.EventProcessor,
+          config.ConfigService
         ]
       },
       exports.BuilderRegistryService,
@@ -6608,60 +6630,52 @@ var McpConverter = class _McpConverter {
   mcpRuntimeUrl;
   constructor(mcpRuntimeUrl = "http://localhost:3004") {
     this.mcpRuntimeUrl = mcpRuntimeUrl;
-    this.logger.log(`\u{1F527} McpConverter initialized with SDK version 0.1.8 (manual jsonSchemaToZod)`);
+    this.logger.log(`\u{1F527} McpConverter initialized (MCP JSON Schema passed through)`);
   }
   /**
-  * Convert JSON Schema to Zod schema manually
-  * This creates a standard Zod schema that zodToJsonSchema can convert back properly
-  */
-  jsonSchemaToZod(jsonSchema) {
-    if (!jsonSchema || typeof jsonSchema !== "object") {
-      return zod.z.any();
-    }
-    try {
-      if (jsonSchema.type === "object" && jsonSchema.properties) {
-        const shape = {};
-        for (const [key, propSchema] of Object.entries(jsonSchema.properties)) {
-          const prop = propSchema;
-          let zodProp;
-          switch (prop.type) {
-            case "string":
-              zodProp = zod.z.string();
-              break;
-            case "number":
-              zodProp = zod.z.number();
-              break;
-            case "boolean":
-              zodProp = zod.z.boolean();
-              break;
-            case "integer":
-              zodProp = zod.z.number().int();
-              break;
-            case "array":
-              zodProp = zod.z.array(zod.z.any());
-              break;
-            case "object":
-              zodProp = zod.z.record(zod.z.any());
-              break;
-            default:
-              zodProp = zod.z.any();
-          }
-          if (prop.description) {
-            zodProp = zodProp.describe(prop.description);
-          }
-          if (!jsonSchema.required?.includes(key)) {
-            zodProp = zodProp.optional();
-          }
-          shape[key] = zodProp;
+  * The tool's own JSON Schema, ready for the model.
+  *
+  * It used to be rebuilt as Zod by hand, which kept only top-level primitive
+  * types: a list of objects, an `anyOf`, a `$ref` — all became "any", and the
+  * model guessed the shape (a filter list sent as one object, rejected by the
+  * server). LangChain takes JSON Schema directly, so the schema now goes
+  * through as is; only local `$ref`s are inlined, because not every provider
+  * resolves them, and the meta keys providers reject are dropped.
+  */
+  static toModelSchema(inputSchema) {
+    const root = inputSchema && typeof inputSchema === "object" ? inputSchema : {};
+    const defs = {
+      ...root.definitions ?? {},
+      ...root.$defs ?? {}
+    };
+    const resolve2 = /* @__PURE__ */ __name((node, depth) => {
+      if (Array.isArray(node)) return node.map((item) => resolve2(item, depth));
+      if (!node || typeof node !== "object") return node;
+      if (typeof node.$ref === "string") {
+        const match = /^#\/(?:\$defs|definitions)\/(.+)$/.exec(node.$ref);
+        const target = match ? defs[decodeURIComponent(match[1])] : void 0;
+        if (!target || depth > 8) return {};
+        const { $ref: _ref, ...siblings } = node;
+        return resolve2({
+          ...target,
+          ...siblings
+        }, depth + 1);
+      }
+      const out = {};
+      for (const [key, value] of Object.entries(node)) {
+        if (key === "$defs" || key === "definitions" || key === "$schema" || key === "$id") {
+          continue;
         }
-        return zod.z.object(shape);
+        out[key] = resolve2(value, depth);
       }
-      this.logger.warn(`Unsupported JSON Schema structure, falling back to z.any()`);
-      return zod.z.any();
-    } catch (error) {
-      this.logger.warn(`Failed to convert JSON Schema, falling back to z.any(): ${error}`);
-      return zod.z.any();
-    }
+      return out;
+    }, "resolve");
+    const schema = resolve2(root, 0);
+    return {
+      ...schema,
+      type: "object",
+      properties: schema.properties ?? {}
+    };
   }
   /**
   * Convert a single MCP tool to LangChain DynamicStructuredTool
@@ -6686,30 +6700,8 @@ Parameters:
 ${paramDescriptions.join("\n")}`;
       }
     }
-    const schema = this.jsonSchemaToZod(mcpTool.inputSchema);
-    logger3.debug(`\u{1F527} [${mcpTool.name}] Original schema:`, JSON.stringify(mcpTool.inputSchema, null, 2));
-    logger3.debug(`\u{1F527} [${mcpTool.name}] Using schema type: ${schema?._def?.typeName ?? "unknown"}`);
-    if (schema?._def?.shape && typeof schema._def.shape === "function") {
-      try {
-        const shape = schema._def.shape();
-        logger3.debug(`\u{1F527} [${mcpTool.name}] Converted Zod schema shape:`, JSON.stringify(Object.entries(shape).reduce((acc, [key, val]) => {
-          acc[key] = {
-            type: val?._def?.typeName,
-            description: val?._def?.description,
-            optional: val?._def?.typeName === "ZodOptional"
-          };
-          return acc;
-        }, {}), null, 2));
-      } catch (error) {
-        logger3.debug(`\u{1F527} [${mcpTool.name}] Could not extract Zod schema shape: ${error}`);
-      }
-    }
-    try {
-      const convertedJsonSchema = zodToJsonSchema.zodToJsonSchema(schema);
-      logger3.warn(`\u{1F527} [${mcpTool.name}] JSON Schema that LangChain will use:`, JSON.stringify(convertedJsonSchema, null, 2));
-    } catch (error) {
-      logger3.warn(`\u{1F527} [${mcpTool.name}] Could not convert Zod to JSON Schema: ${error}`);
-    }
+    const schema = _McpConverter.toModelSchema(mcpTool.inputSchema);
+    logger3.debug(`\u{1F527} [${mcpTool.name}] Schema for the model: ${JSON.stringify(schema)}`);
     return new tools.DynamicStructuredTool({
       name: mcpTool.name,
       description: enhancedDescription,
@@ -8731,6 +8723,7 @@ exports.loadOAuthProviders = loadOAuthProviders;
 exports.modelAcceptsSamplingParams = modelAcceptsSamplingParams;
 exports.modelSupportsPromptCache = modelSupportsPromptCache;
 exports.normalizeToolConfigs = normalizeToolConfigs;
+exports.redactConnectionString = redactConnectionString;
 exports.registerFinanceExampleCallback = registerFinanceExampleCallback;
 exports.registerUIEndpointsFromClass = registerUIEndpointsFromClass;
 exports.resolveOAuthProviderConfig = resolveOAuthProviderConfig;