@flutchai/flutch-sdk 0.2.1 → 0.2.2

package/dist/index.cjs

@@ -1323,34 +1323,25 @@ exports.AbstractGraphBuilder = class AbstractGraphBuilder {
     }
   }
   /**
-   * Creates execution context for graph with tracer and usageRecorder
-   * This method can be overridden in child classes for customization
+   * Prepare config for graph execution
+   * Config comes ready from backend, just add input
    */
-  createGraphContext(payload) {
-    return {
-      messageId: payload.messageId,
-      threadId: payload.threadId,
-      userId: payload.userId,
-      agentId: payload.agentId,
-      companyId: payload.companyId
-    };
+  async preparePayload(payload) {
+    const config = await this.prepareConfig(payload);
+    return config;
   }
   /**
-   * Basic configuration preparation for graph execution
-   * Automatically creates context with tracer and usageRecorder
-   * Handles message deserialization and LangGraph-compatible structure
-   * FINAL method - cannot be overridden. Use customizeConfig() hook instead.
+   * Internal method to prepare config with input deserialization
    */
   async prepareConfig(payload) {
-    const context = this.createGraphContext(payload);
-    let message = payload.message;
-    if (payload.message && typeof payload.message === "object" && "lc" in payload.message) {
+    let input = payload.input;
+    if (payload.input && typeof payload.input === "object" && "lc" in payload.input) {
       try {
         const { load } = await import('@langchain/core/load');
-        message = await load(JSON.stringify(payload.message));
+        input = await load(JSON.stringify(payload.input));
         this.logger.debug({
           message: "Deserialized BaseMessage using load()",
-          type: message.constructor?.name
+          type: input.constructor?.name
         });
       } catch (error) {
         this.logger.warn({
@@ -1360,28 +1351,8 @@ exports.AbstractGraphBuilder = class AbstractGraphBuilder {
       }
     }
     const baseConfig = {
-      // Input for LangGraph (messages array)
-      input: message ? {
-        messages: [message]
-      } : void 0,
-      // Configurable settings for LangGraph checkpointing and context
-      configurable: {
-        thread_id: payload.threadId,
-        checkpoint_ns: this.graphType,
-        checkpoint_id: `${payload.threadId}-${Date.now()}`,
-        context,
-        // Add metadata for compatibility
-        metadata: {
-          userId: payload.userId,
-          agentId: payload.agentId,
-          requestId: payload.requestId,
-          graphType: this.graphType,
-          version: this.version,
-          workflowType: this.graphType
-        },
-        // Graph-specific settings from payload
-        graphSettings: payload.graphSettings || {}
-      }
+      ...payload.config,
+      input
     };
     const finalConfig = await this.customizeConfig(baseConfig, payload);
     return finalConfig;
@@ -1564,9 +1535,15 @@ exports.UniversalGraphService = class UniversalGraphService {
    * Generate answer without streaming
    */
   async generateAnswer(payload) {
-    const builder = this.getBuilderForType(payload.graphType);
+    const graphType = payload.config?.configurable?.graphSettings?.graphType;
+    if (!graphType) {
+      throw new Error(
+        "GraphType is required in payload.config.configurable.graphSettings"
+      );
+    }
+    const builder = this.getBuilderForType(graphType);
     const graph = await builder.buildGraph(payload);
-    const config = await builder.prepareConfig(payload);
+    const config = await builder.preparePayload(payload);
     const abortController = new AbortController();
     this.registerActiveGeneration(payload.requestId, () => {
       abortController.abort();
@@ -1598,13 +1575,16 @@ exports.UniversalGraphService = class UniversalGraphService {
     );
     const abortController = new AbortController();
     try {
-      const builder = this.getBuilderForType(payload.graphType);
-      this.logger.debug(`Got builder for graph type: ${payload.graphType}`);
+      const graphType = payload.config?.configurable?.graphSettings?.graphType;
+      if (!graphType) {
+        throw new Error(
+          "GraphType is required in payload.config.configurable.graphSettings"
+        );
+      }
+      const builder = this.getBuilderForType(graphType);
+      this.logger.debug(`Got builder for graph type: ${graphType}`);
       const graph = await builder.buildGraph(payload);
-      this.logger.debug(`Graph built for requestId: ${payload.requestId}`);
-      this.logger.debug(`Preparing config for requestId: ${payload.requestId}`);
-      const config = await builder.prepareConfig(payload);
-      this.logger.debug(`Config prepared`);
+      const graphRequest = await builder.preparePayload(payload);
       this.registerActiveGeneration(payload.requestId, () => {
         abortController.abort();
       });
@@ -1614,7 +1594,7 @@ exports.UniversalGraphService = class UniversalGraphService {
       );
       const result = await this.engine.streamGraph(
         graph,
-        config,
+        graphRequest,
         onPartial,
         abortController.signal
       );
@@ -5016,6 +4996,43 @@ exports.LangGraphEngine = class LangGraphEngine {
     }
   }
   logger = new common.Logger(exports.LangGraphEngine.name);
+  /**
+   * Deserialize input recursively
+   * Handles serialized LangChain objects at any level of nesting
+   */
+  async deserializeInput(input) {
+    const { load } = await import('@langchain/core/load');
+    const deserializeValue = async (value) => {
+      if (value && typeof value === "object" && "lc" in value) {
+        try {
+          const deserialized = await load(JSON.stringify(value));
+          this.logger.debug({
+            message: "Deserialized LangChain object",
+            type: deserialized.constructor?.name
+          });
+          return deserialized;
+        } catch (error) {
+          this.logger.warn({
+            message: "Failed to deserialize LangChain object",
+            error: error.message
+          });
+          return value;
+        }
+      }
+      if (Array.isArray(value)) {
+        return await Promise.all(value.map((item) => deserializeValue(item)));
+      }
+      if (value && typeof value === "object" && value.constructor === Object) {
+        const result = {};
+        for (const [key, val] of Object.entries(value)) {
+          result[key] = await deserializeValue(val);
+        }
+        return result;
+      }
+      return value;
+    };
+    return await deserializeValue(input);
+  }
   /**
    * Method to invoke LangGraph
    */
@@ -5023,23 +5040,41 @@ exports.LangGraphEngine = class LangGraphEngine {
     if (signal) {
       config.signal = signal;
     }
+    const input = await this.deserializeInput(config.input || {});
     const recursionLimit = config.recursionLimit ?? DEFAULT_RECURSION_LIMIT;
-    const result = await graph.invoke(config.input || {}, {
+    const result = await graph.invoke(input, {
       ...config,
       recursionLimit
     });
     return this.processGraphResult(result);
   }
-  async streamGraph(graph, config, onPartial, signal) {
+  async streamGraph(graph, preparedPayload, onPartial, signal) {
     const acc = this.eventProcessor.createAccumulator();
     let streamError = null;
+    this.logger.debug({
+      message: "[ENGINE] streamGraph called",
+      hasSignal: !!signal,
+      signalType: signal?.constructor?.name,
+      hasAborted: signal?.aborted
+    });
     try {
       if (signal) {
-        config.signal = signal;
-      }
-      const recursionLimit = config.recursionLimit ?? DEFAULT_RECURSION_LIMIT;
-      const eventStream = await graph.streamEvents(config.input || {}, {
-        ...config,
+        preparedPayload.signal = signal;
+        this.logger.debug("[ENGINE] Signal assigned to preparedPayload.signal");
+      }
+      const input = await this.deserializeInput(preparedPayload.input || {});
+      const recursionLimit = preparedPayload.recursionLimit ?? DEFAULT_RECURSION_LIMIT;
+      this.logger.debug({
+        message: "[ENGINE] Calling streamEvents",
+        hasSignalInPayload: !!preparedPayload.signal,
+        signalAborted: preparedPayload.signal?.aborted,
+        configKeys: Object.keys(preparedPayload.config || {}),
+        hasSignalInConfig: !!preparedPayload.config?.signal
+      });
+      const eventStream = await graph.streamEvents(input, {
+        ...preparedPayload.config,
+        signal: preparedPayload.signal,
+        // Include abort signal
         version: "v2",
         // Important for correct operation
         recursionLimit
@@ -5061,12 +5096,12 @@ exports.LangGraphEngine = class LangGraphEngine {
       );
       this.logger.error(`[STREAM-ERROR] Stack trace: ${streamError.stack}`);
     } finally {
-      await this.sendTraceFromAccumulator(acc, config, streamError);
+      await this.sendTraceFromAccumulator(acc, preparedPayload, streamError);
     }
     const { content, trace } = this.eventProcessor.getResult(acc);
     this.logger.debug("[STREAM-RESULT] Got result from EventProcessor", {
       hasContent: !!content,
-      hasContext: !!config.configurable?.context,
+      hasContext: !!preparedPayload.configurable?.context,
       hasTrace: !!trace,
       traceEvents: trace?.events?.length || 0,
       hadError: !!streamError
@@ -5279,9 +5314,11 @@ function createMetaBuilder(config, versionedGraphService, moduleRef) {
       return config.baseGraphType;
     }
     async buildGraph(payload) {
-      const graphType = payload.graphSettings?.graphType;
+      const graphType = payload.config?.configurable?.graphSettings?.graphType;
       if (!graphType) {
-        throw new Error("GraphType is required in payload.graphSettings");
+        throw new Error(
+          "GraphType is required in payload.config.configurable.graphSettings"
+        );
       }
       const resolution = await versionedGraphService.resolveVersion(graphType, {
         strict: false
@@ -5298,10 +5335,12 @@ function createMetaBuilder(config, versionedGraphService, moduleRef) {
         return versionedBuilder.buildGraph(payload);
       }
     }
-    async prepareConfig(payload) {
-      const graphType = payload.graphSettings?.graphType;
+    async preparePayload(payload) {
+      const graphType = payload.config?.configurable?.graphSettings?.graphType;
       if (!graphType) {
-        throw new Error("GraphType is required in payload.graphSettings");
+        throw new Error(
+          "GraphType is required in payload.config.configurable.graphSettings"
+        );
       }
       const resolution = await versionedGraphService.resolveVersion(graphType, {
         strict: false
@@ -5316,9 +5355,15 @@ function createMetaBuilder(config, versionedGraphService, moduleRef) {
       }
       const updatedPayload = {
         ...payload,
-        graphSettings: {
-          ...payload.graphSettings,
-          graphType: resolution.fullGraphType
+        config: {
+          ...payload.config,
+          configurable: {
+            ...payload.config.configurable,
+            graphSettings: {
+              ...payload.config.configurable.graphSettings,
+              graphType: resolution.fullGraphType
+            }
+          }
         }
       };
       return versionedBuilder.prepareConfig(updatedPayload);
@@ -5555,7 +5600,7 @@ exports.UniversalGraphModule = class UniversalGraphModule {
                     "ModuleRef not available - cannot build graph"
                   );
                 }
-                async prepareConfig(payload) {
+                async preparePayload(payload) {
                   throw new Error(
                     "ModuleRef not available - cannot prepare config"
                   );