@librechat/agents 3.2.68 → 3.3.1

package/src/specs/bedrock-toolless.live.test.ts

@@ -0,0 +1,123 @@
+// src/specs/bedrock-toolless.live.test.ts
+/**
+ * Live Bedrock verification for the tool-less-destination toolConfig fix.
+ *
+ * A tool-less agent in a multi-agent graph inherits the prior agent's
+ * toolUse/toolResult history. Because it binds no tools, Bedrock's Converse API
+ * rejects the request ("The toolConfig field must be defined when using toolUse
+ * and toolResult content blocks"). `foldToolBlocksForToollessAgent` folds that
+ * history into text so the request becomes valid.
+ *
+ * Run with:
+ * RUN_BEDROCK_LIVE_TESTS=1 BEDROCK_AWS_ACCESS_KEY_ID=... BEDROCK_AWS_SECRET_ACCESS_KEY=... \
+ *   BEDROCK_AWS_DEFAULT_REGION=us-west-2 npm test -- bedrock-toolless.live.test.ts --runInBand
+ */
+import { config as dotenvConfig } from 'dotenv';
+dotenvConfig();
+
+import {
+  AIMessage,
+  HumanMessage,
+  ToolMessage,
+} from '@langchain/core/messages';
+import { beforeAll, describe, expect, it } from '@jest/globals';
+import type { BaseMessage } from '@langchain/core/messages';
+import type * as t from '@/types';
+import { Providers } from '@/common';
+import { initializeModel } from '@/llm/init';
+import { foldToolBlocksForToollessAgent } from '@/messages';
+
+const accessKeyId =
+  process.env.BEDROCK_AWS_ACCESS_KEY_ID ?? process.env.AWS_ACCESS_KEY_ID;
+const secretAccessKey =
+  process.env.BEDROCK_AWS_SECRET_ACCESS_KEY ??
+  process.env.AWS_SECRET_ACCESS_KEY;
+
+const shouldRunLive =
+  process.env.RUN_BEDROCK_LIVE_TESTS === '1' &&
+  accessKeyId != null &&
+  accessKeyId !== '' &&
+  secretAccessKey != null &&
+  secretAccessKey !== '';
+
+const describeIfLive = shouldRunLive ? describe : describe.skip;
+
+const MODEL =
+  process.env.LIVE_BEDROCK_MODEL ??
+  'us.anthropic.claude-sonnet-4-5-20250929-v1:0';
+const REGION =
+  process.env.BEDROCK_AWS_DEFAULT_REGION ??
+  process.env.AWS_REGION ??
+  'us-west-2';
+
+/** History a tool-less destination inherits: a completed tool call, then a
+ *  follow-up user turn that itself invokes no tool. */
+function toollessHistory(): BaseMessage[] {
+  return [
+    new HumanMessage('Search my files for the roadmap.'),
+    new AIMessage({
+      content: '',
+      tool_calls: [
+        {
+          id: 'tt_live_1',
+          name: 'file_search',
+          args: { query: 'roadmap' },
+          type: 'tool_call',
+        },
+      ],
+    }),
+    new ToolMessage({
+      content: 'Found: roadmap.md — Q3 goals and milestones.',
+      tool_call_id: 'tt_live_1',
+      name: 'file_search',
+    }),
+    new AIMessage('I found roadmap.md with your Q3 goals.'),
+    new HumanMessage('thanks!'),
+  ];
+}
+
+describeIfLive('Bedrock tool-less destination (live)', () => {
+  let clientOptions: t.BedrockConverseClientOptions;
+
+  beforeAll(() => {
+    // Force SigV4 with the explicit keys; the Bedrock API-key (bearer) auth
+    // scheme otherwise takes precedence in the AWS SDK.
+    delete process.env.AWS_BEARER_TOKEN_BEDROCK;
+    // `shouldRunLive` already guarantees both keys are set; `?? ''` only keeps
+    // the credential fields typed as strings.
+    clientOptions = {
+      region: REGION,
+      model: MODEL,
+      credentials: {
+        accessKeyId: accessKeyId ?? '',
+        secretAccessKey: secretAccessKey ?? '',
+      },
+    };
+  });
+
+  it('rejects inherited tool history when the agent binds no tools', async () => {
+    const model = initializeModel({
+      provider: Providers.BEDROCK,
+      clientOptions,
+      tools: undefined,
+    });
+    await expect(model.invoke(toollessHistory())).rejects.toThrow(
+      /toolConfig field must be defined/i
+    );
+  }, 30000);
+
+  it('succeeds once inherited tool blocks are folded to text', async () => {
+    const model = initializeModel({
+      provider: Providers.BEDROCK,
+      clientOptions,
+      tools: undefined,
+    });
+    const folded = foldToolBlocksForToollessAgent(toollessHistory());
+    const res = await model.invoke(folded);
+    const text =
+      typeof res.content === 'string'
+        ? res.content
+        : JSON.stringify(res.content);
+    expect(text.length).toBeGreaterThan(0);
+  }, 30000);
+});

