@librechat/agents 3.2.60 → 3.2.62

package/src/messages/format.ts

@@ -466,9 +466,15 @@ function hasToolCallOutput(part: MessageContentComplex): boolean {
 function formatAssistantMessage(
   message: Partial<TMessage>,
   options?: FormatAssistantMessageOptions
-): Array<RoleBearingMessage<AIMessage> | RoleBearingMessage<ToolMessage>> {
+): Array<
+  | RoleBearingMessage<AIMessage>
+  | RoleBearingMessage<ToolMessage>
+  | RoleBearingMessage<HumanMessage>
+> {
   const formattedMessages: Array<
-    RoleBearingMessage<AIMessage> | RoleBearingMessage<ToolMessage>
+    | RoleBearingMessage<AIMessage>
+    | RoleBearingMessage<ToolMessage>
+    | RoleBearingMessage<HumanMessage>
   > = [];
   let currentContent: MessageContentComplex[] = [];
   let lastAIMessage: RoleBearingMessage<AIMessage> | null = null;
@@ -725,6 +731,70 @@ function formatAssistantMessage(
         hasReasoning = true;
         pendingReasoningContent += extractReasoningContent(part);
         continue;
+      } else if (part.type === ContentTypes.STEER) {
+        /*
+        A mid-run steer: user speech persisted inline in the assistant message
+        at the tool-batch boundary it was injected. Flush accumulated
+        assistant content first so ordering is preserved, then replay the
+        steer as a standalone user message — multimodal when the host stamped
+        a pre-encoded `media` content array (attachment refs are re-encoded
+        per turn host-side, like any other user media). `lastAIMessage` is
+        reset AFTER the HumanMessage: a post-steer tool_call must mint a
+        FRESH assistant anchor (the heal path) so its AIMessage lands after
+        the user turn — attaching it to the pre-steer anchor would emit its
+        ToolMessage after the HumanMessage while the call itself sat before
+        it, an invalid provider ordering.
+        */
+        if (currentContent.length > 0) {
+          if (
+            currentContent.some((content) => content.type !== ContentTypes.TEXT)
+          ) {
+            lastAIMessage = createAIMessage(toLangChainContent(currentContent));
+            formattedMessages.push(lastAIMessage);
+          } else {
+            const flushed = currentContent
+              .reduce((acc, curr) => `${acc}${getTextContent(curr)}\n`, '')
+              .trim();
+            if (flushed.length > 0) {
+              lastAIMessage = createAIMessage(flushed);
+              formattedMessages.push(lastAIMessage);
+            }
+          }
+          currentContent = [];
+        } else if (shouldPreserveReasoningContent && pendingReasoningContent) {
+          /**
+           * Reasoning directly preceding a steer has no `currentContent`
+           * flush to consume it and the anchor resets below — emit an anchor
+           * AIMessage now (createAIMessage folds the pending reasoning into
+           * `additional_kwargs.reasoning_content`) or the persisted
+           * assistant reasoning silently vanishes on replay.
+           */
+          lastAIMessage = createAIMessage('');
+          formattedMessages.push(lastAIMessage);
+        }
+        const steerPart = part as {
+          steer?: string;
+          media?: MessageContentComplex[];
+        };
+        const steerContent =
+          Array.isArray(steerPart.media) && steerPart.media.length > 0
+            ? toLangChainContent(steerPart.media)
+            : (steerPart.steer ?? '');
+        formattedMessages.push(
+          withMessageRole(
+            new HumanMessage({
+              content: steerContent as MessageContent,
+              additional_kwargs: { role: 'user', source: 'steer' },
+            }),
+            'user'
+          )
+        );
+        lastAIMessage = null;
+        /** The steer splits the assistant message: the post-steer segment
+         *  starts with fresh reasoning state (pre-steer reasoning was either
+         *  flushed above or intentionally dropped when not preserving). */
+        hasReasoning = false;
+        pendingReasoningContent = '';
       } else if (
         part.type === ContentTypes.ERROR ||
         part.type === ContentTypes.AGENT_UPDATE ||
@@ -852,6 +922,12 @@ function labelAllAgentContent(
     }
 
     currentAgentId = agentId;
+    if (part.type === ContentTypes.STEER) {
+      /** User speech is never agent content — see the transfer path above. */
+      flushAgentBuffer();
+      result.push(part);
+      continue;
+    }
     agentContentBuffer.push(part);
   }
 
@@ -987,6 +1063,22 @@ export const labelContentByAgent = (
       transferToolCallIndex = result.length - 1;
       transferToolCallId = (part as ToolCallContent).tool_call?.id;
       currentAgentId = undefined; // Reset to capture the next agent
+    } else if (part.type === ContentTypes.STEER) {
+      /**
+       * User speech is never agent content: flush the buffer in place and
+       * pass the steer through verbatim so `formatAssistantMessage` replays
+       * it as a user turn. Folding it into a labeled transfer summary would
+       * both drop the user's words and misattribute them to the agent.
+       * The steer also CLOSES any open transfer capture — `flushAgentBuffer`
+       * no-ops on an empty buffer, and leaving the capture live would fold
+       * post-steer agent content into the pre-steer transfer output,
+       * replaying it BEFORE the user's redirect.
+       */
+      flushAgentBuffer();
+      transferToolCallIndex = undefined;
+      transferToolCallId = undefined;
+      currentAgentId = undefined;
+      result.push(part);
     } else {
       agentContentBuffer.push(part);
     }
@@ -1440,7 +1532,8 @@ export const formatAgentMessages = (
     const formattedMessages = formatAssistantMessage(processedMessage, {
       preserveUnpairedServerToolUses: i === payload.length - 1,
       preserveReasoningContent:
-        options?.preserveReasoningContent ?? options?.provider === Providers.DEEPSEEK,
+        options?.preserveReasoningContent ??
+        options?.provider === Providers.DEEPSEEK,
       provider: options?.provider,
     });
     if (sourceMessageId != null && sourceMessageId !== '') {

package/src/messages/formatAgentMessages.steer.test.ts

@@ -0,0 +1,326 @@
+import { AIMessage, HumanMessage, ToolMessage } from '@langchain/core/messages';
+import type { TPayload } from '@/types';
+import { ContentTypes, Constants, Providers } from '@/common';
+import { formatAgentMessages } from './format';
+
+function toolCallPart(
+  id: string,
+  name = 'search',
+  output = 'result'
+): Record<string, unknown> {
+  return {
+    type: ContentTypes.TOOL_CALL,
+    tool_call: { id, name, args: '{}', output },
+  };
+}
+
+describe('formatAgentMessages steer replay', () => {
+  it('replays a steer part as a user message after preceding tool messages', () => {
+    const payload: TPayload = [
+      { role: 'user', content: 'Original request' },
+      {
+        role: 'assistant',
+        content: [
+          {
+            type: ContentTypes.TEXT,
+            [ContentTypes.TEXT]: 'Working on it.',
+            tool_call_ids: ['call_1'],
+          },
+          toolCallPart('call_1'),
+          {
+            type: ContentTypes.STEER,
+            [ContentTypes.STEER]: 'Actually, focus on the second item.',
+            steerId: 's1',
+          } as unknown as Record<string, unknown>,
+          {
+            type: ContentTypes.TEXT,
+            [ContentTypes.TEXT]: 'Focusing on item two.',
+          },
+        ],
+      },
+    ];
+
+    const { messages } = formatAgentMessages(payload);
+
+    const steerIndex = messages.findIndex(
+      (message) =>
+        message instanceof HumanMessage &&
+        message.additional_kwargs.source === 'steer'
+    );
+    expect(steerIndex).toBeGreaterThan(0);
+    expect(messages[steerIndex].content).toBe(
+      'Actually, focus on the second item.'
+    );
+    expect(messages[steerIndex - 1]).toBeInstanceOf(ToolMessage);
+    const trailing = messages[steerIndex + 1];
+    expect(trailing).toBeInstanceOf(AIMessage);
+  });
+
+  it('mints a fresh assistant anchor for a tool call after a steer', () => {
+    const payload: TPayload = [
+      {
+        role: 'assistant',
+        content: [
+          {
+            type: ContentTypes.TEXT,
+            [ContentTypes.TEXT]: 'First step.',
+            tool_call_ids: ['call_1'],
+          },
+          toolCallPart('call_1'),
+          {
+            type: ContentTypes.STEER,
+            [ContentTypes.STEER]: 'Do the second thing instead.',
+          } as unknown as Record<string, unknown>,
+          toolCallPart('call_2', 'search', 'second result'),
+        ],
+      },
+    ];
+
+    const { messages } = formatAgentMessages(payload);
+
+    // AI(call_1), Tool(call_1), Human(steer), AI(call_2), Tool(call_2) —
+    // the post-steer tool call must NOT attach to the pre-steer anchor, or
+    // its ToolMessage would trail the user turn while the call precedes it.
+    expect(messages.map((message) => message.constructor.name)).toEqual([
+      'AIMessage',
+      'ToolMessage',
+      'HumanMessage',
+      'AIMessage',
+      'ToolMessage',
+    ]);
+    const postSteerAnchor = messages[3] as AIMessage;
+    expect(postSteerAnchor.tool_calls?.map((call) => call.id)).toEqual([
+      'call_2',
+    ]);
+    const preSteerAnchor = messages[0] as AIMessage;
+    expect(preSteerAnchor.tool_calls?.map((call) => call.id)).toEqual([
+      'call_1',
+    ]);
+  });
+
+  it('flushes accumulated assistant text before the steer user message', () => {
+    const payload: TPayload = [
+      {
+        role: 'assistant',
+        content: [
+          { type: ContentTypes.TEXT, [ContentTypes.TEXT]: 'Partial answer.' },
+          {
+            type: ContentTypes.STEER,
+            [ContentTypes.STEER]: 'Change of plans.',
+          } as unknown as Record<string, unknown>,
+        ],
+      },
+    ];
+
+    const { messages } = formatAgentMessages(payload);
+
+    expect(messages).toHaveLength(2);
+    expect(messages[0]).toBeInstanceOf(AIMessage);
+    expect(messages[0].content).toBe('Partial answer.');
+    expect(messages[1]).toBeInstanceOf(HumanMessage);
+    expect(messages[1].content).toBe('Change of plans.');
+  });
+
+  it('preserves pending reasoning that directly precedes a steer', () => {
+    const payload: TPayload = [
+      {
+        role: 'assistant',
+        content: [
+          {
+            type: ContentTypes.THINK,
+            [ContentTypes.THINK]: 'chain of thought',
+          },
+          {
+            type: ContentTypes.STEER,
+            [ContentTypes.STEER]: 'Stop and reconsider.',
+          } as unknown as Record<string, unknown>,
+        ],
+      },
+    ];
+
+    const { messages } = formatAgentMessages(
+      payload,
+      undefined,
+      undefined,
+      undefined,
+      {
+        preserveReasoningContent: true,
+      }
+    );
+
+    expect(messages).toHaveLength(2);
+    expect(messages[0]).toBeInstanceOf(AIMessage);
+    expect(messages[0].additional_kwargs.reasoning_content).toBe(
+      'chain of thought'
+    );
+    expect(messages[1]).toBeInstanceOf(HumanMessage);
+    expect(messages[1].content).toBe('Stop and reconsider.');
+  });
+
+  it('uses the host-stamped media array for multimodal steers', () => {
+    const media = [
+      { type: 'text', text: 'Look at this screenshot.' },
+      {
+        type: 'image_url',
+        image_url: { url: 'data:image/png;base64,abc123', detail: 'auto' },
+      },
+    ];
+    const payload: TPayload = [
+      {
+        role: 'assistant',
+        content: [
+          {
+            type: ContentTypes.STEER,
+            [ContentTypes.STEER]: 'Look at this screenshot.',
+            media,
+          } as unknown as Record<string, unknown>,
+        ],
+      },
+    ];
+
+    const { messages } = formatAgentMessages(payload);
+
+    expect(messages).toHaveLength(1);
+    expect(messages[0]).toBeInstanceOf(HumanMessage);
+    expect(messages[0].content).toEqual(media);
+    expect((messages[0] as HumanMessage).additional_kwargs.source).toBe(
+      'steer'
+    );
+  });
+
+  it('replays [THINK, STEER, TEXT] without duplicating the trailing text', () => {
+    const payload: TPayload = [
+      {
+        role: 'assistant',
+        content: [
+          {
+            type: ContentTypes.THINK,
+            [ContentTypes.THINK]: 'chain of thought',
+          },
+          {
+            type: ContentTypes.STEER,
+            [ContentTypes.STEER]: 'Redirect now.',
+          } as unknown as Record<string, unknown>,
+          {
+            type: ContentTypes.TEXT,
+            [ContentTypes.TEXT]: 'Post-steer answer.',
+          },
+        ],
+      },
+    ];
+
+    const { messages } = formatAgentMessages(
+      payload,
+      undefined,
+      undefined,
+      undefined,
+      {
+        preserveReasoningContent: true,
+      }
+    );
+
+    expect(messages.map((message) => message.constructor.name)).toEqual([
+      'AIMessage',
+      'HumanMessage',
+      'AIMessage',
+    ]);
+    expect(messages[0].additional_kwargs.reasoning_content).toBe(
+      'chain of thought'
+    );
+    // Post-steer segment starts with fresh reasoning state: the trailing
+    // text appears exactly once (end-of-loop array form) and carries no
+    // pre-steer reasoning.
+    expect(messages[2].content).toEqual([
+      { type: 'text', text: 'Post-steer answer.' },
+    ]);
+    expect(messages[2].additional_kwargs.reasoning_content).toBeUndefined();
+  });
+
+  it('keeps a paired Anthropic server-tool use/result together after the steer', () => {
+    const useId = `${Constants.ANTHROPIC_SERVER_TOOL_PREFIX}search1`;
+    const payload: TPayload = [
+      {
+        role: 'assistant',
+        content: [
+          {
+            type: ContentTypes.TOOL_CALL,
+            tool_call: { id: useId, name: 'web_search', args: '{"query":"x"}' },
+          },
+          {
+            type: ContentTypes.STEER,
+            [ContentTypes.STEER]: 'Also check the docs.',
+          } as unknown as Record<string, unknown>,
+          {
+            type: 'web_search_tool_result',
+            tool_use_id: useId,
+            content: [
+              { type: 'web_search_result', url: 'https://example.com' },
+            ],
+          } as unknown as Record<string, unknown>,
+        ],
+      },
+    ];
+
+    const { messages } = formatAgentMessages(
+      payload,
+      undefined,
+      new Set(['web_search']),
+      undefined,
+      { provider: Providers.ANTHROPIC }
+    );
+
+    // The pair may not split across the user turn (invalid for Anthropic);
+    // it emits together in the post-steer assistant segment instead.
+    expect(messages[0]).toBeInstanceOf(HumanMessage);
+    expect(messages[0].content).toBe('Also check the docs.');
+    const assistant = messages[1];
+    expect(assistant).toBeInstanceOf(AIMessage);
+    const parts = assistant.content as Array<{
+      type?: string;
+      tool_use_id?: string;
+      id?: string;
+    }>;
+    const useIndex = parts.findIndex((part) => part.type === 'server_tool_use');
+    const resultIndex = parts.findIndex(
+      (part) => part.type === 'web_search_tool_result'
+    );
+    expect(useIndex).toBeGreaterThanOrEqual(0);
+    expect(resultIndex).toBe(useIndex + 1);
+  });
+
+  it('never leaks a steer part into assistant content sent to the provider', () => {
+    const payload: TPayload = [
+      {
+        role: 'assistant',
+        content: [
+          { type: ContentTypes.TEXT, [ContentTypes.TEXT]: 'Before.' },
+          {
+            type: ContentTypes.STEER,
+            [ContentTypes.STEER]: 'Steer text.',
+          } as unknown as Record<string, unknown>,
+          { type: ContentTypes.TEXT, [ContentTypes.TEXT]: 'After.' },
+        ],
+      },
+    ];
+
+    const { messages } = formatAgentMessages(payload);
+
+    for (const message of messages) {
+      if (message instanceof HumanMessage) {
+        continue;
+      }
+      const content = message.content;
+      if (Array.isArray(content)) {
+        expect(
+          content.some((part) => (part as { type?: string }).type === 'steer')
+        ).toBe(false);
+      }
+    }
+    // Trailing content after the steer keeps the end-of-loop array form.
+    expect(messages.map((message) => message.content)).toEqual([
+      'Before.',
+      'Steer text.',
+      [{ type: 'text', text: 'After.' }],
+    ]);
+  });
+});

package/src/messages/labelContentByAgent.test.ts

@@ -54,6 +54,81 @@ describe('labelContentByAgent', () => {
     });
   });
 
+  describe('steer pass-through', () => {
+    it('passes steer parts through the parallel labeler verbatim', () => {
+      const steerPart = {
+        type: ContentTypes.STEER,
+        steer: 'User redirect mid-run',
+        steerId: 's1',
+      } as unknown as MessageContentComplex;
+      const contentParts: MessageContentComplex[] = [
+        { type: ContentTypes.TEXT, text: 'agent output' },
+        steerPart,
+        { type: ContentTypes.TEXT, text: 'post-steer output' },
+      ];
+
+      const result = labelContentByAgent(
+        contentParts,
+        { 0: 'agent_a', 1: 'agent_a', 2: 'agent_a' },
+        { agent_a: 'Alpha' },
+        { labelNonTransferContent: true }
+      );
+
+      // The user's words survive verbatim (not folded into a labeled
+      // summary) so formatAssistantMessage can replay them as a user turn.
+      expect(result).toContain(steerPart);
+    });
+  });
+
+  describe('steer vs transfer capture', () => {
+    it('closes an open transfer capture at a steer boundary', () => {
+      const transferPart: MessageContentComplex = {
+        type: ContentTypes.TOOL_CALL,
+        tool_call: {
+          id: 'call_transfer',
+          name: 'lc_transfer_to_beta',
+          args: '{}',
+          output: 'original output',
+        },
+      } as MessageContentComplex;
+      const steerPart = {
+        type: ContentTypes.STEER,
+        steer: 'Actually, stop and summarize.',
+      } as unknown as MessageContentComplex;
+      const contentParts: MessageContentComplex[] = [
+        transferPart,
+        steerPart,
+        { type: ContentTypes.TEXT, text: 'post-steer agent output' },
+      ];
+
+      const result = labelContentByAgent(
+        contentParts,
+        { 0: 'agent_a', 1: 'agent_a', 2: 'agent_b' },
+        { agent_b: 'Beta' }
+      );
+
+      // The steer passes through and post-steer content stays AFTER it —
+      // never folded into the pre-steer transfer output, which would replay
+      // it ahead of the user's redirect.
+      expect(result).toContain(steerPart);
+      const transferInResult = result.find(
+        (part) =>
+          isToolCallContent(part) && part.tool_call?.id === 'call_transfer'
+      );
+      expect(
+        isToolCallContent(transferInResult!)
+          ? transferInResult.tool_call?.output
+          : undefined
+      ).toBe('original output');
+      const steerIndex = result.indexOf(steerPart);
+      const textIndex = result.findIndex(
+        (part) =>
+          hasTextProperty(part) && part.text === 'post-steer agent output'
+      );
+      expect(textIndex).toBeGreaterThan(steerIndex);
+    });
+  });
+
   describe('Transfer-based labeling (default)', () => {
     it('should consolidate transferred agent content into transfer tool output', () => {
       const contentParts: MessageContentComplex[] = [

package/src/messages/prune.ts

@@ -135,9 +135,10 @@ export type PruneMessagesParams = {
   usageMetadata?: Partial<UsageMetadata>;
   startType?: ReturnType<BaseMessage['getType']>;
   /**
-   * Usage from the most recent LLM call only (not accumulated).
-   * When provided, calibration uses this instead of usageMetadata
-   * to avoid inflated ratios from N×cacheRead accumulation.
+   * Fallback usage from the most recent LLM call only (not accumulated).
+   * Calibration prefers the provider's raw `usageMetadata.input_tokens`
+   * when available, because cache detail fields may use non-window
+   * accounting units.
    */
   lastCallUsage?: {
     totalTokens: number;
@@ -1436,8 +1437,10 @@ export function createPruneMessages(factoryParams: PruneMessagesFactoryParams) {
     // no per-turn oscillation, no map mutation.
     if (currentUsage && params.totalTokensFresh !== false) {
       const instructionOverhead = factoryParams.getInstructionTokens?.() ?? 0;
-      const providerInputTokens =
-        params.lastCallUsage?.inputTokens ?? currentUsage.input_tokens;
+      const rawProviderInputTokens = Number(params.usageMetadata?.input_tokens);
+      const providerInputTokens = checkValidNumber(rawProviderInputTokens)
+        ? rawProviderInputTokens
+        : (params.lastCallUsage?.inputTokens ?? currentUsage.input_tokens);
 
       // Sum raw tiktoken counts for messages the provider saw (excludes
       // new outputs from this turn — the provider hasn't seen them yet).
@@ -1458,8 +1461,21 @@ export function createPruneMessages(factoryParams: PruneMessagesFactoryParams) {
         0,
         providerInputTokens - instructionOverhead
       );
+      const minimumComparableInputTokens =
+        instructionOverhead + rawSentThisTurn * CALIBRATION_RATIO_MIN;
+      let calibrationSkipReason: string | undefined;
+      if (rawSentThisTurn <= 0) {
+        calibrationSkipReason = 'no_sent_messages';
+      } else if (providerMessageTokens <= 0) {
+        calibrationSkipReason = 'input_below_instruction_overhead';
+      } else if (providerInputTokens < minimumComparableInputTokens) {
+        calibrationSkipReason = 'input_below_calibration_floor';
+      }
+      // No upper-bound rejection: maxTokens is an application budget, not the
+      // provider's real context window.  Usage above the budget is a genuine
+      // measurement — and the one that must drive pruning/summarization.
 
-      if (rawSentThisTurn > 0 && providerMessageTokens > 0) {
+      if (calibrationSkipReason == null) {
         cumulativeRawSent += rawSentThisTurn;
         cumulativeProviderReported += providerMessageTokens;
         const newRatio = cumulativeProviderReported / cumulativeRawSent;
@@ -1467,33 +1483,43 @@ export function createPruneMessages(factoryParams: PruneMessagesFactoryParams) {
           CALIBRATION_RATIO_MIN,
           Math.min(CALIBRATION_RATIO_MAX, newRatio)
         );
-      }
 
-      const calibratedOurTotal =
-        instructionOverhead + rawSentThisTurn * calibrationRatio;
-      const overallRatio =
-        calibratedOurTotal > 0 ? providerInputTokens / calibratedOurTotal : 0;
-      const variancePct = Math.round((overallRatio - 1) * 100);
+        const calibratedOurTotal =
+          instructionOverhead + rawSentThisTurn * calibrationRatio;
+        const overallRatio =
+          calibratedOurTotal > 0 ? providerInputTokens / calibratedOurTotal : 0;
+        const variancePct = Math.round((overallRatio - 1) * 100);
+
+        const absVariance = Math.abs(overallRatio - 1);
+        if (absVariance < bestVarianceAbs) {
+          bestVarianceAbs = absVariance;
+          bestInstructionOverhead = Math.max(
+            0,
+            Math.round(providerInputTokens - rawSentThisTurn * calibrationRatio)
+          );
+          bestInstructionEstimate = factoryParams.getInstructionTokens?.() ?? 0;
+        }
 
-      const absVariance = Math.abs(overallRatio - 1);
-      if (absVariance < bestVarianceAbs && rawSentThisTurn > 0) {
-        bestVarianceAbs = absVariance;
-        bestInstructionOverhead = Math.max(
-          0,
-          Math.round(providerInputTokens - rawSentThisTurn * calibrationRatio)
-        );
-        bestInstructionEstimate = factoryParams.getInstructionTokens?.() ?? 0;
+        factoryParams.log?.('debug', 'Calibration observed', {
+          providerInputTokens,
+          calibratedEstimate: Math.round(calibratedOurTotal),
+          variance: `${variancePct > 0 ? '+' : ''}${variancePct}%`,
+          calibrationRatio: Math.round(calibrationRatio * 100) / 100,
+          instructionOverhead,
+          cumulativeRawSent,
+          cumulativeProviderReported,
+        });
+      } else {
+        factoryParams.log?.('debug', 'Calibration skipped', {
+          reason: calibrationSkipReason,
+          providerInputTokens,
+          minimumComparableInputTokens: Math.round(
+            minimumComparableInputTokens
+          ),
+          rawSentThisTurn,
+          instructionOverhead,
+        });
       }
-
-      factoryParams.log?.('debug', 'Calibration observed', {
-        providerInputTokens,
-        calibratedEstimate: Math.round(calibratedOurTotal),
-        variance: `${variancePct > 0 ? '+' : ''}${variancePct}%`,
-        calibrationRatio: Math.round(calibrationRatio * 100) / 100,
-        instructionOverhead,
-        cumulativeRawSent,
-        cumulativeProviderReported,
-      });
     }
 
     // Computed BEFORE pre-flight truncation so the effective budget can drive

package/src/specs/anthropic.simple.test.ts

@@ -16,14 +16,16 @@ import {
   createMetadataAggregator,
 } from '@/events';
 import { ContentTypes, GraphEvents, Providers, TitleMethod } from '@/common';
-import { capitalizeFirstLetter } from './spec.utils';
+import { capitalizeFirstLetter, hasEnv } from './spec.utils';
 import { createContentAggregator } from '@/stream';
 import { getLLMConfig } from '@/utils/llmConfig';
 import { getArgs } from '@/scripts/args';
 import { Run } from '@/run';
 
 const provider = Providers.ANTHROPIC;
-describe(`${capitalizeFirstLetter(provider)} Streaming Tests`, () => {
+const describeIf = hasEnv('ANTHROPIC_API_KEY') ? describe : describe.skip;
+
+describeIf(`${capitalizeFirstLetter(provider)} Streaming Tests`, () => {
   jest.setTimeout(90000);
   let run: Run<t.IState>;
   let runningHistory: BaseMessage[];