@flutchai/flutch-sdk 0.1.25 → 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);
 
@@ -3193,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: {
@@ -3207,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)
@@ -3923,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";
@@ -4363,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) {
@@ -4671,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);
@@ -4795,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({
@@ -5157,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();
@@ -5344,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,
@@ -7246,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;