@flutchai/flutch-sdk 0.1.24 → 0.1.26

package/dist/index.cjs

@@ -11,7 +11,11 @@ var promClient = require('prom-client');
 var core = require('@nestjs/core');
 var net = require('net');
 var config = require('@nestjs/config');
+var mongoose = require('mongoose');
+var langgraphCheckpointMongodb = require('@langchain/langgraph-checkpoint-mongodb');
 var LangGraph = require('@langchain/langgraph');
+var messages = require('@langchain/core/messages');
+var dispatch = require('@langchain/core/callbacks/dispatch');
 var tools = require('@langchain/core/tools');
 var zod = require('zod');
 var axios2 = require('axios');
@@ -48,6 +52,7 @@ var fs__namespace = /*#__PURE__*/_interopNamespace(fs);
 var path2__namespace = /*#__PURE__*/_interopNamespace(path2);
 var os__namespace = /*#__PURE__*/_interopNamespace(os);
 var net__namespace = /*#__PURE__*/_interopNamespace(net);
+var mongoose__default = /*#__PURE__*/_interopDefault(mongoose);
 var LangGraph__namespace = /*#__PURE__*/_interopNamespace(LangGraph);
 var axios2__default = /*#__PURE__*/_interopDefault(axios2);
 
@@ -1245,28 +1250,54 @@ var init_versioned_graph_service = __esm({
     ], exports.VersionedGraphService);
   }
 });
