@flutchai/flutch-sdk 0.2.20 → 0.3.0

package/dist/index.cjs

@@ -15,6 +15,7 @@ var crypto = require('crypto');
 var promClient = require('prom-client');
 var messages = require('@langchain/core/messages');
 var LangGraph = require('@langchain/langgraph');
+var async_hooks = require('async_hooks');
 var dispatch = require('@langchain/core/callbacks/dispatch');
 var tools = require('@langchain/core/tools');
 var zod = require('zod');
@@ -23,6 +24,7 @@ var zodToJsonSchema = require('zod-to-json-schema');
 var manager = require('@langchain/core/callbacks/manager');
 var openai = require('@langchain/openai');
 var aws = require('@langchain/aws');
+var core$1 = require('cohere-ai/core');
 var anthropic = require('@langchain/anthropic');
 var cohere = require('@langchain/cohere');
 var cohereAi = require('cohere-ai');
@@ -4817,6 +4819,36 @@ exports.EventProcessor = class EventProcessor {
     }
     return [];
   }
+  /**
+   * Convert LangChain unified `tool_call_chunks` (Bedrock / OpenAI streaming
+   * format) into Anthropic-style blocks so the rest of the pipeline can stay
+   * uniform. The first chunk for a tool carries `name` (and usually `id`);
+   * subsequent chunks carry partial `args` strings that need to accumulate.
+   *
+   * NOTE: assumes tool calls arrive sequentially. Parallel tool calls with
+   * interleaved `args` chunks across different `index`es will misroute args
+   * to the most recently opened tool_use block.
+   */
+  toolCallChunksToBlocks(toolCallChunks) {
+    const blocks = [];
+    for (const tcc of toolCallChunks) {
+      if (tcc.name) {
+        blocks.push({
+          type: "tool_use",
+          id: tcc.id,
+          name: tcc.name,
+          input: ""
+        });
+      }
+      if (typeof tcc.args === "string" && tcc.args.length > 0) {
+        blocks.push({
+          type: "input_json_delta",
+          input: tcc.args
+        });
+      }
+    }
+    return blocks;
+  }
   /**
    * Extract attachments from various input formats
    * Handles both array format (IAttachment[]) and object format (Record<string, IGraphAttachment>)
@@ -4980,10 +5012,19 @@ exports.EventProcessor = class EventProcessor {
       }
       return;
     }
-    if (event.event === "on_chat_model_stream" && event.data?.chunk?.content) {
+    if (event.event === "on_chat_model_stream" && event.data?.chunk) {
       const channel = event.metadata?.stream_channel ?? "text" /* TEXT */;
