@flutchai/flutch-sdk 0.1.8 → 0.1.9

package/dist/index.cjs

@@ -15,6 +15,7 @@ var LangGraph = require('@langchain/langgraph');
 var tools = require('@langchain/core/tools');
 var zod = require('zod');
 var axios2 = require('axios');
+var manager = require('@langchain/core/callbacks/manager');
 var openai = require('@langchain/openai');
 var azureOpenai = require('@langchain/azure-openai');
 var anthropic = require('@langchain/anthropic');
@@ -4330,7 +4331,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;
@@ -4586,6 +4587,31 @@ exports.EventProcessor = class EventProcessor {
       }
       return;
     }
+    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_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
+      });
+      return;
+    }
+    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") {
       const output = event.data?.output;
       const usageMetadata = output?.usage_metadata || output?.usageMetadata;
@@ -4711,42 +4737,9 @@ exports.EventProcessor = class EventProcessor {
   /**
    * 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 content and trace events (metrics should be extracted from trace on backend)
    */
   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 startedAt = acc.traceStartedAt ?? Date.now();
     const completedAt = acc.traceCompletedAt ?? startedAt;
     const trace = acc.traceEvents.length > 0 ? {
@@ -4775,7 +4768,6 @@ exports.EventProcessor = class EventProcessor {
         metadata: acc.generation?.metadata || {},
         reasoningChains: acc.reasoningChains.length > 0 ? acc.reasoningChains : void 0
       },
-      metrics,
       trace
     };
   }
@@ -4890,33 +4882,14 @@ exports.LangGraphEngine = class LangGraphEngine {
           );
         }
       }
-      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
+        traceEvents: trace?.events?.length || 0,
+        totalModelCalls: trace?.totalModelCalls || 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", {
@@ -5396,47 +5369,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 zod.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 = zod.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(zod.z.string());
-      case "number":
-      case "integer":
-        return optionalize(zod.z.number());
-      case "boolean":
-        return optionalize(zod.z.boolean());
-      case "array":
-        return optionalize(zod.z.array(zod.z.any()));
-      case "object":
-        return optionalize(zod.z.record(zod.z.any()));
-      default:
-        return optionalize(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;
+        }
+        return zod.z.object(shape);
+      }
+      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();
     }
   }
   /**
@@ -5445,6 +5436,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:`,
@@ -5453,9 +5465,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 tools.DynamicStructuredTool({
       name: mcpTool.name,
-      description: mcpTool.description,
+      description: enhancedDescription,
       schema,
       func: async (input) => {
         logger2.log(`\u{1F527} [${mcpTool.name}] LLM INPUT: ${JSON.stringify(input)}`);
@@ -5772,6 +5823,58 @@ exports.McpRuntimeHttpClient = class McpRuntimeHttpClient {
       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 = manager.parseCallbackConfigArg(config);
+    const callbackManager = manager.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
+      };
+    }
+  }
 };
 exports.McpRuntimeHttpClient = __decorateClass([
   common.Injectable()