@librechat/agents 3.7.22 → 3.8.1

package/src/messages/cache.ts

@@ -4,6 +4,7 @@ import type Anthropic from '@anthropic-ai/sdk';
 import type { AnthropicMessage } from '@/types/messages';
 import { hasComputerCallOutputMarker } from '@/utils/toolContent';
 import { toLangChainContent } from './langchain';
+import { isReasoningContentBlock } from './reasoningTypes';
 import { ContentTypes } from '@/common/enum';
 
 type MessageWithContent = {
@@ -412,27 +413,25 @@ function isCachePoint(block: unknown): boolean {
  * loses tail caching, so all of these are excluded.
  */
 const NON_ANCHORABLE_BLOCK_TYPES = new Set([
-  'thinking',
-  'redacted_thinking',
-  'reasoning_content',
-  'reasoning',
-  'think',
   'input_json_delta',
 ]);
 
 /**
  * A block can anchor the tail cache breakpoint when it is a real content block
  * that the Anthropic API accepts `cache_control` on and that survives provider
- * conversion. Reasoning / dropped-delta blocks are excluded (see
- * {@link NON_ANCHORABLE_BLOCK_TYPES}), and empty text blocks are not cacheable,
- * so both are skipped.
+ * conversion. Reasoning and dropped-delta blocks are excluded, and empty text
+ * blocks are not cacheable, so all are skipped.
  */
 function isTailCacheableBlock(block: MessageContentComplex): boolean {
   if (isCachePoint(block)) {
     return false;
   }
   const type = (block as { type?: string }).type;
-  if (type == null || NON_ANCHORABLE_BLOCK_TYPES.has(type)) {
+  if (
+    type == null ||
+    isReasoningContentBlock(block) ||
+    NON_ANCHORABLE_BLOCK_TYPES.has(type)
+  ) {
     return false;
   }
   if (type === 'text') {

package/src/messages/core.ts

@@ -11,6 +11,11 @@ import type { ContentBlock as LangChainContentBlock } from '@langchain/core/mess
 import type { ToolCall, ToolCallChunk } from '@langchain/core/messages/tool';
 import type { ProviderMessageProvenancePart } from './provenance';
 import type * as t from '@/types';
+import type {
+  ResponsesReplayPosition,
+  ToolHistoryPreparation,
+  OrderedToolHistoryProjection,
+} from './toolHistoryProjection';
 import {
   cloneToolMessageWithContent,
   compactToolContent,
@@ -31,8 +36,16 @@ import {
 } from './provenance';
 import { HARD_MAX_TOOL_RESULT_CHARS } from '@/utils/truncation';
 import { stripAnthropicCacheControl } from './cache';
+import { isReasoningContentBlock } from './reasoningTypes';
 import { ContentTypes, Providers } from '@/common';
 import { toLangChainContent } from './langchain';
+import {
+  OPENAI_RESPONSES_REPLAY_POSITIONS_KEY,
+  createToolHistoryPreparation,
+  getGeneratedImageMimeType,
+  getResponsesHistorySource,
+  isResponsesReplayPosition,
+} from './toolHistoryProjection';
 
 type ReasoningSummary = { summary?: Array<{ text?: string }> };
 type ReasoningDetail = { type?: string; text?: string };
@@ -227,8 +240,7 @@ function getAdditionalReasoningContent(
 /**
  * True when a content block is a provider reasoning block: Anthropic
  * `thinking` / `redacted_thinking`, Google `reasoning`, Bedrock
- * `reasoning_content`, and the streamed delta variants that prefix each of
- * those names.
+ * `reasoning_content`, LibreChat `think`, and their known streamed variants.
  *
  * Shared rather than re-derived because two very different readers must agree
  * on the same answer: the stream classifier, which decides what the host has
@@ -236,38 +248,18 @@ function getAdditionalReasoningContent(
  * holds anything worth keeping. A turn the host renders as thinking-only must
  * never look like a visible answer to the gate.
  *
- * Prefix matching, not equality, because providers stream these as suffixed
- * delta types. `reasoning_content` needs no clause of its own — it already
- * carries the `reasoning` prefix.
+ * Exact matching prevents unrelated custom block types that happen to share a
+ * prefix from being silently classified as hidden reasoning.
  */
-export function isReasoningContentBlock(block: { type?: string }): boolean {
-  const type = block.type;
-  if (type == null) {
-    return false;
-  }
-  return (
-    type.startsWith(ContentTypes.THINKING) ||
-    type.startsWith(ContentTypes.REASONING) ||
-    type === 'redacted_thinking'
-  );
-}
+export { isReasoningContentBlock } from './reasoningTypes';
 
 function hasReasoningContent(content: BaseMessage['content']): boolean {
   if (!Array.isArray(content)) {
     return false;
   }
-  return content.some((item) => {
-    if (typeof item !== 'object' || !('type' in item)) {
-      return false;
-    }
-    return (
-      item.type === ContentTypes.THINK ||
-      item.type === ContentTypes.THINKING ||
-      item.type === ContentTypes.REASONING ||
-      item.type === ContentTypes.REASONING_CONTENT ||
-      item.type === 'redacted_thinking'
-    );
-  });
+  return content.some(
+    (item) => typeof item === 'object' && isReasoningContentBlock(item)
+  );
 }
 
 export function modifyDeltaProperties(
@@ -856,19 +848,13 @@ function hasReplayableEncryptedReasoning(reasoning: unknown): boolean {
 
 type ResponsesReplayProjection = 'fallback' | 'native';
 
-export const OPENAI_RESPONSES_REPLAY_POSITIONS_KEY =
-  '__openai_responses_replay_positions__';
+export { OPENAI_RESPONSES_REPLAY_POSITIONS_KEY } from './toolHistoryProjection';
 
 /** Reasoning item currently streaming, so a terminal ciphertext seals against its own id. */
 export const OPENAI_RESPONSES_ACTIVE_REASONING_ID_KEY =
   '__openai_responses_active_reasoning_id__';
 
-export type ResponsesReplayPosition = {
-  contentIndex?: number;
-  itemId: string;
-  kind: 'message' | 'output' | 'reasoning' | 'text';
-  outputIndex: number;
-};
+export type { ResponsesReplayPosition } from './toolHistoryProjection';
 
 type CompletedGeneratedImages = {
   blocks: PositionedResponsesReplayBlock[];
@@ -1297,56 +1283,7 @@ function projectPreemptedResponsesV1Content(
 }
 
 function getAuthoritativeResponsesOutput(message: AIMessage): unknown[] {
-  const responseOutput = message.response_metadata.output;
-  const toolOutputs = message.additional_kwargs.tool_outputs;
-  if (Array.isArray(responseOutput) && responseOutput.length > 0) {
-    return responseOutput;
-  }
-  return Array.isArray(toolOutputs) ? toolOutputs : [];
-}
-
-function isResponsesReplayPosition(
-  value: unknown
-): value is ResponsesReplayPosition {
-  if (value == null || typeof value !== 'object') {
-    return false;
-  }
-  const position = value as Partial<ResponsesReplayPosition>;
-  return (
-    (position.kind === 'message' ||
-      position.kind === 'output' ||
-      position.kind === 'reasoning' ||
-      position.kind === 'text') &&
-    typeof position.itemId === 'string' &&
-    position.itemId.length > 0 &&
-    typeof position.outputIndex === 'number' &&
-    Number.isSafeInteger(position.outputIndex) &&
-    position.outputIndex >= 0 &&
-    (position.contentIndex == null ||
-      (typeof position.contentIndex === 'number' &&
-        Number.isSafeInteger(position.contentIndex) &&
-        position.contentIndex >= 0))
-  );
-}
-
-function getGeneratedImageMimeType(data: string): string {
-  const bytes = Buffer.from(data.slice(0, 16), 'base64');
-  if (bytes[0] === 0xff && bytes[1] === 0xd8 && bytes[2] === 0xff) {
-    return 'image/jpeg';
-  }
-  if (
-    bytes[0] === 0x52 &&
-    bytes[1] === 0x49 &&
-    bytes[2] === 0x46 &&
-    bytes[3] === 0x46 &&
-    bytes[8] === 0x57 &&
-    bytes[9] === 0x45 &&
-    bytes[10] === 0x42 &&
-    bytes[11] === 0x50
-  ) {
-    return 'image/webp';
-  }
-  return 'image/png';
+  return getResponsesHistorySource(message)?.items ?? [];
 }
 
 function getResponsesReplayItemKey(
@@ -1382,7 +1319,8 @@ function getResponsesReplayArtifacts(
   output: readonly unknown[],
   maxChars: number,
   replayProjection: ResponsesReplayProjection,
-  replayPositionValue?: unknown
+  replayPositionValue?: unknown,
+  history?: OrderedToolHistoryProjection
 ): ResponsesReplayArtifacts {
   const blocks: PositionedResponsesReplayBlock[] = [];
   const data = new Set<string>();
@@ -1441,7 +1379,11 @@ function getResponsesReplayArtifacts(
       kind: 'message',
       outputIndex,
     });
-    if (!('content' in item) || !Array.isArray(item.content)) {
+    if (
+      history != null ||
+      !('content' in item) ||
+      !Array.isArray(item.content)
+    ) {
       continue;
     }
     for (
@@ -1473,6 +1415,24 @@ function getResponsesReplayArtifacts(
       });
     }
   }
+  if (history?.source.coverage === 'complete-output') {
+    for (const contribution of history.contributions) {
+      if (contribution.kind !== 'text') {
+        continue;
+      }
+      const itemId =
+        contribution.itemId ?? `message-${contribution.outputIndex}`;
+      textPositionsByKey.set(
+        `${itemId}:${contribution.outputIndex}:${contribution.contentIndex ?? 0}`,
+        {
+          itemId,
+          kind: 'text',
+          outputIndex: contribution.outputIndex,
+          contentIndex: contribution.contentIndex,
+        }
+      );
+    }
+  }
   if (hasAuthoritativeMessage) {
     for (const [itemId, outputIndex] of authoritativeOutputIndicesByItemId) {
       outputPositionsByItemId.set(itemId, {
@@ -1918,7 +1878,8 @@ function isPreemptedOpenAIResponsesMessage(message: AIMessage): boolean {
 function projectPreemptedOpenAIResponsesMessage(
   message: AIMessage,
   maxChars: number,
-  replayProjection: ResponsesReplayProjection
+  replayProjection: ResponsesReplayProjection,
+  preparation: ToolHistoryPreparation = createToolHistoryPreparation()
 ): AIMessage {
   if (!isPreemptedOpenAIResponsesMessage(message)) {
     return message;
@@ -1929,7 +1890,9 @@ function projectPreemptedOpenAIResponsesMessage(
   const retainsEncryptedReasoning =
     replayProjection === 'native' &&
     hasReplayableEncryptedReasoning(additionalKwargs.reasoning);
-  const authoritativeOutput = getAuthoritativeResponsesOutput(message);
+  const history = preparation.get(message);
+  const authoritativeOutput =
+    history?.source.items ?? getAuthoritativeResponsesOutput(message);
   const {
     generatedImages,
     messagePositions,
@@ -1941,7 +1904,8 @@ function projectPreemptedOpenAIResponsesMessage(
     authoritativeOutput,
     maxChars,
     replayProjection,
-    additionalKwargs[OPENAI_RESPONSES_REPLAY_POSITIONS_KEY]
+    additionalKwargs[OPENAI_RESPONSES_REPLAY_POSITIONS_KEY],
+    history
   );
   const reasoningItemId =
     retainsEncryptedReasoning &&
@@ -2043,7 +2007,8 @@ function projectPreemptedOpenAIResponsesMessage(
 export function projectToolStreamContentForProvider(
   messages: BaseMessage[],
   responsesReplayProjection?: ResponsesReplayProjection,
-  maxChars = HARD_MAX_TOOL_RESULT_CHARS
+  maxChars = HARD_MAX_TOOL_RESULT_CHARS,
+  preparation: ToolHistoryPreparation = createToolHistoryPreparation()
 ): BaseMessage[] {
   let projected: BaseMessage[] | undefined;
   for (let i = 0; i < messages.length; i++) {
@@ -2059,7 +2024,8 @@ export function projectToolStreamContentForProvider(
       const replaySafeMessage = projectPreemptedOpenAIResponsesMessage(
         assistantMessage,
         maxChars,
-        responsesReplayProjection
+        responsesReplayProjection,
+        preparation
       );
       if (replaySafeMessage !== assistantMessage) {
         projected ??= [...messages];
@@ -2798,14 +2764,18 @@ export function findLastIndex<T>(
 function readOwnDataProperty(target: object, key: PropertyKey): unknown {
   try {
     const descriptor = Object.getOwnPropertyDescriptor(target, key);
-    return descriptor != null && 'value' in descriptor ? descriptor.value : undefined;
+    return descriptor != null && 'value' in descriptor
+      ? descriptor.value
+      : undefined;
   } catch {
     return undefined;
   }
 }
 
 /** Whether message content carries non-whitespace text in any text block. */
-export function hasNonEmptyTextContent(content: BaseMessage['content']): boolean {
+export function hasNonEmptyTextContent(
+  content: BaseMessage['content']
+): boolean {
   if (typeof content === 'string') {
     return content.trim() !== '';
   }