🗣️ fix: Keep Provider Error Text on Unclassified Agent Failures

An upstream failure LangChain does not classify discarded the provider's own
message and answered with the generic upstream sentence plus a status, so a
gateway or privacy-proxy rejection lost the only account of what happened.

The provider text now rides along in the persisted payload as `message`,
withheld only where a content policy inspects the traffic — the same condition
`getUserFacingProviderError` and `getUserFacingRequestError` already decide by.

Author: berry-13

api/server/controllers/agents/client.js

@@ -4402,13 +4402,17 @@ class AgentClient extends BaseClient {
     let run;
     /** @type {Promise<(TAttachment | null)[] | undefined>} */
     let memoryPromise;
+    const appConfig = this.options.req.config;
     const terminalRunError = createTerminalRunErrorObserver({
       logger,
       responseMessageId: this.responseMessageId,
       source: '[api/server/controllers/agents/client.js #sendCompletion]',
       genericMessage: '[api/server/controllers/agents/client.js #sendCompletion] Unhandled error',
+      protectionEnabled: hasModelBoundContentProtection(
+        appConfig?.filters,
+        appConfig?.messageFilter?.pii,
+      ),
     });
-    const appConfig = this.options.req.config;
     const balanceConfig = getBalanceConfig(appConfig);
     const transactionsConfig = getTransactionsConfig(appConfig);
     try {
@@ -5287,13 +5291,17 @@ class AgentClient extends BaseClient {
     let config;
     /** @type {ReturnType<createRun>} */
     let run;
+    const appConfig = this.options.req.config;
     const terminalRunError = createTerminalRunErrorObserver({
       logger,
       responseMessageId: this.responseMessageId,
       source: '[api/server/controllers/agents/client.js #resumeCompletion]',
       genericMessage: '[api/server/controllers/agents/client.js #resumeCompletion] Unhandled error',
+      protectionEnabled: hasModelBoundContentProtection(
+        appConfig?.filters,
+        appConfig?.messageFilter?.pii,
+      ),
     });
-    const appConfig = this.options.req.config;
     const balanceConfig = getBalanceConfig(appConfig);
     const transactionsConfig = getTransactionsConfig(appConfig);
     try {

api/server/controllers/agents/client.test.js

@@ -10083,6 +10083,53 @@ describe('AgentClient - resumeCompletion content protection', () => {
     errorSpy.mockRestore();
   });
 
+  /** A gateway or privacy proxy states its rejection in its own message and nowhere else, so an
+   *  unclassified upstream failure carries it exactly as every other failure text does. */
+  it('keeps the provider explanation on a terminal resumed model failure', async () => {
+    const explanation = '400 Request rejected: this prompt cannot be masked safely';
+    const trackTerminalProviderError = (providerError) => {
+      mockCreateRun.mockImplementation(async (options) => {
+        const tracker = options.modelCallbacks.find(
+          (callback) => callback.name === 'librechat-upstream-model-error-tracker',
+        );
+        return {
+          resume: jest.fn(async () => {
+            tracker.handleLLMError(providerError, 'resumed-model-run');
+            throw providerError;
+          }),
+          getCalibrationRatio: jest.fn(() => 0),
+        };
+      });
+    };
+
+    trackTerminalProviderError(Object.assign(new Error(explanation), { status: 400 }));
+    const context = makeContext(undefined);
+
+    await AgentClient.prototype.resumeCompletion.call(context, { resumeValue: {} });
+
+    expect(context.contentParts).toContainEqual({
+      type: ContentTypes.ERROR,
+      [ContentTypes.ERROR]:
+        'The model provider could not complete this request.\n' +
+        JSON.stringify({ type: 'upstream_model_error', status: 400, message: explanation }),
+    });
+
+    /** With a policy inspecting the traffic, the body may echo submitted content: status only. */
+    trackTerminalProviderError(Object.assign(new Error(explanation), { status: 400 }));
+    const protectedContext = makeContext({
+      messages: { pii: { fields: ['text'], starterPatterns: ['email'] } },
+    });
+
+    await AgentClient.prototype.resumeCompletion.call(protectedContext, { resumeValue: {} });
+
+    expect(protectedContext.contentParts).toContainEqual({
+      type: ContentTypes.ERROR,
+      [ContentTypes.ERROR]:
+        'The model provider could not complete this request.\n' +
+        JSON.stringify({ type: 'upstream_model_error', status: 400 }),
+    });
+  });
+
   it('preserves provider error detail when content protection is disabled', async () => {
     const providerMessage = 'Legacy provider detail';
     mockCreateRun.mockRejectedValue(new Error(providerMessage));

api/server/controllers/agents/openai.js

@@ -383,6 +383,10 @@ const executeOpenAIChatCompletion = async (envelope, { req, res }) => {
     logger,
     responseMessageId: responseId,
     source: '[OpenAI API]',
+    protectionEnabled: hasModelBoundContentProtection(
+      appConfig?.filters,
+      appConfig?.messageFilter?.pii,
+    ),
   });
   const created = Math.floor(Date.now() / 1000);
 

api/server/controllers/agents/responses.js

@@ -632,6 +632,10 @@ const executeResponse = async (envelope, { req, res }) => {
     logger,
     responseMessageId: responseId,
     source: '[Responses API]',
+    protectionEnabled: hasModelBoundContentProtection(
+      appConfig?.filters,
+      appConfig?.messageFilter?.pii,
+    ),
   });
   const context = createResponseContext(request, responseId);
 

client/src/components/Messages/Content/Error/ModelError.tsx

@@ -4,7 +4,13 @@ import {
   isCodeWorkspaceSelectionErrorReason,
 } from 'librechat-data-provider';
 import type { ErrorRendererProps } from './parts';
-import { getProviderName, readNumber, readString, useErrorEndpoint } from './parts';
+import {
+  ErrorWithDetail,
+  getProviderName,
+  readNumber,
+  readString,
+  useErrorEndpoint,
+} from './parts';
 import { codeWorkspaceErrorKeys } from '~/utils/errors';
 import { useLocalize } from '~/hooks';
 
@@ -50,9 +56,21 @@ export default function ModelError({ json, message }: ErrorRendererProps) {
       : localize('com_error_code_workspace_unavailable');
   }
 
-  /** Provider-neutral, matching the sentence the server persists as the failure's own text. */
+  /**
+   * Provider-neutral headline, matching the sentence the server persists as the failure's own
+   * text. The provider's own message rides along in `message` when the deployment lets provider
+   * text through: a gateway or proxy rejection explains itself there, and nothing generic can.
+   */
   const status = readNumber(json, 'status');
-  return status != null
-    ? localize('com_error_upstream_model_status', { 0: status })
-    : localize('com_error_upstream_model');
+  const headline =
+    status != null
+      ? localize('com_error_upstream_model_status', { 0: status })
+      : localize('com_error_upstream_model');
+  return (
+    <ErrorWithDetail
+      headline={headline}
+      detail={readString(json, 'message')}
+      label={localize('com_error_details_provider')}
+    />
+  );
 }

client/src/components/Messages/Content/Error/ProviderError.tsx

@@ -1,6 +1,13 @@
 import { ErrorTypes, stripLangChainTroubleshootingUrl } from 'librechat-data-provider';
 import type { ErrorPayload, ErrorRendererProps, UnclassifiedErrorProps } from './parts';
-import { ErrorBody, ErrorDetails, readObject, readString, useErrorEndpoint } from './parts';
+import {
+  ErrorBody,
+  ErrorDetails,
+  ErrorWithDetail,
+  readObject,
+  readString,
+  useErrorEndpoint,
+} from './parts';
 import { extractJson } from '~/utils/json';
 import { useLocalize } from '~/hooks';
 
@@ -115,21 +122,11 @@ export function UnclassifiedError({ json, text, message }: UnclassifiedErrorProp
       : localize('com_error_upstream_model');
   const headline = prose == null && json != null ? localize('com_error_unknown') : providerHeadline;
 
-  if (prose == null) {
-    return headline;
-  }
-
-  if (prose.length <= 240 && !/[\r\n]/.test(prose)) {
-    return (
-      <ErrorBody>
-        <div>{headline}</div>
-        <div className="text-text-secondary">{prose}</div>
-      </ErrorBody>
-    );
-  }
-
-  return withHeadline(headline, {
-    label: localize('com_error_details_provider'),
-    value: prose,
-  });
+  return (
+    <ErrorWithDetail
+      headline={headline}
+      detail={prose}
+      label={localize('com_error_details_provider')}
+    />
+  );
 }

client/src/components/Messages/Content/Error/parts.tsx

@@ -299,6 +299,39 @@ export function ErrorDetails({ label, children }: { label: string; children: Rea
   );
 }
 
+/** Past a sentence's worth of text, or across lines, a detail is a body to open rather than read. */
+const INLINE_DETAIL_LENGTH = 240;
+
+/**
+ * A headline plus the failure's own words, the way every provider-produced error reads: what is
+ * known first, the reported text second. A single sentence stays in place, where a reader gets it
+ * without acting; a body of text collapses under `label`.
+ */
+export function ErrorWithDetail({
+  headline,
+  detail,
+  label,
+}: {
+  headline: string;
+  detail?: string;
+  label: string;
+}) {
+  if (detail == null) {
+    return <>{headline}</>;
+  }
+
+  return (
+    <ErrorBody>
+      <div>{headline}</div>
+      {detail.length <= INLINE_DETAIL_LENGTH && !/[\r\n]/.test(detail) ? (
+        <div className="text-text-secondary">{detail}</div>
+      ) : (
+        <ErrorDetails label={label}>{detail}</ErrorDetails>
+      )}
+    </ErrorBody>
+  );
+}
+
 export function ErrorActions({ children }: { children: React.ReactNode }) {
   return <div className="flex flex-wrap items-center gap-2">{children}</div>;
 }

client/src/components/Messages/Content/__tests__/Error.spec.tsx

@@ -387,6 +387,37 @@ describe('Error — provider and model identity', () => {
     expect(document.body.textContent).not.toContain('OpenAI');
   });
 
+  /** What a gateway or privacy proxy rejects a request with is only stated in its own message. */
+  it('reads the provider explanation an upstream failure carries', () => {
+    const explanation = 'Request rejected: this prompt cannot be masked safely';
+    const { unmount } = renderError(
+      { type: ErrorTypes.UPSTREAM_MODEL_ERROR, status: 400, message: explanation },
+      providerMessage,
+    );
+
+    expect(
+      screen.getByText(localized('com_error_upstream_model_status', '400')),
+    ).toBeInTheDocument();
+    expect(screen.getByText(explanation)).toBeInTheDocument();
+    expectReadable();
+    unmount();
+
+    const body = `Upstream rejection\n${JSON.stringify({ reason: 'masking_unavailable' })}`.padEnd(
+      400,
+      '.',
+    );
+    renderError(
+      { type: ErrorTypes.UPSTREAM_MODEL_ERROR, status: 400, message: body },
+      providerMessage,
+    );
+
+    const disclosure = screen.getByRole('button', { name: catalog.com_error_details_provider });
+    expect(disclosure).toHaveAttribute('aria-expanded', 'false');
+    fireEvent.click(disclosure);
+    expect(disclosure).toHaveAttribute('aria-expanded', 'true');
+    expect(document.body.textContent).toContain(body);
+  });
+
   it.each([
     ['required', 'com_error_code_workspace_required'],
     ['invalid', 'com_error_code_workspace_invalid'],

e2e/specs/mock/completion.spec.ts

@@ -24,6 +24,7 @@ test.describe('generation finalization invariant', () => {
     await expect(
       messagesView(page).getByText('The model provider could not complete this request.'),
     ).toBeVisible();
-    await expect(messagesView(page).getByText(providerError)).toHaveCount(0);
+    /** No content policy is configured here, so the provider's own words reach the reader. */
+    await expect(messagesView(page).getByText(providerError)).toBeVisible();
   });
 });

e2e/specs/mock/message-tree.spec.ts

@@ -1135,7 +1135,11 @@ test.describe('message tree stream operations', () => {
     const errorPrompt = `E2E_FORCED_ERROR:${label}`;
     const providerError = `E2E forced stream error ${label}`;
     const errorText = 'The model provider could not complete this request.';
-    const errorPayload = `${errorText}\n${JSON.stringify({ type: 'upstream_model_error' })}`;
+    /** No content policy is configured here, so the failure keeps the provider's own words. */
+    const errorPayload = `${errorText}\n${JSON.stringify({
+      type: 'upstream_model_error',
+      message: providerError,
+    })}`;
     const afterErrorPrompt = replyPrompt(`${label}-after-error`);
     const afterErrorReply = replyText(`${label}-after-error`);
 
@@ -1145,7 +1149,7 @@ test.describe('message tree stream operations', () => {
 
     await sendAndExpectReply(page, errorPrompt, errorText);
     await expect(messagesView(page).getByText(errorText)).toBeVisible({ timeout: 30000 });
-    await expect(messagesView(page).getByText(providerError)).toHaveCount(0);
+    await expect(messagesView(page).getByText(providerError)).toBeVisible();
 
     await sendAndExpectReply(page, afterErrorPrompt, afterErrorReply);
     const messages = await waitForMessages(