@librechat/agents 3.2.64 → 3.2.66

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

@@ -0,0 +1,471 @@
+/**
+ * Converts a raw Anthropic SSE event stream into LangChain ChatModelStreamEvents.
+ *
+ * @module
+ */
+
+import type {
+  ChatModelStreamEvent,
+  ContentBlockDelta,
+  FinishReason,
+} from '@langchain/core/language_models/event';
+import type { ContentBlock, UsageMetadata } from '@langchain/core/messages';
+import type {
+  AnthropicCompactionBlock,
+  AnthropicCompactionContentBlockDelta,
+  AnthropicMessageStreamEvent,
+} from '../types';
+import type { AnthropicUsageData } from './message_outputs';
+import { getAnthropicUsageMetadata } from './message_outputs';
+
+type AnthropicContentBlock =
+  | Extract<
+      AnthropicMessageStreamEvent,
+      { type: 'content_block_start' }
+    >['content_block']
+  | AnthropicCompactionBlock;
+
+type AnthropicContentDelta =
+  | Extract<
+      AnthropicMessageStreamEvent,
+      { type: 'content_block_delta' }
+    >['delta']
+  | AnthropicCompactionContentBlockDelta;
+
+interface AnthropicStreamErrorEvent {
+  type: 'error';
+  error: {
+    type: string;
+    message: string;
+  };
+  request_id?: string | null;
+}
+
+type AnthropicStreamInputEvent =
+  | AnthropicMessageStreamEvent
+  | AnthropicStreamErrorEvent;
+
+type BlockAccumulator = Record<string, unknown>;
+
+interface AnthropicEventUsage {
+  inputTokens: number;
+  cacheCreationInputTokens: number;
+  cacheReadInputTokens: number;
+  outputTokens: number;
+}
+
+// ─── Public API ─────────────────────────────────────────────────
+
+export interface ConvertAnthropicStreamOptions {
+  streamUsage?: boolean;
+}
+
+/**
+ * Convert an async iterable of raw Anthropic stream events into
+ * LangChain `ChatModelStreamEvent`s with typed deltas.
+ */
+export async function* convertAnthropicStream(
+  source: AsyncIterable<AnthropicStreamInputEvent>,
+  options: ConvertAnthropicStreamOptions = {}
+): AsyncGenerator<ChatModelStreamEvent> {
+  const shouldStreamUsage = options.streamUsage ?? true;
+
+  // Track accumulated state per content block (for finalization)
+  const blockAccumulators = new Map<number, BlockAccumulator>();
+  let usageSnapshot: UsageMetadata | undefined;
+  let eventUsage: AnthropicEventUsage | undefined;
+  let stopReason: string | null = null;
+
+  for await (const data of source) {
+    switch (data.type) {
+    // ── Message lifecycle ──────────────────────────────────
+    case 'message_start': {
+      const { usage, id, model } = data.message;
+      if (shouldStreamUsage) {
+        eventUsage = {
+          inputTokens: usage.input_tokens,
+          cacheCreationInputTokens: usage.cache_creation_input_tokens ?? 0,
+          cacheReadInputTokens: usage.cache_read_input_tokens ?? 0,
+          outputTokens: usage.output_tokens,
+        };
+        usageSnapshot = buildUsageSnapshot(eventUsage);
+      }
+      yield {
+        event: 'message-start' as const,
+        id,
+        ...(usageSnapshot ? { usage: usageSnapshot } : {}),
+      };
+      yield {
+        event: 'provider' as const,
+        provider: 'anthropic',
+        name: 'message_start',
+        payload: { model, id },
+      };
+      break;
+    }
+
+    case 'message_delta': {
+      stopReason = data.delta.stop_reason;
+      if (shouldStreamUsage) {
+        eventUsage = updateEventUsage(eventUsage, data.usage);
+        usageSnapshot = buildUsageSnapshot(eventUsage);
+        yield { event: 'usage' as const, usage: usageSnapshot };
+      }
+      if (
+        'context_management' in data.delta &&
+          data.delta.context_management != null
+      ) {
+        yield {
+          event: 'provider' as const,
+          provider: 'anthropic',
+          name: 'context_management',
+          payload: data.delta.context_management,
+        };
+      }
+      break;
+    }
+
+    case 'message_stop': {
+      const finishEvent = {
+        event: 'message-finish' as const,
+        reason: mapStopReason(stopReason),
+        ...(usageSnapshot ? { usage: usageSnapshot } : {}),
+        responseMetadata: { model_provider: 'anthropic' },
+      };
+      yield finishEvent;
+      break;
+    }
+
+    case 'error': {
+      const streamError = new Error(data.error.message);
+      streamError.name = data.error.type;
+      throw streamError;
+    }
+
+    // ── Content block lifecycle ───────────────────────────
+    case 'content_block_start': {
+      const { index, content_block } = data;
+      const mapped = mapBlockToContentBlock(content_block, index);
+      blockAccumulators.set(index, { ...mapped });
+      yield {
+        event: 'content-block-start' as const,
+        index,
+        content: mapped as unknown as ContentBlock,
+      };
+      break;
+    }
+
+    case 'content_block_delta': {
+      const { index, delta } = data;
+      const acc = blockAccumulators.get(index);
+      if (!acc) break;
+
+      const { contentDelta, accumulated } = applyAnthropicDelta(acc, delta);
+      blockAccumulators.set(index, accumulated);
+
+      yield {
+        event: 'content-block-delta' as const,
+        index,
+        delta: contentDelta,
+      };
+      break;
+    }
+
+    case 'content_block_stop': {
+      const { index } = data;
+      const acc = blockAccumulators.get(index);
+      if (!acc) break;
+
+      const finalized = finalizeBlock(acc);
+      yield {
+        event: 'content-block-finish' as const,
+        index,
+        content: finalized,
+      };
+      blockAccumulators.delete(index);
+      break;
+    }
+
+    // ── Unhandled → provider passthrough ───────────────────
+    default: {
+      const providerData = data as AnthropicMessageStreamEvent;
+      yield {
+        event: 'provider' as const,
+        provider: 'anthropic',
+        name: providerData.type,
+        payload: providerData,
+      };
+      break;
+    }
+    }
+  }
+}
+
+// ─── Internal helpers ───────────────────────────────────────────
+
+function mapStopReason(stopReason: string | null | undefined): FinishReason {
+  switch (stopReason) {
+  case 'end_turn':
+  case 'stop_sequence':
+    return 'stop';
+  case 'tool_use':
+    return 'tool_use';
+  case 'max_tokens':
+  case 'model_context_window_exceeded':
+    return 'length';
+  case 'refusal':
+    return 'content_filter';
+  default:
+    return 'stop';
+  }
+}
+
+function updateEventUsage(
+  previous: AnthropicEventUsage | undefined,
+  current: AnthropicUsageData
+): AnthropicEventUsage {
+  return {
+    inputTokens: getCumulativeUsageValue(
+      current.input_tokens,
+      previous?.inputTokens
+    ),
+    cacheCreationInputTokens: getCumulativeUsageValue(
+      current.cache_creation_input_tokens,
+      previous?.cacheCreationInputTokens
+    ),
+    cacheReadInputTokens: getCumulativeUsageValue(
+      current.cache_read_input_tokens,
+      previous?.cacheReadInputTokens
+    ),
+    outputTokens: getCumulativeUsageValue(
+      current.output_tokens,
+      previous?.outputTokens
+    ),
+  };
+}
+
+function getCumulativeUsageValue(
+  current: number | null | undefined,
+  previous: number | undefined
+): number {
+  return Math.max(previous ?? 0, current ?? 0);
+}
+
+function buildUsageSnapshot(usage: AnthropicEventUsage): UsageMetadata {
+  const metadata = getAnthropicUsageMetadata({
+    input_tokens: usage.inputTokens,
+    output_tokens: usage.outputTokens,
+    cache_creation_input_tokens: usage.cacheCreationInputTokens,
+    cache_read_input_tokens: usage.cacheReadInputTokens,
+  });
+  if (metadata == null) {
+    throw new Error('Anthropic usage metadata was not created');
+  }
+  return metadata;
+}
+
+function getStringField(record: BlockAccumulator, key: string): string {
+  const value = record[key];
+  return typeof value === 'string' ? value : '';
+}
+
+function getArrayField(record: BlockAccumulator, key: string): unknown[] {
+  const value = record[key];
+  return Array.isArray(value) ? value : [];
+}
+
+function mapBlockToContentBlock(
+  block: AnthropicContentBlock,
+  index: number
+): BlockAccumulator {
+  switch (block.type) {
+  case 'text':
+    return {
+      type: 'text' as const,
+      text: block.text,
+      ...(block.citations != null ? { citations: block.citations } : {}),
+      index,
+    };
+  case 'thinking':
+    return {
+      type: 'reasoning' as const,
+      reasoning: block.thinking,
+      index,
+    };
+  case 'redacted_thinking':
+    return { ...block, index };
+  case 'tool_use':
+    return {
+      type: 'tool_call_chunk' as const,
+      id: block.id,
+      name: block.name,
+      args: '',
+      index,
+    };
+  case 'server_tool_use':
+    return {
+      type: 'server_tool_call_chunk' as const,
+      id: block.id,
+      name: block.name,
+      args: '',
+      index,
+    };
+  case 'web_search_tool_result':
+    return { ...block, index };
+  case 'compaction':
+    return { ...block, index };
+  default:
+    return { type: 'non_standard' as const, value: { ...block }, index };
+  }
+}
+
+/**
+ * Map an Anthropic content_block_delta to a content block delta
+ * and update the accumulated state.
+ */
+function applyAnthropicDelta(
+  accumulated: BlockAccumulator,
+  delta: AnthropicContentDelta
+): {
+  contentDelta: ContentBlockDelta;
+  accumulated: BlockAccumulator;
+} {
+  const rawDelta = delta as unknown as Record<string, unknown>;
+  switch (delta.type) {
+  case 'text_delta':
+    return {
+      contentDelta: { type: 'text-delta' as const, text: delta.text },
+      accumulated: {
+        ...accumulated,
+        text: getStringField(accumulated, 'text') + delta.text,
+      },
+    };
+
+  case 'thinking_delta':
+    return {
+      contentDelta: {
+        type: 'reasoning-delta' as const,
+        reasoning: delta.thinking,
+      },
+      accumulated: {
+        ...accumulated,
+        reasoning: getStringField(accumulated, 'reasoning') + delta.thinking,
+      },
+    };
+
+  case 'input_json_delta': {
+    const newArgs = getStringField(accumulated, 'args') + delta.partial_json;
+    return {
+      contentDelta: {
+        type: 'block-delta' as const,
+        fields: {
+          type: getStringField(accumulated, 'type'),
+          args: newArgs,
+        },
+      },
+      accumulated: { ...accumulated, args: newArgs },
+    };
+  }
+
+  case 'citations_delta': {
+    const citations = [
+      ...getArrayField(accumulated, 'citations'),
+      delta.citation,
+    ];
+    return {
+      contentDelta: {
+        type: 'block-delta' as const,
+        fields: {
+          type: getStringField(accumulated, 'type'),
+          citations,
+        },
+      },
+      accumulated: {
+        ...accumulated,
+        citations,
+      },
+    };
+  }
+
+  case 'signature_delta':
+    return {
+      contentDelta: {
+        type: 'block-delta' as const,
+        fields: {
+          type: getStringField(accumulated, 'type'),
+          signature: delta.signature,
+        },
+      },
+      accumulated: { ...accumulated, signature: delta.signature },
+    };
+
+  case 'compaction_delta': {
+    const previousContent = accumulated.content;
+    const content =
+        delta.content == null
+          ? (previousContent ?? null)
+          : getStringField(accumulated, 'content') + delta.content;
+    return {
+      contentDelta: {
+        type: 'block-delta' as const,
+        fields: {
+          type: 'compaction',
+          content,
+          encrypted_content: delta.encrypted_content,
+        },
+      },
+      accumulated: {
+        ...accumulated,
+        content,
+        encrypted_content: delta.encrypted_content,
+      },
+    };
+  }
+
+  default:
+    return {
+      contentDelta: {
+        type: 'block-delta' as const,
+        fields: {
+          type: getStringField(accumulated, 'type'),
+          ...rawDelta,
+        },
+      },
+      accumulated,
+    };
+  }
+}
+
+function finalizeBlock(accumulated: BlockAccumulator): ContentBlock {
+  if (
+    accumulated.type === 'tool_call_chunk' ||
+    accumulated.type === 'server_tool_call_chunk'
+  ) {
+    const finalType =
+      accumulated.type === 'tool_call_chunk'
+        ? ('tool_call' as const)
+        : ('server_tool_call' as const);
+    const args = getStringField(accumulated, 'args');
+    let parsedArgs: unknown;
+    try {
+      parsedArgs = JSON.parse(args || '{}');
+    } catch {
+      return {
+        type: 'invalid_tool_call' as const,
+        id: getStringField(accumulated, 'id'),
+        name: getStringField(accumulated, 'name'),
+        args,
+        error: 'Failed to parse tool call arguments as JSON',
+      } as ContentBlock.Tools.InvalidToolCall;
+    }
+    return {
+      type: finalType,
+      id: getStringField(accumulated, 'id'),
+      name: getStringField(accumulated, 'name'),
+      args: parsedArgs,
+    } as ContentBlock;
+  }
+
+  const { index: _index, ...rest } = accumulated;
+  return rest as ContentBlock;
+}

