@flutchai/flutch-sdk 0.1.10 → 0.1.12

package/dist/index.cjs

@@ -3909,6 +3909,9 @@ var GraphServiceTokens = {
   CLIENT: "GRAPH_SERVICE_CLIENT",
   SETTINGS_REPOSITORY: "GRAPH_SERVICE_SETTINGS_REPOSITORY"
 };
+
+// src/graph/graph.controller.ts
+init_builder_registry_service();
 exports.GraphController = class GraphController {
   constructor(graphService, builderRegistry) {
     this.graphService = graphService;
@@ -4071,7 +4074,8 @@ __decorateClass([
 exports.GraphController = __decorateClass([
   swagger.ApiTags("Graphs"),
   common.Controller(),
-  __decorateParam(0, common.Inject("GRAPH_SERVICE"))
+  __decorateParam(0, common.Inject("GRAPH_SERVICE")),
+  __decorateParam(1, common.Inject(exports.BuilderRegistryService))
 ], exports.GraphController);
 
 // src/graph/graph-manifest.schema.ts
@@ -4707,17 +4711,22 @@ exports.EventProcessor = class EventProcessor {
       durationMs: Math.max(0, completedAt - startedAt),
       totalEvents: acc.traceEvents.length
     } : null;
+    const textChain = allChains.find((c) => c.channel === "text");
+    const text = textChain ? textChain.steps.filter((step) => step.type === "text").map((step) => step.text || "").join("") : "";
     this.logger.log("\u{1F4CA} [EventProcessor] Final result assembled", {
       totalChains: allChains.length,
       textChains: allChains.filter((c) => c.channel === "text").length,
       processingChains: allChains.filter((c) => c.channel === "processing").length,
-      totalSteps: allChains.reduce((sum, c) => sum + c.steps.length, 0)
+      totalSteps: allChains.reduce((sum, c) => sum + c.steps.length, 0),
+      textLength: text.length
     });
     return {
       content: {
         contentChains: allChains.length > 0 ? allChains : void 0,
         attachments: acc.attachments,
-        metadata: acc.metadata
+        metadata: acc.metadata,
+        text
+        // Add extracted text for backwards compatibility
       },
       trace
     };
@@ -5545,37 +5554,43 @@ var McpToolFilter = class _McpToolFilter {
   logger = new common.Logger(_McpToolFilter.name);
   mcpConverter;
   /**
-   * Fetch available tools from MCP runtime with optional filtering
-   * @param enabledTools Array of tool names to filter for
-   * @returns Array of LangChain Tool instances
+   * Fetch available tools from MCP runtime with dynamic schema generation
+   * @param toolsConfig Array of tool configurations with dynamic config
+   * @returns Array of LangChain Tool instances with dynamic schemas
    */
-  async getFilteredTools(enabledTools = []) {
+  async getFilteredTools(toolsConfig = []) {
     this.logger.debug(
-      `[DEBUG] Getting filtered tools. Enabled: ${enabledTools.join(", ")}`
+      `[DEBUG] Getting filtered tools with dynamic schemas. Config: ${JSON.stringify(toolsConfig)}`
     );
     this.logger.debug(`[DEBUG] MCP Runtime URL: ${this.mcpRuntimeUrl}`);
-    if (enabledTools.length === 0) {
-      this.logger.debug("No tools enabled, returning empty array");
+    if (toolsConfig.length === 0) {
+      this.logger.debug("No tools configured, returning empty array");
       return [];
     }
     try {
-      const filterParam = enabledTools.join(",");
       this.logger.debug(
-        `[DEBUG] Making HTTP request to: ${this.mcpRuntimeUrl}/tools/list with filter: ${filterParam}`
+        `[DEBUG] Making HTTP POST request to: ${this.mcpRuntimeUrl}/tools/schemas`
+      );
+      this.logger.debug(`[DEBUG] Request body: ${JSON.stringify(toolsConfig)}`);
+      const response = await axios2__default.default.post(
+        `${this.mcpRuntimeUrl}/tools/schemas`,
+        { tools: toolsConfig },
+        {
+          timeout: 5e3,
+          headers: {
+            "Content-Type": "application/json"
+          }
+        }
       );
-      const response = await axios2__default.default.get(`${this.mcpRuntimeUrl}/tools/list`, {
-        params: { filter: filterParam },
-        timeout: 5e3
-      });
       this.logger.debug(
         `[DEBUG] HTTP response status: ${response.status}, data length: ${Array.isArray(response.data) ? response.data.length : "not array"}`
       );
-      const filteredTools = Array.isArray(response.data) ? response.data : [];
+      const dynamicTools = Array.isArray(response.data) ? response.data : [];
       this.logger.debug(
-        `Retrieved ${filteredTools.length} filtered MCP tools for: ${enabledTools.join(", ")}`
+        `Retrieved ${dynamicTools.length} dynamic tool schemas from MCP Runtime`
       );
       const mcpClient = {
-        getTools: async () => filteredTools,
+        getTools: async () => dynamicTools,
         executeTool: async (name, args) => {
           this.logger.debug(`[DEBUG] Executing tool ${name} with args:`, args);
           const response2 = await axios2__default.default.post(
@@ -5590,20 +5605,20 @@ var McpToolFilter = class _McpToolFilter {
         isHealthy: async () => true
       };
       this.logger.log(
-        `\u{1F680} [McpToolFilter] Converting ${filteredTools.length} tools using new McpConverter`
+        `\u{1F680} [McpToolFilter] Converting ${dynamicTools.length} dynamic tools using McpConverter`
       );
-      const tools = await this.mcpConverter.convertTools(filteredTools);
+      const tools = await this.mcpConverter.convertTools(dynamicTools);
       this.logger.log(
         `\u{1F680} [McpToolFilter] Converted tools: ${tools.map((t) => t.name).join(", ")}`
       );
       this.logger.log(
-        `Configured ${tools.length} tools from MCP runtime: ${filteredTools.map((t) => t.name).join(", ")}`
+        `Configured ${tools.length} tools with dynamic schemas from MCP runtime: ${dynamicTools.map((t) => t.name).join(", ")}`
       );
       return tools;
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
       this.logger.warn(
-        `[DEBUG] Failed to fetch tools from MCP runtime (${this.mcpRuntimeUrl}): ${errorMessage}`
+        `[DEBUG] Failed to fetch dynamic tool schemas from MCP runtime (${this.mcpRuntimeUrl}): ${errorMessage}`
       );
       this.logger.warn(`[DEBUG] Error details:`, {
         error,
@@ -6148,8 +6163,30 @@ var ModelInitializer = class _ModelInitializer {
   /**
    * Generate cache key for model instances based on configuration
    */
-  generateModelCacheKey(modelId, temperature, maxTokens, modelType) {
-    return `${modelId}:${temperature || "default"}:${maxTokens || "default"}:${modelType || "chat" /* CHAT */}`;
+  /**
+   * Generate hash from toolsConfig for cache key
+   * Uses MD5 hash to create short, unique identifier
+   */
+  hashToolsConfig(toolsConfig) {
+    const sorted = toolsConfig.map((t) => `${t.toolName}:${t.enabled}:${JSON.stringify(t.config || {})}`).sort().join("|");
+    return crypto.createHash("md5").update(sorted).digest("hex").slice(0, 16);
+  }
+  /**
+   * Generate cache key from ModelByIdConfig
+   * Format: modelId:temperature:maxTokens[:toolsHash]
+   * Example: "model123:0.7:4096" or "model123:0.7:4096:a1b2c3d4e5f6g7h8"
+   */
+  generateModelCacheKey(config) {
+    const parts = [
+      config.modelId,
+      config.temperature ?? "default",
+      config.maxTokens ?? "default"
+    ];
+    if (config.toolsConfig && config.toolsConfig.length > 0) {
+      const toolsHash = this.hashToolsConfig(config.toolsConfig);
+      parts.push(toolsHash);
+    }
+    return parts.join(":");
   }
   /**
    * TEMPORARY SOLUTION for compatibility with new OpenAI models
@@ -6386,12 +6423,7 @@ var ModelInitializer = class _ModelInitializer {
     ["voyageai" /* VOYAGEAI */]: void 0
   };
   async initializeChatModel(config) {
-    const cacheKey = this.generateModelCacheKey(
-      config.modelId,
-      config.temperature,
-      config.maxTokens,
-      "chat" /* CHAT */
-    );
+    const cacheKey = this.generateModelCacheKey(config);
     const cachedModel = this.modelInstanceCache.get(cacheKey);
     if (cachedModel) {
       this.logger.debug(`Using cached chat model instance: ${cacheKey}`);
@@ -6429,17 +6461,76 @@ var ModelInitializer = class _ModelInitializer {
       metadataKeys: Object.keys(model.metadata || {}),
       hasModelId: !!model.metadata?.modelId
     });
+    this.logger.debug(
+      `[TOOLS CHECK] toolsConfig exists: ${!!config.toolsConfig}, customTools exists: ${!!config.customTools}`
+    );
+    if (config.toolsConfig) {
+      this.logger.debug(
+        `[TOOLS CHECK] toolsConfig length: ${config.toolsConfig.length}, content: ${JSON.stringify(config.toolsConfig)}`
+      );
+    }
+    if (config.toolsConfig || config.customTools) {
+      this.logger.debug(
+        `[TOOLS] Calling bindToolsToModel with toolsConfig: ${JSON.stringify(config.toolsConfig)}`
+      );
+      const boundModel = await this.bindToolsToModel(
+        model,
+        config.toolsConfig,
+        config.customTools
+      );
+      this.logger.debug(`[TOOLS] bindToolsToModel returned successfully`);
+      this.modelInstanceCache.set(cacheKey, boundModel);
+      return boundModel;
+    }
     this.modelInstanceCache.set(cacheKey, model);
     return model;
   }
+  /**
+   * Bind tools to model (merge toolsConfig and customTools)
+   * For toolsConfig: fetch tool executors from MCP Runtime
+   * For customTools: use as-is (already prepared DynamicStructuredTool)
+   *
+   * Returns:
+   * - Runnable when tools are bound (model.bindTools returns Runnable)
+   * - BaseChatModel when no tools
+   */
+  async bindToolsToModel(model, toolsConfig, customTools) {
+    const allTools = [];
+    if (toolsConfig && toolsConfig.length > 0) {
+      try {
+        const enabledToolsConfig = toolsConfig.filter(
+          (tc) => tc.enabled !== false
+        );
+        if (enabledToolsConfig.length > 0) {
+          this.logger.debug(
+            `Fetching ${enabledToolsConfig.length} tools with dynamic schemas from MCP Runtime: ${enabledToolsConfig.map((tc) => tc.toolName).join(", ")}`
+          );
+          const mcpToolFilter = new McpToolFilter();
+          const mcpTools = await mcpToolFilter.getFilteredTools(enabledToolsConfig);
+          this.logger.debug(
+            `Successfully fetched ${mcpTools.length} tools with dynamic schemas from MCP Runtime`
+          );
+          allTools.push(...mcpTools);
+        }
+      } catch (error) {
+        this.logger.error(
+          `Failed to fetch tools from MCP Runtime: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+    if (customTools && customTools.length > 0) {
+      allTools.push(...customTools);
+      this.logger.debug(`Added ${customTools.length} custom tools to model`);
+    }
+    if (allTools.length > 0) {
+      this.logger.debug(`Binding ${allTools.length} tools to model`);
+      const modelWithTools = model.bindTools(allTools);
+      return modelWithTools;
+    }
+    return model;
+  }
   async initializeRerankModel(config) {
-    const cacheKey = this.generateModelCacheKey(
-      config.modelId,
-      void 0,
-      // rerank models typically don't use temperature
-      config.maxTokens,
-      "rerank" /* RERANK */
-    );
+    const cacheKey = this.generateModelCacheKey(config);
     const cachedModel = this.modelInstanceCache.get(cacheKey);
     if (cachedModel) {
       this.logger.debug(`Using cached rerank model instance: ${cacheKey}`);
@@ -6467,14 +6558,7 @@ var ModelInitializer = class _ModelInitializer {
     return model;
   }
   async initializeEmbeddingModel(config) {
-    const cacheKey = this.generateModelCacheKey(
-      config.modelId,
-      void 0,
-      // embedding models typically don't use temperature
-      void 0,
-      // embedding models typically don't use maxTokens
-      "embedding" /* EMBEDDING */
-    );
+    const cacheKey = this.generateModelCacheKey(config);
     const cachedModel = this.modelInstanceCache.get(cacheKey);
     if (cachedModel) {
       this.logger.debug(`Using cached embedding model instance: ${cacheKey}`);
@@ -6622,7 +6706,7 @@ var ModelInitializer = class _ModelInitializer {
   }
   // Simple API request for microservices (copy from original LLMInitializer)
   async fetchFromApi(modelId) {
-    const apiUrl = process.env.API_URL || "http://amelie-service";
+    const apiUrl = process.env.API_URL;
     const token = process.env.INTERNAL_API_TOKEN;
     if (!token) {
       throw new Error("INTERNAL_API_TOKEN required for API mode");
@@ -6666,40 +6750,6 @@ var ModelInitializer = class _ModelInitializer {
     return result;
   }
 };
-function prepareModelWithTools(model, tools, baseConfig = {}) {
-  if (tools.length === 0) {
-    return {
-      modelWithTools: model,
-      finalConfig: baseConfig,
-      toolsMethod: "none"
-    };
-  }
-  if (model.bindTools && typeof model.bindTools === "function") {
-    try {
-      const modelWithTools = model.bindTools(tools);
-      return {
-        modelWithTools,
-        finalConfig: baseConfig,
-        toolsMethod: "bindTools"
-      };
-    } catch (error) {
-      const invokeConfig2 = { tools };
-      const finalConfig2 = { ...baseConfig, ...invokeConfig2 };
-      return {
-        modelWithTools: model,
-        finalConfig: finalConfig2,
-        toolsMethod: "manual"
-      };
-    }
-  }
-  const invokeConfig = { tools };
-  const finalConfig = { ...baseConfig, ...invokeConfig };
-  return {
-    modelWithTools: model,
-    finalConfig,
-    toolsMethod: "manual"
-  };
-}
 
 // src/retriever/enums.ts
 var RetrieverSearchType = /* @__PURE__ */ ((RetrieverSearchType2) => {
@@ -7049,7 +7099,6 @@ exports.getUIEndpointClassMetadata = getUIEndpointClassMetadata;
 exports.getUIEndpointMethodsMetadata = getUIEndpointMethodsMetadata;
 exports.hasCallbacks = hasCallbacks;
 exports.hasUIEndpoints = hasUIEndpoints;
-exports.prepareModelWithTools = prepareModelWithTools;
 exports.registerFinanceExampleCallback = registerFinanceExampleCallback;
 exports.registerUIEndpointsFromClass = registerUIEndpointsFromClass;
 exports.sanitizeTraceData = sanitizeTraceData;