@flutchai/flutch-sdk 0.2.17 → 0.2.19

package/dist/index.cjs

@@ -337,11 +337,6 @@ function registerUIEndpointsFromClass(endpointRegistry, EndpointClass, instance)
   if (methodsMetadata.length === 0) {
     return;
   }
-  console.log("DEBUG: registerUIEndpointsFromClass", {
-    hasInstance: !!instance,
-    willCreateNew: !instance,
-    className: EndpointClass.name
-  });
   const endpointInstance = instance || new EndpointClass();
   const descriptors = methodsMetadata.map((meta) => ({
     name: meta.endpointName,
@@ -403,11 +398,6 @@ var init_ui_endpoints_discovery = __esm({
             }
             if (hasUIEndpoints(metatype)) {
               this.logger.debug(`Found UI endpoints class: ${metatype.name}`);
-              console.log("DEBUG: Discovery found instance", {
-                className: metatype.name,
-                hasInstance: !!instance,
-                instanceType: typeof instance
-              });
               registerUIEndpointsFromClass(
                 this.endpointRegistry,
                 metatype,
@@ -1326,10 +1316,37 @@ exports.AbstractGraphBuilder = class AbstractGraphBuilder {
   }
   /**
    * Prepare config for graph execution
-   * Deserialization happens in engine, so just pass through with customization hook
+   * Automatically sets checkpoint_ns and checkpoint_id if not present
    */
   async preparePayload(payload) {
-    const finalPayload = await this.customizeConfig(payload);
+    const checkpoint_ns = payload.config.configurable.checkpoint_ns || this.graphType;
+    const checkpoint_id = payload.config.configurable.checkpoint_id || payload.config.configurable.thread_id;
+    this.logger.debug({
+      message: "[SDK] preparePayload - setting checkpoint config",
+      checkpoint_ns,
+      checkpoint_id,
+      thread_id: payload.config.configurable.thread_id,
+      graphType: this.graphType
+    });
+    const payloadWithCheckpoint = {
+      ...payload,
+      config: {
+        ...payload.config,
+        configurable: {
+          ...payload.config.configurable,
+          checkpoint_ns,
+          checkpoint_id
+        }
+      }
+    };
+    const finalPayload = await this.customizeConfig(payloadWithCheckpoint);
+    this.logger.debug({
+      message: "[SDK] preparePayload - final config",
+      has_checkpoint_ns: !!finalPayload.config.configurable.checkpoint_ns,
+      has_checkpoint_id: !!finalPayload.config.configurable.checkpoint_id,
+      checkpoint_ns: finalPayload.config.configurable.checkpoint_ns,
+      checkpoint_id: finalPayload.config.configurable.checkpoint_id
+    });
     return finalPayload;
   }
   /**
@@ -1403,11 +1420,6 @@ exports.AbstractGraphBuilder = class AbstractGraphBuilder {
       return null;
     }
   }
-  /**
-   * Validate graph manifest
-   */
-  validateManifest(manifest) {
-  }
   /**
    * Get graph metadata (from manifest or decorator)
    */
@@ -1505,9 +1517,7 @@ exports.UniversalGraphService = class UniversalGraphService {
    * Returns graph types supported by the service
    */
   async getSupportedGraphTypes() {
-    return this.builders.map((builder) => {
-      return builder.graphType;
-    });
+    return this.builders.map((builder) => builder.graphType);
   }
   /**
    * Generate answer without streaming
@@ -1784,12 +1794,10 @@ exports.UniversalGraphService = __decorateClass([
 ], exports.UniversalGraphService);
 function setupRedisMock() {
   if (process.env.NODE_ENV === "development" && !process.env.KUBERNETES_SERVICE_HOST) {
-    console.log("[REDIS_MOCK] Intercepting ioredis requires for development");
     const Module2 = __require("module");
     const originalRequire = Module2.prototype.require;
     Module2.prototype.require = function(...args) {
       if (args[0] === "ioredis") {
-        console.log("[REDIS_MOCK] Redirecting ioredis to ioredis-mock");
         return originalRequire.apply(this, ["ioredis-mock"]);
       }
       return originalRequire.apply(this, args);
@@ -5571,17 +5579,16 @@ function createMetaBuilder(config, versionedGraphService, moduleRef) {
       const resolution = await versionedGraphService.resolveVersion(graphType, {
         strict: false
       });
+      let versionedBuilder;
       try {
-        const versionedBuilder = moduleRef.get(resolution.builderClass, {
+        versionedBuilder = moduleRef.get(resolution.builderClass, {
           strict: false
         });
-        return versionedBuilder.buildGraph(payload);
       } catch (error) {
-        const versionedBuilder = await moduleRef.create(
-          resolution.builderClass
-        );
-        return versionedBuilder.buildGraph(payload);
+        versionedBuilder = await moduleRef.create(resolution.builderClass);
       }
+      const preparedPayload = await versionedBuilder.preparePayload(payload);
+      return versionedBuilder.buildGraph(preparedPayload);
     }
     async preparePayload(payload) {
       const graphType = payload.config?.configurable?.graphSettings?.graphType;
@@ -5620,6 +5627,82 @@ function createMetaBuilder(config, versionedGraphService, moduleRef) {
   Object.defineProperty(VersionRouter, "name", { value: className });
   return VersionRouter;
 }
+function buildCheckpointerProviders(options) {
+  const logger2 = new common.Logger("UniversalGraphModule");
+  if (options.postgres !== void 0) {
+    return [
+      {
+        provide: "CHECKPOINTER",
+        useFactory: async () => {
+          const { PostgresSaver } = await import(
+            // Dynamic import keeps the package optional at build time
+            '@langchain/langgraph-checkpoint-postgres'
+          );
+          const connString = options.postgres.connectionString ?? process.env.DATABASE_URL;
+          if (!connString) {
+            throw new Error(
+              "[UniversalGraphModule] Postgres checkpointer: provide postgres.connectionString or set the DATABASE_URL environment variable."
+            );
+          }
+          logger2.log(
+            `Checkpointer: PostgreSQL (${connString.replace(/:[^:@]+@/, ":***@")})`
+          );
+          const saver = PostgresSaver.fromConnString(connString, {
+            ...options.postgres.schema ? { schema: options.postgres.schema } : {}
+          });
+          await saver.setup();
+          return saver;
+        }
+      }
+    ];
+  }
+  if (options.mongodb !== void 0) {
+    return [
+      {
+        provide: "MONGO_CONNECTION",
+        useFactory: async (configService) => {
+          const mongoUri = options.mongodb?.uri || configService.get("MONGODB_URI") || process.env.MONGODB_URI;
+          const dbName = options.mongodb?.dbName || configService.get("MONGO_DB_NAME") || process.env.MONGO_DB_NAME;
+          if (!mongoUri) {
+            throw new Error(
+              "[UniversalGraphModule] MongoDB checkpointer: provide mongodb.uri or set the MONGODB_URI environment variable."
+            );
+          }
+          logger2.log(`Checkpointer: MongoDB (${mongoUri.substring(0, 50)}...)`);
+          await mongoose__default.default.connect(mongoUri, { dbName });
+          return mongoose__default.default.connection;
+        },
+        inject: [config.ConfigService]
+      },
+      {
+        provide: "CHECKPOINTER",
+        useFactory: async (connection, configService) => {
+          const dbName = options.mongodb?.dbName || configService.get("MONGO_DB_NAME") || process.env.MONGO_DB_NAME;
+          const mongoClient = createMongoClientAdapter(connection.getClient());
+          return new langgraphCheckpointMongodb.MongoDBSaver({
+            client: mongoClient,
+            dbName,
+            checkpointCollectionName: options.mongodb?.checkpointCollectionName ?? "checkpoints",
+            checkpointWritesCollectionName: options.mongodb?.checkpointWritesCollectionName ?? "checkpoint_writes"
+          });
+        },
+        inject: ["MONGO_CONNECTION", config.ConfigService]
+      }
+    ];
+  }
+  return [
+    {
+      provide: "CHECKPOINTER",
+      useFactory: async () => {
+        const { MemorySaver } = await import('@langchain/langgraph');
+        logger2.warn(
+          "Checkpointer: MemorySaver (in-process, no persistence). Configure postgres or mongodb in UniversalGraphModule.forRoot() for production."
+        );
+        return new MemorySaver();
+      }
+    }
+  ];
+}
 exports.UniversalGraphModule = class UniversalGraphModule {
   static forRoot(options) {
     const providers = [
@@ -5640,12 +5723,24 @@ exports.UniversalGraphModule = class UniversalGraphModule {
       exports.GraphEngineFactory,
       exports.VersionedGraphService,
       exports.UniversalGraphService,
-      // Callback infrastructure - Redis client (ioredis or ioredis-mock via main.ts interceptor)
+      // Callback infrastructure — Redis or in-memory fallback
       {
         provide: "REDIS_CLIENT",
         useFactory: () => {
-          const Redis = __require("ioredis");
-          return new Redis(process.env.REDIS_URL || "redis://redis:6379");
+          const redisUrl = options.redis?.url ?? process.env.REDIS_URL;
+          if (redisUrl) {
+            const Redis = __require("ioredis");
+            const logger2 = new common.Logger("UniversalGraphModule");
+            logger2.log(
+              `Callbacks: Redis (${redisUrl.replace(/:[^:@]+@/, ":***@")})`
+            );
+            return new Redis(redisUrl);
+          }
+          const IORedisMock = __require("ioredis-mock");
+          new common.Logger("UniversalGraphModule").warn(
+            "Callbacks: in-memory store (single-instance only). Set redis.url or REDIS_URL for production."
+          );
+          return new IORedisMock();
         }
       },
       {
@@ -5739,58 +5834,9 @@ exports.UniversalGraphModule = class UniversalGraphModule {
         },
         inject: [CallbackRegistry]
       },
-      // MongoDB connection (optional - only if mongodb config provided)
-      ...options.mongodb ? [
-        {
-          provide: "MONGO_CONNECTION",
-          useFactory: async (configService) => {
-            const logger2 = new common.Logger("UniversalGraphModule");
-            const mongoUri = options.mongodb?.uri || configService.get("MONGODB_URI") || process.env.MONGODB_URI;
-            const dbName = options.mongodb?.dbName || configService.get("MONGO_DB_NAME") || process.env.MONGO_DB_NAME;
-            if (!mongoUri) {
-              throw new Error(
-                "MONGODB_URI is not defined in options, config, or environment"
-              );
-            }
-            logger2.log(
-              `Connecting to MongoDB: ${mongoUri?.substring(0, 50) + "..."}`
-            );
-            try {
-              await mongoose__default.default.connect(mongoUri, { dbName });
-              logger2.log(
-                `Successfully connected to MongoDB (db: ${dbName})`
-              );
-              return mongoose__default.default.connection;
-            } catch (error) {
-              logger2.error("Failed to connect to MongoDB", error);
-              throw error;
-            }
-          },
-          inject: [config.ConfigService]
-        },
-        // MongoDB checkpointer
-        {
-          provide: "CHECKPOINTER",
-          useFactory: async (connection, configService) => {
-            const logger2 = new common.Logger("UniversalGraphModule");
-            const dbName = options.mongodb?.dbName || configService.get("MONGO_DB_NAME") || process.env.MONGO_DB_NAME;
-            const checkpointCollectionName = options.mongodb?.checkpointCollectionName || "checkpoints";
-            const checkpointWritesCollectionName = options.mongodb?.checkpointWritesCollectionName || "checkpoint_writes";
-            logger2.log(
-              `Creating CHECKPOINTER with collections: ${checkpointCollectionName}, ${checkpointWritesCollectionName}`
-            );
-            const mongooseClient = connection.getClient();
-            const mongoClient = createMongoClientAdapter(mongooseClient);
-            return new langgraphCheckpointMongodb.MongoDBSaver({
-              client: mongoClient,
-              dbName,
-              checkpointCollectionName,
-              checkpointWritesCollectionName
-            });
-          },
-          inject: ["MONGO_CONNECTION", config.ConfigService]
-        }
-      ] : [],
+      // ── Checkpointer ────────────────────────────────────────────────────
+      // Priority: postgres > mongodb > memory (in-process, no persistence)
+      ...buildCheckpointerProviders(options),
       {
         provide: "GRAPH_ENGINE",
         useFactory: (langGraphEngine) => langGraphEngine,
@@ -5815,12 +5861,10 @@ exports.UniversalGraphModule = class UniversalGraphModule {
       {
         provide: "VERSIONING_INITIALIZER",
         useFactory: (builderRegistry, versionedGraphService, configs, moduleRef) => {
-          console.log(
-            "\u{1F527} VERSIONING_INITIALIZER running with configs:",
-            configs?.length || 0
+          const initLogger = new common.Logger("UniversalGraphModule");
+          initLogger.debug(
+            `Initializing versioning for ${configs?.length || 0} graph type(s)`
           );
-          console.log("\u{1F527} ModuleRef available:", !!moduleRef);
-          console.log("\u{1F527} BuilderRegistry available:", !!builderRegistry);
           configs.forEach(
             (config) => versionedGraphService.registerVersioning(config)
           );
@@ -5832,9 +5876,8 @@ exports.UniversalGraphModule = class UniversalGraphModule {
                 moduleRef
               );
               const versionRouter = new VersionRouterClass();
-              console.log(
-                "\u{1F527} Registering VersionRouter for",
-                config.baseGraphType
+              initLogger.debug(
+                `Registered VersionRouter for ${config.baseGraphType}`
               );
               builderRegistry.registerBuilder(versionRouter);
             } else {
@@ -5855,10 +5898,8 @@ exports.UniversalGraphModule = class UniversalGraphModule {
                 }
               }
               const simpleRouter = new SimpleVersionRouter();
-              console.log(
-                "\u{1F527} Registering SimpleRouter for",
-                config.baseGraphType,
-                "(no ModuleRef)"
+              initLogger.warn(
+                `Registered SimpleRouter for ${config.baseGraphType} (no ModuleRef)`
               );
               builderRegistry.registerBuilder(simpleRouter);
             }
@@ -5882,6 +5923,7 @@ exports.UniversalGraphModule = class UniversalGraphModule {
       exports: [
         "GRAPH_SERVICE",
         "GRAPH_ENGINE",
+        "CHECKPOINTER",
         exports.UniversalGraphService,
         exports.BuilderRegistryService,
         exports.VersionedGraphService,
@@ -7131,28 +7173,11 @@ var ModelInitializer = class _ModelInitializer {
       );
     }
     const config = await response.json();
-    console.debug(
-      `ModelInitializer.fetchFromApi - API response for ${modelId}:`,
-      {
-        url,
-        statusCode: response.status,
-        configKeys: Object.keys(config),
-        modelType: config.modelType,
-        hasModelType: !!config.modelType,
-        fullConfig: config
-      }
-    );
     const result = {
       ...config,
       modelType: config.modelType || "chat" /* CHAT */
       // Fallback for compatibility
     };
-    console.debug(`ModelInitializer.fetchFromApi - final result:`, {
-      modelId,
-      resultModelType: result.modelType,
-      usedFallback: !config.modelType,
-      resultKeys: Object.keys(result)
-    });
     return result;
   }
 };