@flutchai/flutch-sdk 0.2.1 → 0.2.3

package/dist/index.cjs

@@ -1323,92 +1323,39 @@ 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
+   * Deserialization happens in engine, so just pass through with customization hook
    */
-  createGraphContext(payload) {
-    return {
-      messageId: payload.messageId,
-      threadId: payload.threadId,
-      userId: payload.userId,
-      agentId: payload.agentId,
-      companyId: payload.companyId
-    };
-  }
-  /**
-   * 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.
-   */
-  async prepareConfig(payload) {
-    const context = this.createGraphContext(payload);
-    let message = payload.message;
-    if (payload.message && typeof payload.message === "object" && "lc" in payload.message) {
-      try {
-        const { load } = await import('@langchain/core/load');
-        message = await load(JSON.stringify(payload.message));
-        this.logger.debug({
-          message: "Deserialized BaseMessage using load()",
-          type: message.constructor?.name
-        });
-      } catch (error) {
-        this.logger.warn({
-          message: "Failed to deserialize message",
-          error: error.message
-        });
-      }
-    }
-    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 || {}
-      }
-    };
-    const finalConfig = await this.customizeConfig(baseConfig, payload);
-    return finalConfig;
+  async preparePayload(payload) {
+    const finalPayload = await this.customizeConfig(payload);
+    return finalPayload;
   }
   /**
-   * Hook for customizing config after base preparation
+   * Hook for customizing config before graph execution
    * Override this method in child classes to add/modify config fields
    *
-   * @param config - Base config prepared by SDK
-   * @param payload - Original request payload
-   * @returns Modified config
+   * @param payload - Original request payload with input and config
+   * @returns Modified payload
    *
    * @example
    * ```typescript
-   * protected async customizeConfig(config: any, payload: IGraphRequestPayload): Promise<any> {
-   *   // Add custom fields
-   *   config.configurable.myCustomField = "value";
-   *
-   *   // Modify existing fields
-   *   config.configurable.context.customData = await this.loadCustomData(payload);
-   *
-   *   return config;
+   * protected async customizeConfig(payload: IGraphRequestPayload): Promise<any> {
+   *   // Add custom fields to config
+   *   return {
+   *     ...payload,
+   *     config: {
+   *       ...payload.config,
+   *       configurable: {
+   *         ...payload.config.configurable,
+   *         myCustomField: "value",
+   *       },
+   *     },
+   *   };
    * }
    * ```
    */
-  async customizeConfig(config, payload) {
-    return config;
+  async customizeConfig(payload) {
+    return payload;
   }
   /**
    * Load graph manifest (if using manifest-based approach)
@@ -1564,9 +1511,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 +1551,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 +1570,7 @@ exports.UniversalGraphService = class UniversalGraphService {
       );
       const result = await this.engine.streamGraph(
         graph,
-        config,
+        graphRequest,
         onPartial,
         abortController.signal
       );
@@ -5005,7 +4961,6 @@ exports.EventProcessor = class EventProcessor {
 exports.EventProcessor = __decorateClass([
   common.Injectable()
 ], exports.EventProcessor);
-var DEFAULT_RECURSION_LIMIT = 40;
 process.setMaxListeners(0);
 exports.LangGraphEngine = class LangGraphEngine {
   constructor(eventProcessor, configService) {
@@ -5016,34 +4971,80 @@ 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
    */
-  async invokeGraph(graph, config, signal) {
+  async invokeGraph(graph, preparedPayload, signal) {
+    this.logger.debug("invokeGraph preparedPayload", preparedPayload);
     if (signal) {
-      config.signal = signal;
+      preparedPayload.signal = signal;
+      this.logger.debug("[ENGINE] Signal assigned to preparedPayload.signal");
     }
-    const recursionLimit = config.recursionLimit ?? DEFAULT_RECURSION_LIMIT;
-    const result = await graph.invoke(config.input || {}, {
-      ...config,
-      recursionLimit
+    const input = await this.deserializeInput(preparedPayload.input || {});
+    const result = await graph.invoke(input, {
+      ...preparedPayload.config,
+      signal: preparedPayload.signal
     });
     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,
-        version: "v2",
+        preparedPayload.signal = signal;
+        this.logger.debug("[ENGINE] Signal assigned to preparedPayload.signal");
+      }
+      const input = await this.deserializeInput(preparedPayload.input || {});
+      const eventStream = await graph.streamEvents(input, {
+        ...preparedPayload.config,
+        signal: preparedPayload.signal,
+        // Include abort signal
+        version: "v2"
         // Important for correct operation
-        recursionLimit
-        // Prevent GraphRecursionError (default is 25)
       });
       for await (const event of eventStream) {
         try {
@@ -5061,12 +5062,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 +5280,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 +5301,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,12 +5321,18 @@ 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);
+      return versionedBuilder.preparePayload(updatedPayload);
     }
   }
   Object.defineProperty(VersionRouter, "name", { value: className });
@@ -5555,7 +5566,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"
                   );