+function generateCallbackToken(graphType) {
+  return `cb::${graphType}::${crypto.randomBytes(8).toString("base64url")}`;
+}
+function createCallbackRecord(entry, token, now) {
+  return {
+    ...entry,
+    token,
+    status: "pending",
+    createdAt: now,
+    retries: 0
+  };
+}
+function resolveCallbackTTL(entry) {
+  return entry.metadata?.ttlSec ?? 600;
+}
+function parseCallbackRecord(data) {
+  try {
+    return JSON.parse(data);
+  } catch {
+    return null;
+  }
+}
+function markAsFailed(record, error) {
+  return {
+    ...record,
+    status: "failed",
+    retries: (record.retries || 0) + 1,
+    lastError: error
+  };
+}
+function markAsPending(record) {
+  return { ...record, status: "pending" };
+}
+
+// src/callbacks/callback-store.ts
 var CallbackStore = class {
   constructor(redis) {
     this.redis = redis;
     this.isProduction = process.env.NODE_ENV === "production";
   }
   isProduction;
-  generateToken(graphType) {
-    return `cb::${graphType}::${crypto.randomBytes(8).toString("base64url")}`;
-  }
   /**
    * Issues a new callback token and persists its payload.
    */
   async issue(entry) {
-    const token = this.generateToken(entry.graphType);
-    const record = {
-      ...entry,
-      token,
-      status: "pending",
-      createdAt: Date.now(),
-      retries: 0
-    };
-    const ttl = entry.metadata?.ttlSec ?? 600;
+    const token = generateCallbackToken(entry.graphType);
+    const record = createCallbackRecord(entry, token, Date.now());
+    const ttl = resolveCallbackTTL(entry);
     await this.redis.setex(`callback:${token}`, ttl, JSON.stringify(record));
     return token;
   }
@@ -1281,7 +1312,9 @@ var CallbackStore = class {
     }
   }
   /**
-   * Production version with Lua script for atomicity
+   * Production version: uses Redis Lua scripting for atomic get-and-lock.
+   * NOTE: redis.eval() here executes a Lua script on the Redis server,
+   * NOT JavaScript eval(). This is the standard ioredis API for Lua scripting.
    */
   async getAndLockAtomic(token) {
     const script = `
@@ -1305,18 +1338,17 @@ var CallbackStore = class {
     if (!data) {
       return null;
     }
-    try {
-      const record = JSON.parse(data);
-      if (record.status !== "pending") {
-        return null;
-      }
-      record.status = "processing";
-      await this.redis.set(key, JSON.stringify(record));
-      return record;
-    } catch (error) {
-      console.error("Failed to parse callback record:", error);
+    const record = parseCallbackRecord(data);
+    if (!record) {
+      console.error("Failed to parse callback record");
+      return null;
+    }
+    if (record.status !== "pending") {
       return null;
     }
+    record.status = "processing";
+    await this.redis.set(key, JSON.stringify(record));
+    return record;
   }
   /**
    * Finalizes callback processing by removing token.
@@ -1335,7 +1367,8 @@ var CallbackStore = class {
     }
   }
   /**
-   * Production version with Lua script for atomicity
+   * Production version: uses Redis Lua scripting for atomic fail.
+   * NOTE: redis.eval() here executes a Lua script on the Redis server.
    */
   async failAtomic(token, error) {
     const script = `
@@ -1360,17 +1393,14 @@ var CallbackStore = class {
     if (!data) {
       return null;
     }
-    try {
-      const record = JSON.parse(data);
-      record.status = "failed";
-      record.retries = (record.retries || 0) + 1;
-      record.lastError = error;
-      await this.redis.set(key, JSON.stringify(record));
-      return record;
-    } catch (parseError) {
-      console.error("Failed to parse callback record:", parseError);
+    const record = parseCallbackRecord(data);
+    if (!record) {
+      console.error("Failed to parse callback record");
       return null;
     }
+    const updated = markAsFailed(record, error);
+    await this.redis.set(key, JSON.stringify(updated));
+    return updated;
   }
   /**
    * Reset callback status to pending for retry.
@@ -1383,7 +1413,8 @@ var CallbackStore = class {
     }
   }
   /**
-   * Production version with Lua script for atomicity
+   * Production version: uses Redis Lua scripting for atomic retry.
+   * NOTE: redis.eval() here executes a Lua script on the Redis server.
    */
   async retryAtomic(token) {
     const script = `
@@ -1406,15 +1437,14 @@ var CallbackStore = class {
     if (!data) {
       return null;
     }
-    try {
-      const record = JSON.parse(data);
-      record.status = "pending";
-      await this.redis.set(key, JSON.stringify(record));
-      return record;
-    } catch (parseError) {
-      console.error("Failed to parse callback record:", parseError);
+    const record = parseCallbackRecord(data);
+    if (!record) {
+      console.error("Failed to parse callback record");
       return null;
     }
+    const updated = markAsPending(record);
+    await this.redis.set(key, JSON.stringify(updated));
+    return updated;
   }
 };
 
@@ -3066,6 +3096,38 @@ exports.CallbackController = __decorateClass([
 
 // src/graph/abstract-graph.builder.ts
 init_agent_ui();
+
+// src/graph/graph.logic.ts
+function isValidSemver(version) {
+  return /^\d+\.\d+\.\d+$/.test(version);
+}
+function parseCallbackToken(token) {
+  const parts = token.split("_");
+  if (parts.length < 4 || parts[0] !== "cb") {
+    return null;
+  }
+  const graphName = parts[1];
+  const handler = parts[2];
+  const graphType = `${graphName}::1.0.0`;
+  return { graphType, handler };
+}
+function decodeCallbackParams(token) {
+  const parts = token.split("_");
+  if (parts.length < 4) {
+    return {};
+  }
+  try {
+    const encodedParams = parts.slice(3).join("_");
+    const decodedParams = Buffer.from(encodedParams, "base64url").toString(
+      "utf8"
+    );
+    return JSON.parse(decodedParams);
+  } catch {
+    return {};
+  }
+}
+
+// src/graph/abstract-graph.builder.ts
 var _AbstractGraphBuilder = class _AbstractGraphBuilder {
   logger = new common.Logger(_AbstractGraphBuilder.name);
   callbackRegistry;
@@ -3136,13 +3198,37 @@ var _AbstractGraphBuilder = class _AbstractGraphBuilder {
   /**
    * Basic configuration preparation for graph execution
    * Automatically creates context with tracer and usageRecorder
-   * Can be overridden in child classes to add specific logic
+   * Handles message deserialization and LangGraph-compatible structure
+   * FINAL method - cannot be overridden. Use customizeConfig() hook instead.
    */
   async prepareConfig(payload) {
     const context = this.createGraphContext(payload);
-    return {
+    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: {
@@ -3150,10 +3236,39 @@ var _AbstractGraphBuilder = class _AbstractGraphBuilder {
           agentId: payload.agentId,
           requestId: payload.requestId,
           graphType: this.graphType,
-          version: this.version
-        }
+          version: this.version,
+          workflowType: this.graphType
+        },
+        // Graph-specific settings from payload
+        graphSettings: payload.graphSettings || {}
       }
     };
+    const finalConfig = await this.customizeConfig(baseConfig, payload);
+    return finalConfig;
+  }
+  /**
+   * Hook for customizing config after base preparation
+   * 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
+   *
+   * @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;
+   * }
+   * ```
+   */
+  async customizeConfig(config, payload) {
+    return config;
   }
   /**
    * Load graph manifest (if using manifest-based approach)
@@ -3274,8 +3389,7 @@ var _AbstractGraphBuilder = class _AbstractGraphBuilder {
    * Version validation
    */
   validateVersion() {
-    const versionRegex = /^\d+\.\d+\.\d+$/;
-    if (!versionRegex.test(this.version)) {
+    if (!isValidSemver(this.version)) {
       throw new Error(
         `Invalid version format: ${this.version}. Expected format: X.Y.Z`
       );
@@ -3625,36 +3739,21 @@ exports.UniversalGraphService = class UniversalGraphService {
    * Expected format: cb_{graphName}_{handler}_{encodedParams}
    */
   parseCallbackToken(token) {
-    const parts = token.split("_");
-    if (parts.length < 4 || parts[0] !== "cb") {
+    const result = parseCallbackToken(token);
+    if (!result) {
       throw new Error(`Invalid callback token format: ${token}`);
     }
-    const graphName = parts[1];
-    const handler = parts[2];
-    const graphType = `${graphName}::1.0.0`;
-    return { graphType, handler };
+    return result;
   }
   /**
    * Extract parameters from callback token
    */
   parseCallbackParams(token) {
-    const parts = token.split("_");
-    if (parts.length < 4) {
-      return {};
-    }
-    try {
-      const encodedParams = parts.slice(3).join("_");
-      const decodedParams = Buffer.from(encodedParams, "base64url").toString(
-        "utf8"
-      );
-      return JSON.parse(decodedParams);
-    } catch (error) {
-      this.logger.warn(
-        `Failed to parse callback params from token: ${token}`,
-        error
-      );
-      return {};
+    const result = decodeCallbackParams(token);
+    if (Object.keys(result).length === 0 && token.split("_").length >= 4) {
+      this.logger.warn(`Failed to parse callback params from token: ${token}`);
     }
+    return result;
   }
   /**
    * Call a graph endpoint
@@ -3882,6 +3981,24 @@ async function bootstrap(AppModule, options = {}) {
 // src/core/index.ts
 init_builder_registry_service();
 
+// src/core/mongodb/mongodb-client.adapter.ts
+function createMongoClientAdapter(mongooseClient) {
+  if (!mongooseClient || typeof mongooseClient.db !== "function") {
+    throw new Error(
+      "Invalid MongoDB client: missing required methods. Expected MongoClient from mongoose.Connection.getClient()"
+    );
+  }
+  const requiredMethods = ["db", "close", "connect"];
+  for (const method of requiredMethods) {
+    if (typeof mongooseClient[method] !== "function") {
+      throw new Error(
+        `Invalid MongoDB client: missing required method '${method}'`
+      );
+    }
+  }
+  return mongooseClient;
+}
+
 // src/messages/attachments.ts
 var AttachmentType = /* @__PURE__ */ ((AttachmentType2) => {
   AttachmentType2["IMAGE"] = "image";
@@ -4322,8 +4439,8 @@ function getLangGraphDispatch() {
   if (cachedDispatch !== void 0) {
     return cachedDispatch;
   }
-  const { dispatchCustomEvent } = LangGraph__namespace;
-  cachedDispatch = typeof dispatchCustomEvent === "function" ? dispatchCustomEvent : null;
+  const { dispatchCustomEvent: dispatchCustomEvent2 } = LangGraph__namespace;
+  cachedDispatch = typeof dispatchCustomEvent2 === "function" ? dispatchCustomEvent2 : null;
   return cachedDispatch;
 }
 function sanitizeTraceData(value, depth = 0, seen = /* @__PURE__ */ new WeakSet(), options) {
@@ -4630,6 +4747,14 @@ exports.EventProcessor = class EventProcessor {
    */
   processEvent(acc, event, onPartial) {
     this.captureTraceEvent(acc, event);
+    if (event.event === "on_custom_event" && event.data) {
+      const channel = event.metadata?.stream_channel ?? "text" /* TEXT */;
+      if (event.name === "send_static_message" && event.data.content) {
+        const blocks = this.normalizeContentBlocks(event.data.content);
+        this.processContentStream(acc, channel, blocks, onPartial);
+      }
+      return;
+    }
     if (event.event === "on_chat_model_stream" && event.data?.chunk?.content) {
       const channel = event.metadata?.stream_channel ?? "text" /* TEXT */;
       const blocks = this.normalizeContentBlocks(event.data.chunk.content);
@@ -4754,6 +4879,7 @@ exports.EventProcessor = class EventProcessor {
       }
       if (state.currentBlock) {
         state.contentChain.push(state.currentBlock);
+        state.currentBlock = null;
       }
       if (state.contentChain.length > 0) {
         allChains.push({
@@ -5116,6 +5242,13 @@ exports.LangGraphEngine = __decorateClass([
   common.Injectable(),
   __decorateParam(1, common.Optional())
 ], exports.LangGraphEngine);
+async function createStaticMessage(content, config) {
+  const message = new messages.AIMessage({
+    content
+  });
+  await dispatch.dispatchCustomEvent("send_static_message", { content }, config);
+  return message;
+}
 
 // src/core/universal-graph.module.ts
 init_builder_registry_service();
@@ -5303,6 +5436,58 @@ 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]
+        }
+      ] : [],
       {
         provide: "GRAPH_ENGINE",
         useFactory: (langGraphEngine) => langGraphEngine,
@@ -5984,6 +6169,24 @@ var ChatFeature = /* @__PURE__ */ ((ChatFeature2) => {
   ChatFeature2["JSON_MODE"] = "json_mode";
   return ChatFeature2;
 })(ChatFeature || {});
+function isReasoningModel(modelName) {
+  return modelName.includes("gpt-5") || modelName.includes("gpt-o1") || modelName.includes("gpt-o2") || modelName.includes("gpt-o3") || modelName.includes("gpt-o4") || /^gpt-(5|6|7|8|9)/.test(modelName) || /^gpt-o[1-4]/.test(modelName);
+}
+function hashToolsConfig(toolsConfig) {
+  const sorted = toolsConfig.map((t) => `${t.toolName}:${t.enabled}:${JSON.stringify(t.config || {})}`).sort().join("|");
+  return crypto.createHash("md5").update(sorted).digest("hex").slice(0, 16);
+}
+function generateModelCacheKey(modelId, temperature, maxTokens, toolsConfig) {
+  const parts = [
+    modelId,
+    temperature ?? "default",
+    maxTokens ?? "default"
+  ];
+  if (toolsConfig && toolsConfig.length > 0) {
+    parts.push(hashToolsConfig(toolsConfig));
+  }
+  return parts.join(":");
+}
 var VoyageAIRerank = class extends document_compressors.BaseDocumentCompressor {
   apiKey;
   model;
@@ -6279,8 +6482,7 @@ var ModelInitializer = class _ModelInitializer {
    * Uses MD5 hash to create short, unique identifier
    */
   hashToolsConfig(toolsConfig) {
-    const sorted = toolsConfig.map((t) => `${t.toolName}:${t.enabled}:${JSON.stringify(t.config || {})}`).sort().join("|");
-    return crypto.createHash("md5").update(sorted).digest("hex").slice(0, 16);
+    return hashToolsConfig(toolsConfig);
   }
   /**
    * Generate cache key from ModelByIdConfig
@@ -6288,16 +6490,12 @@ var ModelInitializer = class _ModelInitializer {
    * Example: "model123:0.7:4096" or "model123:0.7:4096:a1b2c3d4e5f6g7h8"
    */
   generateModelCacheKey(config) {
-    const parts = [
+    return generateModelCacheKey(
       config.modelId,
-      config.temperature ?? "default",
-      config.maxTokens ?? "default"
-    ];
-    if (config.toolsConfig && config.toolsConfig.length > 0) {
-      const toolsHash = this.hashToolsConfig(config.toolsConfig);
-      parts.push(toolsHash);
-    }
-    return parts.join(":");
+      config.temperature,
+      config.maxTokens,
+      config.toolsConfig
+    );
   }
   /**
    * TEMPORARY SOLUTION for compatibility with new OpenAI models
@@ -6314,20 +6512,10 @@ var ModelInitializer = class _ModelInitializer {
    * @returns true if model requires maxCompletionTokens and temperature = 1
    */
   requiresMaxCompletionTokens(modelName) {
-    const requiresNew = modelName.includes("gpt-5") || modelName.includes("gpt-o1") || modelName.includes("gpt-o2") || modelName.includes("gpt-o3") || modelName.includes("gpt-o4") || // Add other patterns as new models are released
-    /^gpt-(5|6|7|8|9)/.test(modelName) || /^gpt-o[1-4]/.test(modelName);
+    const requiresNew = isReasoningModel(modelName);
     this.logger.debug(`Checking token parameter for model "${modelName}"`, {
       modelName,
-      requiresMaxCompletionTokens: requiresNew,
-      checks: {
-        includesGpt5: modelName.includes("gpt-5"),
-        includesO1: modelName.includes("gpt-o1"),
-        includesO2: modelName.includes("gpt-o2"),
-        includesO3: modelName.includes("gpt-o3"),
-        includesO4: modelName.includes("gpt-o4"),
-        regexGpt5Plus: /^gpt-(5|6|7|8|9)/.test(modelName),
-        regexO1to4: /^gpt-o[1-4]/.test(modelName)
-      }
+      requiresMaxCompletionTokens: requiresNew
     });
     return requiresNew;
   }
@@ -7202,6 +7390,8 @@ exports.WithEndpoints = WithEndpoints;
 exports.WithUIEndpoints = WithUIEndpoints;
 exports.bootstrap = bootstrap;
 exports.createEndpointDescriptors = createEndpointDescriptors;
+exports.createMongoClientAdapter = createMongoClientAdapter;
+exports.createStaticMessage = createStaticMessage;
 exports.findCallbackMethod = findCallbackMethod;
 exports.findEndpointMethod = findEndpointMethod;
 exports.getCallbackMetadata = getCallbackMetadata;