package/src/llm/bedrock/utils/cross-provider-server-tools.test.ts

@@ -0,0 +1,122 @@
+import { AIMessage, HumanMessage } from '@langchain/core/messages';
+import type { BaseMessage } from '@langchain/core/messages';
+import { convertToConverseMessages } from './message_inputs';
+
+/**
+ * Regression for cross-provider agent handoffs (Google → Bedrock): a Gemini
+ * turn that used a server-side tool (URL context, Google Search) leaves
+ * `toolCall`/`toolResponse` content blocks in history. The Bedrock Converse
+ * converter has no branch for them and previously threw
+ * "Unsupported content block type: toolCall", crashing the handoff. Only
+ * Google can execute these blocks or validate their thought signatures, so
+ * they are dropped on assistant turns; any other unknown block still throws.
+ */
+type ConverseResult = ReturnType<typeof convertToConverseMessages>;
+
+/** Minimal view of a converted Bedrock Converse content block the assertions read. */
+interface ConverseBlock {
+  text?: string;
+  toolUse?: {
+    toolUseId?: string;
+    name?: string;
+    input?: Record<string, string>;
+  };
+}
+
+const assistantContent = (result: ConverseResult): ConverseBlock[] => {
+  const msg = result.converseMessages.find((m) => m.role === 'assistant');
+  return (msg?.content ?? []) as ConverseBlock[];
+};
+
+describe('convertToConverseMessages — Google server-side tool blocks (Google → Bedrock)', () => {
+  it('drops toolCall/toolResponse on an assistant turn, keeping text and tool calls', () => {
+    const messages: BaseMessage[] = [
+      new HumanMessage('summarize this article'),
+      new AIMessage({
+        content: [
+          {
+            type: 'toolCall',
+            thoughtSignature: 'google-signature-not-valid-for-bedrock',
+            toolCall: {
+              toolType: 'URL_CONTEXT',
+              args: { urls: ['https://example.com/report'] },
+              id: 'j7pfyr6k',
+            },
+          },
+          {
+            type: 'toolResponse',
+            toolResponse: {
+              toolType: 'URL_CONTEXT',
+              id: 'j7pfyr6k',
+              result: { status: 'SUCCESS' },
+            },
+          },
+          {
+            type: 'text',
+            text: 'The article argues for dollar-cost averaging.',
+          },
+        ],
+        tool_calls: [
+          {
+            id: 'call_client_tool',
+            name: 'save_note',
+            args: { note: 'DCA summary' },
+            type: 'tool_call',
+          },
+        ],
+      }),
+    ];
+
+    expect(() => convertToConverseMessages(messages)).not.toThrow();
+    const content = assistantContent(convertToConverseMessages(messages));
+
+    const serialized = JSON.stringify(content);
+    expect(serialized).not.toContain('URL_CONTEXT');
+    expect(serialized).not.toContain('google-signature-not-valid-for-bedrock');
+
+    expect(
+      content.some(
+        (b) => b.text === 'The article argues for dollar-cost averaging.'
+      )
+    ).toBe(true);
+    const toolUse = content.find((b) => b.toolUse != null);
+    expect(toolUse?.toolUse).toMatchObject({
+      toolUseId: 'call_client_tool',
+      name: 'save_note',
+      input: { note: 'DCA summary' },
+    });
+  });
+
+  it('emits a placeholder (not empty content) when a server-tool-only turn is fully dropped', () => {
+    const messages: BaseMessage[] = [
+      new HumanMessage('hi'),
+      new AIMessage({
+        content: [
+          {
+            type: 'toolCall',
+            toolCall: { toolType: 'URL_CONTEXT', args: { urls: [] }, id: 'x1' },
+          },
+        ],
+      }),
+    ];
+    expect(() => convertToConverseMessages(messages)).not.toThrow();
+    const content = assistantContent(convertToConverseMessages(messages));
+    expect(content.length).toBeGreaterThan(0);
+    expect(content.every((b) => typeof b.text === 'string')).toBe(true);
+  });
+
+  it('still throws on a genuinely unknown assistant block', () => {
+    const messages: BaseMessage[] = [
+      new HumanMessage('run code'),
+      new AIMessage({
+        content: [
+          { type: 'some_future_block_type', foo: 'bar' },
+          { type: 'text', text: 'done' },
+        ],
+      }),
+    ];
+    expect(() => convertToConverseMessages(messages)).toThrow(
+      'Unsupported content block type'
+    );
+  });
+});

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

