@flutchai/flutch-sdk 0.2.16 → 0.2.18

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,
@@ -6475,7 +6517,10 @@ function normalizeToolConfigs(tools) {
 }
 var DEFAULT_ROUTER_URL = "https://router.flutch.ai";
 function resolveRouterURL(baseURL) {
-  return baseURL ?? process.env.FLUTCH_ROUTER_URL ?? DEFAULT_ROUTER_URL;
+  if (baseURL) return baseURL;
+  if (process.env.FLUTCH_ROUTER_URL) return process.env.FLUTCH_ROUTER_URL;
+  if (process.env.FLUTCH_API_TOKEN) return DEFAULT_ROUTER_URL;
+  return void 0;
 }
 function generateModelCacheKey(modelId, temperature, maxTokens, toolsConfig, baseURL) {
   const parts = [
@@ -6582,12 +6627,15 @@ var ModelInitializer = class _ModelInitializer {
   };
   /**
    * Resolve API key for a provider.
-   * Uses custom resolver if provided, falls back to process.env.
+   * Priority: custom resolver > FLUTCH_API_TOKEN > provider-specific env var.
    */
   resolveApiKey(provider) {
     if (this.apiKeyResolver) {
       return this.apiKeyResolver(provider);
     }
+    if (process.env.FLUTCH_API_TOKEN) {
+      return process.env.FLUTCH_API_TOKEN;
+    }
     const envVar = _ModelInitializer.DEFAULT_ENV_MAP[provider];
     return envVar ? process.env[envVar] : void 0;
   }
@@ -6633,7 +6681,10 @@ var ModelInitializer = class _ModelInitializer {
         defaultMaxTokens,
         apiToken || this.resolveApiKey("openai" /* OPENAI */) || ""
       );
-      config.configuration = { baseURL: `${resolveRouterURL(baseURL)}/v1` };
+      const routerURL = resolveRouterURL(baseURL);
+      if (routerURL) {
+        config.configuration = { baseURL: `${routerURL}/v1` };
+      }
       return new openai.ChatOpenAI(config);
     },
     ["anthropic" /* ANTHROPIC */]: ({
@@ -6647,7 +6698,9 @@ var ModelInitializer = class _ModelInitializer {
       temperature: defaultTemperature,
       maxTokens: defaultMaxTokens,
       anthropicApiKey: apiToken || this.resolveApiKey("anthropic" /* ANTHROPIC */),
-      anthropicApiUrl: resolveRouterURL(baseURL)
+      ...resolveRouterURL(baseURL) && {
+        anthropicApiUrl: resolveRouterURL(baseURL)
+      }
     }),
     ["cohere" /* COHERE */]: ({
       modelName,
@@ -6655,30 +6708,35 @@ var ModelInitializer = class _ModelInitializer {
       defaultMaxTokens,
       apiToken,
       baseURL
-    }) => new cohere.ChatCohere({
-      model: modelName,
-      temperature: defaultTemperature,
-      client: new cohereAi.CohereClient({
-        token: apiToken || this.resolveApiKey("cohere" /* COHERE */),
-        baseUrl: resolveRouterURL(baseURL)
-      })
-    }),
+    }) => {
+      const routerURL = resolveRouterURL(baseURL);
+      const token = apiToken || this.resolveApiKey("cohere" /* COHERE */);
+      return routerURL ? new cohere.ChatCohere({
+        model: modelName,
+        temperature: defaultTemperature,
+        client: new cohereAi.CohereClient({ token, baseUrl: routerURL })
+      }) : new cohere.ChatCohere({
+        model: modelName,
+        temperature: defaultTemperature,
+        apiKey: token
+      });
+    },
     ["mistral" /* MISTRAL */]: ({
       modelName,
       defaultTemperature,
       defaultMaxTokens,
       apiToken,
       baseURL
-    }) => new mistralai.ChatMistralAI({
-      model: modelName,
-      temperature: defaultTemperature,
-      maxTokens: defaultMaxTokens,
-      apiKey: apiToken || this.resolveApiKey("mistral" /* MISTRAL */),
-      // Route through the same gateway as OpenAI/Anthropic.
-      // Without serverURL, ChatMistralAI ignores FLUTCH_ROUTER_URL and calls
-      // api.mistral.ai directly — inconsistent with other providers.
-      serverURL: `${resolveRouterURL(baseURL)}/v1`
-    }),
+    }) => {
+      const routerURL = resolveRouterURL(baseURL);
+      return new mistralai.ChatMistralAI({
+        model: modelName,
+        temperature: defaultTemperature,
+        maxTokens: defaultMaxTokens,
+        apiKey: apiToken || this.resolveApiKey("mistral" /* MISTRAL */),
+        ...routerURL && { serverURL: `${routerURL}/v1` }
+      });
+    },
     ["voyageai" /* VOYAGEAI */]: () => {
       throw new Error("VoyageAI chat models not implemented");
     }
@@ -6691,13 +6749,16 @@ var ModelInitializer = class _ModelInitializer {
       maxDocuments,
       baseURL
     }) => {
-      return new cohere.CohereRerank({
+      const routerURL = resolveRouterURL(baseURL);
+      const token = apiToken || this.resolveApiKey("cohere" /* COHERE */);
+      return routerURL ? new cohere.CohereRerank({
         model: modelName,
         topN: maxDocuments || 20,
-        client: new cohereAi.CohereClient({
-          token: apiToken || this.resolveApiKey("cohere" /* COHERE */),
-          baseUrl: resolveRouterURL(baseURL)
-        })
+        client: new cohereAi.CohereClient({ token, baseUrl: routerURL })
+      }) : new cohere.CohereRerank({
+        model: modelName,
+        topN: maxDocuments || 20,
+        apiKey: token
       });
     },
     ["voyageai" /* VOYAGEAI */]: ({
@@ -6706,11 +6767,12 @@ var ModelInitializer = class _ModelInitializer {
       maxDocuments,
       baseURL
     }) => {
+      const routerURL = resolveRouterURL(baseURL);
       return new VoyageAIRerank({
         apiKey: apiToken || this.resolveApiKey("voyageai" /* VOYAGEAI */),
         model: modelName,
         topN: maxDocuments || 20,
-        baseUrl: resolveRouterURL(baseURL)
+        ...routerURL && { baseUrl: routerURL }
       });
     },
     // Other providers don't support rerank yet
@@ -6721,11 +6783,16 @@ var ModelInitializer = class _ModelInitializer {
   };
   // Embedding model creators
   embeddingModelCreators = {
-    ["openai" /* OPENAI */]: ({ modelName, apiToken, baseURL }) => new openai.OpenAIEmbeddings({
-      model: modelName,
-      apiKey: apiToken || this.resolveApiKey("openai" /* OPENAI */),
-      configuration: { baseURL: `${resolveRouterURL(baseURL)}/v1` }
-    }),
+    ["openai" /* OPENAI */]: ({ modelName, apiToken, baseURL }) => {
+      const routerURL = resolveRouterURL(baseURL);
+      return new openai.OpenAIEmbeddings({
+        model: modelName,
+        apiKey: apiToken || this.resolveApiKey("openai" /* OPENAI */),
+        ...routerURL && {
+          configuration: { baseURL: `${routerURL}/v1` }
+        }
+      });
+    },
     // Other providers not yet implemented for embeddings
     ["anthropic" /* ANTHROPIC */]: void 0,
     ["cohere" /* COHERE */]: void 0,
@@ -7106,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;
   }
 };