@librechat/agents 3.7.18 → 3.7.19

package/dist/types/langfuse.d.ts

@@ -44,7 +44,7 @@ type LangfuseAttributeParams = AgentLangfuseHandlerParams & {
 };
 export declare function isExplicitLangfuseConfig(langfuse?: t.LangfuseConfig): boolean;
 export declare function createLibreChatTraceAttributes(attributes: LangfuseConfigTraceAttributes): LangfuseTraceAttributes;
-export declare function createLangfuseTraceMetadata({ messageId, parentMessageId, agentId, agentName, rootAgentId, rootAgentName, activeAgentId, activeAgentName, }: {
+export declare function createLangfuseTraceMetadata({ messageId, parentMessageId, agentId, agentName, rootAgentId, rootAgentName, activeAgentId, activeAgentName, endpoint, model, provider, resolvedProvider, }: {
     messageId?: unknown;
     parentMessageId?: unknown;
     agentId?: unknown;
@@ -53,6 +53,10 @@ export declare function createLangfuseTraceMetadata({ messageId, parentMessageId
     rootAgentName?: unknown;
     activeAgentId?: unknown;
     activeAgentName?: unknown;
+    endpoint?: unknown;
+    model?: unknown;
+    provider?: unknown;
+    resolvedProvider?: unknown;
 }): LangfuseTraceMetadata;
 export declare function getLangfuseTraceName(traceMetadata?: LangfuseTraceMetadata, fallback?: string): string;
 export declare function shouldCreateLangfuseHandler(langfuse?: t.LangfuseConfig): boolean;

package/dist/types/llm/prepareProviderRequest.d.ts

@@ -1,5 +1,5 @@
-import type { RunnableConfig } from '@langchain/core/runnables';
 import type { BaseMessage } from '@langchain/core/messages';
+import type { RunnableConfig } from '@langchain/core/runnables';
 import type { ToolOutputReferenceRegistry } from '@/tools/toolOutputReferences';
 import type * as t from '@/types';
 declare const preparedProviderRequestBrand: unique symbol;

package/dist/types/types/graph.d.ts

@@ -672,6 +672,8 @@ export interface LangfuseConfig {
 }
 interface AgentInputFields {
     agentId: string;
+    /** Logical endpoint selected by the host before provider resolution. */
+    endpoint?: string;
     /**
      * Partition key for transient code-session ids and file refs. Agents with
      * the same key share those refs; different execution profiles/scopes must

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@librechat/agents",
-  "version": "3.7.18",
+  "version": "3.7.19",
   "reova": {
     "enabled": true,
     "endpoint": "https://telemetry.reo.dev/data"

package/src/agents/AgentContext.ts

@@ -104,6 +104,7 @@ export class AgentContext {
   ): AgentContext {
     const {
       agentId,
+      endpoint,
       codeSessionKey,
       name,
       provider,
@@ -135,6 +136,7 @@ export class AgentContext {
 
     const agentContext = new AgentContext({
       agentId,
+      endpoint,
       codeSessionKey,
       name: name ?? agentId,
       provider,
@@ -219,6 +221,8 @@ export class AgentContext {
 
   /** Agent identifier */
   agentId: string;
+  /** Logical endpoint selected by the host before provider resolution. */
+  endpoint: string;
   /** Partition for this agent's transient code session and file refs. */
   codeSessionKey?: string;
   /** Human-readable name for this agent (used in handoff context). Falls back to agentId if not provided. */
@@ -454,6 +458,7 @@ export class AgentContext {
 
   constructor({
     agentId,
+    endpoint,
     codeSessionKey,
     name,
     provider,
@@ -481,6 +486,7 @@ export class AgentContext {
     maxToolResultChars,
   }: {
     agentId: string;
+    endpoint?: string;
     codeSessionKey?: string;
     name?: string;
     provider: t.ProviderName;
@@ -508,6 +514,7 @@ export class AgentContext {
     maxToolResultChars?: number;
   }) {
     this.agentId = agentId;
+    this.endpoint = endpoint ?? provider;
     this.codeSessionKey = codeSessionKey;
     this.name = name;
     this.provider = provider;

package/src/graphs/Graph.ts

@@ -151,6 +151,7 @@ import { shouldTraceToolNodeForLangfuse } from '@/langfuseToolOutputTracing';
 import { createLocalCodingToolBundle } from '@/tools/local/LocalCodingTools';
 import { SUBAGENT_REPLAY_CONTROLLER } from '@/tools/subagent/SubagentReplay';
 import { applyGraphRuntimeConfig } from '@/graphs/applyGraphRuntimeConfig';
+import { isFadingTier, isInformativeFadingTier } from '@/messages/fading';
 import { createContextPressureMeter } from '@/llm/contextPressureMeter';
 import { safeDispatchCustomEvent, emitAgentLog } from '@/utils/events';
 import { prepareProviderRequest } from '@/llm/prepareProviderRequest';
@@ -163,7 +164,6 @@ import { initializeLangfuseTracing } from '@/instrumentation';
 import { shouldTriggerSummarization } from '@/summarization';
 import { isRunStepResumeState } from '@/tools/runStepResume';
 import { resolveLocalToolsForBinding } from '@/tools/local';
-import { isFadingTier, isInformativeFadingTier } from '@/messages/fading';
 import { createSummarizeNode } from '@/summarization/node';
 import { getTruncationStopReason } from '@/llm/truncation';
 import { messagesStateReducer } from '@/messages/reducer';
@@ -3992,6 +3992,7 @@ export class StandardGraph extends Graph<t.BaseGraphState, t.GraphNode> {
         rootAgentName: this.agentContexts.get(this.defaultAgentId)?.name,
         activeAgentId: agentId,
         activeAgentName: agentContext.name,
+        endpoint: agentContext.endpoint,
       });
       let langfuseHandler: CallbackEntry | undefined;
       let invokeConfig = {

package/src/langfuse.ts

@@ -840,6 +840,10 @@ export function createLangfuseTraceMetadata({
   rootAgentName,
   activeAgentId,
   activeAgentName,
+  endpoint,
+  model,
+  provider,
+  resolvedProvider,
 }: {
   messageId?: unknown;
   parentMessageId?: unknown;
@@ -849,6 +853,10 @@ export function createLangfuseTraceMetadata({
   rootAgentName?: unknown;
   activeAgentId?: unknown;
   activeAgentName?: unknown;
+  endpoint?: unknown;
+  model?: unknown;
+  provider?: unknown;
+  resolvedProvider?: unknown;
 }): LangfuseTraceMetadata {
   return createTraceMetadata({
     messageId,
@@ -859,6 +867,10 @@ export function createLangfuseTraceMetadata({
     rootAgentName,
     activeAgentId,
     activeAgentName,
+    endpoint,
+    model,
+    provider,
+    resolvedProvider,
   });
 }
 

package/src/llm/invoke.ts

@@ -692,11 +692,32 @@ export async function attemptInvoke(
   config?: RunnableConfig
 ): Promise<Partial<t.BaseGraphState>> {
   const provider = resolveAttemptProvider(params);
-  const stampedConfig: RunnableConfig = {
+  const providerStampedConfig: RunnableConfig = {
     ...config,
     metadata: {
       ...(config?.metadata ?? {}),
       [Constants.INVOKED_PROVIDER]: provider,
+      provider,
+      resolvedProvider: provider,
+    },
+  };
+  const request = resolveAttemptRequest(params, providerStampedConfig);
+  const configuredModel = providerStampedConfig.metadata?.[
+    Constants.INVOKED_MODEL
+  ];
+  const modelId =
+    request.modelId ??
+    (typeof configuredModel === 'string' ? configuredModel : undefined);
+  const stampedConfig: RunnableConfig = {
+    ...providerStampedConfig,
+    metadata: {
+      ...providerStampedConfig.metadata,
+      ...(modelId == null
+        ? {}
+        : {
+          [Constants.INVOKED_MODEL]: modelId,
+          model: modelId,
+        }),
       /**
        * One `attemptInvoke` call is one model attempt; primary, fallback,
        * and retry attempts within a node otherwise share the same langgraph
@@ -727,7 +748,7 @@ export async function attemptInvoke(
   try {
     return await attemptInvokeBody(
       {
-        request: resolveAttemptRequest(params, stampedConfig),
+        request,
         context: params.context,
         onChunk: params.onChunk,
         preemptAgentId: params.preemptAgentId,

package/src/llm/prepareProviderRequest.ts

@@ -1,5 +1,10 @@
+import { Buffer } from 'node:buffer';
+import type {
+  BaseMessage,
+  Data,
+  MessageContentComplex,
+} from '@langchain/core/messages';
 import type { RunnableConfig } from '@langchain/core/runnables';
-import type { BaseMessage } from '@langchain/core/messages';
 import type { ToolOutputReferenceRegistry } from '@/tools/toolOutputReferences';
 import type * as t from '@/types';
 import {
@@ -20,14 +25,60 @@ import {
 import {
   stripAnthropicCacheControl,
   stripBedrockCacheControl,
+  cloneMessage,
 } from '@/messages/cache';
+import {
+  isAnthropicLike,
+  isGoogleLike,
+  isOpenAILike,
+} from '@/utils/llm';
 import { annotateMessagesForLLM } from '@/tools/toolOutputReferences';
 import { providerRequiresStrictAlternation } from '@/llm/providers';
-import { isAnthropicLike, isOpenAILike } from '@/utils/llm';
 import { getProviderFamily } from '@/llm/providerRegistry';
 import { Providers } from '@/common';
 
 const preparedProviderRequestBrand = Symbol('PreparedProviderRequest');
+const OMITTED_ATTACHMENT_TEXT =
+  '[Attachment omitted because its binary format is unsupported by this provider.]';
+
+const BEDROCK_DOCUMENT_MIME_TYPES: Readonly<Partial<Record<string, string>>> = {
+  csv: 'text/csv',
+  doc: 'application/msword',
+  docx: 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+  html: 'text/html',
+  md: 'text/markdown',
+  pdf: 'application/pdf',
+  txt: 'text/plain',
+  xls: 'application/vnd.ms-excel',
+  xlsx: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+};
+
+interface SerializedBuffer {
+  type: 'Buffer';
+  data: number[];
+}
+
+interface BedrockDocumentBlock {
+  type: 'document';
+  document: {
+    name: string;
+    format: string;
+    source: {
+      bytes: Uint8Array | SerializedBuffer;
+    };
+  };
+}
+
+type StandardBase64FileBlock = Data.StandardFileBlock & {
+  source_type: 'base64';
+  mime_type: string;
+  data: string;
+};
+
+type ProviderContentBlock =
+  | MessageContentComplex
+  | BedrockDocumentBlock
+  | StandardBase64FileBlock;
 
 export type ProviderMessageProjectionMode =
   | 'chat-messages'
@@ -159,16 +210,216 @@ interface ProjectMessagesForProviderParams {
   callOptions?: unknown;
 }
 
+function isSerializedBuffer(value: object): value is SerializedBuffer {
+  return (
+    'type' in value &&
+    value.type === 'Buffer' &&
+    'data' in value &&
+    Array.isArray(value.data)
+  );
+}
+
+function isBedrockDocumentBlock(
+  block: ProviderContentBlock
+): block is BedrockDocumentBlock {
+  if (block.type !== 'document' || !('document' in block)) {
+    return false;
+  }
+  const document = block.document;
+  if (typeof document !== 'object' || document == null) {
+    return false;
+  }
+  if (
+    !('name' in document) ||
+    typeof document.name !== 'string' ||
+    !('format' in document) ||
+    typeof document.format !== 'string' ||
+    !('source' in document) ||
+    typeof document.source !== 'object' ||
+    document.source == null ||
+    !('bytes' in document.source)
+  ) {
+    return false;
+  }
+  const bytes = document.source.bytes;
+  return (
+    bytes instanceof Uint8Array ||
+    (typeof bytes === 'object' && bytes != null && isSerializedBuffer(bytes))
+  );
+}
+
+function toStandardFileBlock(
+  block: BedrockDocumentBlock
+): StandardBase64FileBlock | undefined {
+  const mimeType = BEDROCK_DOCUMENT_MIME_TYPES[block.document.format];
+  if (mimeType == null) {
+    return undefined;
+  }
+  const source = block.document.source.bytes;
+  const bytes = source instanceof Uint8Array ? source : source.data;
+  return {
+    type: 'file',
+    source_type: 'base64',
+    mime_type: mimeType,
+    data: Buffer.from(bytes).toString('base64'),
+    metadata: { name: block.document.name },
+  };
+}
+
+function isStandardFileBlock(
+  block: ProviderContentBlock
+): block is StandardBase64FileBlock {
+  return (
+    block.type === 'file' &&
+    'source_type' in block &&
+    block.source_type === 'base64' &&
+    'mime_type' in block &&
+    typeof block.mime_type === 'string' &&
+    'data' in block &&
+    typeof block.data === 'string'
+  );
+}
+
+function shouldRetainStandardFile(
+  provider: t.ProviderName,
+  mimeType: string
+): boolean {
+  const normalizedMimeType = mimeType.split(';', 1)[0].trim().toLowerCase();
+  if (
+    provider === Providers.ANTHROPIC ||
+    getProviderFamily(provider) === 'anthropic'
+  ) {
+    return (
+      normalizedMimeType === 'application/pdf' ||
+      normalizedMimeType === 'image/jpeg' ||
+      normalizedMimeType === 'image/png' ||
+      normalizedMimeType === 'image/gif' ||
+      normalizedMimeType === 'image/webp'
+    );
+  }
+  if (isOpenAILike(provider)) {
+    return normalizedMimeType === 'application/pdf';
+  }
+  return true;
+}
+
+function canProjectBedrockDocument(
+  provider: t.ProviderName,
+  mimeType: string
+): boolean {
+  if (isGoogleLike(provider)) {
+    return true;
+  }
+  if (
+    provider === Providers.ANTHROPIC ||
+    getProviderFamily(provider) === 'anthropic' ||
+    isOpenAILike(provider)
+  ) {
+    return mimeType === 'application/pdf';
+  }
+  return false;
+}
+
+function isBlankTextBlock(block: ProviderContentBlock): boolean {
+  return (
+    block.type === 'text' &&
+    'text' in block &&
+    typeof block.text === 'string' &&
+    block.text.trim() === ''
+  );
+}
+
+function copyUsableContentPrefix(
+  sourceContent: ProviderContentBlock[],
+  end: number
+): ProviderContentBlock[] {
+  const content: ProviderContentBlock[] = [];
+  for (let index = 0; index < end; index++) {
+    const block = sourceContent[index];
+    if (!isBlankTextBlock(block)) {
+      content.push(block);
+    }
+  }
+  return content;
+}
+
+/** Reprojects persisted provider-native attachments without changing history. */
+function projectAttachmentsForProvider(
+  messages: BaseMessage[],
+  provider: t.ProviderName
+): BaseMessage[] {
+  if (
+    provider === Providers.BEDROCK ||
+    getProviderFamily(provider) === 'bedrock'
+  ) {
+    return messages;
+  }
+  let projected: BaseMessage[] | undefined;
+  for (let messageIndex = 0; messageIndex < messages.length; messageIndex++) {
+    const message = messages[messageIndex];
+    if (!Array.isArray(message.content)) {
+      continue;
+    }
+    const sourceContent = message.content as ProviderContentBlock[];
+    let content: ProviderContentBlock[] | undefined;
+    for (let blockIndex = 0; blockIndex < sourceContent.length; blockIndex++) {
+      const block = sourceContent[blockIndex];
+      if (isStandardFileBlock(block)) {
+        if (shouldRetainStandardFile(provider, block.mime_type)) {
+          content?.push(block);
+          continue;
+        }
+        content ??= copyUsableContentPrefix(sourceContent, blockIndex);
+        continue;
+      }
+      if (!isBedrockDocumentBlock(block)) {
+        if (content != null && !isBlankTextBlock(block)) {
+          content.push(block);
+        }
+        continue;
+      }
+      content ??= copyUsableContentPrefix(sourceContent, blockIndex);
+      const mimeType = BEDROCK_DOCUMENT_MIME_TYPES[block.document.format];
+      if (
+        mimeType == null ||
+        !canProjectBedrockDocument(provider, mimeType)
+      ) {
+        continue;
+      }
+      const standardFile = toStandardFileBlock(block);
+      if (standardFile == null) {
+        continue;
+      }
+      content.push(standardFile);
+    }
+    if (content == null) {
+      continue;
+    }
+    if (content.length === 0) {
+      content.push({ type: 'text', text: OMITTED_ATTACHMENT_TEXT });
+    }
+    projected ??= [...messages];
+    projected[messageIndex] = cloneMessage(
+      message,
+      content as MessageContentComplex[]
+    );
+  }
+  return projected ?? messages;
+}
+
 function projectMessagesForProviderMode(
   { messages, provider, maxToolResultChars }: ProjectMessagesForProviderParams,
   projectionMode: ProviderMessageProjectionMode
 ): BaseMessage[] {
   const providerFamily = getProviderFamily(provider);
   const nativeOpenAIResponses = projectionMode === 'openai-responses';
-  const providerInputMessages = projectToolStreamContentForProvider(
-    messages,
-    nativeOpenAIResponses ? 'native' : 'fallback',
-    maxToolResultChars
+  const providerInputMessages = projectAttachmentsForProvider(
+    projectToolStreamContentForProvider(
+      messages,
+      nativeOpenAIResponses ? 'native' : 'fallback',
+      maxToolResultChars
+    ),
+    provider
   );
   if (nativeOpenAIResponses) {
     return projectOpenAIResponsesToolMessageContent(

package/src/types/graph.ts

@@ -853,6 +853,8 @@ export interface LangfuseConfig {
 
 interface AgentInputFields {
   agentId: string;
+  /** Logical endpoint selected by the host before provider resolution. */
+  endpoint?: string;
   /**
    * Partition key for transient code-session ids and file refs. Agents with
    * the same key share those refs; different execution profiles/scopes must