@@ -41,6 +41,14 @@ const FOREIGN_REASONING_TYPES = [
   'think',
 ];
 
+/**
+ * Google server-side tool blocks (`toolCall`/`toolResponse` parts from e.g.
+ * URL context or Google Search). Only Google can execute these and validate
+ * their thought signatures, so they are dropped on a cross-provider handoff
+ * (e.g. Google → Bedrock); the assistant's answer text is kept.
+ */
+const FOREIGN_SERVER_TOOL_TYPES = ['toolCall', 'toolResponse'];
+
 /**
  * Bedrock Converse rejects assistant messages with no content blocks. When
  * filtering (e.g. dropping foreign reasoning) empties an assistant turn that
@@ -727,6 +735,11 @@ function convertAIMessageToConverseMessage(msg: BaseMessage): BedrockMessage {
           // than crash. The Bedrock model produces its own reasoning. Anything
           // else unknown still throws below — real content must be surfaced.
           return;
+        } else if (FOREIGN_SERVER_TOOL_TYPES.some((t) => t === block.type)) {
+          // Google server-side tool call/response (e.g. URL context) — only
+          // Google can execute it or validate its thought signature; drop it
+          // on a cross-provider handoff rather than crash.
+          return;
         } else {
           const blockValues = Object.fromEntries(
             Object.entries(block).filter(([key]) => key !== 'type')

package/src/specs/langfuse-instrumentation.test.ts

@@ -184,6 +184,70 @@ describe('Langfuse instrumentation', () => {
     expect(mockBasicTracerProvider).toHaveBeenCalledTimes(1);
   });
 
+  it('resolves environment from LANGFUSE_TRACING_ENVIRONMENT', async () => {
+    process.env.LANGFUSE_TRACING_ENVIRONMENT = 'staging';
+
+    const { initializeLangfuseTracing } = await import('@/instrumentation');
+    initializeLangfuseTracing({
+      publicKey: 'pk-config',
+      secretKey: 'sk-config',
+      baseUrl: 'https://langfuse.config',
+    });
+
+    expect(mockLangfuseSpanProcessor).toHaveBeenCalledWith(
+      expect.objectContaining({ environment: 'staging' })
+    );
+  });
+
+  it('falls back to NODE_ENV when LANGFUSE_TRACING_ENVIRONMENT is unset', async () => {
+    delete process.env.LANGFUSE_TRACING_ENVIRONMENT;
+    process.env.NODE_ENV = 'production';
+
+    const { initializeLangfuseTracing } = await import('@/instrumentation');
+    initializeLangfuseTracing({
+      publicKey: 'pk-config',
+      secretKey: 'sk-config',
+      baseUrl: 'https://langfuse.config',
+    });
+
+    expect(mockLangfuseSpanProcessor).toHaveBeenCalledWith(
+      expect.objectContaining({ environment: 'production' })
+    );
+  });
+
+  it('falls through blank environment overrides and trims the selected value', async () => {
+    process.env.LANGFUSE_TRACING_ENVIRONMENT = '   ';
+    process.env.NODE_ENV = ' production ';
+
+    const { initializeLangfuseTracing } = await import('@/instrumentation');
+    initializeLangfuseTracing({
+      publicKey: 'pk-config',
+      secretKey: 'sk-config',
+      baseUrl: 'https://langfuse.config',
+      environment: '',
+    });
+
+    expect(mockLangfuseSpanProcessor).toHaveBeenCalledWith(
+      expect.objectContaining({ environment: 'production' })
+    );
+  });
+
+  it('prefers an explicit config environment over environment variables', async () => {
+    process.env.LANGFUSE_TRACING_ENVIRONMENT = 'staging';
+
+    const { initializeLangfuseTracing } = await import('@/instrumentation');
+    initializeLangfuseTracing({
+      publicKey: 'pk-config',
+      secretKey: 'sk-config',
+      baseUrl: 'https://langfuse.config',
+      environment: 'canary',
+    });
+
+    expect(mockLangfuseSpanProcessor).toHaveBeenCalledWith(
+      expect.objectContaining({ environment: 'canary' })
+    );
+  });
+
   it('does not replace the global provider when explicit credentials change', async () => {
     const { initializeLangfuseTracing } = await import('@/instrumentation');
     initializeLangfuseTracing({