@flutchai/flutch-sdk 0.1.9 → 0.1.11

package/dist/index.cjs

@@ -3900,7 +3900,6 @@ var AttachmentType = /* @__PURE__ */ ((AttachmentType2) => {
 var StreamChannel = /* @__PURE__ */ ((StreamChannel2) => {
   StreamChannel2["TEXT"] = "text";
   StreamChannel2["PROCESSING"] = "processing";
-  StreamChannel2["TOOLS"] = "tools";
   return StreamChannel2;
 })(StreamChannel || {});
 
@@ -4443,15 +4442,15 @@ exports.EventProcessor = class EventProcessor {
    */
   createAccumulator() {
     return {
-      streamedText: "",
-      reasoningChains: [],
-      generation: null,
-      llmCalls: [],
+      channels: /* @__PURE__ */ new Map([
+        ["text" /* TEXT */, { contentChain: [], currentBlock: null }],
+        ["processing" /* PROCESSING */, { contentChain: [], currentBlock: null }]
+      ]),
+      attachments: [],
+      metadata: {},
       traceEvents: [],
       traceStartedAt: null,
-      traceCompletedAt: null,
-      currentReasoningSteps: [],
-      currentToolUse: null
+      traceCompletedAt: null
     };
   }
   /**
@@ -4479,10 +4478,88 @@ exports.EventProcessor = class EventProcessor {
     }
     return [];
   }
+  /**
+   * Send delta to UI (unified format)
+   */
+  sendDelta(channel, delta, onPartial) {
+    if (!onPartial) return;
+    onPartial(
+      JSON.stringify({
+        channel,
+        delta
+      })
+    );
+  }
+  /**
+   * Process content stream blocks (universal for all channels)
+   */
+  processContentStream(acc, channel, blocks, onPartial) {
+    const state = acc.channels.get(channel);
+    for (const block of blocks) {
+      if (block.type === "tool_use" || block.type === "tool_call") {
+        if (state.currentBlock) {
+          state.contentChain.push(state.currentBlock);
+        }
+        state.currentBlock = {
+          index: state.contentChain.length,
+          type: "tool_use",
+          name: block.name,
+          id: block.id,
+          input: block.input || "",
+          output: ""
+        };
+        this.sendDelta(
+          channel,
+          {
+            type: "step_started",
+            step: state.currentBlock
+          },
+          onPartial
+        );
+      } else if (block.type === "input_json_delta") {
+        if (state.currentBlock && state.currentBlock.type === "tool_use") {
+          const chunk = block.input || "";
+          state.currentBlock.input += chunk;
+          this.sendDelta(
+            channel,
+            {
+              type: "tool_input_chunk",
+              stepId: state.currentBlock.id,
+              chunk
+            },
+            onPartial
+          );
+        }
+      } else if (block.type === "text") {
+        const textChunk = block.text || "";
+        if (state.currentBlock && state.currentBlock.type === "text") {
+          state.currentBlock.text = (state.currentBlock.text || "") + textChunk;
+        } else {
+          if (state.currentBlock) {
+            state.contentChain.push(state.currentBlock);
+          }
+          state.currentBlock = {
+            index: state.contentChain.length,
+            type: "text",
+            text: textChunk
+          };
+        }
+        this.sendDelta(
+          channel,
+          {
+            type: "text_chunk",
+            text: textChunk
+          },
+          onPartial
+        );
+      }
+    }
+  }
   /**
    * Groups tool_use and input_json_delta into proper structure
    * tool_use.input → output (tool execution result)
    * input_json_delta.input → output (tool execution result, accumulated)
+   * @deprecated This method is for legacy fallback only
    */
   mapReasoningSteps(rawSteps) {
     const steps = [];
@@ -4531,60 +4608,10 @@ exports.EventProcessor = class EventProcessor {
    */
   processEvent(acc, event, onPartial) {
     this.captureTraceEvent(acc, event);
-    if (event.event === "on_chat_model_stream" && event.metadata?.stream_channel === "text" /* TEXT */ && event.data?.chunk?.content) {
-      const chunk = event.data.chunk.content;
-      const blocks = this.normalizeContentBlocks(chunk);
-      if (blocks.length > 0 && onPartial) {
-        onPartial(JSON.stringify({ text: blocks }));
-      }
-      const textOnly = blocks.filter((block) => block?.type === "text").map((block) => block.text || "").join("");
-      if (textOnly) {
-        acc.streamedText += textOnly;
-      }
-      return;
-    }
-    if (event.event === "on_chat_model_stream" && event.metadata?.stream_channel === "processing" /* PROCESSING */ && event.data?.chunk?.content) {
-      const chunk = event.data.chunk.content;
-      const blocks = this.normalizeContentBlocks(chunk);
-      for (const block of blocks) {
-        if (block.type === "tool_use" || block.type === "tool_call") {
-          if (acc.currentToolUse) {
-            acc.currentReasoningSteps.push(acc.currentToolUse);
-          }
-          acc.currentToolUse = {
-            index: acc.currentReasoningSteps.length,
-            type: "tool_use",
-            name: block.name,
-            id: block.id,
-            input: block.input || "",
-            output: ""
-          };
-          if (onPartial) {
-            onPartial(
-              JSON.stringify({
-                processing_delta: {
-                  type: "step_started",
-                  step: acc.currentToolUse
-                }
-              })
-            );
-          }
-        } else if (block.type === "input_json_delta") {
-          if (acc.currentToolUse && onPartial) {
-            const chunk2 = block.input || "";
-            acc.currentToolUse.output += chunk2;
-            onPartial(
-              JSON.stringify({
-                processing_delta: {
-                  type: "output_chunk",
-                  stepId: acc.currentToolUse.id,
-                  chunk: chunk2
-                }
-              })
-            );
-          }
-        }
-      }
+    if (event.event === "on_chat_model_stream" && event.data?.chunk?.content) {
+      const channel = event.metadata?.stream_channel ?? "text" /* TEXT */;
+      const blocks = this.normalizeContentBlocks(event.data.chunk.content);
+      this.processContentStream(acc, channel, blocks, onPartial);
       return;
     }
     if (event.event === "on_tool_start") {
@@ -4597,11 +4624,27 @@ exports.EventProcessor = class EventProcessor {
       return;
     }
     if (event.event === "on_tool_end") {
-      this.logger.log("\u2705 Tool execution completed", {
-        toolName: event.name,
-        output: typeof event.data?.output === "string" ? event.data.output.substring(0, 200) + (event.data.output.length > 200 ? "..." : "") : event.data?.output,
-        runId: event.run_id
-      });
+      const channel = event.metadata?.stream_channel ?? "text" /* TEXT */;
+      const state = acc.channels.get(channel);
+      if (state?.currentBlock && state.currentBlock.type === "tool_use") {
+        const output = event.data?.output;
+        const outputString = typeof output === "string" ? output : JSON.stringify(output, null, 2);
+        state.currentBlock.output = outputString;
+        this.sendDelta(
+          channel,
+          {
+            type: "tool_output_chunk",
+            stepId: state.currentBlock.id,
+            chunk: outputString
+          },
+          onPartial
+        );
+        this.logger.log("\u2705 Tool execution completed", {
+          toolName: event.name,
+          outputPreview: outputString.substring(0, 200) + (outputString.length > 200 ? "..." : ""),
+          runId: event.run_id
+        });
+      }
       return;
     }
     if (event.event === "on_tool_error") {
@@ -4613,133 +4656,48 @@ exports.EventProcessor = class EventProcessor {
       return;
     }
     if (event.event === "on_chat_model_end") {
-      const output = event.data?.output;
-      const usageMetadata = output?.usage_metadata || output?.usageMetadata;
-      const modelId = event.metadata?.modelId;
-      if (usageMetadata && modelId) {
-        const llmCall = {
-          modelId,
-          promptTokens: usageMetadata.input_tokens || 0,
-          completionTokens: usageMetadata.output_tokens || 0,
-          totalTokens: usageMetadata.total_tokens || 0,
-          timestamp: Date.now(),
-          nodeName: event.metadata?.langgraph_node || event.name
-        };
-        acc.llmCalls.push(llmCall);
-        this.logger.log("\u2705 LLM call recorded", {
-          modelId,
-          tokens: llmCall.totalTokens,
-          nodeName: llmCall.nodeName,
-          totalRecorded: acc.llmCalls.length
-        });
-      } else {
-        this.logger.warn(
-          "\u26A0\uFE0F Missing usage metadata or modelId in on_chat_model_end",
-          {
-            hasUsageMetadata: !!usageMetadata,
-            hasModelId: !!modelId,
-            eventName: event.name,
-            metadataKeys: event.metadata ? Object.keys(event.metadata) : [],
-            outputKeys: output ? Object.keys(output) : []
-          }
-        );
-      }
-      if (event.metadata?.stream_channel === "processing" /* PROCESSING */) {
-        if (acc.currentToolUse) {
-          acc.currentReasoningSteps.push(acc.currentToolUse);
-          acc.currentToolUse = null;
-        }
-        if (acc.currentReasoningSteps.length > 0) {
-          acc.reasoningChains.push({
-            steps: acc.currentReasoningSteps,
-            isComplete: true
-          });
-          if (onPartial) {
-            onPartial(
-              JSON.stringify({
-                processing_delta: {
-                  type: "chain_completed"
-                }
-              })
-            );
-          }
-          acc.currentReasoningSteps = [];
-        } else {
-          const stepsRaw = output?.content || // AIMessageChunk object (direct)
-          output?.kwargs?.content || // Serialized LangChain format
-          event.data?.chunk?.content || // Older version
-          [];
-          let steps;
-          if (Array.isArray(stepsRaw)) {
-            steps = this.mapReasoningSteps(stepsRaw);
-          } else if (typeof stepsRaw === "string" && stepsRaw.trim().length > 0) {
-            steps = [
-              {
-                index: 0,
-                type: "text",
-                text: stepsRaw.trim()
-              }
-            ];
-          } else {
-            steps = [];
-          }
-          if (steps.length > 0) {
-            acc.reasoningChains.push({
-              steps,
-              isComplete: true
-            });
-            if (onPartial) {
-              onPartial(
-                JSON.stringify({
-                  processing_delta: {
-                    type: "chain_completed"
-                  }
-                })
-              );
-            }
-          }
-        }
-      }
+      this.logger.debug("\u2705 LLM call completed", {
+        nodeName: event.metadata?.langgraph_node || event.name,
+        channel: event.metadata?.stream_channel
+      });
       return;
     }
-    if (event.event === "on_chain_end" && event.metadata?.stream_channel === "text" /* TEXT */) {
-      const output = event.data.output;
-      let generation = null;
-      if (output?.answer?.text) {
-        generation = {
-          text: output.answer.text,
-          attachments: output.answer.attachments || [],
-          metadata: output.answer.metadata || {}
-        };
-      } else if (output?.generation?.text) {
-        generation = {
-          text: output.generation.text,
-          attachments: output.generation.attachments || [],
-          metadata: output.generation.metadata || {}
-        };
-      } else if (output?.generation?.content) {
-        generation = {
-          text: output.generation.content,
-          attachments: [],
-          metadata: {}
-        };
-      } else if (output?.text) {
-        generation = {
-          text: output.text,
-          attachments: output.attachments || [],
-          metadata: output.metadata || {}
-        };
+    if (event.event === "on_chain_end") {
+      const channel = event.metadata?.stream_channel ?? "text" /* TEXT */;
+      if (channel === "text" /* TEXT */) {
+        const output = event.data.output;
+        if (output?.answer) {
+          acc.attachments = output.answer.attachments || [];
+          acc.metadata = output.answer.metadata || {};
+        } else if (output?.generation) {
+          acc.attachments = output.generation.attachments || [];
+          acc.metadata = output.generation.metadata || {};
+        } else if (output) {
+          acc.attachments = output.attachments || [];
+          acc.metadata = output.metadata || {};
+        }
       }
-      acc.generation = generation;
       return;
     }
   }
   /**
    * Build final result from accumulator
-   * Uses generation if available, otherwise falls back to streamed text
-   * Returns content and trace events (metrics should be extracted from trace on backend)
+   * Returns unified content chains from all channels
    */
   getResult(acc) {
+    const allChains = [];
+    for (const [channel, state] of acc.channels.entries()) {
+      if (state.currentBlock) {
+        state.contentChain.push(state.currentBlock);
+      }
+      if (state.contentChain.length > 0) {
+        allChains.push({
+          channel,
+          steps: state.contentChain,
+          isComplete: true
+        });
+      }
+    }
     const startedAt = acc.traceStartedAt ?? Date.now();
     const completedAt = acc.traceCompletedAt ?? startedAt;
     const trace = acc.traceEvents.length > 0 ? {
@@ -4747,26 +4705,19 @@ exports.EventProcessor = class EventProcessor {
       startedAt,
       completedAt,
       durationMs: Math.max(0, completedAt - startedAt),
-      totalEvents: acc.traceEvents.length,
-      totalModelCalls: acc.llmCalls.length
+      totalEvents: acc.traceEvents.length
     } : null;
-    if (trace) {
-      this.logger.log("\u{1F4CA} [EventProcessor] Final trace assembled", {
-        totalEvents: trace.totalEvents,
-        eventsArrayLength: trace.events.length,
-        firstEventType: trace.events[0]?.type,
-        lastEventType: trace.events[trace.events.length - 1]?.type,
-        firstEventSample: trace.events[0] ? JSON.stringify(trace.events[0]).substring(0, 150) : null,
-        allEventsNull: trace.events.every((e) => e === null),
-        someEventsNull: trace.events.some((e) => e === null)
-      });
-    }
+    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)
+    });
     return {
       content: {
-        text: acc.generation?.text || acc.streamedText || "",
-        attachments: acc.generation?.attachments || [],
-        metadata: acc.generation?.metadata || {},
-        reasoningChains: acc.reasoningChains.length > 0 ? acc.reasoningChains : void 0
+        contentChains: allChains.length > 0 ? allChains : void 0,
+        attachments: acc.attachments,
+        metadata: acc.metadata
       },
       trace
     };
@@ -4887,8 +4838,7 @@ exports.LangGraphEngine = class LangGraphEngine {
         hasContent: !!content,
         hasContext: !!config.configurable?.context,
         hasTrace: !!trace,
-        traceEvents: trace?.events?.length || 0,
-        totalModelCalls: trace?.totalModelCalls || 0
+        traceEvents: trace?.events?.length || 0
       });
       if (trace && trace.events.length > 0 && config.configurable?.context) {
         const context = config.configurable.context;
@@ -4906,7 +4856,6 @@ exports.LangGraphEngine = class LangGraphEngine {
           companyId: context.companyId || "unknown",
           events: trace.events,
           totalEvents: trace.totalEvents,
-          totalModelCalls: trace.totalModelCalls,
           startedAt: trace.startedAt,
           completedAt: trace.completedAt,
           durationMs: trace.durationMs
@@ -4989,7 +4938,6 @@ exports.LangGraphEngine = class LangGraphEngine {
         agentId: payload.agentId,
         companyId: payload.companyId,
         totalEvents: payload.totalEvents,
-        totalModelCalls: payload.totalModelCalls,
         startedAt: payload.startedAt,
         completedAt: payload.completedAt,
         durationMs: payload.durationMs,
@@ -5597,37 +5545,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(
@@ -5642,20 +5596,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,
@@ -6200,8 +6154,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
@@ -6438,12 +6414,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}`);
@@ -6481,17 +6452,70 @@ 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}`);
@@ -6519,14 +6543,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}`);
@@ -6674,7 +6691,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");
@@ -6718,40 +6735,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) => {
@@ -7101,7 +7084,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;