@librechat/agents 3.8.0 → 3.8.2

package/src/graphs/MultiAgentGraph.ts

@@ -1267,6 +1267,11 @@ export class MultiAgentGraph extends StandardGraph {
         reducer: (_current, update) => update,
         default: () => undefined,
       }),
+      /** Surfaced from the summarizing agent's subgraph on a summarize-only run. */
+      manualSummary: Annotation<string | undefined>({
+        reducer: (_current, update) => update,
+        default: () => undefined,
+      }),
       runStepState: this.createRunStepStateAnnotation(),
     });
 
@@ -1281,14 +1286,29 @@ export class MultiAgentGraph extends StandardGraph {
       builder.addEdge(source, destination);
     };
 
+    /**
+     * A summarize-only run compiles to the opted-in agent alone: no other
+     * node, no handoff or direct edge, START → agent → END. Anything else
+     * would run the summarizer twice (once from START, once through its
+     * predecessor) or append routing prompts to the checkpoint it just
+     * produced.
+     */
+    const summarizeOnlyAgentId = this.summarizeOnlyAgentId;
+    const agentIds =
+      summarizeOnlyAgentId != null
+        ? [summarizeOnlyAgentId]
+        : [...this.agentContexts.keys()];
+    const handoffEdges = summarizeOnlyAgentId != null ? [] : this.handoffEdges;
+    const directEdges = summarizeOnlyAgentId != null ? [] : this.directEdges;
+
     // Add all agents as complete subgraphs