package/src/specs/context-overflow-recovery.live.test.ts

@@ -0,0 +1,213 @@
+/**
+ * Live end-to-end verification that a real provider rejection for an
+ * over-limit prompt is absorbed by forced compaction instead of surfacing.
+ *
+ * Each case deliberately configures `maxContextTokens` far above the model's
+ * real window, so the proactive pruner does not prevent the overflow and the
+ * reactive recovery path is what gets exercised.
+ *
+ * Run with:
+ * RUN_CONTEXT_OVERFLOW_LIVE_TESTS=1 OPENROUTER_API_KEY=... npm test -- context-overflow-recovery.live.test.ts --runInBand
+ *
+ * Cases self-skip when their provider credentials are absent. Models are the
+ * smallest-window, cheapest option per provider — the prompt has to exceed
+ * the window for the test to mean anything, so a large window is a large bill.
+ *
+ * The Bedrock case needs `NODE_OPTIONS='--experimental-vm-modules'`; the AWS
+ * SDK uses a dynamic import that jest otherwise refuses.
+ */
+import { config as dotenvConfig } from 'dotenv';
+dotenvConfig();
+
+import { HumanMessage } from '@langchain/core/messages';
+import { describe, expect, it, jest } from '@jest/globals';
+import type { BaseMessage } from '@langchain/core/messages';
+import type * as t from '@/types';
+import { createTokenCounter } from '@/utils/tokens';
+import { hasAnyEnv, hasEnv } from '@/specs/spec.utils';
+import { GraphEvents, Providers } from '@/common';
+import { Run } from '@/run';
+
+jest.setTimeout(300_000);
+
+const liveEnabled = process.env.RUN_CONTEXT_OVERFLOW_LIVE_TESTS === '1';
+
+interface LiveCase {
+  label: string;
+  provider: Providers;
+  model: string;
+  /** The model's real input window. */
+  contextWindow: number;
+  envKeys: readonly string[];
+  clientOptions: Record<string, unknown>;
+}
+
+const LIVE_CASES: readonly LiveCase[] = [
+  {
+    label: 'openrouter / qwen-2.5-7b (32k window)',
+    provider: Providers.OPENROUTER,
+    model: 'qwen/qwen-2.5-7b-instruct',
+    contextWindow: 32_768,
+    envKeys: ['OPENROUTER_API_KEY'],
+    clientOptions: {
+      apiKey: process.env.OPENROUTER_API_KEY,
+      configuration: {
+        baseURL:
+          process.env.OPENROUTER_BASE_URL ?? 'https://openrouter.ai/api/v1',
+      },
+    },
+  },
+  {
+    /**
+     * Google's text models all carry a ~1M window, which would make this the
+     * most expensive case in the file by an order of magnitude. This model
+     * accepts ordinary text and caps its input at 64k, so it exercises the
+     * same Gemini API rejection for a fraction of the tokens.
+     */
+    label: 'google / gemini-3.1-flash-image (64k window)',
+    provider: Providers.GOOGLE,
+    model: 'gemini-3.1-flash-image',
+    contextWindow: 65_536,
+    envKeys: ['GOOGLE_API_KEY', 'GEMINI_API_KEY'],
+    clientOptions: {
+      apiKey: process.env.GOOGLE_API_KEY ?? process.env.GEMINI_API_KEY,
+    },
+  },
+  {
+    label: 'anthropic / haiku (200k window)',
+    provider: Providers.ANTHROPIC,
+    model: 'claude-haiku-4-5-20251001',
+    contextWindow: 200_000,
+    envKeys: ['ANTHROPIC_API_KEY'],
+    clientOptions: { apiKey: process.env.ANTHROPIC_API_KEY },
+  },
+  {
+    label: 'bedrock / haiku (200k window)',
+    provider: Providers.BEDROCK,
+    model: 'us.anthropic.claude-haiku-4-5-20251001-v1:0',
+    contextWindow: 200_000,
+    envKeys: ['BEDROCK_AWS_ACCESS_KEY_ID', 'AWS_ACCESS_KEY_ID'],
+    clientOptions: {
+      region:
+        process.env.BEDROCK_AWS_REGION ?? process.env.AWS_REGION ?? 'us-east-1',
+    },
+  },
+];
+
+/**
+ * Single-token words, so an N-word message is at least N tokens under every
+ * provider's tokenizer — the prompt must clear the window with certainty,
+ * since a request that squeaks under it is billed in full and proves nothing.
+ */
+const FILLER =
+  'the quick brown fox jumps over lazy dog and then runs past'.split(' ');
+
+function buildOversizedHistory(totalWords: number): BaseMessage[] {
+  const perMessage = Math.ceil(totalWords / 4);
+  const messages: BaseMessage[] = [];
+  for (let turn = 0; turn < 4; turn++) {
+    const words: string[] = new Array(perMessage);
+    for (let i = 0; i < perMessage; i++) {
+      words[i] = FILLER[(i + turn) % FILLER.length];
+    }
+    messages.push(new HumanMessage(`Notes part ${turn}: ${words.join(' ')}`));
+  }
+  messages.push(
+    new HumanMessage('In one short sentence, what were those notes about?')
+  );
+  return messages;
+}
+
+const describeIfLive = liveEnabled ? describe : describe.skip;
+
+describeIfLive('context overflow recovery (live)', () => {
+  for (const testCase of LIVE_CASES) {
+    const runnable = hasAnyEnv(testCase.envKeys);
+    const maybeIt = runnable ? it : it.skip;
+
+    maybeIt(
+      `recovers without surfacing an error — ${testCase.label}`,
+      async () => {
+        const summarizeEvents: t.SummarizeCompleteEvent[] = [];
+        const tokenCounter = await createTokenCounter();
+
+        const run = await Run.create<t.IState>({
+          runId: `overflow-live-${testCase.provider}-${Date.now()}`,
+          graphConfig: {
+            type: 'standard',
+            llmConfig: {
+              provider: testCase.provider,
+              ...testCase.clientOptions,
+              model: testCase.model,
+            } as t.LLMConfig,
+            /**
+             * Deliberately wrong, by a wide margin: the pruner will happily
+             * build a prompt the provider cannot accept, which is exactly the
+             * situation the recovery path exists for.
+             */
+            maxContextTokens: testCase.contextWindow * 2,
+            summarizationEnabled: true,
+            summarizationConfig: {
+              provider: testCase.provider,
+              model: testCase.model,
+            },
+          },
+          returnContent: true,
+          /**
+           * The assertions below read post-run `AgentContext` state, and the
+           * default cleanup path calls `clearHeavyState()` → `reset()`, which
+           * deliberately undoes the overflow correction for the next turn.
+           */
+          skipCleanup: true,
+          tokenCounter,
+          customHandlers: {
+            [GraphEvents.ON_SUMMARIZE_COMPLETE]: {
+              handle: (_event: string, data: t.StreamEventData): void => {
+                summarizeEvents.push(
+                  data as unknown as t.SummarizeCompleteEvent
+                );
+              },
+            },
+          },
+        });
+
+        const messages = buildOversizedHistory(
+          Math.ceil(testCase.contextWindow * 1.3)
+        );
+
+        const content = await run.processStream({ messages }, {
+          configurable: { thread_id: `overflow-live-${testCase.provider}` },
+          streamMode: 'values',
+          version: 'v2',
+        } as never);
+
+        expect(content).toBeDefined();
+        expect(Array.isArray(content)).toBe(true);
+        expect((content ?? []).length).toBeGreaterThan(0);
+
+        const agentContext = run.Graph?.agentContexts.get('default');
+        expect(agentContext?.overflowRecoveryAttempts).toBeGreaterThan(0);
+        /** The corrected budget must be below the fiction we started with. */
+        expect(agentContext?.maxContextTokens).toBeLessThan(
+          testCase.contextWindow * 2
+        );
+        /**
+         * No summarization assertion: the first recovery compacts by
+         * compressing tool output, so a run that fits after compression alone
+         * never spends a summarization call. Any summary event that does
+         * arrive must at least carry no error.
+         */
+        for (const event of summarizeEvents) {
+          expect(event.error).toBeUndefined();
+        }
+      }
+    );
+  }
+
+  it('has at least one runnable provider configured', () => {
+    const anyRunnable = LIVE_CASES.some((testCase) =>
+      testCase.envKeys.some(hasEnv)
+    );
+    expect(anyRunnable).toBe(true);
+  });
+});