@flutchai/flutch-sdk 0.1.15 → 0.1.17

package/dist/index.cjs

@@ -4832,6 +4832,8 @@ exports.LangGraphEngine = class LangGraphEngine {
     return this.processGraphResult(result);
   }
   async streamGraph(graph, config, onPartial, signal) {
+    const acc = this.eventProcessor.createAccumulator();
+    let streamError = null;
     try {
       if (signal) {
         config.signal = signal;
@@ -4841,7 +4843,6 @@ exports.LangGraphEngine = class LangGraphEngine {
         version: "v2"
         // Important for correct operation
       });
-      const acc = this.eventProcessor.createAccumulator();
       for await (const event of eventStream) {
         try {
           this.eventProcessor.processEvent(acc, event, onPartial);
@@ -4851,20 +4852,44 @@ exports.LangGraphEngine = class LangGraphEngine {
           );
         }
       }
-      const { content, trace } = this.eventProcessor.getResult(acc);
-      this.logger.debug("[STREAM-RESULT] Got result from EventProcessor", {
-        hasContent: !!content,
-        hasContext: !!config.configurable?.context,
-        hasTrace: !!trace,
-        traceEvents: trace?.events?.length || 0
-      });
+    } catch (error) {
+      streamError = error instanceof Error ? error : new Error(String(error));
+      this.logger.error(
+        `[STREAM-ERROR] Error in streamGraph: ${streamError.message}`
+      );
+      this.logger.error(`[STREAM-ERROR] Stack trace: ${streamError.stack}`);
+    } finally {
+      await this.sendTraceFromAccumulator(acc, config, streamError);
+    }
+    const { content, trace } = this.eventProcessor.getResult(acc);
+    this.logger.debug("[STREAM-RESULT] Got result from EventProcessor", {
+      hasContent: !!content,
+      hasContext: !!config.configurable?.context,
+      hasTrace: !!trace,
+      traceEvents: trace?.events?.length || 0,
+      hadError: !!streamError
+    });
+    if (streamError) {
+      throw streamError;
+    }
+    return content;
+  }
+  /**
+   * Extract trace from accumulator and send to backend webhook
+   * Called in finally block to ensure trace is sent even on errors
+   */
+  async sendTraceFromAccumulator(acc, config, error) {
+    try {
+      const { trace } = this.eventProcessor.getResult(acc);
       if (trace && trace.events.length > 0 && config.configurable?.context) {
         const context = config.configurable.context;
         this.logger.debug("[TRACE-WEBHOOK] Sending trace events batch", {
           messageId: context.messageId,
           totalEvents: trace.totalEvents,
           eventsArrayLength: trace.events.length,
-          firstEventType: trace.events[0]?.type
+          firstEventType: trace.events[0]?.type,
+          hadError: !!error,
+          errorMessage: error?.message
         });
         await this.sendTraceEventsBatch({
           messageId: context.messageId || "unknown",
@@ -4875,24 +4900,28 @@ exports.LangGraphEngine = class LangGraphEngine {
           events: trace.events,
           totalEvents: trace.totalEvents,
           startedAt: trace.startedAt,
-          completedAt: trace.completedAt,
-          durationMs: trace.durationMs
+          completedAt: trace.completedAt || Date.now(),
+          durationMs: trace.durationMs || Date.now() - trace.startedAt,
+          status: error ? "error" : "success",
+          error: error ? { message: error.message, name: error.name } : void 0
         });
       } else {
         this.logger.debug("[TRACE-WEBHOOK] Skipping webhook", {
           hasTrace: !!trace,
           traceEvents: trace?.events?.length || 0,
           hasContext: !!config.configurable?.context,
-          contextKeys: config.configurable?.context ? Object.keys(config.configurable.context) : []
+          contextKeys: config.configurable?.context ? Object.keys(config.configurable.context) : [],
+          hadError: !!error
         });
       }
-      return content;
-    } catch (error) {
+    } catch (webhookError) {
       this.logger.error(
-        `[STREAM-ERROR] Error in streamGraph: ${error.message}`
+        "[TRACE-WEBHOOK] Failed to send trace in finally block",
+        {
+          error: webhookError instanceof Error ? webhookError.message : String(webhookError),
+          originalError: error?.message
+        }
       );
-      this.logger.error(`[STREAM-ERROR] Stack trace: ${error.stack}`);
-      throw error;
     }
   }
   /**
@@ -4959,6 +4988,8 @@ exports.LangGraphEngine = class LangGraphEngine {
         startedAt: payload.startedAt,
         completedAt: payload.completedAt,
         durationMs: payload.durationMs,
+        status: payload.status || "success",
+        error: payload.error,
         events: payload.events.map((event) => ({
           timestamp: event.timestamp ? new Date(event.timestamp).toISOString() : (/* @__PURE__ */ new Date()).toISOString(),
           meta: {
@@ -5355,11 +5386,7 @@ var McpConverter = class _McpConverter {
           let zodProp;
           switch (prop.type) {
             case "string":
-              if (prop.enum && Array.isArray(prop.enum) && prop.enum.length > 0) {
-                zodProp = zod.z.enum(prop.enum);
-              } else {
-                zodProp = zod.z.string();
-              }
+              zodProp = zod.z.string();
               break;
             case "number":
               zodProp = zod.z.number();