@flutchai/flutch-sdk 0.1.8 → 0.1.10

package/dist/index.js

@@ -13,6 +13,7 @@ import * as LangGraph from '@langchain/langgraph';
 import { DynamicStructuredTool } from '@langchain/core/tools';
 import { z } from 'zod';
 import axios2 from 'axios';
+import { parseCallbackConfigArg, CallbackManager } from '@langchain/core/callbacks/manager';
 import { ChatOpenAI, OpenAIEmbeddings } from '@langchain/openai';
 import { AzureChatOpenAI } from '@langchain/azure-openai';
 import { ChatAnthropic } from '@langchain/anthropic';
@@ -3870,7 +3871,6 @@ var AttachmentType = /* @__PURE__ */ ((AttachmentType2) => {
 var StreamChannel = /* @__PURE__ */ ((StreamChannel2) => {
   StreamChannel2["TEXT"] = "text";
   StreamChannel2["PROCESSING"] = "processing";
-  StreamChannel2["TOOLS"] = "tools";
   return StreamChannel2;
 })(StreamChannel || {});
 
@@ -4301,7 +4301,7 @@ function sanitizeTraceData(value, depth = 0, seen = /* @__PURE__ */ new WeakSet(
     return null;
   }
   if (typeof value === "string") {
-    return value.length > opts.maxStringLength ? `${value.slice(0, opts.maxStringLength)}\u2026` : value;
+    return value;
   }
   if (typeof value === "number" || typeof value === "boolean") {
     return value;
@@ -4413,15 +4413,15 @@ var EventProcessor = class {
    */
   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
     };
   }
   /**
@@ -4449,10 +4449,88 @@ var EventProcessor = class {
     }
     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 = [];
@@ -4501,223 +4579,96 @@ var EventProcessor = class {
    */
   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;
-      }
+    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_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_tool_start") {
+      this.logger.log("\u{1F527} Tool execution started", {
+        toolName: event.name,
+        input: event.data?.input,
+        runId: event.run_id,
+        metadata: event.metadata
+      });
       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",
+    if (event.event === "on_tool_end") {
+      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,
           {
-            hasUsageMetadata: !!usageMetadata,
-            hasModelId: !!modelId,
-            eventName: event.name,
-            metadataKeys: event.metadata ? Object.keys(event.metadata) : [],
-            outputKeys: output ? Object.keys(output) : []
-          }
+            type: "tool_output_chunk",
+            stepId: state.currentBlock.id,
+            chunk: outputString
+          },
+          onPartial
         );
-      }
-      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.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_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_tool_error") {
+      this.logger.error("\u274C Tool execution failed", {
+        toolName: event.name,
+        error: event.data?.error,
+        runId: event.run_id
+      });
+      return;
+    }
+    if (event.event === "on_chat_model_end") {
+      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") {
+      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 metrics separately (metrics should NOT be stored in message.metadata)
+   * Returns unified content chains from all channels
    */
   getResult(acc) {
-    const totalPromptTokens = acc.llmCalls.reduce(
-      (sum, call) => sum + call.promptTokens,
-      0
-    );
-    const totalCompletionTokens = acc.llmCalls.reduce(
-      (sum, call) => sum + call.completionTokens,
-      0
-    );
-    const totalTokens = acc.llmCalls.reduce(
-      (sum, call) => sum + call.totalTokens,
-      0
-    );
-    this.logger.log("\u{1F4CA} Final metrics collected", {
-      llmCallsCount: acc.llmCalls.length,
-      totalPromptTokens,
-      totalCompletionTokens,
-      totalTokens,
-      modelIds: acc.llmCalls.map((c) => c.modelId)
-    });
-    const metrics = acc.llmCalls.length > 0 ? {
-      modelCalls: acc.llmCalls.map((call) => ({
-        nodeName: call.nodeName || "unknown",
-        timestamp: call.timestamp,
-        modelId: call.modelId,
-        promptTokens: call.promptTokens,
-        completionTokens: call.completionTokens,
-        totalTokens: call.totalTokens,
-        latencyMs: 0
-        // Not calculated from events
-      })),
-      apiCalls: []
-      // TODO: Add API calls tracking (rerank, embeddings) via custom events
-    } : null;
+    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 ? {
@@ -4725,28 +4676,20 @@ var EventProcessor = class {
       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
       },
-      metrics,
       trace
     };
   }
@@ -4861,33 +4804,13 @@ var LangGraphEngine = class {
           );
         }
       }