-    for (const [agentId] of this.agentContexts) {
+    for (const agentId of agentIds) {
       // Get all possible destinations for this agent
       const handoffDestinations = new Set<string>();
       const directDestinations = new Set<string>();
 
       // Check handoff edges for destinations
-      for (const edge of this.handoffEdges) {
+      for (const edge of handoffEdges) {
         const sources = Array.isArray(edge.from) ? edge.from : [edge.from];
         if (sources.includes(agentId) === true) {
           const dests = Array.isArray(edge.to) ? edge.to : [edge.to];
@@ -1297,7 +1317,7 @@ export class MultiAgentGraph extends StandardGraph {
       }
 
       // Check direct edges for destinations
-      for (const edge of this.directEdges) {
+      for (const edge of directEdges) {
         const sources = Array.isArray(edge.from) ? edge.from : [edge.from];
         if (sources.includes(agentId) === true) {
           const dests = Array.isArray(edge.to) ? edge.to : [edge.to];
@@ -1500,6 +1520,7 @@ export class MultiAgentGraph extends StandardGraph {
         } else {
           result = await agentSubgraph.invoke(state, memberConfig);
         }
+        result = this.propagateManualCompaction(result);
 
         if (this.resultAgentId === agentId) {
           result = {
@@ -1560,8 +1581,9 @@ export class MultiAgentGraph extends StandardGraph {
       });
     }
 
-    // Add starting edges for all starting nodes
-    for (const startNode of this.startingNodes) {
+    const startingNodes =
+      summarizeOnlyAgentId != null ? [summarizeOnlyAgentId] : this.startingNodes;
+    for (const startNode of startingNodes) {
       // eslint-disable-next-line @typescript-eslint/ban-ts-comment
       /** @ts-ignore */
       builder.addEdge(START, startNode);
@@ -1573,7 +1595,7 @@ export class MultiAgentGraph extends StandardGraph {
      */
     const edgesByDestination = new Map<string, t.GraphEdge[]>();
 
-    for (const edge of this.directEdges) {
+    for (const edge of directEdges) {
       const destinations = Array.isArray(edge.to) ? edge.to : [edge.to];
       for (const destination of destinations) {
         if (!edgesByDestination.has(destination)) {

package/src/hitl/approvalReview.ts

@@ -0,0 +1,209 @@
+import type { RunnableConfig } from '@langchain/core/runnables';
+import type {
+  ToolApprovalInterruptPayload,
+  ToolApprovalRequest,
+  ToolApprovalReviewConfig,
+} from '@/types/hitl';
+import { stableStringify } from '@/tools/eagerEventExecution';
+import { isToolApprovalInterrupt } from '@/types/hitl';
+
+/**
+ * Private resume-only config entry populated from the checkpointed interrupt.
+ * Hosts must never need to construct or inspect this value.
+ */
+export const TOOL_APPROVAL_REVIEW_CONFIG_KEY =
+  '__librechat_tool_approval_review';
+
+export interface ToolApprovalReviewEvidence {
+  interruptId: string;
+  payload: ToolApprovalInterruptPayload;
+  owner?: string;
+}
+
+export interface ReviewedToolApproval {
+  request: ToolApprovalRequest;
+  reviewConfig: ToolApprovalReviewConfig;
+}
+
+const APPROVAL_DECISIONS = new Set(['approve', 'reject', 'edit', 'respond']);
+
+/** Detach approval payloads from host- or transport-owned object graphs. */
+export function cloneToolApprovalInterruptPayload<T>(payload: T): T {
+  return isToolApprovalInterrupt(payload) ? structuredClone(payload) : payload;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return value != null && typeof value === 'object' && !Array.isArray(value);
+}
+
+function hasValidApprovalShape(payload: ToolApprovalInterruptPayload): boolean {
+  if (
+    !Array.isArray(payload.action_requests) ||
+    !Array.isArray(payload.review_configs) ||
+    payload.action_requests.length !== payload.review_configs.length
+  ) {
+    return false;
+  }
+
+  const toolCallIds = new Set<string>();
+  return payload.action_requests.every((request, index) => {
+    const reviewConfig = payload.review_configs[index];
+    if (!isRecord(request) || !isRecord(reviewConfig)) {
+      return false;
+    }
+    const toolCallId = request.tool_call_id;
+    const toolName = request.name;
+    const allowedDecisions = reviewConfig.allowed_decisions;
+    if (
+      typeof toolCallId !== 'string' ||
+      toolCallId.length === 0 ||
+      toolCallIds.has(toolCallId) ||
+      typeof toolName !== 'string' ||
+      toolName.length === 0 ||
+      !isRecord(request.arguments) ||
+      (request.description != null &&
+        typeof request.description !== 'string') ||
+      reviewConfig.tool_call_id !== toolCallId ||
+      reviewConfig.action_name !== toolName ||
+      !Array.isArray(allowedDecisions) ||
+      !allowedDecisions.every(
+        (decision) =>
+          typeof decision === 'string' && APPROVAL_DECISIONS.has(decision)
+      )
+    ) {
+      return false;
+    }
+    toolCallIds.add(toolCallId);
+    return true;
+  });
+}
+
+/** Build trusted review evidence from the interrupt restored by `Run`. */
+export function createToolApprovalReviewEvidence(
+  interruptId: string | undefined,
+  payload: unknown,
+  owner?: string
+): ToolApprovalReviewEvidence | undefined {
+  if (
+    typeof interruptId !== 'string' ||
+    interruptId.length === 0 ||
+    !isToolApprovalInterrupt(payload) ||
+    !hasValidApprovalShape(payload)
+  ) {
+    return undefined;
+  }
+  return {
+    interruptId,
+    payload: cloneToolApprovalInterruptPayload(payload),
+    ...(owner == null ? {} : { owner }),
+  };
+}
+
+/** Read only well-shaped evidence from a ToolNode's runnable config. */
+export function getToolApprovalReviewEvidence(
+  config: RunnableConfig,
+  owner?: string
+): ToolApprovalReviewEvidence | undefined {
+  const candidate = config.configurable?.[TOOL_APPROVAL_REVIEW_CONFIG_KEY];
+  if (candidate == null || typeof candidate !== 'object') {
+    return undefined;
+  }
+  const {
+    interruptId,
+    payload,
+    owner: evidenceOwner,
+  } = candidate as {
+    interruptId?: unknown;
+    payload?: unknown;
+    owner?: unknown;
+  };
+  if (
+    evidenceOwner != null &&
+    (typeof evidenceOwner !== 'string' ||
+      (owner != null && owner !== evidenceOwner))
+  ) {
+    return undefined;
+  }
+  return createToolApprovalReviewEvidence(
+    typeof interruptId === 'string' ? interruptId : undefined,
+    payload,
+    typeof evidenceOwner === 'string' ? evidenceOwner : undefined
+  );
+}
+
+export function getReviewedToolApproval(
+  payload: ToolApprovalInterruptPayload | undefined,
+  toolCallId: string | undefined
+): ReviewedToolApproval | undefined {
+  if (payload == null || toolCallId == null || toolCallId === '') {
+    return undefined;
+  }
+  const request = payload.action_requests.find(
+    (candidate) => candidate.tool_call_id === toolCallId
+  );
+  const reviewConfig = payload.review_configs.find(
+    (candidate) => candidate.tool_call_id === toolCallId
+  );
+  if (request == null || reviewConfig == null) {
+    return undefined;
+  }
+  return { request, reviewConfig };
+}
+
+function decisionsEqual(
+  left: ReadonlyArray<string>,
+  right: ReadonlyArray<string>
+): boolean {
+  if (left.length !== right.length) {
+    return false;
+  }
+  const sortedLeft = [...left].sort();
+  const sortedRight = [...right].sort();
+  return sortedLeft.every((value, index) => value === sortedRight[index]);
+}
+
+/**
+ * Bind a resume decision to the exact proposal the reviewer saw. Description
+ * text is deliberately excluded: it explains policy but cannot change the
+ * side effect. Tool identity, normalized arguments and available decisions
+ * are execution-authoritative.
+ */
+export function toolApprovalProposalMatches(
+  current: ReviewedToolApproval,
+  reviewed: ReviewedToolApproval
+): boolean {
+  return (
+    current.request.tool_call_id === reviewed.request.tool_call_id &&
+    current.request.name === reviewed.request.name &&
+    current.reviewConfig.tool_call_id === reviewed.reviewConfig.tool_call_id &&
+    current.reviewConfig.action_name === reviewed.reviewConfig.action_name &&
+    stableStringify(current.request.arguments) ===
+      stableStringify(reviewed.request.arguments) &&
+    decisionsEqual(
+      current.reviewConfig.allowed_decisions,
+      reviewed.reviewConfig.allowed_decisions
+    )
+  );
+}
+
+/** Preserve batch order as part of the decision-to-request binding. */
+export function toolApprovalPayloadMatches(
+  current: ToolApprovalInterruptPayload,
+  reviewed: ToolApprovalInterruptPayload
+): boolean {
+  if (
+    current.action_requests.length !== reviewed.action_requests.length ||
+    current.review_configs.length !== reviewed.review_configs.length
+  ) {
+    return false;
+  }
+  return current.action_requests.every((request, index) => {
+    const currentReviewConfig = current.review_configs[index];
+    const reviewedRequest = reviewed.action_requests[index];
+    const reviewedReviewConfig = reviewed.review_configs[index];
+    return toolApprovalProposalMatches(
+      { request, reviewConfig: currentReviewConfig },
+      { request: reviewedRequest, reviewConfig: reviewedReviewConfig }
+    );
+  });
+}

package/src/hooks/types.ts

@@ -252,13 +252,16 @@ export interface PreCompactHookInput extends BaseHookInput {
   /**
    * What triggered compaction. Matches `SummarizationTrigger.type` from the
    * agent's summarization config. `'default'` means no trigger was
-   * configured and compaction fired because messages were pruned.
+   * configured and compaction fired because messages were pruned;
+   * `'manual'` means the host asked for the summary outright and no trigger
+   * was evaluated.
    */
   trigger:
     | 'token_ratio'
     | 'remaining_tokens'
     | 'messages_to_refine'
     | 'default'
+    | 'manual'
     | (string & {});
 }
 

package/src/index.ts

@@ -3,6 +3,7 @@ export * from './run';
 export * from './stream';
 export * from './events';
 export * from './messages';
+export { LANGFUSE_OBSERVATION_METADATA_ARTIFACT_KEY } from './langfuseToolOutputTracing';
 
 /* Graphs */
 export * from './graphs';

package/src/langfuse.ts

@@ -1,3 +1,4 @@
+import { tool } from '@langchain/core/tools';
 import { CallbackHandler } from '@langfuse/langchain';
 import { LangfuseOtelContextKeys } from '@langfuse/core';
 import { AIMessage, AIMessageChunk } from '@langchain/core/messages';
@@ -18,6 +19,7 @@ import type {
   LLMResult,
 } from '@langchain/core/outputs';
 import type { PropagateAttributesParams } from '@langfuse/tracing';
+import type { RunnableConfig } from '@langchain/core/runnables';
 import type { Context, SpanContext } from '@opentelemetry/api';
 import type { ResolvedLangfuseToolOutputTracingConfig } from '@/langfuseRuntimeContext';
 import type * as t from '@/types';
@@ -39,10 +41,15 @@ import {
   registerLangfuseManagedSpan,
   resolveLangfuseDestinationKey,
 } from '@/langfuseSpanRegistry';
+import {
+  getToolObservationMetadata,
+  LANGFUSE_TOOL_OUTPUT_REDACTION_TEXT,
+} from '@/langfuseToolOutputTracing';
 import {
   readPreemptRestartedRun,
   PREEMPT_RESTART_CONTROL_FLOW,
 } from '@/llm/preempt';
+import { filterCallbacks, findCallback } from '@/utils/callbacks';
 import { isPresent, parseBooleanEnv } from '@/utils/misc';
 
 export {
@@ -306,10 +313,10 @@ class ScopedLangfuseCallbackHandler extends CallbackHandler {
   private deferredRootStarted = false;
   private deferredRootOutcome:
     | {
-      type: 'end';
-      output: Parameters<CallbackHandler['handleChainEnd']>[0];
-      parentRunId?: string;
-    }
+        type: 'end';
+        output: Parameters<CallbackHandler['handleChainEnd']>[0];
+        parentRunId?: string;
+      }
     | { type: 'error'; error: Error; parentRunId?: string }
     | undefined;
 
@@ -615,11 +622,7 @@ class ScopedLangfuseCallbackHandler extends CallbackHandler {
     this.deferredRootStarted = false;
     this.deferredRootOutcome = undefined;
     if (outcome.type === 'error') {
-      await super.handleChainError(
-        outcome.error,
-        runId,
-        outcome.parentRunId
-      );
+      await super.handleChainError(outcome.error, runId, outcome.parentRunId);
       return;
     }
     await super.handleChainEnd(outcome.output, runId, outcome.parentRunId);
@@ -1023,6 +1026,61 @@ export function isLangfuseCallbackHandler(value: unknown): boolean {
   return value instanceof CallbackHandler;
 }
 
+/** Host results have passed host output filters. Record only reserved metadata,
+ * not arguments, rows, errors, or attachments. These completion observations
+ * do not measure tool latency; execution timing belongs in the metadata. */
+export async function traceHostToolResults(
+  request: t.ToolExecuteBatchRequest,
+  results: t.ToolExecuteResult[],
+  config?: RunnableConfig
+): Promise<void> {
+  if (findCallback(config?.callbacks, isLangfuseCallbackHandler) == null) {
+    return;
+  }
+  const callbacks = filterCallbacks(
+    config?.callbacks,
+    isLangfuseCallbackHandler
+  );
+  const callsById = new Map(request.toolCalls.map((call) => [call.id, call]));
+  for (const result of results) {
+    const metadata = getToolObservationMetadata(result.artifact);
+    const call = callsById.get(result.toolCallId);
+    if (call == null || Object.keys(metadata).length === 0) {
+      continue;
+    }
+    const failure =
+      result.status === 'error'
+        ? new Error('Host tool execution failed')
+        : undefined;
+    const observation = tool(
+      async () => {
+        if (failure != null) {
+          throw failure;
+        }
+        return LANGFUSE_TOOL_OUTPUT_REDACTION_TEXT;
+      },
+      {
+        name: call.name,
+        description: 'Host tool execution metadata',
+        schema: { type: 'object', properties: {} },
+      }
+    );
+    try {
+      await observation.invoke(
+        { type: 'tool_call', id: call.id, name: call.name, args: {} },
+        {
+          callbacks,
+          metadata: { ...metadata, ...request.metadata },
+        }
+      );
+    } catch (error) {
+      if (failure == null || error !== failure) {
+        throw error;
+      }
+    }
+  }
+}
+
 export async function disposeLangfuseHandler(value: unknown): Promise<void> {
   if (value instanceof ScopedLangfuseCallbackHandler) {
     await value.finishDeferredRoot();

package/src/langfuseToolOutputTracing.ts

@@ -24,6 +24,9 @@ import { resolveToolOutputTracingConfigForSpan } from '@/langfuseRuntimeScope';
 
 export { LANGFUSE_TOOL_OUTPUT_REDACTION_TEXT, resolveLangfuseConfig };
 
+export const LANGFUSE_OBSERVATION_METADATA_ARTIFACT_KEY =
+  'librechatLangfuseObservationMetadata';
+
 const LANGGRAPH_TOOL_NODE_PREFIX = 'tools=';
 const SERVER_TOOL_RESULT_PREFIX = '{"serverToolResult":';
 const SERVER_TOOL_RESULT_REPLAY_MARKER_KEY = 'librechatResponsesReplay';
@@ -52,6 +55,9 @@ type RedactionContext = {
 };
 
 const TOOL_OUTPUT_FIELD_KEYS = ['content', 'artifact'];
+const MAX_OBSERVATION_METADATA_FIELDS = 32;
+const MAX_OBSERVATION_METADATA_STRING_LENGTH = 200;
+const OBSERVATION_METADATA_KEY_PATTERN = /^[A-Za-z][A-Za-z0-9_.-]{0,63}$/;
 
 type ResponsesReplayOutputDescriptor = {
   nestedOutputFields?: Readonly<Record<string, readonly string[]>>;
@@ -744,6 +750,90 @@ export function classifyLangfuseToolNodeSpan(span: ReadableSpan): void {
   classifyLangGraphToolNodeSpan((span as SpanWithAttributes).attributes);
 }
 
+function parseSerializedValue(value: unknown): unknown {
+  if (typeof value !== 'string') {
+    return value;
+  }
+  try {
+    return JSON.parse(value) as unknown;
+  } catch {
+    return undefined;
+  }
+}
+
+function getToolMessageArtifact(
+  value: unknown
+): Record<string, unknown> | undefined {
+  const parsed = parseSerializedValue(value);
+  if (!isRecord(parsed)) {
+    return undefined;
+  }
+  if (isRecord(parsed.artifact)) {
+    return parsed.artifact;
+  }
+  if (isRecord(parsed.kwargs) && isRecord(parsed.kwargs.artifact)) {
+    return parsed.kwargs.artifact;
+  }
+  return undefined;
+}
+
+export function getToolObservationMetadata(
+  artifact: unknown
+): Record<string, string | number | boolean> {
+  // This reserved artifact field is for trusted host adapters. Never copy
+  // arbitrary tool or model output into it without an explicit allowlist.
+  const metadata = isRecord(artifact)
+    ? artifact[LANGFUSE_OBSERVATION_METADATA_ARTIFACT_KEY]
+    : undefined;
+  const result: Record<string, string | number | boolean> = {};
+  if (!isRecord(metadata)) {
+    return result;
+  }
+
+  let promoted = 0;
+  for (const [key, value] of Object.entries(metadata)) {
+    if (
+      promoted >= MAX_OBSERVATION_METADATA_FIELDS ||
+      !OBSERVATION_METADATA_KEY_PATTERN.test(key) ||
+      !(
+        typeof value === 'number' ||
+        typeof value === 'boolean' ||
+        (typeof value === 'string' &&
+          value.length <= MAX_OBSERVATION_METADATA_STRING_LENGTH)
+      )
+    ) {
+      continue;
+    }
+    if (typeof value === 'number' && !Number.isFinite(value)) {
+      continue;
+    }
+    result[key] = value;
+    promoted += 1;
+  }
+  return result;
+}
+
+function promoteToolObservationMetadata(
+  span: ReadableSpan,
+  attributes: Record<string, unknown>,
+  config: ResolvedLangfuseToolOutputTracingConfig
+): void {
+  if (!isToolObservation(attributes) || !shouldRedactTool(span.name, config)) {
+    return;
+  }
+  const metadata = getToolObservationMetadata(
+    getToolMessageArtifact(
+      attributes[LangfuseOtelSpanAttributes.OBSERVATION_OUTPUT]
+    )
+  );
+  for (const [key, value] of Object.entries(metadata)) {
+    const attributeKey = `${LangfuseOtelSpanAttributes.OBSERVATION_METADATA}.${key}`;
+    if (!Object.prototype.hasOwnProperty.call(attributes, attributeKey)) {
+      attributes[attributeKey] = value;
+    }
+  }
+}
+
 function redactToolObservationOutput(
   span: ReadableSpan,
   attributes: Record<string, unknown>,
@@ -774,6 +864,7 @@ export function redactLangfuseSpanToolOutputs(
     return;
   }
 
+  promoteToolObservationMetadata(span, attributes, config);
   redactToolObservationOutput(span, attributes, config);
 
   for (const key of [

package/src/langfuseTraceShaping.ts

@@ -246,6 +246,18 @@ function findLastMessageText(value: unknown, role: string): string | undefined {
   return undefined;
 }
 
+/**
+ * A summarize-only run answers with its summary, carried in state as
+ * `manualSummary`, rather than with an assistant message.
+ */
+function getManualSummary(value: unknown): string | undefined {
+  if (!isRecord(value) || typeof value.manualSummary !== 'string') {
+    return undefined;
+  }
+  const text = value.manualSummary.trim();
+  return text === '' ? undefined : text;
+}
+
 function normalizeToolCall(value: unknown): SerializedToolCall | undefined {
   if (!isRecord(value)) {
     return undefined;
@@ -534,10 +546,11 @@ function shapeConversationPayload(span: MutableSpan): void {
     parseAttributeValue(span.attributes[inputKey]),
     'user'
   );
-  const answer = findLastMessageText(
-    parseAttributeValue(span.attributes[outputKey]),
-    'assistant'
-  );
+  const output = parseAttributeValue(span.attributes[outputKey]);
+  /** A summarize-only run's summary is its answer; any assistant message
+   *  still in state is an older reply the run retained, not its output. */
+  const answer =
+    getManualSummary(output) ?? findLastMessageText(output, 'assistant');
   /** A generation that IS the trace root — a bare `model.invoke` with no
    *  wrapping chain, i.e. the activity-label path — is also the only
    *  observation carrying its own prompt: reducing its observation input

package/src/llm/anthropic/utils/message_inputs.ts

@@ -39,6 +39,7 @@ import {
   serializeStructuredValueBounded,
 } from '@/utils/toolContent';
 import { HARD_MAX_TOOL_RESULT_CHARS } from '@/utils/truncation';
+import { isReasoningContentBlock } from '@/messages/reasoningTypes';
 import { Constants } from '@/common';
 
 type StandardTextBlock = Data.StandardTextBlock;
@@ -656,7 +657,6 @@ function _formatContent(message: BaseMessage) {
    * cross-provider handoff (e.g. Bedrock → Anthropic) we drop them rather than
    * forwarding an unusable block. The receiving model produces its own thinking.
    */
-  const foreignReasoningTypes = ['reasoning_content', 'reasoning', 'think'];
   /**
    * Google server-side tool blocks (`toolCall`/`toolResponse` parts from e.g.
    * URL context or Google Search). Only Google can execute these and validate
@@ -1049,7 +1049,7 @@ function _formatContent(message: BaseMessage) {
         };
       } else if (
         isAIMessage(message) &&
-        foreignReasoningTypes.some((t) => t === contentPart.type)
+        isReasoningContentBlock(contentPart)
       ) {
         // Foreign reasoning on an ASSISTANT turn (Bedrock `reasoning_content`,
         // Google `reasoning`, LibreChat `think`) carries provider-specific
@@ -1240,12 +1240,6 @@ function messagesHaveCacheControl(
   );
 }
 
-/** Anthropic rejects cache_control on these reasoning blocks. */
-const NON_CACHEABLE_PAYLOAD_BLOCK_TYPES = new Set([
-  'thinking',
-  'redacted_thinking',
-]);
-
 /**
  * Place one ephemeral `cache_control` on the last cacheable block of the final
  * message of an already-converted Anthropic payload. Used to re-anchor the tail
@@ -1287,8 +1281,9 @@ function reanchorTailCacheControl(
 
   let anchor = -1;
   for (let i = 0; i < content.length; i++) {
-    const type = (content[i] as { type?: string }).type;
-    if (type == null || NON_CACHEABLE_PAYLOAD_BLOCK_TYPES.has(type)) {
+    const block = content[i] as { type?: string };
+    const type = block.type;
+    if (type == null || isReasoningContentBlock(block)) {
       continue;
     }
     if (

package/src/llm/bedrock/utils/message_inputs.ts

@@ -30,6 +30,7 @@ import type {
 } from '../types';
 import { serializeStructuredValueBounded } from '@/utils/toolContent';
 import { HARD_MAX_TOOL_RESULT_CHARS } from '@/utils/truncation';
+import { isReasoningContentBlock } from '@/messages/reasoningTypes';
 
 /**
  * Reasoning blocks from other providers, relative to Bedrock. Bedrock's native
@@ -37,13 +38,6 @@ import { HARD_MAX_TOOL_RESULT_CHARS } from '@/utils/truncation';
  * signatures Bedrock cannot validate, so they are dropped on a cross-provider
  * handoff (e.g. Anthropic → Bedrock) rather than crashing the conversion.
  */
-const FOREIGN_REASONING_TYPES = [
-  'thinking',
-  'redacted_thinking',
-  'reasoning',
-  'think',
-];
-
 /**
  * Google server-side tool blocks (`toolCall`/`toolResponse` parts from e.g.
  * URL context or Google Search). Only Google can execute these and validate
@@ -797,7 +791,7 @@ function convertAIMessageToConverseMessage(msg: BaseMessage): BedrockMessage {
           contentBlocks.push({
             cachePoint,
           } as BedrockContentBlock);
-        } else if (FOREIGN_REASONING_TYPES.some((t) => t === block.type)) {
+        } else if (isReasoningContentBlock(block)) {
           // Reasoning from another provider (Anthropic `thinking`/
           // `redacted_thinking`, Google `reasoning`, LibreChat `think`).
           // Bedrock's native reasoning is `reasoning_content` (handled above); a