-      const blocks = this.normalizeContentBlocks(event.data.chunk.content);
-      this.processContentStream(acc, channel, blocks, onPartial);
+      const chunk = event.data.chunk;
+      const blocks = [];
+      if (chunk.content) {
+        blocks.push(...this.normalizeContentBlocks(chunk.content));
+      }
+      if (Array.isArray(chunk.tool_call_chunks) && chunk.tool_call_chunks.length > 0) {
+        blocks.push(...this.toolCallChunksToBlocks(chunk.tool_call_chunks));
+      }
+      if (blocks.length > 0) {
+        this.processContentStream(acc, channel, blocks, onPartial);
+      }
       return;
     }
     if (event.event === "on_tool_start") {
@@ -4996,6 +5037,44 @@ exports.EventProcessor = class EventProcessor {
         if (idx !== -1) {
           const block = state.pendingToolBlocks.splice(idx, 1)[0];
           state.toolBlocksByRunId.set(event.run_id, block);
+        } else {
+          const toolInput = event.data?.input;
+          let inputString;
+          try {
+            inputString = typeof toolInput === "string" ? toolInput : JSON.stringify(toolInput ?? {});
+          } catch {
+            inputString = "";
+          }
+          const synthesizedBlock = {
+            index: state.contentChain.length + (state.currentBlock ? 1 : 0),
+            type: "tool_use",
+            name: event.name,
+            id: event.run_id,
+            input: inputString,
+            output: ""
+          };
+          if (state.currentBlock) {
+            state.contentChain.push(state.currentBlock);
+            state.currentBlock = null;
+          }
+          state.contentChain.push(synthesizedBlock);
+          state.toolBlocksByRunId.set(event.run_id, synthesizedBlock);
+          this.sendDelta(
+            channel,
+            { type: "step_started", step: synthesizedBlock },
+            onPartial
+          );
+          if (inputString.length > 0) {
+            this.sendDelta(
+              channel,
+              {
+                type: "tool_input_chunk",
+                stepId: synthesizedBlock.id,
+                chunk: inputString
+              },
+              onPartial
+            );
+          }
         }
       }
       this.logger.log("\u{1F527} Tool execution started", {
@@ -5225,6 +5304,71 @@ exports.EventProcessor = class EventProcessor {
 exports.EventProcessor = __decorateClass([
   common.Injectable()
 ], exports.EventProcessor);
+var als = new async_hooks.AsyncLocalStorage();
+function withFlutchContext(ctx, fn) {
+  return als.run(ctx, fn);
+}
+function getFlutchContext() {
+  return als.getStore();
+}
+var HEADER_MAP = {
+  messageId: "x-flutch-message-id",
+  threadId: "x-flutch-thread-id",
+  agentId: "x-flutch-agent-id",
+  userId: "x-flutch-user-id",
+  nodeName: "x-flutch-node"
+};
+var flutchFetch = (input, init) => {
+  const ctx = als.getStore();
+  if (!ctx) {
+    return fetch(input, init);
+  }
+  const headers = new Headers(init?.headers);
+  for (const key of Object.keys(HEADER_MAP)) {
+    const value = ctx[key];
+    if (value) {
+      headers.set(HEADER_MAP[key], String(value));
+    }
+  }
+  return fetch(input, { ...init, headers });
+};
+function flutchHeaders() {
+  const ctx = als.getStore();
+  if (!ctx) return {};
+  const out = {};
+  for (const key of Object.keys(HEADER_MAP)) {
+    const value = ctx[key];
+    if (value) {
+      out[HEADER_MAP[key]] = String(value);
+    }
+  }
+  return out;
+}
+function flutchMistralHook(req) {
+  const extras = flutchHeaders();
+  if (Object.keys(extras).length === 0) {
+    return req;
+  }
+  const headers = new Headers(req.headers);
+  for (const [k, v] of Object.entries(extras)) {
+    headers.set(k, v);
+  }
+  return new Request(req, { headers });
+}
+function wrapCohereFetcher(inner) {
+  return ((args) => {
+    const extras = flutchHeaders();
+    if (Object.keys(extras).length === 0) {
+      return inner(args);
+    }
+    return inner({
+      ...args,
+      headers: { ...args.headers ?? {}, ...extras }
+    });
+  });
+}
+
+// src/engines/langgraph/langgraph-engine.ts
 process.setMaxListeners(0);
 exports.LangGraphEngine = class LangGraphEngine {
   constructor(eventProcessor, configService) {
@@ -5276,29 +5420,42 @@ exports.LangGraphEngine = class LangGraphEngine {
    * Method to invoke LangGraph
    */
   async invokeGraph(graph, preparedPayload, signal) {
-    this.logger.debug("invokeGraph preparedPayload", preparedPayload);
-    if (signal) {
-      preparedPayload.signal = signal;
-      this.logger.debug("[ENGINE] Signal assigned to preparedPayload.signal");
-    }
-    const input = await this.deserializeInput(preparedPayload.input || {});
-    try {
-      const result = await graph.invoke(input, {
-        ...preparedPayload.config,
-        signal: preparedPayload.signal
-      });
-      return this.processGraphResult(result);
-    } finally {
-      const threadId = this.extractThreadId(preparedPayload);
-      if (threadId) {
-        clearAttachmentDataStore(threadId);
-        this.logger.debug(
-          `[ENGINE] Cleared attachment data store for thread: ${threadId}`
-        );
+    return withFlutchContext(
+      this.extractFlutchContext(preparedPayload),
+      async () => {
+        this.logger.debug("invokeGraph preparedPayload", preparedPayload);
+        if (signal) {
+          preparedPayload.signal = signal;
+          this.logger.debug(
+            "[ENGINE] Signal assigned to preparedPayload.signal"
+          );
+        }
+        const input = await this.deserializeInput(preparedPayload.input || {});
+        try {
+          const result = await graph.invoke(input, {
+            ...preparedPayload.config,
+            signal: preparedPayload.signal
+          });
+          return this.processGraphResult(result);
+        } finally {
+          const threadId = this.extractThreadId(preparedPayload);
+          if (threadId) {
+            clearAttachmentDataStore(threadId);
+            this.logger.debug(
+              `[ENGINE] Cleared attachment data store for thread: ${threadId}`
+            );
+          }
+        }
       }
-    }
+    );
   }
   async streamGraph(graph, preparedPayload, onPartial, signal) {
+    return withFlutchContext(
+      this.extractFlutchContext(preparedPayload),
+      () => this.streamGraphInner(graph, preparedPayload, onPartial, signal)
+    );
+  }
+  async streamGraphInner(graph, preparedPayload, onPartial, signal) {
     const acc = this.eventProcessor.createAccumulator();
     let streamError = null;
     this.logger.debug({
@@ -5528,6 +5685,22 @@ exports.LangGraphEngine = class LangGraphEngine {
   extractThreadId(preparedPayload) {
     return preparedPayload.configurable?.thread_id || preparedPayload.configurable?.context?.threadId || preparedPayload.config?.configurable?.thread_id || preparedPayload.config?.configurable?.context?.threadId || void 0;
   }
+  /**
+   * Extract Flutch billing/attribution context from the prepared payload.
+   *
+   * Read by `flutchFetch` (in node-sdk/src/models/flutch-context.ts) to
+   * attach X-Flutch-* headers to every router-bound LLM call made during
+   * this graph run.
+   */
+  extractFlutchContext(preparedPayload) {
+    const ctx = preparedPayload?.config?.configurable?.context || preparedPayload?.configurable?.context || {};
+    return {
+      messageId: ctx.messageId,
+      threadId: ctx.threadId || preparedPayload?.config?.configurable?.thread_id,
+      agentId: ctx.agentId,
+      userId: ctx.userId
+    };
+  }
   /**
    * Process graph execution result
    */
@@ -6683,7 +6856,10 @@ var ModelInitializer = class _ModelInitializer {
       );
       const routerURL = resolveRouterURL(baseURL);
       if (routerURL) {
-        config.configuration = { baseURL: `${routerURL}/v1` };
+        config.configuration = {
+          baseURL: `${routerURL}/v1`,
+          fetch: flutchFetch
+        };
       }
       return new openai.ChatOpenAI(config);
     },
@@ -6693,15 +6869,19 @@ var ModelInitializer = class _ModelInitializer {
       defaultMaxTokens,
       apiToken,
       baseURL
-    }) => new anthropic.ChatAnthropic({
-      modelName,
-      temperature: defaultTemperature,
-      maxTokens: defaultMaxTokens,
-      anthropicApiKey: apiToken || this.resolveApiKey("anthropic" /* ANTHROPIC */),
-      ...resolveRouterURL(baseURL) && {
-        anthropicApiUrl: resolveRouterURL(baseURL)
-      }
-    }),
+    }) => {
+      const routerURL = resolveRouterURL(baseURL);
+      return new anthropic.ChatAnthropic({
+        modelName,
+        temperature: defaultTemperature,
+        maxTokens: defaultMaxTokens,
+        anthropicApiKey: apiToken || this.resolveApiKey("anthropic" /* ANTHROPIC */),
+        ...routerURL && {
+          anthropicApiUrl: routerURL,
+          clientOptions: { fetch: flutchFetch }
+        }
+      });
+    },
     ["cohere" /* COHERE */]: ({
       modelName,
       defaultTemperature,
@@ -6714,7 +6894,13 @@ var ModelInitializer = class _ModelInitializer {
       return routerURL ? new cohere.ChatCohere({
         model: modelName,
         temperature: defaultTemperature,
-        client: new cohereAi.CohereClient({ token, baseUrl: routerURL })
+        client: new cohereAi.CohereClient({
+          token,
+          baseUrl: routerURL,
+          // Inject X-Flutch-* headers from the ALS context on every
+          // outbound request via the wrapped default fetcher.
+          fetcher: wrapCohereFetcher(core$1.fetcher)
+        })
       }) : new cohere.ChatCohere({
         model: modelName,
         temperature: defaultTemperature,
@@ -6734,7 +6920,13 @@ var ModelInitializer = class _ModelInitializer {
         temperature: defaultTemperature,
         maxTokens: defaultMaxTokens,
         apiKey: apiToken || this.resolveApiKey("mistral" /* MISTRAL */),
-        ...routerURL && { serverURL: `${routerURL}/v1` }
+        ...routerURL && {
+          serverURL: `${routerURL}/v1`,
+          // Mistral SDK doesn't accept a custom fetch directly — its
+          // beforeRequestHooks let us mutate the outgoing Request to add
+          // X-Flutch-* headers from the ALS context.
+          beforeRequestHooks: [flutchMistralHook]
+        }
       });
     },
     ["voyageai" /* VOYAGEAI */]: () => {
@@ -6789,7 +6981,7 @@ var ModelInitializer = class _ModelInitializer {
         model: modelName,
         apiKey: apiToken || this.resolveApiKey("openai" /* OPENAI */),
         ...routerURL && {
-          configuration: { baseURL: `${routerURL}/v1` }
+          configuration: { baseURL: `${routerURL}/v1`, fetch: flutchFetch }
         }
       });
     },
@@ -7783,11 +7975,15 @@ exports.encryptTokens = encryptTokens;
 exports.executeToolWithAttachments = executeToolWithAttachments;
 exports.findCallbackMethod = findCallbackMethod;
 exports.findEndpointMethod = findEndpointMethod;
+exports.flutchFetch = flutchFetch;
+exports.flutchHeaders = flutchHeaders;
+exports.flutchMistralHook = flutchMistralHook;
 exports.generateAttachmentSummary = generateAttachmentSummary;
 exports.generateModelCacheKey = generateModelCacheKey;
 exports.getAttachmentData = getAttachmentData;
 exports.getCallbackMetadata = getCallbackMetadata;
 exports.getEndpointMetadata = getEndpointMetadata;
+exports.getFlutchContext = getFlutchContext;
 exports.getOAuthProvider = getOAuthProvider;
 exports.getOAuthProviderNames = getOAuthProviderNames;
 exports.getUIEndpointClassMetadata = getUIEndpointClassMetadata;
@@ -7805,5 +8001,7 @@ exports.resolveRouterURL = resolveRouterURL;
 exports.sanitizeTraceData = sanitizeTraceData;
 exports.storeAttachmentData = storeAttachmentData;
 exports.traceApiCall = traceApiCall;
+exports.withFlutchContext = withFlutchContext;
+exports.wrapCohereFetcher = wrapCohereFetcher;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map