-      const { content, metrics, trace } = this.eventProcessor.getResult(acc);
+      const { content, trace } = this.eventProcessor.getResult(acc);
       this.logger.debug("[STREAM-RESULT] Got result from EventProcessor", {
         hasContent: !!content,
-        hasMetrics: !!metrics,
-        modelCallsCount: metrics?.modelCalls?.length || 0,
-        apiCallsCount: metrics?.apiCalls?.length || 0,
         hasContext: !!config.configurable?.context,
         hasTrace: !!trace,
         traceEvents: trace?.events?.length || 0
       });
-      if (metrics && metrics.modelCalls?.length > 0 && config.configurable?.context) {
-        const context = config.configurable.context;
-        await this.sendMetricsWebhook({
-          messageId: context.messageId || "unknown",
-          threadId: context.threadId || "unknown",
-          userId: context.userId || "unknown",
-          agentId: context.agentId || "unknown",
-          companyId: context.companyId || "unknown",
-          metrics
-        });
-      } else {
-        this.logger.debug("[METRICS-WEBHOOK] Skipping webhook", {
-          hasMetrics: !!metrics,
-          modelCallsCount: metrics?.modelCalls?.length || 0,
-          hasContext: !!config.configurable?.context
-        });
-      }
       if (trace && trace.events.length > 0 && config.configurable?.context) {
         const context = config.configurable.context;
         this.logger.debug("[TRACE-WEBHOOK] Sending trace events batch", {
@@ -4904,7 +4827,6 @@ var LangGraphEngine = class {
           companyId: context.companyId || "unknown",
           events: trace.events,
           totalEvents: trace.totalEvents,
-          totalModelCalls: trace.totalModelCalls,
           startedAt: trace.startedAt,
           completedAt: trace.completedAt,
           durationMs: trace.durationMs
@@ -4987,7 +4909,6 @@ var LangGraphEngine = class {
         agentId: payload.agentId,
         companyId: payload.companyId,
         totalEvents: payload.totalEvents,
-        totalModelCalls: payload.totalModelCalls,
         startedAt: payload.startedAt,
         completedAt: payload.completedAt,
         durationMs: payload.durationMs,
@@ -5367,47 +5288,65 @@ 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)`
+    );
   }
   /**
-   * Convert JSON Schema to simplified Zod schema for LangChain
+   * 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 z.any();
     }
-    if (jsonSchema.type !== "object") {
-      return this.mapPrimitiveSchema(jsonSchema.type, true);
-    }
-    const properties = jsonSchema.properties || {};
-    const required = Array.isArray(jsonSchema.required) ? jsonSchema.required : [];
-    const zodShape = {};
-    for (const [key, prop] of Object.entries(properties)) {
-      const propDef = prop;
-      const isRequired = required.includes(key);
-      const schemaType = propDef?.type ?? "any";
-      const mappedType = this.mapPrimitiveSchema(schemaType, isRequired);
-      zodShape[key] = mappedType;
-    }
-    const baseObject = z.object(zodShape);
-    const configuredObject = jsonSchema.additionalProperties === false ? baseObject.strict() : baseObject.passthrough();
-    return configuredObject;
-  }
-  mapPrimitiveSchema(type, required) {
-    const optionalize = (schema) => required ? schema : schema.optional();
-    switch (type) {
-      case "string":
-        return optionalize(z.string());
-      case "number":
-      case "integer":
-        return optionalize(z.number());
-      case "boolean":
-        return optionalize(z.boolean());
-      case "array":
-        return optionalize(z.array(z.any()));
-      case "object":
-        return optionalize(z.record(z.any()));
-      default:
-        return optionalize(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 = z.string();
+              break;
+            case "number":
+              zodProp = z.number();
+              break;
+            case "boolean":
+              zodProp = z.boolean();
+              break;
+            case "integer":
+              zodProp = z.number().int();
+              break;
+            case "array":
+              zodProp = z.array(z.any());
+              break;
+            case "object":
+              zodProp = z.record(z.any());
+              break;
+            default:
+              zodProp = z.any();
+          }
+          if (prop.description) {
+            zodProp = zodProp.describe(prop.description);
+          }
+          if (!jsonSchema.required?.includes(key)) {
+            zodProp = zodProp.optional();
+          }
+          shape[key] = zodProp;
+        }
+        return z.object(shape);
+      }
+      this.logger.warn(
+        `Unsupported JSON Schema structure, falling back to z.any()`
+      );
+      return z.any();
+    } catch (error) {
+      this.logger.warn(
+        `Failed to convert JSON Schema, falling back to z.any(): ${error}`
+      );
+      return z.any();
     }
   }
   /**
@@ -5416,6 +5355,27 @@ var McpConverter = class _McpConverter {
   convertTool(mcpTool) {
     const logger2 = this.logger;
     const mcpRuntimeUrl = this.mcpRuntimeUrl;
+    let enhancedDescription = mcpTool.description;
+    if (mcpTool.inputSchema?.properties) {
+      const paramDescriptions = [];
+      for (const [key, propSchema] of Object.entries(
+        mcpTool.inputSchema.properties
+      )) {
+        const prop = propSchema;
+        if (prop.description) {
+          const isRequired = mcpTool.inputSchema.required?.includes(key);
+          paramDescriptions.push(
+            `- ${key}${isRequired ? " (required)" : ""}: ${prop.description}`
+          );
+        }
+      }
+      if (paramDescriptions.length > 0) {
+        enhancedDescription = `${mcpTool.description}
+
+Parameters:
+${paramDescriptions.join("\n")}`;
+      }
+    }
     const schema = this.jsonSchemaToZod(mcpTool.inputSchema);
     logger2.debug(
       `\u{1F527} [${mcpTool.name}] Original schema:`,
@@ -5424,9 +5384,48 @@ var McpConverter = class _McpConverter {
     logger2.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();
+        logger2.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) {
+        logger2.debug(
+          `\u{1F527} [${mcpTool.name}] Could not extract Zod schema shape: ${error}`
+        );
+      }
+    }
+    try {
+      const { zodToJsonSchema } = __require("zod-to-json-schema");
+      const convertedJsonSchema = zodToJsonSchema(schema);
+      logger2.warn(
+        `\u{1F527} [${mcpTool.name}] JSON Schema that LangChain will use:`,
+        JSON.stringify(convertedJsonSchema, null, 2)
+      );
+    } catch (error) {
+      logger2.warn(
+        `\u{1F527} [${mcpTool.name}] Could not convert Zod to JSON Schema: ${error}`
+      );
+    }
     return new DynamicStructuredTool({
       name: mcpTool.name,
-      description: mcpTool.description,
+      description: enhancedDescription,
       schema,
       func: async (input) => {
         logger2.log(`\u{1F527} [${mcpTool.name}] LLM INPUT: ${JSON.stringify(input)}`);
@@ -5743,6 +5742,58 @@ var McpRuntimeHttpClient = class {
       return false;
     }
   }
+  /**
+   * Execute tool with LangChain event emission
+   * @param toolCallId - Tool call ID from LLM
+   * @param toolName - Tool name
+   * @param enrichedArgs - Merged arguments (toolConfig + LLM args)
+   * @param executionContext - Execution context (userId, agentId, etc.)
+   * @param config - RunnableConfig with callbacks
+   * @returns Tool execution result with content
+   */
+  async executeToolWithEvents(toolCallId, toolName, enrichedArgs, executionContext, config) {
+    const parsedConfig = parseCallbackConfigArg(config);
+    const callbackManager = CallbackManager.configure(parsedConfig.callbacks);
+    let runManager;
+    try {
+      runManager = await callbackManager?.handleToolStart(
+        {
+          name: toolName,
+          lc: 1,
+          type: "not_implemented",
+          id: ["langchain", "tools", "mcp", toolName]
+        },
+        JSON.stringify(enrichedArgs),
+        parsedConfig.runId,
+        void 0,
+        parsedConfig.tags,
+        parsedConfig.metadata,
+        toolName
+      );
+      const result = await this.executeTool(
+        toolName,
+        enrichedArgs,
+        executionContext
+      );
+      const content = result.success ? JSON.stringify(result) : result.error || JSON.stringify(result);
+      await runManager?.handleToolEnd(content);
+      return {
+        content,
+        success: result.success
+      };
+    } catch (error) {
+      this.logger.error(`Error executing tool ${toolName}:`, error);
+      await runManager?.handleToolError(error);
+      const errorContent = JSON.stringify({
+        success: false,
+        error: error instanceof Error ? error.message : "Tool execution failed"
+      });
+      return {
+        content: errorContent,
+        success: false
+      };
+    }
+  }
 };
 McpRuntimeHttpClient = __decorateClass([
   Injectable()