@librechat/agents 3.7.22 → 3.8.1

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/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);
@@ -895,6 +898,18 @@ function mergeLangfuseTags(
   return merged.length > 0 ? [...new Set(merged)] : undefined;
 }
 
+/**
+ * The trace's user identity: the host-configured `langfuse.userId` when
+ * present, else the caller's (normally `configurable.user_id`).
+ */
+export function resolveLangfuseTraceUserId(
+  langfuse: t.LangfuseConfig | undefined,
+  userId: string | undefined
+): string | undefined {
+  const configured = langfuse?.userId?.trim();
+  return isPresent(configured) ? configured : userId;
+}
+
 export function getLangfuseTraceName(
   traceMetadata?: LangfuseTraceMetadata,
   fallback: string = 'LibreChat Agent'
@@ -942,7 +957,7 @@ export function createLangfuseHandler({
     return undefined;
   }
   return new ScopedLangfuseCallbackHandler({
-    userId,
+    userId: resolveLangfuseTraceUserId(langfuse, userId),
     sessionId,
     traceMetadata:
       inheritTraceIdentity === true
@@ -972,7 +987,10 @@ function createPropagateAttributeParams({
   inheritTraceIdentity,
 }: LangfuseAttributeParams): PropagateAttributesParams {
   return {
-    userId: inheritTraceIdentity === true ? undefined : userId,
+    userId:
+      inheritTraceIdentity === true
+        ? undefined
+        : resolveLangfuseTraceUserId(langfuse, userId),
     sessionId: inheritTraceIdentity === true ? undefined : sessionId,
     traceName: inheritTraceIdentity === true ? undefined : traceName,
     tags: mergeLangfuseTags(tags, langfuse?.tags),
@@ -1008,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

package/src/llm/contextPressureMeter.ts

@@ -9,7 +9,8 @@ import {
   REPLY_PRIMER_TOKENS,
   isSyntheticProviderContextMessage,
 } from '@/messages';
-import { apportionTokenCounts } from '@/utils';
+import { createToolMessageUsageAccumulator } from '@/messages/budget';
+import { readTokenMetadataProperty, apportionTokenCounts } from '@/utils';
 
 interface ContextPressureUsage {
   contextBudget?: number;
@@ -19,6 +20,7 @@ interface ContextPressureUsage {
 }
 
 interface ContextPressureMeterParams {
+  provider?: t.ProviderName;
   tokenCounter?: t.TokenCounter;
   tokenCountCache?: ExactTokenCountCache;
   sourceMessages: BaseMessage[];
@@ -89,6 +91,21 @@ function readDataProperty(
     : { own: true, safe: false };
 }
 
+function readCacheMetadataProperty(
+  owner: object,
+  property: PropertyKey,
+  path: string
+): { safe: boolean; value?: unknown } {
+  try {
+    return {
+      safe: true,
+      value: readTokenMetadataProperty(owner, property, path),
+    };
+  } catch {
+    return { safe: false };
+  }
+}
+
 function getStableTokenSurface(
   message: BaseMessage
 ): StableTokenSurface | undefined {
@@ -105,10 +122,13 @@ function getStableTokenSurface(
   }
   const messageType = message.getType();
   const roleProperty = readDataProperty(message, 'role');
-  if (!roleProperty.safe || (!roleProperty.own && 'role' in message)) {
+  const resolvedRoleProperty = roleProperty.own
+    ? roleProperty
+    : readCacheMetadataProperty(message, 'role', 'message.role');
+  if (!resolvedRoleProperty.safe) {
     return undefined;
   }
-  const role = roleProperty.value;
+  const role = resolvedRoleProperty.value;
   if (role != null && typeof role !== 'string') {
     return undefined;
   }
@@ -129,6 +149,14 @@ function getStableTokenSurface(
     return undefined;
   }
   const additionalKwargs = rawAdditionalKwargs;
+  const rawToolCalls = readCacheMetadataProperty(
+    additionalKwargs,
+    'tool_calls',
+    'additional_kwargs.tool_calls'
+  );
+  if (!rawToolCalls.safe || rawToolCalls.value != null) {
+    return undefined;
+  }
   const typeProperty = readDataProperty(additionalKwargs, 'type');
   if (!typeProperty.safe) {
     return undefined;
@@ -138,16 +166,16 @@ function getStableTokenSurface(
       message as AIMessage,
       'tool_calls'
     );
-    if (
-      !toolCallsProperty.safe ||
-      (!toolCallsProperty.own && 'tool_calls' in message)
-    ) {
+    const resolvedToolCallsProperty = toolCallsProperty.own
+      ? toolCallsProperty
+      : readCacheMetadataProperty(message, 'tool_calls', 'message.tool_calls');
+    if (!resolvedToolCallsProperty.safe) {
       return undefined;
     }
-    const toolCalls = toolCallsProperty.value;
+    const toolCalls = resolvedToolCallsProperty.value;
     if (
       toolCalls != null &&
-      (!Array.isArray(toolCalls) || isProxy(toolCalls) || toolCalls.length > 0)
+      (isProxy(toolCalls) || !Array.isArray(toolCalls) || toolCalls.length > 0)
     ) {
       return undefined;
     }
@@ -230,6 +258,7 @@ function getProviderMessageOriginKey(message: BaseMessage): string | undefined {
 
 /** Measures repeated provider projections while tokenizing each message object once. */
 export function createContextPressureMeter({
+  provider,
   tokenCounter,
   tokenCountCache,
   sourceMessages,
@@ -382,6 +411,22 @@ export function createContextPressureMeter({
         ? availableMessageTokens -
           Math.min(availableMessageTokens, Math.max(0, baselineRemaining))
         : undefined;
+    const toolUsage = createToolMessageUsageAccumulator(provider);
+    const toolUsageState: { error?: Error } = {};
+    const addToolUsage = (
+      message: BaseMessage,
+      getRawTokens: () => number
+    ): void => {
+      if (toolUsageState.error != null) {
+        return;
+      }
+      try {
+        toolUsage.add(message, getRawTokens);
+      } catch (error) {
+        toolUsageState.error =
+          error instanceof Error ? error : new Error(String(error));
+      }
+    };
 
     let projectedMessageTokens: number;
     if (
@@ -423,15 +468,18 @@ export function createContextPressureMeter({
       const usedOrigins = new Set<number>();
       for (const message of messages) {
         const origin = origins.get(message);
+        let rawTokens: number | undefined;
+        const getRawTokens = (): number => (rawTokens ??= count(message));
+        addToolUsage(message, getRawTokens);
         if (origin == null || usedOrigins.has(origin)) {
-          newRawTokens += count(message);
+          newRawTokens += getRawTokens();
           continue;
         }
         usedOrigins.add(origin);
         const projectionDelta =
           message === baseline[origin].message
             ? 0
-            : count(message) - baseline[origin].rawTokens;
+            : getRawTokens() - baseline[origin].rawTokens;
         projectedMessageTokens += Math.max(
           0,
           attribution.attributedByOrigin[origin] +
@@ -442,16 +490,36 @@ export function createContextPressureMeter({
     } else {
       let rawTokens = REPLY_PRIMER_TOKENS;
       for (const message of messages) {
-        rawTokens += count(message);
+        const messageTokens = count(message);
+        addToolUsage(message, () => messageTokens);
+        rawTokens += messageTokens;
       }
       projectedMessageTokens = Math.round(rawTokens * usageRatio);
     }
+    let measuredToolUsage:
+      | Pick<
+          t.TokenBudgetBreakdown,
+          'toolMessageTokens' | 'toolMessageTokenCounts'
+        >
+      | undefined;
+    try {
+      measuredToolUsage =
+        toolUsageState.error == null ? toolUsage.finish(usageRatio) : undefined;
+    } catch (error) {
+      toolUsageState.error =
+        error instanceof Error ? error : new Error(String(error));
+      measuredToolUsage = undefined;
+    }
     return {
       fits: projectedMessageTokens <= availableMessageTokens,
       projectedMessageTokens,
       availableMessageTokens,
       contextBudget,
       effectiveInstructionTokens,
+      ...measuredToolUsage,
+      ...(toolUsageState.error == null
+        ? {}
+        : { toolMessageUsageError: toolUsageState.error }),
     };
   };