@librechat/agents 3.3.8 → 3.3.9

package/src/langfuseRuntimeScope.ts

@@ -8,8 +8,11 @@ import type * as t from '@/types';
 import {
   getLangfuseRuntimeConfig,
   getLangfuseRuntimeToolOutputTracingConfig,
+  getLangfuseScopeAgentId,
+  getLangfuseScopeRunId,
   getTraceIdSeed,
   hasLangfuseRuntimeContextValue,
+  replaceLangfuseRuntimeContext,
   runWithLangfuseRuntimeContext,
 } from '@/langfuseRuntimeContext';
 import {
@@ -24,6 +27,16 @@ export type ResolveLangfuseRuntimeScopeParams = {
   runLangfuse?: t.LangfuseConfig;
   langfuseOverlay?: t.LangfuseConfig;
   traceIdSeed?: string;
+  runId?: string;
+  agentId?: string;
+};
+
+export type LangfuseRuntimeScopeOptions = {
+  /** Replace the surrounding scope entirely instead of merging with it:
+   *  fields absent from `scope` are CLEARED rather than inherited. Required
+   *  when rejecting a foreign concurrent run's scope, whose explicit values
+   *  must not survive merge inheritance. */
+  replace?: boolean;
 };
 
 const langfuseToolOutputTracingConfigKey = createContextKey(
@@ -33,6 +46,8 @@ const langfuseConfigKey = createContextKey('librechat.langfuse.config');
 const langfuseTraceIdSeedKey = createContextKey(
   'librechat.langfuse.trace-id-seed'
 );
+const langfuseScopeRunIdKey = createContextKey('librechat.langfuse.run-id');
+const langfuseScopeAgentIdKey = createContextKey('librechat.langfuse.agent-id');
 
 function isRecord(value: unknown): value is Record<string, unknown> {
   return value != null && typeof value === 'object' && !Array.isArray(value);
@@ -75,6 +90,32 @@ export function resolveTraceIdSeedForSpan(
   return getTraceIdSeed() ?? getOtelTraceIdSeed(activeContext);
 }
 
+function getOtelScopeRunId(activeContext: Context): string | undefined {
+  const value = activeContext.getValue(langfuseScopeRunIdKey);
+  return typeof value === 'string' && value.trim() !== '' ? value : undefined;
+}
+
+function getOtelScopeAgentId(activeContext: Context): string | undefined {
+  const value = activeContext.getValue(langfuseScopeAgentIdKey);
+  return typeof value === 'string' && value.trim() !== '' ? value : undefined;
+}
+
+/** The run identity the active scope belongs to (see
+ *  `LangfuseRuntimeContext.runId`), or `undefined` for unstamped scopes. */
+export function resolveLangfuseScopeRunId(
+  activeContext: Context
+): string | undefined {
+  return getLangfuseScopeRunId() ?? getOtelScopeRunId(activeContext);
+}
+
+/** The agent identity of a per-agent overlay scope (see
+ *  `LangfuseRuntimeContext.agentId`), or `undefined` for run-level scopes. */
+export function resolveLangfuseScopeAgentId(
+  activeContext: Context
+): string | undefined {
+  return getLangfuseScopeAgentId() ?? getOtelScopeAgentId(activeContext);
+}
+
 export function resolveToolOutputTracingConfigForSpan(
   activeContext: Context
 ): ResolvedLangfuseToolOutputTracingConfig | undefined {
@@ -84,45 +125,77 @@ export function resolveToolOutputTracingConfigForSpan(
   );
 }
 
+function setOrClearContextValue(
+  activeContext: Context,
+  key: Parameters<Context['setValue']>[0],
+  value: unknown,
+  replace: boolean
+): Context {
+  if (value != null) {
+    return activeContext.setValue(key, value);
+  }
+  return replace ? activeContext.deleteValue(key) : activeContext;
+}
+
 export function withLangfuseRuntimeScope<T>(
   scope: LangfuseRuntimeScope,
-  action: () => T
+  action: () => T,
+  options?: LangfuseRuntimeScopeOptions
 ): T {
-  if (!hasLangfuseRuntimeContextValue(scope)) {
+  const replace = options?.replace === true;
+  if (!replace && !hasLangfuseRuntimeContextValue(scope)) {
     return action();
   }
 
   let activeContext = context.active();
-  if (scope.langfuse != null) {
-    activeContext = activeContext.setValue(langfuseConfigKey, scope.langfuse);
-  }
-  if (scope.toolOutputTracing != null) {
-    activeContext = activeContext.setValue(
-      langfuseToolOutputTracingConfigKey,
-      scope.toolOutputTracing
-    );
-  }
-  if (hasText(scope.traceIdSeed)) {
-    activeContext = activeContext.setValue(
-      langfuseTraceIdSeedKey,
-      scope.traceIdSeed
-    );
-  }
+  activeContext = setOrClearContextValue(
+    activeContext,
+    langfuseConfigKey,
+    scope.langfuse,
+    replace
+  );
+  activeContext = setOrClearContextValue(
+    activeContext,
+    langfuseToolOutputTracingConfigKey,
+    scope.toolOutputTracing,
+    replace
+  );
+  activeContext = setOrClearContextValue(
+    activeContext,
+    langfuseTraceIdSeedKey,
+    hasText(scope.traceIdSeed) ? scope.traceIdSeed : undefined,
+    replace
+  );
+  activeContext = setOrClearContextValue(
+    activeContext,
+    langfuseScopeRunIdKey,
+    hasText(scope.runId) ? scope.runId : undefined,
+    replace
+  );
+  activeContext = setOrClearContextValue(
+    activeContext,
+    langfuseScopeAgentIdKey,
+    hasText(scope.agentId) ? scope.agentId : undefined,
+    replace
+  );
 
   // Span processors receive the OTel parent context in `onStart`, while
   // LangChain callback handlers may run outside that context and need ALS.
   // The trace id generator reads the seed from ALS or OTel context so SDK
   // callbacks that preserve only one of those contexts still keep trace/score
   // cohesion.
-  return runWithLangfuseRuntimeContext(scope, () =>
-    context.with(activeContext, action)
-  );
+  const runScoped = replace
+    ? replaceLangfuseRuntimeContext
+    : runWithLangfuseRuntimeContext;
+  return runScoped(scope, () => context.with(activeContext, action));
 }
 
 export function resolveLangfuseRuntimeScope({
   runLangfuse,
   langfuseOverlay,
   traceIdSeed,
+  runId,
+  agentId,
 }: ResolveLangfuseRuntimeScopeParams): LangfuseRuntimeScope {
   const langfuse = resolveLangfuseConfig(runLangfuse, langfuseOverlay);
   const toolOutputTracing = !hasToolOutputTracingConfig(
@@ -131,5 +204,5 @@ export function resolveLangfuseRuntimeScope({
   )
     ? undefined
     : resolveToolOutputTracingConfig(runLangfuse, langfuseOverlay);
-  return { langfuse, traceIdSeed, toolOutputTracing };
+  return { langfuse, traceIdSeed, toolOutputTracing, runId, agentId };
 }

package/src/langfuseSpanRegistry.ts

@@ -0,0 +1,131 @@
+import { createHash } from 'node:crypto';
+import type { LangfuseSpanProcessorParams } from '@langfuse/otel';
+import type { Span } from '@opentelemetry/api';
+import type * as t from '@/types';
+import {
+  hasLangfuseConfigCredentials,
+  hasLangfuseEnvCredentials,
+  hasLangfuseEnvConfig,
+} from '@/langfuseConfig';
+import { isPresent } from '@/utils/misc';
+
+/**
+ * Spans created through the Langfuse tracer provider, keyed by the export
+ * destination they were routed to. Callback handlers use this to distinguish
+ * safe ambient parents from spans a root observation must not inherit:
+ *
+ * - Foreign spans (a host's own OpenTelemetry instrumentation, e.g. HTTP
+ *   server spans on the global provider) are never exported to Langfuse —
+ *   inheriting one orphans the trace root (its root/trace input-output
+ *   shaping is skipped), collapses concurrent runs inside one request
+ *   context into a single merged trace, and bypasses the seeded
+ *   deterministic trace id generator.
+ * - Langfuse-managed spans bound to a *different* destination (another
+ *   tenant's project) would leave the new trace dangling in its own
+ *   destination while inheriting the other tenant's trace id.
+ *
+ * Only a managed span whose destination matches the starting run's resolved
+ * destination is a safe parent — that is the sanctioned way for hosts to
+ * group runs under their own Langfuse observations.
+ */
+const managedSpanDestinations = new WeakMap<Span, string>();
+
+export function registerLangfuseManagedSpan(
+  span: Span,
+  destinationKey: string
+): void {
+  managedSpanDestinations.set(span, destinationKey);
+}
+
+export function getLangfuseManagedSpanDestination(
+  span: Span
+): string | undefined {
+  return managedSpanDestinations.get(span);
+}
+
+function resolveLangfuseEnvironment(
+  langfuse?: t.LangfuseConfig
+): string | undefined {
+  const candidates = [
+    langfuse?.environment,
+    process.env.LANGFUSE_TRACING_ENVIRONMENT,
+    process.env.NODE_ENV,
+  ];
+  for (const candidate of candidates) {
+    if (candidate != null && candidate.trim() !== '') {
+      return candidate.trim();
+    }
+  }
+  return undefined;
+}
+
+export function getLangfuseSpanProcessorParams(
+  langfuse?: t.LangfuseConfig
+): LangfuseSpanProcessorParams | undefined {
+  if (langfuse?.enabled === false) {
+    return undefined;
+  }
+  const environment = resolveLangfuseEnvironment(langfuse);
+  if (hasLangfuseConfigCredentials(langfuse)) {
+    return {
+      publicKey: langfuse.publicKey,
+      secretKey: langfuse.secretKey,
+      ...(isPresent(langfuse.baseUrl) ? { baseUrl: langfuse.baseUrl } : {}),
+      ...(isPresent(environment) ? { environment } : {}),
+    };
+  }
+  if (hasLangfuseEnvConfig()) {
+    const baseUrl =
+      langfuse?.baseUrl ??
+      process.env.LANGFUSE_BASE_URL ??
+      process.env.LANGFUSE_BASEURL;
+    return {
+      publicKey: process.env.LANGFUSE_PUBLIC_KEY as string,
+      secretKey: process.env.LANGFUSE_SECRET_KEY as string,
+      ...(isPresent(baseUrl) ? { baseUrl } : {}),
+      ...(isPresent(environment) ? { environment } : {}),
+    };
+  }
+  if (isPresent(langfuse?.baseUrl) && hasLangfuseEnvCredentials()) {
+    return {
+      publicKey: process.env.LANGFUSE_PUBLIC_KEY as string,
+      secretKey: process.env.LANGFUSE_SECRET_KEY as string,
+      baseUrl: langfuse.baseUrl,
+      ...(isPresent(environment) ? { environment } : {}),
+    };
+  }
+  return undefined;
+}
+
+function hashCacheKeyValue(value: string | undefined): string | undefined {
+  return isPresent(value)
+    ? createHash('sha256').update(value, 'utf8').digest('hex')
+    : undefined;
+}
+
+/**
+ * Identity of an export destination (project credentials + endpoint +
+ * environment) only. Processor-level policies like `toolOutputTracing` are
+ * deliberately excluded: two spans exporting to the same project under
+ * different redaction settings still share a destination and may parent one
+ * another.
+ */
+export function getLangfuseDestinationKey(
+  params: LangfuseSpanProcessorParams
+): string {
+  return JSON.stringify({
+    publicKey: params.publicKey,
+    secretKeyHash: hashCacheKeyValue(params.secretKey),
+    baseUrl: params.baseUrl,
+    environment: params.environment,
+  });
+}
+
+/** The export destination a run with this config resolves to, or `undefined`
+ *  when no Langfuse destination is configured. */
+export function resolveLangfuseDestinationKey(
+  langfuse?: t.LangfuseConfig
+): string | undefined {
+  const params = getLangfuseSpanProcessorParams(langfuse);
+  return params == null ? undefined : getLangfuseDestinationKey(params);
+}

package/src/langfuseTraceShaping.ts

@@ -1,5 +1,6 @@
 import { LangfuseOtelSpanAttributes } from '@langfuse/tracing';
 import type { ReadableSpan } from '@opentelemetry/sdk-trace-base';
+import { Constants } from '@/common';
 
 const LANGGRAPH_START_NODE = '__start__';
 const ANONYMOUS_LAMBDA_NAME = 'RunnableLambda';
@@ -10,8 +11,12 @@ const TOOL_DISPATCH_SPAN_NAME = 'tool-dispatch';
 const GENERATION_SPAN_NAME = 'llm';
 const ROOT_OBSERVATION_TYPE = 'agent';
 const CHAIN_OBSERVATION_TYPE = 'chain';
+const TOOL_OBSERVATION_TYPE = 'tool';
 const AGENT_TRACE_TAG = 'agent';
 const TITLE_TRACE_TAG = 'title';
+const EPHEMERAL_AGENT_SENDER_SEPARATOR = '___';
+const EPHEMERAL_AGENT_INDEX_SEPARATOR = '____';
+const OBSERVATION_METADATA_LANGGRAPH_NODE = `${LangfuseOtelSpanAttributes.OBSERVATION_METADATA}.langgraph_node`;
 
 type MutableSpan = ReadableSpan & {
   name: string;
@@ -175,17 +180,112 @@ function getMessageToolCalls(
   return calls;
 }
 
+/**
+ * Id-bearing `invalid_tool_calls` on the assistant turn. ToolNode pairs these
+ * with synthesized error results (and an invalid-only turn is routed on them
+ * alone), so the tool-dispatch span must count them as part of the executing
+ * batch — otherwise an invalid-only dispatch finds zero calls and the span
+ * keeps the full serialized graph state as its input, and a mixed dispatch
+ * silently omits the malformed call. `args` stays the raw unparsed string.
+ */
+/** Tool-result ids present in the serialized state — ToolNode's
+ *  `!toolMessageIds.has(id)` execution filter, mirrored for the span. */
+function getToolResultIds(
+  messages: Record<string, unknown>[]
+): Set<string> {
+  const ids = new Set<string>();
+  for (const message of messages) {
+    if (getMessageRole(message) !== 'tool') {
+      continue;
+    }
+    const rawId =
+      message.tool_call_id ??
+      (isRecord(message.kwargs) ? message.kwargs.tool_call_id : undefined) ??
+      (isRecord(message.data) ? message.data.tool_call_id : undefined);
+    if (typeof rawId === 'string' && rawId !== '') {
+      ids.add(rawId);
+    }
+  }
+  return ids;
+}
+
+function getMessageInvalidToolCalls(
+  message: Record<string, unknown>,
+  answeredIds: ReadonlySet<string>
+): SerializedToolCall[] {
+  const rawCalls =
+    message.invalid_tool_calls ??
+    (isRecord(message.kwargs) ? message.kwargs.invalid_tool_calls : undefined) ??
+    (isRecord(message.data) ? message.data.invalid_tool_calls : undefined);
+  if (!Array.isArray(rawCalls)) {
+    return [];
+  }
+  const calls: SerializedToolCall[] = [];
+  for (const rawCall of rawCalls) {
+    // Same attribution predicate ToolNode executes with (id-bearing,
+    // non-server) so the span never claims calls the node deliberately skips.
+    if (
+      !isRecord(rawCall) ||
+      typeof rawCall.id !== 'string' ||
+      rawCall.id === '' ||
+      answeredIds.has(rawCall.id) ||
+      rawCall.id.startsWith(Constants.ANTHROPIC_SERVER_TOOL_PREFIX)
+    ) {
+      continue;
+    }
+    // Same name fallback ToolNode synthesizes with — a nameless attributable
+    // call still gets a result, so it must still count in the span input.
+    const call = normalizeToolCall(
+      typeof rawCall.name === 'string' && rawCall.name !== ''
+        ? rawCall
+        : { ...rawCall, name: 'unknown' }
+    );
+    if (call != null) {
+      calls.push(call);
+    }
+  }
+  return calls;
+}
+
+/** The serialized message's own id (uuid), NOT the LC-serialization type id
+ *  array that `message.id` carries in constructor dumps. */
+function getSerializedMessageId(
+  message: Record<string, unknown>
+): string | undefined {
+  const kwargsId = isRecord(message.kwargs) ? message.kwargs.id : undefined;
+  const dataId = isRecord(message.data) ? message.data.id : undefined;
+  const rawId = message.id;
+  const id = kwargsId ?? dataId ?? rawId;
+  return typeof id === 'string' && id !== '' ? id : undefined;
+}
+
 /** Latest assistant turn's tool calls — the calls this tool node is executing. */
 function findPendingToolCalls(value: unknown): SerializedToolCall[] {
   const messages = getMessageArray(value);
   if (messages == null) {
     return [];
   }
+  /**
+   * Invalid calls count only where ToolNode's own gate lets them execute:
+   * the messages-state form (a bare-array state means the node returns a
+   * plain output list and skips invalid handling) with an id-bearing
+   * assistant message (no id, no reducer upsert). Mirrors
+   * `canPromoteInvalidCalls` so the span never reports skipped calls.
+   */
+  const invalidCallsApply = !Array.isArray(value);
+  const answeredIds = invalidCallsApply
+    ? getToolResultIds(messages)
+    : undefined;
   for (let i = messages.length - 1; i >= 0; i--) {
     if (getMessageRole(messages[i]) !== 'assistant') {
       continue;
     }
-    const calls = getMessageToolCalls(messages[i]);
+    const calls = [
+      ...getMessageToolCalls(messages[i]),
+      ...(invalidCallsApply && getSerializedMessageId(messages[i]) != null
+        ? getMessageInvalidToolCalls(messages[i], answeredIds!)
+        : []),
+    ];
     if (calls.length > 0) {
       return calls;
     }
@@ -254,11 +354,20 @@ function shapeRootSpan(span: MutableSpan): void {
     parseAttributeValue(span.attributes[outputKey]),
     'assistant'
   );
-  if (question != null) {
-    span.attributes[inputKey] = question;
-  }
-  if (answer != null) {
-    span.attributes[outputKey] = answer;
+  /** 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
+   *  would discard the SystemMessage from the one place it is traced.
+   *  Chain/agent roots keep the full reduction; their child generations
+   *  still record the complete prompt. Trace-level input/output reduce
+   *  either way, so the trace list keeps showing question and answer. */
+  if (!isGenerationSpan(span)) {
+    if (question != null) {
+      span.attributes[inputKey] = question;
+    }
+    if (answer != null) {
+      span.attributes[outputKey] = answer;
+    }
   }
   const traceInput = question ?? span.attributes[inputKey];
   const traceOutput = answer ?? span.attributes[outputKey];
@@ -275,6 +384,81 @@ function isGenerationSpan(span: MutableSpan): boolean {
   return typeof type === 'string' && type.toLowerCase() === 'generation';
 }
 
+function isToolSpan(span: MutableSpan): boolean {
+  const type = span.attributes[LangfuseOtelSpanAttributes.OBSERVATION_TYPE];
+  return (
+    typeof type === 'string' && type.toLowerCase() === TOOL_OBSERVATION_TYPE
+  );
+}
+
+/**
+ * Whether the span is a LangGraph node execution whose node id is the span
+ * name — the shape of the outer workflow-agent node. `@langfuse/tracing`
+ * flattens object metadata to per-key attributes with string values stored
+ * raw, so LangGraph's `langgraph_node` arrives directly comparable.
+ */
+function isWorkflowNodeSpan(span: MutableSpan): boolean {
+  return span.attributes[OBSERVATION_METADATA_LANGGRAPH_NODE] === span.name;
+}
+
+/**
+ * LibreChat ephemeral agents are identified as
+ * `endpoint__model___sender[____index]` (`__` encodes `:`; see LibreChat's
+ * `encodeEphemeralAgentId`), and the outer workflow node carries that id as
+ * its span name — so switching models renames the span (item 1). Returns the
+ * stable human `sender` segment only when the name matches that encoding:
+ * the `endpoint__model` prefix must contain both segments and — unlike
+ * display names such as `LibreChat Agent: Ops___EU` — never contains
+ * whitespace, so legitimate names that merely embed `___` are left alone.
+ */
+function extractEphemeralAgentSender(name: string): string | undefined {
+  let workingId = name;
+  const indexSeparator = workingId.lastIndexOf(EPHEMERAL_AGENT_INDEX_SEPARATOR);
+  if (
+    indexSeparator !== -1 &&
+    /^\d+$/.test(
+      workingId.slice(indexSeparator + EPHEMERAL_AGENT_INDEX_SEPARATOR.length)
+    )
+  ) {
+    workingId = workingId.slice(0, indexSeparator);
+  }
+  const senderSeparator = workingId.indexOf(EPHEMERAL_AGENT_SENDER_SEPARATOR);
+  if (senderSeparator <= 0) {
+    return undefined;
+  }
+  const encodedPrefix = workingId.slice(0, senderSeparator);
+  if (/\s/.test(encodedPrefix)) {
+    return undefined;
+  }
+  const prefixParts = encodedPrefix.split('__');
+  if (prefixParts.length < 2 || prefixParts.some((part) => part === '')) {
+    return undefined;
+  }
+  const sender = workingId
+    .slice(senderSeparator + EPHEMERAL_AGENT_SENDER_SEPARATOR.length)
+    .replace(/__/g, ':');
+  return sender === '' ? undefined : sender;
+}
+
+/** Workflow-agent node spans are always children of the run's root chain and
+ *  always carry `langgraph_node` metadata equal to their name, so host-named
+ *  run roots (`LibreChat Agent: <name>`) and ordinary chains that merely look
+ *  like encoded ids (`pipeline__stage___EU`) are never rename candidates.
+ *  Successful decodes become `agent` observations, matching the inner
+ *  `agent=<id>` node shaping. */
+function shapeEphemeralAgentNodeSpan(span: MutableSpan): void {
+  if (isToolSpan(span) || isRootSpan(span) || !isWorkflowNodeSpan(span)) {
+    return;
+  }
+  const sender = extractEphemeralAgentSender(span.name);
+  if (sender == null) {
+    return;
+  }
+  span.name = sender;
+  span.attributes[LangfuseOtelSpanAttributes.OBSERVATION_TYPE] =
+    ROOT_OBSERVATION_TYPE;
+}
+
 function hasTraceTag(span: MutableSpan, expectedTag: string): boolean {
   const tags = parseAttributeValue(
     span.attributes[LangfuseOtelSpanAttributes.TRACE_TAGS]
@@ -304,7 +488,8 @@ function shapeRootObservationType(span: MutableSpan): void {
  * Reshapes spans per Langfuse-team feedback before export:
  * - `agent=<id>` / `tools=<id>` node names carry the ephemeral agent id
  *   (`provider__model`) — strip it so switching models doesn't break
- *   name-based logic (item 1).
+ *   name-based logic (item 1). The outer workflow node is named with the
+ *   bare agent id; ephemeral ids reduce to their stable sender name.
  * - LLM generation spans keep the provider client class name (`ChatOpenAI`,
  *   `AzureChatOpenAI`, …); rename them to a provider-agnostic `llm` so the
  *   name reflects the operation, not the model (the model stays on the
@@ -324,6 +509,8 @@ export function shapeLangfuseSpan(span: ReadableSpan): void {
     shapeToolNodeSpan(mutable);
   } else if (isGenerationSpan(mutable)) {
     mutable.name = GENERATION_SPAN_NAME;
+  } else {
+    shapeEphemeralAgentNodeSpan(mutable);
   }
   if (!isRootSpan(span)) {
     return;

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

@@ -388,6 +388,44 @@ function _ensureMessageContents(
   return updatedMsgs as (SystemMessage | HumanMessage | AIMessage)[];
 }
 
+/**
+ * Anthropic requires `tool_use.input` to be a JSON object; anything else is
+ * rejected with a 400 (`tool_use.input: Input should be an object`).
+ * History can carry non-object inputs: streaming leaves the raw partial-JSON
+ * string on the content block, and upstream context projections can leave
+ * `null` (observed live on a summarization-retained tool call replayed after
+ * compaction). A string is parsed when it forms complete JSON; every other
+ * shape degrades to `{}` — the call already executed, so the replayed input
+ * is informational and an empty object is the safe representation.
+ */
+/** True for `{}` — no own enumerable keys on a non-array, non-null object. */
+function isEmptyPlainObject(value: unknown): boolean {
+  return (
+    typeof value === 'object' &&
+    value !== null &&
+    !Array.isArray(value) &&
+    Object.keys(value).length === 0
+  );
+}
+
+export function coerceAnthropicToolUseInput(
+  input: unknown
+): Record<string, unknown> {
+  let candidate: unknown = input;
+  if (typeof candidate === 'string') {
+    try {
+      candidate = JSON.parse(candidate);
+    } catch {
+      return {};
+    }
+  }
+  return typeof candidate === 'object' &&
+    candidate !== null &&
+    !Array.isArray(candidate)
+    ? (candidate as Record<string, unknown>)
+    : {};
+}
+
 export function _convertLangChainToolCallToAnthropic(
   toolCall: ToolCall
 ): AnthropicToolResponse {
@@ -401,7 +439,7 @@ export function _convertLangChainToolCallToAnthropic(
     type: isServerTool ? 'server_tool_use' : 'tool_use',
     id: isServerTool ? toolCall.id : normalizeAnthropicToolCallId(toolCall.id),
     name: toolCall.name,
-    input: toolCall.args,
+    input: coerceAnthropicToolUseInput(toolCall.args),
   };
 }
 
@@ -649,19 +687,11 @@ function _formatContent(message: BaseMessage) {
         'name' in contentPart
       ) {
         const rawPart = contentPart as Record<string, unknown>;
-        let input = rawPart.input ?? rawPart.args;
-        if (typeof input === 'string') {
-          try {
-            input = JSON.parse(input);
-          } catch {
-            input = {};
-          }
-        }
         const corrected: AnthropicServerToolUseBlockParam = {
           type: 'server_tool_use',
           id: rawPart.id as string,
           name: (rawPart.name ?? 'web_search') as 'web_search',
-          input: (input ?? {}) as Record<string, unknown>,
+          input: coerceAnthropicToolUseInput(rawPart.input ?? rawPart.args),
         };
         return corrected;
       }
@@ -916,10 +946,16 @@ function _formatContent(message: BaseMessage) {
         // Core's streaming aggregation can leave the inline tool_use input empty
         // (the assembled arguments live in `message.tool_calls` or, for persisted
         // messages, in sibling input_json_delta blocks). Restore it when missing.
+        // An empty plain object counts as missing too: context-pressure
+        // truncation degrades an inline input to `{}` while a small `args`
+        // mirror survives intact, and a genuinely empty call's mirror is also
+        // `{}`, so preferring the mirror never loses information.
         if (
           contentPartCopy.type === 'tool_use' &&
           typeof contentPartCopy.id === 'string' &&
-          (contentPartCopy.input === '' || contentPartCopy.input == null)
+          (contentPartCopy.input === '' ||
+            contentPartCopy.input == null ||
+            isEmptyPlainObject(contentPartCopy.input))
         ) {
           const matchingToolCall = isAIMessage(message)
             ? message.tool_calls?.find(
@@ -949,14 +985,29 @@ function _formatContent(message: BaseMessage) {
           }
         }
 
-        if ('input' in contentPartCopy) {
-          // Anthropic tool use inputs should be valid objects, when applicable.
-          if (typeof contentPartCopy.input === 'string') {
-            try {
-              contentPartCopy.input = JSON.parse(contentPartCopy.input);
-            } catch {
-              contentPartCopy.input = {};
-            }
+        if (
+          contentPartCopy.type === 'tool_use' ||
+          contentPartCopy.type === 'server_tool_use'
+        ) {
+          /**
+           * The API requires `input` to be a JSON object. Streaming leaves the
+           * raw partial-JSON string here, and context-pressure truncation can
+           * leave `null` on BOTH the block and its `tool_calls` mirror — so
+           * the restore above may itself restore a non-object. Coerce last,
+           * after every restore path has run.
+           */
+          contentPartCopy.input = coerceAnthropicToolUseInput(
+            'input' in contentPartCopy ? contentPartCopy.input : undefined
+          );
+        } else if (
+          'input' in contentPartCopy &&
+          typeof contentPartCopy.input === 'string'
+        ) {
+          // Non-tool_use tool blocks keep their legacy string handling.
+          try {
+            contentPartCopy.input = JSON.parse(contentPartCopy.input);
+          } catch {
+            contentPartCopy.input = {};
           }
         }