diff --git a/.github/workflows/codegraph-select.yml b/.github/workflows/codegraph-select.yml
index d76d673a8aa..9257c4bac1d 100644
--- a/.github/workflows/codegraph-select.yml
+++ b/.github/workflows/codegraph-select.yml
@@ -17,6 +17,10 @@ permissions:
   contents: read
   pull-requests: read
 
+concurrency:
+  group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
+  cancel-in-progress: true
+
 jobs:
   select:
     runs-on: ubuntu-latest
diff --git a/CONTEXT.md b/CONTEXT.md
index b390f49505c..62ad3558459 100644
--- a/CONTEXT.md
+++ b/CONTEXT.md
@@ -9,6 +9,7 @@
 - **Agent execution host**: the protocol-neutral module that owns run admission, disconnect cancellation, provider-start fencing, and terminal settlement. Protocol implementations execute behind its callback interface; HTTP adapters retain validation and final stream rendering.
 - **Agent execution enrollment**: the durable, protocol-neutral lifecycle authority for an admitted Agent run. It is created under the authenticated user and tenant before user-owned initialization, rechecks the shared owner-deletion admission fence after registration, exposes the only provider abort signal, fences exact provider start, terminalizes the run, waits for every trailing usage, artifact, and stored-response write, and acknowledges provider drain last. A transient terminalization failure is reconciled after trailing writes; provider drain is never acknowledged while the exact job remains nonterminal. Delete-all holds the owner fence, drains every owner run before selecting its first persistence snapshot, and repeats both the drain and an idempotent owner-persistence sweep after any recovered fence lapse before releasing admission. Exact-conversation deletion additionally performs an unconditional idempotent cleanup over its immutable deleted-ID set because a fully drained run may leave the active index after racing the first delete; only the explicit empty result is benign, while storage failures remain fatal. Chat Completions, Responses, Channels, and future ingress adapters share this authority without moving LibreChat persistence policy into the Agents SDK.
 - **Agent turn execution plan**: the immutable, request-local decision compiled once after authentication, agent resolution, and tool initialization. It records the trusted turn origin, conversation lineage, pause capability, binding/action context, and the preferred checkpoint, history, or fresh state-loading strategy without executing the model or owning persistence. Checkpoint failure falls back to durable history within the same Agents lifecycle.
+- **Turn delivery routing**: the per-agent, request-local value that decides how each attachment reaches the model on one turn (`provider`, `text`, or `none`). Initialization settles it once, after the provider swap and the Responses API decision, under the endpoint's own name and the media dialect its config declares. Every reader of a turn route consumes that one value rather than deriving it from the agent. A stored route is an upload-time inference that this value resolves again for the turn; a destination the user chose stands.
 - **Effective agent selection**: the resolved endpoint and agent identity after an enforced model spec is applied. Authorization and agent loading must consume this same identity before the Agent run envelope is initialized.
 - **MCP runtime request body**: trusted chat identifiers supplied only while an MCP server handles an agent request. It enables request-scoped header placeholders without retaining user-specific request data on a shared server definition.
 - **MCP direct OpenID bearer**: an operator-trusted remote MCP credential mode that resolves the logged-in user's live OpenID access token into an Authorization header. It may replace one rejected connection after a forced session refresh, but it never replays the rejected tool invocation automatically.
diff --git a/api/app/clients/BaseClient.js b/api/app/clients/BaseClient.js
index 5ec6e7db960..4835f9ad80d 100644
--- a/api/app/clients/BaseClient.js
+++ b/api/app/clients/BaseClient.js
@@ -9,6 +9,7 @@ const {
   sanitizeFileForTransmit,
   extractFileContext,
   getReferencedQuotes,
+  applyTurnDelivery,
   encodeAndFormatAudios,
   encodeAndFormatVideos,
   getTransactionsConfig,
@@ -33,17 +34,14 @@ const {
   isCompactedLeaf,
   excludedKeys,
   EModelEndpoint,
-  mergeFileConfig,
   isParamEndpoint,
   isAgentsEndpoint,
   isEphemeralAgentId,
   supportsBalanceCheck,
   isBedrockDocumentType,
   HITL_MESSAGE_FILTER_FIELDS,
-  getEndpointFileConfig,
   stripReasoningLabelMetadata,
-  resolveUploadLLMDeliveryPath,
-  isSpeechProviderConfigured,
+  resolveTurnLLMDeliveryPath,
   resolveUseResponsesApi,
 } = require('librechat-data-provider');
 const { getStrategyFunctions } = require('~/server/services/Files/strategies');
@@ -241,10 +239,6 @@ class BaseClient {
     this.currentMessages = [];
     /** @type {import('librechat-data-provider').VisionModes | undefined} */
     this.visionMode;
-    /** @type {import('librechat-data-provider').FileConfig | undefined} */
-    this._mergedFileConfig;
-    /** @type {import('librechat-data-provider').EndpointFileConfig | undefined} */
-    this._endpointFileConfig;
   }
 
   setOptions() {
@@ -831,9 +825,8 @@ class BaseClient {
     if (this.options.resendFiles !== false && this.authorizedHistoricalFiles == null) {
       const historicalFileState = collectModelBoundHistoricalFileIdState(modelBoundStoredMessages);
       this.modelBoundHistoricalFileIdsOverflowed ||= historicalFileState.overflowed;
-      const files = await getOwnerHistoricalFiles(
-        historicalFileState.fileIds,
-        this.options.req?.user,
+      const files = this.resolveTurnAttachments(
+        await getOwnerHistoricalFiles(historicalFileState.fileIds, this.options.req?.user),
       );
       this.authorizedHistoricalFiles = new Map(
         files
@@ -1780,8 +1773,8 @@ class BaseClient {
    * @param {MongoFile[]} attachments - Array of file attachments
    * @returns {Promise<void>}
    */
-  async addFileContextToMessage(message, attachments) {
-    const textAttachments = this.getTextContextAttachments(attachments);
+  async addFileContextToMessage(message, attachments, fileConsumers) {
+    const textAttachments = this.getTextContextAttachments(attachments, fileConsumers);
     const fileContext = await extractFileContext({
       attachments: textAttachments,
       req: this.options?.req,
@@ -1793,9 +1786,9 @@ class BaseClient {
     }
   }
 
-  getTextContextAttachments(attachments) {
+  getTextContextAttachments(attachments, fileConsumers) {
     return attachments.filter((file) => {
-      const deliveryPath = this.getAttachmentDeliveryPath(file);
+      const deliveryPath = this.getAttachmentDeliveryPath(file, fileConsumers);
       /* Records predating delivery paths keep legacy extraction. Current routing is
        * authoritative for inferred uploads, so native provider bytes are not also
        * injected as extracted text after a provider handoff. */
@@ -1803,35 +1796,19 @@ class BaseClient {
     });
   }
 
-  /** Re-resolves an inferred upload route against the provider handling this turn. */
-  getAttachmentDeliveryPath(file) {
-    if (!this._mergedFileConfig) {
-      this._mergedFileConfig = mergeFileConfig(this.options.req?.config?.fileConfig);
-      /* Agent file policy is configured under the endpoint it names, not the client
-       * family initialization may rewrite it to. */
-      const agentEndpoint = this.options.agent?.endpoint ?? this.options.agent?.provider;
-      this._deliveryEndpoint = agentEndpoint ?? this.options.endpoint;
-      this._endpointFileConfig = getEndpointFileConfig({
-        fileConfig: this._mergedFileConfig,
-        endpoint: this._deliveryEndpoint,
-        endpointType: agentEndpoint != null ? undefined : this.options.endpointType,
-      });
-    }
+  /** The turn's view of stored records, applied before admission at every load. */
+  resolveTurnAttachments(files, fileConsumers = this.options.agent?.fileConsumers) {
+    return applyTurnDelivery(files, {
+      routing: this.options.agent?.deliveryRouting,
+      consumers: fileConsumers,
+    });
+  }
 
-    return file.llmDeliveryPath == null || file.metadata?.destinationChosen === true
-      ? file.llmDeliveryPath
-      : resolveUploadLLMDeliveryPath({
-          /* Conversion changes the stored type, so use the type routing originally saw. */
-          mimeType: file.metadata?.routingMimeType ?? file.type,
-          endpointConfig: this._endpointFileConfig,
-          fileConfig: this._mergedFileConfig,
-          endpoint: this._deliveryEndpoint,
-          useResponsesApi: this.usesResponsesApi(),
-          sttConfigured: isSpeechProviderConfigured(this.options.req?.config?.speech?.stt),
-        });
+  getAttachmentDeliveryPath(file, fileConsumers = this.options.agent?.fileConsumers) {
+    return resolveTurnLLMDeliveryPath(this.options.agent?.deliveryRouting, file, fileConsumers);
   }
 
-  async processAttachments(message, attachments) {
+  async processAttachments(message, attachments, fileConsumers) {
     const categorizedAttachments = {
       images: [],
       videos: [],
@@ -1842,6 +1819,7 @@ class BaseClient {
     const allFiles = [];
     const provider = this.options.agent?.provider ?? this.options.endpoint;
     const isBedrock = provider === EModelEndpoint.bedrock;
+    const deliveryRouting = this.options.agent?.deliveryRouting;
 
     /* The stored path records what upload time inferred from the endpoint it saw, and this
      * turn may be running somewhere else: audio stored as `provider` under Google reaches
@@ -1855,7 +1833,7 @@ class BaseClient {
         allFiles.push(file);
         continue;
       }
-      const deliveryPath = this.getAttachmentDeliveryPath(file);
+      const deliveryPath = this.getAttachmentDeliveryPath(file, fileConsumers);
       if (deliveryPath === 'text' || deliveryPath === 'none') {
         allFiles.push(file);
         continue;
@@ -1890,9 +1868,11 @@ class BaseClient {
         allFiles.push(file);
       } else if (
         file.type &&
-        this._mergedFileConfig &&
-        this._endpointFileConfig?.supportedMimeTypes &&
-        this._mergedFileConfig.checkType(file.type, this._endpointFileConfig.supportedMimeTypes)
+        deliveryRouting?.endpointConfig.supportedMimeTypes &&
+        deliveryRouting.fileConfig.checkType(
+          file.type,
+          deliveryRouting.endpointConfig.supportedMimeTypes,
+        )
       ) {
         categorizedAttachments.documents.push(file);
         allFiles.push(file);
@@ -1954,9 +1934,8 @@ class BaseClient {
     const historicalFileState = collectModelBoundHistoricalFileIdState(_messages);
     this.modelBoundHistoricalFileIdsOverflowed ||= historicalFileState.overflowed;
     const authorizedFilesById = new Map();
-    const files = await getOwnerHistoricalFiles(
-      historicalFileState.fileIds,
-      this.options.req?.user,
+    const files = this.resolveTurnAttachments(
+      await getOwnerHistoricalFiles(historicalFileState.fileIds, this.options.req?.user),
     );
     const nonSteerReplayFileIds = collectModelBoundHistoricalFileIdState(
       _messages.map((message) => ({
diff --git a/api/app/clients/specs/BaseClient.test.js b/api/app/clients/specs/BaseClient.test.js
index 26d8f3ccfb6..53c22c33dc0 100644
--- a/api/app/clients/specs/BaseClient.test.js
+++ b/api/app/clients/specs/BaseClient.test.js
@@ -1,6 +1,11 @@
 const { Constants, ContentTypes, EModelEndpoint } = require('librechat-data-provider');
 const BaseClientClass = require('../BaseClient');
-const { ContentFilterError } = require('@librechat/api');
+const {
+  ContentFilterError,
+  resolveTurnDeliveryRouting,
+  buildSteerMedia,
+  Tokenizer,
+} = require('@librechat/api');
 const { FakeClient, initializeFakeClient } = require('./FakeClient');
 
 function deferred() {
@@ -1174,6 +1179,69 @@ describe('BaseClient', () => {
       expect(TestClient.buildMessages).toHaveBeenCalled();
     });
 
+    test('keeps the turn view of historical files that projection and steer replay read', async () => {
+      const routedCsv = {
+        file_id: 'csv-file',
+        filename: 'sales.csv',
+        filepath: '/uploads/sales.csv',
+        type: 'text/csv',
+        text: 'region,total',
+        llmDeliveryPath: 'none',
+        metadata: { destinationChosen: false },
+        user: 'user-1',
+      };
+      getFiles.mockReset();
+      getFiles.mockResolvedValueOnce([routedCsv]);
+      TestClient = initializeFakeClient(
+        apiKey,
+        {
+          ...options,
+          agent: {
+            provider: EModelEndpoint.openAI,
+            fileConsumers: { executeCode: false, fileSearch: false },
+          },
+          req: {
+            user: { id: 'user-1', tenantId: 'tenant-a' },
+            config: {
+              fileConfig: {
+                endpoints: {
+                  [EModelEndpoint.openAI]: {
+                    defaultLLMDeliveryPath: { overrides: { 'text/csv': 'none' } },
+                    textFallbackWithoutTools: true,
+                  },
+                },
+              },
+            },
+          },
+        },
+        [
+          {
+            role: 'user',
+            isCreatedByUser: true,
+            text: 'Summarize my sheet',
+            files: [{ file_id: 'csv-file' }],
+            messageId: 'historical-csv-message',
+            parentMessageId: Constants.NO_PARENT,
+          },
+        ],
+      );
+
+      TestClient.options.agent.deliveryRouting = resolveTurnDeliveryRouting({
+        agent: TestClient.options.agent,
+        config: TestClient.options.req.config,
+      });
+      await TestClient.sendMessage('And the totals?', {
+        conversationId: 'historical-csv-conversation',
+        parentMessageId: 'historical-csv-message',
+      });
+
+      expect(TestClient.authorizedHistoricalFiles.get('csv-file')).toEqual({
+        ...routedCsv,
+        llmDeliveryPath: 'text',
+      });
+      expect(routedCsv.llmDeliveryPath).toBe('none');
+    });
+
     test('does not block a missing historical file omitted from the final payload', async () => {
       getFiles.mockReset();
       getFiles.mockResolvedValueOnce([]);
@@ -2580,6 +2648,110 @@ describe('BaseClient', () => {
       TestClient.checkVisionRequest = jest.fn();
     });
 
+    describe('tool-routed files on a later turn', () => {
+      const routedCsv = {
+        file_id: 'csv-file',
+        filename: 'sales.csv',
+        filepath: '/uploads/sales.csv',
+        source: 'local',
+        type: 'text/csv',
+        user: 'user-1',
+        text: 'region,total',
+        llmDeliveryPath: 'none',
+        metadata: { destinationChosen: false },
+      };
+
+      const replayCsv = async (
+        fileConsumers,
+        endpointConfig = {
+          defaultLLMDeliveryPath: { overrides: { 'text/csv': 'none' } },
+          textFallbackWithoutTools: true,
+        },
+      ) => {
+        getFiles.mockResolvedValueOnce([routedCsv]);
+        TestClient.options.req.config = {
+          fileConfig: { endpoints: { [EModelEndpoint.openAI]: endpointConfig } },
+        };
+        TestClient.options.agent = { provider: EModelEndpoint.openAI, fileConsumers };
+        TestClient.options.agent.deliveryRouting = resolveTurnDeliveryRouting({
+          agent: TestClient.options.agent,
+          config: TestClient.options.req?.config,
+        });
+        TestClient.assertHistoricalAttachmentLimits = jest.fn(async (files) => files);
+        const [message] = await TestClient.addPreviousAttachments([
+          { messageId: 'msg-csv', text: 'Summarize it', files: [{ file_id: 'csv-file' }] },
+        ]);
+        return message;
+      };
+
+      test('replays the stored text when this turn runs no tool that can read the file', async () => {
+        const message = await replayCsv({ executeCode: false, fileSearch: false });
+        const replayed = { ...routedCsv, llmDeliveryPath: 'text' };
+
+        expect(TestClient.assertHistoricalAttachmentLimits).toHaveBeenCalledWith([replayed]);
+        expect(TestClient.addFileContextToMessage).toHaveBeenCalledWith(message, [replayed]);
+        expect(TestClient.authorizedHistoricalFiles.get('csv-file')).toEqual(replayed);
+        expect(message.fileContext).toBe('region,total');
+        expect(routedCsv.llmDeliveryPath).toBe('none');
+      });
+
+      test('replays the stored text once the endpoint routes the type to text', async () => {
+        const message = await replayCsv(
+          { executeCode: true, fileSearch: false },
+          { defaultLLMDeliveryPath: { overrides: { 'text/csv': 'text' } } },
+        );
+        const replayed = { ...routedCsv, llmDeliveryPath: 'text' };
+
+        expect(TestClient.assertHistoricalAttachmentLimits).toHaveBeenCalledWith([replayed]);
+        expect(TestClient.addFileContextToMessage).toHaveBeenCalledWith(message, [replayed]);
+        expect(message.fileContext).toBe('region,total');
+      });
+
+      test('admits a historical tool-routed file this turn sends to the provider', async () => {
+        const routedImage = {
+          file_id: 'image-file',
+          filename: 'chart.png',
+          filepath: '/uploads/chart.png',
+          source: 'local',
+          type: 'image/png',
+          user: 'user-1',
+          llmDeliveryPath: 'none',
+          metadata: { destinationChosen: false },
+        };
+        getFiles.mockResolvedValueOnce([routedImage]);
+        TestClient.options.req.config = { fileConfig: { endpoints: {} } };
+        TestClient.options.agent = {
+          provider: EModelEndpoint.openAI,
+          fileConsumers: { executeCode: false, fileSearch: false },
+        };
+        TestClient.options.agent.deliveryRouting = resolveTurnDeliveryRouting({
+          agent: TestClient.options.agent,
+          config: TestClient.options.req?.config,
+        });
+        TestClient.assertHistoricalAttachmentLimits = jest.fn(async (files) => files);
+
+        await TestClient.addPreviousAttachments([
+          {
+            messageId: 'msg-image',
+            text: 'What does it show?',
+            files: [{ file_id: 'image-file' }],
+          },
+        ]);
+
+        expect(TestClient.assertHistoricalAttachmentLimits).toHaveBeenCalledWith([
+          { ...routedImage, llmDeliveryPath: 'provider' },
+        ]);
+      });
+
+      test('keeps the file off the prompt when this turn can read it with code', async () => {
+        const message = await replayCsv({ executeCode: true, fileSearch: false });
+
+        expect(TestClient.assertHistoricalAttachmentLimits).toHaveBeenCalledWith([]);
+        expect(TestClient.addFileContextToMessage).not.toHaveBeenCalled();
+        expect(message.fileContext).toBeUndefined();
+      });
+    });
+
     test('rehydrates historical file refs from owner-scoped DB rows only', async () => {
       getFiles.mockResolvedValueOnce([ownerFile]);
 
@@ -3192,8 +3364,6 @@ describe('BaseClient', () => {
       TestClient.options = {
         endpoint: EModelEndpoint.openAI,
       };
-      TestClient._mergedFileConfig = undefined;
-      TestClient._endpointFileConfig = undefined;
       TestClient.addImageURLs = jest.fn(async (message, files) => {
         message.image_urls = ['encoded-image'];
         return files;
@@ -3207,9 +3377,18 @@ describe('BaseClient', () => {
       TestClient.addAudios = jest.fn(async (_message, files) => files);
     });
 
-    /* The stored path is an upload-time inference, so delivery re-resolves it for the
-     * endpoint running the turn. A test asserting a route has to configure that route
-     * rather than rely on the stored value alone. */
+    /** The routing initialization settles for an agent, from the request config it reads. */
+    const routedAgent = (agent) => ({
+      ...agent,
+      deliveryRouting: resolveTurnDeliveryRouting({
+        agent,
+        config: TestClient.options.req?.config,
+      }),
+    });
+
+    /* The stored path is an upload-time inference, so delivery resolves it again by the
+     * routing settled for the agent running the turn. A test asserting a route has to
+     * configure that route rather than rely on the stored value alone. */
     const routeTo = (path, ...mimeTypes) => {
       TestClient.options.req = {
         config: {
@@ -3224,8 +3403,10 @@ describe('BaseClient', () => {
           },
         },
       };
-      TestClient._mergedFileConfig = undefined;
-      TestClient._endpointFileConfig = undefined;
+      TestClient.options.agent = routedAgent({
+        provider: EModelEndpoint.openAI,
+        endpoint: EModelEndpoint.openAI,
+      });
     };
 
     test('keeps a none image in returned files without adding image URLs', async () => {
@@ -3262,6 +3443,144 @@ describe('BaseClient', () => {
       expect(TestClient.getTextContextAttachments([file])).toEqual([]);
     });
 
+    const routeCsvToTools = ({ textFallbackWithoutTools = true } = {}) => {
+      routeTo('none', 'text/csv');
+      TestClient.options.req.config.fileConfig.endpoints[
+        EModelEndpoint.openAI
+      ].textFallbackWithoutTools = textFallbackWithoutTools;
+    };
+
+    test('injects the text stored for a tool-routed file when this turn runs no reader', () => {
+      routeCsvToTools();
+      TestClient.options.agent = {
+        provider: EModelEndpoint.openAI,
+        fileConsumers: { executeCode: false, fileSearch: false },
+      };
+      TestClient.options.agent.deliveryRouting = resolveTurnDeliveryRouting({
+        agent: TestClient.options.agent,
+        config: TestClient.options.req?.config,
+      });
+      /* Agent initialization marks the copy it hands this client, so the stored route reads
+       * `text` while the configured route stays `none`. */
+      const file = {
+        file_id: 'fallback-csv',
+        filename: 'sales.csv',
+        type: 'text/csv',
+        text: 'region,total',
+        llmDeliveryPath: 'text',
+        metadata: { destinationChosen: false },
+      };
+
+      expect(TestClient.getAttachmentDeliveryPath(file)).toBe('text');
+      expect(TestClient.getTextContextAttachments([file])).toEqual([file]);
+    });
+
+    test('delivers a late steer through fallback even when the initialized agent has file tools', async () => {
+      routeCsvToTools();
+      TestClient.options.agent = routedAgent({
+        provider: EModelEndpoint.openAI,
+        fileConsumers: { executeCode: true, fileSearch: true },
+      });
+      const file = {
+        file_id: 'late-csv',
+        filename: 'late.csv',
+        type: 'text/csv',
+        source: 'local',
+        text: 'region,total',
+        llmDeliveryPath: 'none',
+        metadata: { destinationChosen: false },
+      };
+      const assertFilesAllowed = jest.fn();
+      const initEncoding = jest.spyOn(Tokenizer, 'initEncoding').mockResolvedValue(undefined);
+      const getTokenCount = jest.spyOn(Tokenizer, 'getTokenCount').mockReturnValue(4);
+      let result;
+      try {
+        result = await buildSteerMedia({
+          client: {
+            resolveTurnAttachments: TestClient.resolveTurnAttachments.bind(TestClient),
+            addFileContextToMessage:
+              BaseClientClass.prototype.addFileContextToMessage.bind(TestClient),
+            processAttachments: BaseClientClass.prototype.processAttachments.bind(TestClient),
+          },
+          user: { id: 'user-1' },
+          item: { steerId: 'late', text: 'Read this file', files: [{ file_id: file.file_id }] },
+          getFiles: jest.fn().mockResolvedValue([file]),
+          assertFilesAllowed,
+        });
+      } finally {
+        initEncoding.mockRestore();
+        getTokenCount.mockRestore();
+      }
+      expect(assertFilesAllowed).toHaveBeenCalledWith([{ ...file, llmDeliveryPath: 'text' }]);
+      expect(JSON.stringify(result.content)).toContain('region,total');
+      expect(file.llmDeliveryPath).toBe('none');
+      expect(TestClient.options.agent.fileConsumers).toEqual({
+        executeCode: true,
+        fileSearch: true,
+      });
+    });
+
+    test('keeps a tool-routed file off the prompt when this turn can read it with code', () => {
+      routeCsvToTools();
+      TestClient.options.agent = {
+        provider: EModelEndpoint.openAI,
+        fileConsumers: { executeCode: true, fileSearch: false },
+      };
+      TestClient.options.agent.deliveryRouting = resolveTurnDeliveryRouting({
+        agent: TestClient.options.agent,
+        config: TestClient.options.req?.config,
+      });
+      const file = {
+        file_id: 'code-csv',
+        filename: 'sales.csv',
+        type: 'text/csv',
+        text: 'region,total',
+        llmDeliveryPath: 'none',
+        metadata: { destinationChosen: false },
+      };
+
+      expect(TestClient.getAttachmentDeliveryPath(file)).toBe('none');
+      expect(TestClient.getTextContextAttachments([file])).toEqual([]);
+    });
+
+    test('does not fall back on an endpoint that has not enabled it', () => {
+      routeCsvToTools({ textFallbackWithoutTools: false });
+      TestClient.options.agent = {
+        provider: EModelEndpoint.openAI,
+        fileConsumers: { executeCode: false, fileSearch: false },
+      };
+      TestClient.options.agent.deliveryRouting = resolveTurnDeliveryRouting({
+        agent: TestClient.options.agent,
+        config: TestClient.options.req?.config,
+      });
+      const file = {
+        file_id: 'disabled-csv',
+        filename: 'sales.csv',
+        type: 'text/csv',
+        text: 'region,total',
+        llmDeliveryPath: 'text',
+        metadata: { destinationChosen: false },
+      };
+
+      expect(TestClient.getAttachmentDeliveryPath(file)).toBe('none');
+      expect(TestClient.getTextContextAttachments([file])).toEqual([]);
+    });
+
+    test('does not fall back when the turn tools are unknown', () => {
+      routeCsvToTools();
+      TestClient.options.agent = { provider: EModelEndpoint.openAI };
+      const file = {
+        file_id: 'unknown-csv',
+        filename: 'sales.csv',
+        type: 'text/csv',
+        text: 'region,total',
+        llmDeliveryPath: 'none',
+        metadata: { destinationChosen: false },
+      };
+
+      expect(TestClient.getTextContextAttachments([file])).toEqual([]);
+    });
+
     test('does not inject extracted text when the current provider resolves native delivery', () => {
       routeTo('provider', 'application/pdf');
       const file = {
@@ -3327,17 +3646,19 @@ describe('BaseClient', () => {
       expect(TestClient.addImageURLs).not.toHaveBeenCalled();
     });
 
-    test('reads the Responses setting from a plain conversation too', async () => {
-      /* A non-agent Azure chat carries it in model options, and reading only the agent
-       * parameters re-resolves a natively supported PDF to text, which the record has
-       * none of, so the model receives nothing. */
+    test('reads the Responses setting the turn runs on from the settled routing', async () => {
+      /* Azure sends a PDF natively only under the Responses API. The routing carries the
+       * decision initialization made, so a record stored as `provider` is not resolved
+       * again to text it has none of, which would leave the model with nothing. */
       TestClient.options = {
-        endpoint: EModelEndpoint.azureOpenAI,
+        endpoint: EModelEndpoint.agents,
         req: { config: { fileConfig: undefined } },
       };
-      TestClient.modelOptions = { useResponsesApi: true };
-      TestClient._mergedFileConfig = undefined;
-      TestClient._endpointFileConfig = undefined;
+      TestClient.options.agent = routedAgent({
+        provider: EModelEndpoint.azureOpenAI,
+        endpoint: EModelEndpoint.azureOpenAI,
+        model_parameters: { useResponsesApi: true },
+      });
       const message = {};
       const file = {
         user: 'user1',
@@ -3353,7 +3674,6 @@ describe('BaseClient', () => {
       await TestClient.processAttachments(message, [file]);
 
       expect(TestClient.addDocuments).toHaveBeenCalled();
-      TestClient.modelOptions = undefined;
     });
 
     test('resolves a custom endpoint policy by the name the admin configured', async () => {
@@ -3377,8 +3697,7 @@ describe('BaseClient', () => {
           },
         },
       };
-      TestClient._mergedFileConfig = undefined;
-      TestClient._endpointFileConfig = undefined;
+      TestClient.options.agent = routedAgent(TestClient.options.agent);
       const message = {};
       const file = {
         user: 'user1',
@@ -3418,8 +3737,7 @@ describe('BaseClient', () => {
           },
         },
       };
-      TestClient._mergedFileConfig = undefined;
-      TestClient._endpointFileConfig = undefined;
+      TestClient.options.agent = routedAgent(TestClient.options.agent);
       const message = {};
       const file = {
         user: 'user1',
diff --git a/api/package.json b/api/package.json
index 5f38267f31b..1149d87d39c 100644
--- a/api/package.json
+++ b/api/package.json
@@ -46,7 +46,7 @@
     "@azure/storage-blob": "^12.30.0",
     "@google/genai": "^2.8.0",
     "@keyv/redis": "5.1.6",
-    "@librechat/agents": "^3.8.6",
+    "@librechat/agents": "^3.8.7",
     "@librechat/api": "*",
     "@librechat/data-schemas": "*",
     "@microsoft/microsoft-graph-client": "^3.0.7",
diff --git a/api/server/controllers/agents/client.js b/api/server/controllers/agents/client.js
index 4ae39e90a19..0176ad23ce1 100644
--- a/api/server/controllers/agents/client.js
+++ b/api/server/controllers/agents/client.js
@@ -137,6 +137,7 @@ const {
   isAttachmentObjectNotFoundError,
   buildAgentScopedContext,
   buildAgentScopedAttachmentMap,
+  resolveScopedTurnAttachments,
   buildAgentContextAttachmentsByAgentId,
   buildSkillPrimeContentParts,
   buildInitialToolSessions,
@@ -389,7 +390,7 @@ class AgentClient extends BaseClient {
     }
   }
 
-  async processAttachments(message, attachments) {
+  async processAttachments(message, attachments, fileConsumers) {
     const modelBoundAttachments = this.getModelBoundAttachmentsForEndpoint(attachments);
     const processableAttachments = this.getProcessableAttachmentsForEndpoint(
       attachments,
@@ -409,7 +410,7 @@ class AgentClient extends BaseClient {
     };
     logAgentMemorySnapshot('before_process_attachments', memoryContext);
     try {
-      return await super.processAttachments(message, processableAttachments);
+      return await super.processAttachments(message, processableAttachments, fileConsumers);
     } finally {
       logAgentMemorySnapshot('after_process_attachments', memoryContext);
     }
@@ -2374,6 +2375,16 @@ class AgentClient extends BaseClient {
       ...modelBoundRequestAttachments,
     ];
     const sharedRunAttachmentIds = collectFileIds(sharedAttachmentFiles);
+    this.options.agentContextAttachmentsByAgentId = resolveScopedTurnAttachments({
+      agents: allAgents,
+      sharedConversationAgentIds: [this.options.agent.id, ...(this.agentConfigs?.keys() ?? [])],
+      resendFiles: this.options.resendFiles,
+      messages: orderedMessages,
+      historicalFiles: this.authorizedHistoricalFiles,
+      requestAttachments,
+      sharedRunAttachmentIds,
+      attachmentsByAgentId: this.options.agentContextAttachmentsByAgentId,
+    });
     const scopedAttachmentMap = buildAgentScopedAttachmentMap({
       agentIds: allAgents.map(({ agentId }) => agentId),
       attachmentsByAgentId: this.options.agentContextAttachmentsByAgentId,
diff --git a/api/server/controllers/agents/client.test.js b/api/server/controllers/agents/client.test.js
index 7a986a19cf0..852487c2de9 100644
--- a/api/server/controllers/agents/client.test.js
+++ b/api/server/controllers/agents/client.test.js
@@ -5471,6 +5471,9 @@ describe('AgentClient - titleConvo', () => {
         },
       };
       mockRes = {};
+      mockAgent.deliveryRouting = jest
+        .requireActual('@librechat/api')
+        .resolveTurnDeliveryRouting({ agent: mockAgent, config: mockReq.config });
 
       client = new AgentClient({
         req: mockReq,
@@ -6708,6 +6711,71 @@ describe('AgentClient - titleConvo', () => {
       },
     );
 
+    it.each(['current', 'history', 'history-disabled'])(
+      'resolves %s tool-routed text only for an authorized handoff without a reader',
+      async (location) => {
+        const file = {
+          ...makeUploadedFile('fallback-file', 'sales.csv', 'text/csv'),
+          text: 'handoff fallback content',
+          llmDeliveryPath: 'none',
+          metadata: { destinationChosen: false },
+        };
+        const { resolveTurnDeliveryRouting } = jest.requireActual('@librechat/api');
+        client.options.req.config.fileConfig = {
+          endpoints: {
+            default: {
+              defaultLLMDeliveryPath: { overrides: { 'text/csv': 'none' } },
+              textFallbackWithoutTools: true,
+            },
+          },
+        };
+        mockAgent.deliveryRouting = resolveTurnDeliveryRouting({
+          agent: mockAgent,
+          config: client.options.req.config,
+        });
+        mockAgent.fileConsumers = { executeCode: true, fileSearch: false };
+        const handoffAgent = {
+          id: 'handoff-agent',
+          endpoint: EModelEndpoint.openAI,
+          provider: EModelEndpoint.openAI,
+          instructions: 'Handoff instructions',
+          model_parameters: { model: 'gpt-4' },
+          tools: [],
+          deliveryRouting: mockAgent.deliveryRouting,
+          fileConsumers: { executeCode: false, fileSearch: false },
+        };
+        const isolatedAgent = { ...handoffAgent, id: 'isolated-agent' };
+        mockAgent.subagentAgentConfigs = new Map([['isolated-agent', isolatedAgent]]);
+        client.agentConfigs = new Map([['handoff-agent', handoffAgent]]);
+        client.options.resendFiles = location !== 'history-disabled';
+        client.options.attachments = location === 'current' ? [file] : [];
+        client.authorizedHistoricalFiles = new Map([[file.file_id, file]]);
+        client.message_file_map = {};
+        const messages = [
+          {
+            messageId: 'msg-1',
+            sender: 'User',
+            text: 'Read it',
+            isCreatedByUser: true,
+            ...(location !== 'current' ? { files: [{ file_id: file.file_id }] } : {}),
+          },
+        ];
+        const result = await client.buildMessages(messages, 'msg-1', {});
+        expect(JSON.stringify(result.prompt)).not.toContain(file.text);
+        expect(mockAgent.additional_instructions ?? '').not.toContain(file.text);
+        expect(isolatedAgent.additional_instructions ?? '').not.toContain(file.text);
+        if (location === 'history-disabled') {
+          expect(handoffAgent.additional_instructions ?? '').not.toContain(file.text);
+        } else {
+          expect(handoffAgent.additional_instructions).toContain(file.text);
+          expect(client.turnScopedAttachmentsByAgentId.get('handoff-agent')).toEqual([
+            { ...file, llmDeliveryPath: 'text' },
+          ]);
+        }
+        expect(file.llmDeliveryPath).toBe('none');
+      },
+    );
+
     it('places request context inline and applies each agent context doc only once', async () => {
       const requestFile = makeTextFile('request-file', 'request.txt', 'Shared request context');
       const primaryContext = makeTextFile(
diff --git a/api/server/routes/files/files.agents.test.js b/api/server/routes/files/files.agents.test.js
index 4323a28e817..45b082601d1 100644
--- a/api/server/routes/files/files.agents.test.js
+++ b/api/server/routes/files/files.agents.test.js
@@ -427,6 +427,33 @@ describe('File Routes - Agent Files Endpoint', () => {
       return testApp;
     };
 
+    it.each([
+      [false, 'application/json'],
+      [true, 'text/event-stream'],
+    ])(
+      'rejects unsupported provider audio before persistence (legacy=%s, accept=%s)',
+      async (legacyFileUploadUX, accept) => {
+        const testApp = createAppWithUser(
+          otherUserId,
+          SystemRoles.USER,
+          {
+            fileConfig: {
+              endpoints: { MyGateway: { supportedMimeTypes: ['audio/.*'], legacyFileUploadUX } },
+            },
+          },
+          { originalname: 'clip.wma', mimetype: 'audio/wma' },
+        );
+        const response = await request(testApp).post('/files').set('Accept', accept).send({
+          endpoint: 'MyGateway',
+          file_id: uuidv4(),
+        });
+        expect(response.status).toBe(415);
+        expect(response.body.message).toBe('com_error_files_provider_audio_format');
+        expect(processAgentFileUpload).not.toHaveBeenCalled();
+        expect(fs.unlink).toHaveBeenCalledWith('/tmp/test.txt');
+      },
+    );
+
     it('inspects the canonical sanitized filename used by upload processing', async () => {
       await createAgent({
         id: agentCustomId,
diff --git a/api/server/routes/files/images.js b/api/server/routes/files/images.js
index 7e5512f0cd1..435027a3b0c 100644
--- a/api/server/routes/files/images.js
+++ b/api/server/routes/files/images.js
@@ -23,6 +23,7 @@ const {
   resolveUploadLLMDeliveryPath,
   isResponsesApiUpload,
   isSpeechProviderConfigured,
+  getCustomEndpointProvider,
 } = require('librechat-data-provider');
 const {
   processAgentFileUpload,
@@ -107,6 +108,7 @@ router.post('/', async (req, res) => {
       endpointConfig: getEndpointFileConfig({ fileConfig, endpoint: effectiveEndpoint }),
       fileConfig,
       endpoint: effectiveEndpoint,
+      endpointProvider: getCustomEndpointProvider(req.config?.endpoints?.custom, effectiveEndpoint),
       useResponsesApi: isResponsesApiUpload(metadata.useResponsesApi),
       sttConfigured: isSpeechProviderConfigured(req.config?.speech?.stt),
     });
diff --git a/api/server/services/Endpoints/agents/skillDeps.js b/api/server/services/Endpoints/agents/skillDeps.js
index c8aa0f2b303..7f695bbfea0 100644
--- a/api/server/services/Endpoints/agents/skillDeps.js
+++ b/api/server/services/Endpoints/agents/skillDeps.js
@@ -291,10 +291,11 @@ function buildAgentToolContext({ agent, config }) {
     agent,
     fileEncodingAgent: {
       provider: config.provider,
-      endpoint: config.endpoint,
       model_parameters: config.model_parameters,
       imageDetail: config.imageDetail,
       agentContextAttachments: config.agentContextAttachments,
+      fileConsumers: config.fileConsumers,
+      deliveryRouting: config.deliveryRouting,
     },
     /** Per-agent resolved endpoint token/pricing config. Retained here because
      *  `agentToolContexts` is the one map that holds every agent — including
diff --git a/api/server/services/Files/process.js b/api/server/services/Files/process.js
index 0a5705e60c3..05b02ae6df6 100644
--- a/api/server/services/Files/process.js
+++ b/api/server/services/Files/process.js
@@ -25,6 +25,7 @@ const {
   isMessageFileUpload,
   isResponsesApiUpload,
   isSpeechProviderConfigured,
+  getCustomEndpointProvider,
 } = require('librechat-data-provider');
 const { logger, runAsSystem } = require('@librechat/data-schemas');
 const {
@@ -35,7 +36,9 @@ const {
   assertExtractedTextInspectable,
   getFileExtractionLogDetails,
   getUploadExtractedTextPlan,
+  resolveUploadFallbackText,
   UPLOAD_EXTRACTED_TEXT_PLANS,
+  MAX_STORED_EXTRACTED_TEXT_BYTES,
   inspectContent,
   extractFileContent,
   hasActiveFileFieldPolicy,
@@ -494,6 +497,7 @@ const processImageFile = async ({ req, res, metadata, returnFile = false, sseStr
     endpointConfig,
     fileConfig,
     endpoint: configEndpoint,
+    endpointProvider: getCustomEndpointProvider(appConfig?.endpoints?.custom, configEndpoint),
     useResponsesApi: isResponsesApiUpload(metadata.useResponsesApi ?? req.body?.useResponsesApi),
     sttConfigured: isSpeechProviderConfigured(appConfig?.speech?.stt),
   });
@@ -810,6 +814,7 @@ const processAgentFileUpload = async ({ req, res, metadata, sseStream }) => {
     endpointConfig,
     fileConfig,
     endpoint,
+    endpointProvider: getCustomEndpointProvider(appConfig?.endpoints?.custom, endpoint),
     useResponsesApi: isResponsesApiUpload(metadata.useResponsesApi ?? req.body?.useResponsesApi),
     sttConfigured: isSpeechProviderConfigured(appConfig?.speech?.stt),
   });
@@ -939,9 +944,9 @@ const processAgentFileUpload = async ({ req, res, metadata, sseStream }) => {
         });
       }
       const textBytes = Buffer.byteLength(text, 'utf8');
-      if (textBytes > 15 * megabyte) {
+      if (textBytes > MAX_STORED_EXTRACTED_TEXT_BYTES) {
         throw new Error(
-          `Extracted text from "${file.originalname}" exceeds the 15MB storage limit (${Math.round(textBytes / megabyte)}MB). Try a shorter document.`,
+          `Extracted text from "${file.originalname}" exceeds the ${MAX_STORED_EXTRACTED_TEXT_BYTES / megabyte}MB storage limit (${Math.round(textBytes / megabyte)}MB). Try a shorter document.`,
         );
       }
       if (
@@ -1149,6 +1154,17 @@ const processAgentFileUpload = async ({ req, res, metadata, sseStream }) => {
     return await createTextFile({ text });
   }
 
+  /* Extracted before storage, which may move the temporary upload the extractors read. */
+  const fallbackText = await resolveUploadFallbackText({
+    file,
+    fileId: file_id,
+    deliveryPath: llmDeliveryPath,
+    destinationChosen: uploadChoiceMetadata.destinationChosen,
+    isMessageAttachment: messageAttachment,
+    endpointConfig,
+    filters: appConfig?.filters,
+  });
+
   // Dual storage pattern for RAG files: Storage + Vector DB
   let storageResult, embeddingResult;
   let storedType = file.mimetype;
@@ -1345,6 +1361,7 @@ const processAgentFileUpload = async ({ req, res, metadata, sseStream }) => {
       width,
       tenantId: req.user.tenantId,
       llmDeliveryPath,
+      text: fallbackText,
     }),
     ...retentionExpiry,
   };
diff --git a/api/server/services/Files/process.spec.js b/api/server/services/Files/process.spec.js
index fbf1aca9b4e..efbb8a1b008 100644
--- a/api/server/services/Files/process.spec.js
+++ b/api/server/services/Files/process.spec.js
@@ -125,6 +125,9 @@ jest.mock('@librechat/api', () => {
     /** Grants both; these specs vary the capability set, not the role. */
     resolveToolRoleGrants: jest.fn(async () => ({ runCode: true, fileSearch: true })),
     parseText: jest.fn().mockResolvedValue({ text: '', bytes: 0 }),
+    /** Stores no fallback text unless a test opts in; its own rules are covered in packages/api. */
+    resolveUploadFallbackText: jest.fn(async () => undefined),
+    MAX_STORED_EXTRACTED_TEXT_BYTES: 15 * 1024 * 1024,
     processAudioFile: jest.fn(),
     extractInspectableFileText: jest.fn(async ({ extract }) => extract()),
     assertExtractedTextInspectable: jest.fn(),
@@ -3190,3 +3193,104 @@ describe('filterFile endpoint resolution', () => {
     expect(() => filterFile({ req, image: true, isAvatar: true })).not.toThrow();
   });
 });
+
+describe('fallback text for uploads left to tools', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+    mockRes.status.mockReturnThis();
+    mockRes.json.mockReturnValue({});
+    mergeFileConfig.mockReturnValue({
+      ...makeFileConfig(),
+      endpoints: {
+        'Custom Provider': {
+          defaultLLMDeliveryPath: { fallback: 'none' },
+          textFallbackWithoutTools: true,
+        },
+      },
+    });
+  });
+
+  const uploadCsv = (metadata) => {
+    const req = makeReq({ mimetype: 'text/csv', ocrConfig: null });
+    req.body.endpoint = EModelEndpoint.agents;
+    return {
+      req,
+      upload: processAgentFileUpload({
+        req,
+        res: mockRes,
+        metadata: {
+          agent_id: 'agent-abc',
+          message_file: 'true',
+          file_id: 'file-uuid-csv',
+          effectiveEndpoint: 'Custom Provider',
+          ...metadata,
+        },
+      }),
+    };
+  };
+
+  test('stores the text a turn without a reading tool can fall back to', async () => {
+    const { createFile } = require('~/models');
+    const { resolveUploadFallbackText } = require('@librechat/api');
+    setupStoredFileUpload();
+    resolveUploadFallbackText.mockResolvedValueOnce('region,total');
+
+    const { req, upload } = uploadCsv();
+    await upload;
+
+    expect(resolveUploadFallbackText).toHaveBeenCalledWith(
+      expect.objectContaining({
+        file: req.file,
+        fileId: 'file-uuid-csv',
+        deliveryPath: 'none',
+        destinationChosen: false,
+        isMessageAttachment: true,
+        endpointConfig: expect.objectContaining({ textFallbackWithoutTools: true }),
+      }),
+    );
+    expect(createFile).toHaveBeenCalledWith(
+      expect.objectContaining({ llmDeliveryPath: 'none', text: 'region,total' }),
+      true,
+    );
+  });
+
+  test('marks a legacy chooser upload as chosen, so no fallback text is extracted for it', async () => {
+    const { resolveUploadFallbackText } = require('@librechat/api');
+    mergeFileConfig.mockReturnValue({
+      ...makeFileConfig(),
+      endpoints: {
+        'Custom Provider': {
+          defaultLLMDeliveryPath: { fallback: 'none' },
+          textFallbackWithoutTools: true,
+          legacyFileUploadUX: true,
+        },
+      },
+    });
+    setupStoredFileUpload();
+
+    const { upload } = uploadCsv();
+    await upload;
+
+    expect(resolveUploadFallbackText).toHaveBeenCalledWith(
+      expect.objectContaining({ destinationChosen: true, isMessageAttachment: true }),
+    );
+  });
+
+  test('stores fallback text for an attachment filed under a tool a later turn may not run', async () => {
+    const { createFile } = require('~/models');
+    const { resolveUploadFallbackText } = require('@librechat/api');
+    setupStoredFileUpload();
+    resolveUploadFallbackText.mockResolvedValueOnce('region,total');
+
+    const { upload } = uploadCsv({ agentTools: [EToolResources.execute_code] });
+    await upload;
+
+    expect(resolveUploadFallbackText).toHaveBeenCalledWith(
+      expect.objectContaining({ destinationChosen: false, isMessageAttachment: true }),
+    );
+    expect(createFile).toHaveBeenCalledWith(
+      expect.objectContaining({ llmDeliveryPath: 'none', text: 'region,total' }),
+      true,
+    );
+  });
+});
diff --git a/api/server/services/ToolService.js b/api/server/services/ToolService.js
index 6994c106d3a..3afc2ba13ef 100644
--- a/api/server/services/ToolService.js
+++ b/api/server/services/ToolService.js
@@ -2280,6 +2280,7 @@ async function loadToolsForExecution({
               authHeaders,
               baseUrl: codeExecutionContext.baseUrl,
               workspaceId: codeExecutionContext.codeWorkspace.workspaceId,
+              environment: codeExecutionContext.codeWorkspace.environment,
               gitIdentity: agent?.git_identity,
               maxTimeoutMs: resolveAttachedWorkspaceCommandTimeoutMax(
                 codeExecutionContext.codeEnvironmentConfigSchema,
diff --git a/client/src/common/types.ts b/client/src/common/types.ts
index 2c39712cbd1..6d1ec5ce2a9 100644
--- a/client/src/common/types.ts
+++ b/client/src/common/types.ts
@@ -596,6 +596,7 @@ export interface ExtendedFile {
   source?: FileSources;
   attached?: boolean;
   embedded?: boolean;
+  llmDeliveryPath?: t.TFile['llmDeliveryPath'];
   tool_resource?: string;
   metadata?: t.TFile['metadata'];
 }
diff --git a/client/src/components/Chat/ChatView.tsx b/client/src/components/Chat/ChatView.tsx
index 8e127931f5b..bb8ffcb3511 100644
--- a/client/src/components/Chat/ChatView.tsx
+++ b/client/src/components/Chat/ChatView.tsx
@@ -14,6 +14,7 @@ import {
   useAdaptiveSSE,
   useChatHelpers,
   useQueueDrain,
+  useQueuedTurnReveal,
   useLocalize,
 } from '~/hooks';
 import { ChatContext, AddedChatContext, ChatFormProvider, useFileMapContext } from '~/Providers';
@@ -105,8 +106,12 @@ function ChatView({ index = 0, project }: { index?: number; project?: TChatProje
   // refetch is in flight, and resume must not build from (or race) it.
   useResumeOnLoad(conversationId, chatHelpers.getMessages, index, !isLoading && !isFetching);
 
+  // Show a server-owned queued follow-up as the next user turn as soon as its
+  // predecessor completes, ahead of the receipt and active-job polls.
+  const revealQueuedTurn = useQueuedTurnReveal(conversationId, index);
+
   // Auto-send queued follow-up messages once a run finishes cleanly.
-  useQueueDrain(index, conversationId, chatHelpers.ask);
+  useQueueDrain(index, conversationId, chatHelpers.ask, revealQueuedTurn);
 
   let content: JSX.Element | null | undefined;
   const isLandingPage =
diff --git a/client/src/components/Chat/Input/ChatForm.tsx b/client/src/components/Chat/Input/ChatForm.tsx
index 6bc3a9715b4..dd0b1e8e92d 100644
--- a/client/src/components/Chat/Input/ChatForm.tsx
+++ b/client/src/components/Chat/Input/ChatForm.tsx
@@ -57,6 +57,7 @@ import FileFormChat from './Files/FileFormChat';
 import InFlightSteers from './InFlightSteers';
 import TextareaHeader from './TextareaHeader';
 import PromptsCommand from './PromptsCommand';
+import { submitFromComposer } from './submit';
 import SkillsCommand from './SkillsCommand';
 import AudioRecorder from './AudioRecorder';
 import AutoPlayAudio from './AutoPlayAudio';
@@ -70,6 +71,26 @@ import BadgeRow from './BadgeRow';
 import Mention from './Mention';
 import store from '~/store';
 
+export function toRestoredComposerFile(
+  file: NonNullable<TMessage['files']>[number],
+): ExtendedFile | null {
+  if (!file.file_id) {
+    return null;
+  }
+  return {
+    file_id: file.file_id,
+    filename: file.filename,
+    filepath: file.filepath,
+    type: file.type ?? '',
+    height: file.height,
+    width: file.width,
+    size: file.bytes ?? 0,
+    progress: 1,
+    attached: true,
+    llmDeliveryPath: file.llmDeliveryPath,
+  };
+}
+
 interface ChatFormProps {
   index: number;
   placeholder?: string;
@@ -259,7 +280,7 @@ const ChatForm = memo(function ChatForm({
    *  collapsed batch is neither — it hands the composer back to the thread. */
   const composerReserved = answerMode.composerAnswers || answerMode.composerLocked;
 
-  useAutoSave({
+  const consumeDraft = useAutoSave({
     index,
     files,
     setFiles,
@@ -346,20 +367,11 @@ const ChatForm = memo(function ChatForm({
         setFiles((prev) => {
           const next = new Map(prev);
           for (const file of chipFiles) {
-            if (!file.file_id) {
+            const restoredFile = toRestoredComposerFile(file);
+            if (restoredFile == null) {
               continue;
             }
-            next.set(file.file_id, {
-              file_id: file.file_id,
-              filename: file.filename,
-              filepath: file.filepath,
-              type: file.type ?? '',
-              height: file.height,
-              width: file.width,
-              size: file.bytes ?? 0,
-              progress: 1,
-              attached: true,
-            });
+            next.set(restoredFile.file_id, restoredFile);
           }
           return next;
         });
@@ -370,6 +382,7 @@ const ChatForm = memo(function ChatForm({
     [methods, setFiles, restoreComposerContext],
   );
   const steering = useSteering({
+    consumeDraft,
     index,
     conversationId,
     conversation,
@@ -602,25 +615,27 @@ const ChatForm = memo(function ChatForm({
     bottomClearance = 'sm:mb-10';
   }
 
+  /** Answer mode, then during-run steering or queueing (a run in flight, or a
+   *  queued follow-up about to start), then an ordinary send: the same route
+   *  for typed, dictated, and shortcut-bound submissions. */
+  const submitComposerText = useCallback(
+    (data: { text: string }): false | void =>
+      submitFromComposer(
+        {
+          answerMode,
+          steering,
+          submitMessage,
+          reset: () => methods.reset(),
+        },
+        data,
+      ),
+    [answerMode, steering, submitMessage, methods],
+  );
+
   return (
     <form
       onSubmit={methods.handleSubmit((data) => {
-        // Answer mode: composer text answers the paused run instead of
-        // starting a new turn (submitText resets the composer itself).
-        // Dismissing the popover — or collapsing a batch, which answers in its
-        // own card — restores normal sends.
-        if (answerMode.active && answerMode.submitText(data.text)) {
-          return;
-        }
-        // During a run, a submit steers or queues per the effective action
-        // instead of starting a new turn (which would be dropped anyway).
-        if (steering.duringRunActive) {
-          if (steering.submitDuringRun(data.text)) {
-            methods.reset();
-          }
-          return;
-        }
-        return submitMessage(data);
+        submitComposerText(data);
       })}
       className={cn(
         /* `margin-bottom` is animated as well as `max-width`: it is what carries
@@ -855,7 +870,7 @@ const ChatForm = memo(function ChatForm({
                   conversation={conversation}
                   addedConversation={addedConvo}
                   setConversation={setConversation}
-                  disabled={disableInputs || isSubmitting}
+                  disabled={disableInputs}
                 />
                 {index === 0 && conversationId != null && (
                   <PendingToolApprovalButton conversationId={conversationId} />
@@ -865,7 +880,7 @@ const ChatForm = memo(function ChatForm({
                 {SpeechToText && (
                   <AudioRecorder
                     methods={methods}
-                    ask={submitMessage}
+                    ask={submitComposerText}
                     disabled={disableInputs || isNotAppendable}
                     isSubmitting={isSubmitting}
                   />
diff --git a/client/src/components/Chat/Input/CodeApprovalMenu.tsx b/client/src/components/Chat/Input/CodeApprovalMenu.tsx
index d4e78ec4b75..85446bf57ee 100644
--- a/client/src/components/Chat/Input/CodeApprovalMenu.tsx
+++ b/client/src/components/Chat/Input/CodeApprovalMenu.tsx
@@ -1,4 +1,6 @@
 import * as Ariakit from '@ariakit/react';
+import { useQueryClient } from '@tanstack/react-query';
+import { QueryKeys, Constants } from 'librechat-data-provider';
 import { TooltipAnchor, composerControlClasses } from '@librechat/client';
 import { Check, ChevronDown, FilePen, FileQuestionMark, FileTerminal } from 'lucide-react';
 import type { CodeApprovalMode, TConversation } from 'librechat-data-provider';
@@ -47,6 +49,7 @@ export default function CodeApprovalMenu({
   disabled: boolean;
 }) {
   const localize = useLocalize();
+  const queryClient = useQueryClient();
   const { available, modes, selected } = useCodeApprovalMode(conversation, addedConversation);
   const menuStore = Ariakit.useMenuStore({ focusLoop: true, placement: 'top-start' });
   const isOpen = menuStore.useState('open');
@@ -55,6 +58,11 @@ export default function CodeApprovalMenu({
     return null;
   }
 
+  /** Navigation and run recovery rebuild the conversation from its detail
+   *  cache, so the pick lands there too, seeding the record from the live
+   *  conversation when none exists yet (the resumable transport seeds the same
+   *  key optimistically). A chat that has no id yet keeps the pick in
+   *  conversation state alone until the run assigns one. */
   const selectMode = (mode: CodeApprovalMode) => {
     if (!modes.includes(mode)) {
       return;
@@ -62,6 +70,15 @@ export default function CodeApprovalMenu({
     setConversation((current) =>
       current == null ? current : { ...current, codeApprovalMode: mode },
     );
+    const record = conversation;
+    const conversationId = record?.conversationId;
+    if (record == null || conversationId == null || conversationId === Constants.NEW_CONVO) {
+      return;
+    }
+    queryClient.setQueryData<TConversation>([QueryKeys.conversation, conversationId], (cached) => ({
+      ...(cached ?? record),
+      codeApprovalMode: mode,
+    }));
   };
 
   const SelectedIcon = modeOptions[selected].icon;
diff --git a/client/src/components/Chat/Input/CodeWorkspaceMenu.tsx b/client/src/components/Chat/Input/CodeWorkspaceMenu.tsx
index d71265f96c8..783f1f00a2e 100644
--- a/client/src/components/Chat/Input/CodeWorkspaceMenu.tsx
+++ b/client/src/components/Chat/Input/CodeWorkspaceMenu.tsx
@@ -123,6 +123,13 @@ function EnvironmentWorkspaces({
               {descriptor.name && (
                 <p className="truncate text-xs text-text-secondary">{descriptor.id}</p>
               )}
+              {(descriptor.environment?.repo || descriptor.environment?.ref) && (
+                <p className="truncate text-xs text-text-secondary">
+                  {[descriptor.environment.repo, descriptor.environment.ref]
+                    .filter(Boolean)
+                    .join(' · ')}
+                </p>
+              )}
             </div>
             {selected && (
               <Check className="mt-0.5 size-4 shrink-0 text-text-primary" aria-hidden="true" />
diff --git a/client/src/components/Chat/Input/Files/AttachFileMenu.tsx b/client/src/components/Chat/Input/Files/AttachFileMenu.tsx
index 71f89b03ee4..ead2d57bc1d 100644
--- a/client/src/components/Chat/Input/Files/AttachFileMenu.tsx
+++ b/client/src/components/Chat/Input/Files/AttachFileMenu.tsx
@@ -20,6 +20,7 @@ import {
   Providers,
   EToolResources,
   EModelEndpoint,
+  isExplicitMimeConfig,
   getConfiguredMimeAccept,
   bedrockDocumentMimeTypes,
   defaultAgentCapabilities,
@@ -52,7 +53,8 @@ type FileUploadType =
   | 'document'
   | 'image_document'
   | 'image_document_extended'
-  | 'image_document_video_audio';
+  | 'image_document_video_audio'
+  | 'image_document_video_audio_configured';
 
 /** What each provider upload path can actually send, used to scope the picker filter to selectable files. */
 const fileTypeCapabilities: Record<FileUploadType, MimeUploadCapability> = {
@@ -68,6 +70,10 @@ const fileTypeCapabilities: Record<FileUploadType, MimeUploadCapability> = {
     categories: ['image', 'document', 'audio', 'video'],
     documentMimeTypes: ['application/pdf'],
   },
+  /** Custom endpoint with an admin-configured allowlist: the config decides, including video/audio. */
+  image_document_video_audio_configured: {
+    categories: ['image', 'document', 'audio', 'video'],
+  },
 };
 
 interface AttachFileMenuProps {
@@ -164,6 +170,10 @@ const AttachFileMenu = ({
         inputRef.current.accept = `image/*,.heif,.heic,${bedrockDocumentExtensions}`;
       } else if (fileType === 'image_document_video_audio') {
         inputRef.current.accept = 'image/*,.heif,.heic,.pdf,application/pdf,video/*,audio/*';
+      } else if (fileType === 'image_document_video_audio_configured') {
+        /** Only reached with an explicit allowlist the accept string cannot represent; leave the
+         * picker open so it never hides a file the admin allowed (backend still enforces). */
+        inputRef.current.accept = '';
       } else {
         inputRef.current.accept = '';
       }
@@ -237,6 +247,11 @@ const AttachFileMenu = ({
               endpointType === EModelEndpoint.bedrock
             ) {
               fileType = 'image_document_extended';
+            } else if (
+              endpointType === EModelEndpoint.custom &&
+              isExplicitMimeConfig(endpointFileConfig?.supportedMimeTypes)
+            ) {
+              fileType = 'image_document_video_audio_configured';
             }
             onAction(fileType);
           },
@@ -324,6 +339,7 @@ const AttachFileMenu = ({
     handleUploadClick,
     setEphemeralAgent,
     sharePointEnabled,
+    endpointFileConfig?.supportedMimeTypes,
     codeAllowedByAgent,
     fileSearchAllowedByAgent,
     setIsSharePointDialogOpen,
diff --git a/client/src/components/Chat/Input/Files/__tests__/AttachFileMenu.spec.tsx b/client/src/components/Chat/Input/Files/__tests__/AttachFileMenu.spec.tsx
index 13d60564e41..7fcd7ba32bf 100644
--- a/client/src/components/Chat/Input/Files/__tests__/AttachFileMenu.spec.tsx
+++ b/client/src/components/Chat/Input/Files/__tests__/AttachFileMenu.spec.tsx
@@ -208,6 +208,46 @@ describe('AttachFileMenu', () => {
     });
   });
 
+  describe('Upload to Provider picker filter', () => {
+    /** `accept` is reset right after `click()`, so capture it at click time. */
+    const captureAcceptOnClick = () => {
+      const seen: string[] = [];
+      const spy = jest.spyOn(HTMLInputElement.prototype, 'click').mockImplementation(function (
+        this: HTMLInputElement,
+      ) {
+        seen.push(this.accept);
+      });
+      return { seen, spy };
+    };
+
+    it('keeps images and PDFs only for a custom endpoint with the inherited default config', () => {
+      const { seen, spy } = captureAcceptOnClick();
+      setupMocks({ provider: 'MyGateway' });
+      renderMenu({ endpointType: EModelEndpoint.custom, endpointFileConfig: {} });
+      openMenu();
+      fireEvent.click(screen.getByText('Upload to Provider'));
+      expect(seen).toEqual(['image/*,.heif,.heic,.pdf,application/pdf']);
+      spy.mockRestore();
+    });
+
+    it('adds video when a custom endpoint config explicitly allows it', () => {
+      const { seen, spy } = captureAcceptOnClick();
+      setupMocks({ provider: 'MyGateway' });
+      renderMenu({
+        endpointType: EModelEndpoint.custom,
+        endpointFileConfig: {
+          supportedMimeTypes: [/^image\/.*$/, /^application\/pdf$/, /^video\/.*$/],
+        },
+      });
+      openMenu();
+      fireEvent.click(screen.getByText('Upload to Provider'));
+      expect(seen).toHaveLength(1);
+      expect(seen[0]).toContain('video/*');
+      expect(seen[0]).not.toContain('audio/*');
+      spy.mockRestore();
+    });
+  });
+
   describe('Upload to Provider vs Upload Image', () => {
     it('shows "Upload to Provider" when endpointType is custom (resolved from agent provider)', () => {
       setupMocks({ provider: 'Moonshot' });
diff --git a/client/src/components/Chat/Input/InFlightSteers.tsx b/client/src/components/Chat/Input/InFlightSteers.tsx
index 5884663c400..12623319b07 100644
--- a/client/src/components/Chat/Input/InFlightSteers.tsx
+++ b/client/src/components/Chat/Input/InFlightSteers.tsx
@@ -15,6 +15,7 @@ import {
   useDefaultToggleEntry,
   useInterruptToggleEntry,
 } from './SteerMenu';
+import { carriedSteerContext, cn, hydrateFileDeliveryMetadata, usesImagePreview } from '~/utils';
 import FilePreviewDialog from '~/components/Chat/Messages/Content/FilePreviewDialog';
 import { supportsGenerationProtocolV2, useArmSteerMutation } from '~/data-provider';
 import { steerOverlayHeightFamily, escalatingSteerFamily } from '~/store/steer';
@@ -25,7 +26,7 @@ import FileContainer from '~/components/Chat/Input/Files/FileContainer';
 import { useSteerCancel, useSteerReclaim, useLocalize } from '~/hooks';
 import ImagePreview from '~/components/Chat/Input/Files/ImagePreview';
 import SteerReceipt from '~/components/Chat/Steering/Receipt';
-import { carriedSteerContext, cn } from '~/utils';
+import { useFileMapContext } from '~/Providers';
 import store from '~/store';
 
 /** Restores a message's text into the composer, or refuses (false) when the
@@ -42,7 +43,7 @@ const splitFiles = (files?: TMessage['files']) => {
   const images: NonNullable<TMessage['files']> = [];
   const others: NonNullable<TMessage['files']> = [];
   for (const file of files ?? []) {
-    (file.type?.startsWith('image/') === true ? images : others).push(file);
+    (usesImagePreview(file) ? images : others).push(file);
   }
   return { images, others };
 };
@@ -609,6 +610,7 @@ const InFlightSteer = memo(function InFlightSteer({
           fileType={selectedFile?.type ?? undefined}
           fileSource={selectedFile?.source}
           fileSize={(selectedFile as TFile | null)?.bytes}
+          deliveryPath={selectedFile?.llmDeliveryPath}
         />
       )}
     </div>
@@ -632,7 +634,17 @@ const InFlightSteers = memo(function InFlightSteers({
 }) {
   const localize = useLocalize();
   const steers = useRecoilValue(store.pendingSteersByConvoId(conversationId));
-  const inFlight = useMemo(() => steers.filter((steer) => steer.status !== 'failed'), [steers]);
+  const fileMap = useFileMapContext();
+  const inFlight = useMemo(
+    () =>
+      steers
+        .filter((steer) => steer.status !== 'failed')
+        .map((steer) => {
+          const files = hydrateFileDeliveryMetadata(steer.files, undefined, fileMap);
+          return files === steer.files ? steer : { ...steer, files };
+        }),
+    [fileMap, steers],
+  );
   /** Mirrors `PendingSteerChips`: while one interrupt is unresolved, every
    *  other escalation control disables rather than arming a second seal. The
    *  escalating flag covers an arm request's round trip, before its chip
diff --git a/client/src/components/Chat/Input/PendingSteerChips.tsx b/client/src/components/Chat/Input/PendingSteerChips.tsx
index 04078e80ee6..2467a7e588c 100644
--- a/client/src/components/Chat/Input/PendingSteerChips.tsx
+++ b/client/src/components/Chat/Input/PendingSteerChips.tsx
@@ -27,8 +27,8 @@ import {
   useDefaultToggleEntry,
   useInterruptToggleEntry,
 } from './SteerMenu';
+import { escalatingSteerFamily, revealedQueuedTurnFamily } from '~/store/steer';
 import { QUEUE_ICON, STEER_ICON } from '~/components/Chat/Steering/identity';
-import { escalatingSteerFamily } from '~/store/steer';
 import { useLocalize } from '~/hooks';
 import { cn } from '~/utils';
 import store from '~/store';
@@ -109,6 +109,7 @@ function QueuedRow({
   steering,
   conversationId,
   interruptPending,
+  revealed,
   onEditToComposer,
   onRestoreToComposer,
 }: {
@@ -116,6 +117,8 @@ function QueuedRow({
   steering: SteeringControls;
   conversationId: string;
   interruptPending: boolean;
+  /** Shown as the next user turn already; only removal remains meaningful. */
+  revealed?: boolean;
   onEditToComposer: (
     text: string,
     files?: TMessage['files'],
@@ -186,12 +189,16 @@ function QueuedRow({
   // Edit/remove are safe because `afterDiscard` tombstones that source first.
   const canSteerNow = steering.duringRunActive && steering.canSteer && !isRecovered;
   const showPrimary =
-    serverActionable && (canSteerNow || (!steering.duringRunActive && steering.canSendQueuedNow));
+    revealed !== true &&
+    serverActionable &&
+    (canSteerNow || (!steering.duringRunActive && steering.canSendQueuedNow));
   /** `canSteer` is defined as false while paused on approval, but the
    *  escalation control must stay visible-and-disabled there — hiding it
    *  during the pause is exactly the discoverability gap this button fixes. */
   const showEscalate =
-    !isRecovered && (steering.pausedOnApproval || (steering.duringRunActive && steering.canSteer));
+    revealed !== true &&
+    !isRecovered &&
+    (steering.pausedOnApproval || (steering.duringRunActive && steering.canSteer));
 
   const entries: MenuEntry[] = [
     {
@@ -256,6 +263,11 @@ function QueuedRow({
       {(isRejected || isUnconfirmed || isIndeterminate) && (
         <span className="shrink-0 text-xs text-text-warning">{localize(statusLabel)}</span>
       )}
+      {revealed === true && (
+        <span className="shrink-0 text-xs text-text-secondary">
+          {localize('com_ui_queued_turn_starting')}
+        </span>
+      )}
       {showPrimary && (
         <button
           type="button"
@@ -291,7 +303,12 @@ function QueuedRow({
         aria-label={localize(
           isUnconfirmed ? 'com_ui_dismiss_unconfirmed_delivery' : 'com_ui_remove_queued',
         )}
-        disabled={actionPending || (!serverActionable && !isUnconfirmed)}
+        disabled={
+          actionPending ||
+          (!serverActionable &&
+            !isUnconfirmed &&
+            !(message.server?.id != null && message.server.status === 'claimed'))
+        }
         onClick={() => {
           if (isUnconfirmed) {
             steering.removeQueued(message.id);
@@ -320,11 +337,13 @@ function QueuedRow({
       >
         <Trash2 className="h-4 w-4" aria-hidden="true" />
       </button>
-      <RowMenu
-        label={localize('com_ui_more_options')}
-        entries={entries}
-        preferences={preferences}
-      />
+      {revealed !== true && (
+        <RowMenu
+          label={localize('com_ui_more_options')}
+          entries={entries}
+          preferences={preferences}
+        />
+      )}
     </div>
   );
 }
@@ -472,6 +491,9 @@ function PendingSteerChips({
   const localize = useLocalize();
   const steers = useRecoilValue(store.pendingSteersByConvoId(conversationId));
   const queued = useRecoilValue(store.queuedMessagesByConvoId(steering.queueKey));
+  /** A row already shown as the next user turn keeps only its remove action
+   *  here: the turn can still be retracted until the server admits it. */
+  const revealed = useAtomValue(revealedQueuedTurnFamily(steering.queueKey));
   const failedSteers = useMemo(() => steers.filter((steer) => steer.status === 'failed'), [steers]);
   /** Only one interrupt can be in flight: a second preempt while one is
    *  unresolved would arm a second seal, so escalation buttons disable. The
@@ -509,6 +531,11 @@ function PendingSteerChips({
             steering={steering}
             conversationId={conversationId}
             interruptPending={interruptPending}
+            revealed={
+              revealed != null &&
+              message.clientRequestId != null &&
+              revealed.clientRequestId === message.clientRequestId
+            }
             onEditToComposer={onEditToComposer}
             onRestoreToComposer={onRestoreToComposer}
           />
diff --git a/client/src/components/Chat/Input/__tests__/ChatForm.approvalMode.spec.tsx b/client/src/components/Chat/Input/__tests__/ChatForm.approvalMode.spec.tsx
new file mode 100644
index 00000000000..b0d2ba31e98
--- /dev/null
+++ b/client/src/components/Chat/Input/__tests__/ChatForm.approvalMode.spec.tsx
@@ -0,0 +1,122 @@
+import React, { useMemo, useState } from 'react';
+import '@testing-library/jest-dom';
+import { DndProvider } from 'react-dnd';
+import { useForm } from 'react-hook-form';
+import { RecoilRoot, useRecoilState } from 'recoil';
+import { HTML5Backend } from 'react-dnd-html5-backend';
+import { render, screen } from '@testing-library/react';
+import { BrowserRouter as Router } from 'react-router-dom';
+import { QueryKeys, EModelEndpoint } from 'librechat-data-provider';
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
+import type { TFile, TConversation } from 'librechat-data-provider';
+import type { ChatFormValues } from '~/common';
+import { ChatContext, ChatFormProvider } from '~/Providers';
+import { AuthContextProvider } from '~/hooks/AuthContext';
+import ChatForm from '../ChatForm';
+import store from '~/store';
+
+jest.mock('~/hooks/Agents/useCodeApprovalMode', () => ({
+  __esModule: true,
+  ...jest.requireActual('~/hooks/Agents/useCodeApprovalMode'),
+  default: () => ({
+    available: true,
+    modes: ['ask', 'acceptEdits'],
+    selected: 'ask',
+  }),
+}));
+
+const conversation = {
+  conversationId: 'conversation-1',
+  endpoint: EModelEndpoint.agents,
+  agent_id: 'agent-1',
+  title: 'Code',
+} as TConversation;
+
+function Harness() {
+  const [files, setFiles] = useRecoilState(store.filesByIndex(0));
+  const [isSubmitting] = useRecoilState(store.isSubmittingFamily(0));
+  const [, setFilesLoading] = useState(false);
+  const methods = useForm<ChatFormValues>({ defaultValues: { text: '' } });
+
+  const chatHelpers = useMemo(
+    () =>
+      ({
+        index: 0,
+        conversation,
+        setConversation: () => undefined,
+        files,
+        setFiles,
+        isSubmitting,
+        setIsSubmitting: () => undefined,
+        filesLoading: false,
+        setFilesLoading,
+        newConversation: () => undefined,
+        handleStopGenerating: () => undefined,
+        stopGenerating: () => undefined,
+        getMessages: () => undefined,
+        setMessages: () => undefined,
+        ask: () => undefined,
+        regenerate: () => undefined,
+        setSiblingIdx: () => undefined,
+        showPopover: false,
+        setShowPopover: () => undefined,
+        abortScroll: false,
+        setAbortScroll: () => undefined,
+        preset: null,
+        setPreset: () => undefined,
+        optionSettings: {},
+        setOptionSettings: () => undefined,
+        handleRegenerate: () => undefined,
+        handleContinue: () => undefined,
+      }) as unknown as React.ContextType<typeof ChatContext>,
+    [files, setFiles, isSubmitting],
+  );
+
+  return (
+    <ChatFormProvider {...methods}>
+      <ChatContext.Provider value={chatHelpers}>
+        <ChatForm index={0} isLandingPage={false} footerBelow={false} centerFormOnLanding={false} />
+      </ChatContext.Provider>
+    </ChatFormProvider>
+  );
+}
+
+function renderComposer({ submitting }: { submitting: boolean }) {
+  const queryClient = new QueryClient({
+    defaultOptions: { queries: { retry: false }, mutations: { retry: false } },
+  });
+  queryClient.setQueryData<TFile[]>([QueryKeys.files], []);
+  queryClient.setQueryData([QueryKeys.endpoints], { [EModelEndpoint.agents]: { order: 0 } });
+
+  return render(
+    <QueryClientProvider client={queryClient}>
+      <RecoilRoot initializeState={({ set }) => set(store.isSubmittingFamily(0), submitting)}>
+        <Router>
+          <AuthContextProvider authConfig={{ loginRedirect: '', test: true }}>
+            <DndProvider backend={HTML5Backend}>
+              <Harness />
+            </DndProvider>
+          </AuthContextProvider>
+        </Router>
+      </RecoilRoot>
+    </QueryClientProvider>,
+  );
+}
+
+describe('ChatForm code approval mode', () => {
+  beforeEach(() => {
+    localStorage.clear();
+  });
+
+  test('keeps the mode selector usable while a run is in flight', async () => {
+    renderComposer({ submitting: true });
+
+    expect(await screen.findByTestId('code-approval-mode')).toBeEnabled();
+  }, 20000);
+
+  test('keeps the mode selector usable between runs', async () => {
+    renderComposer({ submitting: false });
+
+    expect(await screen.findByTestId('code-approval-mode')).toBeEnabled();
+  }, 20000);
+});
diff --git a/client/src/components/Chat/Input/__tests__/ChatForm.attachments.spec.tsx b/client/src/components/Chat/Input/__tests__/ChatForm.attachments.spec.tsx
index 18442369ad3..2364da87c63 100644
--- a/client/src/components/Chat/Input/__tests__/ChatForm.attachments.spec.tsx
+++ b/client/src/components/Chat/Input/__tests__/ChatForm.attachments.spec.tsx
@@ -11,9 +11,9 @@ import { QueryKeys, FileSources, EModelEndpoint } from 'librechat-data-provider'
 import { render, screen, within, waitFor, fireEvent } from '@testing-library/react';
 import type { TFile, TFileUpload, TConversation } from 'librechat-data-provider';
 import type { ChatFormValues } from '~/common';
+import ChatForm, { toRestoredComposerFile } from '../ChatForm';
 import { ChatContext, ChatFormProvider } from '~/Providers';
 import { AuthContextProvider } from '~/hooks/AuthContext';
-import ChatForm from '../ChatForm';
 import store from '~/store';
 
 const mockUpload = jest.fn();
@@ -178,6 +178,23 @@ describe('ChatForm attachments', () => {
     );
   });
 
+  test('preserves extracted-text delivery when restoring a queued attachment', () => {
+    expect(
+      toRestoredComposerFile({
+        file_id: 'stored-doc',
+        filename: 'report.docx',
+        type: 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+        llmDeliveryPath: 'text',
+      }),
+    ).toMatchObject({
+      file_id: 'stored-doc',
+      filename: 'report.docx',
+      progress: 1,
+      attached: true,
+      llmDeliveryPath: 'text',
+    });
+  });
+
   test('re-enables send once an attachment finishes uploading', async () => {
     const { container } = renderComposer();
 
diff --git a/client/src/components/Chat/Input/__tests__/CodeApprovalMenu.spec.tsx b/client/src/components/Chat/Input/__tests__/CodeApprovalMenu.spec.tsx
index 753aa3df7cd..4d48c8981e1 100644
--- a/client/src/components/Chat/Input/__tests__/CodeApprovalMenu.spec.tsx
+++ b/client/src/components/Chat/Input/__tests__/CodeApprovalMenu.spec.tsx
@@ -1,5 +1,7 @@
 import userEvent from '@testing-library/user-event';
+import { QueryKeys, Constants } from 'librechat-data-provider';
 import { render, screen, within } from '@testing-library/react';
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
 import type { TConversation } from 'librechat-data-provider';
 import CodeApprovalMenu from '../CodeApprovalMenu';
 
@@ -28,14 +30,20 @@ describe('CodeApprovalMenu', () => {
     });
   });
 
-  const renderMenu = () =>
-    render(
-      <CodeApprovalMenu
-        conversation={conversation}
-        setConversation={mockSetConversation}
-        disabled={false}
-      />,
+  let queryClient: QueryClient;
+
+  const renderMenu = () => {
+    queryClient = new QueryClient();
+    return render(
+      <QueryClientProvider client={queryClient}>
+        <CodeApprovalMenu
+          conversation={conversation}
+          setConversation={mockSetConversation}
+          disabled={false}
+        />
+      </QueryClientProvider>,
     );
+  };
 
   test('defaults to ask and stores accept-edits on the conversation', async () => {
     renderMenu();
@@ -47,6 +55,46 @@ describe('CodeApprovalMenu', () => {
     expect(update(conversation)).toEqual({ ...conversation, codeApprovalMode: 'acceptEdits' });
   });
 
+  test('writes the pick into the conversation detail cache', async () => {
+    renderMenu();
+    const key = [QueryKeys.conversation, conversation.conversationId];
+    queryClient.setQueryData<TConversation>(key, { ...conversation, codeApprovalMode: 'ask' });
+
+    await userEvent.click(screen.getByTestId('code-approval-mode'));
+    await userEvent.click(await screen.findByText('com_ui_code_approval_accept_edits'));
+
+    expect(queryClient.getQueryData<TConversation>(key)?.codeApprovalMode).toBe('acceptEdits');
+  });
+
+  test('seeds a detail record from the live conversation when none exists yet', async () => {
+    renderMenu();
+
+    await userEvent.click(screen.getByTestId('code-approval-mode'));
+    await userEvent.click(await screen.findByText('com_ui_code_approval_accept_edits'));
+
+    expect(queryClient.getQueryData([QueryKeys.conversation, conversation.conversationId])).toEqual(
+      { ...conversation, codeApprovalMode: 'acceptEdits' },
+    );
+  });
+
+  test('leaves the detail cache alone for a chat that has no id yet', async () => {
+    queryClient = new QueryClient();
+    render(
+      <QueryClientProvider client={queryClient}>
+        <CodeApprovalMenu
+          conversation={{ ...conversation, conversationId: Constants.NEW_CONVO as string }}
+          setConversation={mockSetConversation}
+          disabled={false}
+        />
+      </QueryClientProvider>,
+    );
+
+    await userEvent.click(screen.getByTestId('code-approval-mode'));
+    await userEvent.click(await screen.findByText('com_ui_code_approval_accept_edits'));
+
+    expect(queryClient.getQueryData([QueryKeys.conversation, Constants.NEW_CONVO])).toBeUndefined();
+  });
+
   test('offers every mode as a radio and marks the selected one', async () => {
     renderMenu();
 
diff --git a/client/src/components/Chat/Input/__tests__/CodeWorkspaceMenu.spec.tsx b/client/src/components/Chat/Input/__tests__/CodeWorkspaceMenu.spec.tsx
index 29b31609f0b..40934c0e304 100644
--- a/client/src/components/Chat/Input/__tests__/CodeWorkspaceMenu.spec.tsx
+++ b/client/src/components/Chat/Input/__tests__/CodeWorkspaceMenu.spec.tsx
@@ -88,6 +88,25 @@ function renderMenu(ui: React.ReactElement) {
 }
 
 describe('CodeWorkspaceMenu', () => {
+  test.each([
+    ['example/app', 'example/app · dev'],
+    [undefined, 'dev'],
+  ])('shows project metadata without changing selection (%s)', async (repo, label) => {
+    const state = workspace();
+    state.environments[0].workspaces[0].environment = {
+      fingerprint: 'a'.repeat(64),
+      repo,
+      ref: 'dev',
+      actions: ['typecheck'],
+    };
+    const setConversation = jest.fn();
+    renderMenu(
+      <CodeWorkspaceMenu setConversation={setConversation} workspace={state} disabled={false} />,
+    );
+    await userEvent.click(screen.getByTestId('code-workspace'));
+    expect(await screen.findByText(label!)).toBeInTheDocument();
+    expect(setConversation).not.toHaveBeenCalled();
+  });
   test('shows a suggested workspace without committing the conversation decision', () => {
     const setConversation = jest.fn();
     renderMenu(
diff --git a/client/src/components/Chat/Input/__tests__/InFlightSteers.test.tsx b/client/src/components/Chat/Input/__tests__/InFlightSteers.test.tsx
index 9e97f55ca4c..e0c7ab75ec2 100644
--- a/client/src/components/Chat/Input/__tests__/InFlightSteers.test.tsx
+++ b/client/src/components/Chat/Input/__tests__/InFlightSteers.test.tsx
@@ -20,6 +20,11 @@ const mockRestoreToComposer = jest.fn();
 let convertSteersForTest: ReturnType<typeof useSteerConvert>;
 let observedQueueForTest: QueuedMessage[];
 let setSteersForTest: (updater: (prev: PendingSteer[]) => PendingSteer[]) => void;
+let mockFileMap: Record<string, { llmDeliveryPath?: 'provider' | 'text' | 'none' }> = {};
+
+jest.mock('~/Providers', () => ({
+  useFileMapContext: () => mockFileMap,
+}));
 
 jest.mock('~/hooks', () => ({
   useLocalize: () => (key: string) => key,
@@ -81,8 +86,20 @@ jest.mock('~/components/Chat/Input/Files/ImagePreview', () => ({
 
 jest.mock('~/components/Chat/Messages/Content/FilePreviewDialog', () => ({
   __esModule: true,
-  default: ({ open, fileName }: { open: boolean; fileName: string }) =>
-    open ? <div data-testid="steer-file-preview">{fileName}</div> : null,
+  default: ({
+    open,
+    fileName,
+    deliveryPath,
+  }: {
+    open: boolean;
+    fileName: string;
+    deliveryPath?: string;
+  }) =>
+    open ? (
+      <div data-testid="steer-file-preview" data-delivery-path={deliveryPath}>
+        {fileName}
+      </div>
+    ) : null,
 }));
 
 jest.mock('~/components/Chat/Messages/Content/MarkdownLite', () => ({
@@ -173,6 +190,7 @@ async function clickMenuItem(label: string) {
 describe('InFlightSteers', () => {
   beforeEach(() => {
     jest.clearAllMocks();
+    mockFileMap = {};
     mockCancelMutateAsync.mockResolvedValue({ removed: true });
     mockRestoreToComposer.mockReturnValue(true);
     observedQueueForTest = [];
@@ -634,6 +652,29 @@ describe('InFlightSteers', () => {
     expect(screen.getByTestId('steer-file-preview')).toHaveTextContent('notes.pdf');
   });
 
+  it.each(['application/pdf', 'image/png'])(
+    'hydrates %s preview metadata after the steer',
+    (type) => {
+      const steer: PendingSteer = {
+        steerId: 's1',
+        text: 'see attached',
+        status: 'pending',
+        createdAt: 1,
+        files: [{ file_id: 'f1', filename: 'notes.pdf', type }],
+      };
+      const rendered = renderSteers([steer]);
+
+      mockFileMap = { f1: { llmDeliveryPath: 'text' } };
+      rendered.rerender(steersElement([steer]));
+
+      fireEvent.click(screen.getByTestId('steer-file'));
+      expect(screen.getByTestId('steer-file-preview')).toHaveAttribute(
+        'data-delivery-path',
+        'text',
+      );
+    },
+  );
+
   it('renders markdown the same way the applied part will, so text does not reflow on apply', () => {
     renderSteers([{ steerId: 's1', text: '**bold** steer', status: 'pending', createdAt: 1 }], {
       enableUserMsgMarkdown: true,
diff --git a/client/src/components/Chat/Input/__tests__/PendingSteerChips.test.tsx b/client/src/components/Chat/Input/__tests__/PendingSteerChips.test.tsx
index e757c562bd4..76bb6bfa346 100644
--- a/client/src/components/Chat/Input/__tests__/PendingSteerChips.test.tsx
+++ b/client/src/components/Chat/Input/__tests__/PendingSteerChips.test.tsx
@@ -2,10 +2,10 @@ import React from 'react';
 import { getDefaultStore } from 'jotai';
 import userEvent from '@testing-library/user-event';
 import { RecoilRoot, useRecoilValue, useSetRecoilState } from 'recoil';
-import { render, screen, fireEvent, act, waitFor } from '@testing-library/react';
+import { render, screen, fireEvent, act, waitFor, within } from '@testing-library/react';
 import type { PendingSteer, QueuedMessage } from '~/store/families';
 import type { SteeringControls } from '~/hooks/Chat/useSteering';
-import { escalatingSteerFamily } from '~/store/steer';
+import { escalatingSteerFamily, revealedQueuedTurnFamily } from '~/store/steer';
 import PendingSteerChips from '../PendingSteerChips';
 import store from '~/store';
 
@@ -706,3 +706,72 @@ describe('PendingSteerChips — queued hint', () => {
     expect(screen.queryByRole('img', { name: hintName })).toBeNull();
   });
 });
+
+describe('PendingSteerChips — revealed queued turn', () => {
+  const revealedFamily = () => revealedQueuedTurnFamily(CONVO_ID);
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    act(() => {
+      getDefaultStore().set(revealedFamily(), null);
+    });
+  });
+
+  afterEach(() => {
+    act(() => {
+      getDefaultStore().set(revealedFamily(), null);
+    });
+  });
+
+  const serverRow = (clientRequestId: string): QueuedMessage => ({
+    id: `q-${clientRequestId}`,
+    text: `queued ${clientRequestId}`,
+    createdAt: 1,
+    clientRequestId,
+    server: { id: `server-${clientRequestId}`, status: 'queued', revision: 1 },
+  });
+
+  it('reduces the row shown as the next turn to its remove action', () => {
+    getDefaultStore().set(revealedFamily(), {
+      clientRequestId: 'req-1',
+      parentMessageId: 'response-1',
+      text: 'queued req-1',
+      revealedAt: '2026-09-14T00:00:00.000Z',
+    });
+    renderChips([serverRow('req-1'), serverRow('req-2')], {
+      steering: { duringRunActive: true, canSendQueuedNow: false, canSteer: false },
+    });
+
+    const rows = screen.getAllByTestId('queued-message-row');
+    expect(rows).toHaveLength(2);
+    expect(rows[0]).toHaveTextContent('com_ui_queued_turn_starting');
+    expect(within(rows[0]).queryByRole('button', { name: 'com_ui_more_options' })).toBeNull();
+    expect(within(rows[0]).getByRole('button', { name: /com_ui_remove/ })).toBeInTheDocument();
+    expect(rows[1]).not.toHaveTextContent('com_ui_queued_turn_starting');
+    expect(
+      within(rows[1]).getByRole('button', { name: 'com_ui_more_options' }),
+    ).toBeInTheDocument();
+  });
+  it.each([true, false])(
+    'attempts claimed cancellation and respects acceptance=%s',
+    async (accepted) => {
+      const message = serverRow('req-1');
+      message.server!.status = 'claimed';
+      getDefaultStore().set(revealedFamily(), {
+        clientRequestId: 'req-1',
+        parentMessageId: 'response-1',
+        text: message.text,
+        revealedAt: new Date().toISOString(),
+      });
+      mockDiscardQueued.mockResolvedValueOnce(accepted);
+      renderChips([message], { steering: { duringRunActive: true, canSendQueuedNow: false } });
+      const remove = screen.getByRole('button', { name: /com_ui_remove/ });
+      expect(remove).toBeEnabled();
+      await userEvent.click(remove);
+      await waitFor(() => expect(mockDiscardQueued).toHaveBeenCalledWith(message));
+      expect(mockRemoveQueued).toHaveBeenCalledTimes(accepted ? 1 : 0);
+      expect(mockRestoreToComposer).toHaveBeenCalledTimes(accepted ? 1 : 0);
+      expect(mockSendQueuedNow).not.toHaveBeenCalled();
+    },
+  );
+});
diff --git a/client/src/components/Chat/Input/__tests__/submit.spec.ts b/client/src/components/Chat/Input/__tests__/submit.spec.ts
new file mode 100644
index 00000000000..754e5755bab
--- /dev/null
+++ b/client/src/components/Chat/Input/__tests__/submit.spec.ts
@@ -0,0 +1,49 @@
+import type { ComposerSubmitRoute } from '../submit';
+import { submitFromComposer } from '../submit';
+
+const route = (overrides: Partial<ComposerSubmitRoute> = {}): ComposerSubmitRoute => ({
+  answerMode: { active: false, submitText: jest.fn(() => false) },
+  steering: { duringRunActive: false, submitDuringRun: jest.fn(() => true) },
+  submitMessage: jest.fn(),
+  reset: jest.fn(),
+  ...overrides,
+});
+
+describe('submitFromComposer', () => {
+  it('starts an ordinary turn when nothing owns the composer', () => {
+    const r = route();
+    submitFromComposer(r, { text: 'hello' });
+    expect(r.submitMessage).toHaveBeenCalledWith({ text: 'hello' });
+    expect(r.steering.submitDuringRun).not.toHaveBeenCalled();
+  });
+
+  it('answers the paused run before any send or steer routing', () => {
+    const r = route({
+      answerMode: { active: true, submitText: jest.fn(() => true) },
+      steering: { duringRunActive: true, submitDuringRun: jest.fn(() => true) },
+    });
+    submitFromComposer(r, { text: 'option b' });
+    expect(r.answerMode.submitText).toHaveBeenCalledWith('option b');
+    expect(r.steering.submitDuringRun).not.toHaveBeenCalled();
+    expect(r.submitMessage).not.toHaveBeenCalled();
+  });
+
+  it('steers or queues instead of starting a turn while a run or a revealed follow-up is pending', () => {
+    const r = route({
+      steering: { duringRunActive: true, submitDuringRun: jest.fn(() => true) },
+    });
+    expect(submitFromComposer(r, { text: 'wait for it' })).toBeUndefined();
+    expect(r.steering.submitDuringRun).toHaveBeenCalledWith('wait for it');
+    expect(r.reset).toHaveBeenCalled();
+    expect(r.submitMessage).not.toHaveBeenCalled();
+  });
+
+  it('keeps the text in the composer when the during-run route refuses it', () => {
+    const r = route({
+      steering: { duringRunActive: true, submitDuringRun: jest.fn(() => false) },
+    });
+    expect(submitFromComposer(r, { text: 'not now' })).toBe(false);
+    expect(r.reset).not.toHaveBeenCalled();
+    expect(r.submitMessage).not.toHaveBeenCalled();
+  });
+});
diff --git a/client/src/components/Chat/Input/submit.ts b/client/src/components/Chat/Input/submit.ts
new file mode 100644
index 00000000000..58adbb62117
--- /dev/null
+++ b/client/src/components/Chat/Input/submit.ts
@@ -0,0 +1,31 @@
+export type ComposerSubmitRoute = {
+  answerMode: { active: boolean; submitText: (text: string) => boolean };
+  steering: { duringRunActive: boolean; submitDuringRun: (text: string) => boolean };
+  submitMessage: (data: { text: string }) => false | void;
+  reset: () => void;
+};
+
+/**
+ * One route for every submission that originates in the composer, whether
+ * typed, dictated, or bound to a shortcut. Answer mode takes the text for the
+ * paused run; during a run, or while a queued follow-up is about to start, the
+ * text steers or queues per the effective action instead of starting a turn
+ * that would race the one already owed. `false` means the composer keeps the
+ * text, exactly as a refused send does.
+ */
+export function submitFromComposer(
+  route: ComposerSubmitRoute,
+  data: { text: string },
+): false | void {
+  if (route.answerMode.active && route.answerMode.submitText(data.text)) {
+    return;
+  }
+  if (route.steering.duringRunActive) {
+    if (!route.steering.submitDuringRun(data.text)) {
+      return false;
+    }
+    route.reset();
+    return;
+  }
+  return route.submitMessage(data);
+}
diff --git a/client/src/components/Chat/Messages/Content/FilePreviewDialog.tsx b/client/src/components/Chat/Messages/Content/FilePreviewDialog.tsx
index 958be9f4ab8..7911b2fd4e4 100644
--- a/client/src/components/Chat/Messages/Content/FilePreviewDialog.tsx
+++ b/client/src/components/Chat/Messages/Content/FilePreviewDialog.tsx
@@ -1,13 +1,31 @@
-import { useState, useEffect, useCallback, useMemo, useRef } from 'react';
+import { useState, useEffect, useCallback, useMemo } from 'react';
 import copy from 'copy-to-clipboard';
 import { Download } from 'lucide-react';
 import { useRecoilValue } from 'recoil';
-import { OGDialog, OGDialogContent, OGDialogTitle, OGDialogDescription } from '@librechat/client';
+import {
+  Button,
+  OGDialog,
+  OGDialogContent,
+  OGDialogTitle,
+  OGDialogDescription,
+} from '@librechat/client';
+import type { TFile } from 'librechat-data-provider';
+import {
+  getFileExtension,
+  getPreviewKind,
+  isExtractedTextPreviewLoading,
+  shouldUseExtractedTextPreview,
+  shouldUseSharedFileDownload,
+} from './preview';
+import {
+  useFilePreview,
+  useFilePreviewBlob,
+  useFileDownload,
+  useSharedFileDownload,
+} from '~/data-provider';
 import { getDownloadFilename, logger, sortPagesByRelevance, triggerDownload } from '~/utils';
-import { revokeDownloadURL, useFileDownload, useSharedFileDownload } from '~/data-provider';
-import { getFileExtension, getPreviewKind, shouldUseSharedFileDownload } from './preview';
 import CopyButton from '~/components/Messages/Content/CopyButton';
-import { useShareContext } from '~/Providers';
+import { useFileMapContext, useShareContext } from '~/Providers';
 import { useLocalize } from '~/hooks';
 import store from '~/store';
 
@@ -23,6 +41,7 @@ interface FilePreviewDialogProps {
   fileType?: string;
   fileSource?: string;
   fileSize?: number;
+  deliveryPath?: TFile['llmDeliveryPath'];
 }
 
 /** Formats bytes with unit suffix (differs from ~/utils/formatBytes which returns a raw number). */
@@ -78,88 +97,109 @@ export default function FilePreviewDialog({
   fileType,
   fileSource,
   fileSize,
+  deliveryPath,
 }: FilePreviewDialogProps) {
   const localize = useLocalize();
   const user = useRecoilValue(store.user);
   const { shareId } = useShareContext();
-  // Preview reads revoke their blob after consumption, so they need a separate
-  // query identity from user-triggered downloads that may be in flight concurrently.
+  const fileMap = useFileMapContext();
+  const showExtractedText = shouldUseExtractedTextPreview(
+    deliveryPath ?? (!shareId && fileId ? fileMap?.[fileId]?.llmDeliveryPath : undefined),
+  );
+  const {
+    data: extractedPreview,
+    isInitialLoading: extractedTextLoading,
+    isFetching: extractedTextFetching,
+    isError: extractedTextError,
+    refetch: refetchExtractedPreview,
+  } = useFilePreview(
+    fileId,
+    {
+      enabled: open && showExtractedText && !!fileId,
+    },
+    shareId,
+  );
+  // Downloads own URLs; previews share bytes and create only their display URL.
   const { refetch: downloadOwned } = useFileDownload(user?.id ?? '', fileId, { direct: false });
   const { refetch: downloadShared } = useSharedFileDownload(shareId, fileId);
-  const { refetch: previewOwned } = useFileDownload(user?.id ?? '', fileId, {
-    direct: false,
-    purpose: 'preview',
-  });
-  const { refetch: previewShared } = useSharedFileDownload(shareId, fileId, 'preview');
+  const { refetch: previewFile } = useFilePreviewBlob(user?.id, fileId, shareId);
   // A shared viewer must stay inside the share-scoped authorization boundary;
   // citation and retrieval previews do not carry a rewritten filepath signal.
   const useShared = shouldUseSharedFileDownload(shareId, fileId);
   const downloadFile = useShared ? downloadShared : downloadOwned;
-  const previewFile = useShared ? previewShared : previewOwned;
 
   const [fileContent, setFileContent] = useState<string | null>(null);
   const [fileBlobUrl, setFileBlobUrl] = useState<string | null>(null);
   const [loading, setLoading] = useState(false);
   const [previewError, setPreviewError] = useState(false);
   const [isCopied, setIsCopied] = useState(false);
-  const loadingRef = useRef(false);
 
-  const previewKind = getPreviewKind(fileName, fileType, fileSource);
+  const previewKind = showExtractedText ? false : getPreviewKind(fileName, fileType, fileSource);
   const downloadFilename = getDownloadFilename(fileName, fileId, fileSource);
+  const displayedText = showExtractedText ? (extractedPreview?.text ?? null) : fileContent;
+  const isLoading =
+    (!showExtractedText && loading) ||
+    (showExtractedText &&
+      isExtractedTextPreviewLoading(
+        extractedPreview?.status,
+        extractedTextLoading,
+        extractedTextError,
+      ));
+  const hasPreviewError =
+    (!showExtractedText && previewError) ||
+    (showExtractedText &&
+      (extractedTextError ||
+        extractedPreview?.status === 'failed' ||
+        (extractedPreview?.status === 'ready' && extractedPreview.text == null)));
 
-  const cancelledRef = useRef(false);
-
-  const loadPreview = useCallback(async () => {
-    if (!fileId || !previewKind || loadingRef.current) {
+  useEffect(() => {
+    let cancelled = false;
+    let objectUrl: string | undefined;
+    setFileContent(null);
+    setFileBlobUrl(null);
+    setPreviewError(false);
+    setLoading(false);
+    if (!open || !fileId || !previewKind) {
       return;
     }
-    loadingRef.current = true;
-    cancelledRef.current = false;
-    setLoading(true);
-    setPreviewError(false);
 
-    try {
-      const result = await previewFile();
-      if (!result.data) {
-        if (!cancelledRef.current) {
+    setLoading(true);
+    const load = async () => {
+      try {
+        const { data: blob } = await previewFile();
+        if (!blob) {
+          throw new Error('Preview download unavailable');
+        }
+        if (cancelled) {
+          return;
+        }
+        if (previewKind === 'text') {
+          const text = await blob.text();
+          if (!cancelled) {
+            setFileContent(text);
+          }
+        } else {
+          objectUrl = URL.createObjectURL(new Blob([blob], { type: 'application/pdf' }));
+          setFileBlobUrl(objectUrl);
+        }
+      } catch {
+        if (!cancelled) {
           setPreviewError(true);
         }
-        return;
-      }
-      if (cancelledRef.current) {
-        revokeDownloadURL(result.data);
-        return;
-      }
-
-      let blob: Blob;
-      try {
-        const resp = await fetch(result.data);
-        blob = await resp.blob();
       } finally {
-        revokeDownloadURL(result.data);
-      }
-
-      if (cancelledRef.current) {
-        return;
-      }
-
-      if (previewKind === 'text') {
-        setFileContent(await blob.text());
-      } else {
-        const typed = new Blob([blob], { type: 'application/pdf' });
-        setFileBlobUrl(URL.createObjectURL(typed));
-      }
-    } catch {
-      if (!cancelledRef.current) {
-        setPreviewError(true);
+        if (!cancelled) {
+          setLoading(false);
+        }
       }
-    } finally {
-      loadingRef.current = false;
-      if (!cancelledRef.current) {
-        setLoading(false);
+    };
+    void load();
+    return () => {
+      cancelled = true;
+      if (objectUrl) {
+        URL.revokeObjectURL(objectUrl);
       }
-    }
-  }, [fileId, previewKind, previewFile]);
+    };
+  }, [open, fileId, previewKind, previewFile, shareId, user?.id]);
 
   const handleDownload = useCallback(async () => {
     if (!fileId) {
@@ -176,39 +216,20 @@ export default function FilePreviewDialog({
     }
   }, [downloadFile, downloadFilename, fileId]);
 
-  useEffect(() => {
-    if (open && previewKind && fileContent === null && !fileBlobUrl) {
-      loadPreview();
-    }
-  }, [open, previewKind, fileContent, fileBlobUrl, loadPreview]);
-
-  useEffect(() => {
-    return () => {
-      if (fileBlobUrl) {
-        URL.revokeObjectURL(fileBlobUrl);
-      }
-    };
-  }, [fileBlobUrl]);
-
   useEffect(() => {
     if (!open) {
-      cancelledRef.current = true;
-      setFileContent(null);
-      setFileBlobUrl(null);
-      setPreviewError(false);
-      setLoading(false);
       setIsCopied(false);
     }
   }, [open]);
 
   const handleCopy = useCallback(() => {
-    if (!fileContent) {
+    if (!displayedText) {
       return;
     }
-    copy(fileContent, { format: 'text/plain' });
+    copy(displayedText, { format: 'text/plain' });
     setIsCopied(true);
     setTimeout(() => setIsCopied(false), 3000);
-  }, [fileContent]);
+  }, [displayedText]);
 
   const displayType = useMemo(() => getDisplayType(fileType, fileName), [fileType, fileName]);
   const sortedPages = useMemo(
@@ -254,28 +275,39 @@ export default function FilePreviewDialog({
         </div>
 
         <div className="relative min-h-0 flex-1 overflow-y-auto px-6 pb-6 pt-4">
-          {loading && (
+          {isLoading && (
             <div className="flex h-60 items-center justify-center rounded-lg bg-surface-secondary">
               <span className="shimmer text-sm text-text-secondary">
                 {localize('com_ui_loading')}
               </span>
             </div>
           )}
-          {previewError && (
-            <div className="flex h-32 items-center justify-center rounded-lg bg-surface-secondary">
+          {hasPreviewError && !isLoading && (
+            <div className="flex h-32 flex-col items-center justify-center gap-2 rounded-lg bg-surface-secondary">
               <span className="text-sm text-text-secondary">
                 {localize('com_ui_preview_unavailable')}
               </span>
+              {showExtractedText && (
+                <Button
+                  type="button"
+                  variant="outline"
+                  size="sm"
+                  disabled={extractedTextFetching}
+                  onClick={() => void refetchExtractedPreview()}
+                >
+                  {localize('com_ui_retry')}
+                </Button>
+              )}
             </div>
           )}
-          {fileBlobUrl && (
+          {fileBlobUrl && !showExtractedText && (
             <iframe
               src={fileBlobUrl}
               title={`${localize('com_ui_preview')}: ${fileName}`}
               className="h-[70vh] w-full rounded-lg border border-border-light"
             />
           )}
-          {fileContent !== null && (
+          {displayedText !== null && !isLoading && !hasPreviewError && (
             <>
               <div className="pointer-events-none sticky top-0 z-10 flex justify-end pr-1">
                 <CopyButton
@@ -288,12 +320,12 @@ export default function FilePreviewDialog({
               </div>
               <div className="-mt-8 rounded-lg bg-surface-secondary p-4">
                 <pre className="whitespace-pre-wrap break-words pr-8 font-mono text-sm leading-6 text-text-primary">
-                  {fileContent}
+                  {displayedText}
                 </pre>
               </div>
             </>
           )}
-          {!previewKind && !loading && (
+          {!previewKind && !showExtractedText && !isLoading && (
             <div className="flex h-32 items-center justify-center rounded-lg bg-surface-secondary">
               <span className="text-sm text-text-secondary">
                 {localize('com_ui_preview_unavailable')}
diff --git a/client/src/components/Chat/Messages/Content/Files.tsx b/client/src/components/Chat/Messages/Content/Files.tsx
index 1bfa7008715..0f2be00c356 100644
--- a/client/src/components/Chat/Messages/Content/Files.tsx
+++ b/client/src/components/Chat/Messages/Content/Files.tsx
@@ -1,17 +1,25 @@
 import { useMemo, useState, useCallback, memo } from 'react';
 import type { TFile, TMessage } from 'librechat-data-provider';
 import FileContainer from '~/components/Chat/Input/Files/FileContainer';
+import { usesImagePreview, hydrateFileDeliveryMetadata } from '~/utils';
+import { useFileMapContext, useShareContext } from '~/Providers';
 import FilePreviewDialog from './FilePreviewDialog';
 import Image from './Image';
 
 const Files = ({ message }: { message?: TMessage }) => {
+  const fileMap = useFileMapContext();
+  const { shareId } = useShareContext();
+  const files = useMemo(
+    () => hydrateFileDeliveryMetadata(message?.files, undefined, shareId ? undefined : fileMap),
+    [message?.files, fileMap, shareId],
+  );
   const imageFiles = useMemo(() => {
-    return message?.files?.filter((file) => file.type?.startsWith('image/')) || [];
-  }, [message?.files]);
+    return files?.filter(usesImagePreview) || [];
+  }, [files]);
 
   const otherFiles = useMemo(() => {
-    return message?.files?.filter((file) => !file.type?.startsWith('image/')) || [];
-  }, [message?.files]);
+    return files?.filter((file) => !usesImagePreview(file)) || [];
+  }, [files]);
 
   const [selectedFile, setSelectedFile] = useState<Partial<TFile> | null>(null);
 
@@ -50,6 +58,7 @@ const Files = ({ message }: { message?: TMessage }) => {
         fileType={selectedFile?.type ?? undefined}
         fileSource={selectedFile?.source}
         fileSize={(selectedFile as TFile)?.bytes}
+        deliveryPath={selectedFile?.llmDeliveryPath}
       />
     </>
   );
diff --git a/client/src/components/Chat/Messages/Content/Parts/SteerPart.tsx b/client/src/components/Chat/Messages/Content/Parts/SteerPart.tsx
index dcd84772b21..f00ae091c7a 100644
--- a/client/src/components/Chat/Messages/Content/Parts/SteerPart.tsx
+++ b/client/src/components/Chat/Messages/Content/Parts/SteerPart.tsx
@@ -4,14 +4,14 @@ import type { TFile, TMessage } from 'librechat-data-provider';
 import FilePreviewDialog from '~/components/Chat/Messages/Content/FilePreviewDialog';
 import MessageTimestamp from '~/components/Chat/Messages/ui/MessageTimestamp';
 import MessageQuotes from '~/components/Chat/Messages/Content/MessageQuotes';
+import { cn, hydrateFileDeliveryMetadata, usesImagePreview } from '~/utils';
 import MarkdownLite from '~/components/Chat/Messages/Content/MarkdownLite';
 import FileContainer from '~/components/Chat/Input/Files/FileContainer';
+import { useFileMapContext, useShareContext } from '~/Providers';
 import SteerReceipt from '~/components/Chat/Steering/Receipt';
 import Image from '~/components/Chat/Messages/Content/Image';
 import CollapsibleText from './CollapsibleText';
-import { useShareContext } from '~/Providers';
 import { useLocalize } from '~/hooks';
-import { cn } from '~/utils';
 import store from '~/store';
 
 /**
@@ -49,6 +49,7 @@ const SteerPart = memo(function SteerPart({
    *  user into it, and the public share route mounts outside that provider. */
   const user = useRecoilValue(store.user);
   const { isSharedConvo } = useShareContext();
+  const fileMap = useFileMapContext();
   const usernameDisplay = useRecoilValue<boolean>(store.UsernameDisplay);
   const enableUserMsgMarkdown = useRecoilValue<boolean>(store.enableUserMsgMarkdown);
   const collapseLongUserMessages = useRecoilValue<boolean>(store.collapseLongUserMessages);
@@ -65,13 +66,14 @@ const SteerPart = memo(function SteerPart({
     () => (createdAt != null ? new Date(createdAt).toISOString() : null),
     [createdAt],
   );
-  const imageFiles = useMemo(
-    () => files?.filter((file) => file.type?.startsWith('image/')) ?? [],
-    [files],
+  const hydratedFiles = useMemo(
+    () => hydrateFileDeliveryMetadata(files, undefined, fileMap),
+    [files, fileMap],
   );
+  const imageFiles = useMemo(() => hydratedFiles?.filter(usesImagePreview) ?? [], [hydratedFiles]);
   const otherFiles = useMemo(
-    () => files?.filter((file) => !file.type?.startsWith('image/')) ?? [],
-    [files],
+    () => hydratedFiles?.filter((file) => !usesImagePreview(file)) ?? [],
+    [hydratedFiles],
   );
   const [selectedFile, setSelectedFile] = useState<Partial<TFile> | null>(null);
   const handlePreviewClose = useCallback((open: boolean) => {
@@ -174,6 +176,7 @@ const SteerPart = memo(function SteerPart({
           fileType={selectedFile?.type ?? undefined}
           fileSource={selectedFile?.source}
           fileSize={(selectedFile as TFile | null)?.bytes}
+          deliveryPath={selectedFile?.llmDeliveryPath}
         />
       )}
     </div>
diff --git a/client/src/components/Chat/Messages/Content/Parts/__tests__/SteerPart.test.tsx b/client/src/components/Chat/Messages/Content/Parts/__tests__/SteerPart.test.tsx
index d2f9d4d7ca3..bf6898c8c3d 100644
--- a/client/src/components/Chat/Messages/Content/Parts/__tests__/SteerPart.test.tsx
+++ b/client/src/components/Chat/Messages/Content/Parts/__tests__/SteerPart.test.tsx
@@ -7,6 +7,7 @@ import SteerPart from '../SteerPart';
 import store from '~/store';
 
 let mockShareContext: { isSharedConvo?: boolean; shareId?: string } = {};
+let mockFileMap: Record<string, { llmDeliveryPath?: 'provider' | 'text' | 'none' }> = {};
 
 jest.mock('~/hooks', () => ({
   useLocalize: () => (key: string) => key,
@@ -14,6 +15,7 @@ jest.mock('~/hooks', () => ({
 
 jest.mock('~/Providers', () => ({
   useShareContext: () => mockShareContext,
+  useFileMapContext: () => mockFileMap,
 }));
 
 jest.mock('~/components/Chat/Messages/ui/MessageTimestamp', () => ({
@@ -37,8 +39,20 @@ jest.mock('~/components/Chat/Input/Files/FileContainer', () => ({
 
 jest.mock('~/components/Chat/Messages/Content/FilePreviewDialog', () => ({
   __esModule: true,
-  default: ({ open, fileName }: { open: boolean; fileName: string }) =>
-    open ? <div data-testid="steer-file-preview">{fileName}</div> : null,
+  default: ({
+    open,
+    fileName,
+    deliveryPath,
+  }: {
+    open: boolean;
+    fileName: string;
+    deliveryPath?: string;
+  }) =>
+    open ? (
+      <div data-testid="steer-file-preview" data-delivery-path={deliveryPath}>
+        {fileName}
+      </div>
+    ) : null,
 }));
 
 jest.mock('~/components/Chat/Messages/Content/Image', () => ({
@@ -66,6 +80,7 @@ function renderPart(
 describe('SteerPart author label', () => {
   beforeEach(() => {
     mockShareContext = {};
+    mockFileMap = {};
   });
 
   it('labels with the logged-in user name in the owner view (username display on)', () => {
@@ -138,6 +153,7 @@ describe('SteerPart author label', () => {
 describe('SteerPart presentation', () => {
   beforeEach(() => {
     mockShareContext = {};
+    mockFileMap = {};
   });
 
   it('presents the steer as a compact user bubble with accessible attribution', () => {
@@ -172,13 +188,21 @@ describe('SteerPart presentation', () => {
     expect(screen.getByTestId('steer-image')).toBeInTheDocument();
   });
 
-  it('opens the file preview dialog when a non-image steer attachment is clicked', () => {
-    renderPart([{ file_id: 'f1', filename: 'notes.pdf', type: 'application/pdf' }]);
-    expect(screen.queryByTestId('steer-file-preview')).toBeNull();
-
-    fireEvent.click(screen.getByTestId('steer-file'));
-    expect(screen.getByTestId('steer-file-preview')).toHaveTextContent('notes.pdf');
-  });
+  it.each(['application/pdf', 'image/png'])(
+    'opens extracted previews for %s attachments',
+    (type) => {
+      mockFileMap = { f1: { llmDeliveryPath: 'text' } };
+      renderPart([{ file_id: 'f1', filename: 'notes.pdf', type }]);
+      expect(screen.queryByTestId('steer-file-preview')).toBeNull();
+
+      fireEvent.click(screen.getByTestId('steer-file'));
+      expect(screen.getByTestId('steer-file-preview')).toHaveTextContent('notes.pdf');
+      expect(screen.getByTestId('steer-file-preview')).toHaveAttribute(
+        'data-delivery-path',
+        'text',
+      );
+    },
+  );
 
   it('renders quoted excerpts as reference blocks inside the bubble', () => {
     render(
diff --git a/client/src/components/Chat/Messages/Content/__tests__/FilePreviewDialog.lifecycle.test.tsx b/client/src/components/Chat/Messages/Content/__tests__/FilePreviewDialog.lifecycle.test.tsx
new file mode 100644
index 00000000000..64757fc785e
--- /dev/null
+++ b/client/src/components/Chat/Messages/Content/__tests__/FilePreviewDialog.lifecycle.test.tsx
@@ -0,0 +1,180 @@
+import React from 'react';
+import { act, fireEvent, render, screen, waitFor } from '@testing-library/react';
+import type { TFilePreview } from 'librechat-data-provider';
+import FilePreviewDialog from '../FilePreviewDialog';
+
+let mockFileMap: Record<string, { llmDeliveryPath: 'text' }> = {};
+let mockShareId: string | undefined;
+let mockPreview: TFilePreview | undefined;
+let mockPreviewError = false;
+const mockOwnedPreview = jest.fn();
+const mockSharedPreview = jest.fn();
+const mockDownload = jest.fn();
+const mockRetry = jest.fn();
+const mockRevoke = jest.fn();
+const mockTriggerDownload = jest.fn();
+const mockUseFilePreview = jest.fn();
+
+jest.mock('recoil', () => ({ useRecoilValue: () => ({ id: 'owner' }) }));
+jest.mock('~/store', () => ({ user: {} }));
+jest.mock('~/Providers', () => ({
+  useShareContext: () => ({ shareId: mockShareId }),
+  useFileMapContext: () => mockFileMap,
+}));
+jest.mock('~/hooks', () => ({ useLocalize: () => (key: string) => key }));
+jest.mock('~/utils', () => ({
+  getDownloadFilename: (name: string) => name,
+  logger: { error: jest.fn() },
+  sortPagesByRelevance: () => [],
+  triggerDownload: (...args: unknown[]) => mockTriggerDownload(...args),
+}));
+jest.mock('~/data-provider', () => ({
+  useFilePreview: (...args: unknown[]) => {
+    mockUseFilePreview(...args);
+    return {
+      data: mockPreview,
+      isInitialLoading: !mockPreview && !mockPreviewError,
+      isFetching: false,
+      isError: mockPreviewError,
+      refetch: mockRetry,
+    };
+  },
+  useFileDownload: (_user: string, _file: string, options: { purpose?: string }) => ({
+    refetch: options.purpose === 'preview' ? mockOwnedPreview : mockDownload,
+  }),
+  useFilePreviewBlob: (_user: string, _file: string, shareId?: string) => ({
+    refetch: shareId ? mockSharedPreview : mockOwnedPreview,
+  }),
+  useSharedFileDownload: (_share: string, _file: string, purpose?: string) => ({
+    refetch: purpose === 'preview' ? mockSharedPreview : mockDownload,
+  }),
+  revokeDownloadURL: (url: string) => mockRevoke(url),
+}));
+jest.mock('@librechat/client', () => ({
+  OGDialog: ({ open, children }: React.PropsWithChildren<{ open: boolean }>) =>
+    open ? <div>{children}</div> : null,
+  OGDialogContent: ({ children }: React.PropsWithChildren) => <div>{children}</div>,
+  OGDialogTitle: ({ children }: React.PropsWithChildren) => <h2>{children}</h2>,
+  OGDialogDescription: ({ children }: React.PropsWithChildren) => <p>{children}</p>,
+  Button: ({ children, onClick }: React.PropsWithChildren<{ onClick: () => void }>) => (
+    <button onClick={onClick}>{children}</button>
+  ),
+}));
+jest.mock('~/components/Messages/Content/CopyButton', () => () => null);
+
+const props = {
+  open: true,
+  onOpenChange: jest.fn(),
+  fileId: 'f1',
+  fileName: 'report.pdf',
+  fileType: 'application/pdf',
+};
+
+describe('FilePreviewDialog lifecycle', () => {
+  it('renders an ordinary PDF and revokes its display URL on close', async () => {
+    const originalCreate = URL.createObjectURL;
+    const originalRevoke = URL.revokeObjectURL;
+    const revoke = jest.fn();
+    URL.createObjectURL = jest.fn(() => 'blob:display');
+    URL.revokeObjectURL = revoke;
+    try {
+      mockOwnedPreview.mockResolvedValue({ data: new Blob(['pdf']) });
+      const view = render(<FilePreviewDialog {...props} />);
+      await waitFor(() =>
+        expect(screen.getByTitle('com_ui_preview: report.pdf')).toHaveAttribute(
+          'src',
+          'blob:display',
+        ),
+      );
+      view.unmount();
+      expect(revoke).toHaveBeenCalledWith('blob:display');
+    } finally {
+      URL.createObjectURL = originalCreate;
+      URL.revokeObjectURL = originalRevoke;
+    }
+  });
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    mockFileMap = {};
+    mockShareId = undefined;
+    mockPreview = { file_id: 'f1', status: 'ready', text: 'extracted document' };
+    mockPreviewError = false;
+    mockOwnedPreview.mockResolvedValue({});
+    mockSharedPreview.mockResolvedValue({});
+    mockDownload.mockResolvedValue({ data: 'blob:original' });
+  });
+
+  it('renders extracted text and downloads the original object', async () => {
+    render(<FilePreviewDialog {...props} deliveryPath="text" />);
+    expect(screen.getByText('extracted document')).toBeInTheDocument();
+    expect(mockOwnedPreview).not.toHaveBeenCalled();
+    fireEvent.click(screen.getByRole('button', { name: 'com_ui_download report.pdf' }));
+    await waitFor(() =>
+      expect(mockTriggerDownload).toHaveBeenCalledWith('blob:original', 'report.pdf'),
+    );
+  });
+
+  it('handles pending, polling failure, retry, and empty success', () => {
+    mockPreview = { file_id: 'f1', status: 'pending' };
+    const view = render(<FilePreviewDialog {...props} deliveryPath="text" />);
+    expect(screen.getByText('com_ui_loading')).toBeInTheDocument();
+    mockPreviewError = true;
+    view.rerender(<FilePreviewDialog {...props} deliveryPath="text" />);
+    expect(screen.queryByText('com_ui_loading')).toBeNull();
+    fireEvent.click(screen.getByRole('button', { name: 'com_ui_retry' }));
+    expect(mockRetry).toHaveBeenCalledTimes(1);
+    mockPreviewError = false;
+    mockPreview = { file_id: 'f1', status: 'ready', text: '' };
+    view.rerender(<FilePreviewDialog {...props} deliveryPath="text" />);
+    expect(screen.queryByText('com_ui_preview_unavailable')).toBeNull();
+  });
+
+  it('recovers late metadata while open and discards the obsolete binary response', async () => {
+    let resolve!: (value: { data: Blob }) => void;
+    mockOwnedPreview.mockReturnValue(
+      new Promise((done) => {
+        resolve = done;
+      }),
+    );
+    const view = render(<FilePreviewDialog {...props} />);
+    mockFileMap = { f1: { llmDeliveryPath: 'text' } };
+    view.rerender(<FilePreviewDialog {...props} />);
+    expect(screen.getByText('extracted document')).toBeInTheDocument();
+    await act(async () => {
+      resolve({ data: new Blob(['obsolete']) });
+    });
+    expect(screen.queryByTitle('com_ui_preview: report.pdf')).toBeNull();
+  });
+
+  it('handles a deduplicated response after closing and reopening', async () => {
+    let resolve!: (value: { data: Blob }) => void;
+    mockOwnedPreview.mockReturnValue(
+      new Promise((done) => {
+        resolve = done;
+      }),
+    );
+    const textProps = { ...props, fileName: 'notes.txt', fileType: 'text/plain' };
+    const view = render(<FilePreviewDialog {...textProps} />);
+    view.rerender(<FilePreviewDialog {...textProps} open={false} />);
+    view.rerender(<FilePreviewDialog {...textProps} />);
+    expect(mockOwnedPreview).toHaveBeenCalledTimes(2);
+    await act(async () => {
+      resolve({ data: { text: async () => 'shared bytes' } as Blob });
+    });
+    expect(screen.getByText('shared bytes')).toBeInTheDocument();
+    expect(screen.queryByText('com_ui_preview_unavailable')).toBeNull();
+  });
+
+  it('uses only shared metadata and the shared authorization scope', async () => {
+    mockShareId = 'public-share';
+    mockFileMap = { f1: { llmDeliveryPath: 'text' } };
+    const view = render(<FilePreviewDialog {...props} />);
+    await waitFor(() => expect(mockSharedPreview).toHaveBeenCalledTimes(1));
+    expect(mockOwnedPreview).not.toHaveBeenCalled();
+    expect(screen.queryByText('extracted document')).toBeNull();
+    view.rerender(<FilePreviewDialog {...props} deliveryPath="text" />);
+    expect(mockUseFilePreview).toHaveBeenLastCalledWith('f1', { enabled: true }, 'public-share');
+    expect(screen.getByText('extracted document')).toBeInTheDocument();
+  });
+});
diff --git a/client/src/components/Chat/Messages/Content/__tests__/FilePreviewDialog.test.ts b/client/src/components/Chat/Messages/Content/__tests__/FilePreviewDialog.test.ts
index 6e8438dbb1f..c8c0c9edb22 100644
--- a/client/src/components/Chat/Messages/Content/__tests__/FilePreviewDialog.test.ts
+++ b/client/src/components/Chat/Messages/Content/__tests__/FilePreviewDialog.test.ts
@@ -1,5 +1,10 @@
 import { FileSources } from 'librechat-data-provider';
-import { getPreviewKind, shouldUseSharedFileDownload } from '../preview';
+import {
+  getPreviewKind,
+  isExtractedTextPreviewLoading,
+  shouldUseExtractedTextPreview,
+  shouldUseSharedFileDownload,
+} from '../preview';
 import { getDownloadFilename } from '~/utils/downloadFile';
 
 describe('FilePreviewDialog text-source behavior', () => {
@@ -17,6 +22,17 @@ describe('FilePreviewDialog text-source behavior', () => {
     expect(getDownloadFilename('report.pdf', 'file-3', FileSources.local)).toBe('report.pdf');
   });
 
+  it('uses stored extracted text when the delivery path is text', () => {
+    expect(shouldUseExtractedTextPreview('text')).toBe(true);
+    expect(shouldUseExtractedTextPreview('provider')).toBe(false);
+    expect(shouldUseExtractedTextPreview(undefined)).toBe(false);
+  });
+
+  it('stops showing a pending preview as loading when polling fails', () => {
+    expect(isExtractedTextPreviewLoading('pending', false, true)).toBe(false);
+    expect(isExtractedTextPreviewLoading('pending', false, false)).toBe(true);
+  });
+
   it('routes any identified file through the share boundary in a shared view', () => {
     expect(shouldUseSharedFileDownload('share-1', 'file-1')).toBe(true);
     expect(shouldUseSharedFileDownload('share-1', undefined)).toBe(false);
diff --git a/client/src/components/Chat/Messages/Content/__tests__/Files.test.tsx b/client/src/components/Chat/Messages/Content/__tests__/Files.test.tsx
new file mode 100644
index 00000000000..267ecda3dbb
--- /dev/null
+++ b/client/src/components/Chat/Messages/Content/__tests__/Files.test.tsx
@@ -0,0 +1,40 @@
+/* eslint-disable i18next/no-literal-string */
+import React from 'react';
+import { fireEvent, render, screen } from '@testing-library/react';
+import type { TMessage } from 'librechat-data-provider';
+import Files from '../Files';
+
+jest.mock('~/Providers', () => ({
+  useFileMapContext: () => ({}),
+  useShareContext: () => ({}),
+}));
+jest.mock(
+  '~/components/Chat/Input/Files/FileContainer',
+  () =>
+    ({ onClick }: { onClick: () => void }) => <button onClick={onClick}>file action</button>,
+);
+jest.mock('../Image', () => () => <div>image preview</div>);
+jest.mock(
+  '../FilePreviewDialog',
+  () =>
+    ({ open, deliveryPath }: { open: boolean; deliveryPath?: string }) =>
+      open ? <div>preview: {deliveryPath}</div> : null,
+);
+
+it('exposes extracted image text without changing ordinary image previews', () => {
+  render(
+    <Files
+      message={
+        {
+          files: [
+            { file_id: 'text-image', type: 'image/png', llmDeliveryPath: 'text' },
+            { file_id: 'image', type: 'image/png' },
+          ],
+        } as TMessage
+      }
+    />,
+  );
+  expect(screen.getAllByText('image preview')).toHaveLength(1);
+  fireEvent.click(screen.getByText('file action'));
+  expect(screen.getByText('preview: text')).toBeInTheDocument();
+});
diff --git a/client/src/components/Chat/Messages/Content/preview.ts b/client/src/components/Chat/Messages/Content/preview.ts
index d369cbf597e..45f64fa1d68 100644
--- a/client/src/components/Chat/Messages/Content/preview.ts
+++ b/client/src/components/Chat/Messages/Content/preview.ts
@@ -1,4 +1,5 @@
 import { FileSources } from 'librechat-data-provider';
+import type { TFile } from 'librechat-data-provider';
 
 type PreviewKind = 'pdf' | 'text' | false;
 
@@ -38,6 +39,18 @@ export function shouldUseSharedFileDownload(shareId?: string, fileId?: string):
   return !!shareId && !!fileId;
 }
 
+export function shouldUseExtractedTextPreview(deliveryPath?: TFile['llmDeliveryPath']): boolean {
+  return deliveryPath === 'text';
+}
+
+export function isExtractedTextPreviewLoading(
+  status: 'pending' | 'ready' | 'failed' | undefined,
+  isInitialLoading: boolean,
+  isError: boolean,
+): boolean {
+  return !isError && (isInitialLoading || status === 'pending');
+}
+
 function getPreviewKindByMime(mime?: string): PreviewKind {
   if (!mime) {
     return false;
diff --git a/client/src/components/Chat/Messages/HoverButtons.tsx b/client/src/components/Chat/Messages/HoverButtons.tsx
index 97133fa06fd..15c59e34381 100644
--- a/client/src/components/Chat/Messages/HoverButtons.tsx
+++ b/client/src/components/Chat/Messages/HoverButtons.tsx
@@ -1,5 +1,6 @@
 import React, { useState, useMemo, useCallback, memo } from 'react';
 import { Copy, Check } from 'lucide';
+import { useAtomValue } from 'jotai';
 import { useRecoilState } from 'recoil';
 import { findMessageById, isUserInitiatedCompaction } from 'librechat-data-provider';
 import {
@@ -14,6 +15,7 @@ import type { TConversation, TMessage, TFeedback } from 'librechat-data-provider
 import { useGenerationsByLatest, useLocalize } from '~/hooks';
 import { useOptionalMessagesOperations } from '~/Providers';
 import { hasEditablePart } from './Content/editableParts';
+import { revealedQueuedTurnFamily } from '~/store/steer';
 import { Fork } from '~/components/Conversations';
 import { hoverButtonClasses } from './styles';
 import MessageAudio from './MessageAudio';
@@ -139,6 +141,7 @@ const HoverButtons = ({
   const [isCopied, setIsCopied] = useState(false);
   const [TextToSpeech] = useRecoilState<boolean>(store.textToSpeech);
   const { getMessages } = useOptionalMessagesOperations();
+  const pendingReveal = useAtomValue(revealedQueuedTurnFamily(conversation?.conversationId ?? ''));
 
   const endpoint = useMemo(() => {
     if (!conversation) {
@@ -171,9 +174,11 @@ const HoverButtons = ({
    *  inside parses markdown. */
   const getHasEditablePart = useCallback(() => hasEditablePart(message), [message]);
 
+  /** A pending queued follow-up is a generation about to start: no rerun or
+   *  continuation may race it, exactly as while a run is submitting. */
   const generationCapabilities = useGenerationsByLatest({
     isEditing,
-    isSubmitting,
+    isSubmitting: isSubmitting || pendingReveal != null,
     error: message.error,
     endpoint: endpoint ?? '',
     messageId: message.messageId,
diff --git a/client/src/components/Chat/Messages/MessagesView.tsx b/client/src/components/Chat/Messages/MessagesView.tsx
index 0b7642f1b9c..1369a74791b 100644
--- a/client/src/components/Chat/Messages/MessagesView.tsx
+++ b/client/src/components/Chat/Messages/MessagesView.tsx
@@ -14,6 +14,7 @@ import { FLAT_THREAD, ThreadList } from './Thread';
 import { fontSizeAtom } from '~/store/fontSize';
 import MultiMessage from './MultiMessage';
 import ScrollButton from './ScrollButton';
+import PendingTurn from './PendingTurn';
 import MessageNav from './MessageNav';
 import { cn } from '~/utils';
 import store from '~/store';
@@ -125,6 +126,11 @@ function MessagesViewContent({
                       )}
                     </RowMountProvider>
                   </div>
+                  <PendingTurn
+                    scrollableRef={scrollableRef}
+                    messages={messages}
+                    maximizeChatSpace={maximizeChatSpace}
+                  />
                 </>
               )}
               <div
diff --git a/client/src/components/Chat/Messages/PendingTurn.tsx b/client/src/components/Chat/Messages/PendingTurn.tsx
new file mode 100644
index 00000000000..f04f1cdc550
--- /dev/null
+++ b/client/src/components/Chat/Messages/PendingTurn.tsx
@@ -0,0 +1,132 @@
+import { useEffect, useMemo, useRef } from 'react';
+import { useAtomValue } from 'jotai';
+import { useRecoilValue } from 'recoil';
+import type { TMessage } from 'librechat-data-provider';
+import type { RefObject } from 'react';
+import type { TMessageIcon } from '~/common';
+import { buildRevealedMessage, hasRevealSuccessor } from '~/hooks/Chat/useQueuedTurnReveal';
+import { getHeaderPrefixForScreenReader, getMessageAriaLabel } from '~/utils';
+import { messageFooterClasses } from '~/components/Chat/Messages/styles';
+import MessageRow from '~/components/Chat/Messages/ui/MessageRow';
+import MessageIcon from '~/components/Chat/Messages/MessageIcon';
+import { revealedQueuedTurnFamily } from '~/store/steer';
+import { useAuthContext } from '~/hooks/AuthContext';
+import MarkdownLite from './Content/MarkdownLite';
+import { useChatContext } from '~/Providers';
+import Container from './Content/Container';
+import { useLocalize } from '~/hooks';
+import SubRow from './SubRow';
+import { cn } from '~/utils';
+import store from '~/store';
+
+/** How far above the end of the thread a reader can be and still be handed
+ *  the next turn, matching the scroll button's own near-bottom band. */
+const FOLLOW_THRESHOLD_PX = 160;
+
+/**
+ * The queued follow-up the server is about to admit, drawn as the user turn
+ * after the completed response it follows. It is not a message: it holds no
+ * hover actions, anchors no send, and leaves the thread the moment the thread
+ * gains a turn after that response (see `useQueuedTurnReveal`).
+ */
+export default function PendingTurn({
+  scrollableRef,
+  messages,
+  maximizeChatSpace = false,
+}: {
+  scrollableRef?: RefObject<HTMLDivElement | null>;
+  messages?: TMessage[] | null;
+  maximizeChatSpace?: boolean;
+}) {
+  const localize = useLocalize();
+  const { user } = useAuthContext();
+  const { conversation, latestMessageId } = useChatContext();
+  const conversationId = conversation?.conversationId ?? '';
+  const reveal = useAtomValue(revealedQueuedTurnFamily(conversationId));
+  const usernameDisplay = useRecoilValue(store.UsernameDisplay);
+  const enableUserMsgMarkdown = useRecoilValue(store.enableUserMsgMarkdown);
+  const rowRef = useRef<HTMLDivElement | null>(null);
+  const message = useMemo(
+    () => (reveal == null ? null : buildRevealedMessage(reveal, conversationId)),
+    [reveal, conversationId],
+  );
+  const successorSeen = useMemo(
+    () => reveal != null && hasRevealSuccessor(messages ?? [], reveal),
+    [messages, reveal],
+  );
+  const shown =
+    message != null &&
+    reveal != null &&
+    reveal.parentMessageId === latestMessageId &&
+    !successorSeen;
+
+  /** A reader resting at the end of the thread was following the response;
+   *  bring the turn that replaces it into view the way its streaming did.
+   *  Anyone reading further up is left where they are. */
+  useEffect(() => {
+    const row = rowRef.current;
+    const scrollEl = scrollableRef?.current;
+    if (!shown || row == null || scrollEl == null) {
+      return;
+    }
+    const distanceFromEnd =
+      scrollEl.scrollHeight - scrollEl.scrollTop - scrollEl.clientHeight - row.offsetHeight;
+    if (distanceFromEnd > FOLLOW_THRESHOLD_PX) {
+      return;
+    }
+    const reduceMotion = window.matchMedia?.('(prefers-reduced-motion: reduce)').matches === true;
+    row.scrollIntoView({ block: 'end', behavior: reduceMotion ? 'auto' : 'smooth' });
+  }, [shown, scrollableRef]);
+
+  if (!shown) {
+    return null;
+  }
+
+  const label = usernameDisplay
+    ? (user?.name ?? '') || (user?.username ?? '')
+    : localize('com_user_message');
+  const iconData: TMessageIcon = {
+    endpoint: conversation?.endpoint,
+    model: conversation?.model,
+    modelLabel: label,
+    isCreatedByUser: true,
+  };
+
+  return (
+    <div
+      ref={rowRef}
+      className="w-full border-0 bg-transparent text-text-primary"
+      data-testid="pending-turn"
+    >
+      <div className="m-auto justify-center px-4 py-3 sm:px-0">
+        <MessageRow
+          icon={<MessageIcon iconData={iconData} />}
+          label={label}
+          timestamp={reveal.revealedAt}
+          ariaLabel={getMessageAriaLabel(message, localize)}
+          headerPrefix={getHeaderPrefixForScreenReader(message, localize)}
+          isCreatedByUser
+          fullWidth={maximizeChatSpace}
+          footer={
+            <SubRow classes={cn(messageFooterClasses, 'justify-end')}>
+              <span className="text-xs text-text-secondary" role="status">
+                {localize('com_ui_queued_turn_starting')}
+              </span>
+            </SubRow>
+          }
+        >
+          <Container message={message}>
+            <div
+              className={cn(
+                'markdown prose message-content dark:prose-invert light w-full break-words text-text-primary',
+                !enableUserMsgMarkdown && 'whitespace-pre-wrap',
+              )}
+            >
+              {enableUserMsgMarkdown ? <MarkdownLite content={reveal.text} /> : reveal.text}
+            </div>
+          </Container>
+        </MessageRow>
+      </div>
+    </div>
+  );
+}
diff --git a/client/src/components/Chat/Messages/__tests__/PendingTurn.spec.tsx b/client/src/components/Chat/Messages/__tests__/PendingTurn.spec.tsx
new file mode 100644
index 00000000000..ae4a67fa3c4
--- /dev/null
+++ b/client/src/components/Chat/Messages/__tests__/PendingTurn.spec.tsx
@@ -0,0 +1,125 @@
+import React from 'react';
+import { RecoilRoot } from 'recoil';
+import { EModelEndpoint } from 'librechat-data-provider';
+import { act, render, screen } from '@testing-library/react';
+import { Provider as JotaiProvider, createStore } from 'jotai';
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
+import type { TConversation, TMessage } from 'librechat-data-provider';
+import type { RevealedQueuedTurn } from '~/store/steer';
+import PendingTurn from '~/components/Chat/Messages/PendingTurn';
+import { revealedQueuedTurnFamily } from '~/store/steer';
+import { ChatContext } from '~/Providers';
+
+jest.mock('~/hooks', () => ({
+  useLocalize: () => (key: string) => key,
+}));
+
+jest.mock('~/hooks/AuthContext', () => ({
+  useAuthContext: () => ({ user: { name: 'Danny', username: 'danny' } }),
+}));
+
+jest.mock('~/components/Chat/Messages/MessageIcon', () => ({
+  __esModule: true,
+  default: () => <span data-testid="message-icon" />,
+}));
+
+jest.mock('~/components/Chat/Messages/Content/MarkdownLite', () => ({
+  __esModule: true,
+  default: ({ content }: { content: string }) => <span data-testid="markdown-lite">{content}</span>,
+}));
+
+const CONVO_ID = 'convo-pending';
+const RESPONSE_ID = 'response-1';
+
+const conversation = {
+  conversationId: CONVO_ID,
+  endpoint: EModelEndpoint.agents,
+  model: 'gpt-x',
+} as TConversation;
+
+const reveal = (overrides: Partial<RevealedQueuedTurn> = {}): RevealedQueuedTurn => ({
+  clientRequestId: 'client-request-1',
+  parentMessageId: RESPONSE_ID,
+  text: 'queued follow-up',
+  revealedAt: '2026-09-14T00:00:00.000Z',
+  ...overrides,
+});
+
+function renderPendingTurn({
+  revealed,
+  latestMessageId = RESPONSE_ID,
+  messages,
+}: {
+  revealed?: RevealedQueuedTurn | null;
+  latestMessageId?: string | undefined;
+  messages?: TMessage[];
+}) {
+  const jotaiStore = createStore();
+  if (revealed != null) {
+    jotaiStore.set(revealedQueuedTurnFamily(CONVO_ID), revealed);
+  }
+  const queryClient = new QueryClient({ defaultOptions: { queries: { retry: false } } });
+  const chatContext = { conversation, latestMessageId, index: 0 } as unknown as React.ContextType<
+    typeof ChatContext
+  >;
+  const rendered = render(
+    <QueryClientProvider client={queryClient}>
+      <RecoilRoot>
+        <JotaiProvider store={jotaiStore}>
+          <ChatContext.Provider value={chatContext}>
+            <PendingTurn messages={messages} />
+          </ChatContext.Provider>
+        </JotaiProvider>
+      </RecoilRoot>
+    </QueryClientProvider>,
+  );
+  return { ...rendered, jotaiStore };
+}
+
+describe('PendingTurn', () => {
+  it('draws the revealed queued turn as a user turn after the response it follows', () => {
+    const { container } = renderPendingTurn({ revealed: reveal() });
+
+    const row = screen.getByTestId('pending-turn');
+    expect(row.querySelector('.message-render')).not.toBeNull();
+    expect(row.querySelector('.user-turn')).not.toBeNull();
+    expect(row).toHaveTextContent('queued follow-up');
+    expect(screen.getByRole('status')).toHaveTextContent('com_ui_queued_turn_starting');
+    expect(container.querySelectorAll('button')).toHaveLength(0);
+  });
+
+  it('renders nothing without a reveal', () => {
+    renderPendingTurn({ revealed: null });
+    expect(screen.queryByTestId('pending-turn')).toBeNull();
+  });
+
+  it('renders nothing while the thread shows a different tail than the response it follows', () => {
+    renderPendingTurn({ revealed: reveal(), latestMessageId: 'another-branch' });
+    expect(screen.queryByTestId('pending-turn')).toBeNull();
+  });
+
+  it('leaves the thread the moment the reveal ends', () => {
+    const { jotaiStore } = renderPendingTurn({ revealed: reveal() });
+    expect(screen.getByTestId('pending-turn')).toBeInTheDocument();
+
+    act(() => {
+      jotaiStore.set(revealedQueuedTurnFamily(CONVO_ID), null);
+    });
+
+    expect(screen.queryByTestId('pending-turn')).toBeNull();
+  });
+  it('hides the drawing once history has a successor while the handoff guard remains', () => {
+    const { jotaiStore } = renderPendingTurn({
+      revealed: reveal(),
+      messages: [
+        {
+          messageId: 'real-successor',
+          parentMessageId: RESPONSE_ID,
+          isCreatedByUser: true,
+        } as TMessage,
+      ],
+    });
+    expect(screen.queryByTestId('pending-turn')).toBeNull();
+    expect(jotaiStore.get(revealedQueuedTurnFamily(CONVO_ID))).not.toBeNull();
+  });
+});
diff --git a/client/src/components/Chat/__tests__/ChatView.spec.tsx b/client/src/components/Chat/__tests__/ChatView.spec.tsx
index f97f4d7e1eb..80d03eada04 100644
--- a/client/src/components/Chat/__tests__/ChatView.spec.tsx
+++ b/client/src/components/Chat/__tests__/ChatView.spec.tsx
@@ -33,6 +33,7 @@ jest.mock('~/hooks', () => ({
   useAdaptiveSSE: jest.fn(),
   useResumeOnLoad: jest.fn(),
   useQueueDrain: jest.fn(),
+  useQueuedTurnReveal: jest.fn(),
   useScrollbarGutterSeed: jest.fn(),
 }));
 
diff --git a/client/src/components/Chat/__tests__/ChatView.subagent.spec.tsx b/client/src/components/Chat/__tests__/ChatView.subagent.spec.tsx
index 7f7a5cadfe0..72a66c62bc5 100644
--- a/client/src/components/Chat/__tests__/ChatView.subagent.spec.tsx
+++ b/client/src/components/Chat/__tests__/ChatView.subagent.spec.tsx
@@ -32,6 +32,7 @@ jest.mock('~/hooks', () => ({
   useResumeOnLoad: jest.fn(),
   useAdaptiveSSE: jest.fn(),
   useQueueDrain: jest.fn(),
+  useQueuedTurnReveal: jest.fn(),
   useScrollbarGutterSeed: jest.fn(),
   useLocalize: () => (key: string) => key,
   useChatHelpers: () => ({
diff --git a/client/src/components/Chat/approval/__tests__/preview.test.ts b/client/src/components/Chat/approval/__tests__/preview.test.ts
index 77111f9abc3..a20c8b1c26b 100644
--- a/client/src/components/Chat/approval/__tests__/preview.test.ts
+++ b/client/src/components/Chat/approval/__tests__/preview.test.ts
@@ -1,6 +1,16 @@
 import { buildApprovalPreview, buildApprovalPreviews } from '../preview';
 
 describe('buildApprovalPreview', () => {
+  test('shows named action arguments instead of an empty command', () => {
+    const preview = buildApprovalPreview({
+      name: 'bash_tool',
+      source: 'librechat_code',
+      tool_call_id: 'action-1',
+      arguments: { environmentAction: 'typecheck', timeoutMs: 120000 },
+    });
+    expect(preview.kind).toBe('generic');
+    expect(JSON.parse(preview.body)).toEqual({ environmentAction: 'typecheck', timeoutMs: 120000 });
+  });
   test('shows the exact effective command and reveals bidi control characters', () => {
     const preview = buildApprovalPreview({
       name: 'bash_tool',
diff --git a/client/src/components/Chat/approval/preview.ts b/client/src/components/Chat/approval/preview.ts
index 23652e1051b..f5008a23ee1 100644
--- a/client/src/components/Chat/approval/preview.ts
+++ b/client/src/components/Chat/approval/preview.ts
@@ -116,7 +116,12 @@ export function buildApprovalPreview(
   let target: string | undefined;
   let rawBody = stringifyArguments(request.arguments);
 
-  if (request.source === 'librechat_code' && request.name === 'bash_tool' && parsed) {
+  if (
+    request.source === 'librechat_code' &&
+    request.name === 'bash_tool' &&
+    parsed &&
+    parsed.environmentAction === undefined
+  ) {
     kind = 'command';
     rawBody = stringField(parsed, 'command');
   } else if (request.source === 'librechat_code' && request.name === 'create_file' && parsed) {
diff --git a/client/src/components/SidePanel/Files/PanelTable.tsx b/client/src/components/SidePanel/Files/PanelTable.tsx
index c46d6ba2577..b526ce2ce11 100644
--- a/client/src/components/SidePanel/Files/PanelTable.tsx
+++ b/client/src/components/SidePanel/Files/PanelTable.tsx
@@ -11,6 +11,14 @@ import {
   TableHeader,
   useToastContext,
 } from '@librechat/client';
+import {
+  megabyte,
+  mergeFileConfig,
+  checkOpenAIStorage,
+  isAssistantsEndpoint,
+  getEndpointFileConfig,
+  fileConfig as defaultFileConfig,
+} from 'librechat-data-provider';
 import {
   flexRender,
   getCoreRowModel,
@@ -23,14 +31,6 @@ import {
   type VisibilityState,
   type ColumnFiltersState,
 } from '@tanstack/react-table';
-import {
-  megabyte,
-  mergeFileConfig,
-  checkOpenAIStorage,
-  isAssistantsEndpoint,
-  getEndpointFileConfig,
-  fileConfig as defaultFileConfig,
-} from 'librechat-data-provider';
 import type { TFile } from 'librechat-data-provider';
 import { MyFilesModal } from '~/components/Chat/Input/Files/MyFilesModal';
 import { useFileMapContext, useChatContext } from '~/Providers';
@@ -197,6 +197,7 @@ export default function DataTable<TData, TValue>({ columns, data }: DataTablePro
         source: fileData.source,
         size: fileData.bytes,
         metadata: fileData.metadata,
+        llmDeliveryPath: fileData.llmDeliveryPath,
       });
     },
     [addFile, files, fileMap, conversation, localize, showToast, fileConfig],
diff --git a/client/src/components/SidePanel/Files/__tests__/PanelTable.spec.tsx b/client/src/components/SidePanel/Files/__tests__/PanelTable.spec.tsx
index b7ebba77c61..3039820c3bb 100644
--- a/client/src/components/SidePanel/Files/__tests__/PanelTable.spec.tsx
+++ b/client/src/components/SidePanel/Files/__tests__/PanelTable.spec.tsx
@@ -170,6 +170,7 @@ describe('PanelTable handleFileClick', () => {
       filename: 'report.pdf',
       context: FileContext.run_artifact,
       metadata: { runFile },
+      llmDeliveryPath: 'text',
     });
     mockFileMap = { [file.file_id]: file };
 
@@ -182,6 +183,7 @@ describe('PanelTable handleFileClick', () => {
         filename: 'report.pdf',
         filepath: file.filepath,
         metadata: { runFile },
+        llmDeliveryPath: 'text',
         attached: true,
         progress: 1,
       }),
diff --git a/client/src/data-provider/Files/previewBlob.test.tsx b/client/src/data-provider/Files/previewBlob.test.tsx
new file mode 100644
index 00000000000..34b2dc7b02a
--- /dev/null
+++ b/client/src/data-provider/Files/previewBlob.test.tsx
@@ -0,0 +1,50 @@
+import React from 'react';
+import { dataService } from 'librechat-data-provider';
+import { act, renderHook } from '@testing-library/react';
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
+import { useFilePreviewBlob } from './queries';
+
+jest.mock('librechat-data-provider', () => ({
+  ...jest.requireActual('librechat-data-provider'),
+  dataService: { getFileDownload: jest.fn(), getSharedFileDownload: jest.fn() },
+}));
+jest.mock('~/store', () => ({}));
+jest.mock('~/utils', () => ({}));
+jest.mock('~/common', () => ({}));
+
+describe('preview blob ownership', () => {
+  afterEach(() => jest.clearAllMocks());
+
+  it.each([undefined, 'share-1'])(
+    'shares bytes across deduplicated requests (%s)',
+    async (shareId) => {
+      let resolve!: (value: { data: Blob }) => void;
+      const pending = new Promise<{ data: Blob }>((done) => {
+        resolve = done;
+      });
+      const owned = jest.mocked(dataService.getFileDownload).mockReturnValue(pending as never);
+      const shared = jest
+        .mocked(dataService.getSharedFileDownload)
+        .mockReturnValue(pending as never);
+      const client = new QueryClient();
+      const wrapper = ({ children }: React.PropsWithChildren) => (
+        <QueryClientProvider client={client}>{children}</QueryClientProvider>
+      );
+      const first = renderHook(() => useFilePreviewBlob('owner', 'f1', shareId), { wrapper });
+      const second = renderHook(() => useFilePreviewBlob('owner', 'f1', shareId), { wrapper });
+      const blob = new Blob(['preview']);
+      await act(async () => {
+        const a = first.result.current.refetch();
+        const b = second.result.current.refetch();
+        resolve({ data: blob });
+        expect((await a).data).toBe(blob);
+        expect((await b).data).toBe(blob);
+      });
+      expect(shareId ? shared : owned).toHaveBeenCalledTimes(1);
+      expect(shareId ? owned : shared).not.toHaveBeenCalled();
+      first.unmount();
+      second.unmount();
+      client.clear();
+    },
+  );
+});
diff --git a/client/src/data-provider/Files/queries.ts b/client/src/data-provider/Files/queries.ts
index da6981571e0..3c455a4bef8 100644
--- a/client/src/data-provider/Files/queries.ts
+++ b/client/src/data-provider/Files/queries.ts
@@ -161,6 +161,26 @@ export const useSharedFileDownload = (
   );
 };
 
+/** Preview consumers share immutable bytes, never a revocable download URL. */
+export const useFilePreviewBlob = (
+  userId?: string,
+  fileId?: string,
+  shareId?: string,
+): QueryObserverResult<Blob> =>
+  useQuery(
+    [QueryKeys.fileDownload, 'previewBlob', shareId ? 'share' : 'owner', shareId ?? userId, fileId],
+    async () => {
+      if (!fileId || (!shareId && !userId)) {
+        throw new Error('Preview identity unavailable');
+      }
+      const response = shareId
+        ? await dataService.getSharedFileDownload(shareId, fileId)
+        : await dataService.getFileDownload(userId!, fileId);
+      return response.data;
+    },
+    { enabled: false, retry: false, cacheTime: 0 },
+  );
+
 export const useCodeOutputDownload = (url = ''): QueryObserverResult<string> => {
   return useQuery(
     [QueryKeys.fileDownload, url],
diff --git a/client/src/data-provider/SSE/__tests__/queuedTurns.test.ts b/client/src/data-provider/SSE/__tests__/queuedTurns.test.ts
index 3e1db9a5b91..4f7a435f89d 100644
--- a/client/src/data-provider/SSE/__tests__/queuedTurns.test.ts
+++ b/client/src/data-provider/SSE/__tests__/queuedTurns.test.ts
@@ -145,6 +145,12 @@ describe('Agent queued-turn data adapter', () => {
     expect(shouldPollAgentQueuedTurns([{ status: 'queued' }])).toBe(true);
   });
 
+  it('keeps polling an empty projection while the client still holds a server-owned row', () => {
+    expect(shouldPollAgentQueuedTurns([])).toBe(false);
+    expect(shouldPollAgentQueuedTurns([], undefined, Date.now(), true)).toBe(true);
+    expect(shouldPollAgentQueuedTurns(undefined, undefined, Date.now(), true)).toBe(true);
+  });
+
   it('counts an admitted turn as an owed run, unlike the receipt poll', () => {
     /**
      * The receipt poll stops at `admitted` because nothing is left to wait
diff --git a/client/src/data-provider/SSE/queuedTurns.ts b/client/src/data-provider/SSE/queuedTurns.ts
index ea7097adc63..e87b9b7961e 100644
--- a/client/src/data-provider/SSE/queuedTurns.ts
+++ b/client/src/data-provider/SSE/queuedTurns.ts
@@ -83,8 +83,10 @@ export function shouldPollAgentQueuedTurns(
   receipts: unknown,
   reconcileUntil?: number,
   observedAt = Date.now(),
+  expectsReceipts = false,
 ): boolean {
   return (
+    expectsReceipts ||
     (reconcileUntil != null && observedAt < reconcileUntil) ||
     (Array.isArray(receipts) &&
       receipts.some(
@@ -117,11 +119,18 @@ export function isQueuedTurnSuccessorOwed(receipts: unknown): boolean {
   );
 }
 
+/**
+ * `expectsReceipts` keeps the poll alive while the caller still holds a
+ * server-owned row the projection has not settled. A snapshot fetched while
+ * the enqueue is still committing can come back empty, and a poll that stops
+ * on that answer would leave a fast successor unnoticed until the next focus.
+ */
 export function useAgentQueuedTurns(
   conversationId: string,
   enabled: boolean,
   clientRequestIds: string[] = [],
   reconcileUntil?: number,
+  expectsReceipts = false,
 ) {
   const queryClient = useQueryClient();
   const knownIds = [...new Set(clientRequestIds)].sort();
@@ -138,7 +147,9 @@ export function useAgentQueuedTurns(
     refetchOnMount: 'always',
     refetchOnWindowFocus: 'always',
     refetchInterval: (receipts) =>
-      shouldPollAgentQueuedTurns(receipts, reconcileUntil) ? 2_000 : false,
+      shouldPollAgentQueuedTurns(receipts, reconcileUntil, Date.now(), expectsReceipts)
+        ? 2_000
+        : false,
     retry: false,
   });
   const { refetch } = query;
diff --git a/client/src/hooks/Chat/__tests__/useChatFunctions.regenerate.spec.tsx b/client/src/hooks/Chat/__tests__/useChatFunctions.regenerate.spec.tsx
index f922db8a3f8..2bce0165189 100644
--- a/client/src/hooks/Chat/__tests__/useChatFunctions.regenerate.spec.tsx
+++ b/client/src/hooks/Chat/__tests__/useChatFunctions.regenerate.spec.tsx
@@ -1,3 +1,4 @@
+import { getDefaultStore } from 'jotai';
 import { renderHook, act } from '@testing-library/react';
 import { Constants, ContentTypes, EModelEndpoint, createPayload } from 'librechat-data-provider';
 import type {
@@ -7,6 +8,7 @@ import type {
   TMessage,
   TSubmission,
 } from 'librechat-data-provider';
+import { revealedQueuedTurnFamily } from '~/store/steer';
 import useChatFunctions from '../useChatFunctions';
 import { isPasteSubmitted } from '~/utils';
 
@@ -168,6 +170,7 @@ describe('useChatFunctions ask', () => {
 
     const submission = setSubmission.mock.calls.at(-1)?.[0] as TSubmission;
     expect(submission.codeApprovalMode).toBe('acceptEdits');
+    expect(submission.conversation.codeApprovalMode).toBe('acceptEdits');
   });
 
   it('preallocates a durable Agents user id for the optimistic response anchor', () => {
@@ -207,6 +210,30 @@ describe('useChatFunctions ask', () => {
     expect(submission.codeWorkspaces).toEqual([selection]);
   });
 
+  it('refuses every direct send before consuming composer context during handoff', () => {
+    const family = revealedQueuedTurnFamily('conversation-1');
+    getDefaultStore().set(family, {
+      clientRequestId: 'queued',
+      parentMessageId: 'response',
+      generationCreatedAt: 41,
+      text: 'queued',
+      revealedAt: new Date().toISOString(),
+    });
+    try {
+      const { result, setSubmission, getMessages } = renderAsk([]);
+      expect(result.current.ask({ text: 'direct' })).toBe(false);
+      expect(
+        result.current.ask({ text: 'rerun', parentMessageId: 'earlier' }, { isRegenerate: true }),
+      ).toBe(false);
+      expect(mockResolveCodeWorkspaceSubmission).not.toHaveBeenCalled();
+      expect(getMessages).not.toHaveBeenCalled();
+      expect(setSubmission).not.toHaveBeenCalled();
+      expect(mockSetFilesToDelete).not.toHaveBeenCalled();
+    } finally {
+      getDefaultStore().set(family, null);
+    }
+  });
+
   it('refuses to send when workspace submission resolution is not ready', () => {
     mockResolveCodeWorkspaceSubmission.mockReturnValue(undefined);
     const { result, setSubmission } = renderAsk([]);
diff --git a/client/src/hooks/Chat/__tests__/useQueueDrain.spec.tsx b/client/src/hooks/Chat/__tests__/useQueueDrain.spec.tsx
index 232c79c993e..d14d0b6a7e6 100644
--- a/client/src/hooks/Chat/__tests__/useQueueDrain.spec.tsx
+++ b/client/src/hooks/Chat/__tests__/useQueueDrain.spec.tsx
@@ -1,4 +1,5 @@
 import React from 'react';
+import { getDefaultStore } from 'jotai';
 import { Constants } from 'librechat-data-provider';
 import { act, renderHook, waitFor } from '@testing-library/react';
 import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
@@ -9,6 +10,7 @@ import type {
   QueuedMessage,
   SettledQueuedTurnReceipt,
 } from '~/store/families';
+import { revealedQueuedTurnFamily } from '~/store/steer';
 import useQueueDrain from '../useQueueDrain';
 import store from '~/store';
 
@@ -24,6 +26,7 @@ const CONVO_ID = 'convo-drain';
 function setup(
   initialize?: (snapshot: MutableSnapshot) => void,
   activeConversationId: string | undefined = CONVO_ID,
+  revealQueuedTurn?: jest.Mock,
 ) {
   const ask = jest.fn();
   const setters: {
@@ -54,7 +57,7 @@ function setup(
     setters.newConvoQueue = useRecoilValue(store.queuedMessagesByConvoId(Constants.NEW_CONVO));
     setters.settledReceipts = useRecoilValue(store.settledQueuedTurnReceiptsByConvoId(CONVO_ID));
     setters.runEnd = useRecoilValue(store.runEndByIndex(INDEX));
-    useQueueDrain(INDEX, activeConversationId, ask);
+    useQueueDrain(INDEX, activeConversationId, ask, revealQueuedTurn);
     return null;
   }
 
@@ -140,6 +143,135 @@ describe('useQueueDrain', () => {
     });
   });
 
+  it('hands the server-owned head to the reveal on clean completion and keeps the boundary', async () => {
+    const reveal = jest.fn();
+    const head = {
+      ...queuedMessage('q-server', 'the server starts this turn'),
+      clientRequestId: 'client-request-1',
+      server: { id: 'server-queue-1', status: 'queued' as const, revision: 1 },
+    };
+    const { ask, setters } = setup(
+      ({ set }) => {
+        set(store.queuedMessagesByConvoId(CONVO_ID), [head]);
+      },
+      CONVO_ID,
+      reveal,
+    );
+
+    const end = runEnd({ responseMessageId: 'response-1' });
+    act(() => {
+      setters.setRunEnd!(end);
+    });
+
+    await waitFor(() => expect(reveal).toHaveBeenCalled());
+    expect(reveal).toHaveBeenCalledWith(head, expect.objectContaining(end));
+    expect(ask).not.toHaveBeenCalled();
+    expect(setters.runEnd).toEqual(expect.objectContaining(end));
+    expect(setters.queue).toEqual([head]);
+  });
+
+  it('re-selects the next server-owned row once the revealed head settles', async () => {
+    const reveal = jest.fn();
+    const first = {
+      ...queuedMessage('q-first', 'first server turn'),
+      clientRequestId: 'client-request-1',
+      server: { id: 'server-queue-1', status: 'queued' as const, revision: 1 },
+    };
+    const second = {
+      ...queuedMessage('q-second', 'second server turn'),
+      clientRequestId: 'client-request-2',
+      server: { id: 'server-queue-2', status: 'queued' as const, revision: 2 },
+    };
+    const { setters } = setup(
+      ({ set }) => {
+        set(store.queuedMessagesByConvoId(CONVO_ID), [first, second]);
+      },
+      CONVO_ID,
+      reveal,
+    );
+
+    act(() => {
+      setters.setRunEnd!(runEnd({ responseMessageId: 'response-1' }));
+    });
+    await waitFor(() => expect(reveal).toHaveBeenCalled());
+    expect(reveal.mock.calls[0][0]).toEqual(first);
+    act(() => {
+      getDefaultStore().set(revealedQueuedTurnFamily(CONVO_ID), {
+        clientRequestId: 'client-request-1',
+        parentMessageId: 'response-1',
+        text: first.text,
+        revealedAt: '2026-09-14T00:00:00.000Z',
+      });
+    });
+    reveal.mockClear();
+
+    /** The first row is cancelled before admission: its reveal ends and the
+     *  row leaves the queue, while the boundary stays server-owned. */
+    act(() => {
+      getDefaultStore().set(revealedQueuedTurnFamily(CONVO_ID), null);
+      setters.setQueue!([second]);
+    });
+
+    await waitFor(() => expect(reveal).toHaveBeenCalled());
+    expect(reveal.mock.calls[reveal.mock.calls.length - 1][0]).toEqual(second);
+    expect(setters.runEnd).toEqual(expect.objectContaining({ responseMessageId: 'response-1' }));
+  });
+
+  it('reveals the server-owned row behind a migrated local head', async () => {
+    const reveal = jest.fn();
+    const local = queuedMessage('q-local', 'queued before the id arrived');
+    const serverRow = {
+      ...queuedMessage('q-server', 'queued after the id arrived'),
+      clientRequestId: 'client-request-2',
+      server: { id: 'server-queue-2', status: 'queued' as const, revision: 1 },
+    };
+    const { ask, setters } = setup(
+      ({ set }) => {
+        set(store.queuedMessagesByConvoId(Constants.NEW_CONVO), [local]);
+        set(store.queuedMessagesByConvoId(CONVO_ID), [serverRow]);
+      },
+      CONVO_ID,
+      reveal,
+    );
+
+    act(() => {
+      setters.setRunEnd!(runEnd({ startedAsNewConvo: true, responseMessageId: 'response-1' }));
+    });
+
+    await waitFor(() => expect(reveal).toHaveBeenCalled());
+    expect(reveal.mock.calls[0][0]).toEqual(serverRow);
+    expect(ask).not.toHaveBeenCalled();
+  });
+
+  it('reveals nothing on a stop, or when the completed run carries no response id', async () => {
+    const reveal = jest.fn();
+    const { setters } = setup(
+      ({ set }) => {
+        set(store.queuedMessagesByConvoId(CONVO_ID), [
+          {
+            ...queuedMessage('q-server', 'the server starts this turn'),
+            clientRequestId: 'client-request-1',
+            server: { id: 'server-queue-1', status: 'queued', revision: 1 },
+          },
+        ]);
+      },
+      CONVO_ID,
+      reveal,
+    );
+
+    act(() => {
+      setters.setRunEnd!(runEnd({ outcome: 'aborted', responseMessageId: 'response-1' }));
+    });
+    await new Promise((resolve) => setTimeout(resolve, 25));
+    act(() => {
+      setters.setRunEnd!(null);
+      setters.setRunEnd!(runEnd());
+    });
+    await new Promise((resolve) => setTimeout(resolve, 25));
+
+    expect(reveal).not.toHaveBeenCalled();
+  });
+
   it('retains the terminal boundary until server authority releases a local successor', async () => {
     const localSuccessor = queuedMessage('q-local', 'legacy successor');
     const queue: QueuedMessage[] = [
diff --git a/client/src/hooks/Chat/__tests__/useQueuedTurnReveal.spec.tsx b/client/src/hooks/Chat/__tests__/useQueuedTurnReveal.spec.tsx
new file mode 100644
index 00000000000..b112b972488
--- /dev/null
+++ b/client/src/hooks/Chat/__tests__/useQueuedTurnReveal.spec.tsx
@@ -0,0 +1,457 @@
+import React from 'react';
+import { QueryKeys } from 'librechat-data-provider';
+import { RecoilRoot, useSetRecoilState } from 'recoil';
+import { Provider as JotaiProvider, createStore } from 'jotai';
+import { act, renderHook, waitFor } from '@testing-library/react';
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
+import type { TMessage, TAgentQueuedTurnReceipt } from 'librechat-data-provider';
+import type { QueuedMessage, RunEnd } from '~/store/families';
+import type { RevealedQueuedTurn } from '~/store/steer';
+import useQueuedTurnReveal, {
+  buildRevealedMessage,
+  hasRevealSuccessor,
+  selectQueuedTurnReveal,
+  shouldRollbackReveal,
+} from '../useQueuedTurnReveal';
+import { agentQueuedTurnsQueryKey } from '~/data-provider/SSE/queuedTurns';
+import { streamStatusQueryKey } from '~/data-provider/SSE/queries';
+import { revealedQueuedTurnFamily } from '~/store/steer';
+import store from '~/store';
+
+const CONVO_ID = 'convo-reveal';
+const RESPONSE_ID = 'response-1';
+
+const serverRow = (overrides: Partial<QueuedMessage> = {}): QueuedMessage => ({
+  id: 'q-server',
+  text: 'queued follow-up',
+  createdAt: 10,
+  parentMessageId: 'original-queue-parent',
+  expectedPredecessorCreatedAt: 41,
+  clientRequestId: 'client-request-1',
+  server: { id: 'server-queue-1', status: 'queued', revision: 1 },
+  ...overrides,
+});
+
+const completedEnd = (overrides: Partial<RunEnd> = {}): RunEnd => ({
+  conversationId: CONVO_ID,
+  outcome: 'completed',
+  endedAt: 100,
+  generationCreatedAt: 41,
+  responseMessageId: RESPONSE_ID,
+  ...overrides,
+});
+
+const history = (): TMessage[] => [
+  { messageId: 'user-1', parentMessageId: '00000000-0000-0000-0000-000000000000' } as TMessage,
+  { messageId: RESPONSE_ID, parentMessageId: 'user-1', isCreatedByUser: false } as TMessage,
+];
+
+const successor = (messageId = 'user-2'): TMessage =>
+  ({ messageId, parentMessageId: RESPONSE_ID, isCreatedByUser: true }) as TMessage;
+
+const reveal = (overrides: Partial<RevealedQueuedTurn> = {}): RevealedQueuedTurn => ({
+  clientRequestId: 'client-request-1',
+  parentMessageId: RESPONSE_ID,
+  text: 'queued follow-up',
+  revealedAt: '2026-09-14T00:00:00.000Z',
+  ...overrides,
+});
+
+const receipt = (overrides: Partial<TAgentQueuedTurnReceipt> = {}): TAgentQueuedTurnReceipt =>
+  ({
+    queuedTurnId: 'server-queue-1',
+    clientRequestId: 'client-request-1',
+    conversationId: CONVO_ID,
+    text: 'queued follow-up',
+    status: 'queued',
+    revision: 1,
+    createdAt: '2026-09-14T00:00:00.000Z',
+    updatedAt: '2026-09-14T00:00:00.000Z',
+    ...overrides,
+  }) as TAgentQueuedTurnReceipt;
+
+describe('selectQueuedTurnReveal', () => {
+  it('picks a durably queued server-owned head after a clean completion', () => {
+    expect(selectQueuedTurnReveal(completedEnd(), [serverRow()])?.id).toBe('q-server');
+    expect(
+      selectQueuedTurnReveal(completedEnd(), [
+        serverRow({ server: { id: 'server-queue-1', status: 'claimed', revision: 1 } }),
+      ])?.id,
+    ).toBe('q-server');
+  });
+
+  it('reveals nothing for a stop, an error, or a run with no response to follow', () => {
+    expect(selectQueuedTurnReveal(completedEnd({ outcome: 'aborted' }), [serverRow()])).toBeNull();
+    expect(selectQueuedTurnReveal(completedEnd({ outcome: 'error' }), [serverRow()])).toBeNull();
+    expect(
+      selectQueuedTurnReveal(completedEnd({ generationCreatedAt: undefined }), [serverRow()]),
+    ).toBeNull();
+    expect(
+      selectQueuedTurnReveal(completedEnd({ responseMessageId: undefined }), [serverRow()]),
+    ).toBeNull();
+  });
+
+  it('skips rejected server rows and local rows ahead of the admissible successor', () => {
+    const rejected = serverRow({
+      id: 'q-rejected',
+      clientRequestId: 'client-request-0',
+      server: { id: 'server-queue-0', status: 'rejected', revision: 0 },
+    });
+    const local: QueuedMessage = { id: 'q-local', text: 'local first', createdAt: 5 };
+    expect(selectQueuedTurnReveal(completedEnd(), [rejected, serverRow()])?.id).toBe('q-server');
+    expect(selectQueuedTurnReveal(completedEnd(), [local, serverRow()])?.id).toBe('q-server');
+    expect(selectQueuedTurnReveal(completedEnd(), [local])).toBeNull();
+  });
+
+  it('leaves rows the server has not durably accepted, or has settled, on the chip', () => {
+    expect(
+      selectQueuedTurnReveal(completedEnd(), [serverRow({ server: { status: 'sending' } })]),
+    ).toBeNull();
+    expect(selectQueuedTurnReveal(completedEnd(), [serverRow({ server: undefined })])).toBeNull();
+    expect(selectQueuedTurnReveal(completedEnd(), [])).toBeNull();
+  });
+});
+
+describe('hasRevealSuccessor', () => {
+  it('is true once anything parents on the response the reveal follows', () => {
+    expect(hasRevealSuccessor(history(), reveal())).toBe(false);
+    expect(hasRevealSuccessor([...history(), successor()], reveal())).toBe(true);
+    expect(
+      hasRevealSuccessor(
+        [...history(), { messageId: 'x', parentMessageId: 'user-1' } as TMessage],
+        reveal(),
+      ),
+    ).toBe(false);
+  });
+});
+
+describe('shouldRollbackReveal', () => {
+  it('ends the reveal on cancelled, dead, or indeterminate receipts for its request', () => {
+    expect(shouldRollbackReveal([receipt({ status: 'cancelled' })], reveal())).toBe(true);
+    expect(shouldRollbackReveal([receipt({ status: 'dead' })], reveal())).toBe(true);
+    expect(
+      shouldRollbackReveal(
+        [receipt({ status: 'claimed', failure: { code: 'ADMISSION_INDETERMINATE' } })],
+        reveal(),
+      ),
+    ).toBe(true);
+    expect(
+      shouldRollbackReveal(
+        [receipt({ status: 'cancelled', clientRequestId: 'client-request-9' })],
+        reveal(),
+      ),
+    ).toBe(false);
+  });
+
+  it('keeps the reveal while the turn is queued, claimed, or admitted', () => {
+    expect(shouldRollbackReveal([receipt()], reveal())).toBe(false);
+    expect(shouldRollbackReveal([receipt({ status: 'claimed' })], reveal())).toBe(false);
+    expect(shouldRollbackReveal([receipt({ status: 'admitted' })], reveal())).toBe(false);
+    expect(shouldRollbackReveal([], reveal())).toBe(false);
+  });
+});
+
+describe('buildRevealedMessage', () => {
+  it('shapes a render-only user turn after the completed response with the queued context', () => {
+    const message = buildRevealedMessage(
+      reveal({ files: [{ file_id: 'f1' }], quotes: ['q'], manualSkills: ['s'] }),
+      CONVO_ID,
+    );
+    expect(message).toEqual(
+      expect.objectContaining({
+        parentMessageId: RESPONSE_ID,
+        conversationId: CONVO_ID,
+        text: 'queued follow-up',
+        isCreatedByUser: true,
+        clientTimestamp: '2026-09-14T00:00:00.000Z',
+        files: [{ file_id: 'f1' }],
+        quotes: ['q'],
+        manualSkills: ['s'],
+      }),
+    );
+    expect(message.createdAt).toBeUndefined();
+    expect(buildRevealedMessage(reveal(), CONVO_ID)).not.toHaveProperty('files');
+  });
+});
+
+describe('useQueuedTurnReveal', () => {
+  function setup(initialMessages: TMessage[] = history()) {
+    let setSubmitting: (value: boolean) => void;
+    let setEpoch: (value: number | null) => void;
+    function StateProbe() {
+      setSubmitting = useSetRecoilState(store.isSubmittingFamily(0));
+      setEpoch = useSetRecoilState(store.activeGenerationCreatedAtByConvoId(CONVO_ID));
+      return null;
+    }
+    const queryClient = new QueryClient({
+      defaultOptions: { queries: { retry: false } },
+    });
+    queryClient.setQueryData<TMessage[]>([QueryKeys.messages, CONVO_ID], initialMessages);
+    const jotaiStore = createStore();
+    const getMessages = () => queryClient.getQueryData<TMessage[]>([QueryKeys.messages, CONVO_ID]);
+    const setMessages = (messages: TMessage[]) =>
+      queryClient.setQueryData<TMessage[]>([QueryKeys.messages, CONVO_ID], messages);
+    const wrapper = ({ children }: { children: React.ReactNode }) => (
+      <QueryClientProvider client={queryClient}>
+        <RecoilRoot>
+          <JotaiProvider store={jotaiStore}>
+            <StateProbe />
+            {children}
+          </JotaiProvider>
+        </RecoilRoot>
+      </QueryClientProvider>
+    );
+    const rendered = renderHook(() => useQueuedTurnReveal(CONVO_ID), { wrapper });
+    const current = () => jotaiStore.get(revealedQueuedTurnFamily(CONVO_ID));
+    return {
+      ...rendered,
+      queryClient,
+      jotaiStore,
+      getMessages,
+      setMessages,
+      current,
+      attach: (epoch: number, submitting = true) => {
+        setEpoch(epoch);
+        setSubmitting(submitting);
+      },
+      setReceipts: (receipts: TAgentQueuedTurnReceipt[]) =>
+        queryClient.setQueryData(agentQueuedTurnsQueryKey(CONVO_ID), receipts),
+    };
+  }
+
+  it('records the queued turn as the next user turn without touching the message cache', () => {
+    const { result, getMessages, current } = setup();
+
+    act(() => {
+      result.current(
+        serverRow({ files: [{ file_id: 'f1' }], quotes: ['why'], manualSkills: ['skill'] }),
+        completedEnd(),
+      );
+    });
+
+    expect(getMessages()).toHaveLength(2);
+    expect(current()).toEqual(
+      expect.objectContaining({
+        clientRequestId: 'client-request-1',
+        parentMessageId: RESPONSE_ID,
+        queueParentMessageId: 'original-queue-parent',
+        queuePredecessorCreatedAt: 41,
+        text: 'queued follow-up',
+        files: [{ file_id: 'f1' }],
+        quotes: ['why'],
+        manualSkills: ['skill'],
+      }),
+    );
+  });
+
+  it('reveals once per boundary however often the drain re-observes it', () => {
+    const { result, current } = setup();
+
+    act(() => {
+      result.current(serverRow(), completedEnd());
+    });
+    const first = current();
+    act(() => {
+      result.current(serverRow({ text: 'a later observation' }), completedEnd());
+    });
+
+    expect(current()).toBe(first);
+  });
+
+  it('refuses a foreign conversation, a row without a request id, and a run without a response', () => {
+    const { result, current } = setup();
+
+    act(() => {
+      result.current(serverRow(), completedEnd({ conversationId: 'elsewhere' }));
+      result.current(serverRow({ clientRequestId: undefined }), completedEnd());
+      result.current(serverRow(), completedEnd({ responseMessageId: undefined }));
+    });
+
+    expect(current()).toBeNull();
+  });
+
+  it('keeps admission guarded when history already has the successor before attachment', () => {
+    const { result, current } = setup([...history(), successor()]);
+
+    act(() => {
+      result.current(serverRow(), completedEnd());
+    });
+
+    expect(current()).not.toBeNull();
+  });
+
+  it('keeps admission guarded when history receives the successor before attachment', async () => {
+    const { result, setMessages, current } = setup();
+    act(() => {
+      result.current(serverRow(), completedEnd());
+    });
+    expect(current()).not.toBeNull();
+
+    act(() => {
+      setMessages([...history(), successor('someone-elses-turn')]);
+    });
+
+    expect(current()).not.toBeNull();
+  });
+
+  it('survives a history refetch that has not yet caught up with the admitted turn', async () => {
+    const { result, setMessages, current } = setup();
+    act(() => {
+      result.current(serverRow(), completedEnd());
+    });
+
+    act(() => {
+      setMessages(history());
+    });
+    await act(async () => {
+      await new Promise((resolve) => setTimeout(resolve, 10));
+    });
+
+    expect(current()).not.toBeNull();
+  });
+
+  it('ends on a cancelled, dead, or indeterminate receipt for the revealed request', async () => {
+    const { result, setReceipts, current } = setup();
+    act(() => {
+      result.current(serverRow(), completedEnd());
+    });
+
+    act(() => {
+      setReceipts([receipt({ status: 'dead' })]);
+    });
+
+    await waitFor(() => expect(current()).toBeNull());
+  });
+
+  it('keeps the reveal through queued, claimed, and admitted receipts', async () => {
+    const { result, setReceipts, current } = setup();
+    act(() => {
+      result.current(serverRow(), completedEnd());
+    });
+
+    act(() => {
+      setReceipts([receipt({ status: 'admitted' })]);
+    });
+    await act(async () => {
+      await new Promise((resolve) => setTimeout(resolve, 10));
+    });
+
+    expect(current()).not.toBeNull();
+  });
+  it('hands the guard to a newer attached generation, never to the predecessor or a pending attach', () => {
+    const { result, attach, current } = setup();
+    act(() => {
+      result.current(serverRow(), completedEnd());
+    });
+    act(() => {
+      attach(41);
+    });
+    expect(current()).not.toBeNull();
+    act(() => {
+      attach(42, false);
+    });
+    expect(current()).not.toBeNull();
+    act(() => {
+      attach(42);
+    });
+    expect(current()).toBeNull();
+    act(() => {
+      result.current(serverRow(), completedEnd());
+    });
+    expect(current()).toBeNull();
+  });
+
+  it('settles a successor that completed inside the poll gap without trusting old inactive status', () => {
+    const { result, queryClient, current } = setup();
+    act(() => {
+      queryClient.setQueryData(streamStatusQueryKey(CONVO_ID), { active: false, createdAt: 41 });
+      result.current(serverRow(), completedEnd());
+    });
+    expect(current()).not.toBeNull();
+    act(() => {
+      queryClient.setQueryData(streamStatusQueryKey(CONVO_ID), {
+        active: false,
+        status: 'complete',
+        createdAt: 42,
+      });
+    });
+    expect(current()).toBeNull();
+    act(() => {
+      result.current(serverRow(), completedEnd());
+    });
+    expect(current()).toBeNull();
+  });
+
+  it('does not resurrect a cancelled head from a stale queue snapshot', () => {
+    const { result, setReceipts, current } = setup();
+    act(() => {
+      setReceipts([receipt({ status: 'cancelled' })]);
+    });
+    act(() => {
+      result.current(serverRow(), completedEnd());
+    });
+    expect(current()).toBeNull();
+    act(() => {
+      result.current(serverRow({ clientRequestId: 'next-request' }), completedEnd());
+    });
+    expect(current()?.clientRequestId).toBe('next-request');
+  });
+
+  it('does not register a message fetcher or replace history fetching during invalidation', async () => {
+    const { queryClient, getMessages, unmount } = setup();
+    const key = [QueryKeys.messages, CONVO_ID];
+    const fetchHistory = jest.fn(async () => [...history(), successor()]);
+    await queryClient.fetchQuery({ queryKey: key, queryFn: fetchHistory });
+    fetchHistory.mockClear();
+    await queryClient.invalidateQueries({ queryKey: key, refetchType: 'all' });
+    expect(fetchHistory).toHaveBeenCalledTimes(1);
+    expect(getMessages()).toHaveLength(3);
+    expect(queryClient.getQueryCache().find(key)?.getObserversCount()).toBe(0);
+    unmount();
+  });
+  it.each(['queued', 'claimed'] as const)(
+    'keeps the handoff through a %s sibling and its admission boundary',
+    (status) => {
+      const { result, current, queryClient, setReceipts } = setup();
+      act(() => {
+        result.current(serverRow(), completedEnd());
+        setReceipts([
+          receipt({ status: 'admitted', effectivePredecessorCreatedAt: 41 }),
+          receipt({ clientRequestId: 'second', status, expectedPredecessorCreatedAt: 41 }),
+        ]);
+        queryClient.setQueryData(streamStatusQueryKey(CONVO_ID), {
+          active: false,
+          status: 'complete',
+          createdAt: 42,
+        });
+      });
+      expect(current()).not.toBeNull();
+      act(() => {
+        setReceipts([
+          receipt({
+            clientRequestId: 'second',
+            status: 'admitted',
+            effectivePredecessorCreatedAt: 42,
+          }),
+        ]);
+      });
+      expect(current()).toMatchObject({
+        generationCreatedAt: 42,
+        queueParentMessageId: 'original-queue-parent',
+        queuePredecessorCreatedAt: 41,
+      });
+      act(() => {
+        setReceipts([]);
+      });
+      expect(current()).not.toBeNull();
+      act(() => {
+        queryClient.setQueryData(streamStatusQueryKey(CONVO_ID), {
+          active: false,
+          status: 'complete',
+          createdAt: 43,
+        });
+      });
+      expect(current()).toBeNull();
+    },
+  );
+});
diff --git a/client/src/hooks/Chat/__tests__/useSteerConvert.spec.tsx b/client/src/hooks/Chat/__tests__/useSteerConvert.spec.tsx
index b1eb60a2044..98adf2d9244 100644
--- a/client/src/hooks/Chat/__tests__/useSteerConvert.spec.tsx
+++ b/client/src/hooks/Chat/__tests__/useSteerConvert.spec.tsx
@@ -5,6 +5,8 @@ import useSteerConvert from '../useSteerConvert';
 import store from '~/store';
 
 const mockFetchStreamStatus = jest.fn();
+let mockFileMap: Record<string, { llmDeliveryPath: 'text' }> = {};
+jest.mock('~/Providers', () => ({ useFileMapContext: () => mockFileMap }));
 jest.mock('~/data-provider', () => ({
   fetchStreamStatus: (...args: unknown[]) => mockFetchStreamStatus(...args),
   getGenerationProtocolVersion: (value: unknown) =>
@@ -45,6 +47,47 @@ function setup(initialize?: (snapshot: MutableSnapshot) => void) {
 }
 
 describe('useSteerConvert', () => {
+  beforeEach(() => {
+    mockFileMap = {};
+  });
+
+  it.each([false, true])(
+    'hydrates late metadata during terminal recovery (queued origin: %s)',
+    (fromQueue) => {
+      const files = [{ file_id: 'f1', filename: 'notes.pdf' }];
+      const { result, rerender } = setup(({ set }) => {
+        set(store.pendingSteersByConvoId(CONVO_ID), [
+          {
+            steerId: 'legacy',
+            text: 'recover',
+            status: 'pending',
+            createdAt: 1,
+            files,
+            ...(fromQueue && {
+              queuedOrigin: {
+                item: { id: 'original', text: 'recover', createdAt: 1, files },
+                beforeIds: [],
+                afterIds: [],
+              },
+            }),
+          },
+        ]);
+      });
+      const retainedCallback = result.current.convert;
+      mockFileMap = { f1: { llmDeliveryPath: 'text' } };
+      rerender();
+      act(() => {
+        retainedCallback(CONVO_ID, [{ steerId: 'legacy', text: 'recover', files }]);
+      });
+      expect(result.current.queue[0].files).toEqual([{ ...files[0], llmDeliveryPath: 'text' }]);
+      expect(result.current.chips).toEqual([]);
+      act(() => {
+        retainedCallback(CONVO_ID, [{ steerId: 'legacy', text: 'recover', files }]);
+      });
+      expect(result.current.queue).toHaveLength(1);
+    },
+  );
+
   it('converts leftover steers to queued chips and drops their pending chips', () => {
     const { result } = setup(({ set }) => {
       set(store.pendingSteersByConvoId(CONVO_ID), [
diff --git a/client/src/hooks/Chat/__tests__/useSteering.spec.tsx b/client/src/hooks/Chat/__tests__/useSteering.spec.tsx
index 5ad9353f15d..2e62cbe58dd 100644
--- a/client/src/hooks/Chat/__tests__/useSteering.spec.tsx
+++ b/client/src/hooks/Chat/__tests__/useSteering.spec.tsx
@@ -1,11 +1,14 @@
 import React from 'react';
+import { getDefaultStore } from 'jotai';
 import { act, renderHook, waitFor } from '@testing-library/react';
 import { RecoilRoot, useRecoilValue, useSetRecoilState, type MutableSnapshot } from 'recoil';
 import { Constants, ContentTypes, EModelEndpoint, LocalStorageKeys } from 'librechat-data-provider';
-import type { TConversation, TMessage } from 'librechat-data-provider';
+import type { TConversation, TFile, TMessage } from 'librechat-data-provider';
 import type { QueuedMessage } from '~/store/families';
+import { clearAllDrafts, getPendingDraftId, getNewConversationDraftId } from '~/utils';
+import useSteering, { mergeQueuedTurnFileMetadata } from '../useSteering';
+import { revealedQueuedTurnFamily } from '~/store/steer';
 import useQueueDrain from '../useQueueDrain';
-import useSteering from '../useSteering';
 import store from '~/store';
 
 const CONVO_ID = 'convo-steer-ui';
@@ -20,8 +23,13 @@ const mockMarkUsage = jest.fn();
 let mockMessages: TMessage[] | undefined;
 let mockLatestMessage: TMessage | null | undefined;
 let mockServerQueuedTurns: unknown[] | undefined;
+let mockFileMap: Record<string, Pick<TFile, 'llmDeliveryPath'>> = {};
 const mockUseAgentQueuedTurns = jest.fn((..._args: unknown[]) => ({ data: mockServerQueuedTurns }));
 
+jest.mock('~/Providers', () => ({
+  useFileMapContext: () => mockFileMap,
+}));
+
 jest.mock('~/data-provider', () => ({
   useCancelSteerMutation: () => ({ mutateAsync: mockCancelSteer }),
   useSteerMessageMutation: () => ({ mutate: mockMutate }),
@@ -104,6 +112,14 @@ function setup(params: HookParams = {}, initialize?: (snapshot: MutableSnapshot)
   const rendered = renderHook(
     () =>
       useSteering({
+        consumeDraft: () => {
+          const id = params.conversationId ?? CONVO_ID;
+          const conversationDraftId =
+            id === Constants.NEW_CONVO ? getNewConversationDraftId(0) : id;
+          clearAllDrafts(
+            params.isSubmitting === false ? conversationDraftId : getPendingDraftId(0),
+          );
+        },
         index: 0,
         conversationId: CONVO_ID,
         conversation: agentsConversation,
@@ -130,9 +146,55 @@ function useQueue(convoId: string) {
 describe('useSteering', () => {
   beforeEach(() => {
     jest.clearAllMocks();
+    getDefaultStore().set(revealedQueuedTurnFamily(CONVO_ID), null);
     mockMessages = undefined;
     mockLatestMessage = undefined;
     mockServerQueuedTurns = undefined;
+    mockFileMap = {};
+  });
+
+  it('keeps optimistic delivery metadata when a legacy receipt omits it', () => {
+    expect(
+      mergeQueuedTurnFileMetadata(
+        [{ file_id: 'stored-doc', filename: 'report.pdf', type: 'application/pdf' }],
+        [
+          {
+            file_id: 'stored-doc',
+            filename: 'report.pdf',
+            type: 'application/pdf',
+            llmDeliveryPath: 'text',
+          },
+        ],
+      ),
+    ).toEqual([
+      {
+        file_id: 'stored-doc',
+        filename: 'report.pdf',
+        type: 'application/pdf',
+        llmDeliveryPath: 'text',
+      },
+    ]);
+  });
+
+  it('hydrates legacy receipt delivery metadata from the stored file map', () => {
+    expect(
+      mergeQueuedTurnFileMetadata(
+        [{ file_id: 'stored-doc', filename: 'report.pdf', type: 'application/pdf' }],
+        undefined,
+        {
+          'stored-doc': {
+            llmDeliveryPath: 'text',
+          },
+        },
+      ),
+    ).toEqual([
+      {
+        file_id: 'stored-doc',
+        filename: 'report.pdf',
+        type: 'application/pdf',
+        llmDeliveryPath: 'text',
+      },
+    ]);
   });
 
   describe('effectiveAction', () => {
@@ -252,6 +314,7 @@ describe('useSteering', () => {
       const rendered = renderHook(
         () => ({
           steering: useSteering({
+            consumeDraft: jest.fn(),
             index: 0,
             conversationId: CONVO_ID,
             conversation: agentsConversation,
@@ -298,6 +361,70 @@ describe('useSteering', () => {
       expect(result.current.queue[0].server).toBeUndefined();
     });
 
+    it('persists another follow-up against the original queue lineage after its completion boundary advances', async () => {
+      const family = revealedQueuedTurnFamily(CONVO_ID);
+      getDefaultStore().set(family, {
+        clientRequestId: 'pending-first',
+        parentMessageId: 'completed-response',
+        generationCreatedAt: 42,
+        queueParentMessageId: 'original-queue-parent',
+        queuePredecessorCreatedAt: 41,
+        text: 'first',
+        revealedAt: new Date().toISOString(),
+      });
+      mockEnqueueQueuedTurn.mockImplementation((input, options) => {
+        options.onSuccess({
+          ...input,
+          queuedTurnId: 'durable-second',
+          status: 'queued',
+          revision: 1,
+          createdAt: new Date().toISOString(),
+          updatedAt: new Date().toISOString(),
+        });
+      });
+      const { result, unmount } = setup({ isSubmitting: false }, ({ set }) => {
+        set(store.activeGenerationCreatedAtByConvoId(CONVO_ID), null);
+        set(store.pendingQuotesByConvoId(CONVO_ID), ['quoted context']);
+        set(store.pendingManualSkillsByConvoId(CONVO_ID), ['skill']);
+      });
+      expect(result.current.duringRunActive).toBe(true);
+      expect(result.current.canSteer).toBe(false);
+      await act(async () => {
+        expect(result.current.submitDuringRun('second')).toBe(true);
+      });
+      expect(mockEnqueueQueuedTurn).toHaveBeenCalledWith(
+        expect.objectContaining({
+          parentMessageId: 'original-queue-parent',
+          expectedPredecessorCreatedAt: 41,
+          text: 'second',
+          quotes: ['quoted context'],
+          manualSkills: ['skill'],
+        }),
+        expect.any(Object),
+      );
+      unmount();
+      getDefaultStore().set(family, null);
+      mockServerQueuedTurns = [
+        {
+          ...mockEnqueueQueuedTurn.mock.calls[0][0],
+          queuedTurnId: 'durable-second',
+          status: 'queued',
+          revision: 1,
+          createdAt: new Date().toISOString(),
+          updatedAt: new Date().toISOString(),
+        },
+      ];
+      const restored = setupServerQueue();
+      await waitFor(() =>
+        expect(restored.result.current.queue[0]).toMatchObject({
+          text: 'second',
+          quotes: ['quoted context'],
+          manualSkills: ['skill'],
+          server: { id: 'durable-second', status: 'queued' },
+        }),
+      );
+    });
+
     it('enrolls one optimistic row with a stable request and visible branch identity', async () => {
       mockEnqueueQueuedTurn.mockImplementation((input, options) => {
         options.onSuccess({
@@ -854,6 +981,7 @@ describe('useSteering', () => {
         true,
         [clientRequestId],
         uncertainSince! + 60_000,
+        true,
       );
     });
 
@@ -881,6 +1009,15 @@ describe('useSteering', () => {
         expect(result.current.queue[0]).toMatchObject({
           server: { status: 'uncertain', reconciliationExpired: true },
         });
+        /** Held for manual recovery only: the projection owes it nothing more,
+         *  so the poll no longer stays alive on its account. */
+        expect(mockUseAgentQueuedTurns).toHaveBeenLastCalledWith(
+          CONVO_ID,
+          true,
+          [result.current.queue[0].clientRequestId],
+          expect.any(Number),
+          false,
+        );
       } finally {
         jest.useRealTimers();
       }
@@ -914,6 +1051,11 @@ describe('useSteering', () => {
     });
 
     it('projects the authoritative server snapshot into Recoil', async () => {
+      mockFileMap = {
+        'stored-doc': {
+          llmDeliveryPath: 'text',
+        },
+      };
       mockServerQueuedTurns = [
         {
           queuedTurnId: 'server-snapshot-1',
@@ -921,6 +1063,7 @@ describe('useSteering', () => {
           conversationId: CONVO_ID,
           parentMessageId: 'visible-assistant-tail',
           text: 'restored after reload',
+          files: [{ file_id: 'stored-doc', filename: 'report.pdf', type: 'application/pdf' }],
           status: 'queued',
           revision: 3,
           createdAt: new Date(200).toISOString(),
@@ -933,6 +1076,14 @@ describe('useSteering', () => {
       expect(rendered.result.current.queue[0]).toMatchObject({
         id: 'client-snapshot-1',
         text: 'restored after reload',
+        files: [
+          {
+            file_id: 'stored-doc',
+            filename: 'report.pdf',
+            type: 'application/pdf',
+            llmDeliveryPath: 'text',
+          },
+        ],
         server: { id: 'server-snapshot-1', status: 'queued', revision: 3 },
       });
     });
@@ -1033,6 +1184,7 @@ describe('useSteering', () => {
       const { result } = renderHook(
         () => {
           useSteering({
+            consumeDraft: jest.fn(),
             index: 0,
             conversationId: CONVO_ID,
             conversation: agentsConversation,
@@ -1237,6 +1389,7 @@ describe('useSteering', () => {
       const rendered = renderHook(
         () => ({
           steering: useSteering({
+            consumeDraft: jest.fn(),
             index: 0,
             conversationId: CONVO_ID,
             conversation: agentsConversation,
@@ -1416,6 +1569,7 @@ describe('useSteering', () => {
       const rendered = renderHook(
         ({ convoId, isSubmitting }: { convoId: string; isSubmitting: boolean }) => ({
           steering: useSteering({
+            consumeDraft: jest.fn(),
             index: 0,
             conversationId: convoId,
             conversation: agentsConversation,
@@ -1992,6 +2146,7 @@ describe('useSteering', () => {
       const { result, rerender } = renderHook(
         ({ conversationId }: { conversationId: string }) =>
           useSteering({
+            consumeDraft: jest.fn(),
             index: 0,
             conversationId,
             conversation: {
@@ -2052,6 +2207,7 @@ describe('useSteering', () => {
       const rendered = renderHook(
         () => ({
           steering: useSteering({
+            consumeDraft: jest.fn(),
             index: 0,
             conversationId: CONVO_ID,
             conversation: agentsConversation,
@@ -3013,6 +3169,7 @@ describe('useSteering', () => {
       const rendered = renderHook(
         () => ({
           steering: useSteering({
+            consumeDraft: jest.fn(),
             index: 0,
             conversationId: CONVO_ID,
             conversation: agentsConversation,
@@ -3215,6 +3372,7 @@ describe('useSteering', () => {
       const rendered = renderHook(
         () => ({
           steering: useSteering({
+            consumeDraft: jest.fn(),
             index: 0,
             conversationId: CONVO_ID,
             conversation: agentsConversation,
@@ -3775,6 +3933,45 @@ describe('useSteering', () => {
       expect(localStorage.getItem(pendingDraftKey)).toBeNull();
     });
 
+    it.each([false, true])(
+      'consumes the conversation draft only after a handoff submission is accepted (blocked=%s)',
+      async (filesLoading) => {
+        const key = `${LocalStorageKeys.TEXT_DRAFT}${CONVO_ID}`;
+        const unrelatedKey = `${LocalStorageKeys.TEXT_DRAFT}another-conversation`;
+        localStorage.setItem(key, 'ZHJhZnRlZCB0ZXh0');
+        localStorage.setItem(unrelatedKey, 'other draft');
+        getDefaultStore().set(revealedQueuedTurnFamily(CONVO_ID), {
+          clientRequestId: 'pending',
+          parentMessageId: 'response',
+          generationCreatedAt: 41,
+          text: 'pending',
+          revealedAt: new Date().toISOString(),
+        });
+        const { result, unmount } = setup({ isSubmitting: false, filesLoading }, ({ set }) => {
+          set(store.activeGenerationCreatedAtByConvoId(CONVO_ID), null);
+        });
+        await act(async () => {
+          expect(result.current.submitDuringRun('drafted text')).toBe(!filesLoading);
+        });
+        expect(localStorage.getItem(key)).toBe(filesLoading ? 'ZHJhZnRlZCB0ZXh0' : null);
+        expect(localStorage.getItem(unrelatedKey)).toBe('other draft');
+        unmount();
+        getDefaultStore().set(revealedQueuedTurnFamily(CONVO_ID), null);
+      },
+    );
+
+    it.each([false, true])(
+      'delegates draft consumption to its owner only on acceptance (blocked=%s)',
+      (filesLoading) => {
+        const consumeDraft = jest.fn();
+        const { result } = setup({ filesLoading, consumeDraft });
+        act(() => {
+          expect(result.current.queueFromComposer('drafted text')).toBe(!filesLoading);
+        });
+        expect(consumeDraft).toHaveBeenCalledTimes(filesLoading ? 0 : 1);
+      },
+    );
+
     it('drops the pending draft when steering from the composer', () => {
       stageDraft();
       const { result } = setup();
diff --git a/client/src/hooks/Chat/index.ts b/client/src/hooks/Chat/index.ts
index 9da73b17499..589a942252c 100644
--- a/client/src/hooks/Chat/index.ts
+++ b/client/src/hooks/Chat/index.ts
@@ -11,6 +11,7 @@ export { default as useGetAddedConvo } from './useGetAddedConvo';
 export { default as useIdChangeEffect } from './useIdChangeEffect';
 export { default as useFocusChatEffect } from './useFocusChatEffect';
 export { default as useQueueDrain } from './useQueueDrain';
+export { default as useQueuedTurnReveal } from './useQueuedTurnReveal';
 export { default as useSteering } from './useSteering';
 export { default as useSteerCancel, useSteerReclaim } from './useSteerCancel';
 export { default as useSteerConvert } from './useSteerConvert';
diff --git a/client/src/hooks/Chat/useChatFunctions.ts b/client/src/hooks/Chat/useChatFunctions.ts
index d1e8ab1499f..d3b370da95b 100644
--- a/client/src/hooks/Chat/useChatFunctions.ts
+++ b/client/src/hooks/Chat/useChatFunctions.ts
@@ -1,4 +1,5 @@
 import { v4 } from 'uuid';
+import { useStore } from 'jotai';
 import { cloneDeep } from 'lodash';
 import { useNavigate } from 'react-router-dom';
 import { useQueryClient } from '@tanstack/react-query';
@@ -42,6 +43,7 @@ import useCodeApprovalMode from '~/hooks/Agents/useCodeApprovalMode';
 import useSetFilesToDelete from '~/hooks/Files/useSetFilesToDelete';
 import useCodeWorkspace from '~/hooks/Agents/useCodeWorkspace';
 import useGetSender from '~/hooks/Conversations/useGetSender';
+import { revealedQueuedTurnFamily } from '~/store/steer';
 import store, { useGetEphemeralAgent } from '~/store';
 import { startupConfigKey } from '~/data-provider';
 import useUserKey from '~/hooks/Input/useUserKey';
@@ -227,6 +229,7 @@ export default function useChatFunctions({
   const setSubmissionStart = useSetRecoilState(store.submissionStartFamily(index));
   const setShowStopButton = useSetRecoilState(store.showStopButtonByIndex(index));
   const focusRegeneratedResponse = useFocusRegeneratedResponse();
+  const jotaiStore = useStore();
   const getConversation = useGetConversation(index);
   const addedConversation = useRecoilValue(store.conversationByKeySelector(1));
   const { modes: codeApprovalModes, selected: fallbackCodeApprovalMode } = useCodeApprovalMode(
@@ -320,6 +323,8 @@ export default function useChatFunctions({
     const regenerateShaped = isRegenerate || compact;
     if (
       !!isSubmitting ||
+      jotaiStore.get(revealedQueuedTurnFamily(immutableConversation?.conversationId ?? '')) !=
+        null ||
       (!regenerateShaped && !isSubmittableMessage(text, (files?.size ?? 0) + replayFileCount))
     ) {
       return false;
@@ -611,6 +616,7 @@ export default function useChatFunctions({
         filepath: file.filepath,
         filename: file.filename,
         type: file.type ?? '', // Ensure type is not undefined
+        llmDeliveryPath: file.llmDeliveryPath,
         height: file.height,
         width: file.width,
       }));
@@ -740,6 +746,7 @@ export default function useChatFunctions({
       conversation: {
         ...conversation,
         ...(chatProjectId ? { chatProjectId } : {}),
+        ...(latestCodeApprovalMode != null ? { codeApprovalMode: latestCodeApprovalMode } : {}),
         conversationId,
       },
       endpointOption,
diff --git a/client/src/hooks/Chat/useQueueDrain.ts b/client/src/hooks/Chat/useQueueDrain.ts
index 7039adc21d7..b0e4c21fa55 100644
--- a/client/src/hooks/Chat/useQueueDrain.ts
+++ b/client/src/hooks/Chat/useQueueDrain.ts
@@ -1,9 +1,12 @@
 import { useEffect, useMemo } from 'react';
+import { useAtomValue } from 'jotai';
 import { Constants } from 'librechat-data-provider';
 import { useRecoilValue, useRecoilCallback } from 'recoil';
 import type { DrainAfterAbort, QueuedMessage, QueuedMessageOrigin, RunEnd } from '~/store/families';
 import type { TAskFunction } from '~/common';
+import { selectQueuedTurnReveal } from '~/hooks/Chat/useQueuedTurnReveal';
 import { useMarkFilesUsageMutation } from '~/data-provider';
+import { revealedQueuedTurnFamily } from '~/store/steer';
 import store from '~/store';
 
 /** Mirrors the server's per-request cap on a usage touch. */
@@ -75,6 +78,7 @@ export default function useQueueDrain(
   index: string | number,
   activeConversationId: string | undefined,
   ask: TAskFunction,
+  revealQueuedTurn?: (item: QueuedMessage, end: RunEnd) => void,
 ) {
   const runEnd = useRecoilValue(store.runEndByIndex(index));
   const parkedRunEnd = useRecoilValue(
@@ -97,6 +101,20 @@ export default function useQueueDrain(
     store.settledQueuedTurnReceiptsByConvoId(activeConversationId ?? Constants.NEW_CONVO),
   );
   const hasServerOwnedQueue = [...ownQueue, ...newConvoQueue].some((item) => item.server != null);
+  /** The row the reveal would pick, and whether one is already revealed: a
+   *  revealed head that is cancelled or dies before admission leaves the
+   *  server-owned queue non-empty and its terminal evidence out of the
+   *  settled receipts, so nothing above re-runs the effect for the row the
+   *  backend moves on to. */
+  const revealedQueuedTurn = useAtomValue(
+    revealedQueuedTurnFamily(activeConversationId ?? Constants.NEW_CONVO),
+  );
+  const admissibleHeadId =
+    [...ownQueue, ...newConvoQueue].find(
+      (item) =>
+        item.server?.id != null &&
+        (item.server.status === 'queued' || item.server.status === 'claimed'),
+    )?.id ?? null;
 
   /* Deduped because the two subscriptions are the same atom before migration.
    * Keyed by id list so the effect re-runs when the held set changes, not
@@ -172,12 +190,16 @@ export default function useQueueDrain(
   // awaits may interleave with the reads.
   const drainNext = useRecoilCallback(
     ({ snapshot, set }) =>
-      (): {
-        next: QueuedMessage;
-        conversationId: string;
-        queuedMessageOrigin: QueuedMessageOrigin;
-        expectedPredecessorCreatedAt?: number;
-      } | null => {
+      ():
+        | {
+            kind: 'drain';
+            next: QueuedMessage;
+            conversationId: string;
+            queuedMessageOrigin: QueuedMessageOrigin;
+            expectedPredecessorCreatedAt?: number;
+          }
+        | { kind: 'reveal'; item: QueuedMessage; end: RunEnd }
+        | null => {
         let end = snapshot.getLoadable(store.runEndByIndex(index)).getValue();
         let fromParked = false;
         if (
@@ -305,8 +327,11 @@ export default function useQueueDrain(
           /** Keep the one-shot terminal signal until the authoritative snapshot
            * removes the server row. If it was admitted, its own later terminal
            * signal orders the remaining local queue; if it was cancelled/dead,
-           * this signal still lets the legacy successor make progress. */
-          return null;
+           * this signal still lets the legacy successor make progress. The
+           * head the server is about to admit can already be shown as the
+           * next user turn; the signal itself stays untouched. */
+          const reveal = selectQueuedTurnReveal(end, merged);
+          return reveal == null ? null : { kind: 'reveal', item: reveal, end };
         }
 
         // Consume only after server authority has yielded the boundary — a
@@ -324,6 +349,7 @@ export default function useQueueDrain(
         }
         return next
           ? {
+              kind: 'drain',
               next,
               conversationId,
               queuedMessageOrigin: {
@@ -365,6 +391,10 @@ export default function useQueueDrain(
     if (drained == null) {
       return;
     }
+    if (drained.kind === 'reveal') {
+      revealQueuedTurn?.(drained.item, drained.end);
+      return;
+    }
     const { next, conversationId, queuedMessageOrigin, expectedPredecessorCreatedAt } = drained;
     // The queued item is the FULL submission context: explicit (possibly
     // empty) overrides stop `ask` from vacuuming up files, quotes, or skill
@@ -414,6 +444,9 @@ export default function useQueueDrain(
     markFilesUsage,
     hasServerOwnedQueue,
     settledQueuedTurnReceipts,
+    revealedQueuedTurn,
+    admissibleHeadId,
+    revealQueuedTurn,
     ask,
   ]);
 }
diff --git a/client/src/hooks/Chat/useQueuedTurnReveal.ts b/client/src/hooks/Chat/useQueuedTurnReveal.ts
new file mode 100644
index 00000000000..31e686fc4f6
--- /dev/null
+++ b/client/src/hooks/Chat/useQueuedTurnReveal.ts
@@ -0,0 +1,209 @@
+import { useCallback, useEffect, useSyncExternalStore } from 'react';
+import { useRecoilValue } from 'recoil';
+import { useStore, useAtomValue } from 'jotai';
+import { QueryKeys } from 'librechat-data-provider';
+import { useQueryClient } from '@tanstack/react-query';
+import type { TMessage, TAgentQueuedTurnReceipt } from 'librechat-data-provider';
+import type { StreamStatusResponse } from '~/data-provider/SSE/queries';
+import type { QueuedMessage, RunEnd } from '~/store/families';
+import type { RevealedQueuedTurn } from '~/store/steer';
+import { agentQueuedTurnsQueryKey } from '~/data-provider/SSE/queuedTurns';
+import { streamStatusQueryKey } from '~/data-provider/SSE/queries';
+import { revealedQueuedTurnFamily } from '~/store/steer';
+import store from '~/store';
+
+const isAdmissible = (item: QueuedMessage): boolean =>
+  item.server?.id != null &&
+  item.clientRequestId != null &&
+  (item.server.status === 'queued' || item.server.status === 'claimed');
+
+/**
+ * The server-owned row the backend will admit behind a run that just
+ * completed cleanly: the first durably enqueued row that has not settled.
+ * Rows ahead of it never stand in for the successor: a local row cannot
+ * drain while the server owns the boundary, and a rejected or still-sending
+ * server row is not what the backend will admit. A Stop or an error leaves
+ * every chip in place.
+ */
+export const selectQueuedTurnReveal = (
+  end: RunEnd,
+  queue: QueuedMessage[],
+): QueuedMessage | null => {
+  if (
+    end.outcome !== 'completed' ||
+    end.responseMessageId == null ||
+    end.generationCreatedAt == null
+  ) {
+    return null;
+  }
+  return queue.find(isAdmissible) ?? null;
+};
+
+/** The thread has moved past the response the reveal follows: the admitted
+ *  turn, or any other turn, now parents on it. */
+export const hasRevealSuccessor = (messages: TMessage[], reveal: RevealedQueuedTurn): boolean =>
+  messages.some((message) => message.parentMessageId === reveal.parentMessageId);
+
+/** Authoritative evidence that the revealed turn will not run as shown. */
+export const shouldRollbackReveal = (
+  receipts: TAgentQueuedTurnReceipt[],
+  reveal: RevealedQueuedTurn,
+): boolean =>
+  receipts.some(
+    (receipt) =>
+      receipt.clientRequestId === reveal.clientRequestId &&
+      (receipt.status === 'cancelled' ||
+        receipt.status === 'dead' ||
+        receipt.failure?.code === 'ADMISSION_INDETERMINATE'),
+  );
+
+/** A render-only message for the revealed row: it feeds the same row
+ *  primitives a persisted user turn uses and is never written to the cache. */
+export const buildRevealedMessage = (
+  reveal: RevealedQueuedTurn,
+  conversationId: string,
+): TMessage =>
+  ({
+    messageId: `revealed-${reveal.clientRequestId}`,
+    parentMessageId: reveal.parentMessageId,
+    conversationId,
+    text: reveal.text,
+    sender: 'User',
+    isCreatedByUser: true,
+    error: false,
+    clientTimestamp: reveal.revealedAt,
+    ...(reveal.files != null && reveal.files.length > 0 && { files: reveal.files }),
+    ...(reveal.quotes != null && reveal.quotes.length > 0 && { quotes: reveal.quotes }),
+    ...(reveal.manualSkills != null &&
+      reveal.manualSkills.length > 0 && { manualSkills: reveal.manualSkills }),
+  }) as TMessage;
+
+/** Presentation and admission have separate lifetimes: history replaces the
+ * drawn row, but sends stay queued until the successor attaches or terminates.
+ * Observe existing caches without registering a competing query function. */
+export default function useQueuedTurnReveal(
+  conversationId: string | undefined,
+  index: string | number = 0,
+): (item: QueuedMessage, end: RunEnd) => void {
+  const jotaiStore = useStore();
+  const queryClient = useQueryClient();
+  const revealKey = conversationId ?? '';
+  const reveal = useAtomValue(revealedQueuedTurnFamily(revealKey));
+  const isSubmitting = useRecoilValue(store.isSubmittingFamily(index));
+  const activeEpoch = useRecoilValue(store.activeGenerationCreatedAtByConvoId(revealKey));
+  const readHandoff = useCallback(
+    (intent: RevealedQueuedTurn) => {
+      const receipts = queryClient.getQueryData<TAgentQueuedTurnReceipt[]>(
+        agentQueuedTurnsQueryKey(revealKey),
+      );
+      const status = queryClient.getQueryData<StreamStatusResponse>(
+        streamStatusQueryKey(revealKey),
+      );
+      let generationCreatedAt = intent.generationCreatedAt;
+      let waiting = false;
+      for (const receipt of receipts ?? []) {
+        const actionable =
+          (receipt.status === 'queued' || receipt.status === 'claimed') &&
+          receipt.failure?.code !== 'ADMISSION_INDETERMINATE';
+        waiting ||= actionable;
+        if (!actionable && receipt.status !== 'admitted') {
+          continue;
+        }
+        const boundary =
+          receipt.effectivePredecessorCreatedAt ?? receipt.expectedPredecessorCreatedAt;
+        if (boundary != null && (generationCreatedAt == null || boundary > generationCreatedAt)) {
+          generationCreatedAt = boundary;
+        }
+      }
+      return {
+        generationCreatedAt,
+        settled:
+          (receipts != null && shouldRollbackReveal(receipts, intent)) ||
+          (generationCreatedAt != null &&
+            ((isSubmitting && activeEpoch != null && activeEpoch > generationCreatedAt) ||
+              (!waiting &&
+                status?.active === false &&
+                (status.status === 'complete' ||
+                  status.status === 'error' ||
+                  status.status === 'aborted') &&
+                status.createdAt != null &&
+                status.createdAt > generationCreatedAt))),
+      };
+    },
+    [queryClient, revealKey, isSubmitting, activeEpoch],
+  );
+  const subscribe = useCallback(
+    (notify: () => void) =>
+      queryClient.getQueryCache().subscribe((event) => {
+        const key = event?.query.queryKey;
+        if (
+          key?.[1] === revealKey &&
+          (key[0] === QueryKeys.agentQueuedTurns || key[0] === 'streamStatus')
+        ) {
+          notify();
+        }
+      }),
+    [queryClient, revealKey],
+  );
+  /** Only ownership facts trigger a render, not every receipt poll. Remember
+   * an admitted successor's effective boundary even after its receipt leaves
+   * the projection, so an earlier terminal cannot release a later handoff. */
+  const getSnapshot = useCallback(() => {
+    if (reveal == null) return '';
+    const handoff = readHandoff(reveal);
+    return `${handoff.generationCreatedAt ?? ''}:${handoff.settled}`;
+  }, [reveal, readHandoff]);
+  const handoffVersion = useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
+
+  const revealQueuedTurn = useCallback(
+    (item: QueuedMessage, end: RunEnd) => {
+      const target = end.conversationId;
+      if (
+        target == null ||
+        target !== conversationId ||
+        end.outcome !== 'completed' ||
+        end.responseMessageId == null ||
+        end.generationCreatedAt == null ||
+        item.clientRequestId == null ||
+        !isAdmissible(item)
+      ) {
+        return;
+      }
+      const family = revealedQueuedTurnFamily(target);
+      if (jotaiStore.get(family) != null) {
+        return;
+      }
+      const intent: RevealedQueuedTurn = {
+        clientRequestId: item.clientRequestId,
+        parentMessageId: end.responseMessageId,
+        generationCreatedAt: end.generationCreatedAt,
+        queueParentMessageId: item.parentMessageId,
+        queuePredecessorCreatedAt: item.expectedPredecessorCreatedAt,
+        text: item.text,
+        ...(item.files != null && item.files.length > 0 && { files: item.files }),
+        ...(item.quotes != null && item.quotes.length > 0 && { quotes: item.quotes }),
+        ...(item.manualSkills != null &&
+          item.manualSkills.length > 0 && { manualSkills: item.manualSkills }),
+        revealedAt: new Date().toISOString(),
+      };
+      const handoff = readHandoff(intent);
+      if (!handoff.settled) {
+        jotaiStore.set(family, { ...intent, generationCreatedAt: handoff.generationCreatedAt });
+      }
+    },
+    [conversationId, readHandoff, jotaiStore],
+  );
+
+  useEffect(() => {
+    const family = revealedQueuedTurnFamily(revealKey);
+    if (reveal == null || jotaiStore.get(family) !== reveal) return;
+    const handoff = readHandoff(reveal);
+    if (handoff.settled) {
+      jotaiStore.set(family, null);
+    } else if (handoff.generationCreatedAt !== reveal.generationCreatedAt) {
+      jotaiStore.set(family, { ...reveal, generationCreatedAt: handoff.generationCreatedAt });
+    }
+  }, [jotaiStore, revealKey, reveal, readHandoff, handoffVersion]);
+
+  return revealQueuedTurn;
+}
diff --git a/client/src/hooks/Chat/useSteerConvert.ts b/client/src/hooks/Chat/useSteerConvert.ts
index df6ecc22b5f..2cc711f2235 100644
--- a/client/src/hooks/Chat/useSteerConvert.ts
+++ b/client/src/hooks/Chat/useSteerConvert.ts
@@ -1,12 +1,18 @@
-import { useCallback } from 'react';
+import { useCallback, useRef } from 'react';
 import { v4 } from 'uuid';
 import { useRecoilCallback } from 'recoil';
 import type { TPendingSteer } from 'librechat-data-provider';
 import type { QueuedMessage, QueuedMessageOrigin } from '~/store/families';
 import type { GenerationProtocolVersion } from '~/data-provider';
 import type { SteerCarriedContext } from '~/utils';
-import { appendAppliedSteerIds, carriedSteerContext, insertQueuedOrigin } from '~/utils';
+import {
+  appendAppliedSteerIds,
+  carriedSteerContext,
+  insertQueuedOrigin,
+  hydrateFileDeliveryMetadata,
+} from '~/utils';
 import { fetchStreamStatus, getGenerationProtocolVersion } from '~/data-provider';
+import { useFileMapContext } from '~/Providers';
 import store from '~/store';
 
 /** A server-reported steer, or a local one that carries its own client-only
@@ -47,6 +53,9 @@ interface SteerConvertOptions {
  * server-side removal.
  */
 export default function useSteerConvert() {
+  const fileMap = useFileMapContext();
+  const fileMapRef = useRef(fileMap);
+  fileMapRef.current = fileMap;
   const convert = useRecoilCallback(
     ({ snapshot, set }) =>
       (
@@ -129,6 +138,11 @@ export default function useSteerConvert() {
               const local = localChipFor(steer);
               const source = local ?? steer;
               const queuedOrigin = source.queuedOrigin;
+              const files = hydrateFileDeliveryMetadata(
+                queuedOrigin?.item.files ?? steer.files,
+                local?.files,
+                fileMapRef.current,
+              );
               const recoveryFields = bindRecoverySource
                 ? {
                     // One UUID is stable for this queued attempt and all of
@@ -142,13 +156,13 @@ export default function useSteerConvert() {
                 : {};
               const item =
                 queuedOrigin != null
-                  ? { ...queuedOrigin.item, ...recoveryFields }
+                  ? { ...queuedOrigin.item, ...recoveryFields, ...(files && { files }) }
                   : ({
                       id: steer.steerId,
                       text: steer.text,
                       createdAt: steer.createdAt ?? Date.now(),
                       ...recoveryFields,
-                      ...(steer.files && steer.files.length > 0 && { files: steer.files }),
+                      ...(files && files.length > 0 && { files }),
                       // The chip is the usual source, but a reclaimed steer may
                       // have lost its chip to a competing cancel mid-round-trip.
                       ...carriedSteerContext(source),
diff --git a/client/src/hooks/Chat/useSteering.ts b/client/src/hooks/Chat/useSteering.ts
index 9701d4d132a..02867fcb73c 100644
--- a/client/src/hooks/Chat/useSteering.ts
+++ b/client/src/hooks/Chat/useSteering.ts
@@ -1,5 +1,6 @@
 import { useCallback, useEffect, useMemo, useRef } from 'react';
 import { v4 } from 'uuid';
+import { useAtomValue, useStore } from 'jotai';
 import { useToastContext } from '@librechat/client';
 import { useRecoilValue, useSetRecoilState, useRecoilCallback } from 'recoil';
 import {
@@ -37,14 +38,15 @@ import {
 import {
   appendAppliedSteerIds,
   carriedSteerContext,
-  clearAllDrafts,
-  getPendingDraftId,
   insertQueuedOrigin,
+  hydrateFileDeliveryMetadata,
   mergeRestagedQuotes,
 } from '~/utils';
 import useSteerConvert from '~/hooks/Chat/useSteerConvert';
+import { revealedQueuedTurnFamily } from '~/store/steer';
 import { useLatestMessage } from '~/hooks/Messages';
 import { useSetFilesToDelete } from '~/hooks/Files';
+import { useFileMapContext } from '~/Providers';
 import useLocalize from '~/hooks/useLocalize';
 import store from '~/store';
 
@@ -259,6 +261,7 @@ function toQueuedTurnFileRefs(files: TMessage['files']): TAgentQueuedTurnFileRef
         ...(file.type != null && { type: file.type }),
         ...(file.filepath != null && { filepath: file.filepath }),
         ...(file.filename != null && { filename: file.filename }),
+        ...(file.llmDeliveryPath != null && { llmDeliveryPath: file.llmDeliveryPath }),
         ...(file.height != null && { height: file.height }),
         ...(file.width != null && { width: file.width }),
         ...(file.bytes != null && { bytes: file.bytes }),
@@ -268,11 +271,14 @@ function toQueuedTurnFileRefs(files: TMessage['files']): TAgentQueuedTurnFileRef
   return refs.length > 0 ? refs : undefined;
 }
 
+export { hydrateFileDeliveryMetadata as mergeQueuedTurnFileMetadata } from '~/utils/files';
+
 function reconcileServerQueuedTurns(
   previous: QueuedMessage[],
   receipts: AgentQueuedTurnReceipt[],
   settledByRequestId: ReadonlyMap<string, SettledQueuedTurnReceipt>,
   authoritativeSnapshot = true,
+  storedFiles?: Parameters<typeof hydrateFileDeliveryMetadata>[2],
 ): QueuedMessage[] {
   const previousByClientRequestId = new Map(
     previous.flatMap((item) =>
@@ -305,6 +311,7 @@ function reconcileServerQueuedTurns(
     } else if (receipt.status === 'queued' || receipt.status === 'claimed') {
       status = receipt.status;
     }
+    const files = hydrateFileDeliveryMetadata(receipt.files, optimistic?.files, storedFiles);
     return [
       {
         id: optimistic?.id ?? receipt.clientRequestId,
@@ -315,7 +322,7 @@ function reconcileServerQueuedTurns(
         ...(receipt.expectedPredecessorCreatedAt != null && {
           expectedPredecessorCreatedAt: receipt.expectedPredecessorCreatedAt,
         }),
-        ...(receipt.files != null && receipt.files.length > 0 && { files: receipt.files }),
+        ...(files != null && files.length > 0 && { files }),
         ...(receipt.quotes != null && receipt.quotes.length > 0 && { quotes: receipt.quotes }),
         ...(receipt.manualSkills != null &&
           receipt.manualSkills.length > 0 && {
@@ -365,6 +372,8 @@ function reconcileServerQueuedTurns(
 }
 
 export interface UseSteeringParams {
+  /** Consume the actual storage key selected by the composer’s autosave owner. */
+  consumeDraft: () => void;
   index: number;
   conversationId: string;
   conversation: TConversation | null;
@@ -398,6 +407,7 @@ export interface UseSteeringParams {
  * (abort, then auto-send via the one-shot drain override).
  */
 export default function useSteering({
+  consumeDraft: takeComposerDraft,
   index,
   conversationId,
   conversation,
@@ -411,6 +421,8 @@ export default function useSteering({
 }: UseSteeringParams) {
   const localize = useLocalize();
   const { showToast } = useToastContext();
+  const jotaiStore = useStore();
+  const fileMap = useFileMapContext();
   const setFilesToDelete = useSetFilesToDelete();
   const convertSteersToQueued = useSteerConvert();
   /** `mutate` is a stable callback; the mutation result objects are fresh
@@ -463,12 +475,31 @@ export default function useSteering({
     const expiry = item.server.uncertainSince + QUEUED_TURN_RECONCILIATION_MS;
     return earliest == null ? expiry : Math.min(earliest, expiry);
   }, undefined);
+  /** An expired uncertain row is held for manual recovery only; nothing the
+   *  projection can say about it is still expected. */
+  const expectsReceipts = useMemo(
+    () =>
+      queuedMessages.some(
+        (item) =>
+          item.server != null &&
+          (item.server.status === 'sending' ||
+            item.server.status === 'queued' ||
+            item.server.status === 'claimed' ||
+            (item.server.status === 'uncertain' && item.server.reconciliationExpired !== true)),
+      ),
+    [queuedMessages],
+  );
   const { data: serverQueuedTurns } = useAgentQueuedTurns(
     conversationId,
     serverQueueEnabled,
     knownClientRequestIds,
     reconciliationUntil,
+    expectsReceipts,
   );
+  /** Retain admission ownership through history hydration and stream attach;
+   * ordinary sends must not overtake the server-owned successor. */
+  const pendingReveal = useAtomValue(revealedQueuedTurnFamily(queueKey));
+  const revealPending = pendingReveal != null;
   const activeGenerationCreatedAt = useRecoilValue(
     store.activeGenerationCreatedAtByConvoId(queueKey),
   );
@@ -525,11 +556,12 @@ export default function useSteering({
               receipts,
               terminalForReconciliation,
               source === 'snapshot',
+              fileMap,
             ),
           );
         }
       },
-    [queueKey],
+    [fileMap, queueKey],
   );
 
   const finishQueuedTurnEnqueue = useRecoilCallback(
@@ -594,7 +626,7 @@ export default function useSteering({
    * `isSubmitting` flips earlier so the user can keep typing; during that
    * bounded interval submits degrade to the local queue and Stop/steer refuse. */
   const canControlGeneration = activeGenerationCreatedAt != null;
-  const duringRunActive = enabled && isSubmitting && !answerModeActive;
+  const duringRunActive = enabled && (isSubmitting || revealPending) && !answerModeActive;
   /** Queue rows can be sent concurrently. Keep their captured origins while
    *  absent so a later capture still sees the complete logical queue. Origins
    *  are isolated per conversation because this hook survives navigation. */
@@ -715,7 +747,7 @@ export default function useSteering({
   /** Whether a queued row has a real immediate-send path. Answer mode keeps
    * `isSubmitting` true while hiding during-run steering, so presenting Send
    * now there would be an enabled no-op. */
-  const canSendQueuedNow = !isSubmitting || (duringRunActive && canSteer);
+  const canSendQueuedNow = (!isSubmitting && !revealPending) || (duringRunActive && canSteer);
   /** Steering needs a live server-side job; degrade to queue otherwise. */
   const effectiveAction: DuringRunAction = canSteer ? defaultAction : 'queue';
 
@@ -953,12 +985,20 @@ export default function useSteering({
         if (trimmed.length === 0) {
           return;
         }
-        const parentMessageId = liveMessageState?.parentMessageId;
-        /** The active epoch is the authority-transfer fence. During startup an
-         * existing branch tail may already be visible while no generation owns
-         * it yet, so keep those turns local until the epoch is concrete. */
+        const parentMessageId =
+          pendingReveal != null
+            ? pendingReveal.queueParentMessageId
+            : liveMessageState?.parentMessageId;
+        const predecessorCreatedAt =
+          pendingReveal != null
+            ? pendingReveal.queuePredecessorCreatedAt
+            : activeGenerationCreatedAt;
+        /** FINAL clears the active epoch before attachment. The revealed
+         * intent retains the queue's original parent/epoch pair. Its display
+         * parent and advancing completion boundary are not queue lineage.
+         * Without an authoritative pair, retain the follow-up locally. */
         const serverOwned =
-          serverQueueEnabled && parentMessageId != null && activeGenerationCreatedAt != null;
+          serverQueueEnabled && parentMessageId != null && predecessorCreatedAt != null;
         const generatedClientRequestId = options?.clientRequestId == null;
         const clientRequestId = options?.clientRequestId ?? (serverOwned ? v4() : undefined);
         const item: QueuedMessage = {
@@ -970,9 +1010,9 @@ export default function useSteering({
             parentMessageId,
             server: { status: 'sending' },
           }),
-          ...((options?.expectedPredecessorCreatedAt ?? activeGenerationCreatedAt) != null && {
+          ...((options?.expectedPredecessorCreatedAt ?? predecessorCreatedAt) != null && {
             expectedPredecessorCreatedAt:
-              options?.expectedPredecessorCreatedAt ?? activeGenerationCreatedAt ?? undefined,
+              options?.expectedPredecessorCreatedAt ?? predecessorCreatedAt ?? undefined,
           }),
           ...(options?.files && options.files.length > 0 && { files: options.files }),
           ...(options?.quotes && options.quotes.length > 0 && { quotes: options.quotes }),
@@ -1069,6 +1109,7 @@ export default function useSteering({
       conversationId,
       serverQueueEnabled,
       liveMessageState?.parentMessageId,
+      pendingReveal,
       markQueuedFilesUsage,
       activeGenerationCreatedAt,
       enqueueAgentQueuedTurn,
@@ -1095,6 +1136,7 @@ export default function useSteering({
       // the attachment into the composer with its real name and size.
       filename: file.filename,
       bytes: file.size,
+      llmDeliveryPath: file.llmDeliveryPath,
     }));
     setFiles(new Map());
     setFilesToDelete({});
@@ -1193,19 +1235,6 @@ export default function useSteering({
     [],
   );
 
-  /** Consumes the composer's autosaved draft once its text has been taken into
-   *  a steer or queued item. The composer clears via the form's `reset()`,
-   *  which is programmatic and never fires the `input` event `useAutoSave`
-   *  listens on — so the draft would outlive the submit. It is keyed under
-   *  this pane's pending draft key here (every caller is gated on
-   *  `duringRunActive`, which requires `isSubmitting` and rules out the
-   *  answer-mode draft key), and run end migrates a surviving pending draft
-   *  onto the conversation and restores it: resurfacing text the user already
-   *  sent. */
-  const takeComposerDraft = useCallback(() => {
-    clearAllDrafts(getPendingDraftId(index));
-  }, [index]);
-
   const removeQueued = useRecoilCallback(
     ({ set }) =>
       (id: string) => {
@@ -1299,6 +1328,12 @@ export default function useSteering({
             return false;
           }
           applyQueuedTurnReceipts([receipt], 'direct');
+          /** The turn was shown as next; the confirmed cancellation ends that
+           *  at once rather than on the next receipt refetch. */
+          const revealFamily = revealedQueuedTurnFamily(queueKey);
+          if (jotaiStore.get(revealFamily)?.clientRequestId === item.clientRequestId) {
+            jotaiStore.set(revealFamily, null);
+          }
           return downgradeServerQueuedTurn(item.id);
         } catch {
           showToast({
@@ -1350,6 +1385,8 @@ export default function useSteering({
       hasRealConvoId,
       localize,
       showToast,
+      jotaiStore,
+      queueKey,
     ],
   );
 
diff --git a/client/src/hooks/Files/__tests__/useFileHandling.test.ts b/client/src/hooks/Files/__tests__/useFileHandling.test.ts
index bcbc2e1b564..564b7279f63 100644
--- a/client/src/hooks/Files/__tests__/useFileHandling.test.ts
+++ b/client/src/hooks/Files/__tests__/useFileHandling.test.ts
@@ -1,4 +1,4 @@
-import { renderHook, act } from '@testing-library/react';
+import { renderHook, act, waitFor } from '@testing-library/react';
 import {
   megabyte,
   Constants,
@@ -17,6 +17,7 @@ type MockUploadMutationOptions = {
       filename: string;
       source: string;
       embedded: boolean;
+      llmDeliveryPath?: string;
       height?: number;
       width?: number;
     },
@@ -210,6 +211,40 @@ describe('useFileHandling', () => {
 
   const loadHook = async () => (await import('../useFileHandling')).default;
 
+  it('removes rejected provider audio and localizes the upload error before retry', async () => {
+    const consoleLog = jest.spyOn(console, 'log').mockImplementation(() => undefined);
+    const useFileHandling = await loadHook();
+    const { result } = renderHook(() => useFileHandling());
+    const recovery = jest.fn();
+    await act(async () => {
+      await result.current.handleFiles(
+        [new File(['audio'], 'clip.wma', { type: 'audio/wma' })],
+        undefined,
+        { onError: recovery },
+      );
+    });
+    const body = mockMutate.mock.calls[0][0] as FormData;
+    const fileId = body.get('file_id');
+    act(() =>
+      mockUploadOptions.onError?.(
+        {
+          response: { status: 415, data: { message: 'com_error_files_provider_audio_format' } },
+        },
+        body,
+      ),
+    );
+    expect(mockDeleteFileById).toHaveBeenCalledWith(fileId);
+    await waitFor(() =>
+      expect(mockLocalize).toHaveBeenCalledWith('com_error_files_provider_audio_format'),
+    );
+    expect(recovery).toHaveBeenCalledWith(fileId);
+    await act(async () => {
+      await result.current.handleFiles([new File(['audio'], 'clip.wav', { type: 'audio/wav' })]);
+    });
+    expect(mockMutate).toHaveBeenCalledTimes(2);
+    consoleLog.mockRestore();
+  });
+
   describe('endpointOverride', () => {
     it('clears the loading state when file validation throws', async () => {
       const consoleError = jest.spyOn(console, 'error').mockImplementation(() => undefined);
@@ -1531,6 +1566,45 @@ describe('useFileHandling', () => {
       expect(onSuccess).toHaveBeenCalledWith(fileId);
     });
 
+    it('keeps the upload delivery path on the completed attachment', async () => {
+      jest.useFakeTimers();
+      const useFileHandling = await loadHook();
+      const { result } = renderHook(() => useFileHandling());
+
+      await act(async () => {
+        await result.current.handleFiles([
+          new File(['hello'], 'notes.docx', {
+            type: 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+          }),
+        ]);
+      });
+
+      const uploadBody = mockMutate.mock.calls[0][0] as FormData;
+      act(() => {
+        mockUploadOptions.onSuccess?.(
+          {
+            temp_file_id: uploadBody.get('file_id') as string,
+            file_id: 'saved-file-id',
+            filepath: '/files/notes.docx',
+            type: 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+            filename: 'notes.docx',
+            source: 'local',
+            embedded: false,
+            llmDeliveryPath: 'text',
+          },
+          uploadBody,
+        );
+        jest.runAllTimers();
+      });
+      jest.useRealTimers();
+
+      const [, completion] = mockUpdateFileById.mock.calls.at(-1) as [
+        string,
+        { llmDeliveryPath?: string },
+      ];
+      expect(completion.llmDeliveryPath).toBe('text');
+    });
+
     it('resolves false when every file fails preprocessing', async () => {
       const consoleLog = jest.spyOn(console, 'log').mockImplementation(() => undefined);
       mockProcessFileForUpload.mockRejectedValue(new Error('HEIC conversion failed'));
diff --git a/client/src/hooks/Files/useFileHandling.ts b/client/src/hooks/Files/useFileHandling.ts
index 51e8608c6ee..c498c7d2673 100644
--- a/client/src/hooks/Files/useFileHandling.ts
+++ b/client/src/hooks/Files/useFileHandling.ts
@@ -311,6 +311,7 @@ const useFileHandlingCore = (params: UseFileHandling | undefined, fileState: Fil
               filename: data.filename,
               source: data.source,
               embedded: data.embedded,
+              llmDeliveryPath: data.llmDeliveryPath,
             },
             assistant_id ? true : false,
           );
diff --git a/client/src/hooks/Input/useAutoSave.spec.ts b/client/src/hooks/Input/useAutoSave.spec.ts
index 09d2d1d608f..62cc492a7a2 100644
--- a/client/src/hooks/Input/useAutoSave.spec.ts
+++ b/client/src/hooks/Input/useAutoSave.spec.ts
@@ -36,6 +36,7 @@ import { useGetFiles } from '~/data-provider';
 import { hasInFlightUpload } from '~/hooks/Files/useFileHandling';
 import {
   encodeBase64,
+  clearAllDrafts,
   getAskAnswerDraftId,
   getDraft,
   getFilesDraft,
@@ -735,6 +736,41 @@ describe('useAutoSave — file cache updates', () => {
     expect(mockSetValue).not.toHaveBeenCalledWith('text', 'other tab text');
     expect(getFilesDraft('convo-2').tabId).toBe('other-tab');
   });
+  it('consumes the retained pending draft without clearing a foreign conversation draft', () => {
+    markTabLive('other-tab');
+    (clearAllDrafts as jest.Mock).mockImplementation(jest.requireActual('~/utils').clearAllDrafts);
+    const { result, rerender, unmount } = renderHook(
+      ({ isSubmitting }: { isSubmitting: boolean }) =>
+        useAutoSave({
+          isSubmitting,
+          conversationId: 'convo-2',
+          textAreaRef: makeTextAreaRef(),
+          files: new Map(),
+          setFiles: jest.fn(),
+        }),
+      { initialProps: { isSubmitting: true } },
+    );
+    setFilesDraft(Constants.PENDING_CONVO, { fileIds: ['ours'], pendingPastes: {} });
+    setFilesDraft('convo-2', {
+      fileIds: ['theirs'],
+      pendingPastes: {},
+      tabId: 'other-tab',
+    });
+    const pendingTextKey = `${LocalStorageKeys.TEXT_DRAFT}${Constants.PENDING_CONVO}`;
+    const foreignTextKey = `${LocalStorageKeys.TEXT_DRAFT}convo-2`;
+    localStorage.setItem(pendingTextKey, encodeBase64('submitted text'));
+    localStorage.setItem(foreignTextKey, encodeBase64('their text'));
+    act(() => rerender({ isSubmitting: false }));
+    act(() => result.current());
+    expect(clearAllDrafts).toHaveBeenLastCalledWith(Constants.PENDING_CONVO);
+    expect(localStorage.getItem(pendingTextKey)).toBeNull();
+    expect(getFilesDraft(Constants.PENDING_CONVO).fileIds).toEqual([]);
+    expect(localStorage.getItem(foreignTextKey)).toBe(encodeBase64('their text'));
+    expect(getFilesDraft('convo-2').fileIds).toEqual(['theirs']);
+    unmount();
+    (clearAllDrafts as jest.Mock).mockReset();
+  });
+
   it('keeps autosaving to the pending key while the destination is owned by another live tab', () => {
     jest.useFakeTimers();
     markTabLive('other-tab');
diff --git a/client/src/hooks/Input/useAutoSave.ts b/client/src/hooks/Input/useAutoSave.ts
index 31ccc1f54f0..f6d46fd9ed1 100644
--- a/client/src/hooks/Input/useAutoSave.ts
+++ b/client/src/hooks/Input/useAutoSave.ts
@@ -8,6 +8,7 @@ import type { ExtendedFile } from '~/common';
 import {
   applyPendingPastesToDraft,
   clearDraft,
+  clearAllDrafts,
   getDraft,
   getFilesDraft,
   getNewConversationDraftId,
@@ -208,6 +209,13 @@ export const useAutoSave = ({
    * which after a send put the just-sent attachment straight back as a chip. */
   const activeStorageId =
     currentConversationId === pendingDraftId ? pendingDraftId : conversationId;
+  /** Only autosave knows whether a foreign tab kept this composer on the
+   * pending key. Submission consumes that actual key under its ownership guard. */
+  const consumeDraft = useCallback(() => {
+    if (activeStorageId) {
+      clearAllDrafts(activeStorageId);
+    }
+  }, [activeStorageId]);
   useEffect(() => {
     // This useEffect is responsible for setting up and cleaning up the auto-save functionality
     // for the text area input. It saves the text to localStorage with a debounce to prevent
@@ -456,4 +464,6 @@ export const useAutoSave = ({
       pendingPastes: existingDraft.pendingPastes,
     });
   }, [conversationId, saveDrafts, currentConversationId, fileIds, files]);
+
+  return consumeDraft;
 };
diff --git a/client/src/hooks/Messages/__tests__/useSubmitMessage.spec.ts b/client/src/hooks/Messages/__tests__/useSubmitMessage.spec.ts
index 9525d4a6222..ee075982950 100644
--- a/client/src/hooks/Messages/__tests__/useSubmitMessage.spec.ts
+++ b/client/src/hooks/Messages/__tests__/useSubmitMessage.spec.ts
@@ -83,6 +83,21 @@ describe('useSubmitMessage', () => {
     expect(reset).not.toHaveBeenCalled();
   });
 
+  it.each([false, true])('preserves a refused automatic prompt (accepted=%s)', (accepted) => {
+    mockUseRecoilValue.mockReturnValue(true);
+    ask.mockReturnValue(accepted);
+    const { result } = renderHook(() => useSubmitMessage());
+    act(() => result.current.submitPrompt('selected prompt'));
+    expect(ask).toHaveBeenCalledWith({ text: 'selected prompt' }, expect.any(Object));
+    if (accepted) {
+      expect(mockSetActivePrompt).not.toHaveBeenCalled();
+      expect(reset).toHaveBeenCalled();
+    } else {
+      expect(mockSetActivePrompt).toHaveBeenCalledWith('selected prompt');
+      expect(reset).not.toHaveBeenCalled();
+    }
+  });
+
   it('reads the tail at call time and appends it to root when missing', () => {
     const rootMessages = [{ messageId: 'root-user' }];
     const latest = { messageId: 'assistant-tail', text: 'tail' };
diff --git a/client/src/hooks/Messages/useSubmitMessage.ts b/client/src/hooks/Messages/useSubmitMessage.ts
index 17179e7f0b6..a01d1ce1d42 100644
--- a/client/src/hooks/Messages/useSubmitMessage.ts
+++ b/client/src/hooks/Messages/useSubmitMessage.ts
@@ -72,10 +72,12 @@ export default function useSubmitMessage() {
   const submitPrompt = useCallback(
     (text: string) => {
       const parsedText = replaceSpecialVars({ text, user });
-      if (autoSendPrompts) {
-        submitMessage({ text: parsedText });
+      if (autoSendPrompts && submitMessage({ text: parsedText }) !== false) {
         return;
       }
+      /** A refused auto-send still belongs to the user. Stage it exactly like
+       * a non-auto-sent prompt so every picker, including variable dialogs,
+       * preserves the text for the composer's guarded submit route. */
 
       const textarea = document.getElementById(mainTextareaId) as HTMLTextAreaElement | null;
       const currentText = textarea?.value ?? methods.getValues('text');
diff --git a/client/src/hooks/SSE/__tests__/useEventHandlers.spec.ts b/client/src/hooks/SSE/__tests__/useEventHandlers.spec.ts
index 08fb6943678..524b6966386 100644
--- a/client/src/hooks/SSE/__tests__/useEventHandlers.spec.ts
+++ b/client/src/hooks/SSE/__tests__/useEventHandlers.spec.ts
@@ -1,9 +1,11 @@
 import { Constants } from 'librechat-data-provider';
-import type { EventSubmission, TMessage } from 'librechat-data-provider';
+import type { EventSubmission, TMessage, TConversation } from 'librechat-data-provider';
 import {
   buildCreatedInitialResponse,
   getExistingConversationAbortMessages,
   isInitialNewConversationSubmission,
+  keepLocalCodeApprovalMode,
+  buildRecoveryPreset,
   mergeErrorMessages,
   mergeRegenerateFinalMessages,
   startedAsNewConversation,
@@ -289,3 +291,64 @@ describe('mergeErrorMessages', () => {
     expect(merged[1]).toEqual(errorMessage);
   });
 });
+
+describe('keepLocalCodeApprovalMode', () => {
+  const server = { conversationId: 'conversation-1', codeApprovalMode: 'ask' } as TConversation;
+  const local = {
+    conversationId: 'conversation-1',
+    codeApprovalMode: 'acceptEdits',
+  } as TConversation;
+
+  it('keeps a locally picked mode over the server copy', () => {
+    expect(keepLocalCodeApprovalMode(server, local, 'conversation-1').codeApprovalMode).toBe(
+      'acceptEdits',
+    );
+  });
+
+  it('lets the server copy win when nothing was picked locally', () => {
+    const unset = { conversationId: 'conversation-1' } as TConversation;
+    expect(keepLocalCodeApprovalMode(server, unset, 'conversation-1')).toBe(server);
+    expect(keepLocalCodeApprovalMode(server, null, 'conversation-1')).toBe(server);
+  });
+
+  it('ignores the mode of a conversation the user navigated to mid-run', () => {
+    const elsewhere = { conversationId: 'conversation-2', codeApprovalMode: 'fullAccess' };
+    expect(keepLocalCodeApprovalMode(server, elsewhere as TConversation, 'conversation-1')).toBe(
+      server,
+    );
+  });
+
+  it('follows a new chat to the id the server assigned', () => {
+    const assigned = { conversationId: 'server-id', codeApprovalMode: 'acceptEdits' };
+    expect(
+      keepLocalCodeApprovalMode(
+        { conversationId: 'server-id' } as TConversation,
+        assigned as TConversation,
+        'server-id',
+      ).codeApprovalMode,
+    ).toBe('acceptEdits');
+    expect(keepLocalCodeApprovalMode(server, assigned as TConversation, Constants.NEW_CONVO)).toBe(
+      server,
+    );
+  });
+});
+
+describe('buildRecoveryPreset', () => {
+  const sent = {
+    conversationId: 'conversation-1',
+    endpoint: 'agents',
+    agent_id: 'agent-1',
+    codeApprovalMode: 'ask',
+  } as TConversation;
+
+  it('carries the mode the detail cache holds for the rebuilt conversation', () => {
+    const cached = { ...sent, codeApprovalMode: 'acceptEdits' } as TConversation;
+    const preset = buildRecoveryPreset(sent, cached, 'conversation-1');
+    expect(preset.codeApprovalMode).toBe('acceptEdits');
+    expect(preset.agent_id).toBe('agent-1');
+  });
+
+  it('falls back to the sent mode when no record exists', () => {
+    expect(buildRecoveryPreset(sent, undefined, '_fresh').codeApprovalMode).toBe('ask');
+  });
+});
diff --git a/client/src/hooks/SSE/__tests__/useResumableSSE.spec.ts b/client/src/hooks/SSE/__tests__/useResumableSSE.spec.ts
index a42af9fa7cb..b0fedd00679 100644
--- a/client/src/hooks/SSE/__tests__/useResumableSSE.spec.ts
+++ b/client/src/hooks/SSE/__tests__/useResumableSSE.spec.ts
@@ -1470,6 +1470,44 @@ describe('useResumableSSE', () => {
     unmount();
   });
 
+  it('keeps a mode picked while a settled start was pending', async () => {
+    (request.post as jest.Mock).mockResolvedValue({
+      conversationId: CONV_ID,
+      status: 'settled',
+      generationProtocolVersion: 2,
+    });
+    mockGetConversationById.mockResolvedValue({
+      conversationId: CONV_ID,
+      endpoint: 'agents',
+      codeApprovalMode: 'fullAccess',
+    });
+    mockGetQueryData.mockImplementation((queryKey: unknown[]) =>
+      queryKey[0] === QueryKeys.conversation
+        ? { conversationId: CONV_ID, codeApprovalMode: 'ask' }
+        : undefined,
+    );
+    const chatHelpers = buildChatHelpers();
+
+    const { unmount } = renderHook(() => useResumableSSE(buildSubmission(), chatHelpers));
+
+    await waitFor(() => {
+      expect(chatHelpers.setConversation).toHaveBeenCalled();
+    });
+
+    const update = chatHelpers.setConversation.mock.calls.at(-1)?.[0];
+    expect(update({ conversationId: CONV_ID, codeApprovalMode: 'ask' }).codeApprovalMode).toBe(
+      'ask',
+    );
+    expect(
+      update({ conversationId: 'conv-elsewhere', codeApprovalMode: 'ask' }).codeApprovalMode,
+    ).toBe('fullAccess');
+    expect(mockSetQueryData).toHaveBeenCalledWith(
+      [QueryKeys.conversation, CONV_ID],
+      expect.objectContaining({ codeApprovalMode: 'ask' }),
+    );
+    unmount();
+  });
+
   it.each(['settled', 'replaced'] as const)(
     'rejects an unnegotiated %s start control response',
     async (status) => {
@@ -2154,73 +2192,114 @@ describe('useResumableSSE', () => {
     unmount();
   });
 
-  it('reconciles a synthesized terminal frame without rendering a bogus final or error', async () => {
-    (request.post as jest.Mock).mockResolvedValue({
-      streamId: CONV_ID,
-      status: 'started',
-      generationCreatedAt: 1000,
-      generationProtocolVersion: 2,
-    });
-    const persisted = [
-      {
-        messageId: 'persisted-response',
-        conversationId: CONV_ID,
-        isCreatedByUser: false,
-        text: 'Persisted answer',
-      },
-    ] as TMessage[];
-    mockGetQueryData.mockReturnValue(persisted);
-    mockFetchStreamStatus.mockResolvedValue({ active: false, generationProtocolVersion: 2 });
-    const submission = buildSubmission();
-    const chatHelpers = buildChatHelpers();
-    getDefaultStore().set(pendingApprovalActionFamily(CONV_ID), {
-      actionId: 'stale-action',
-      streamId: CONV_ID,
-      createdAt: 1000,
-      payload: { type: 'tool_approval', action_requests: [], review_configs: [] },
-    });
+  it.each([
+    'status',
+    'submission',
+    'unique-placeholder',
+    'ambiguous-placeholder',
+    'missing-response',
+  ])(
+    'reconciles a synthesized terminal using %s response identity instead of a later sibling',
+    async (identitySource) => {
+      (request.post as jest.Mock).mockResolvedValue({
+        streamId: CONV_ID,
+        status: 'started',
+        generationCreatedAt: 1000,
+        generationProtocolVersion: 2,
+      });
+      const persisted = [
+        {
+          messageId: 'persisted-response',
+          parentMessageId: 'msg-1',
+          conversationId: CONV_ID,
+          isCreatedByUser: false,
+          text: 'Persisted answer',
+        },
+        {
+          messageId: 'later-sibling',
+          parentMessageId: 'msg-1',
+          conversationId: CONV_ID,
+          isCreatedByUser: false,
+          text: 'A different branch',
+        },
+      ] as TMessage[];
+      if (identitySource === 'unique-placeholder') {
+        persisted.pop();
+      }
+      mockGetQueryData.mockReturnValue(persisted);
+      mockFetchStreamStatus.mockResolvedValue({
+        active: false,
+        generationProtocolVersion: 2,
+        ...(identitySource === 'status' && {
+          resumeState: { responseMessageId: 'persisted-response' },
+        }),
+      });
+      const responseIds: Record<string, string> = {
+        submission: 'persisted-response_',
+        'missing-response': 'missing-response_',
+      };
+      const submission = buildSubmission({
+        initialResponse: { messageId: responseIds[identitySource] ?? 'msg-1_' },
+      });
+      const chatHelpers = buildChatHelpers();
+      getDefaultStore().set(pendingApprovalActionFamily(CONV_ID), {
+        actionId: 'stale-action',
+        streamId: CONV_ID,
+        createdAt: 1000,
+        payload: { type: 'tool_approval', action_requests: [], review_configs: [] },
+      });
 
-    const { unmount } = renderHook(() => useResumableSSE(submission, chatHelpers));
-    await flushMicrotasks();
+      const { unmount } = renderHook(() => useResumableSSE(submission, chatHelpers));
+      await flushMicrotasks();
 
-    const sse = getLastSSE();
-    await act(async () => {
-      sse._emit('message', {
-        data: JSON.stringify({
-          final: true,
-          reconcile: true,
-          reconcileReason: 'terminal_payload_missing',
-          terminalStatus: 'complete',
-          generationCreatedAt: 1000,
-          generationProtocolVersion: 2,
-          conversation: { conversationId: CONV_ID },
-        }),
+      const sse = getLastSSE();
+      await act(async () => {
+        sse._emit('message', {
+          data: JSON.stringify({
+            final: true,
+            reconcile: true,
+            reconcileReason: 'terminal_payload_missing',
+            terminalStatus: 'complete',
+            generationCreatedAt: 1000,
+            generationProtocolVersion: 2,
+            conversation: { conversationId: CONV_ID },
+          }),
+        });
+        await Promise.resolve();
       });
-      await Promise.resolve();
-    });
-    await flushMicrotasks();
+      await flushMicrotasks();
 
-    expect(mockFinalHandler).not.toHaveBeenCalled();
-    expect(mockErrorHandler).not.toHaveBeenCalled();
-    expect(getDefaultStore().get(pendingApprovalActionFamily(CONV_ID))).toBeNull();
-    expect(mockInvalidateQueries).toHaveBeenCalledWith({
-      queryKey: [QueryKeys.messages, CONV_ID],
-      refetchType: 'none',
-    });
-    expect(mockInvalidateQueries).toHaveBeenCalledWith({
-      queryKey: [QueryKeys.allConversations],
-    });
-    expect(mockInvalidateQueries).toHaveBeenCalledWith({
-      queryKey: [QueryKeys.pinnedConversations],
-    });
-    expect(mockSettleAppliedSteerParts).toHaveBeenCalledWith(CONV_ID, persisted);
-    expect(mockSetRunEnd).toHaveBeenCalledWith(
-      expect.objectContaining({ conversationId: CONV_ID, outcome: 'completed' }),
-    );
-    expect(mockSetSubmission).toHaveBeenCalledWith(null);
-    expect(mockUpdateGenerationEpoch).toHaveBeenCalledWith(CONV_ID, null, 1000);
-    unmount();
-  });
+      expect(mockFinalHandler).not.toHaveBeenCalled();
+      expect(mockErrorHandler).not.toHaveBeenCalled();
+      expect(getDefaultStore().get(pendingApprovalActionFamily(CONV_ID))).toBeNull();
+      expect(mockInvalidateQueries).toHaveBeenCalledWith({
+        queryKey: [QueryKeys.messages, CONV_ID],
+        refetchType: 'none',
+      });
+      expect(mockInvalidateQueries).toHaveBeenCalledWith({
+        queryKey: [QueryKeys.allConversations],
+      });
+      expect(mockInvalidateQueries).toHaveBeenCalledWith({
+        queryKey: [QueryKeys.pinnedConversations],
+      });
+      expect(mockSettleAppliedSteerParts).toHaveBeenCalledWith(CONV_ID, persisted);
+      expect(mockSetRunEnd).toHaveBeenCalledWith(
+        expect.objectContaining({
+          conversationId: CONV_ID,
+          outcome: 'completed',
+          ...(['status', 'submission', 'unique-placeholder'].includes(identitySource) && {
+            responseMessageId: 'persisted-response',
+          }),
+        }),
+      );
+      if (['ambiguous-placeholder', 'missing-response'].includes(identitySource)) {
+        expect(mockSetRunEnd.mock.calls.at(-1)?.[0]).not.toHaveProperty('responseMessageId');
+      }
+      expect(mockSetSubmission).toHaveBeenCalledWith(null);
+      expect(mockUpdateGenerationEpoch).toHaveBeenCalledWith(CONV_ID, null, 1000);
+      unmount();
+    },
+  );
 
   it('ignores v2-only lifecycle reconciliation on a legacy generation', async () => {
     (request.post as jest.Mock).mockResolvedValue({
diff --git a/client/src/hooks/SSE/__tests__/useResumeOnLoad.spec.tsx b/client/src/hooks/SSE/__tests__/useResumeOnLoad.spec.tsx
index 05214791305..9104c4c6b68 100644
--- a/client/src/hooks/SSE/__tests__/useResumeOnLoad.spec.tsx
+++ b/client/src/hooks/SSE/__tests__/useResumeOnLoad.spec.tsx
@@ -9,6 +9,8 @@ import type { ReactNode } from 'react';
 import type { PendingSteer, QueuedMessage } from '~/store/families';
 import { siblingIdxFamily, siblingKey } from '~/components/Chat/Messages/Thread/state';
 import { pendingApprovalActionFamily } from '~/components/Chat/approval/state';
+import { agentQueuedTurnsQueryKey } from '~/data-provider/SSE/queuedTurns';
+import { revealedQueuedTurnFamily } from '~/store/steer';
 import useResumeOnLoad from '../useResumeOnLoad';
 import store from '~/store';
 
@@ -16,6 +18,11 @@ const mockUseStreamStatus = jest.fn();
 const mockUseActiveJobs = jest.fn();
 const mockUseAgentQueuedTurns = jest.fn();
 const mockExtendActiveJobsGrace = jest.fn();
+let mockFileMap: Record<string, { llmDeliveryPath?: 'provider' | 'text' | 'none' }> = {};
+
+jest.mock('~/Providers', () => ({
+  useFileMapContext: () => mockFileMap,
+}));
 
 jest.mock('~/data-provider', () => ({
   useStreamStatus: (conversationId: string | undefined, enabled: boolean) =>
@@ -213,6 +220,7 @@ describe('useResumeOnLoad', () => {
     mockUseAgentQueuedTurns.mockReset();
     mockUseAgentQueuedTurns.mockReturnValue({ data: [], dataUpdatedAt: 1 });
     mockExtendActiveJobsGrace.mockReset();
+    mockFileMap = {};
   });
 
   afterEach(() => {
@@ -970,15 +978,50 @@ describe('useResumeOnLoad', () => {
       expect(attached?.resumeStreamId).toBe(CONVERSATION_ID);
     });
 
+    it('retires a remounted reveal after fresh inactive status and restored successor history', async () => {
+      mockUseStreamStatus.mockReturnValue({ ...INACTIVE_STATUS, isSuccess: false });
+      mockUseAgentQueuedTurns.mockReturnValue({ data: [] });
+      const messages = [
+        buildUserMessage(CONVERSATION_ID),
+        { messageId: 'successor', parentMessageId: 'response' } as TMessage,
+      ];
+      const { rerender, jotaiStore, queryClient } = renderUseResumeOnLoad({ messages });
+      const family = revealedQueuedTurnFamily(CONVERSATION_ID);
+      act(() => {
+        queryClient.setQueryData([QueryKeys.messages, CONVERSATION_ID], messages);
+        jotaiStore.set(family, {
+          clientRequestId: 'queued',
+          parentMessageId: 'response',
+          generationCreatedAt: 41,
+          text: 'queued',
+          revealedAt: new Date(Date.now() - 60_000).toISOString(),
+        });
+      });
+      mockUseStreamStatus.mockReturnValue({ ...INACTIVE_STATUS, dataUpdatedAt: Date.now() + 1 });
+      rerender();
+      expect(jotaiStore.get(family)).toBeNull();
+    });
+
     it('lets the owed state lapse once the receipt has gone quiet for the window', async () => {
       jest.useFakeTimers();
       mockUseStreamStatus.mockReturnValue(INACTIVE_STATUS);
       mockUseAgentQueuedTurns.mockReturnValue({ data: [{ status: 'queued' }], dataUpdatedAt: 2 });
-      const { rerender } = renderUseResumeOnLoad({ messages: [buildUserMessage(CONVERSATION_ID)] });
+      const { rerender, jotaiStore } = renderUseResumeOnLoad({
+        messages: [buildUserMessage(CONVERSATION_ID)],
+      });
       await act(async () => {
         await Promise.resolve();
       });
 
+      const revealFamily = revealedQueuedTurnFamily(CONVERSATION_ID);
+      jotaiStore.set(revealFamily, {
+        clientRequestId: 'queued',
+        parentMessageId: 'response',
+        generationCreatedAt: 41,
+        text: 'queued',
+        revealedAt: new Date().toISOString(),
+      });
+
       /** A long wait behind an unadmitted turn must not burn the window: the
        *  countdown starts only when the receipt stops reporting. */
       await act(async () => {
@@ -986,6 +1029,7 @@ describe('useResumeOnLoad', () => {
       });
       expect(mockUseActiveJobs).toHaveBeenLastCalledWith(true, true);
 
+      expect(jotaiStore.get(revealFamily)).not.toBeNull();
       mockUseAgentQueuedTurns.mockReturnValue({ data: [], dataUpdatedAt: 3 });
       rerender();
       await act(async () => {
@@ -998,6 +1042,7 @@ describe('useResumeOnLoad', () => {
       });
       rerender();
       expect(mockUseActiveJobs).toHaveBeenLastCalledWith(true, false);
+      expect(jotaiStore.get(revealFamily)).toBeNull();
       jest.useRealTimers();
     });
 
@@ -1257,6 +1302,47 @@ describe('useResumeOnLoad', () => {
       nowSpy.mockRestore();
     });
 
+    it.each(['queued', 'claimed', 'admitted'])(
+      'retains off-screen admission ownership while a cached receipt is %s',
+      async (status) => {
+        jest.useFakeTimers();
+        mockUseStreamStatus.mockReturnValue(INACTIVE_STATUS);
+        mockUseAgentQueuedTurns.mockReturnValue({
+          data: [{ queuedTurnId: 'q1', status }],
+          dataUpdatedAt: 2,
+        });
+        const { rerender, queryClient, jotaiStore } = renderUseResumeOnLoad({
+          messages: [buildUserMessage(CONVERSATION_ID)],
+        });
+        const family = revealedQueuedTurnFamily(CONVERSATION_ID);
+        act(() => {
+          jotaiStore.set(family, {
+            clientRequestId: 'request',
+            parentMessageId: 'response',
+            generationCreatedAt: 41,
+            text: 'queued',
+            revealedAt: new Date().toISOString(),
+          });
+          queryClient.setQueryData(agentQueuedTurnsQueryKey(CONVERSATION_ID), [
+            { queuedTurnId: 'q1', status },
+          ]);
+        });
+        mockUseAgentQueuedTurns.mockReturnValue({ data: [], dataUpdatedAt: 3 });
+        rerender({ conversationId: STALE_CONVERSATION_ID });
+        await act(async () => {
+          jest.advanceTimersByTime(30_001);
+        });
+        expect(jotaiStore.get(family)).not.toBeNull();
+        mockUseAgentQueuedTurns.mockReturnValue({
+          data: [{ queuedTurnId: 'q1', status }],
+          dataUpdatedAt: 4,
+        });
+        rerender({ conversationId: CONVERSATION_ID });
+        expect(jotaiStore.get(family)).not.toBeNull();
+        jest.useRealTimers();
+      },
+    );
+
     it('expires the owed state on an absolute window even while its conversation is off-screen', async () => {
       jest.useFakeTimers();
       mockUseStreamStatus.mockReturnValue(INACTIVE_STATUS);
diff --git a/client/src/hooks/SSE/useEventHandlers.ts b/client/src/hooks/SSE/useEventHandlers.ts
index fcef419cf7a..dbc285664c1 100644
--- a/client/src/hooks/SSE/useEventHandlers.ts
+++ b/client/src/hooks/SSE/useEventHandlers.ts
@@ -14,6 +14,7 @@ import {
   isAssistantsEndpoint,
 } from 'librechat-data-provider';
 import type {
+  TPreset,
   TMessage,
   TConversation,
   EventSubmission,
@@ -298,6 +299,38 @@ const createErrorMessage = ({
   return tMessageSchema.parse(errorMessage) as TMessage;
 };
 
+/**
+ * A code approval mode picked locally is newer than any server copy of the
+ * conversation: the final and abort events return the mode the run STARTED
+ * with, and error recovery rebuilds from the pre-run capture. The local mode
+ * therefore survives every merge and the next send carries it. Identity is
+ * checked because the conversation atom is index-global: after navigating
+ * elsewhere mid-run, that conversation's mode must not land in this one.
+ */
+export const keepLocalCodeApprovalMode = <T extends Partial<TConversation>>(
+  merged: T,
+  local: Partial<TConversation> | null | undefined,
+  conversationId: string | null | undefined,
+): T => {
+  const localMode = local?.codeApprovalMode;
+  if (localMode == null || local?.conversationId !== conversationId) {
+    return merged;
+  }
+  return merged.codeApprovalMode === localMode
+    ? merged
+    : { ...merged, codeApprovalMode: localMode };
+};
+
+/** Preset for a conversation rebuilt after a failed or aborted run. The detail
+ *  cache holds a mode picked while that run streamed; the capture only the
+ *  pre-run one. */
+export const buildRecoveryPreset = (
+  submissionConvo: Partial<TConversation>,
+  cachedConvo: TConversation | null | undefined,
+  conversationId: string,
+): TPreset =>
+  tPresetSchema.parse(keepLocalCodeApprovalMode(submissionConvo, cachedConvo, conversationId));
+
 export const getConvoTitle = ({
   parentId,
   queryClient,
@@ -349,6 +382,22 @@ export default function useEventHandlers({
    *  would inherit a stale baseline. Navigation teardown deliberately does not
    *  clear it — a reattach to a still-live run keeps its original start. */
   const setSubmissionStart = useSetRecoilState(store.submissionStartFamily(runIndex));
+  const recoverConversation = useCallback(
+    (conversationId: string, submission: EventSubmission) => {
+      if (!newConversation) {
+        return;
+      }
+      const cachedConvo = queryClient.getQueryData<TConversation>([
+        QueryKeys.conversation,
+        conversationId,
+      ]);
+      newConversation({
+        template: { conversationId },
+        preset: buildRecoveryPreset(submission.conversation, cachedConvo, conversationId),
+      });
+    },
+    [newConversation, queryClient],
+  );
   const navigate = useNavigate();
   const location = useLocation();
 
@@ -510,10 +559,13 @@ export default function useEventHandlers({
       }
 
       if (setConversation && !isAddedRequest) {
-        setConversation((prevState) => {
-          const update = { ...prevState, ...convoUpdate };
-          return update;
-        });
+        setConversation((prevState) =>
+          keepLocalCodeApprovalMode(
+            { ...prevState, ...convoUpdate },
+            prevState,
+            convoUpdate.conversationId,
+          ),
+        );
       }
 
       setIsSubmitting(false);
@@ -923,10 +975,11 @@ export default function useEventHandlers({
          *  generating before the Stop, so the local one stays in sync. */
         if (setConversation && isAddedRequest !== true) {
           setConversation((prevState) => {
-            const update = {
-              ...prevState,
-              ...(conversation as TConversation),
-            };
+            const update = keepLocalCodeApprovalMode(
+              { ...prevState, ...(conversation as TConversation) },
+              prevState,
+              conversation.conversationId,
+            );
             if (prevState?.model != null && prevState.model !== submissionConvo.model) {
               update.model = prevState.model;
             }
@@ -938,10 +991,13 @@ export default function useEventHandlers({
               queryClient.setQueryData<TConversation>(
                 [QueryKeys.conversation, conversation.conversationId],
                 (cachedConvo) => {
-                  const merged = {
-                    ...cachedConvo,
-                    ...serverConversation,
-                  } as TConversation;
+                  const merged = keepLocalCodeApprovalMode(
+                    { ...cachedConvo, ...serverConversation } as TConversation,
+                    prevState?.conversationId === conversation.conversationId
+                      ? prevState
+                      : cachedConvo,
+                    conversation.conversationId,
+                  );
                   const cachedTitle = cachedConvo?.title;
                   if (!hasRealTitle(serverConversation.title) && hasRealTitle(cachedTitle)) {
                     merged.title = cachedTitle;
@@ -1042,12 +1098,7 @@ export default function useEventHandlers({
           submission,
         });
         setErrorMessages(convoId, errorResponse);
-        if (newConversation) {
-          newConversation({
-            template: { conversationId: convoId },
-            preset: tPresetSchema.parse(submission.conversation),
-          });
-        }
+        recoverConversation(convoId, submission);
         setIsSubmitting(false);
         return;
       }
@@ -1057,12 +1108,7 @@ export default function useEventHandlers({
         const convoId = `_${v4()}`;
         const errorResponse = parseErrorResponse(data);
         setErrorMessages(convoId, errorResponse);
-        if (newConversation) {
-          newConversation({
-            template: { conversationId: convoId },
-            preset: tPresetSchema.parse(submission.conversation),
-          });
-        }
+        recoverConversation(convoId, submission);
         setIsSubmitting(false);
         return;
       } else if (!receivedConvoId) {
@@ -1079,11 +1125,8 @@ export default function useEventHandlers({
       }) as TMessage;
 
       setErrorMessages(receivedConvoId, errorResponse);
-      if (receivedConvoId && paramId === Constants.NEW_CONVO && newConversation) {
-        newConversation({
-          template: { conversationId: receivedConvoId },
-          preset: tPresetSchema.parse(submission.conversation),
-        });
+      if (receivedConvoId && paramId === Constants.NEW_CONVO) {
+        recoverConversation(receivedConvoId, submission);
       }
 
       setIsSubmitting(false);
@@ -1093,11 +1136,11 @@ export default function useEventHandlers({
       setCompleted,
       setMessages,
       paramId,
-      newConversation,
       setIsSubmitting,
       setSubmissionStart,
       getMessages,
       queryClient,
+      recoverConversation,
     ],
   );
 
@@ -1149,12 +1192,7 @@ export default function useEventHandlers({
       } else if (!isAssistantsEndpoint(endpoint)) {
         const convoId = conversationId || `_${v4()}`;
         logger.log('conversation', 'Aborted conversation with minimal messages, ID: ' + convoId);
-        if (newConversation) {
-          newConversation({
-            template: { conversationId: convoId },
-            preset: tPresetSchema.parse(submission.conversation),
-          });
-        }
+        recoverConversation(convoId, submission);
         setIsSubmitting(false);
         return;
       }
@@ -1202,12 +1240,7 @@ export default function useEventHandlers({
           error,
         });
         setMessages([...submission.messages, submission.userMessage, errorResponse]);
-        if (newConversation) {
-          newConversation({
-            template: { conversationId: conversationId || errorResponse.conversationId || v4() },
-            preset: tPresetSchema.parse(submission.conversation),
-          });
-        }
+        recoverConversation(conversationId || errorResponse.conversationId || v4(), submission);
         setIsSubmitting(false);
       }
     },
@@ -1217,10 +1250,10 @@ export default function useEventHandlers({
       setMessages,
       finalHandler,
       cancelHandler,
-      newConversation,
       setIsSubmitting,
       setShowStopButton,
       setSubmissionStart,
+      recoverConversation,
     ],
   );
 
diff --git a/client/src/hooks/SSE/useResumableSSE.ts b/client/src/hooks/SSE/useResumableSSE.ts
index 737a0654570..f677914321d 100644
--- a/client/src/hooks/SSE/useResumableSSE.ts
+++ b/client/src/hooks/SSE/useResumableSSE.ts
@@ -67,6 +67,7 @@ import {
   markStreamStartFailedMetadata,
   findPendingActionMessageIndex,
   insertQueuedOrigin,
+  hydrateFileDeliveryMetadata,
 } from '~/utils';
 import {
   useGetUserBalance,
@@ -80,10 +81,14 @@ import {
   supportsGenerationProtocolV2,
   GENERATION_PROTOCOL_VERSION,
 } from '~/data-provider';
-import useEventHandlers, { buildCreatedInitialResponse } from './useEventHandlers';
+import useEventHandlers, {
+  buildCreatedInitialResponse,
+  keepLocalCodeApprovalMode,
+} from './useEventHandlers';
 import { pendingApprovalActionFamily } from '~/components/Chat/approval/state';
 import useSteerConvert from '~/hooks/Chat/useSteerConvert';
 import { useAuthContext } from '~/hooks/AuthContext';
+import { useFileMapContext } from '~/Providers';
 import useUsageHandler from './useUsageHandler';
 import store from '~/store';
 
@@ -496,6 +501,38 @@ const replaceNewConversationUrl = (conversationId: string) => {
 const shouldHydrateMessage = (message: TMessage) =>
   !hasConcreteConversationId(message.conversationId);
 
+/** Recovery must identify the response itself: regenerations share a user
+ * parent, and array order says nothing about which sibling just completed.
+ * A fresh-turn placeholder has no server response ID yet; only an unambiguous
+ * persisted child can stand in for it. */
+const completedResponseMessageId = (
+  messages: TMessage[] | undefined,
+  userMessageId: string | undefined,
+  responseMessageId: string | undefined,
+): string | undefined => {
+  if (messages == null || userMessageId == null) {
+    return undefined;
+  }
+  const target = responseMessageId?.replace(/_+$/, '');
+  const hasResponseIdentity = target != null && target !== userMessageId;
+  let candidate: string | undefined;
+  let ambiguous = false;
+  for (const message of messages) {
+    if (message.isCreatedByUser !== false || message.parentMessageId !== userMessageId) {
+      continue;
+    }
+    if (hasResponseIdentity) {
+      if (message.messageId === target) {
+        return message.messageId;
+      }
+      continue;
+    }
+    ambiguous ||= candidate != null;
+    candidate = message.messageId;
+  }
+  return hasResponseIdentity || ambiguous ? undefined : candidate;
+};
+
 const hydrateMessageConversationId = (message: TMessage, conversationId: string): TMessage =>
   shouldHydrateMessage(message) ? { ...message, conversationId } : message;
 
@@ -759,6 +796,9 @@ export default function useResumableSSE(
   const setActiveRunId = useSetRecoilState(store.activeRunFamily(runIndex));
 
   const { token, isAuthenticated } = useAuthContext();
+  const fileMap = useFileMapContext();
+  const fileMapRef = useRef(fileMap);
+  fileMapRef.current = fileMap;
   const { setMessages, getMessages, setConversation, setIsSubmitting, newConversation } =
     chatHelpers;
 
@@ -1055,13 +1095,18 @@ export default function useResumableSSE(
               const keepLocalPreempt =
                 (localChip?.preemptRevision ?? 0) > (steer.preemptRevision ?? 0);
               const chipGenerationCreatedAt = generationCreatedAt ?? localChip?.generationCreatedAt;
+              const restoredFiles = hydrateFileDeliveryMetadata(
+                steer.files,
+                localChip?.files,
+                fileMapRef.current,
+              );
               return {
                 steerId: steer.steerId,
                 ...(steer.clientSteerId && { clientSteerId: steer.clientSteerId }),
                 text: steer.text,
                 status: 'pending' as const,
                 createdAt: steer.createdAt ?? Date.now(),
-                ...(steer.files && steer.files.length > 0 && { files: steer.files }),
+                ...(restoredFiles && restoredFiles.length > 0 && { files: restoredFiles }),
                 ...((keepLocalPreempt ? localChip?.preempt : steer.preempt) === true && {
                   preempt: true,
                 }),
@@ -2073,6 +2118,9 @@ export default function useResumableSSE(
               startedAsNewConvo: runEndTarget.startedAsNewConvo,
               endedAt: Date.now(),
               generationCreatedAt,
+              ...(data.responseMessage?.messageId != null && {
+                responseMessageId: data.responseMessage.messageId,
+              }),
             });
             // Clear handler maps on stream completion to prevent memory leaks
             clearStepMaps();
@@ -2952,11 +3000,23 @@ export default function useResumableSSE(
         } else if (event.terminalStatus === 'error') {
           reconciliationOutcome = 'error';
         }
+        const reconciledResponseMessageId =
+          reconciliationOutcome === 'completed'
+            ? completedResponseMessageId(
+                persistedMessages,
+                userMessage?.messageId,
+                status?.resumeState?.responseMessageId ??
+                  currentSubmission.initialResponse?.messageId,
+              )
+            : undefined;
         setRunEnd({
           conversationId: reconciliationConvoId,
           outcome: reconciliationOutcome,
           endedAt: Date.now(),
           generationCreatedAt: status?.createdAt ?? generationCreatedAt,
+          ...(reconciledResponseMessageId != null && {
+            responseMessageId: reconciledResponseMessageId,
+          }),
         });
         setSubmission(null);
         setStreamId(null);
@@ -3644,11 +3704,23 @@ export default function useResumableSSE(
           } else if (status.status === 'aborted') {
             recoveryOutcome = 'aborted';
           }
+          const recoveredResponseMessageId =
+            recoveryOutcome === 'completed'
+              ? completedResponseMessageId(
+                  persistedMessages,
+                  userMessage?.messageId,
+                  status?.resumeState?.responseMessageId ??
+                    currentSubmission.initialResponse?.messageId,
+                )
+              : undefined;
           setRunEnd({
             conversationId: recoveryConvoId,
             outcome: recoveryOutcome,
             endedAt: Date.now(),
             generationCreatedAt: status.createdAt ?? generationCreatedAt,
+            ...(recoveredResponseMessageId != null && {
+              responseMessageId: recoveredResponseMessageId,
+            }),
           });
           setSubmission(null);
           setStreamId(null);
@@ -4296,7 +4368,16 @@ export default function useResumableSSE(
                 replacementStart.conversationId,
               ]);
               if (authoritativeConversation?.conversationId === replacementStart.conversationId) {
-                setConversation?.(authoritativeConversation);
+                const localConversationId = isInitialNewConversation(submission)
+                  ? Constants.NEW_CONVO
+                  : replacementStart.conversationId;
+                setConversation?.((current) =>
+                  keepLocalCodeApprovalMode(
+                    authoritativeConversation,
+                    current,
+                    localConversationId,
+                  ),
+                );
               }
               queryClient.setQueryData(streamStatusQueryKey(replacementStart.conversationId), {
                 ...replacementStatus,
@@ -4394,12 +4475,30 @@ export default function useResumableSSE(
             }
 
             if (persistedConversation != null) {
+              /** The persisted copy carries the mode the settled turn started
+               *  with; a pick made while the start was pending is newer. The
+               *  live conversation still holds the new-chat id here because no
+               *  stream event ran for this turn. */
+              const settledCopy = persistedConversation;
+              const localConversationId = startedAsNewConvo
+                ? Constants.NEW_CONVO
+                : settledConversationId;
+              const conversationRecord = keepLocalCodeApprovalMode(
+                settledCopy,
+                queryClient.getQueryData<TConversation>([
+                  QueryKeys.conversation,
+                  settledConversationId,
+                ]),
+                settledConversationId,
+              );
               queryClient.setQueryData(
                 [QueryKeys.conversation, settledConversationId],
-                persistedConversation,
+                conversationRecord,
+              );
+              upsertConvoInAllQueries(queryClient, conversationRecord);
+              setConversation?.((current) =>
+                keepLocalCodeApprovalMode(settledCopy, current, localConversationId),
               );
-              upsertConvoInAllQueries(queryClient, persistedConversation);
-              setConversation?.(persistedConversation);
               if (startedAsNewConvo) {
                 replaceNewConversationUrl(settledConversationId);
               }
diff --git a/client/src/hooks/SSE/useResumeOnLoad.ts b/client/src/hooks/SSE/useResumeOnLoad.ts
index 185bfe0e9c8..68e9bb60551 100644
--- a/client/src/hooks/SSE/useResumeOnLoad.ts
+++ b/client/src/hooks/SSE/useResumeOnLoad.ts
@@ -20,6 +20,7 @@ import {
   applyPendingAction,
   carriedSteerContext,
   getBranchSiblingIndexesForTarget,
+  hydrateFileDeliveryMetadata,
 } from '~/utils';
 import {
   useStreamStatus,
@@ -36,7 +37,10 @@ import {
 } from '~/data-provider/SSE/protocol';
 import { siblingIdxFamily, siblingKey } from '~/components/Chat/Messages/Thread/state';
 import { pendingApprovalActionFamily } from '~/components/Chat/approval/state';
+import { agentQueuedTurnsQueryKey } from '~/data-provider/SSE/queuedTurns';
 import useSteerConvert from '~/hooks/Chat/useSteerConvert';
+import { revealedQueuedTurnFamily } from '~/store/steer';
+import { useFileMapContext } from '~/Providers';
 import store from '~/store';
 
 /**
@@ -257,6 +261,7 @@ export default function useResumeOnLoad(
   runIndex = 0,
   messagesLoaded = true,
 ) {
+  const fileMap = useFileMapContext();
   const jotaiStore = useStore();
   const queryClient = useQueryClient();
   const setSubmission = useSetRecoilState(store.submissionByIndex(runIndex));
@@ -353,13 +358,18 @@ export default function useResumeOnLoad(
               const keepLocalPreempt =
                 (localChip?.preemptRevision ?? 0) > (steer.preemptRevision ?? 0);
               const chipGenerationCreatedAt = generationCreatedAt ?? localChip?.generationCreatedAt;
+              const restoredFiles = hydrateFileDeliveryMetadata(
+                steer.files,
+                localChip?.files,
+                fileMap,
+              );
               return {
                 steerId: steer.steerId,
                 ...(steer.clientSteerId && { clientSteerId: steer.clientSteerId }),
                 text: steer.text,
                 status: 'pending' as const,
                 createdAt: steer.createdAt ?? Date.now(),
-                ...(steer.files && steer.files.length > 0 && { files: steer.files }),
+                ...(restoredFiles && restoredFiles.length > 0 && { files: restoredFiles }),
                 ...((keepLocalPreempt ? localChip?.preempt : steer.preempt) === true && {
                   preempt: true,
                 }),
@@ -384,7 +394,7 @@ export default function useResumeOnLoad(
           ];
         });
       },
-    [],
+    [fileMap],
   );
 
   const settleAppliedSteerParts = useRecoilCallback(
@@ -754,6 +764,17 @@ export default function useResumeOnLoad(
            *  and finished inside a poll gap, its turns are on the server and
            *  nowhere else; one refetch is the whole repair, and marking an
            *  off-screen conversation stale costs nothing until it is opened. */
+          const revealFamily = revealedQueuedTurnFamily(owedConversationId);
+          const pendingReveal = jotaiStore.get(revealFamily);
+          if (
+            pendingReveal != null &&
+            Date.parse(pendingReveal.revealedAt) <= latch.quietSince! &&
+            !isQueuedTurnSuccessorOwed(
+              queryClient.getQueryData(agentQueuedTurnsQueryKey(owedConversationId)),
+            )
+          ) {
+            jotaiStore.set(revealFamily, null);
+          }
           queryClient.invalidateQueries({ queryKey: [QueryKeys.messages, owedConversationId] });
         }, remaining),
       );
@@ -775,7 +796,7 @@ export default function useResumeOnLoad(
         clearTimeout(timer);
       }
     };
-  }, [owedSuccessors, owedIsReporting, conversationId, queryClient]);
+  }, [owedSuccessors, owedIsReporting, conversationId, queryClient, jotaiStore]);
 
   const shouldCheck =
     resumableEnabled &&
@@ -897,6 +918,30 @@ export default function useResumeOnLoad(
 
     if (!streamStatus.active || !streamStatus.streamId) {
       console.log('[ResumeOnLoad] No active job to resume for:', conversationId);
+      const revealFamily = revealedQueuedTurnFamily(conversationId);
+      const pendingReveal = jotaiStore.get(revealFamily);
+      /** A remounted pane may have missed attachment and the quiet-window
+       * timer. An expired job has no epoch; require a fresh inactive read
+       * after restored history before retiring its surviving handoff guard. */
+      const historyUpdatedAt = queryClient.getQueryState([
+        QueryKeys.messages,
+        conversationId,
+      ])?.dataUpdatedAt;
+      if (
+        pendingReveal != null &&
+        streamStatus.active === false &&
+        streamStatus.createdAt == null &&
+        historyUpdatedAt != null &&
+        streamStatusUpdatedAt >= historyUpdatedAt &&
+        streamStatusUpdatedAt > Date.parse(pendingReveal.revealedAt) &&
+        !isQueuedTurnSuccessorOwed(queuedTurnReceipts) &&
+        (getMessages() ?? []).some(
+          (message) => message.parentMessageId === pendingReveal.parentMessageId,
+        )
+      ) {
+        jotaiStore.set(revealFamily, null);
+      }
+
       // A terminal drain may have parked acknowledged steers no subscriber
       // received (tab closed / reload racing the final event) — the status
       // claim returns them exactly once; restore as queued follow-up chips.
@@ -1027,6 +1072,8 @@ export default function useResumeOnLoad(
     isFetching,
     streamStatus,
     streamStatusUpdatedAt,
+    queuedTurnReceipts,
+    queryClient,
     getMessages,
     setSubmission,
     setSubmissionStart,
diff --git a/client/src/locales/en/translation.json b/client/src/locales/en/translation.json
index 64de2fe31b1..446501702ba 100644
--- a/client/src/locales/en/translation.json
+++ b/client/src/locales/en/translation.json
@@ -1089,6 +1089,7 @@
   "com_ui_attach_error_size": "File size limit exceeded for endpoint:",
   "com_ui_attach_error_total_size": "Total file size limit exceeded for endpoint:",
   "com_ui_attach_error_type": "Unsupported file type for endpoint:",
+  "com_error_files_provider_audio_format": "This audio format cannot be attached directly to this model. Convert the file to WAV or MP3 and upload it again, or choose Upload as Text if transcription is configured.",
   "com_ui_attach_remove": "Remove file",
   "com_ui_attach_warn_endpoint": "Non-Assistant files may be ignored without a compatible tool",
   "com_ui_attached_image": "Attached image",
@@ -1995,6 +1996,7 @@
   "com_ui_queued_quote_count": "{{0}} quoted excerpts included with this message",
   "com_ui_queued_turn_failed": "Queued message failed",
   "com_ui_queued_turn_reconciliation_required": "Awaiting reconciliation",
+  "com_ui_queued_turn_starting": "Starting as the next turn",
   "com_ui_quote_selections": "{{0}} selections",
   "com_ui_quotes_queued": "Quotes added for your next message",
   "com_ui_ran_n_actions": "Ran {{0}} actions",
diff --git a/client/src/store/families.ts b/client/src/store/families.ts
index 3bfb45ec9d7..b66a5552910 100644
--- a/client/src/store/families.ts
+++ b/client/src/store/families.ts
@@ -510,6 +510,8 @@ export type RunEnd = {
   endedAt: number;
   /** Exact terminal epoch whose idle transition may release one queued start. */
   generationCreatedAt?: number;
+  /** The completed run's response, which a revealed queued follow-up parents to. */
+  responseMessageId?: string;
   /** Armed "Interrupt & send" flag traveling with a PARKED signal, so
    *  another run on the same pane can neither consume nor clear it. */
   interruptArmed?: boolean;
diff --git a/client/src/store/steer.ts b/client/src/store/steer.ts
index d0c152f483a..87a1298949d 100644
--- a/client/src/store/steer.ts
+++ b/client/src/store/steer.ts
@@ -1,5 +1,6 @@
 import { atom } from 'jotai';
 import { atomFamily } from 'jotai/utils';
+import type { TMessage } from 'librechat-data-provider';
 
 /**
  * Measured pixel height of the in-flight steer overlay for a conversation.
@@ -20,3 +21,26 @@ export const steerOverlayHeightFamily = atomFamily((_conversationId: string) =>
  * and the chip-derived check cannot see an arm until its response lands.
  */
 export const escalatingSteerFamily = atomFamily((_conversationId: string) => atom<boolean>(false));
+
+/** A server-owned follow-up and its admission handoff, keyed by conversation.
+ * The drawing never enters history. Its guard survives the drawing until a
+ * successor generation owns the pane or terminal evidence settles the turn. */
+export type RevealedQueuedTurn = {
+  clientRequestId: string;
+  /** The drawing follows this response only while history has no successor. */
+  parentMessageId: string;
+  /** Completion boundary, advanced as later queued turns are admitted. */
+  generationCreatedAt?: number;
+  /** Immutable queue lineage, independent of the display/completion boundary. */
+  queueParentMessageId?: string;
+  queuePredecessorCreatedAt?: number;
+  text: string;
+  files?: TMessage['files'];
+  quotes?: string[];
+  manualSkills?: string[];
+  revealedAt: string;
+};
+
+export const revealedQueuedTurnFamily = atomFamily((_conversationId: string) =>
+  atom<RevealedQueuedTurn | null>(null),
+);
diff --git a/client/src/utils/__tests__/getViableUploadOptions.spec.ts b/client/src/utils/__tests__/getViableUploadOptions.spec.ts
index 261ea70e401..6d2ea63580d 100644
--- a/client/src/utils/__tests__/getViableUploadOptions.spec.ts
+++ b/client/src/utils/__tests__/getViableUploadOptions.spec.ts
@@ -132,6 +132,33 @@ describe('getViableUploadOptions', () => {
       expect(getViableUploadOptions([file(XLSX, 'report.xlsx')], ctx)).toEqual([undefined]);
     });
 
+    it('offers direct attach for a video when the custom config explicitly allows video', () => {
+      const ctx = baseCtx({
+        provider: 'MyGateway',
+        endpoint: 'MyGateway',
+        endpointType: 'custom',
+        fileSearchEnabled: false,
+        codeEnabled: false,
+        contextEnabled: false,
+        endpointSupportedMimeTypes: [/^image\/.*$/, /^application\/pdf$/, /^video\/.*$/],
+      });
+      expect(getViableUploadOptions([file('video/mp4', 'clip.mp4')], ctx)).toEqual([undefined]);
+      expect(getViableUploadOptions([file('audio/wav', 'tone.wav')], ctx)).toEqual([]);
+    });
+
+    it('does not offer video for a custom endpoint that inherits the default config', () => {
+      const ctx = baseCtx({
+        provider: 'MyGateway',
+        endpoint: 'MyGateway',
+        endpointType: 'custom',
+        fileSearchEnabled: false,
+        codeEnabled: false,
+        contextEnabled: false,
+        endpointSupportedMimeTypes: undefined,
+      });
+      expect(getViableUploadOptions([file('video/mp4', 'clip.mp4')], ctx)).toEqual([]);
+    });
+
     it('does not treat a non-permissive custom config as broad provider support', () => {
       const ctx = baseCtx({
         provider: 'MyGateway',
diff --git a/client/src/utils/files.ts b/client/src/utils/files.ts
index 62e77dacafd..5692905d666 100644
--- a/client/src/utils/files.ts
+++ b/client/src/utils/files.ts
@@ -16,13 +16,14 @@ import {
   EModelEndpoint,
   retrievalMimeTypes,
   isBedrockDocumentType,
-  isPermissiveMimeConfig,
+  isExplicitMimeConfig,
   codeInterpreterMimeTypes,
   isDocumentSupportedProvider,
   fileConfig as defaultFileConfig,
 } from 'librechat-data-provider';
 import type {
   TFile,
+  TMessage,
   DeleteFilesResponse,
   EndpointFileConfig,
   FileConfig,
@@ -34,6 +35,45 @@ import type { ExtendedFile } from '~/common';
 
 export const partialTypes = ['text/x-'];
 
+/** Text-routed images use the file action so their extracted preview is reachable. */
+export function usesImagePreview(file: Partial<Pick<TFile, 'type' | 'llmDeliveryPath'>>): boolean {
+  return file.type?.startsWith('image/') === true && file.llmDeliveryPath !== 'text';
+}
+
+export type FileDeliveryMetadataMap = Readonly<
+  Record<string, Pick<TFile, 'llmDeliveryPath'> | undefined>
+>;
+
+/** Restores display-only delivery metadata that an older replica may have
+ * omitted from a persisted attachment ref. The persisted ref wins, followed
+ * by the matching process-local ref, then the owner-scoped stored file map. */
+export function hydrateFileDeliveryMetadata(
+  persistedFiles: TMessage['files'],
+  localFiles?: TMessage['files'],
+  storedFiles?: FileDeliveryMetadataMap,
+): TMessage['files'] {
+  if (persistedFiles == null || persistedFiles.length === 0) {
+    return persistedFiles;
+  }
+  const localById = new Map(
+    (localFiles ?? []).flatMap((file) =>
+      file.file_id != null ? [[file.file_id, file] as const] : [],
+    ),
+  );
+  let changed = false;
+  const hydrated = persistedFiles.map((file) => {
+    const local = file.file_id == null ? undefined : localById.get(file.file_id);
+    const stored = file.file_id == null ? undefined : storedFiles?.[file.file_id];
+    const llmDeliveryPath = local?.llmDeliveryPath ?? stored?.llmDeliveryPath;
+    if (file.llmDeliveryPath != null || llmDeliveryPath == null) {
+      return file;
+    }
+    changed = true;
+    return { ...file, llmDeliveryPath };
+  });
+  return changed ? hydrated : persistedFiles;
+}
+
 export function hasIncompleteFiles(files: Map<string, ExtendedFile>): boolean {
   for (const file of files.values()) {
     if (file.progress < 1) {
@@ -522,12 +562,12 @@ const isProviderAttachType = (type: string, ctx: UploadOptionContext): boolean =
     isDocumentSupportedProvider(currentProvider) ||
     isAzureWithResponsesApi
   ) {
-    /** Custom endpoints that the admin opened up (permissive config) honor that allowlist,
-     * matching the file picker; an inherited default config is not treated as opened up. */
+    /** Custom endpoints with an admin-configured allowlist honor it for direct attach (this is
+     * how video/audio get opted in for an OpenAI-compatible gateway), matching the file picker
+     * and the server-side encoders; an inherited default config is not treated as opened up. */
     if (
       ctx.endpointType === EModelEndpoint.custom &&
-      ctx.endpointSupportedMimeTypes != null &&
-      isPermissiveMimeConfig(ctx.endpointSupportedMimeTypes)
+      isExplicitMimeConfig(ctx.endpointSupportedMimeTypes)
     ) {
       return checkType(type, ctx.endpointSupportedMimeTypes);
     }
diff --git a/e2e/specs/mock/queued-reveal.spec.ts b/e2e/specs/mock/queued-reveal.spec.ts
new file mode 100644
index 00000000000..ce6e07dda51
--- /dev/null
+++ b/e2e/specs/mock/queued-reveal.spec.ts
@@ -0,0 +1,217 @@
+import { expect, test } from '@playwright/test';
+import type { Page, Route } from '@playwright/test';
+import type { AgentDetail } from './agents.helpers';
+import { cleanupAgent, openAgentBuilder, uniqueAgentName } from './agents.helpers';
+import {
+  MOCK_ENDPOINTS,
+  MOCK_REPLY_TEXT,
+  NEW_CHAT_PATH,
+  messagesView,
+  replyPrompt,
+  replyText,
+  getAccessToken,
+  requestJson,
+  sendMessage,
+} from './helpers';
+
+/** Last chunk streamed by the fake model's slow replies (160 chunks, 0-indexed). */
+const SLOW_REPLY_LAST_CHUNK = 'chunk-159';
+
+const uniqueLabel = (prefix: string) =>
+  `${prefix}-${Date.now()}-${Math.floor(Math.random() * 1e4)}`;
+
+const messageInput = (page: Page) => page.getByRole('textbox', { name: 'Message input' });
+const duringRunSendButton = (page: Page) => page.getByTestId('during-run-send-button');
+const queuedRows = (page: Page) => page.getByTestId('queued-message-row');
+const messageTurns = (page: Page) => messagesView(page).locator('.message-render');
+
+const RECEIPTS_ROUTE = /\/api\/agents\/chat\/queued-turns\?/;
+const STATUS_ROUTE = /\/api\/agents\/chat\/status\//;
+
+type ReceiptsBody = { queuedTurns?: Array<{ status?: string }> };
+type StatusBody = { active?: boolean; resumeState?: { userMessage?: { text?: string } } };
+
+/**
+ * Reproduces production timing inside the mock lane. Here the backend admits a
+ * queued turn within milliseconds, so the predecessor's terminal reconcile
+ * already sees the successor in stream status and hands off to it at once. A
+ * real deployment admits later, and the client then learns of the successor
+ * only through the receipt projection and the status it re-arms. While held
+ * back, the receipts stay frozen at their pre-admission snapshot and a status
+ * that describes the successor reads as inactive, so the next user turn can
+ * only come from the completion event itself. Every other request, including
+ * the predecessor's own terminal status, passes through untouched.
+ */
+function holdBackSuccessor(page: Page, successorText: string) {
+  let holding = false;
+  let frozenReceipts: ReceiptsBody | null = null;
+  const receipts = async (route: Route) => {
+    const response = await route.fetch();
+    if (response.status() !== 200) {
+      return route.fulfill({ response });
+    }
+    const body = (await response.json()) as ReceiptsBody;
+    if (!holding) {
+      frozenReceipts = body;
+      return route.fulfill({ response, json: body });
+    }
+    return route.fulfill({ response, json: frozenReceipts ?? body });
+  };
+  const status = async (route: Route) => {
+    const response = await route.fetch();
+    if (!holding || response.status() !== 200) {
+      return route.fulfill({ response });
+    }
+    const body = (await response.json()) as StatusBody;
+    const describesSuccessor =
+      body.active === true && body.resumeState?.userMessage?.text === successorText;
+    return route.fulfill({
+      response,
+      json: describesSuccessor ? { active: false } : body,
+    });
+  };
+  return {
+    arm: async () => {
+      await page.route(RECEIPTS_ROUTE, receipts);
+      await page.route(STATUS_ROUTE, status);
+    },
+    hold: () => {
+      holding = true;
+    },
+    release: async () => {
+      holding = false;
+      await page.unroute(RECEIPTS_ROUTE, receipts);
+      await page.unroute(STATUS_ROUTE, status);
+    },
+  };
+}
+
+async function createAgent(page: Page, token: string, name: string): Promise<AgentDetail> {
+  return requestJson<AgentDetail>(page, {
+    path: '/api/agents',
+    token,
+    method: 'POST',
+    body: {
+      name,
+      description: 'Playwright verification of the queued follow-up reveal.',
+      instructions: 'Follow the deterministic end-to-end request exactly.',
+      provider: MOCK_ENDPOINTS[0].label,
+      model: MOCK_ENDPOINTS[0].model,
+    },
+  });
+}
+
+async function selectAgent(page: Page, name: string): Promise<void> {
+  const form = await openAgentBuilder(page);
+  await form.getByRole('combobox', { name: 'Agent', exact: true }).click();
+  await page.getByRole('option', { name }).click();
+  await expect(form.getByLabel('Agent name')).toHaveValue(name);
+  await form.getByRole('button', { name: 'Select Agent' }).click();
+}
+
+async function establishConversation(page: Page, label: string) {
+  const setup = await sendMessage(page, replyPrompt(label));
+  expect(setup.ok()).toBeTruthy();
+  await expect(messagesView(page).getByText(replyText(label))).toBeVisible({ timeout: 30000 });
+  await expect(page).toHaveURL(/\/c\/[0-9a-fA-F-]{36}$/, { timeout: 15000 });
+}
+
+async function typeDuringRun(page: Page, text: string) {
+  const input = messageInput(page);
+  await input.click();
+  await input.fill(text);
+  await expect(duringRunSendButton(page)).toBeVisible({ timeout: 5000 });
+}
+
+test.describe('server-queued follow-up reveal', () => {
+  test('shows the queued follow-up as the next user turn the moment the run completes', async ({
+    page,
+  }) => {
+    test.setTimeout(120000);
+    const label = uniqueLabel('queue-reveal');
+    const queueText = `Queued reveal ${label}`;
+    let agentId: string | undefined;
+
+    try {
+      await page.goto(NEW_CHAT_PATH, { timeout: 10000 });
+      const token = await getAccessToken(page);
+      const agent = await createAgent(page, token, uniqueAgentName('E2E Queue Reveal Agent'));
+      agentId = agent.id;
+      await selectAgent(page, agent.name);
+      await establishConversation(page, `queue-reveal-setup-${label}`);
+
+      const successor = holdBackSuccessor(page, queueText);
+      await successor.arm();
+
+      const run = await sendMessage(page, `E2E_SLOW_REPLY:${label}`);
+      expect(run.ok()).toBeTruthy();
+
+      await typeDuringRun(page, queueText);
+      /** Agent conversations queue on the server: the row is only eligible for
+       *  the reveal once the durable enqueue has been acknowledged. */
+      const [enqueued] = await Promise.all([
+        page.waitForResponse(
+          (response) =>
+            response.request().method() === 'POST' &&
+            new URL(response.url()).pathname === '/api/agents/chat/queued-turns',
+          { timeout: 10000 },
+        ),
+        messageInput(page).press('ControlOrMeta+Enter'),
+      ]);
+      expect(enqueued.ok()).toBeTruthy();
+      const row = queuedRows(page).filter({ hasText: queueText });
+      await expect(row).toBeVisible({ timeout: 10000 });
+      successor.hold();
+
+      const predecessor = messageTurns(page).nth(3);
+      await expect(predecessor).toContainText(SLOW_REPLY_LAST_CHUNK, { timeout: 60000 });
+
+      const queuedTurn = messageTurns(page).nth(4);
+      await expect(queuedTurn).toContainText(queueText, { timeout: 5000 });
+      await expect(queuedTurn.locator('.user-turn')).toBeVisible();
+      /** The chip stays only as a way to retract the turn until it is admitted. */
+      await expect(row).toContainText('Starting as the next turn');
+      await expect(row.getByRole('button', { name: 'Send now' })).toHaveCount(0);
+      await expect(row.getByRole('button', { name: 'Remove message' })).toBeVisible();
+
+      const nextQueueText = `Queued during handoff ${label}`;
+      await messageInput(page).fill(nextQueueText);
+      const [handoffEnqueue] = await Promise.all([
+        page.waitForResponse(
+          (response) =>
+            response.request().method() === 'POST' &&
+            new URL(response.url()).pathname === '/api/agents/chat/queued-turns',
+        ),
+        messageInput(page).press('Enter'),
+      ]);
+      expect(handoffEnqueue.ok()).toBeTruthy();
+      const originalQueue = enqueued.request().postDataJSON();
+      expect(handoffEnqueue.request().postDataJSON()).toMatchObject({
+        parentMessageId: originalQueue.parentMessageId,
+        expectedPredecessorCreatedAt: originalQueue.expectedPredecessorCreatedAt,
+      });
+      await successor.release();
+
+      /** Once the successor attaches, the shown row is the server's own turn:
+       *  exactly one copy of the text, followed by its reply. */
+      await expect(messageTurns(page)).toHaveCount(8, { timeout: 30000 });
+      await expect(messageTurns(page).filter({ hasText: queueText })).toHaveCount(1);
+      const followupReply = messageTurns(page).nth(5);
+      await expect(followupReply).toContainText(MOCK_REPLY_TEXT, { timeout: 30000 });
+      await expect(followupReply.locator('.agent-turn')).toBeVisible();
+      await expect(queuedRows(page)).toHaveCount(0);
+
+      /** The turn ran and was persisted, not merely shown. */
+      const conversationPath = new URL(page.url()).pathname;
+      await page.reload({ waitUntil: 'domcontentloaded' });
+      await expect(page).toHaveURL(conversationPath);
+      await expect(messageTurns(page)).toHaveCount(8, { timeout: 30000 });
+      await expect(messageTurns(page).nth(4)).toContainText(queueText);
+      await expect(messageTurns(page).nth(5)).toContainText(MOCK_REPLY_TEXT);
+      await expect(messageTurns(page).nth(6)).toContainText(nextQueueText);
+      await expect(messageTurns(page).nth(7)).toContainText(MOCK_REPLY_TEXT);
+    } finally {
+      await cleanupAgent(page, agentId);
+    }
+  });
+});
diff --git a/librechat.example.yaml b/librechat.example.yaml
index a114cd30576..dc77303721e 100644
--- a/librechat.example.yaml
+++ b/librechat.example.yaml
@@ -1084,6 +1084,12 @@ endpoints:
 #     tokens: 2000 # Also preserve up to this many recent tokens
 
 # fileConfig:
+#   # Store best-effort text for inferred tool-routed message attachments. On each turn,
+#   # deliver it only if no available tool can read the type. Off by default; also configurable
+#   # under endpoints.default or a provider/custom endpoint name. Explicit destinations stand.
+#   # Existing files without extracted text are not backfilled. Paused runs retain encoded text
+#   # and conservatively count referenced fallback text against current limits on resume.
+#   textFallbackWithoutTools: false
 #   fileContextSizeLimit: 128  # Maximum aggregate model-bound attachment size in one agent turn (MB)
 #   fileContextCharLimit: 1000000  # Maximum aggregate extracted-text characters in one agent turn
 #   endpoints:
diff --git a/package-lock.json b/package-lock.json
index cec8d0287dd..35f5ed7c84d 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -64,7 +64,7 @@
         "@azure/storage-blob": "^12.30.0",
         "@google/genai": "^2.8.0",
         "@keyv/redis": "5.1.6",
-        "@librechat/agents": "^3.8.6",
+        "@librechat/agents": "^3.8.7",
         "@librechat/api": "*",
         "@librechat/data-schemas": "*",
         "@microsoft/microsoft-graph-client": "^3.0.7",
@@ -10619,9 +10619,9 @@
       }
     },
     "node_modules/@librechat/agents": {
-      "version": "3.8.6",
-      "resolved": "https://registry.npmjs.org/@librechat/agents/-/agents-3.8.6.tgz",
-      "integrity": "sha512-9Oar3pfwdJTWm7ppIjRL0SrE38PhHj9r/NsxwMkydVppFGXX1ISWYFGjmvA+XlCdUO/Wv1fVW6wZ6IWlFHfH6g==",
+      "version": "3.8.7",
+      "resolved": "https://registry.npmjs.org/@librechat/agents/-/agents-3.8.7.tgz",
+      "integrity": "sha512-yIO/SnWakpKXLzaRCNJfaai0emp22cD7mO8ffzu8gDyIVTzK0jaoG1nrr0+PoVkIeK/piKb+QJEyobPecGX6fg==",
       "license": "MIT",
       "dependencies": {
         "@anthropic-ai/sdk": "^0.115.0",
@@ -42416,7 +42416,7 @@
         "@azure/storage-blob": "^12.30.0",
         "@google/genai": "^2.8.0",
         "@keyv/redis": "5.1.6",
-        "@librechat/agents": "^3.8.6",
+        "@librechat/agents": "^3.8.7",
         "@librechat/data-schemas": "*",
         "@modelcontextprotocol/sdk": "^1.30.0",
         "@opentelemetry/api": "^1.9.0",
diff --git a/packages/api/package.json b/packages/api/package.json
index de1272e6904..9529ee0ff2c 100644
--- a/packages/api/package.json
+++ b/packages/api/package.json
@@ -115,7 +115,7 @@
     "@azure/storage-blob": "^12.30.0",
     "@google/genai": "^2.8.0",
     "@keyv/redis": "5.1.6",
-    "@librechat/agents": "^3.8.6",
+    "@librechat/agents": "^3.8.7",
     "@librechat/data-schemas": "*",
     "@modelcontextprotocol/sdk": "^1.30.0",
     "@opentelemetry/api": "^1.9.0",
diff --git a/packages/api/src/agents/__tests__/initialize.test.ts b/packages/api/src/agents/__tests__/initialize.test.ts
index 51ea605bab7..a6792435b80 100644
--- a/packages/api/src/agents/__tests__/initialize.test.ts
+++ b/packages/api/src/agents/__tests__/initialize.test.ts
@@ -133,6 +133,7 @@ jest.mock('../../middleware/modelBoundContent', () => {
 });
 
 import { initializeAgent } from '../initialize';
+import { primeResources } from '../resources';
 import { isFatalAgentInitializationError } from '../errors';
 
 const realUtils = jest.requireActual<typeof import('~/utils')>('~/utils');
@@ -1655,7 +1656,7 @@ describe('initializeAgent — attachment scoping', () => {
     expect(db.updateFilesUsage).not.toHaveBeenCalled();
     expect(primeResources).not.toHaveBeenCalled();
     expect(loadTools).not.toHaveBeenCalled();
-    expect(mockGetProviderConfig).not.toHaveBeenCalled();
+    expect(mockGetProviderConfig).toHaveBeenCalledTimes(1);
   });
 });
 
@@ -2910,6 +2911,7 @@ describe('initializeAgent — execute_code capability expansion', () => {
           environmentId: 'personal-vm',
           workspaceId: 'project-a',
           operations: ['read_file', 'list_files', 'execute_command'],
+          environment: { fingerprint: 'a'.repeat(64), repo: 'owner/project', actions: ['check'] },
         },
       };
       if (protectedEdit) codeExecutionContext.codeWorkspace!.operations.push('edit_file');
@@ -2944,6 +2946,11 @@ describe('initializeAgent — execute_code capability expansion', () => {
         'read_file',
       ]);
       const bashTool = result.toolDefinitions?.find(({ name }) => name === 'bash_tool');
+      expect(bashTool?.parameters).toMatchObject({
+        properties: { environmentAction: { enum: ['check'] } },
+        required: [],
+      });
+      expect(bashTool?.description).toContain('owner/project');
       expect(
         (bashTool?.parameters as { properties?: { timeoutMs?: { maximum?: number } } })?.properties
           ?.timeoutMs?.maximum,
@@ -4493,3 +4500,352 @@ describe('initializeAgent — provider-native web search role gate', () => {
     expect(result.tools).toContainEqual(OPENAI_SEARCH);
   });
 });
+
+describe('initializeAgent tool-routed text fallback', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  const routedCsv = () =>
+    ({
+      file_id: 'csv-file',
+      filename: 'sales.csv',
+      type: 'text/csv',
+      text: 'region,total',
+      llmDeliveryPath: 'none',
+      metadata: { destinationChosen: false },
+    }) as IMongoFile;
+
+  async function initializeWith({
+    tools,
+    csv,
+    textFallbackWithoutTools = true,
+    provider = Providers.OPENAI,
+    overrideProvider,
+    supportedMimeTypes,
+    softFailure = false,
+    fileSearchAvailable = true,
+    fileContextCharLimit,
+    useResponsesApi,
+  }: {
+    tools: string[];
+    csv: IMongoFile;
+    textFallbackWithoutTools?: boolean;
+    provider?: string;
+    overrideProvider?: string;
+    supportedMimeTypes?: string[];
+    softFailure?: boolean;
+    fileSearchAvailable?: boolean;
+    fileContextCharLimit?: number;
+    useResponsesApi?: boolean;
+  }) {
+    const { filterFilesByEndpointRuntimeConfig } = jest.requireMock('~/files') as {
+      filterFilesByEndpointRuntimeConfig: jest.Mock;
+    };
+    const { agent, req, res, loadTools, db } = createMocks({
+      provider,
+      overrideProvider,
+      loadedToolDefinitions: tools.includes(EToolResources.file_search)
+        ? [{ name: EToolResources.file_search }]
+        : [],
+    });
+    if (useResponsesApi != null) {
+      mockGetProviderConfig.mockReturnValue({
+        overrideProvider: overrideProvider ?? provider,
+        getOptions: jest
+          .fn()
+          .mockResolvedValue({ llmConfig: { model: agent.model, useResponsesApi } }),
+      });
+    }
+    (primeResources as jest.Mock).mockImplementationOnce(async ({ attachments }) => {
+      const files = await attachments;
+      return {
+        attachments: files,
+        requestAttachments: files,
+        agentContextAttachments: [],
+        tool_resources: {},
+      };
+    });
+    agent.tools = tools;
+    if (softFailure) loadTools.mockResolvedValue(undefined);
+    req.config = {
+      fileConfig: {
+        fileContextCharLimit,
+        endpoints: {
+          [provider]: {
+            defaultLLMDeliveryPath: { overrides: { 'text/csv': 'none' } },
+            textFallbackWithoutTools,
+            ...(supportedMimeTypes != null && { supportedMimeTypes }),
+          },
+        },
+      },
+    } as unknown as ServerRequest['config'];
+    (db.getFiles as jest.Mock).mockResolvedValueOnce([csv]);
+    filterFilesByEndpointRuntimeConfig.mockImplementationOnce(
+      (_config: ServerRequest['config'], { files }: { files: IMongoFile[] }) => files,
+    );
+
+    const result = await initializeAgent(
+      {
+        req,
+        res,
+        agent,
+        loadTools,
+        requestFiles: [csv],
+        codeEnvAvailable: true,
+        fileSearchAvailable,
+        endpointOption: { endpoint: EModelEndpoint.agents },
+        allowedProviders: new Set([provider]),
+        isInitialAgent: true,
+      },
+      db,
+    );
+    return { result, filterFilesByEndpointRuntimeConfig };
+  }
+
+  it.each([true, false])(
+    'admits Azure PDFs with the final Responses mode %s',
+    async (useResponsesApi) => {
+      const pdf = { ...routedCsv(), type: 'application/pdf', text: undefined };
+      const { result, filterFilesByEndpointRuntimeConfig } = await initializeWith({
+        tools: [],
+        csv: pdf,
+        provider: EModelEndpoint.azureOpenAI,
+        overrideProvider: Providers.OPENAI,
+        useResponsesApi,
+      });
+      expect(result.deliveryRouting.useResponsesApi).toBe(useResponsesApi);
+      expect(filterFilesByEndpointRuntimeConfig).toHaveBeenCalledWith(
+        expect.anything(),
+        expect.objectContaining({
+          files: [{ ...pdf, llmDeliveryPath: useResponsesApi ? 'provider' : 'text' }],
+        }),
+      );
+    },
+  );
+
+  it('keeps fallback out of the prompt when file search loads successfully', async () => {
+    const csv = routedCsv();
+    const { result } = await initializeWith({ tools: [EToolResources.file_search], csv });
+    expect(result.fileConsumers).toEqual({ executeCode: false, fileSearch: true });
+    expect(result.requestAttachments).toEqual([csv]);
+  });
+
+  it('falls back after file search soft-fails and admits the returned text copy', async () => {
+    const csv = routedCsv();
+    const { result } = await initializeWith({
+      tools: [EToolResources.file_search],
+      csv,
+      softFailure: true,
+    });
+    expect(result.fileConsumers).toEqual({ executeCode: false, fileSearch: false });
+    expect(result.requestAttachments).toEqual([{ ...csv, llmDeliveryPath: 'text' }]);
+    expect(csv.llmDeliveryPath).toBe('none');
+  });
+
+  it('rejects fallback text that exceeds admission after a reader soft-fails', async () => {
+    await expect(
+      initializeWith({
+        tools: [EToolResources.file_search],
+        csv: routedCsv(),
+        softFailure: true,
+        fileContextCharLimit: 3,
+      }),
+    ).rejects.toMatchObject({ name: 'AgentAttachmentLimitError' });
+  });
+
+  it('hands endpoint filtering a text copy when the agent runs no tool that can read the file', async () => {
+    const csv = routedCsv();
+
+    const { result, filterFilesByEndpointRuntimeConfig } = await initializeWith({ tools: [], csv });
+
+    expect(filterFilesByEndpointRuntimeConfig).toHaveBeenCalledWith(
+      expect.anything(),
+      expect.objectContaining({ files: [{ ...csv, llmDeliveryPath: 'text' }] }),
+    );
+    expect(result.fileConsumers).toEqual({ executeCode: false, fileSearch: false });
+    expect(csv.llmDeliveryPath).toBe('none');
+  });
+
+  it('hands endpoint filtering the provider route a tool-routed file takes on this turn', async () => {
+    /* Admission reads the route, so a record left for tools that this endpoint sends to the
+     * provider must reach filtering, limits and inspection as a provider file. */
+    const image = {
+      file_id: 'image-file',
+      filename: 'chart.png',
+      type: 'image/png',
+      llmDeliveryPath: 'none',
+      metadata: { destinationChosen: false },
+    } as IMongoFile;
+
+    const { filterFilesByEndpointRuntimeConfig } = await initializeWith({
+      tools: [],
+      csv: image,
+    });
+
+    expect(filterFilesByEndpointRuntimeConfig).toHaveBeenCalledWith(
+      expect.anything(),
+      expect.objectContaining({ files: [{ ...image, llmDeliveryPath: 'provider' }] }),
+    );
+    expect(image.llmDeliveryPath).toBe('none');
+  });
+
+  it('keeps media a custom endpoint opted into on its provider route before the provider swap', async () => {
+    /* The encoders send OpenAI-format media to a custom endpoint that lists the type, so the
+     * route has to read that endpoint's dialect from config, not the name still in `provider`. */
+    const video = {
+      file_id: 'video-file',
+      filename: 'clip.mp4',
+      type: 'video/mp4',
+      llmDeliveryPath: 'provider',
+      metadata: { destinationChosen: false },
+    } as IMongoFile;
+
+    const { filterFilesByEndpointRuntimeConfig } = await initializeWith({
+      tools: [],
+      csv: video,
+      provider: 'MyGateway',
+      overrideProvider: Providers.OPENAI,
+      supportedMimeTypes: ['video/mp4'],
+    });
+
+    expect(filterFilesByEndpointRuntimeConfig).toHaveBeenCalledWith(
+      expect.anything(),
+      expect.objectContaining({ files: [video] }),
+    );
+  });
+
+  it('resolves a custom endpoint agent under the endpoint its upload was routed by', async () => {
+    /* Uploads resolve the agent's saved provider, which for a custom endpoint is its name.
+     * Initialization later swaps the provider for the backing client, so an opt-in set only
+     * on the custom endpoint must still be read under that name, here and after the swap. */
+    const csv = routedCsv();
+
+    const { result, filterFilesByEndpointRuntimeConfig } = await initializeWith({
+      tools: [],
+      csv,
+      provider: 'MyGateway',
+      overrideProvider: Providers.OPENAI,
+    });
+
+    expect(filterFilesByEndpointRuntimeConfig).toHaveBeenCalledWith(
+      expect.anything(),
+      expect.objectContaining({ files: [{ ...csv, llmDeliveryPath: 'text' }] }),
+    );
+    expect(result.provider).toBe(Providers.OPENAI);
+    expect(result.endpoint).toBe('MyGateway');
+  });
+
+  it('leaves the file on its tool route where the endpoint has not enabled the fallback', async () => {
+    const csv = routedCsv();
+
+    const { filterFilesByEndpointRuntimeConfig } = await initializeWith({
+      tools: [],
+      csv,
+      textFallbackWithoutTools: false,
+    });
+
+    expect(filterFilesByEndpointRuntimeConfig).toHaveBeenCalledWith(
+      expect.anything(),
+      expect.objectContaining({ files: [csv] }),
+    );
+  });
+
+  it('leaves the file to Run Code when the agent can run code', async () => {
+    const csv = routedCsv();
+
+    const { result, filterFilesByEndpointRuntimeConfig } = await initializeWith({
+      tools: [EToolResources.execute_code],
+      csv,
+    });
+
+    expect(filterFilesByEndpointRuntimeConfig).toHaveBeenCalledWith(
+      expect.anything(),
+      expect.objectContaining({ files: [csv] }),
+    );
+    expect(result.fileConsumers).toEqual({ executeCode: true, fileSearch: false });
+  });
+});
+
+describe('initializeAgent turn delivery routing', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('settles the routing once, after the provider swap and the Responses API decision', async () => {
+    const { agent, req, res, loadTools, db } = createMocks({ provider: 'MyClaude' });
+    req.config = {
+      fileConfig: { endpoints: { MyClaude: { supportedMimeTypes: ['video/mp4'] } } },
+      endpoints: { custom: [{ name: 'MyClaude', provider: 'anthropic' }] },
+    } as unknown as ServerRequest['config'];
+    mockGetProviderConfig.mockReturnValue({
+      overrideProvider: Providers.ANTHROPIC,
+      getOptions: jest
+        .fn()
+        .mockResolvedValue({ llmConfig: { model: 'test-model', useResponsesApi: true } }),
+    });
+
+    const result = await initializeAgent(
+      {
+        req,
+        res,
+        agent,
+        loadTools,
+        endpointOption: { endpoint: EModelEndpoint.agents },
+        allowedProviders: new Set(['MyClaude']),
+        isInitialAgent: true,
+      },
+      db,
+    );
+
+    expect(result.provider).toBe(Providers.ANTHROPIC);
+    expect(result.deliveryRouting).toMatchObject({
+      endpoint: 'MyClaude',
+      endpointProvider: 'anthropic',
+      useResponsesApi: true,
+      sttConfigured: false,
+    });
+    expect(result.deliveryRouting.endpointConfig.supportedMimeTypes).toEqual([/video\/mp4/]);
+  });
+
+  it('resolves the provider and its options before any attachment is loaded', async () => {
+    const { filterFilesByEndpointRuntimeConfig } = jest.requireMock('~/files') as {
+      filterFilesByEndpointRuntimeConfig: jest.Mock;
+    };
+    const { agent, req, res, loadTools, db } = createMocks();
+    const getOptions = jest.fn().mockResolvedValue({ llmConfig: { model: 'test-model' } });
+    mockGetProviderConfig.mockReturnValue({ overrideProvider: Providers.OPENAI, getOptions });
+    const file = {
+      file_id: 'file-1',
+      filename: 'notes.txt',
+      type: 'text/plain',
+      bytes: 10,
+      text: 'notes',
+      llmDeliveryPath: 'text',
+    } as IMongoFile;
+    (db.getFiles as jest.Mock).mockResolvedValueOnce([file]);
+    filterFilesByEndpointRuntimeConfig.mockImplementationOnce(
+      (_config: ServerRequest['config'], { files }: { files: IMongoFile[] }) => files,
+    );
+
+    await initializeAgent(
+      {
+        req,
+        res,
+        agent,
+        loadTools,
+        requestFiles: [file],
+        endpointOption: { endpoint: EModelEndpoint.agents },
+        allowedProviders: new Set([Providers.OPENAI]),
+        isInitialAgent: true,
+      },
+      db,
+    );
+
+    const [optionsOrder] = getOptions.mock.invocationCallOrder;
+    const [filesOrder] = (db.getFiles as jest.Mock).mock.invocationCallOrder;
+    const [toolsOrder] = loadTools.mock.invocationCallOrder;
+    expect(optionsOrder).toBeLessThan(filesOrder);
+    expect(filesOrder).toBeLessThan(toolsOrder);
+  });
+});
diff --git a/packages/api/src/agents/execution.spec.ts b/packages/api/src/agents/execution.spec.ts
index d281dbd4d2e..376da3583ac 100644
--- a/packages/api/src/agents/execution.spec.ts
+++ b/packages/api/src/agents/execution.spec.ts
@@ -391,6 +391,23 @@ describe('stateful code approval target binding', () => {
     ).not.toEqual(binding(original));
   });
 
+  it('requires new approval when an environment action definition changes', () => {
+    const original = context();
+    original.codeWorkspace!.environment = { fingerprint: 'a'.repeat(64), actions: ['typecheck'] };
+    const expected = captureCodeExecutionApprovalBinding([
+      { id: 'a', codeExecutionContext: original },
+    ]);
+    const updated = context({
+      codeWorkspace: {
+        ...original.codeWorkspace!,
+        environment: { fingerprint: 'b'.repeat(64), actions: ['typecheck'] },
+      },
+    });
+    expect(() =>
+      assertCodeExecutionApprovalBinding(expected, [{ id: 'a', codeExecutionContext: updated }]),
+    ).toThrow('changed while this action awaited approval');
+  });
+
   it('captures only opaque, canonical identities for stateful targets', () => {
     const binding = captureCodeExecutionApprovalBinding([
       {
diff --git a/packages/api/src/agents/execution.ts b/packages/api/src/agents/execution.ts
index 34473935407..65e01681766 100644
--- a/packages/api/src/agents/execution.ts
+++ b/packages/api/src/agents/execution.ts
@@ -4,6 +4,7 @@ import { Constants, getCodeBaseURL } from '@librechat/agents';
 import type {
   Agents,
   CodeWorkspaceOperation,
+  CodeWorkspaceDescriptor,
   CodeWorkspaceSelection,
   CodeEnvironmentUserConfigSchema,
   CodeEnvironmentUserSettings,
@@ -38,7 +39,10 @@ export interface CodeExecutionContext {
   codeEnvironmentConfigSchema?: CodeEnvironmentUserConfigSchema;
   codeEnvironmentSettings?: CodeEnvironmentUserSettings;
   /** Live, server-validated directory selection. Never derive session reuse from this field. */
-  codeWorkspace?: CodeWorkspaceSelection & { operations: CodeWorkspaceOperation[] };
+  codeWorkspace?: CodeWorkspaceSelection & {
+    operations: CodeWorkspaceOperation[];
+    environment?: CodeWorkspaceDescriptor['environment'];
+  };
 }
 
 /** Removes live capability data before a workspace binding is persisted. */
@@ -109,6 +113,9 @@ export function captureCodeExecutionApprovalBinding(
                 environmentId: context.codeWorkspace.environmentId,
                 workspaceId: context.codeWorkspace.workspaceId,
                 operations: [...new Set(context.codeWorkspace.operations)].sort(),
+                ...(context.codeWorkspace.environment
+                  ? { definitionFingerprint: context.codeWorkspace.environment.fingerprint }
+                  : {}),
               },
         ]),
       )
diff --git a/packages/api/src/agents/files/delivery.spec.ts b/packages/api/src/agents/files/delivery.spec.ts
new file mode 100644
index 00000000000..fb5c490daf1
--- /dev/null
+++ b/packages/api/src/agents/files/delivery.spec.ts
@@ -0,0 +1,291 @@
+import type { TurnFileConsumers, TurnDeliveryFile } from 'librechat-data-provider';
+import {
+  applyTurnDelivery as materializeTurnDelivery,
+  resolveTurnDeliveryRouting,
+  resolveScopedTurnAttachments,
+} from './delivery';
+
+function applyTurnDelivery<T extends TurnDeliveryFile>(
+  files: T[],
+  {
+    agent,
+    config,
+    consumers,
+  }: {
+    agent?: Parameters<typeof resolveTurnDeliveryRouting>[0]['agent'];
+    config?: Parameters<typeof resolveTurnDeliveryRouting>[0]['config'];
+    consumers?: TurnFileConsumers;
+  },
+) {
+  return materializeTurnDelivery(files, {
+    routing: agent ? resolveTurnDeliveryRouting({ agent, config }) : undefined,
+    consumers,
+  });
+}
+
+const config = {
+  fileConfig: {
+    endpoints: {
+      openAI: {
+        defaultLLMDeliveryPath: { overrides: { 'text/csv': 'none' as const } },
+        textFallbackWithoutTools: true,
+      },
+    },
+  },
+};
+const noReader: TurnFileConsumers = { executeCode: false, fileSearch: false };
+const runsCode: TurnFileConsumers = { executeCode: true, fileSearch: false };
+
+describe('resolveTurnDeliveryRouting', () => {
+  it('routes under the endpoint an agent names before its provider', () => {
+    expect(resolveTurnDeliveryRouting({ agent: { provider: 'openAI' }, config }).endpoint).toBe(
+      'openAI',
+    );
+    expect(
+      resolveTurnDeliveryRouting({
+        agent: { provider: 'openAI', endpoint: 'Azure Foundry' },
+        config,
+      }).endpoint,
+    ).toBe('Azure Foundry');
+  });
+
+  it('reads a custom endpoint dialect as upload does, before and after the provider swap', () => {
+    /* Initialization first stores the endpoint name in both fields and only later replaces the
+     * provider with the backing client, so the dialect has to come from config either way. */
+    const declared = {
+      ...config,
+      endpoints: {
+        custom: [{ name: 'MyClaude', provider: 'anthropic' }],
+      },
+    } as Parameters<typeof resolveTurnDeliveryRouting>[0]['config'];
+    const dialect = (agent: { provider: string; endpoint?: string }, routingConfig = declared) =>
+      resolveTurnDeliveryRouting({ agent, config: routingConfig }).endpointProvider;
+
+    expect(dialect({ provider: 'MyClaude', endpoint: 'MyClaude' })).toBe('anthropic');
+    expect(dialect({ provider: 'anthropic', endpoint: 'MyClaude' })).toBe('anthropic');
+    expect(dialect({ provider: 'MyGateway', endpoint: 'MyGateway' }, config)).toBeUndefined();
+    expect(dialect({ provider: 'openAI', endpoint: 'MyGateway' }, config)).toBeUndefined();
+  });
+
+  it('carries the agent Responses API choice into routing', () => {
+    expect(
+      resolveTurnDeliveryRouting({
+        agent: { provider: 'openAI', model_parameters: { useResponsesApi: true } },
+        config,
+      }).useResponsesApi,
+    ).toBe(true);
+  });
+});
+
+describe('applyTurnDelivery', () => {
+  const agent = { provider: 'openAI' };
+  const csv = {
+    file_id: 'csv',
+    type: 'text/csv',
+    text: 'region,total\nwest,4',
+    llmDeliveryPath: 'none',
+    metadata: { destinationChosen: false },
+  };
+  const pdf = { file_id: 'pdf', type: 'application/pdf', llmDeliveryPath: 'provider' };
+
+  it('marks a copy of each file this turn delivers as text, leaving the rest untouched', () => {
+    const result = applyTurnDelivery([csv, pdf], { agent, config, consumers: noReader });
+
+    expect(result[0]).toEqual({ ...csv, llmDeliveryPath: 'text' });
+    expect(result[0]).not.toBe(csv);
+    expect(result[1]).toBe(pdf);
+    expect(csv.llmDeliveryPath).toBe('none');
+  });
+
+  it('returns the same array when a tool this turn runs can read every file', () => {
+    const files = [csv, pdf];
+
+    expect(applyTurnDelivery(files, { agent, config, consumers: runsCode })).toBe(files);
+  });
+
+  it('marks nothing where the endpoint has not enabled the fallback', () => {
+    const files = [csv];
+    const disabled = {
+      fileConfig: {
+        endpoints: {
+          openAI: { defaultLLMDeliveryPath: { overrides: { 'text/csv': 'none' as const } } },
+        },
+      },
+    };
+
+    expect(applyTurnDelivery(files, { agent, config: disabled, consumers: noReader })).toBe(files);
+  });
+
+  it('reads the opt-in under the custom endpoint an initialized agent names', () => {
+    /* After initialization the provider is the backing client and the endpoint keeps the name
+     * the upload resolved, so a setting made only on that endpoint still applies. */
+    const files = [csv];
+    const customOnly = {
+      fileConfig: {
+        endpoints: {
+          MyGateway: {
+            defaultLLMDeliveryPath: { overrides: { 'text/csv': 'none' as const } },
+            textFallbackWithoutTools: true,
+          },
+        },
+      },
+    };
+
+    expect(
+      applyTurnDelivery(files, {
+        agent: { provider: 'openAI', endpoint: 'MyGateway' },
+        config: customOnly,
+        consumers: noReader,
+      }),
+    ).toEqual([{ ...csv, llmDeliveryPath: 'text' }]);
+  });
+
+  it('marks a stored tool-routed file the endpoint now routes to text, with the fallback off', () => {
+    /* Only this mark lets the admission checks and `extractFileContext`, which read the stored
+     * route, see the text the resolver now delivers. */
+    const rerouted = {
+      fileConfig: {
+        endpoints: {
+          openAI: { defaultLLMDeliveryPath: { overrides: { 'text/csv': 'text' as const } } },
+        },
+      },
+    };
+
+    expect(applyTurnDelivery([csv], { agent, config: rerouted, consumers: runsCode })).toEqual([
+      { ...csv, llmDeliveryPath: 'text' },
+    ]);
+    expect(applyTurnDelivery([csv], { agent, config: rerouted })).toEqual([
+      { ...csv, llmDeliveryPath: 'text' },
+    ]);
+  });
+
+  it('falls back only for a turn whose tools are known', () => {
+    const files = [csv];
+
+    expect(applyTurnDelivery(files, { agent, config })).toBe(files);
+  });
+
+  it('marks nothing without an agent to route by', () => {
+    const files = [csv];
+
+    expect(applyTurnDelivery(files, { config, consumers: noReader })).toBe(files);
+  });
+
+  it('leaves a record predating routing to its legacy handling', () => {
+    const files = [{ file_id: 'legacy', type: 'text/csv', text: 'region,total' }];
+
+    expect(applyTurnDelivery(files, { agent, config, consumers: noReader })).toBe(files);
+  });
+
+  it('does not mark a tool-routed file that stored no text', () => {
+    const files = [{ ...csv, text: undefined }];
+
+    expect(applyTurnDelivery(files, { agent, config, consumers: noReader })).toBe(files);
+  });
+
+  it('gives a stored tool-routed file the provider route this turn sends it by', () => {
+    /* Admission would otherwise skip a record the client then encodes for the provider. */
+    const image = {
+      file_id: 'image',
+      type: 'image/png',
+      llmDeliveryPath: 'none',
+      metadata: { destinationChosen: false },
+    };
+
+    expect(applyTurnDelivery([image], { agent, config, consumers: noReader })).toEqual([
+      { ...image, llmDeliveryPath: 'provider' },
+    ]);
+  });
+
+  it('removes a record this turn leaves to tools from model admission', () => {
+    /* Over-admitting cannot pass a limit; dropping a record the client still sends would. */
+    const files = [{ ...csv, llmDeliveryPath: 'text' }];
+
+    expect(applyTurnDelivery(files, { agent, config, consumers: runsCode })).toEqual([
+      { ...csv, llmDeliveryPath: 'none' },
+    ]);
+  });
+
+  it('materializes a final text route even without stored text', () => {
+    const files = [{ ...pdf, metadata: { destinationChosen: false } }];
+    const pdfToText = {
+      fileConfig: {
+        endpoints: {
+          openAI: { defaultLLMDeliveryPath: { overrides: { 'application/pdf': 'text' as const } } },
+        },
+      },
+    };
+
+    expect(applyTurnDelivery(files, { agent, config: pdfToText, consumers: noReader })).toEqual(
+      files.map((file) => ({ ...file, llmDeliveryPath: 'text' })),
+    );
+  });
+
+  it('does not mark a destination the user chose', () => {
+    const files = [{ ...csv, metadata: { destinationChosen: true } }];
+
+    expect(applyTurnDelivery(files, { agent, config, consumers: noReader })).toBe(files);
+  });
+});
+
+describe('resolveScopedTurnAttachments', () => {
+  const file = {
+    file_id: 'csv',
+    type: 'text/csv',
+    text: 'sales,total',
+    llmDeliveryPath: 'none' as const,
+    metadata: { destinationChosen: false },
+  };
+  const routing = resolveTurnDeliveryRouting({ agent: { provider: 'openAI' }, config });
+  const receiver = {
+    agentId: 'handoff',
+    agent: { deliveryRouting: routing, fileConsumers: noReader },
+  };
+
+  it.each([
+    ['explicit destination', { ...file, metadata: { destinationChosen: true } }, routing],
+    ['legacy destination', { ...file, llmDeliveryPath: undefined, metadata: undefined }, routing],
+    [
+      'disabled fallback',
+      file,
+      resolveTurnDeliveryRouting({
+        agent: { provider: 'openAI' },
+        config: {
+          fileConfig: {
+            endpoints: {
+              openAI: { ...config.fileConfig.endpoints.openAI, textFallbackWithoutTools: false },
+            },
+          },
+        },
+      }),
+    ],
+  ])('preserves %s when a receiver has no reader', (_name, candidate, deliveryRouting) => {
+    expect(
+      resolveScopedTurnAttachments({
+        agents: [{ ...receiver, agent: { ...receiver.agent, deliveryRouting } }],
+        sharedConversationAgentIds: ['handoff'],
+        messages: [],
+        requestAttachments: [candidate],
+        sharedRunAttachmentIds: new Set(),
+      }).get('handoff'),
+    ).toEqual([]);
+  });
+
+  it('ignores unhydrated and no-longer-retained history and deduplicates shared prompt files', () => {
+    const stale = { ...file, file_id: 'stale' };
+    const unhydrated = { file_id: 'unhydrated', text: 'untrusted' };
+    expect(
+      resolveScopedTurnAttachments({
+        agents: [receiver],
+        sharedConversationAgentIds: ['handoff'],
+        messages: [{ files: [unhydrated, { file_id: 'csv' }] }],
+        historicalFiles: new Map([
+          [file.file_id, file],
+          [stale.file_id, stale],
+        ]),
+        requestAttachments: [file],
+        sharedRunAttachmentIds: new Set(['csv']),
+      }).get('handoff'),
+    ).toEqual([]);
+  });
+});
diff --git a/packages/api/src/agents/files/delivery.ts b/packages/api/src/agents/files/delivery.ts
new file mode 100644
index 00000000000..97dc85e80ac
--- /dev/null
+++ b/packages/api/src/agents/files/delivery.ts
@@ -0,0 +1,153 @@
+import {
+  mergeFileConfig,
+  getEndpointFileConfig,
+  resolveUseResponsesApi,
+  getCustomEndpointProvider,
+  isSpeechProviderConfigured,
+  resolveTurnLLMDeliveryPath,
+  hasInferredLLMDeliveryPath,
+} from 'librechat-data-provider';
+import type {
+  TurnDeliveryRouting,
+  TurnDeliveryFile,
+  TurnFileConsumers,
+} from 'librechat-data-provider';
+import type { AppConfig } from '@librechat/data-schemas';
+import { collectModelBoundHistoricalFileIdState } from '~/middleware/modelBoundContent';
+
+/** The app config a turn's attachment routing reads. */
+export type TurnDeliveryConfig = Pick<AppConfig, 'fileConfig' | 'speech' | 'endpoints'>;
+
+/** The fields of an agent that route its attachments. */
+export interface TurnDeliveryAgent {
+  provider: string;
+  /** The endpoint name initialization records before it swaps `provider` for the backing
+   *  client; an agent loaded without one is routed by its provider. */
+  endpoint?: string | null;
+  /** The Responses API setting the turn runs on, once initialization has decided it. */
+  model_parameters?: { useResponsesApi?: boolean } | null;
+}
+
+/**
+ * Settles how the agent running a turn receives its attachments.
+ *
+ * Read once, after initialization has resolved the backing provider and the Responses API
+ * decision: the file policy is the one configured under the endpoint's own name, the media
+ * dialect is the one its config declares rather than the client family it runs as, and the
+ * Responses setting is the one the model call uses. Every reader of a turn route consumes the
+ * returned value, so delivery, steering and child run-file encoding cannot answer differently.
+ */
+export function resolveTurnDeliveryRouting({
+  agent,
+  config,
+}: {
+  agent: TurnDeliveryAgent;
+  config?: TurnDeliveryConfig;
+}): TurnDeliveryRouting {
+  const endpoint = agent.endpoint ?? agent.provider;
+  const fileConfig = mergeFileConfig(config?.fileConfig);
+  return {
+    fileConfig,
+    endpointConfig: getEndpointFileConfig({ fileConfig, endpoint }),
+    endpoint,
+    endpointProvider: getCustomEndpointProvider(config?.endpoints?.custom, endpoint),
+    useResponsesApi: resolveUseResponsesApi(agent.model_parameters?.useResponsesApi),
+    sttConfigured: isSpeechProviderConfigured(config?.speech?.stt),
+  };
+}
+
+/** Materialize the exact turn route before admission without mutating stored records. */
+export function applyTurnDelivery<T extends TurnDeliveryFile>(
+  files: T[],
+  { routing, consumers }: { routing?: TurnDeliveryRouting; consumers?: TurnFileConsumers },
+): T[] {
+  if (routing == null) {
+    return files;
+  }
+  let changed = false;
+  const result = files.map((file) => {
+    if (!hasInferredLLMDeliveryPath(file)) {
+      return file;
+    }
+    const llmDeliveryPath = resolveTurnLLMDeliveryPath(routing, file, consumers);
+    if (llmDeliveryPath == null || llmDeliveryPath === file.llmDeliveryPath) {
+      return file;
+    }
+    changed = true;
+    return { ...file, llmDeliveryPath };
+  });
+  return changed ? result : files;
+}
+
+/**
+ * Checkpoints replay already encoded content; current tools and policy cannot remove it.
+ * A referenced inferred tool file carrying extracted text may have been delivered as fallback.
+ * Charge that text conservatively even if fallback was since disabled. Explicit destinations
+ * and records predating routing keep their existing accounting; no stored record is changed.
+ */
+export function applyCheckpointDelivery<T extends TurnDeliveryFile>(files: T[]): T[] {
+  return files.map((file) =>
+    hasInferredLLMDeliveryPath(file) && file.llmDeliveryPath === 'none' && file.text
+      ? { ...file, llmDeliveryPath: 'text' }
+      : file,
+  );
+}
+
+/**
+ * A primary agent's tool route cannot decide whether a handoff receives text. Keep
+ * owner-hydrated candidates until each receiver resolves them, then add only text absent
+ * from the shared prompt to its scoped context. The existing scoped-context pipeline owns
+ * endpoint filtering, aggregate admission, inspection and extraction for these copies.
+ */
+export function resolveScopedTurnAttachments<T extends TurnDeliveryFile & { file_id: string }>({
+  agents,
+  sharedConversationAgentIds,
+  resendFiles,
+  messages,
+  historicalFiles,
+  requestAttachments,
+  sharedRunAttachmentIds,
+  attachmentsByAgentId,
+}: {
+  agents: readonly {
+    agentId: string;
+    agent: {
+      deliveryRouting?: TurnDeliveryRouting;
+      fileConsumers?: TurnFileConsumers;
+    };
+  }[];
+  /** Only the primary/handoff graph shares root conversation files. */
+  sharedConversationAgentIds: readonly string[];
+  resendFiles?: boolean;
+  messages: Parameters<typeof collectModelBoundHistoricalFileIdState>[0];
+  historicalFiles?: ReadonlyMap<string, T>;
+  requestAttachments: readonly T[];
+  sharedRunAttachmentIds: ReadonlySet<string>;
+  attachmentsByAgentId?: Map<string, T[]> | Record<string, T[]>;
+}): Map<string, T[]> {
+  const candidates = new Map<string, T>();
+  for (const fileId of collectModelBoundHistoricalFileIdState(resendFiles === false ? [] : messages)
+    .fileIds) {
+    const file = historicalFiles?.get(fileId);
+    if (file && !sharedRunAttachmentIds.has(fileId)) candidates.set(fileId, file);
+  }
+  for (const file of requestAttachments) {
+    if (!sharedRunAttachmentIds.has(file.file_id)) candidates.set(file.file_id, file);
+  }
+  const sharedAgents = new Set(sharedConversationAgentIds);
+  const result = new Map<string, T[]>();
+  for (const { agentId, agent } of agents) {
+    const scoped =
+      attachmentsByAgentId instanceof Map
+        ? (attachmentsByAgentId.get(agentId) ?? [])
+        : (attachmentsByAgentId?.[agentId] ?? []);
+    const files = new Map(scoped.map((file) => [file.file_id, file]));
+    for (const [fileId, file] of sharedAgents.has(agentId) ? candidates : []) {
+      if (files.has(fileId)) continue;
+      const path = resolveTurnLLMDeliveryPath(agent.deliveryRouting, file, agent.fileConsumers);
+      if (path === 'text' && file.text) files.set(fileId, { ...file, llmDeliveryPath: path });
+    }
+    result.set(agentId, [...files.values()]);
+  }
+  return result;
+}
diff --git a/packages/api/src/agents/files/encode.spec.ts b/packages/api/src/agents/files/encode.spec.ts
index 753db6d0982..f0982f7ac76 100644
--- a/packages/api/src/agents/files/encode.spec.ts
+++ b/packages/api/src/agents/files/encode.spec.ts
@@ -3,6 +3,7 @@ import type { TFile } from 'librechat-data-provider';
 import type { RunFileEncodingAgent, RunFileMessageEncoderDeps } from './encode';
 import type { ServerRequest } from '~/types';
 import { AgentAttachmentLimitError, AgentAttachmentPolicyError } from '../attachments';
+import { resolveTurnDeliveryRouting } from './delivery';
 import { createRunFileMessageEncoder } from './encode';
 
 jest.mock('~/utils/tokenizer', () => ({ countTokens: (text: string) => text.length }));
@@ -28,14 +29,32 @@ const nativeDocument = {
 };
 const nativeImage = { type: 'image_url', image_url: { url: 'data:image/png;base64,aW1n' } };
 
+/** A child as the host loads it, before initialization settles its delivery routing. */
+type LoadedAgent = Omit<RunFileEncodingAgent, 'deliveryRouting'> & {
+  endpoint?: string;
+  useResponsesApi?: boolean;
+};
+
 function setup({
   fileConfig = {},
   agents = { child: { provider: 'openAI' } },
 }: {
   fileConfig?: NonNullable<ServerRequest['config']>['fileConfig'];
-  agents?: Record<string, RunFileEncodingAgent>;
+  agents?: Record<string, LoadedAgent>;
 } = {}) {
   const req = { body: {}, config: { fileConfig } } as ServerRequest;
+  const initialized = Object.fromEntries(
+    Object.entries(agents).map(([id, { endpoint, useResponsesApi, ...agent }]) => [
+      id,
+      {
+        ...agent,
+        deliveryRouting: resolveTurnDeliveryRouting({
+          agent: { provider: agent.provider, endpoint, model_parameters: { useResponsesApi } },
+          config: req.config,
+        }),
+      },
+    ]),
+  );
   const encodeImages = jest.fn(async () => ({ image_urls: [nativeImage] }));
   const encodeDocuments = jest.fn(async () => ({ documents: [nativeDocument] }));
   const encodeAudios = jest.fn(async () => ({ audios: [{ type: 'media', data: 'audio' }] }));
@@ -46,7 +65,7 @@ function setup({
   >(extractFileContext);
   const deps: RunFileMessageEncoderDeps = {
     req,
-    getAgent: (id) => agents[id],
+    getAgent: (id) => initialized[id],
     encodeImages,
     encodeDocuments,
     encodeAudios,
@@ -65,7 +84,7 @@ describe('createRunFileMessageEncoder', () => {
           provider: 'openAI',
           endpoint: 'child-provider',
           model: 'child-model',
-          model_parameters: { useResponsesApi: true },
+          useResponsesApi: true,
           imageDetail: ImageDetail.high,
         },
       },
@@ -138,6 +157,49 @@ describe('createRunFileMessageEncoder', () => {
     expect(pdf.llmDeliveryPath).toBe('provider');
   });
 
+  it('delivers stored text only to a child that runs no tool able to read a tool-routed file', async () => {
+    const csv: TFile = {
+      ...pdf,
+      file_id: 'input-csv',
+      filename: 'sales.csv',
+      filepath: '/files/sales.csv',
+      type: 'text/csv',
+      text: 'region,total\nwest,4',
+      llmDeliveryPath: 'none',
+      metadata: { destinationChosen: false },
+    };
+    const harness = setup({
+      agents: {
+        noReader: { provider: 'openAI', fileConsumers: { executeCode: false, fileSearch: false } },
+        runsCode: { provider: 'openAI', fileConsumers: { executeCode: true, fileSearch: false } },
+        unknown: { provider: 'openAI' },
+      },
+      fileConfig: {
+        endpoints: {
+          openAI: {
+            defaultLLMDeliveryPath: { overrides: { 'text/csv': 'none' } },
+            textFallbackWithoutTools: true,
+          },
+        },
+      },
+    });
+
+    const [noReader, runsCode, unknown] = await Promise.all([
+      harness.encode([csv], 'noReader'),
+      harness.encode([csv], 'runsCode'),
+      harness.encode([csv], 'unknown'),
+    ]);
+
+    expect(JSON.stringify(noReader[0].content)).toContain('region,total');
+    expect(runsCode).toEqual([]);
+    expect(unknown).toEqual([]);
+    expect(harness.extractText).toHaveBeenCalledWith(
+      expect.objectContaining({ attachments: [{ ...csv, llmDeliveryPath: 'text' }] }),
+    );
+    expect(harness.encodeDocuments).not.toHaveBeenCalled();
+    expect(csv.llmDeliveryPath).toBe('none');
+  });
+
   it('honors an explicit tool destination even when the receiving endpoint supports native files', async () => {
     const harness = setup();
     const file: TFile = {
diff --git a/packages/api/src/agents/files/encode.ts b/packages/api/src/agents/files/encode.ts
index 63b273bd76e..a5312c52992 100644
--- a/packages/api/src/agents/files/encode.ts
+++ b/packages/api/src/agents/files/encode.ts
@@ -3,14 +3,15 @@ import { HumanMessage } from '@librechat/agents/langchain';
 import {
   FileSources,
   EModelEndpoint,
-  mergeFileConfig,
-  getEndpointFileConfig,
   isBedrockDocumentType,
-  resolveUseResponsesApi,
-  isSpeechProviderConfigured,
-  resolveUploadLLMDeliveryPath,
+  resolveTurnLLMDeliveryPath,
+} from 'librechat-data-provider';
+import type {
+  TFile,
+  ImageDetail,
+  TurnDeliveryRouting,
+  TurnFileConsumers,
 } from 'librechat-data-provider';
-import type { TFile, ImageDetail } from 'librechat-data-provider';
 import type { BaseMessage } from '@librechat/agents/langchain';
 import type { ServerRequest, StrategyFunctions } from '~/types';
 import type { TokenCountFn } from '~/utils/text';
@@ -28,11 +29,13 @@ type ContentBlock = Exclude<BaseMessage['content'], string>[number];
 /** The already loaded child configuration; storage documents never cross this boundary. */
 export interface RunFileEncodingAgent {
   provider: string;
-  endpoint?: string | null;
   model?: string | null;
-  model_parameters?: { model?: string; useResponsesApi?: boolean };
+  model_parameters?: { model?: string };
   imageDetail?: ImageDetail;
   agentContextAttachments?: readonly TFile[];
+  /** How the child receives attachments, settled when its configuration was initialized. */
+  deliveryRouting: TurnDeliveryRouting;
+  fileConsumers?: TurnFileConsumers;
 }
 
 export interface RunFileEncodingParams {
@@ -80,33 +83,26 @@ export function createRunFileMessageEncoder(
     if (!agent) {
       throw new Error('The target agent is not available for shared file delivery.');
     }
-    const endpoint = agent.endpoint ?? agent.provider;
-    const fileConfig = mergeFileConfig(deps.req.config?.fileConfig);
-    const endpointConfig = getEndpointFileConfig({ fileConfig, endpoint });
-    const useResponsesApi = resolveUseResponsesApi(agent.model_parameters?.useResponsesApi);
+    const { deliveryRouting } = agent;
+    const { endpoint, fileConfig, endpointConfig } = deliveryRouting;
     const params: RunFileEncodingParams = {
       provider: agent.provider,
       endpoint,
       model: agent.model_parameters?.model ?? agent.model ?? undefined,
-      useResponsesApi,
+      useResponsesApi: deliveryRouting.useResponsesApi,
       imageDetail: agent.imageDetail,
     };
 
     const resolveDelivery = (file: TFile): TFile => {
-      if (file.llmDeliveryPath == null || file.metadata?.destinationChosen === true) {
+      const llmDeliveryPath = resolveTurnLLMDeliveryPath(
+        deliveryRouting,
+        file,
+        agent.fileConsumers,
+      );
+      if (llmDeliveryPath == null || llmDeliveryPath === file.llmDeliveryPath) {
         return file;
       }
-      return {
-        ...file,
-        llmDeliveryPath: resolveUploadLLMDeliveryPath({
-          mimeType: file.metadata?.routingMimeType ?? file.type,
-          endpointConfig,
-          fileConfig,
-          endpoint,
-          useResponsesApi,
-          sttConfigured: isSpeechProviderConfigured(deps.req.config?.speech?.stt),
-        }),
-      };
+      return { ...file, llmDeliveryPath };
     };
     const sharedFiles = files.map(resolveDelivery);
     const compatibleFiles = filterFilesByEndpointRuntimeConfig(deps.req.config, {
diff --git a/packages/api/src/agents/files/index.ts b/packages/api/src/agents/files/index.ts
index 9293cd7f4ea..0bdab2ea815 100644
--- a/packages/api/src/agents/files/index.ts
+++ b/packages/api/src/agents/files/index.ts
@@ -3,3 +3,4 @@ export * from './session';
 export * from './host';
 export * from './binding';
 export * from './encode';
+export * from './delivery';
diff --git a/packages/api/src/agents/files/session.spec.ts b/packages/api/src/agents/files/session.spec.ts
index ad786df7ccd..9a01735a096 100644
--- a/packages/api/src/agents/files/session.spec.ts
+++ b/packages/api/src/agents/files/session.spec.ts
@@ -7,6 +7,7 @@ import type { RunFileSessionDeps } from './session';
 import type { ServerRequest } from '~/types';
 import { createRunFileSession, getAuthorizedRunFileSnapshot } from './session';
 import { AgentAttachmentLimitError } from '../attachments';
+import { resolveTurnDeliveryRouting } from './delivery';
 import { createRunFileMessageEncoder } from './encode';
 
 function setup(
@@ -219,6 +220,10 @@ it.each([{ totalSizeLimit: 1 }, { fileLimit: 1 }])(
       getAgent: (id) => ({
         provider: 'openAI',
         agentContextAttachments: id === 'writer' ? writerAttachments : [],
+        deliveryRouting: resolveTurnDeliveryRouting({
+          agent: { provider: 'openAI' },
+          config: { fileConfig },
+        }),
       }),
       encodeDocuments,
       encodeImages: async () => ({ image_urls: [] }),
diff --git a/packages/api/src/agents/hitl/protection.spec.ts b/packages/api/src/agents/hitl/protection.spec.ts
index 6c7c1949154..26c877cdc91 100644
--- a/packages/api/src/agents/hitl/protection.spec.ts
+++ b/packages/api/src/agents/hitl/protection.spec.ts
@@ -3,6 +3,11 @@ import type {
   ResumeContentProtectionDependencies,
   ResumeRuntimeContentProtectionDependencies,
 } from './protection';
+import {
+  assertAgentAttachmentLimits,
+  AgentAttachmentLimitError,
+  isModelBoundAttachmentFile,
+} from '../attachments';
 import { assertResumeContentAllowed, assertResumeRuntimeContentAllowed } from './protection';
 
 const user = {
@@ -99,6 +104,48 @@ describe('assertResumeRuntimeContentAllowed', () => {
     },
   );
 
+  it('charges retained fallback text after settings change, using owner-hydrated records', async () => {
+    const dependencies = createDependencies();
+    dependencies.getAgentCheckpointer.mockResolvedValue({
+      getTuple: jest.fn().mockResolvedValue({
+        checkpoint: {
+          channel_values: {
+            messages: [{ role: 'human', additional_kwargs: { sourceMessageId: 'source-message' } }],
+          },
+        },
+      }),
+    });
+    dependencies.getMessages.mockResolvedValue([
+      { messageId: 'source-message', files: [{ file_id: 'fallback-file' }] },
+    ]);
+    const storedFile = {
+      file_id: 'fallback-file',
+      filename: 'sales.csv',
+      type: 'text/csv',
+      source: 'local',
+      bytes: 20,
+      text: 'region,total',
+      llmDeliveryPath: 'none',
+      metadata: { destinationChosen: false },
+    };
+    dependencies.getFiles.mockResolvedValue([storedFile]);
+    const input = {
+      ...createInput({ fileConfig: { textFallbackWithoutTools: false } }),
+      isTemporary: false,
+    };
+    const projection = await assertResumeRuntimeContentAllowed(input, dependencies);
+    expect(projection.checkpointFiles).toEqual([{ ...storedFile, llmDeliveryPath: 'text' }]);
+    expect(storedFile.llmDeliveryPath).toBe('none');
+    expect(() =>
+      assertAgentAttachmentLimits({
+        attachments: projection.checkpointFiles.filter(isModelBoundAttachmentFile),
+        fileConfig: { fileContextCharLimit: 3 },
+        endpoint: 'openAI',
+      }),
+    ).toThrow(AgentAttachmentLimitError);
+    expect(dependencies.getFiles).toHaveBeenCalledTimes(1);
+  });
+
   it('hydrates checkpoint-bound files when content filters are inactive', async () => {
     const dependencies = createDependencies();
     dependencies.getAgentCheckpointer.mockResolvedValue({
diff --git a/packages/api/src/agents/hitl/protection.ts b/packages/api/src/agents/hitl/protection.ts
index 500e7b3126f..7ba81fed609 100644
--- a/packages/api/src/agents/hitl/protection.ts
+++ b/packages/api/src/agents/hitl/protection.ts
@@ -58,6 +58,7 @@ import { LIBRECHAT_CHECKPOINT_NAMESPACE_KEY } from '../checkpointer';
 import { AttachmentObjectNotFoundError } from '~/files/encode/utils';
 import { ASK_USER_QUESTION_TOOL_NAME } from './askUserQuestionTool';
 import { ContentFilterError } from '~/middleware/contentFilter';
+import { applyCheckpointDelivery } from '../files/delivery';
 import { hasActiveFilePolicy } from '~/protection/files';
 import { parseSkillMarkdown } from '../../skills/parse';
 import { inspectContent } from '~/protection/runtime';
@@ -1137,7 +1138,7 @@ export async function assertResumeRuntimeContentAllowed(
     );
     throw new AttachmentObjectNotFoundError(unresolvedFileId ?? 'unknown');
   }
-  return { resolvedFiles, checkpointFiles };
+  return { resolvedFiles, checkpointFiles: applyCheckpointDelivery(checkpointFiles) };
 }
 
 export function getUserFacingResumeError(
diff --git a/packages/api/src/agents/initialize.ts b/packages/api/src/agents/initialize.ts
index f36ffc49f59..7f9cc7391ac 100644
--- a/packages/api/src/agents/initialize.ts
+++ b/packages/api/src/agents/initialize.ts
@@ -21,10 +21,12 @@ import type {
   TEndpointOption,
   ReasoningResponseKey,
   StatefulCodeEnvironment,
+  TurnDeliveryRouting,
   ImageDetail,
   TFile,
   Agent,
   TUser,
+  TurnFileConsumers,
 } from 'librechat-data-provider';
 import type { GenericTool, LCToolRegistry, ToolMap, LCTool } from '@librechat/agents';
 import type { IMongoFile, FileOwnerScope } from '@librechat/data-schemas';
@@ -113,10 +115,12 @@ import { applyIntentLabels, sanitizeIntentLabels } from './intent';
 import { ContentFilterError } from '../middleware/contentFilter';
 import { resolveToolRoleGrants } from '~/tools/rolePermissions';
 import { createRequestAgentExecutionContext } from './runtime';
+import { resolveTurnDeliveryRouting } from './files/delivery';
 import { filterFilesByEndpointRuntimeConfig } from '~/files';
 import { hasActiveFileFieldPolicy } from '~/protection';
 import { PARTIAL_RESOLVED_CONVERSATION } from './guard';
 import { applyBackgroundToolCalls } from './background';
+import { applyTurnDelivery } from './files/delivery';
 import { generateArtifactsPrompt } from '~/prompts';
 import { getProviderConfig } from '~/endpoints';
 import { primeResources } from './resources';
@@ -616,6 +620,8 @@ export type InitializedAgent = Agent & {
   currentRequestAttachments: TFile[];
   /** Files attached to this agent's permanent context via tool_resources. */
   agentContextAttachments: IMongoFile[];
+  /** File-reading tools this turn runs, which decide when a tool-routed file falls back to text. */
+  fileConsumers?: TurnFileConsumers;
   toolContextMap: Record<string, unknown>;
   dynamicToolContextMap?: Record<string, unknown>;
   maxContextTokens: number;
@@ -626,6 +632,8 @@ export type InitializedAgent = Agent & {
   /** Detail level LibreChat encodes image content blocks with, from the agent's
    * model parameters. Absent when the agent does not configure one. */
   imageDetail?: ImageDetail;
+  /** How this agent receives its attachments this turn, settled once every routing input is final. */
+  deliveryRouting: TurnDeliveryRouting;
   tool_resources?: AgentToolResources;
   userMCPAuthMap?: Record<string, Record<string, string>>;
   /** Tool map for ToolNode to use when executing tools (required for PTC) */
@@ -1282,6 +1290,88 @@ export async function initializeAgent(
   const provider = agent.provider;
   agent.endpoint = provider;
 
+  /** Settle the provider and its client options before any attachment is judged. The file
+   * policy reads the endpoint's own name, but the route each attachment takes also depends on
+   * the backing client and on the Responses API decision `getOptions` makes, and nothing
+   * between here and tool loading feeds either. */
+  const { getOptions, overrideProvider, customEndpointConfig } = getProviderConfig({
+    provider,
+    appConfig,
+  });
+  if (overrideProvider !== agent.provider) {
+    agent.provider = overrideProvider;
+  }
+
+  const finalModelOptions = {
+    ...modelOptions,
+    model: agent.model,
+  };
+
+  const options: InitializeResultBase = await getOptions({
+    runtime: {
+      appConfig,
+      user,
+      requestBody: runtime.requestBody,
+    },
+    endpoint: provider,
+    model_parameters: finalModelOptions,
+    db,
+  });
+
+  const llmConfig = options.llmConfig as Record<string, unknown>;
+  const webSearchDenied =
+    hasProviderWebSearch(options.tools, llmConfig) &&
+    !(await resolveWebSearchGrant({
+      req: params.req as Request | undefined,
+      user,
+      resolve: params.resolveWebSearchGrant,
+      getRoleByName: db.getRoleByName,
+    }));
+  if (webSearchDenied && stripWebSearchPlugin(llmConfig) > 0) {
+    logger.debug(
+      `[initializeAgent] Removed the OpenRouter web search plugin; role denies WEB_SEARCH.`,
+    );
+  }
+  const tokensModel =
+    agent.provider === EModelEndpoint.azureOpenAI ? agent.model : (llmConfig?.model as string);
+  const maxOutputTokens = optionalChainWithEmptyCheck(
+    llmConfig?.maxOutputTokens as number | undefined,
+    llmConfig?.maxTokens as number | undefined,
+    0,
+  );
+  const agentMaxContextTokens = optionalChainWithEmptyCheck(
+    maxContextTokens,
+    getModelMaxTokens(
+      tokensModel ?? '',
+      providerEndpointMap[overrideProvider as keyof typeof providerEndpointMap],
+      options.endpointTokenConfig,
+    ),
+    DEFAULT_MAX_CONTEXT_TOKENS,
+  );
+
+  if (
+    agent.endpoint === EModelEndpoint.azureOpenAI &&
+    (llmConfig?.azureOpenAIApiInstanceName as string | undefined) == null
+  ) {
+    agent.provider = Providers.OPENAI;
+  }
+
+  if (options.provider != null) {
+    agent.provider = options.provider;
+  }
+
+  const deliveryRouting = resolveTurnDeliveryRouting({
+    agent: {
+      provider: agent.provider,
+      endpoint: agent.endpoint,
+      model_parameters: {
+        useResponsesApi:
+          typeof llmConfig.useResponsesApi === 'boolean' ? llmConfig.useResponsesApi : undefined,
+      },
+    },
+    config: appConfig,
+  });
+
   /** Resolve the per-agent Code API route before resource/tool priming. A
    * stateful agent must perform freshness checks and recovery uploads against
    * the same isolated deployment its eventual `/exec` request will use. */
@@ -1371,6 +1461,10 @@ export async function initializeAgent(
    * that lookup runs whichever way the setting is configured. */
   const wantsCodeFiles = toolResourceSet.has(EToolResources.execute_code);
   const wantsSearchFiles = toolResourceSet.has(EToolResources.file_search);
+  const fileConsumers: TurnFileConsumers = {
+    executeCode: wantsCodeFiles,
+    fileSearch: wantsSearchFiles,
+  };
   const wantsProvisioning = wantsCodeFiles || wantsSearchFiles;
 
   if (
@@ -1553,6 +1647,14 @@ export async function initializeAgent(
   } else if (requestFiles.length > 0 || toolFileIds.length > 0) {
     currentFiles = requestUsageFiles.concat(toolUsageFiles);
   }
+  if (currentFiles?.length) {
+    /* Before any check reads the route: endpoint filtering, model-bound limits and content
+     * inspection below all have to judge each file by the route this turn delivers it by. */
+    currentFiles = applyTurnDelivery(currentFiles, {
+      routing: deliveryRouting,
+      consumers: fileConsumers,
+    });
+  }
 
   let endpointFileType: EModelEndpoint | undefined;
   if (!paramEndpoints.has(agent.endpoint ?? '')) {
@@ -1917,72 +2019,6 @@ export async function initializeAgent(
     }
   }
 
-  const { getOptions, overrideProvider, customEndpointConfig } = getProviderConfig({
-    provider,
-    appConfig,
-  });
-  if (overrideProvider !== agent.provider) {
-    agent.provider = overrideProvider;
-  }
-
-  const finalModelOptions = {
-    ...modelOptions,
-    model: agent.model,
-  };
-
-  const options: InitializeResultBase = await getOptions({
-    runtime: {
-      appConfig,
-      user,
-      requestBody: runtime.requestBody,
-    },
-    endpoint: provider,
-    model_parameters: finalModelOptions,
-    db,
-  });
-
-  const llmConfig = options.llmConfig as Record<string, unknown>;
-  const webSearchDenied =
-    hasProviderWebSearch(options.tools, llmConfig) &&
-    !(await resolveWebSearchGrant({
-      req: params.req as Request | undefined,
-      user,
-      resolve: params.resolveWebSearchGrant,
-      getRoleByName: db.getRoleByName,
-    }));
-  if (webSearchDenied && stripWebSearchPlugin(llmConfig) > 0) {
-    logger.debug(
-      `[initializeAgent] Removed the OpenRouter web search plugin; role denies WEB_SEARCH.`,
-    );
-  }
-  const tokensModel =
-    agent.provider === EModelEndpoint.azureOpenAI ? agent.model : (llmConfig?.model as string);
-  const maxOutputTokens = optionalChainWithEmptyCheck(
-    llmConfig?.maxOutputTokens as number | undefined,
-    llmConfig?.maxTokens as number | undefined,
-    0,
-  );
-  const agentMaxContextTokens = optionalChainWithEmptyCheck(
-    maxContextTokens,
-    getModelMaxTokens(
-      tokensModel ?? '',
-      providerEndpointMap[overrideProvider as keyof typeof providerEndpointMap],
-      options.endpointTokenConfig,
-    ),
-    DEFAULT_MAX_CONTEXT_TOKENS,
-  );
-
-  if (
-    agent.endpoint === EModelEndpoint.azureOpenAI &&
-    (llmConfig?.azureOpenAIApiInstanceName as string | undefined) == null
-  ) {
-    agent.provider = Providers.OPENAI;
-  }
-
-  if (options.provider != null) {
-    agent.provider = options.provider;
-  }
-
   /**
    * Unify code-execution tools around `bash_tool` + `read_file` when the
    * agent explicitly lists `execute_code` in its tools and the admin
@@ -2038,6 +2074,7 @@ export async function initializeAgent(
       workspaceTools: attachedWorkspaceTools,
       workspaceOperations: attachedWorkspaceOperations,
       workspaceCommandTimeoutMaxMs: attachedWorkspaceCommandTimeoutMaxMs,
+      workspaceEnvironment: trustedCodeExecutionContext.codeWorkspace?.environment,
     });
     toolDefinitions = codeExecResult.toolDefinitions;
     recordCapabilityToolNames(AgentCapabilities.execute_code, codeExecResult.toolNames);
@@ -2255,6 +2292,8 @@ export async function initializeAgent(
       workspaceTools: attachedWorkspaceTools,
       workspaceOperations: attachedWorkspaceOperations,
       userId: user?.id,
+      workspaceCommandTimeoutMaxMs: attachedWorkspaceCommandTimeoutMaxMs,
+      workspaceEnvironment: trustedCodeExecutionContext.codeWorkspace?.environment,
       skillStates: params.skillStates,
       defaultActiveOnShare: params.defaultActiveOnShare,
       maxCatalogSkills: getMaxCatalogSkills(runtime),
@@ -2328,11 +2367,60 @@ export async function initializeAgent(
   const toMongoFiles = (files: Array<TFile | undefined> | undefined): IMongoFile[] =>
     (files ?? []).filter((a): a is TFile => a != null).map((a) => a as unknown as IMongoFile);
 
-  const finalAttachments: IMongoFile[] = toMongoFiles(primedAttachments);
-  const requestAttachments: IMongoFile[] = toMongoFiles(primedRequestAttachments);
-  const agentContextAttachments: IMongoFile[] = toMongoFiles(primedAgentContextAttachments);
+  const loadedFileToolNames = new Set([
+    ...(structuredTools ?? []).map((tool) => tool.name),
+    ...(toolDefinitions ?? []).map((tool) => tool.name),
+  ]);
+  const finalFileConsumers: TurnFileConsumers = {
+    executeCode:
+      wantsCodeFiles &&
+      (loadedFileToolNames.has(Tools.execute_code) ||
+        (loadedFileToolNames.has('bash_tool') && loadedFileToolNames.has('read_file'))),
+    fileSearch: wantsSearchFiles && loadedFileToolNames.has(Tools.file_search),
+  };
+  const consumersChanged =
+    fileConsumers.executeCode !== finalFileConsumers.executeCode ||
+    fileConsumers.fileSearch !== finalFileConsumers.fileSearch;
+  Object.assign(fileConsumers, finalFileConsumers);
+  const finalizeAttachments = (files: Array<TFile | undefined> | undefined): IMongoFile[] => {
+    const hydrated = toMongoFiles(files);
+    return consumersChanged
+      ? applyTurnDelivery(hydrated, { routing: deliveryRouting, consumers: fileConsumers })
+      : hydrated;
+  };
+  const finalAttachments = finalizeAttachments(primedAttachments);
+  const finalRequestAttachments = consumersChanged
+    ? applyTurnDelivery(
+        (primedRequestAttachments ?? []).filter((file): file is TFile => file != null),
+        {
+          routing: deliveryRouting,
+          consumers: fileConsumers,
+        },
+      )
+    : primedRequestAttachments;
+  const requestAttachments = toMongoFiles(finalRequestAttachments);
+  const agentContextAttachments = finalizeAttachments(primedAgentContextAttachments);
+  if (consumersChanged) {
+    /* A loader may drop a reader, including a skill extra on retry. Newly model-bound text
+     * must pass admission before it can escape initialization, just like initial fallback. */
+    const admissionFileIds = new Set(
+      (authorizedRunFiles ?? requestUsageFiles).map((file) => file.file_id),
+    );
+    assertAgentAttachmentLimits({
+      attachments: requestAttachments.filter(
+        (file) => admissionFileIds.has(file.file_id) && isModelBoundAttachmentFile(file),
+      ),
+      fileConfig: appConfig?.fileConfig,
+      endpoint: agent.endpoint ?? '',
+      endpointType: endpointFileType,
+    });
+    assertModelBoundContent({
+      filters: appConfig?.filters,
+      files: [...finalAttachments, ...requestAttachments, ...agentContextAttachments],
+    });
+  }
   const currentRequestFileIds = new Set(requestFileIds);
-  const currentRequestAttachments: TFile[] = (primedRequestAttachments ?? [])
+  const currentRequestAttachments: TFile[] = (finalRequestAttachments ?? [])
     .filter((file): file is TFile => file != null && currentRequestFileIds.has(file.file_id))
     .map((file) => ({
       ...file,
@@ -2368,6 +2456,7 @@ export async function initializeAgent(
     azureOptions: options.azureOptions,
     resendFiles,
     imageDetail,
+    deliveryRouting,
     toolRegistry,
     mcpAvailableTools,
     requestScopedConnections,
@@ -2402,6 +2491,7 @@ export async function initializeAgent(
     requestAttachments,
     currentRequestAttachments,
     agentContextAttachments,
+    fileConsumers,
     toolContextMap: toolContextMap ?? {},
     dynamicToolContextMap: dynamicToolContextMap ?? {},
     useLegacyContent: !!options.useLegacyContent,
diff --git a/packages/api/src/agents/skills.ts b/packages/api/src/agents/skills.ts
index 9c7367f6095..beb5373b72a 100644
--- a/packages/api/src/agents/skills.ts
+++ b/packages/api/src/agents/skills.ts
@@ -2,8 +2,12 @@ import { logger } from '@librechat/data-schemas';
 import { HumanMessage } from '@librechat/agents/langchain/messages';
 import { SkillsScope, isEphemeralAgentId, resolveAgentSkillsScope } from 'librechat-data-provider';
 import { formatSkillCatalog, SkillToolDefinition, ReadFileToolDefinition } from '@librechat/agents';
+import type {
+  Agent,
+  CodeWorkspaceOperation,
+  CodeWorkspaceDescriptor,
+} from 'librechat-data-provider';
 import type { LCToolRegistry, LCTool, InjectedMessage } from '@librechat/agents';
-import type { Agent, CodeWorkspaceOperation } from 'librechat-data-provider';
 import type { BaseMessage } from '@librechat/agents/langchain/messages';
 import type { Types } from 'mongoose';
 import { createSkillContentDigest } from './compatibility';
@@ -436,6 +440,7 @@ export interface InjectSkillCatalogParams {
   workspaceOperations?: ReadonlySet<CodeWorkspaceOperation>;
   /** Deployment ceiling advertised on attached Bash tool definitions. */
   workspaceCommandTimeoutMaxMs?: number;
+  workspaceEnvironment?: CodeWorkspaceDescriptor['environment'];
   /** Current user ID — used to determine skill ownership for active-state resolution. */
   userId?: string;
   /** Per-user skill overrides: `{ [skillId]: boolean }`. Missing entries use the default. */
@@ -665,6 +670,7 @@ export async function injectSkillCatalog(
     workspaceTools,
     workspaceOperations,
     workspaceCommandTimeoutMaxMs,
+    workspaceEnvironment,
     userId,
     skillStates,
     defaultActiveOnShare = false,
@@ -825,6 +831,7 @@ export async function injectSkillCatalog(
     workspaceTools: workspaceTools === true,
     workspaceOperations,
     workspaceCommandTimeoutMaxMs,
+    workspaceEnvironment,
   });
   workingDefs = codeExecResult.toolDefinitions;
 
diff --git a/packages/api/src/agents/steering/__tests__/media.spec.ts b/packages/api/src/agents/steering/__tests__/media.spec.ts
index acc1ff7e57e..460f162aa11 100644
--- a/packages/api/src/agents/steering/__tests__/media.spec.ts
+++ b/packages/api/src/agents/steering/__tests__/media.spec.ts
@@ -16,8 +16,9 @@ function createClient({
   image_urls?: Array<Record<string, unknown>>;
   documents?: Array<Record<string, unknown>>;
   fileContext?: string;
-} = {}): SteerMediaClient & { processAttachments: jest.Mock } {
+} = {}): SteerMediaClient & { processAttachments: jest.Mock; resolveTurnAttachments: jest.Mock } {
   return {
+    resolveTurnAttachments: jest.fn((files: IMongoFile[]) => files),
     addFileContextToMessage: jest.fn(async (pseudo: Record<string, unknown>) => {
       if (fileContext) {
         pseudo.fileContext = fileContext;
@@ -104,10 +105,11 @@ describe('buildSteerMedia', () => {
       getFiles,
     });
 
-    expect(client.processAttachments).toHaveBeenCalledWith(expect.anything(), [
-      secondDoc,
-      imageDoc,
-    ]);
+    expect(client.processAttachments).toHaveBeenCalledWith(
+      expect.anything(),
+      [secondDoc, imageDoc],
+      { executeCode: false, fileSearch: false },
+    );
     expect(result?.files?.map((file) => file.file_id)).toEqual(['f2', 'f1']);
   });
 
@@ -134,6 +136,39 @@ describe('buildSteerMedia', () => {
     expect(client.processAttachments).not.toHaveBeenCalled();
   });
 
+  it('checks and encodes the turn view of the records it loads', async () => {
+    /* A tool-routed file this turn delivers as text is stored as `none`: the preflight and the
+     * encoders must both see the turn's copy, or the text would skip the model-bound checks. */
+    const storedCsv = { file_id: 'csv', type: 'text/csv', llmDeliveryPath: 'none' };
+    const turnCsv = { ...storedCsv, llmDeliveryPath: 'text' };
+    const getFiles: SteerFileFetcher = jest.fn(async () => [storedCsv as unknown as IMongoFile]);
+    const client = createClient();
+    client.resolveTurnAttachments.mockReturnValueOnce([turnCsv]);
+    const assertFilesAllowed = jest.fn();
+
+    await buildSteerMedia({
+      client,
+      user,
+      item: steerItem([{ file_id: 'csv' }]),
+      getFiles,
+      assertFilesAllowed,
+    });
+
+    expect(client.resolveTurnAttachments).toHaveBeenCalledWith([storedCsv], {
+      executeCode: false,
+      fileSearch: false,
+    });
+    expect(assertFilesAllowed).toHaveBeenCalledWith([turnCsv]);
+    expect(client.addFileContextToMessage).toHaveBeenCalledWith(expect.anything(), [turnCsv], {
+      executeCode: false,
+      fileSearch: false,
+    });
+    expect(client.processAttachments).toHaveBeenCalledWith(expect.anything(), [turnCsv], {
+      executeCode: false,
+      fileSearch: false,
+    });
+  });
+
   it('prepends extracted file context to the steer text', async () => {
     const getFiles: SteerFileFetcher = jest.fn(async () => [
       { file_id: 'f2', type: 'text/plain' } as unknown as IMongoFile,
@@ -239,6 +274,25 @@ describe('stampSteerPartMedia', () => {
     ]);
   });
 
+  it('encodes the turn view of the records it fetches itself', async () => {
+    const storedCsv = { file_id: 'csv', type: 'text/csv', llmDeliveryPath: 'none' };
+    const turnCsv = { ...storedCsv, llmDeliveryPath: 'text' };
+    const getFiles: SteerFileFetcher = jest.fn(async () => [storedCsv as unknown as IMongoFile]);
+    const client = createClient();
+    client.resolveTurnAttachments.mockReturnValueOnce([turnCsv]);
+    const message = {
+      role: 'assistant',
+      content: [
+        { type: 'steer', steer: 'use the sheet', steerId: 's3', files: [{ file_id: 'csv' }] },
+      ],
+    };
+
+    await stampSteerPartMedia({ client, user, payload: [message], getFiles });
+
+    expect(client.resolveTurnAttachments).toHaveBeenCalledWith([storedCsv]);
+    expect(client.processAttachments).toHaveBeenCalledWith(expect.anything(), [turnCsv], undefined);
+  });
+
   it('consumes prefetched docs without issuing a second query', async () => {
     const getFiles: SteerFileFetcher = jest.fn(async () => []);
     const client = createClient({ image_urls: [imagePart] });
@@ -261,7 +315,11 @@ describe('stampSteerPartMedia', () => {
     expect(getFiles).not.toHaveBeenCalled();
     expect(stamped).toHaveLength(1);
     expect(stamped[0].index).toBe(0);
-    expect(client.processAttachments).toHaveBeenCalledWith(expect.anything(), [imageDoc]);
+    expect(client.processAttachments).toHaveBeenCalledWith(
+      expect.anything(),
+      [imageDoc],
+      undefined,
+    );
   });
 
   it('does nothing when no steer part carries files', async () => {
diff --git a/packages/api/src/agents/steering/__tests__/request.spec.ts b/packages/api/src/agents/steering/__tests__/request.spec.ts
index d3e694e11ed..85958885a78 100644
--- a/packages/api/src/agents/steering/__tests__/request.spec.ts
+++ b/packages/api/src/agents/steering/__tests__/request.spec.ts
@@ -264,6 +264,7 @@ describe('handleSteerRequest (real in-memory job manager)', () => {
           height: 10,
           width: 20,
           bytes: 999,
+          llmDeliveryPath: 'text',
           user: 'someone-else',
           embedded: true,
         },
@@ -292,6 +293,7 @@ describe('handleSteerRequest (real in-memory job manager)', () => {
         height: 10,
         width: 20,
         bytes: 999,
+        llmDeliveryPath: 'text',
       },
     ]);
   });
@@ -388,6 +390,7 @@ describe('handleSteerRequest (real in-memory job manager)', () => {
       height: 4,
       width: 6,
       bytes: 111,
+      llmDeliveryPath: 'text',
       user: 'user-1',
     } as unknown as IMongoFile;
 
@@ -450,6 +453,7 @@ describe('handleSteerRequest (real in-memory job manager)', () => {
           height: 4,
           width: 6,
           bytes: 111,
+          llmDeliveryPath: 'text',
         },
       ]);
     });
@@ -916,6 +920,57 @@ describe('generation protocol bridge for steering mutations', () => {
     expect(plain?.requestedQuotesFingerprint).toBeUndefined();
   });
 
+  it('keeps receipt fingerprints stable when display delivery metadata is added', async () => {
+    const streamId = 'steer-protocol-v2-delivery-path-fingerprint';
+    await GenerationJobManager.createJob(streamId, user.id, undefined, {
+      initialMetadata: { generationProtocolVersion: 2 },
+    });
+    const base = {
+      conversationId: streamId,
+      text: 'same attachment steer',
+      files: [{ file_id: 'f1', type: 'application/pdf', filename: 'report.pdf' }],
+    };
+
+    await handleSteerRequest(
+      user,
+      { ...base, clientSteerId: 'client-legacy-file-ref' },
+      {
+        generationProtocolVersion: 2,
+      },
+    );
+    await handleSteerRequest(
+      user,
+      {
+        ...base,
+        clientSteerId: 'client-current-file-ref',
+        files: [{ ...base.files[0], llmDeliveryPath: 'text' }],
+      },
+      { generationProtocolVersion: 2 },
+    );
+
+    const legacy = await GenerationJobManager.steering.getReceipt(
+      streamId,
+      'client-legacy-file-ref',
+    );
+    const current = await GenerationJobManager.steering.getReceipt(
+      streamId,
+      'client-current-file-ref',
+    );
+    expect(current?.fingerprint).toBe(legacy?.fingerprint);
+    for (const [clientSteerId, files] of [
+      ['client-legacy-file-ref', [{ ...base.files[0], llmDeliveryPath: 'text' }]],
+      ['client-current-file-ref', base.files],
+    ] as const) {
+      const replay = await handleSteerRequest(
+        user,
+        { ...base, clientSteerId, files },
+        { generationProtocolVersion: 2 },
+      );
+      expect(replay.body).toMatchObject({ replayed: true });
+    }
+    expect(await GenerationJobManager.steering.peek(streamId)).toHaveLength(2);
+  });
+
   it('treats quotes as part of the idempotency identity', async () => {
     const streamId = 'steer-protocol-v2-quote-fingerprint';
     await GenerationJobManager.createJob(streamId, user.id, undefined, {
diff --git a/packages/api/src/agents/steering/media.ts b/packages/api/src/agents/steering/media.ts
index 4536f5678f3..977549a59f8 100644
--- a/packages/api/src/agents/steering/media.ts
+++ b/packages/api/src/agents/steering/media.ts
@@ -1,8 +1,8 @@
 import { logger } from '@librechat/data-schemas';
 import { formatMessage } from '@librechat/agents';
 import { ContentTypes } from 'librechat-data-provider';
+import type { TFile, TurnFileConsumers } from 'librechat-data-provider';
 import type { IMongoFile } from '@librechat/data-schemas';
-import type { TFile } from 'librechat-data-provider';
 import type { SteerQueueItem } from '~/stream/interfaces/IJobStore';
 import type { SteerFileFetcher } from './request';
 import type { SteerMediaResult } from './runtime';
@@ -14,10 +14,17 @@ import { prependFileContext } from '../client';
 
 /** The BaseClient encode surface the steer media pipeline reuses. */
 export interface SteerMediaClient {
-  addFileContextToMessage(message: Record<string, unknown>, files: IMongoFile[]): Promise<void>;
+  /** The turn's view of stored records, which every check and encode below must share. */
+  resolveTurnAttachments(files: IMongoFile[], consumers?: TurnFileConsumers): IMongoFile[];
+  addFileContextToMessage(
+    message: Record<string, unknown>,
+    files: IMongoFile[],
+    consumers?: TurnFileConsumers,
+  ): Promise<void>;
   processAttachments(
     message: Record<string, unknown>,
     files: IMongoFile[],
+    consumers?: TurnFileConsumers,
   ): Promise<IMongoFile[] | undefined>;
 }
 
@@ -75,17 +82,19 @@ async function encodeSteerContent({
   quotes,
   steerId,
   fileDocs,
+  fileConsumers,
 }: {
   client: SteerMediaClient;
   text: string;
   quotes?: string[] | null;
   steerId: string;
   fileDocs: IMongoFile[];
+  fileConsumers?: TurnFileConsumers;
 }): Promise<SteerMediaResult> {
   const modelText = mergeSteerModelText(text, quotes);
   const pseudo: PseudoMessage = { messageId: `steer:${steerId}` };
-  await client.addFileContextToMessage(pseudo, fileDocs);
-  const validated = await client.processAttachments(pseudo, fileDocs);
+  await client.addFileContextToMessage(pseudo, fileDocs, fileConsumers);
+  const validated = await client.processAttachments(pseudo, fileDocs, fileConsumers);
   const formatted = formatMessage({
     message: {
       role: 'user',
@@ -139,9 +148,13 @@ export async function buildSteerMedia({
     return undefined;
   }
   const docsById = new Map(rawDocs.map((file) => [file.file_id, file]));
-  const fileDocs = ids
-    .map((id) => docsById.get(id))
-    .filter((doc): doc is IMongoFile => doc != null);
+  /* These files arrived after resource priming. A loaded tool is not evidence that
+   * it can access them; use the opted-in text fallback until a new turn provisions them. */
+  const fileConsumers: TurnFileConsumers = { executeCode: false, fileSearch: false };
+  const fileDocs = client.resolveTurnAttachments(
+    ids.map((id) => docsById.get(id)).filter((doc): doc is IMongoFile => doc != null),
+    fileConsumers,
+  );
   assertFilesAllowed?.(fileDocs);
   return encodeSteerContent({
     client,
@@ -149,6 +162,7 @@ export async function buildSteerMedia({
     quotes: item.quotes,
     steerId: item.steerId,
     fileDocs,
+    fileConsumers,
   });
 }
 
@@ -247,7 +261,9 @@ export async function stampSteerPartMedia({
     if (filter != null) {
       const fileDocs = await getFiles(filter, {}, {});
       if (Array.isArray(fileDocs) && fileDocs.length > 0) {
-        resolvedDocsById = new Map(fileDocs.map((file) => [file.file_id, file]));
+        resolvedDocsById = new Map(
+          client.resolveTurnAttachments(fileDocs).map((file) => [file.file_id, file]),
+        );
       }
     }
   }
diff --git a/packages/api/src/agents/steering/refs.ts b/packages/api/src/agents/steering/refs.ts
index eb5f3d7691f..e1c28f43d6f 100644
--- a/packages/api/src/agents/steering/refs.ts
+++ b/packages/api/src/agents/steering/refs.ts
@@ -5,6 +5,10 @@ export interface SteerRequestUser {
   tenantId?: string;
 }
 
+function isLlmDeliveryPath(value: unknown): value is NonNullable<TFile['llmDeliveryPath']> {
+  return value === 'provider' || value === 'text' || value === 'none';
+}
+
 /**
  * Copies the display-metadata fields a steer attachment ref may carry,
  * dropping everything else. The single source of truth for the ref shape —
@@ -29,6 +33,9 @@ export function toSteerFileRef(raw: unknown): Partial<TFile> | null {
     ...(typeof candidate.type === 'string' && { type: candidate.type }),
     ...(typeof candidate.filepath === 'string' && { filepath: candidate.filepath }),
     ...(typeof candidate.filename === 'string' && { filename: candidate.filename }),
+    ...(isLlmDeliveryPath(candidate.llmDeliveryPath) && {
+      llmDeliveryPath: candidate.llmDeliveryPath,
+    }),
     ...(typeof candidate.height === 'number' && { height: candidate.height }),
     ...(typeof candidate.width === 'number' && { width: candidate.width }),
     ...(typeof candidate.bytes === 'number' && { bytes: candidate.bytes }),
diff --git a/packages/api/src/agents/steering/request.ts b/packages/api/src/agents/steering/request.ts
index e380535ac41..90f3319ba42 100644
--- a/packages/api/src/agents/steering/request.ts
+++ b/packages/api/src/agents/steering/request.ts
@@ -235,18 +235,22 @@ function hasTenantMismatch(
   return metadata?.tenantId != null && metadata.tenantId !== user.tenantId;
 }
 
-/** DELIBERATELY quote-independent: this exact 3-field hash is what EVERY
- *  deployed replica version computes, so a lost-ACK retry can replay its
- *  receipt no matter which replica wrote it or reads it. Quote identity is
- *  enforced separately via `SteerReceipt.requestedQuotesFingerprint`, which
- *  only quote-aware readers consult. */
+/** DELIBERATELY quote-independent and display-metadata-independent: the
+ *  legacy 3-field hash saw these same file refs before `llmDeliveryPath` was
+ *  added, so a lost-ACK retry can replay its receipt across rollout versions.
+ *  Quote identity is enforced separately via
+ *  `SteerReceipt.requestedQuotesFingerprint`, which only quote-aware readers
+ *  consult. */
 function steerFingerprint(
   text: string,
   files: Partial<TFile>[] | undefined,
   preempt: boolean,
 ): string {
+  const stableFiles = (files ?? []).map((file) =>
+    Object.fromEntries(Object.entries(file).filter(([key]) => key !== 'llmDeliveryPath')),
+  );
   return createHash('sha256')
-    .update(JSON.stringify({ text, files: files ?? [], preempt }))
+    .update(JSON.stringify({ text, files: stableFiles, preempt }))
     .digest('base64url');
 }
 
diff --git a/packages/api/src/agents/tools.spec.ts b/packages/api/src/agents/tools.spec.ts
index a49d61aaac8..d21683a668d 100644
--- a/packages/api/src/agents/tools.spec.ts
+++ b/packages/api/src/agents/tools.spec.ts
@@ -431,6 +431,27 @@ describe('buildHistoricalToolNames', () => {
 });
 
 describe('registerCodeExecutionTools', () => {
+  it('advertises selected named actions to the model', () => {
+    const result = registerCodeExecutionTools({
+      toolRegistry: undefined,
+      toolDefinitions: [],
+      includeBash: true,
+      workspaceTools: true,
+      workspaceOperations: new Set(['execute_command']),
+      workspaceEnvironment: {
+        fingerprint: 'a'.repeat(64),
+        repo: 'owner/app',
+        ref: 'main',
+        actions: ['check'],
+      },
+    });
+    const bash = result.toolDefinitions.find((def) => def.name === 'bash_tool');
+    expect(bash?.parameters).toMatchObject({
+      required: [],
+      properties: { environmentAction: { enum: ['check'] } },
+    });
+    expect(bash?.description).toContain('owner/app');
+  });
   const makeRegistry = (): LCToolRegistry => new Map() as unknown as LCToolRegistry;
 
   describe('fresh run (no pre-existing defs or registry entries)', () => {
diff --git a/packages/api/src/agents/tools.ts b/packages/api/src/agents/tools.ts
index b2a651ae2be..08f4091d29e 100644
--- a/packages/api/src/agents/tools.ts
+++ b/packages/api/src/agents/tools.ts
@@ -12,7 +12,12 @@ import {
   ReadFileToolDefinition,
   buildBashExecutionToolDescription,
 } from '@librechat/agents';
-import type { AgentToolOptions, CodeWorkspaceOperation, GraphEdge } from 'librechat-data-provider';
+import type {
+  AgentToolOptions,
+  CodeWorkspaceOperation,
+  CodeWorkspaceDescriptor,
+  GraphEdge,
+} from 'librechat-data-provider';
 import type { LCTool, LCToolRegistry } from '@librechat/agents';
 import type { ReachableAgent } from './traversal';
 import {
@@ -406,6 +411,7 @@ export interface RegisterCodeExecutionToolsParams {
   workspaceOperations?: ReadonlySet<CodeWorkspaceOperation>;
   /** Deployment ceiling advertised on attached Bash tool definitions. */
   workspaceCommandTimeoutMaxMs?: number;
+  workspaceEnvironment?: CodeWorkspaceDescriptor['environment'];
   /**
    * When `true`, the registered `bash_tool` description includes the
    * LLM-facing `{{tool<idx>turn<turn>}}` reference syntax guide so the
@@ -916,6 +922,7 @@ function createBashToolDef(
   statefulSessions = false,
   workspaceTools = false,
   workspaceCommandTimeoutMaxMs?: number,
+  workspaceEnvironment?: CodeWorkspaceDescriptor['environment'],
 ): LCTool {
   /* Passed as a variable (not an inline literal) so the extra
    * `statefulSessions` key stays assignable against pinned SDK versions
@@ -925,10 +932,10 @@ function createBashToolDef(
     name: BashExecutionToolDefinition.name,
     toolType: 'builtin',
     description: workspaceTools
-      ? buildAttachedWorkspaceBashDescription(enableToolOutputReferences)
+      ? buildAttachedWorkspaceBashDescription(enableToolOutputReferences, workspaceEnvironment)
       : buildBashExecutionToolDescription(descriptionOpts),
     parameters: (workspaceTools
-      ? buildAttachedWorkspaceBashSchema(workspaceCommandTimeoutMaxMs)
+      ? buildAttachedWorkspaceBashSchema(workspaceCommandTimeoutMaxMs, workspaceEnvironment)
       : BashExecutionToolDefinition.schema) as unknown as LCTool['parameters'],
   }) as LCTool;
 }
@@ -941,6 +948,7 @@ function buildBashToolDef(opts: {
   statefulSessions?: boolean;
   workspaceTools?: boolean;
   workspaceCommandTimeoutMaxMs?: number;
+  workspaceEnvironment?: CodeWorkspaceDescriptor['environment'];
 }): LCTool {
   /* Stateful defs are built on demand: the stateless pair covers the
    * default path, and per-run construction is negligible next to init. */
@@ -950,6 +958,7 @@ function buildBashToolDef(opts: {
       opts.statefulSessions === true,
       opts.workspaceTools === true,
       opts.workspaceCommandTimeoutMaxMs,
+      opts.workspaceEnvironment,
     );
   }
   return opts.enableToolOutputReferences
@@ -982,6 +991,7 @@ export function registerCodeExecutionTools(
     workspaceTools = false,
     workspaceOperations,
     workspaceCommandTimeoutMaxMs,
+    workspaceEnvironment,
     enableToolOutputReferences = false,
     statefulSessions = false,
   } = params;
@@ -1001,6 +1011,7 @@ export function registerCodeExecutionTools(
         statefulSessions,
         workspaceTools,
         workspaceCommandTimeoutMaxMs,
+        workspaceEnvironment,
       }),
     );
   }
diff --git a/packages/api/src/code/bridge.spec.ts b/packages/api/src/code/bridge.spec.ts
index 1e7e78c9ffe..36e1494c926 100644
--- a/packages/api/src/code/bridge.spec.ts
+++ b/packages/api/src/code/bridge.spec.ts
@@ -5,6 +5,40 @@ import {
 } from './bridge';
 
 describe('getCodeBridgeWorkerStatus', () => {
+  test('accepts the maximum declared environment metadata population', async () => {
+    const workspaces = Array.from({ length: 32 }, (_, index) => ({
+      id: `root-${index}`,
+      name: 'n'.repeat(128),
+      environment: {
+        fingerprint: 'a'.repeat(64),
+        repo: `a/${'b'.repeat(254)}`,
+        ref: '\t'.repeat(255) + 'x',
+        actions: Array.from({ length: 32 }, (_, action) => `${action}${'a'.repeat(62)}`),
+      },
+    }));
+    const payload = {
+      protocolVersion: 1,
+      workerId: 'personal-vm',
+      online: true,
+      ready: true,
+      leaseExpiresInMs: 45000,
+      capabilities: {
+        statefulWorkspace: false,
+        sandboxProfile: 'native-srt',
+        runtimes: [],
+        workspaceTools: { protocolVersion: 1, operations: ['execute_command'], workspaces },
+      },
+    };
+    expect(Buffer.byteLength(JSON.stringify(payload))).toBeGreaterThan(64 * 1024);
+    await expect(
+      getCodeBridgeWorkerStatus({
+        baseURL: 'https://code.example.com/v1',
+        token: 'token',
+        workerId: 'personal-vm',
+        fetchImpl: jest.fn().mockResolvedValue(Response.json(payload)),
+      }),
+    ).resolves.toMatchObject({ status: 'ready', workspaces });
+  });
   test('normalizes a ready worker while exposing only bounded capability metadata', async () => {
     const fetchImpl = jest.fn().mockResolvedValue(
       new Response(
@@ -171,10 +205,10 @@ describe('getCodeBridgeWorkerStatus', () => {
     );
   });
 
-  test('rejects an upstream response before buffering more than 64 KiB', async () => {
+  test('rejects an upstream response before buffering more than 256 KiB', async () => {
     const fetchImpl = jest
       .fn()
-      .mockResolvedValue(new Response(JSON.stringify({ ignored: 'x'.repeat(65 * 1024) })));
+      .mockResolvedValue(new Response(JSON.stringify({ ignored: 'x'.repeat(257 * 1024) })));
 
     await expect(
       getCodeBridgeWorkerStatus({
diff --git a/packages/api/src/code/bridge.ts b/packages/api/src/code/bridge.ts
index 0ad24ad4cbb..6b5dd940d21 100644
--- a/packages/api/src/code/bridge.ts
+++ b/packages/api/src/code/bridge.ts
@@ -3,11 +3,13 @@ import {
   CODE_WORKSPACE_ID_PATTERN,
   CODE_WORKSPACE_MAX_COUNT,
   CODE_WORKSPACE_OPERATIONS,
+  isCodeWorkspaceEnvironment,
 } from 'librechat-data-provider';
 import type { CodeWorkspaceDescriptor, CodeWorkspaceOperation } from 'librechat-data-provider';
 
 const CODE_BRIDGE_REQUEST_TIMEOUT_MS = 10_000;
-const CODE_BRIDGE_STATUS_RESPONSE_MAX_BYTES = 64 * 1024;
+// Covers 32 roots with 32 bounded action names and escaped metadata per root.
+const CODE_BRIDGE_STATUS_RESPONSE_MAX_BYTES = 256 * 1024;
 
 export type CodeBridgePrincipalType = 'deployment' | 'tenant' | 'user' | 'role' | 'group';
 
@@ -183,11 +185,12 @@ function validWorkspaceCapabilities(value: unknown): value is {
     const workspace = value as Record<string, unknown>;
     if (
       Object.keys(workspace).some(
-        (key) => key !== 'id' && key !== 'name' && key !== 'operations',
+        (key) => key !== 'id' && key !== 'name' && key !== 'operations' && key !== 'environment',
       ) ||
       typeof workspace.id !== 'string' ||
       !CODE_WORKSPACE_ID_PATTERN.test(workspace.id) ||
       ids.has(workspace.id) ||
+      (workspace.environment !== undefined && !isCodeWorkspaceEnvironment(workspace.environment)) ||
       (workspace.name !== undefined &&
         (typeof workspace.name !== 'string' ||
           workspace.name.trim().length === 0 ||
diff --git a/packages/api/src/code/capabilities.spec.ts b/packages/api/src/code/capabilities.spec.ts
index a820f6cd69d..f9c3056d1a5 100644
--- a/packages/api/src/code/capabilities.spec.ts
+++ b/packages/api/src/code/capabilities.spec.ts
@@ -333,6 +333,28 @@ describe('resolveCodeExecutionWorkspaceContext', () => {
     });
   });
 
+  it('carries validated project metadata from the selected workspace', async () => {
+    const environment = {
+      fingerprint: 'a'.repeat(64),
+      repo: 'example/app',
+      ref: 'dev',
+      actions: ['typecheck'],
+    };
+    jest.spyOn(globalThis, 'fetch').mockResolvedValue(
+      workspaceStatus([
+        { id: 'docs', environment },
+        { id: 'other', environment: { ...environment, actions: ['other'] } },
+      ]),
+    );
+    const resolved = await resolveCodeExecutionWorkspaceContext({
+      context,
+      requestedSelections: [{ environmentId: 'personal', workspaceId: 'docs' }],
+      environments,
+      getAppConfig,
+    });
+    expect(resolved.codeWorkspace?.environment).toEqual(environment);
+  });
+
   it('admits native workspace tools without enabling programmatic runtime execution', async () => {
     jest
       .spyOn(globalThis, 'fetch')
diff --git a/packages/api/src/code/capabilities.ts b/packages/api/src/code/capabilities.ts
index 9f049247a82..74a7e40469b 100644
--- a/packages/api/src/code/capabilities.ts
+++ b/packages/api/src/code/capabilities.ts
@@ -178,6 +178,7 @@ export async function resolveCodeExecutionWorkspaceContext({
     codeWorkspace: {
       ...selection,
       operations: [...(workspace.operations ?? status.operations)],
+      ...(workspace.environment ? { environment: workspace.environment } : {}),
     },
   };
 }
diff --git a/packages/api/src/code/command.spec.ts b/packages/api/src/code/command.spec.ts
index d265f5a754f..ff542a05c8f 100644
--- a/packages/api/src/code/command.spec.ts
+++ b/packages/api/src/code/command.spec.ts
@@ -66,6 +66,37 @@ function commandResponse(overrides: Record<string, unknown> = {}): Response {
 }
 
 describe('createAttachedWorkspaceBashTool', () => {
+  test('dispatches only advertised named actions with the resolved definition fingerprint', async () => {
+    const fetchImpl: CodeBridgeFetch = jest.fn(async () => commandResponse());
+    const bashTool = createAttachedWorkspaceBashTool({
+      baseUrl: 'https://code.example.com/v1/',
+      authHeaders: () => ({}),
+      workspaceId: 'project-a',
+      environment: {
+        fingerprint: 'a'.repeat(64),
+        repo: 'example/app',
+        ref: 'main',
+        actions: ['typecheck'],
+      },
+      fetchImpl,
+    });
+    await bashTool.invoke({ environmentAction: 'typecheck' });
+    const [, options] = (fetchImpl as jest.Mock).mock.calls[0];
+    expect(JSON.parse(options.body)).toMatchObject({
+      workspaceId: 'project-a',
+      environmentAction: { name: 'typecheck', fingerprint: 'a'.repeat(64) },
+      timeoutMs: 30000,
+    });
+    for (const input of [
+      { environmentAction: 'missing' },
+      { environmentAction: 'typecheck', command: 'rm x' },
+      { environmentAction: 'typecheck', cwd: 'other' },
+      {},
+    ]) {
+      await expect(bashTool.invoke(input)).rejects.toThrow();
+    }
+    expect(fetchImpl).toHaveBeenCalledTimes(1);
+  });
   test('disconnects the actual HTTP request when an invoked command is cancelled', async () => {
     let markStarted!: () => void;
     let markDisconnected!: () => void;
diff --git a/packages/api/src/code/command.ts b/packages/api/src/code/command.ts
index 25c3123378a..cd9f6875bfa 100644
--- a/packages/api/src/code/command.ts
+++ b/packages/api/src/code/command.ts
@@ -5,7 +5,11 @@ import {
   BashToolOutputReferencesGuide,
   createBashProgrammaticToolCallingTool,
 } from '@librechat/agents';
-import type { AgentGitIdentity, CodeEnvironmentUserConfigSchema } from 'librechat-data-provider';
+import type {
+  AgentGitIdentity,
+  CodeEnvironmentUserConfigSchema,
+  CodeWorkspaceDescriptor,
+} from 'librechat-data-provider';
 import type { DynamicStructuredTool } from '@librechat/agents/langchain/tools';
 import type { LCTool } from '@librechat/agents';
 import type { WorkspaceExecuteCommandResult } from './workspace';
@@ -89,6 +93,7 @@ export function resolveAttachedWorkspaceCommandTimeoutMax(
 
 export function buildAttachedWorkspaceBashSchema(
   maxTimeoutMs: number = WORKSPACE_COMMAND_DEFAULT_TIMEOUT_MS,
+  environment?: CodeWorkspaceDescriptor['environment'],
 ): NonNullable<LCTool['parameters']> {
   const effectiveMaxTimeoutMs = normalizeAttachedWorkspaceCommandTimeoutMax(maxTimeoutMs);
   return {
@@ -98,8 +103,18 @@ export function buildAttachedWorkspaceBashSchema(
       command: attachedCommandSchema,
       cwd: attachedWorkingDirectorySchema,
       timeoutMs: buildAttachedTimeoutSchema(effectiveMaxTimeoutMs),
+      ...(environment?.actions.length
+        ? {
+            environmentAction: {
+              type: 'string',
+              enum: [...environment.actions],
+              description:
+                'Run a fixed action defined by the machine owner. Supply this instead of command, args or cwd. Normal command approval rules still apply.',
+            },
+          }
+        : {}),
     },
-    required: ['command'],
+    required: environment?.actions.length ? [] : ['command'],
   };
 }
 
@@ -112,10 +127,19 @@ export const ATTACHED_WORKSPACE_BASH_SCHEMA: NonNullable<LCTool['parameters']> =
   buildAttachedWorkspaceBashSchema(),
 );
 
-export function buildAttachedWorkspaceBashDescription(enableToolOutputReferences: boolean): string {
-  return enableToolOutputReferences
+export function buildAttachedWorkspaceBashDescription(
+  enableToolOutputReferences: boolean,
+  environment?: CodeWorkspaceDescriptor['environment'],
+): string {
+  const description = enableToolOutputReferences
     ? `${ATTACHED_WORKSPACE_BASH_DESCRIPTION}\n\n${BashToolOutputReferencesGuide}`
     : ATTACHED_WORKSPACE_BASH_DESCRIPTION;
+  return (
+    description +
+    (environment
+      ? `\n\nSelected project metadata (declared by the machine owner): ${JSON.stringify({ repo: environment.repo, ref: environment.ref })}. Named actions use the environmentAction parameter and the same approval rules as commands.`
+      : '')
+  );
 }
 
 function quoteShellArgument(value: string): string {
@@ -178,6 +202,7 @@ export function createAttachedWorkspaceBashTool({
   baseUrl,
   authHeaders,
   workspaceId,
+  environment,
   gitIdentity,
   maxTimeoutMs = WORKSPACE_COMMAND_DEFAULT_TIMEOUT_MS,
   fetchImpl,
@@ -185,16 +210,22 @@ export function createAttachedWorkspaceBashTool({
   baseUrl: string;
   authHeaders: () => Promise<Record<string, string>> | Record<string, string>;
   workspaceId: string;
+  environment?: CodeWorkspaceDescriptor['environment'];
   gitIdentity?: AgentGitIdentity | null;
   /** Deployment ceiling already intersected with the protocol hard cap. */
   maxTimeoutMs?: number;
   fetchImpl?: CodeBridgeFetch;
 }): DynamicStructuredTool {
   const effectiveMaxTimeoutMs = normalizeAttachedWorkspaceCommandTimeoutMax(maxTimeoutMs);
+  const schema = structuredClone(
+    buildAttachedWorkspaceBashSchema(effectiveMaxTimeoutMs, environment),
+  );
+  const actions = environment?.actions ?? [];
   return tool(
     async (
       rawInput: {
-        command: string;
+        command?: string;
+        environmentAction?: string;
         args?: string[];
         cwd?: string;
         timeoutMs?: number;
@@ -202,15 +233,28 @@ export function createAttachedWorkspaceBashTool({
       },
       config,
     ): Promise<[string, Record<string, never>]> => {
+      const action = rawInput.environmentAction;
+      if (action !== undefined) {
+        if (
+          !environment ||
+          !actions.includes(action) ||
+          rawInput.command !== undefined ||
+          rawInput.args !== undefined ||
+          rawInput.cwd !== undefined
+        ) {
+          throw new Error('Choose an advertised environment action without command, args or cwd.');
+        }
+      } else if (typeof rawInput.command !== 'string' || rawInput.command.trim().length === 0) {
+        throw new Error('Supply a command or an advertised environment action.');
+      }
       if (rawInput.timeoutMs != null && rawInput.timeoutMs > effectiveMaxTimeoutMs) {
         throw new Error(
           `Command timeout exceeds the deployment limit of ${effectiveMaxTimeoutMs} milliseconds.`,
         );
       }
-      const command = commandWithGitIdentity(
-        commandWithArguments(rawInput.command, rawInput.args),
-        gitIdentity,
-      );
+      const command =
+        action ??
+        commandWithGitIdentity(commandWithArguments(rawInput.command!, rawInput.args), gitIdentity);
       const timeoutMs =
         rawInput.timeoutMs ?? Math.min(WORKSPACE_COMMAND_DEFAULT_TIMEOUT_MS, effectiveMaxTimeoutMs);
       const signal = config?.signal;
@@ -233,6 +277,9 @@ export function createAttachedWorkspaceBashTool({
             operation: 'execute_command',
             workspaceId,
             command,
+            ...(action && environment
+              ? { environmentAction: { name: action, fingerprint: environment.fingerprint } }
+              : {}),
             ...(rawInput.cwd ? { cwd: rawInput.cwd } : {}),
             timeoutMs,
             maxOutputBytes: DEFAULT_OUTPUT_BYTES,
@@ -255,8 +302,8 @@ export function createAttachedWorkspaceBashTool({
     },
     {
       name: BashExecutionToolDefinition.name,
-      description: ATTACHED_WORKSPACE_BASH_DESCRIPTION,
-      schema: structuredClone(buildAttachedWorkspaceBashSchema(effectiveMaxTimeoutMs)),
+      description: buildAttachedWorkspaceBashDescription(false, environment),
+      schema,
       responseFormat: 'content_and_artifact',
     },
   ) as unknown as DynamicStructuredTool;
diff --git a/packages/api/src/code/environment.live.spec.ts b/packages/api/src/code/environment.live.spec.ts
new file mode 100644
index 00000000000..76b948785a3
--- /dev/null
+++ b/packages/api/src/code/environment.live.spec.ts
@@ -0,0 +1,90 @@
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { once } from 'node:events';
+import { spawn } from 'node:child_process';
+import { mkdtemp, mkdir, writeFile, readFile, rm } from 'node:fs/promises';
+import type { CodeWorkspaceDescriptor } from 'librechat-data-provider';
+import { createAttachedWorkspaceBashTool } from './command';
+import { registerCodeExecutionTools } from '~/agents/tools';
+
+const live = process.env.LIBRECHAT_CODE_TEST_PACKAGE ? describe : describe.skip;
+
+live('native environment integration', () => {
+  test('runs a named action through the LibreChat tool, HTTP and a real native worker', async () => {
+    const directory = await mkdtemp(join(tmpdir(), 'lc-environment-live-'));
+    const root = join(directory, 'project');
+    await mkdir(root);
+    const definition = join(directory, 'environment.yaml');
+    await writeFile(
+      definition,
+      'name: project\nroot: project\nactions:\n  - name: verify\n    command: "printf verified > result.txt; printf success"\n',
+    );
+    const child = spawn(process.execPath, [join(__dirname, 'fixtures/environment.mjs')], {
+      env: { ...process.env, LIBRECHAT_CODE_TEST_DEFINITION: definition },
+      stdio: ['ignore', 'pipe', 'pipe'],
+    });
+    const exited = once(child, 'exit');
+    let errors = '';
+    child.stderr.on('data', (chunk) => {
+      errors += chunk.toString();
+    });
+    try {
+      const started = new Promise<{
+        port: number;
+        environment: CodeWorkspaceDescriptor['environment'];
+      }>((resolve, reject) => {
+        let output = '';
+        child.stdout.on('data', (chunk) => {
+          output += chunk.toString();
+          if (output.includes('\n')) {
+            try {
+              resolve(JSON.parse(output.trim()));
+            } catch (error) {
+              reject(error);
+            }
+          }
+        });
+      });
+      const ready = await Promise.race([
+        started,
+        exited.then(() => {
+          throw new Error(errors);
+        }),
+      ]);
+      const tool = createAttachedWorkspaceBashTool({
+        baseUrl: `http://127.0.0.1:${ready.port}/v1`,
+        authHeaders: () => ({}),
+        workspaceId: 'project',
+        environment: ready.environment,
+      });
+      const definitions = registerCodeExecutionTools({
+        toolRegistry: undefined,
+        toolDefinitions: [],
+        includeBash: true,
+        workspaceTools: true,
+        workspaceOperations: new Set(['execute_command']),
+        workspaceEnvironment: ready.environment,
+      });
+      const modelSchema = definitions.toolDefinitions.find(
+        (definition) => definition.name === 'bash_tool',
+      )?.parameters;
+      expect(modelSchema).toMatchObject({
+        properties: { environmentAction: { enum: ['verify'] } },
+        required: [],
+      });
+      await tool.invoke({ environmentAction: 'verify' });
+      expect(await readFile(join(root, 'result.txt'), 'utf8')).toBe('verified');
+      const stale = createAttachedWorkspaceBashTool({
+        baseUrl: `http://127.0.0.1:${ready.port}/v1`,
+        authHeaders: () => ({}),
+        workspaceId: 'project',
+        environment: { ...ready.environment!, fingerprint: 'b'.repeat(64) },
+      });
+      await expect(stale.invoke({ environmentAction: 'verify' })).rejects.toThrow();
+    } finally {
+      child.kill('SIGTERM');
+      await exited;
+      await rm(directory, { recursive: true, force: true });
+    }
+  }, 20_000);
+});
diff --git a/packages/api/src/code/fixtures/environment.mjs b/packages/api/src/code/fixtures/environment.mjs
new file mode 100644
index 00000000000..a5359d9b710
--- /dev/null
+++ b/packages/api/src/code/fixtures/environment.mjs
@@ -0,0 +1,55 @@
+import { join } from 'node:path';
+import { createServer } from 'node:http';
+import { pathToFileURL } from 'node:url';
+
+const source = process.env.LIBRECHAT_CODE_TEST_PACKAGE;
+const { loadCodeEnvironment, EnvironmentWorkspaceTools } = await import(
+  pathToFileURL(join(source, 'dist/environment.js'))
+);
+const { LocalWorkspaceTools, SandboxWorkspaceTools } = await import(
+  pathToFileURL(join(source, 'dist/workspace.js'))
+);
+const { NativeProcessWorkspaceCommandSandbox } = await import(
+  pathToFileURL(join(source, 'dist/native-process.js'))
+);
+const definition = await loadCodeEnvironment(process.env.LIBRECHAT_CODE_TEST_DEFINITION);
+const id = definition.definition.name;
+const sandbox = new NativeProcessWorkspaceCommandSandbox({
+  workspaceRoot: definition.definition.root,
+});
+await sandbox.prepare();
+const tools = new EnvironmentWorkspaceTools(
+  new SandboxWorkspaceTools({
+    workspaceTools: await LocalWorkspaceTools.create({
+      workspaces: [{ id, root: definition.definition.root }],
+    }),
+    commandWorkspaces: [id],
+    commandSandbox: sandbox,
+  }),
+  [definition],
+);
+const server = createServer(async (request, response) => {
+  try {
+    const chunks = [];
+    for await (const chunk of request) chunks.push(chunk);
+    const result = await tools.execute(JSON.parse(Buffer.concat(chunks).toString()));
+    response.setHeader('Content-Type', 'application/json');
+    response.end(JSON.stringify(result));
+  } catch {
+    response.writeHead(409, { 'Content-Type': 'application/json' });
+    response.end(JSON.stringify({ error: 'Environment action rejected' }));
+  }
+});
+server.listen(0, '127.0.0.1', () =>
+  process.stdout.write(
+    JSON.stringify({
+      port: server.address().port,
+      environment: tools.capabilities.workspaces[0].environment,
+    }) + '\n',
+  ),
+);
+process.on('SIGTERM', async () => {
+  server.closeAllConnections();
+  await sandbox.close();
+  server.close(() => process.exit(0));
+});
diff --git a/packages/api/src/code/workspace.ts b/packages/api/src/code/workspace.ts
index 900dd6d2112..5deb991b176 100644
--- a/packages/api/src/code/workspace.ts
+++ b/packages/api/src/code/workspace.ts
@@ -126,6 +126,7 @@ export interface WorkspaceExecuteCommandRequest {
   cwd?: string;
   timeoutMs?: number;
   maxOutputBytes?: number;
+  environmentAction?: { name: string; fingerprint: string };
 }
 
 export interface WorkspaceWriteRequest {
diff --git a/packages/api/src/files/encode/audio.spec.ts b/packages/api/src/files/encode/audio.spec.ts
new file mode 100644
index 00000000000..e795042fd6f
--- /dev/null
+++ b/packages/api/src/files/encode/audio.spec.ts
@@ -0,0 +1,211 @@
+import { Providers } from '@librechat/agents';
+import type { IMongoFile } from '@librechat/data-schemas';
+import type { ServerRequest } from '~/types';
+import { encodeAndFormatAudios } from './audio';
+
+jest.mock('~/files/validation', () => ({
+  validateAudio: jest.fn(),
+}));
+
+jest.mock('./utils', () => ({
+  ...jest.requireActual('./utils'),
+  getFileStream: jest.fn(),
+  getConfiguredFileSizeLimit: jest.fn(),
+  isConfiguredProviderMediaType: jest.fn(),
+}));
+
+jest.mock('./memoryGuard', () => ({
+  runGuardedEncode: jest.fn((_bytes: number, fn: () => unknown) => fn()),
+}));
+
+import { validateAudio } from '~/files/validation';
+import { getFileStream, isConfiguredProviderMediaType } from './utils';
+import { Types } from 'mongoose';
+
+const mockedValidateAudio = validateAudio as jest.MockedFunction<typeof validateAudio>;
+const mockedGetFileStream = getFileStream as jest.MockedFunction<typeof getFileStream>;
+const mockedIsConfigured = isConfiguredProviderMediaType as jest.MockedFunction<
+  typeof isConfiguredProviderMediaType
+>;
+
+const createMockFile = (type = 'audio/wav', filename = 'tone.wav'): IMongoFile =>
+  ({
+    _id: new Types.ObjectId(),
+    file_id: 'audio-1',
+    filename,
+    filepath: `/uploads/${filename}`,
+    type,
+    bytes: 1024,
+    source: 'local',
+    user: 'user-1',
+    object: 'file',
+    usage: 0,
+    createdAt: new Date(),
+    updatedAt: new Date(),
+  }) as unknown as IMongoFile;
+
+const req = { config: {} } as unknown as ServerRequest;
+const getStrategyFunctions = jest.fn();
+
+describe('encodeAndFormatAudios - provider formatting', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+    mockedValidateAudio.mockResolvedValue({ isValid: true });
+    mockedIsConfigured.mockReturnValue(false);
+    const file = createMockFile();
+    mockedGetFileStream.mockResolvedValue({
+      file,
+      content: 'AAAA',
+      metadata: {
+        file_id: file.file_id,
+        filepath: file.filepath,
+        source: file.source,
+        filename: file.filename,
+        type: file.type,
+      },
+    });
+  });
+
+  it('emits a Google media block for google', async () => {
+    const result = await encodeAndFormatAudios(
+      req,
+      [createMockFile()],
+      { provider: Providers.GOOGLE },
+      getStrategyFunctions,
+    );
+    expect(result.audios).toEqual([{ type: 'media', mimeType: 'audio/wav', data: 'AAAA' }]);
+  });
+
+  it('emits an OpenAI-compatible input_audio block for openrouter without configuration', async () => {
+    const result = await encodeAndFormatAudios(
+      req,
+      [createMockFile()],
+      { provider: Providers.OPENROUTER },
+      getStrategyFunctions,
+    );
+    expect(mockedIsConfigured).not.toHaveBeenCalled();
+    expect(result.audios).toEqual([
+      { type: 'input_audio', input_audio: { data: 'AAAA', format: 'wav' } },
+    ]);
+  });
+
+  it('drops the audio for a custom endpoint that is not configured for audio', async () => {
+    const result = await encodeAndFormatAudios(
+      req,
+      [createMockFile()],
+      { provider: Providers.OPENAI, endpoint: 'MyGateway' },
+      getStrategyFunctions,
+    );
+    expect(mockedIsConfigured).toHaveBeenCalledWith(
+      req,
+      { provider: Providers.OPENAI, endpoint: 'MyGateway' },
+      'audio/wav',
+    );
+    expect(result.audios).toEqual([]);
+    expect(result.files).toHaveLength(1);
+  });
+
+  it('emits an input_audio block for a custom endpoint whose config allows audio', async () => {
+    mockedIsConfigured.mockReturnValue(true);
+    const result = await encodeAndFormatAudios(
+      req,
+      [createMockFile()],
+      { provider: Providers.OPENAI, endpoint: 'MyGateway' },
+      getStrategyFunctions,
+    );
+    expect(result.audios).toEqual([
+      { type: 'input_audio', input_audio: { data: 'AAAA', format: 'wav' } },
+    ]);
+  });
+
+  it('never emits a block for providers without an audio path, even when configured', async () => {
+    mockedIsConfigured.mockReturnValue(true);
+    const result = await encodeAndFormatAudios(
+      req,
+      [createMockFile()],
+      { provider: Providers.ANTHROPIC },
+      getStrategyFunctions,
+    );
+    expect(result.audios).toEqual([]);
+  });
+
+  describe('input_audio format canonicalization', () => {
+    /** Re-points the `getFileStream` mock at a specific file for one test. */
+    const stageFile = (file: IMongoFile) => {
+      mockedGetFileStream.mockResolvedValue({
+        file,
+        content: 'AAAA',
+        metadata: {
+          file_id: file.file_id,
+          filepath: file.filepath,
+          source: file.source,
+          filename: file.filename,
+          type: file.type,
+        },
+      });
+    };
+
+    const formatFor = async (file: IMongoFile) => {
+      stageFile(file);
+      mockedIsConfigured.mockReturnValue(true);
+      const result = await encodeAndFormatAudios(
+        req,
+        [file],
+        { provider: Providers.OPENAI, endpoint: 'MyGateway' },
+        getStrategyFunctions,
+      );
+      return (result.audios[0] as { input_audio?: { format?: string } })?.input_audio?.format;
+    };
+
+    it.each([
+      ['audio/wave', 'clip.wave', 'wav'],
+      ['audio/x-wav', 'clip.x-wav', 'wav'],
+      ['audio/mpeg', 'clip.mpeg', 'mp3'],
+      ['audio/mpeg3', 'clip.mpeg3', 'mp3'],
+      ['audio/x-m4a', 'clip.x-m4a', 'm4a'],
+      ['audio/vorbis', 'clip.vorbis', 'ogg'],
+      ['audio/x-flac', 'clip.x-flac', 'flac'],
+    ])('canonicalizes %s to a provider-accepted format', async (type, filename, expected) => {
+      expect(await formatFor(createMockFile(type, filename))).toBe(expected);
+    });
+
+    it('derives the format from the MIME type when the filename has no extension', async () => {
+      expect(await formatFor(createMockFile('audio/mpeg', 'recording'))).toBe('mp3');
+    });
+
+    it('prefers the canonical MIME format over a mismatched extension', async () => {
+      expect(await formatFor(createMockFile('audio/mpeg', 'clip.wav'))).toBe('mp3');
+    });
+
+    it('falls back to a supported filename extension for MIME types with no mapping', async () => {
+      expect(await formatFor(createMockFile('audio/aac', 'clip.aac'))).toBe('aac');
+    });
+
+    it('throws rather than emitting an unsupported format', async () => {
+      /** `audio/wma` passes MIME validation but has no provider-accepted format. */
+      stageFile(createMockFile('audio/wma', 'recording'));
+      mockedIsConfigured.mockReturnValue(true);
+      await expect(
+        encodeAndFormatAudios(
+          req,
+          [createMockFile('audio/wma', 'recording')],
+          { provider: Providers.OPENAI, endpoint: 'MyGateway' },
+          getStrategyFunctions,
+        ),
+      ).rejects.toThrow(/supported audio format/i);
+    });
+
+    it('canonicalizes for openrouter as well', async () => {
+      stageFile(createMockFile('audio/wave', 'clip.wave'));
+      const result = await encodeAndFormatAudios(
+        req,
+        [createMockFile('audio/wave', 'clip.wave')],
+        { provider: Providers.OPENROUTER },
+        getStrategyFunctions,
+      );
+      expect(result.audios).toEqual([
+        { type: 'input_audio', input_audio: { data: 'AAAA', format: 'wav' } },
+      ]);
+    });
+  });
+});
diff --git a/packages/api/src/files/encode/audio.ts b/packages/api/src/files/encode/audio.ts
index fa155cd3b3e..ac51c8f7727 100644
--- a/packages/api/src/files/encode/audio.ts
+++ b/packages/api/src/files/encode/audio.ts
@@ -1,11 +1,13 @@
 import { Providers } from '@librechat/agents';
-import { isDocumentSupportedProvider } from 'librechat-data-provider';
+import { isDocumentSupportedProvider, isOpenAILikeProvider } from 'librechat-data-provider';
 import type { IMongoFile } from '@librechat/data-schemas';
 import type { ServerRequest, StrategyFunctions, AudioResult } from '~/types';
 import {
   getFileStream,
+  getAudioFormat,
   getConfiguredFileSizeLimit,
   isAttachmentObjectNotFoundError,
+  isConfiguredProviderMediaType,
 } from './utils';
 import { validateAudio } from '~/files/validation';
 import { runGuardedEncode } from './memoryGuard';
@@ -15,7 +17,7 @@ import { runGuardedEncode } from './memoryGuard';
  * @param req - The request object
  * @param files - Array of audio files
  * @param params - Object containing provider and optional endpoint
- * @param params.provider - The provider to format for (currently only google is supported)
+ * @param params.provider - The provider to format for
  * @param params.endpoint - Optional endpoint name for file config lookup
  * @param getStrategyFunctions - Function to get strategy functions
  * @returns Promise that resolves to audio and file metadata
@@ -91,13 +93,22 @@ export async function encodeAndFormatAudios(
         mimeType: file.type,
         data: content,
       });
-    } else if (provider === Providers.OPENROUTER) {
-      // Extract format from filename extension (e.g., 'audio.mp3' -> 'mp3')
-      // OpenRouter expects format values like: wav, mp3, aiff, aac, ogg, flac, m4a, pcm16, pcm24
-      // Note: MIME types don't always match (e.g., 'audio/mpeg' is mp3, not mpeg), so that is why we are using the file extension instead
-      const format = file.filename.split('.').pop()?.toLowerCase();
+    } else if (
+      provider === Providers.OPENROUTER ||
+      (isOpenAILikeProvider(provider) &&
+        isConfiguredProviderMediaType(req, { provider, endpoint }, file.type))
+    ) {
+      /** OpenAI-compatible `input_audio` part (OpenRouter, vLLM, and other gateways).
+       * Custom endpoints only get here when the admin listed audio types in the
+       * endpoint's `supportedMimeTypes`, since not every gateway accepts audio. */
+      /** Canonicalized from the MIME type: the accepted MIME list contains aliases
+       * (`audio/wave`, `audio/mpeg`) that are not valid format values, and the filename
+       * may carry no extension at all. */
+      const format = getAudioFormat(file.type, file.filename);
       if (!format) {
-        throw new Error(`Could not extract audio format from filename: ${file.filename}`);
+        throw new Error(
+          `Could not determine a supported audio format for "${file.filename}" (${file.type})`,
+        );
       }
       result.audios.push({
         type: 'input_audio',
diff --git a/packages/api/src/files/encode/utils.spec.ts b/packages/api/src/files/encode/utils.spec.ts
index 24367409c7a..d4882d952dd 100644
--- a/packages/api/src/files/encode/utils.spec.ts
+++ b/packages/api/src/files/encode/utils.spec.ts
@@ -1,6 +1,13 @@
 import { Readable } from 'node:stream';
+import { Providers } from '@librechat/agents';
+import { audioMimeTypes } from 'librechat-data-provider';
 import type { ServerRequest } from '~/types';
-import { AttachmentObjectNotFoundError, getFileStream } from './utils';
+import {
+  AttachmentObjectNotFoundError,
+  getAudioFormat,
+  getFileStream,
+  isConfiguredProviderMediaType,
+} from './utils';
 
 const file = {
   file_id: 'file-1',
@@ -84,3 +91,110 @@ describe('getFileStream', () => {
     expect(getDownloadStream).toHaveBeenCalledWith(req, legacyUrl);
   });
 });
+
+/** Uses the real data-provider merge logic so the "inherited default" identity check is exercised. */
+const reqWith = (fileConfig: unknown): ServerRequest =>
+  ({ config: fileConfig === undefined ? undefined : { fileConfig } }) as unknown as ServerRequest;
+
+describe('isConfiguredProviderMediaType', () => {
+  const params = { provider: Providers.OPENAI, endpoint: 'MyGateway' };
+
+  it('is false without any fileConfig', () => {
+    expect(isConfiguredProviderMediaType(reqWith(undefined), params, 'video/mp4')).toBe(false);
+  });
+
+  it('is false when the endpoint only inherits the built-in default list', () => {
+    const req = reqWith({ endpoints: { OtherEndpoint: { fileLimit: 3 } } });
+    expect(isConfiguredProviderMediaType(req, params, 'video/mp4')).toBe(false);
+    expect(isConfiguredProviderMediaType(req, params, 'audio/wav')).toBe(false);
+  });
+
+  it('is true when the endpoint config explicitly lists the media type', () => {
+    const req = reqWith({
+      endpoints: { MyGateway: { supportedMimeTypes: ['image/.*', 'application/pdf', 'video/.*'] } },
+    });
+    expect(isConfiguredProviderMediaType(req, params, 'video/mp4')).toBe(true);
+    expect(isConfiguredProviderMediaType(req, params, 'audio/wav')).toBe(false);
+  });
+
+  it('is true for a permissive config', () => {
+    const req = reqWith({ endpoints: { MyGateway: { supportedMimeTypes: ['.*'] } } });
+    expect(isConfiguredProviderMediaType(req, params, 'audio/wav')).toBe(true);
+  });
+
+  it('falls back to the provider key when no endpoint is given', () => {
+    const req = reqWith({ endpoints: { openAI: { supportedMimeTypes: ['audio/.*'] } } });
+    expect(isConfiguredProviderMediaType(req, { provider: Providers.OPENAI }, 'audio/wav')).toBe(
+      true,
+    );
+  });
+});
+
+describe('getAudioFormat', () => {
+  it.each([
+    ['audio/mp3', 'mp3'],
+    ['audio/mpeg', 'mp3'],
+    ['audio/mpeg3', 'mp3'],
+    ['audio/wav', 'wav'],
+    ['audio/wave', 'wav'],
+    ['audio/x-wav', 'wav'],
+    ['audio/ogg', 'ogg'],
+    ['audio/vorbis', 'ogg'],
+    ['audio/mp4', 'm4a'],
+    ['audio/x-m4a', 'm4a'],
+    ['audio/flac', 'flac'],
+    ['audio/x-flac', 'flac'],
+  ])('maps %s to %s regardless of the filename', (mimeType, expected) => {
+    expect(getAudioFormat(mimeType, 'clip.bogus')).toBe(expected);
+    expect(getAudioFormat(mimeType, 'recording')).toBe(expected);
+  });
+
+  it('is case-insensitive for the MIME type', () => {
+    expect(getAudioFormat('AUDIO/WAVE', 'clip.wave')).toBe('wav');
+  });
+
+  it('falls back to a supported extension when the MIME type is unmapped', () => {
+    expect(getAudioFormat('audio/unknown', 'clip.mp3')).toBe('mp3');
+    expect(getAudioFormat('audio/unknown', 'clip.PCM16')).toBe('pcm16');
+  });
+
+  it('rejects an unsupported extension rather than passing it through', () => {
+    expect(getAudioFormat('audio/unknown', 'clip.wave')).toBeUndefined();
+    expect(getAudioFormat('audio/unknown', 'clip.exe')).toBeUndefined();
+  });
+
+  it('returns undefined when the filename has no extension and the MIME is unmapped', () => {
+    expect(getAudioFormat('audio/wma', 'recording')).toBeUndefined();
+    expect(getAudioFormat('', '')).toBeUndefined();
+  });
+
+  it('does not treat a leading-dot filename as an extension', () => {
+    expect(getAudioFormat('audio/unknown', '.mp3')).toBeUndefined();
+  });
+
+  /** Guards against the accepted-MIME list drifting ahead of the format mapping. */
+  it('resolves a format for every accepted audio MIME type that has one', () => {
+    const accepted = [
+      'audio/mp3',
+      'audio/mpeg',
+      'audio/mpeg3',
+      'audio/wav',
+      'audio/wave',
+      'audio/x-wav',
+      'audio/ogg',
+      'audio/vorbis',
+      'audio/mp4',
+      'audio/m4a',
+      'audio/x-m4a',
+      'audio/flac',
+      'audio/x-flac',
+      'audio/webm',
+      'audio/aac',
+      'audio/opus',
+    ];
+    for (const mimeType of accepted) {
+      expect(audioMimeTypes.test(mimeType)).toBe(true);
+      expect(getAudioFormat(mimeType, 'recording')).toBeDefined();
+    }
+  });
+});
diff --git a/packages/api/src/files/encode/utils.ts b/packages/api/src/files/encode/utils.ts
index 7d7ac21a3a7..9c39ce2c13c 100644
--- a/packages/api/src/files/encode/utils.ts
+++ b/packages/api/src/files/encode/utils.ts
@@ -1,6 +1,11 @@
 import getStream from 'get-stream';
 import { Providers } from '@librechat/agents';
-import { FileSources, mergeFileConfig, getEndpointFileConfig } from 'librechat-data-provider';
+import {
+  FileSources,
+  mergeFileConfig,
+  isExplicitMimeConfig,
+  getEndpointFileConfig,
+} from 'librechat-data-provider';
 import type { ServerRequest, StrategyFunctions, ProcessedFile } from '~/types';
 import type { StoredFileRef } from '~/storage/path';
 import { resolveDownloadPath } from '~/storage/path';
@@ -70,6 +75,107 @@ export const getConfiguredFileSizeLimit = (
   return endpointConfig?.fileSizeLimit;
 };
 
+/**
+ * Whether the admin explicitly allowed `mimeType` for this endpoint via
+ * `fileConfig.endpoints.<name>.supportedMimeTypes`. The inherited default list does
+ * not count as opting in, mirroring the client's picker and drag-drop logic, so an
+ * OpenAI-compatible endpoint only receives video/audio parts when configured for them.
+ * @param req - The server request object containing config
+ * @param params - Object containing provider and optional endpoint
+ * @param params.provider - The provider to look up
+ * @param params.endpoint - Optional endpoint name for lookup
+ * @param mimeType - The MIME type of the file being attached
+ * @returns True when the endpoint config explicitly matches the MIME type
+ */
+export const isConfiguredProviderMediaType = (
+  req: ServerRequest,
+  params: {
+    provider: Providers;
+    endpoint?: string;
+  },
+  mimeType: string,
+): boolean => {
+  if (!req.config?.fileConfig) {
+    return false;
+  }
+  const { provider, endpoint } = params;
+  const fileConfig = mergeFileConfig(req.config.fileConfig);
+  const endpointConfig = getEndpointFileConfig({
+    fileConfig,
+    endpoint: endpoint ?? provider,
+  });
+  const types = endpointConfig?.supportedMimeTypes;
+  if (!isExplicitMimeConfig(types)) {
+    return false;
+  }
+  return fileConfig.checkType?.(mimeType, types) ?? false;
+};
+
+/**
+ * Maps accepted audio MIME types to the format token OpenAI-compatible providers expect.
+ * Mirrors the canonicalization in `api/server/services/Files/Audio/STTService.js`: the
+ * accepted MIME list carries aliases (`audio/wave`, `audio/x-wav`, `audio/mpeg`) whose
+ * names are not themselves valid format values.
+ */
+const audioMimeToFormat: Record<string, string> = {
+  'audio/mp3': 'mp3',
+  'audio/mpeg': 'mp3',
+  'audio/mpeg3': 'mp3',
+  'audio/wav': 'wav',
+  'audio/wave': 'wav',
+  'audio/x-wav': 'wav',
+  'audio/ogg': 'ogg',
+  'audio/vorbis': 'ogg',
+  'audio/opus': 'ogg',
+  'audio/mp4': 'm4a',
+  'audio/m4a': 'm4a',
+  'audio/x-m4a': 'm4a',
+  'audio/flac': 'flac',
+  'audio/x-flac': 'flac',
+  'audio/webm': 'webm',
+  'audio/aac': 'aac',
+};
+
+/**
+ * Format values OpenAI-compatible providers accept for an `input_audio` part.
+ * Used to validate an extension-derived fallback so an arbitrary filename suffix
+ * never reaches the provider as a format.
+ */
+const supportedAudioFormats = new Set([
+  'wav',
+  'mp3',
+  'aiff',
+  'aac',
+  'ogg',
+  'flac',
+  'm4a',
+  'webm',
+  'pcm16',
+  'pcm24',
+]);
+
+/**
+ * Resolves the `input_audio.format` value for a file.
+ *
+ * Prefers the MIME type, which is validated upstream against `audioMimeTypes`, because
+ * the filename extension is user-controlled: it may be absent (`recording`), an alias
+ * that is not a valid format (`clip.wave`), or disagree with the actual content. Falls
+ * back to the extension only when it is itself a supported format.
+ * @param mimeType - The file's MIME type
+ * @param filename - The original filename
+ * @returns The canonical format, or undefined when neither source yields a supported one
+ */
+export const getAudioFormat = (mimeType: string, filename: string): string | undefined => {
+  const fromMime = audioMimeToFormat[mimeType?.toLowerCase()];
+  if (fromMime) {
+    return fromMime;
+  }
+  const parts = filename?.toLowerCase().split('.') ?? [];
+  /** `parts[0]` must be non-empty so a dotfile (`.mp3`) is not read as an extension. */
+  const extension = parts.length > 1 && parts[0] ? parts[parts.length - 1] : undefined;
+  return extension && supportedAudioFormats.has(extension) ? extension : undefined;
+};
+
 /**
  * Processes a file by downloading and encoding it to base64
  * @param req - Express request object
diff --git a/packages/api/src/files/encode/video.spec.ts b/packages/api/src/files/encode/video.spec.ts
new file mode 100644
index 00000000000..06da3028d0f
--- /dev/null
+++ b/packages/api/src/files/encode/video.spec.ts
@@ -0,0 +1,130 @@
+import { Providers } from '@librechat/agents';
+import type { IMongoFile } from '@librechat/data-schemas';
+import type { ServerRequest } from '~/types';
+import { encodeAndFormatVideos } from './video';
+
+jest.mock('~/files/validation', () => ({
+  validateVideo: jest.fn(),
+}));
+
+jest.mock('./utils', () => ({
+  getFileStream: jest.fn(),
+  getConfiguredFileSizeLimit: jest.fn(),
+  isConfiguredProviderMediaType: jest.fn(),
+}));
+
+jest.mock('./memoryGuard', () => ({
+  runGuardedEncode: jest.fn((_bytes: number, fn: () => unknown) => fn()),
+}));
+
+import { validateVideo } from '~/files/validation';
+import { getFileStream, isConfiguredProviderMediaType } from './utils';
+import { Types } from 'mongoose';
+
+const mockedValidateVideo = validateVideo as jest.MockedFunction<typeof validateVideo>;
+const mockedGetFileStream = getFileStream as jest.MockedFunction<typeof getFileStream>;
+const mockedIsConfigured = isConfiguredProviderMediaType as jest.MockedFunction<
+  typeof isConfiguredProviderMediaType
+>;
+
+const createMockFile = (type = 'video/mp4'): IMongoFile =>
+  ({
+    _id: new Types.ObjectId(),
+    file_id: 'video-1',
+    filename: 'clip.mp4',
+    filepath: '/uploads/clip.mp4',
+    type,
+    bytes: 1024,
+    source: 'local',
+    user: 'user-1',
+    object: 'file',
+    usage: 0,
+    createdAt: new Date(),
+    updatedAt: new Date(),
+  }) as unknown as IMongoFile;
+
+const req = { config: {} } as unknown as ServerRequest;
+const getStrategyFunctions = jest.fn();
+
+describe('encodeAndFormatVideos - provider formatting', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+    mockedValidateVideo.mockResolvedValue({ isValid: true });
+    mockedIsConfigured.mockReturnValue(false);
+    const file = createMockFile();
+    mockedGetFileStream.mockResolvedValue({
+      file,
+      content: 'AAAA',
+      metadata: {
+        file_id: file.file_id,
+        filepath: file.filepath,
+        source: file.source,
+        filename: file.filename,
+        type: file.type,
+      },
+    });
+  });
+
+  it('emits a Google media block for google', async () => {
+    const result = await encodeAndFormatVideos(
+      req,
+      [createMockFile()],
+      { provider: Providers.GOOGLE },
+      getStrategyFunctions,
+    );
+    expect(result.videos).toEqual([{ type: 'media', mimeType: 'video/mp4', data: 'AAAA' }]);
+  });
+
+  it('emits an OpenAI-compatible video_url block for openrouter without configuration', async () => {
+    const result = await encodeAndFormatVideos(
+      req,
+      [createMockFile()],
+      { provider: Providers.OPENROUTER },
+      getStrategyFunctions,
+    );
+    expect(mockedIsConfigured).not.toHaveBeenCalled();
+    expect(result.videos).toEqual([
+      { type: 'video_url', video_url: { url: 'data:video/mp4;base64,AAAA' } },
+    ]);
+  });
+
+  it('drops the video for a custom endpoint that is not configured for video', async () => {
+    const result = await encodeAndFormatVideos(
+      req,
+      [createMockFile()],
+      { provider: Providers.OPENAI, endpoint: 'MyGateway' },
+      getStrategyFunctions,
+    );
+    expect(mockedIsConfigured).toHaveBeenCalledWith(
+      req,
+      { provider: Providers.OPENAI, endpoint: 'MyGateway' },
+      'video/mp4',
+    );
+    expect(result.videos).toEqual([]);
+    expect(result.files).toHaveLength(1);
+  });
+
+  it('emits a video_url block for a custom endpoint whose config allows video', async () => {
+    mockedIsConfigured.mockReturnValue(true);
+    const result = await encodeAndFormatVideos(
+      req,
+      [createMockFile()],
+      { provider: Providers.OPENAI, endpoint: 'MyGateway' },
+      getStrategyFunctions,
+    );
+    expect(result.videos).toEqual([
+      { type: 'video_url', video_url: { url: 'data:video/mp4;base64,AAAA' } },
+    ]);
+  });
+
+  it('never emits a block for providers without a video path, even when configured', async () => {
+    mockedIsConfigured.mockReturnValue(true);
+    const result = await encodeAndFormatVideos(
+      req,
+      [createMockFile()],
+      { provider: Providers.ANTHROPIC },
+      getStrategyFunctions,
+    );
+    expect(result.videos).toEqual([]);
+  });
+});
diff --git a/packages/api/src/files/encode/video.ts b/packages/api/src/files/encode/video.ts
index 52a9331c8d5..2715b36eed9 100644
--- a/packages/api/src/files/encode/video.ts
+++ b/packages/api/src/files/encode/video.ts
@@ -1,11 +1,12 @@
 import { Providers } from '@librechat/agents';
-import { isDocumentSupportedProvider } from 'librechat-data-provider';
+import { isDocumentSupportedProvider, isOpenAILikeProvider } from 'librechat-data-provider';
 import type { IMongoFile } from '@librechat/data-schemas';
 import type { ServerRequest, StrategyFunctions, VideoResult } from '~/types';
 import {
   getFileStream,
   getConfiguredFileSizeLimit,
   isAttachmentObjectNotFoundError,
+  isConfiguredProviderMediaType,
 } from './utils';
 import { validateVideo } from '~/files/validation';
 import { runGuardedEncode } from './memoryGuard';
@@ -91,7 +92,14 @@ export async function encodeAndFormatVideos(
         mimeType: file.type,
         data: content,
       });
-    } else if (provider === Providers.OPENROUTER) {
+    } else if (
+      provider === Providers.OPENROUTER ||
+      (isOpenAILikeProvider(provider) &&
+        isConfiguredProviderMediaType(req, { provider, endpoint }, file.type))
+    ) {
+      /** OpenAI-compatible `video_url` part (OpenRouter, vLLM, and other gateways).
+       * Custom endpoints only get here when the admin listed video types in the
+       * endpoint's `supportedMimeTypes`, since not every gateway accepts video. */
       result.videos.push({
         type: 'video_url',
         video_url: {
diff --git a/packages/api/src/files/extract.ts b/packages/api/src/files/extract.ts
index 190e243db8c..48606c6ebae 100644
--- a/packages/api/src/files/extract.ts
+++ b/packages/api/src/files/extract.ts
@@ -1,3 +1,4 @@
+import { megabyte } from 'librechat-data-provider';
 import type { FiltersConfig } from 'librechat-data-provider';
 import {
   getBlockedUninspectableFileField,
@@ -6,6 +7,13 @@ import {
 } from '~/protection/files';
 import { getSafeErrorMetadata } from '~/utils/errors';
 
+/**
+ * The most extracted text a file document can hold. MongoDB refuses a document past 16 MiB and
+ * the text shares it with the file's other fields, so this bounds storage rather than policy:
+ * what reaches a model is governed by `fileContextCharLimit` and `fileTokenLimit`.
+ */
+export const MAX_STORED_EXTRACTED_TEXT_BYTES: number = 15 * megabyte;
+
 interface ExtractedFileText {
   readonly text?: string | null;
 }
diff --git a/packages/api/src/files/index.ts b/packages/api/src/files/index.ts
index 87df6f41054..5bda69aea7b 100644
--- a/packages/api/src/files/index.ts
+++ b/packages/api/src/files/index.ts
@@ -16,6 +16,7 @@ export * from './preflight';
 export * from './provision';
 export * from './upload/routing';
 export * from './upload/diagnostics';
+export * from './upload/fallback';
 export * from './rag';
 export * from './regexEngine';
 export * from './retention';
diff --git a/packages/api/src/files/upload/errors.ts b/packages/api/src/files/upload/errors.ts
new file mode 100644
index 00000000000..11e579abb8a
--- /dev/null
+++ b/packages/api/src/files/upload/errors.ts
@@ -0,0 +1,9 @@
+/** A direct audio attachment must be representable before the upload is persisted. */
+export class UnsupportedProviderAudioError extends Error {
+  readonly userErrorStatusCode = 415;
+
+  constructor() {
+    super('com_error_files_provider_audio_format');
+    this.name = 'UnsupportedProviderAudioError';
+  }
+}
diff --git a/packages/api/src/files/upload/fallback.spec.ts b/packages/api/src/files/upload/fallback.spec.ts
new file mode 100644
index 00000000000..1b65139d1fe
--- /dev/null
+++ b/packages/api/src/files/upload/fallback.spec.ts
@@ -0,0 +1,210 @@
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import type { FiltersConfig } from 'librechat-data-provider';
+import type { UploadFallbackTextExtractors } from './fallback';
+import {
+  UPLOAD_FALLBACK_TEXT_PLANS,
+  getUploadFallbackTextPlan,
+  resolveUploadFallbackText,
+} from './fallback';
+import { MAX_STORED_EXTRACTED_TEXT_BYTES } from '~/files/extract';
+import { parseDocument } from '~/files/documents/crud';
+import { parseTextNative } from '~/files/text';
+
+const XLSX_MIME = 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet';
+const csvRoute = {
+  deliveryPath: 'none' as const,
+  destinationChosen: false,
+  isMessageAttachment: true,
+  mimeType: 'text/csv',
+  endpointConfig: { textFallbackWithoutTools: true },
+};
+
+describe('getUploadFallbackTextPlan', () => {
+  it('reads a natively textual file left to tools', () => {
+    expect(getUploadFallbackTextPlan(csvRoute)).toBe(UPLOAD_FALLBACK_TEXT_PLANS.nativeText);
+  });
+
+  it('parses a spreadsheet with the built-in document parser', () => {
+    expect(getUploadFallbackTextPlan({ ...csvRoute, mimeType: XLSX_MIME })).toBe(
+      UPLOAD_FALLBACK_TEXT_PLANS.documentParser,
+    );
+  });
+
+  it('runs nothing for a type no built-in extractor can read', () => {
+    expect(getUploadFallbackTextPlan({ ...csvRoute, mimeType: 'image/png' })).toBeNull();
+    expect(getUploadFallbackTextPlan({ ...csvRoute, mimeType: 'application/zip' })).toBeNull();
+  });
+
+  it('runs nothing where the upload endpoint has not enabled the fallback', () => {
+    expect(getUploadFallbackTextPlan({ ...csvRoute, endpointConfig: undefined })).toBeNull();
+    expect(
+      getUploadFallbackTextPlan({
+        ...csvRoute,
+        endpointConfig: { textFallbackWithoutTools: false },
+      }),
+    ).toBeNull();
+  });
+
+  it('runs nothing for an upload that already reaches the model', () => {
+    expect(getUploadFallbackTextPlan({ ...csvRoute, deliveryPath: 'text' })).toBeNull();
+    expect(getUploadFallbackTextPlan({ ...csvRoute, deliveryPath: 'provider' })).toBeNull();
+  });
+
+  it('runs nothing for a destination the user chose, which no turn re-resolves', () => {
+    expect(getUploadFallbackTextPlan({ ...csvRoute, destinationChosen: true })).toBeNull();
+  });
+
+  it('runs nothing for a file kept on an agent, which no turn delivers as text', () => {
+    expect(getUploadFallbackTextPlan({ ...csvRoute, isMessageAttachment: false })).toBeNull();
+  });
+});
+
+describe('resolveUploadFallbackText', () => {
+  const { mimeType: _mimeType, ...route } = csvRoute;
+  const privateTokenFilters: FiltersConfig = {
+    files: {
+      pii: {
+        fields: ['extracted_text'],
+        starterPatterns: [],
+        customPatterns: [{ id: 'private', label: 'private token', regex: 'PRIVATE-[A-Z]+' }],
+      },
+    },
+  };
+  let uploadDir: string;
+
+  beforeAll(() => {
+    uploadDir = fs.mkdtempSync(path.join(os.tmpdir(), 'fallback-text-'));
+  });
+
+  afterAll(() => {
+    fs.rmSync(uploadDir, { recursive: true, force: true });
+  });
+
+  /** A CSV upload as multer leaves it; without content, its temporary file is already gone. */
+  function csvUpload(name: string, content?: string): Express.Multer.File {
+    const filePath = path.join(uploadDir, name);
+    if (content != null) {
+      fs.writeFileSync(filePath, content);
+    }
+    return {
+      originalname: name,
+      path: filePath,
+      mimetype: 'text/csv',
+      size: content != null ? Buffer.byteLength(content) : 0,
+    } as Express.Multer.File;
+  }
+
+  /** The real built-in extractors, observed. */
+  function spiedExtractors() {
+    return {
+      parseDocument: jest.fn(parseDocument),
+      parseTextNative: jest.fn(parseTextNative),
+    } satisfies UploadFallbackTextExtractors;
+  }
+
+  it('stores the native text of a CSV without running the document parser', async () => {
+    const extractors = spiedExtractors();
+    const file = csvUpload('sales.csv', 'region,total\nwest,4');
+
+    await expect(
+      resolveUploadFallbackText({ ...route, file, fileId: 'file-1', extractors }),
+    ).resolves.toBe('region,total\nwest,4');
+    expect(extractors.parseTextNative).toHaveBeenCalledWith(file);
+    expect(extractors.parseDocument).not.toHaveBeenCalled();
+  });
+
+  it('stores the parsed text of a spreadsheet without decoding its bytes', async () => {
+    const extractors = spiedExtractors();
+    const file = {
+      originalname: 'sample.xlsx',
+      path: path.join(__dirname, '../documents/sample.xlsx'),
+      mimetype: XLSX_MIME,
+    } as Express.Multer.File;
+
+    await expect(
+      resolveUploadFallbackText({ ...route, file, fileId: 'file-1', extractors }),
+    ).resolves.toBe('Sheet One:\nData,on,first,sheet\nSecond Sheet:\nData,On\nSecond,Sheet\n');
+    expect(extractors.parseDocument).toHaveBeenCalledWith({ file });
+    expect(extractors.parseTextNative).not.toHaveBeenCalled();
+  });
+
+  it('extracts nothing when no plan applies', async () => {
+    const extractors = spiedExtractors();
+
+    await expect(
+      resolveUploadFallbackText({
+        ...route,
+        isMessageAttachment: false,
+        file: csvUpload('kept.csv', 'region,total'),
+        fileId: 'file-1',
+        extractors,
+      }),
+    ).resolves.toBeUndefined();
+    expect(extractors.parseDocument).not.toHaveBeenCalled();
+    expect(extractors.parseTextNative).not.toHaveBeenCalled();
+  });
+
+  it('keeps the upload when extraction fails', async () => {
+    await expect(
+      resolveUploadFallbackText({ ...route, file: csvUpload('missing.csv'), fileId: 'file-1' }),
+    ).resolves.toBeUndefined();
+  });
+
+  it('stores nothing for text with no content', async () => {
+    await expect(
+      resolveUploadFallbackText({ ...route, file: csvUpload('blank.csv', '  \n '), fileId: 'f' }),
+    ).resolves.toBeUndefined();
+  });
+
+  it('stores nothing past the extracted-text storage cap', async () => {
+    const extractors: UploadFallbackTextExtractors = {
+      parseDocument,
+      parseTextNative: async () => ({ text: 'a'.repeat(MAX_STORED_EXTRACTED_TEXT_BYTES + 1) }),
+    };
+
+    await expect(
+      resolveUploadFallbackText({
+        ...route,
+        file: csvUpload('huge.csv', 'a'),
+        fileId: 'file-1',
+        extractors,
+      }),
+    ).resolves.toBeUndefined();
+  });
+
+  it('stores nothing a configured content policy flags, and keeps text it does not', async () => {
+    await expect(
+      resolveUploadFallbackText({
+        ...route,
+        file: csvUpload('flagged.csv', 'token,PRIVATE-SECRET'),
+        fileId: 'file-1',
+        filters: privateTokenFilters,
+      }),
+    ).resolves.toBeUndefined();
+    await expect(
+      resolveUploadFallbackText({
+        ...route,
+        file: csvUpload('clean.csv', 'region,total'),
+        fileId: 'file-2',
+        filters: privateTokenFilters,
+      }),
+    ).resolves.toBe('region,total');
+  });
+
+  it('stores nothing a blocking policy cannot inspect', async () => {
+    const filters: FiltersConfig = {
+      files: { pii: { fields: ['extracted_text'], starterPatterns: [], uninspectable: 'block' } },
+    };
+
+    await expect(
+      resolveUploadFallbackText({
+        ...route,
+        file: csvUpload('empty.csv', ''),
+        fileId: 'file-1',
+        filters,
+      }),
+    ).resolves.toBeUndefined();
+  });
+});
diff --git a/packages/api/src/files/upload/fallback.ts b/packages/api/src/files/upload/fallback.ts
new file mode 100644
index 00000000000..96b8bce20ac
--- /dev/null
+++ b/packages/api/src/files/upload/fallback.ts
@@ -0,0 +1,143 @@
+import { logger } from '@librechat/data-schemas';
+import { isNativelyReadableText, documentParserMimeTypes } from 'librechat-data-provider';
+import type {
+  FiltersConfig,
+  EndpointFileConfig,
+  TDefaultLLMDeliveryPath,
+} from 'librechat-data-provider';
+import {
+  extractInspectableFileText,
+  getFileExtractionLogDetails,
+  MAX_STORED_EXTRACTED_TEXT_BYTES,
+} from '~/files/extract';
+import { extractFileContent } from '~/protection/adapters/submissions';
+import { hasActiveFileFieldPolicy } from '~/protection/files';
+import { parseDocument } from '~/files/documents/crud';
+import { inspectContent } from '~/protection/runtime';
+import { parseTextNative } from '~/files/text';
+
+export const UPLOAD_FALLBACK_TEXT_PLANS = {
+  documentParser: 'document_parser',
+  nativeText: 'native_text',
+} as const;
+
+export type UploadFallbackTextPlan =
+  (typeof UPLOAD_FALLBACK_TEXT_PLANS)[keyof typeof UPLOAD_FALLBACK_TEXT_PLANS];
+
+export interface UploadFallbackTextRoute {
+  /** The route the upload resolved to. */
+  deliveryPath: TDefaultLLMDeliveryPath;
+  /** Whether the user chose the destination, by tool resource or the legacy chooser. */
+  destinationChosen: boolean;
+  /** Whether the upload attaches to a message; an agent's own tool files never reach a prompt. */
+  isMessageAttachment: boolean;
+  mimeType: string;
+  /** The upload endpoint's file config, which opts in through `textFallbackWithoutTools`. */
+  endpointConfig?: Pick<EndpointFileConfig, 'textFallbackWithoutTools'>;
+}
+
+interface ExtractedText {
+  readonly text?: string | null;
+}
+
+/** The built-in readers fallback text comes from. */
+export interface UploadFallbackTextExtractors {
+  parseDocument: (params: { file: Express.Multer.File }) => Promise<ExtractedText>;
+  parseTextNative: (file: Express.Multer.File) => Promise<ExtractedText>;
+}
+
+const builtInExtractors: UploadFallbackTextExtractors = { parseDocument, parseTextNative };
+
+/**
+ * Which built-in extractor stores text for an upload left to tools, or `null` when none runs.
+ *
+ * Where the endpoint enables `textFallbackWithoutTools`, a turn that runs no tool able to read a
+ * `none`-routed file delivers this text instead (`resolveTurnLLMDeliveryPath`). Only an inferred
+ * route on a message attachment qualifies: a turn never re-resolves a destination the user chose,
+ * and files kept on an agent's tool resources never reach a prompt. A file filed
+ * under a tool that reads it still gets text, because a later turn may run without that tool: a
+ * handoff agent, or the same agent after its tools or grants change. Only built-in extractors
+ * run, so a file meant for a tool never costs a RAG or OCR call.
+ */
+export function getUploadFallbackTextPlan(
+  route: UploadFallbackTextRoute,
+): UploadFallbackTextPlan | null {
+  if (
+    route.endpointConfig?.textFallbackWithoutTools !== true ||
+    route.deliveryPath !== 'none' ||
+    route.destinationChosen ||
+    !route.isMessageAttachment
+  ) {
+    return null;
+  }
+  if (documentParserMimeTypes.some((pattern) => pattern.test(route.mimeType))) {
+    return UPLOAD_FALLBACK_TEXT_PLANS.documentParser;
+  }
+  return isNativelyReadableText(route.mimeType) ? UPLOAD_FALLBACK_TEXT_PLANS.nativeText : null;
+}
+
+/**
+ * Text a turn without a reading tool can fall back to for this upload, when one applies.
+ *
+ * Reads the upload before storage can move it, with the extractor its plan names. Best effort by
+ * design: an extractor failure, text a policy cannot inspect, an overrun of the storage cap, or a
+ * content finding leaves the upload without fallback text rather than refusing a file whose
+ * primary reader is a tool. Text that is delivered later is inspected again as model-bound
+ * content.
+ */
+export async function resolveUploadFallbackText({
+  file,
+  fileId,
+  filters,
+  extractors = builtInExtractors,
+  ...route
+}: Omit<UploadFallbackTextRoute, 'mimeType'> & {
+  file: Express.Multer.File;
+  fileId: string;
+  filters?: FiltersConfig;
+  extractors?: UploadFallbackTextExtractors;
+}): Promise<string | undefined> {
+  const plan = getUploadFallbackTextPlan({ ...route, mimeType: file.mimetype });
+  if (plan == null) {
+    return undefined;
+  }
+  const skip = (reason: string, error?: unknown): undefined => {
+    const { fileLabel, errorMetadata } = getFileExtractionLogDetails({
+      filters,
+      filename: file.originalname,
+      fileId,
+      error,
+    });
+    logger.warn(
+      `[resolveUploadFallbackText] No fallback text for ${fileLabel}: ${reason}`,
+      errorMetadata,
+    );
+    return undefined;
+  };
+  try {
+    const result = await extractInspectableFileText({
+      filters,
+      extract: () =>
+        plan === UPLOAD_FALLBACK_TEXT_PLANS.documentParser
+          ? extractors.parseDocument({ file })
+          : extractors.parseTextNative(file),
+    });
+    const text = result?.text;
+    if (typeof text !== 'string' || text.trim().length === 0) {
+      return undefined;
+    }
+    if (Buffer.byteLength(text, 'utf8') > MAX_STORED_EXTRACTED_TEXT_BYTES) {
+      return skip('extracted text exceeds the storage limit');
+    }
+    if (
+      filters != null &&
+      hasActiveFileFieldPolicy(filters, ['extracted_text']) &&
+      inspectContent(extractFileContent({ extractedText: text }), { filters }) != null
+    ) {
+      return skip('extracted text matched a content policy');
+    }
+    return text;
+  } catch (error) {
+    return skip('extraction failed', error);
+  }
+}
diff --git a/packages/api/src/files/upload/routing.spec.ts b/packages/api/src/files/upload/routing.spec.ts
index 2d8de0dc8a0..3f1cf8b5630 100644
--- a/packages/api/src/files/upload/routing.spec.ts
+++ b/packages/api/src/files/upload/routing.spec.ts
@@ -1,6 +1,10 @@
-import { EModelEndpoint } from 'librechat-data-provider';
+import { Readable } from 'node:stream';
+import { Constants, EModelEndpoint, EToolResources, Providers } from 'librechat-data-provider';
+import type { IMongoFile } from '@librechat/data-schemas';
 import type { ServerRequest } from '~/types';
 import { resolveUploadEndpoint, resolveEffectiveToolResource } from './routing';
+import { encodeAndFormatAudios } from '~/files/encode/audio';
+import { UnsupportedProviderAudioError } from './errors';
 
 describe('resolveUploadEndpoint', () => {
   const req = { user: { id: 'user-1' } } as unknown as ServerRequest;
@@ -38,6 +42,20 @@ describe('resolveUploadEndpoint', () => {
     expect(getAgent).not.toHaveBeenCalled();
   });
 
+  it.each(['openAI', 'azureOpenAI', 'MyGateway'])(
+    'keeps the provider endpoint carried by an ephemeral conversation (%s)',
+    async (endpoint) => {
+      const getAgent = jest.fn().mockResolvedValue(null);
+      await expect(
+        resolveUploadEndpoint({
+          req,
+          metadata: { endpoint, agent_id: String(Constants.EPHEMERAL_AGENT_ID) },
+          getAgent,
+        }),
+      ).resolves.toBe(endpoint);
+    },
+  );
+
   it('leaves an upload naming no agent alone', async () => {
     const getAgent = jest.fn();
 
@@ -104,3 +122,141 @@ describe('resolveEffectiveToolResource Responses handling', () => {
     expect(usable).toBe('context');
   });
 });
+
+describe('direct provider audio preflight', () => {
+  const makeReq = (legacyFileUploadUX = false, mimetype = 'audio/wma', originalname = 'clip.wma') =>
+    Object.assign({} as ServerRequest, {
+      file: {
+        mimetype,
+        originalname,
+        fieldname: 'file',
+        encoding: '7bit',
+        size: 16,
+        destination: '/uploads',
+        filename: originalname,
+        path: '/uploads/audio-1',
+        stream: Readable.from(Buffer.alloc(16)),
+        buffer: Buffer.alloc(16),
+      },
+      config: {
+        fileConfig: {
+          endpoints: { MyGateway: { supportedMimeTypes: ['audio/.*'], legacyFileUploadUX } },
+        },
+      },
+    });
+
+  it.each([false, true])(
+    'rejects unsupported audio before processing (legacy=%s)',
+    async (legacy) => {
+      await expect(
+        resolveEffectiveToolResource({
+          req: makeReq(legacy),
+          metadata: { endpoint: 'MyGateway' },
+          getAgent: jest.fn(),
+        }),
+      ).rejects.toMatchObject({
+        message: 'com_error_files_provider_audio_format',
+        userErrorStatusCode: 415,
+      });
+    },
+  );
+
+  it('uses the resolved agent endpoint and reuses the agent read', async () => {
+    const req = makeReq();
+    const getAgent = jest.fn().mockResolvedValue({ provider: 'MyGateway' });
+    const metadata = { endpoint: EModelEndpoint.agents, agent_id: 'agent_saved01' };
+    await resolveUploadEndpoint({ req, metadata, getAgent });
+    await expect(resolveEffectiveToolResource({ req, metadata, getAgent })).rejects.toBeInstanceOf(
+      UnsupportedProviderAudioError,
+    );
+    expect(getAgent).toHaveBeenCalledTimes(1);
+  });
+
+  it.each([EToolResources.context, EToolResources.ocr, EToolResources.execute_code])(
+    'preserves explicit %s uploads',
+    async (tool_resource) => {
+      await expect(
+        resolveEffectiveToolResource({
+          req: makeReq(true),
+          metadata: { endpoint: 'MyGateway', tool_resource },
+          getAgent: jest.fn(),
+        }),
+      ).resolves.toBe(
+        tool_resource === EToolResources.ocr ? EToolResources.context : tool_resource,
+      );
+    },
+  );
+
+  it('preserves audio explicitly routed to transcription', async () => {
+    const req = makeReq();
+    req.config!.fileConfig!.defaultLLMDeliveryPath = { overrides: { 'audio/*': 'text' } };
+    await expect(
+      resolveEffectiveToolResource({
+        req,
+        metadata: { endpoint: 'MyGateway' },
+        getAgent: jest.fn(),
+      }),
+    ).resolves.toBe(EToolResources.context);
+  });
+
+  it.each([EModelEndpoint.google, Providers.VERTEXAI])(
+    'does not apply input_audio rules to %s',
+    async (endpoint) => {
+      await expect(
+        resolveEffectiveToolResource({
+          req: makeReq(),
+          metadata: { endpoint },
+          getAgent: jest.fn(),
+        }),
+      ).resolves.toBeUndefined();
+    },
+  );
+
+  it('also rejects unsupported OpenRouter audio', async () => {
+    await expect(
+      resolveEffectiveToolResource({
+        req: makeReq(),
+        metadata: { endpoint: Providers.OPENROUTER },
+        getAgent: jest.fn(),
+      }),
+    ).rejects.toBeInstanceOf(UnsupportedProviderAudioError);
+  });
+
+  it.each([
+    ['audio/wave', 'clip.wave', 'wav'],
+    ['audio/mpeg', 'recording', 'mp3'],
+    ['audio/unknown', 'clip.pcm16', 'pcm16'],
+  ])(
+    'delivers an accepted %s upload through the real encoder',
+    async (mimetype, originalname, format) => {
+      const req = makeReq(false, mimetype, originalname);
+      await expect(
+        resolveEffectiveToolResource({
+          req,
+          metadata: { endpoint: 'MyGateway' },
+          getAgent: jest.fn(),
+        }),
+      ).resolves.toBeUndefined();
+      const file = {
+        file_id: 'audio-1',
+        filename: originalname,
+        filepath: '/uploads/audio-1',
+        type: mimetype,
+        bytes: 16,
+        source: 'local',
+      } as IMongoFile;
+      const result = await encodeAndFormatAudios(
+        req,
+        [file],
+        { provider: Providers.OPENAI, endpoint: 'MyGateway' },
+        () => ({ getDownloadStream: async () => Readable.from(Buffer.alloc(16)) }),
+      );
+      expect(result.audios).toEqual([
+        {
+          type: 'input_audio',
+          input_audio: { data: Buffer.alloc(16).toString('base64'), format },
+        },
+      ]);
+    },
+  );
+});
diff --git a/packages/api/src/files/upload/routing.ts b/packages/api/src/files/upload/routing.ts
index 31f571cbaeb..f6a5e1d7a77 100644
--- a/packages/api/src/files/upload/routing.ts
+++ b/packages/api/src/files/upload/routing.ts
@@ -1,13 +1,21 @@
 import {
+  Providers,
+  EModelEndpoint,
   EToolResources,
   mergeFileConfig,
+  isExplicitMimeConfig,
+  isOpenAILikeProvider,
+  isKnownProviderIdentifier,
   isAssistantsEndpoint,
   isResponsesApiUpload,
   getEndpointFileConfig,
   resolveUploadLLMDeliveryPath,
   isSpeechProviderConfigured,
+  getCustomEndpointProvider,
 } from 'librechat-data-provider';
 import type { ServerRequest } from '~/types';
+import { UnsupportedProviderAudioError } from './errors';
+import { getAudioFormat } from '~/files/encode/utils';
 
 /** The subset of an agent record this module reads. */
 export interface UploadAgent {
@@ -27,6 +35,7 @@ export interface UploadMetadata {
 /** The uploaded file fields routing depends on. */
 export interface UploadFile {
   mimetype: string;
+  originalname?: string;
 }
 
 export type GetUploadAgent = (params: { id: string }) => Promise<UploadAgent | null>;
@@ -112,14 +121,35 @@ export async function resolveEffectiveToolResource({
   const fileConfig = mergeFileConfig(req.config?.fileConfig);
   const endpoint = await resolveUploadEndpoint({ req, metadata, getAgent });
   const endpointConfig = getEndpointFileConfig({ fileConfig, endpoint });
+  const endpointProvider = getCustomEndpointProvider(req.config?.endpoints?.custom, endpoint);
+  const file = req.file as UploadFile;
   const path = resolveUploadLLMDeliveryPath({
     toolResource: metadata.tool_resource,
-    mimeType: (req.file as UploadFile).mimetype,
+    mimeType: file.mimetype,
     endpointConfig,
     fileConfig,
     endpoint,
+    endpointProvider,
     useResponsesApi: isResponsesApiUpload(metadata.useResponsesApi),
     sttConfigured: isSpeechProviderConfigured(req.config?.speech?.stt),
   });
+  const provider =
+    endpointProvider ?? (isKnownProviderIdentifier(endpoint) ? endpoint : EModelEndpoint.openAI);
+  const usesInputAudio =
+    provider?.toLowerCase() === Providers.OPENROUTER ||
+    (isOpenAILikeProvider(provider) &&
+      isExplicitMimeConfig(endpointConfig.supportedMimeTypes) &&
+      fileConfig.checkType?.(file.mimetype, endpointConfig.supportedMimeTypes));
+  if (
+    path === 'provider' &&
+    endpoint != null &&
+    endpoint !== EModelEndpoint.agents &&
+    !isAssistantsEndpoint(endpoint) &&
+    file.mimetype.startsWith('audio/') &&
+    usesInputAudio &&
+    !getAudioFormat(file.mimetype, file.originalname ?? '')
+  ) {
+    throw new UnsupportedProviderAudioError();
+  }
   return path === 'text' ? EToolResources.context : undefined;
 }
diff --git a/packages/api/src/types/files.ts b/packages/api/src/types/files.ts
index b49a1a1f902..4d606f24825 100644
--- a/packages/api/src/types/files.ts
+++ b/packages/api/src/types/files.ts
@@ -39,7 +39,7 @@ export interface GoogleVideoBlock {
   data: string;
 }
 
-/** OpenRouter video block format */
+/** OpenAI-compatible video block format (OpenRouter, vLLM, configured custom endpoints) */
 export interface OpenRouterVideoBlock {
   type: 'video_url';
   video_url: {
@@ -136,7 +136,7 @@ export interface GoogleAudioBlock {
   data: string;
 }
 
-/** OpenRouter audio block format */
+/** OpenAI-compatible audio block format (OpenRouter, vLLM, configured custom endpoints) */
 export interface OpenRouterAudioBlock {
   type: 'input_audio';
   input_audio: {
diff --git a/packages/api/src/utils/files.spec.ts b/packages/api/src/utils/files.spec.ts
index f8910b37c4c..59eb11decc2 100644
--- a/packages/api/src/utils/files.spec.ts
+++ b/packages/api/src/utils/files.spec.ts
@@ -4,6 +4,7 @@ import {
   flattenArtifactPath,
   resolveUploadErrorMessage,
 } from './files';
+import { UnsupportedProviderAudioError } from '~/files/upload/errors';
 
 jest.mock('node:crypto', () => {
   const actualModule = jest.requireActual('node:crypto');
@@ -503,6 +504,14 @@ describe('flattenArtifactPath', () => {
 });
 
 describe('resolveUploadErrorMessage', () => {
+  it.each([false, true])(
+    'preserves the localized audio preflight error (redaction=%s)',
+    (redact) => {
+      expect(
+        resolveUploadErrorMessage(new UnsupportedProviderAudioError(), undefined, redact),
+      ).toBe('com_error_files_provider_audio_format');
+    },
+  );
   test('returns default message for null error', () => {
     expect(resolveUploadErrorMessage(null)).toBe('Error processing file');
   });
diff --git a/packages/api/src/utils/files.ts b/packages/api/src/utils/files.ts
index b313dc9b6fd..5be59b27aab 100644
--- a/packages/api/src/utils/files.ts
+++ b/packages/api/src/utils/files.ts
@@ -2,6 +2,7 @@ import path from 'path';
 import crypto from 'node:crypto';
 import { createReadStream } from 'fs';
 import { readFile, stat } from 'fs/promises';
+import { UnsupportedProviderAudioError } from '~/files/upload/errors';
 
 const USER_FACING_UPLOAD_ERRORS = [
   ['Invalid file format', 'Invalid file format'],
@@ -98,6 +99,9 @@ export function resolveUploadErrorMessage(
   defaultMessage = 'Error processing file',
   redactDetails = false,
 ): string {
+  if (error instanceof UnsupportedProviderAudioError) {
+    return error.message;
+  }
   const errorMessage = error?.message;
   if (!errorMessage) {
     return defaultMessage;
diff --git a/packages/data-provider/src/code/workspace.ts b/packages/data-provider/src/code/workspace.ts
index 2bc3f2bc6e9..60665cb7cb8 100644
--- a/packages/data-provider/src/code/workspace.ts
+++ b/packages/data-provider/src/code/workspace.ts
@@ -35,6 +35,41 @@ export interface CodeWorkspaceDescriptor {
   name?: string;
   /** Omitted when every worker-level operation applies to this workspace. */
   operations?: CodeWorkspaceOperation[];
+  environment?: {
+    fingerprint: string;
+    repo?: string;
+    ref?: string;
+    actions: string[];
+  };
+}
+
+export function isCodeWorkspaceEnvironment(
+  value: unknown,
+): value is NonNullable<CodeWorkspaceDescriptor['environment']> {
+  if (value == null || typeof value !== 'object' || Array.isArray(value)) return false;
+  const environment = value as Record<string, unknown>;
+  return (
+    Object.keys(environment).every((key) =>
+      ['fingerprint', 'repo', 'ref', 'actions'].includes(key),
+    ) &&
+    typeof environment.fingerprint === 'string' &&
+    /^[a-f0-9]{64}$/.test(environment.fingerprint) &&
+    (environment.repo === undefined ||
+      (typeof environment.repo === 'string' &&
+        environment.repo.length <= 256 &&
+        /^[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+$/.test(environment.repo))) &&
+    (environment.ref === undefined ||
+      (typeof environment.ref === 'string' &&
+        environment.ref.trim().length > 0 &&
+        environment.ref.length <= 256 &&
+        !/[\0\r\n]/.test(environment.ref))) &&
+    Array.isArray(environment.actions) &&
+    environment.actions.length <= 32 &&
+    environment.actions.every(
+      (name) => typeof name === 'string' && /^[A-Za-z0-9][A-Za-z0-9_-]{0,63}$/.test(name),
+    ) &&
+    new Set(environment.actions).size === environment.actions.length
+  );
 }
 
 /** Conversation-owned selection, bound to the environment that advertised it. */
diff --git a/packages/data-provider/src/file-config.spec.ts b/packages/data-provider/src/file-config.spec.ts
index 1ee9e035cc8..908117c913f 100644
--- a/packages/data-provider/src/file-config.spec.ts
+++ b/packages/data-provider/src/file-config.spec.ts
@@ -9,6 +9,7 @@ import {
   bedrockDocumentMimeTypes,
   isAnthropicDocumentType,
   isPermissiveMimeConfig,
+  isExplicitMimeConfig,
   convertStringsToRegex,
   setFileConfigRegexCompiler,
   documentParserMimeTypes,
@@ -1399,6 +1400,35 @@ describe('getEndpointFileConfig', () => {
   });
 });
 
+describe('isExplicitMimeConfig', () => {
+  it('is false for undefined or empty lists', () => {
+    expect(isExplicitMimeConfig(undefined)).toBe(false);
+    expect(isExplicitMimeConfig([])).toBe(false);
+  });
+
+  it('is false for the built-in default list (inherited, not configured)', () => {
+    expect(isExplicitMimeConfig(supportedMimeTypes)).toBe(false);
+    const endpointConfig = getEndpointFileConfig({
+      fileConfig: mergeFileConfig({ endpoints: { Other: { fileLimit: 1 } } }),
+      endpoint: 'MyGateway',
+      endpointType: 'custom',
+    });
+    expect(isExplicitMimeConfig(endpointConfig.supportedMimeTypes)).toBe(false);
+  });
+
+  it('is true for an admin-configured list, permissive or not', () => {
+    const endpointConfig = getEndpointFileConfig({
+      fileConfig: mergeFileConfig({
+        endpoints: { MyGateway: { supportedMimeTypes: ['image/.*', 'video/.*'] } },
+      }),
+      endpoint: 'MyGateway',
+      endpointType: 'custom',
+    });
+    expect(isExplicitMimeConfig(endpointConfig.supportedMimeTypes)).toBe(true);
+    expect(isExplicitMimeConfig([/.*/])).toBe(true);
+  });
+});
+
 describe('isPermissiveMimeConfig', () => {
   it('returns true for wildcard .* pattern', () => {
     expect(isPermissiveMimeConfig([/.*/])).toBe(true);
@@ -1978,6 +2008,58 @@ describe('defaultLLMDeliveryPath config merging', () => {
   });
 });
 
+describe('textFallbackWithoutTools config merging', () => {
+  const resolveFor = (dynamic: Parameters<typeof mergeFileConfig>[0], endpoint: string) =>
+    getEndpointFileConfig({ fileConfig: mergeFileConfig(dynamic), endpoint })
+      .textFallbackWithoutTools;
+
+  it('is off unless configured', () => {
+    expect(mergeFileConfig(undefined).textFallbackWithoutTools).toBeUndefined();
+    expect(resolveFor(undefined, EModelEndpoint.openAI)).toBeUndefined();
+    expect(resolveFor({ endpoints: { default: {} } }, EModelEndpoint.openAI)).toBeUndefined();
+  });
+
+  it('accepts the setting at the top level and on an endpoint', () => {
+    expect(
+      fileConfigSchema.safeParse({
+        textFallbackWithoutTools: true,
+        endpoints: { openAI: { textFallbackWithoutTools: false } },
+      }).success,
+    ).toBe(true);
+    expect(fileConfigSchema.safeParse({ textFallbackWithoutTools: 'yes' }).success).toBe(false);
+  });
+
+  it('reaches an endpoint configured for it', () => {
+    expect(
+      resolveFor(
+        { endpoints: { [EModelEndpoint.openAI]: { textFallbackWithoutTools: true } } },
+        EModelEndpoint.openAI,
+      ),
+    ).toBe(true);
+  });
+
+  it('is inherited from the top level and from the default endpoint', () => {
+    expect(resolveFor({ textFallbackWithoutTools: true }, EModelEndpoint.anthropic)).toBe(true);
+    expect(
+      resolveFor({ endpoints: { default: { textFallbackWithoutTools: true } } }, 'MyGateway'),
+    ).toBe(true);
+  });
+
+  it('lets an endpoint turn off what it would inherit', () => {
+    expect(
+      resolveFor(
+        {
+          endpoints: {
+            default: { textFallbackWithoutTools: true },
+            [EModelEndpoint.openAI]: { textFallbackWithoutTools: false },
+          },
+        },
+        EModelEndpoint.openAI,
+      ),
+    ).toBe(false);
+  });
+});
+
 describe('agent attachment context limits', () => {
   it('keeps the turn-memory ceiling separate from agent upload storage', () => {
     expect(baseFileConfig.fileContextSizeLimit).toBe(128 * 1024 * 1024);
diff --git a/packages/data-provider/src/file-config.ts b/packages/data-provider/src/file-config.ts
index b3f55413b93..0123c2b6a67 100644
--- a/packages/data-provider/src/file-config.ts
+++ b/packages/data-provider/src/file-config.ts
@@ -583,6 +583,7 @@ export const endpointFileConfigSchema = z.object({
   supportedMimeTypes: supportedMimeTypesSchema.optional(),
   defaultLLMDeliveryPath: defaultLLMDeliveryPathSchema.optional(),
   legacyFileUploadUX: z.boolean().optional(),
+  textFallbackWithoutTools: z.boolean().optional(),
 });
 
 const skillFileConfigSchema = z.object({
@@ -624,6 +625,7 @@ export const fileConfigSchema = z.object({
     .optional(),
   defaultLLMDeliveryPath: defaultLLMDeliveryPathSchema.optional(),
   legacyFileUploadUX: z.boolean().optional(),
+  textFallbackWithoutTools: z.boolean().optional(),
 });
 
 export type TFileConfig = z.infer<typeof fileConfigSchema>;
@@ -674,6 +676,18 @@ export const isPermissiveMimeConfig = (types?: RegexLike[]): boolean => {
   return types.some((regex) => regex.test('x-librechat/x-probe'));
 };
 
+/**
+ * Detects whether an endpoint's `supportedMimeTypes` were set by the admin rather than inherited
+ * from the built-in default list. Inheritance is signaled by referential identity with
+ * `supportedMimeTypes`, which `mergeWithDefault` preserves for unconfigured endpoints.
+ */
+export const isExplicitMimeConfig = (types?: RegexLike[]): types is RegexLike[] => {
+  if (!types || types.length === 0) {
+    return false;
+  }
+  return types !== supportedMimeTypes;
+};
+
 /** The kind of content a provider upload path can actually send to the model. */
 export type MimeUploadCategory = 'image' | 'document' | 'audio' | 'video';
 
@@ -958,6 +972,8 @@ function mergeWithDefault(
       defaultConfig.defaultLLMDeliveryPath,
     ),
     legacyFileUploadUX: endpointConfig.legacyFileUploadUX ?? defaultConfig.legacyFileUploadUX,
+    textFallbackWithoutTools:
+      endpointConfig.textFallbackWithoutTools ?? defaultConfig.textFallbackWithoutTools,
   };
 }
 
@@ -1048,6 +1064,8 @@ export function getEndpointFileConfig(params: {
       baseDefaultConfig.defaultLLMDeliveryPath,
     ),
     legacyFileUploadUX: mergedFileConfig.legacyFileUploadUX ?? baseDefaultConfig.legacyFileUploadUX,
+    textFallbackWithoutTools:
+      mergedFileConfig.textFallbackWithoutTools ?? baseDefaultConfig.textFallbackWithoutTools,
   };
   const userDefaultConfig = mergedFileConfig.endpoints.default;
   const defaultConfig = userDefaultConfig
@@ -1172,6 +1190,10 @@ export function mergeFileConfig(dynamic: z.infer<typeof fileConfigSchema> | unde
     mergedConfig.legacyFileUploadUX = dynamic.legacyFileUploadUX;
   }
 
+  if (dynamic.textFallbackWithoutTools !== undefined) {
+    mergedConfig.textFallbackWithoutTools = dynamic.textFallbackWithoutTools;
+  }
+
   if (dynamic.serverFileSizeLimit !== undefined) {
     mergedConfig.serverFileSizeLimit = mbToBytes(dynamic.serverFileSizeLimit);
   }
@@ -1287,6 +1309,10 @@ export function mergeFileConfig(dynamic: z.infer<typeof fileConfigSchema> | unde
     if (dynamicEndpoint.legacyFileUploadUX !== undefined) {
       mergedEndpoint.legacyFileUploadUX = dynamicEndpoint.legacyFileUploadUX;
     }
+
+    if (dynamicEndpoint.textFallbackWithoutTools !== undefined) {
+      mergedEndpoint.textFallbackWithoutTools = dynamicEndpoint.textFallbackWithoutTools;
+    }
   }
 
   return mergedConfig;
diff --git a/packages/data-provider/src/resolve-llm-delivery-path.spec.ts b/packages/data-provider/src/resolve-llm-delivery-path.spec.ts
index 520e60a63f1..9fb477bfa0c 100644
--- a/packages/data-provider/src/resolve-llm-delivery-path.spec.ts
+++ b/packages/data-provider/src/resolve-llm-delivery-path.spec.ts
@@ -1,11 +1,35 @@
+import type {
+  TurnFileConsumers,
+  TurnDeliveryFile,
+  TurnDeliveryRouting,
+} from './resolve-llm-delivery-path';
 import type { TDefaultLLMDeliveryPathConfig } from './file-config';
+import type { EndpointFileConfig } from './types/files';
+import type { TEndpoint } from './config';
 import {
+  hasTurnFileConsumer,
   isNativelyReadableText,
   canToolResourceConsume,
   resolveUploadDestination,
+  getCustomEndpointProvider,
+  resolveTurnLLMDeliveryPath as resolveStoredTurnPath,
+  hasInferredLLMDeliveryPath,
   resolveDefaultLLMDeliveryPath,
+  resolveUploadLLMDeliveryPath,
   SYSTEM_LLM_DELIVERY_DEFAULTS,
 } from './resolve-llm-delivery-path';
+import { mergeFileConfig, supportedMimeTypes, getEndpointFileConfig } from './file-config';
+
+function resolveTurnLLMDeliveryPath({
+  file,
+  consumers,
+  ...routing
+}: {
+  file: TurnDeliveryFile;
+  consumers?: TurnFileConsumers;
+} & Partial<TurnDeliveryRouting>) {
+  return resolveStoredTurnPath(routing, file, consumers);
+}
 
 describe('resolveDefaultLLMDeliveryPath', () => {
   it('should return system default for images when no config provided', () => {
@@ -300,6 +324,97 @@ describe('resolveDefaultLLMDeliveryPath', () => {
     );
   });
 
+  describe('media a custom endpoint opted into', () => {
+    /* The encoders emit OpenAI-format media parts for an OpenAI-compatible endpoint only
+     * when the admin listed the type in its `supportedMimeTypes`, so the route has to
+     * agree: an explicit match is provider-capable, the inherited default list is not. */
+    const explicit = [/^image\/.*$/, /^application\/pdf$/, /^video\/.*$/, /^audio\/wav$/];
+    const resolve = (mimeType: string, endpoint: string, types?: RegExp[]) =>
+      resolveDefaultLLMDeliveryPath(
+        mimeType,
+        undefined,
+        undefined,
+        endpoint,
+        undefined,
+        true,
+        types,
+      );
+
+    it('keeps an explicitly allowed type on the provider path for a custom endpoint', () => {
+      expect(resolve('video/mp4', 'MyGateway', explicit)).toBe('provider');
+      expect(resolve('audio/wav', 'MyGateway', explicit)).toBe('provider');
+    });
+
+    it('still downgrades a media type the allowlist does not name', () => {
+      expect(resolve('audio/mpeg', 'MyGateway', explicit)).toBe('text');
+    });
+
+    it('does not read the inherited default list as an opt-in', () => {
+      expect(resolve('video/mp4', 'MyGateway', supportedMimeTypes)).toBe('none');
+      expect(resolve('video/mp4', 'MyGateway', [])).toBe('none');
+    });
+
+    it('does not opt in a built-in endpoint, which the client offers no media for', () => {
+      /* Anthropic and Bedrock encoders have no media branch at all, and OpenAI/Azure are
+       * left out because the picker and drag-drop only open media for custom endpoints:
+       * a route the client cannot send to is a capability with no entry point. */
+      expect(resolve('video/mp4', 'openAI', explicit)).toBe('none');
+      expect(resolve('video/mp4', 'azureOpenAI', explicit)).toBe('none');
+      expect(resolve('video/mp4', 'anthropic', explicit)).toBe('none');
+      expect(resolve('video/mp4', 'bedrock', explicit)).toBe('none');
+    });
+
+    it('keeps a custom endpoint that runs as Anthropic on its previous route', () => {
+      /* A custom endpoint may declare `provider: anthropic`, and the encoders emit
+       * OpenAI-format parts only, so the opt-in would deliver nothing there. Audio keeps
+       * its transcription route and video stays off the model path. */
+      const endpointConfig = { supportedMimeTypes: explicit };
+      const anthropic = { mimeType: 'video/mp4', endpointConfig, endpoint: 'MyClaude' };
+      expect(resolveUploadLLMDeliveryPath({ ...anthropic, endpointProvider: 'anthropic' })).toBe(
+        'none',
+      );
+      expect(
+        resolveUploadLLMDeliveryPath({
+          ...anthropic,
+          mimeType: 'audio/wav',
+          endpointProvider: 'anthropic',
+          sttConfigured: true,
+        }),
+      ).toBe('text');
+      expect(resolveUploadLLMDeliveryPath({ ...anthropic, endpointProvider: 'openAI' })).toBe(
+        'provider',
+      );
+      expect(resolveUploadLLMDeliveryPath(anthropic)).toBe('provider');
+    });
+
+    it('reaches the upload resolver through the merged endpoint config', () => {
+      /* The real merge, so the identity check that separates a configured list from the
+       * inherited default is exercised the way the upload route exercises it. */
+      const fileConfig = mergeFileConfig({
+        endpoints: { MyGateway: { supportedMimeTypes: ['image/.*', 'video/.*'] } },
+      });
+      const configured = getEndpointFileConfig({ fileConfig, endpoint: 'MyGateway' });
+      const inherited = getEndpointFileConfig({ fileConfig, endpoint: 'OtherGateway' });
+
+      expect(
+        resolveUploadLLMDeliveryPath({
+          mimeType: 'video/mp4',
+          endpointConfig: configured,
+          fileConfig,
+          endpoint: 'MyGateway',
+        }),
+      ).toBe('provider');
+      expect(
+        resolveUploadLLMDeliveryPath({
+          mimeType: 'video/mp4',
+          endpointConfig: inherited,
+          fileConfig,
+          endpoint: 'OtherGateway',
+        }),
+      ).toBe('none');
+    });
+  });
+
   it('leaves media alone when no endpoint is resolved at all', () => {
     /* An ephemeral agent reports no usable endpoint, which is not the same as naming one
      * we cannot identify. */
@@ -545,6 +660,27 @@ describe('resolveUploadDestination', () => {
   });
 });
 
+describe('getCustomEndpointProvider', () => {
+  const custom = [
+    { name: 'My Claude', provider: 'anthropic' },
+    { name: 'Ollama', provider: 'anthropic' },
+    { name: 'MyGateway' },
+  ] as Array<Partial<Pick<TEndpoint, 'name' | 'provider'>>>;
+
+  it('returns the declared dialect for a custom endpoint, matching the normalized name', () => {
+    expect(getCustomEndpointProvider(custom, 'My Claude')).toBe('anthropic');
+    /* The same normalization the file config lookup applies to endpoint names. */
+    expect(getCustomEndpointProvider(custom, 'ollama')).toBe('anthropic');
+  });
+
+  it('returns nothing for an endpoint without a dialect, an unknown one, or no config', () => {
+    expect(getCustomEndpointProvider(custom, 'MyGateway')).toBeUndefined();
+    expect(getCustomEndpointProvider(custom, 'Other')).toBeUndefined();
+    expect(getCustomEndpointProvider(undefined, 'My Claude')).toBeUndefined();
+    expect(getCustomEndpointProvider(custom, undefined)).toBeUndefined();
+  });
+});
+
 describe('isNativelyReadableText', () => {
   it('admits the application types whose payload is text', () => {
     /* Kept in step with the textual set in the content-protection code. Missing one sends
@@ -634,3 +770,179 @@ describe('provider document capability', () => {
     ).toBe('provider');
   });
 });
+
+describe('hasTurnFileConsumer', () => {
+  it('finds a reader only among the tools this turn runs', () => {
+    expect(hasTurnFileConsumer('text/csv', { executeCode: false, fileSearch: false })).toBe(false);
+    expect(hasTurnFileConsumer('text/csv', { executeCode: true, fileSearch: false })).toBe(true);
+    expect(hasTurnFileConsumer('text/csv', { executeCode: false, fileSearch: true })).toBe(true);
+  });
+
+  it('does not count a tool that cannot read the type', () => {
+    expect(hasTurnFileConsumer('video/mp4', { executeCode: false, fileSearch: true })).toBe(false);
+  });
+});
+
+describe('hasInferredLLMDeliveryPath', () => {
+  it('re-resolves only a route upload inferred', () => {
+    expect(hasInferredLLMDeliveryPath({ llmDeliveryPath: 'none' })).toBe(true);
+    expect(
+      hasInferredLLMDeliveryPath({
+        llmDeliveryPath: 'text',
+        metadata: { destinationChosen: false },
+      }),
+    ).toBe(true);
+    expect(
+      hasInferredLLMDeliveryPath({
+        llmDeliveryPath: 'none',
+        metadata: { destinationChosen: true },
+      }),
+    ).toBe(false);
+    expect(hasInferredLLMDeliveryPath({ type: 'text/csv' })).toBe(false);
+  });
+});
+
+describe('resolveTurnLLMDeliveryPath', () => {
+  const endpointConfig: EndpointFileConfig = {
+    defaultLLMDeliveryPath: { overrides: { 'text/csv': 'none' } },
+    textFallbackWithoutTools: true,
+  };
+  const noReader: TurnFileConsumers = { executeCode: false, fileSearch: false };
+  const routedCsv = {
+    type: 'text/csv',
+    text: 'region,total\nwest,4',
+    llmDeliveryPath: 'none',
+    metadata: { destinationChosen: false },
+  };
+
+  it('delivers stored text when the turn runs no tool that can read the file', () => {
+    expect(
+      resolveTurnLLMDeliveryPath({ file: routedCsv, consumers: noReader, endpointConfig }),
+    ).toBe('text');
+  });
+
+  it('keeps the tool route on an endpoint that has not enabled the fallback', () => {
+    expect(
+      resolveTurnLLMDeliveryPath({
+        file: routedCsv,
+        consumers: noReader,
+        endpointConfig: { ...endpointConfig, textFallbackWithoutTools: undefined },
+      }),
+    ).toBe('none');
+    expect(
+      resolveTurnLLMDeliveryPath({
+        file: routedCsv,
+        consumers: noReader,
+        endpointConfig: { ...endpointConfig, textFallbackWithoutTools: false },
+      }),
+    ).toBe('none');
+  });
+
+  it('leaves the file to Run Code when the turn can read it with code', () => {
+    expect(
+      resolveTurnLLMDeliveryPath({
+        file: routedCsv,
+        consumers: { executeCode: true, fileSearch: false },
+        endpointConfig,
+      }),
+    ).toBe('none');
+  });
+
+  it('leaves the file to File Search when the turn can read it by retrieval', () => {
+    expect(
+      resolveTurnLLMDeliveryPath({
+        file: routedCsv,
+        consumers: { executeCode: false, fileSearch: true },
+        endpointConfig,
+      }),
+    ).toBe('none');
+  });
+
+  it('does not judge a turn whose tools are unknown', () => {
+    expect(resolveTurnLLMDeliveryPath({ file: routedCsv, endpointConfig })).toBe('none');
+  });
+
+  it('keeps the tool route when upload stored no text to fall back to', () => {
+    expect(
+      resolveTurnLLMDeliveryPath({
+        file: { ...routedCsv, text: undefined },
+        consumers: noReader,
+        endpointConfig,
+      }),
+    ).toBe('none');
+    expect(
+      resolveTurnLLMDeliveryPath({
+        file: { ...routedCsv, text: '' },
+        consumers: noReader,
+        endpointConfig,
+      }),
+    ).toBe('none');
+  });
+
+  it('keeps a destination the user chose even when nothing this turn can read it', () => {
+    expect(
+      resolveTurnLLMDeliveryPath({
+        file: { ...routedCsv, metadata: { destinationChosen: true } },
+        consumers: noReader,
+        endpointConfig,
+      }),
+    ).toBe('none');
+  });
+
+  it('leaves a record predating routing to its legacy handling', () => {
+    expect(
+      resolveTurnLLMDeliveryPath({
+        file: { type: 'text/csv', text: 'region,total' },
+        consumers: noReader,
+        endpointConfig,
+      }),
+    ).toBeUndefined();
+  });
+
+  it('does not fall back from a route that already reaches the model', () => {
+    expect(
+      resolveTurnLLMDeliveryPath({
+        file: routedCsv,
+        consumers: noReader,
+        endpointConfig: { defaultLLMDeliveryPath: { overrides: { 'text/csv': 'provider' } } },
+      }),
+    ).toBe('provider');
+  });
+
+  it('re-resolves media against the provider the endpoint runs as', () => {
+    /* A custom endpoint whose admin listed video receives it only while it speaks OpenAI's
+     * format, so the turn route has to see the declared provider the upload route saw. */
+    const video = {
+      type: 'video/mp4',
+      llmDeliveryPath: 'provider',
+      metadata: { destinationChosen: false },
+    };
+    const gateway = {
+      file: video,
+      consumers: noReader,
+      endpoint: 'MyGateway',
+      endpointConfig: { supportedMimeTypes: [/^video\/mp4$/] },
+    };
+
+    expect(resolveTurnLLMDeliveryPath({ ...gateway, endpointProvider: 'openAI' })).toBe('provider');
+    expect(resolveTurnLLMDeliveryPath({ ...gateway, endpointProvider: 'anthropic' })).toBe('none');
+  });
+
+  it('judges readers against the type routing saw before conversion', () => {
+    /* File Search reads the original CSV but not the converted image type, so checking the
+     * stored type here would wrongly find no reader and paste the file into the prompt. */
+    const converted = {
+      ...routedCsv,
+      type: 'image/png',
+      metadata: { destinationChosen: false, routingMimeType: 'text/csv' },
+    };
+
+    expect(
+      resolveTurnLLMDeliveryPath({
+        file: converted,
+        consumers: { executeCode: false, fileSearch: true },
+        endpointConfig,
+      }),
+    ).toBe('none');
+  });
+});
diff --git a/packages/data-provider/src/resolve-llm-delivery-path.ts b/packages/data-provider/src/resolve-llm-delivery-path.ts
index bb6148efaf7..09726f74c2a 100644
--- a/packages/data-provider/src/resolve-llm-delivery-path.ts
+++ b/packages/data-provider/src/resolve-llm-delivery-path.ts
@@ -1,13 +1,57 @@
 import type { TDefaultLLMDeliveryPath, TDefaultLLMDeliveryPathConfig } from './file-config';
-import type { EndpointFileConfig, FileConfig } from './types/files';
+import type { EndpointFileConfig, FileConfig, RegexLike } from './types/files';
+import type { TEndpoint } from './config';
+import {
+  retrievalMimeTypes,
+  isExplicitMimeConfig,
+  isBedrockDocumentType,
+  codeInterpreterMimeTypes,
+  fileConfig as baseFileConfig,
+} from './file-config';
 import {
   EModelEndpoint,
-  isDocumentSupportedProvider,
+  isOpenAILikeProvider,
   isKnownProviderIdentifier,
   isMediaSupportedProvider,
+  isDocumentSupportedProvider,
 } from './schemas';
-import { retrievalMimeTypes, isBedrockDocumentType, codeInterpreterMimeTypes } from './file-config';
 import { EToolResources } from './types/assistants';
+import { normalizeEndpointName } from './utils';
+
+/**
+ * The native provider a custom endpoint declares, when it declares one. A custom endpoint
+ * speaks OpenAI's API unless its config names another dialect, and the upload route needs
+ * that answer for the same reason request initialization does: the media encoders emit
+ * OpenAI-format parts, so a custom endpoint running as Anthropic receives none.
+ */
+export function getCustomEndpointProvider(
+  customEndpoints: Array<Partial<Pick<TEndpoint, 'name' | 'provider'>>> | undefined,
+  endpoint?: string | null,
+): string | undefined {
+  if (!customEndpoints || !endpoint) {
+    return undefined;
+  }
+  const normalized = normalizeEndpointName(endpoint);
+  return customEndpoints.find((config) => normalizeEndpointName(config.name ?? '') === normalized)
+    ?.provider;
+}
+
+/** A custom endpoint emits OpenAI-format media parts only for the types the admin listed
+ *  in its `supportedMimeTypes`; the inherited default list is not an opt-in. A name that
+ *  is not a known provider is a custom endpoint. Mirrors `isConfiguredProviderMediaType`
+ *  on the encoder side, so the route and the encoder agree on which uploads the provider
+ *  actually receives; the built-in endpoints are left out because the client offers no
+ *  media for them. */
+const isConfiguredMediaEndpoint = (
+  mimeType: string,
+  endpoint: string,
+  supportedMimeTypes?: RegexLike[],
+): boolean => {
+  if (!isExplicitMimeConfig(supportedMimeTypes) || isKnownProviderIdentifier(endpoint)) {
+    return false;
+  }
+  return baseFileConfig.checkType(mimeType, supportedMimeTypes);
+};
 
 /** Audio and video reach the model only through the media encoders, which support a
  *  narrower provider set than documents. Images use the broadly supported vision
@@ -16,9 +60,13 @@ const isProviderCapable = (
   mimeType: string,
   endpoint: string,
   useResponsesApi?: boolean,
+  supportedMimeTypes?: RegexLike[],
 ): boolean => {
   if (mimeType.startsWith('audio/') || mimeType.startsWith('video/')) {
-    return isMediaSupportedProvider(endpoint);
+    return (
+      isMediaSupportedProvider(endpoint) ||
+      isConfiguredMediaEndpoint(mimeType, endpoint, supportedMimeTypes)
+    );
   }
   if (mimeType === 'application/pdf') {
     /* Azure is out of the document set because it needs the Responses API for native
@@ -104,6 +152,7 @@ export function resolveDefaultLLMDeliveryPath(
   endpoint?: string,
   useResponsesApi?: boolean,
   sttConfigured?: boolean,
+  supportedMimeTypes?: RegexLike[],
 ): TDefaultLLMDeliveryPath {
   const wildcard = mimeType.split('/')[0] + '/*';
 
@@ -149,10 +198,11 @@ export function resolveDefaultLLMDeliveryPath(
   const namedEndpoint = endpoint != null && endpoint !== EModelEndpoint.agents;
   const providerKnown = namedEndpoint && isKnownProviderIdentifier(endpoint);
   /* Media is judged for any named endpoint, identified or not. The media encoders emit a
-   * payload only for the providers they name, so a custom endpoint gets nothing whatever
-   * it proxies to, and leaving it on the provider path delivers neither media nor text.
-   * Documents keep the narrower rule: an unidentified endpoint is usually OpenAI- or
-   * Anthropic-compatible, both of which do carry them. */
+   * payload only for the providers they name, or for an OpenAI-compatible endpoint whose
+   * admin listed the type in its `supportedMimeTypes`; any other custom endpoint gets
+   * nothing whatever it proxies to, and leaving it on the provider path delivers neither
+   * media nor text. Documents keep the narrower rule: an unidentified endpoint is usually
+   * OpenAI- or Anthropic-compatible, both of which do carry them. */
   const isMedia = mimeType.startsWith('audio/') || mimeType.startsWith('video/');
   /* Audio's text path is transcription, so on a deployment with no speech provider it is
    * not recoverable at all. Routing it to text there sends the upload to a service that
@@ -164,7 +214,7 @@ export function resolveDefaultLLMDeliveryPath(
   if (
     systemDefault === 'provider' &&
     canJudgeCapability &&
-    !isProviderCapable(mimeType, endpoint as string, useResponsesApi)
+    !isProviderCapable(mimeType, endpoint as string, useResponsesApi, supportedMimeTypes)
   ) {
     /* Downgrading is only useful where text can actually be recovered. Video has no
      * extraction step: speech-to-text covers audio, and the default text matcher accepts
@@ -206,6 +256,7 @@ export function resolveDefaultUploadLLMDeliveryPath({
   endpointConfig,
   fileConfig,
   endpoint,
+  endpointProvider,
   useResponsesApi,
   sttConfigured,
 }: {
@@ -213,12 +264,19 @@ export function resolveDefaultUploadLLMDeliveryPath({
   endpointConfig?: EndpointFileConfig;
   fileConfig?: FileConfig;
   endpoint?: string;
+  /** The provider the endpoint runs as, when the caller knows it: a custom endpoint's
+   *  declared dialect at upload time, the agent's resolved provider at turn time. */
+  endpointProvider?: string | null;
   useResponsesApi?: boolean;
   sttConfigured?: boolean;
 }): TDefaultLLMDeliveryPath {
   if (endpointConfig?.legacyFileUploadUX === true) {
     return 'provider';
   }
+  /* The media opt-in exists for OpenAI-format parts, so an endpoint known to run as
+   * something else — a custom endpoint declaring `provider: anthropic` — keeps the
+   * capability gate it had, where audio still reaches transcription. */
+  const runsAsOpenAI = endpointProvider == null || isOpenAILikeProvider(endpointProvider);
   return resolveDefaultLLMDeliveryPath(
     mimeType,
     endpointConfig?.defaultLLMDeliveryPath,
@@ -226,6 +284,7 @@ export function resolveDefaultUploadLLMDeliveryPath({
     endpoint,
     useResponsesApi,
     sttConfigured,
+    runsAsOpenAI ? endpointConfig?.supportedMimeTypes : undefined,
   );
 }
 
@@ -237,6 +296,7 @@ export function resolveUploadLLMDeliveryPath({
   fileConfig,
   endpoint,
   useResponsesApi,
+  endpointProvider,
   sttConfigured,
 }: {
   toolResource?: string | null;
@@ -244,6 +304,7 @@ export function resolveUploadLLMDeliveryPath({
   endpointConfig?: EndpointFileConfig;
   fileConfig?: FileConfig;
   endpoint?: string;
+  endpointProvider?: string | null;
   useResponsesApi?: boolean;
   sttConfigured?: boolean;
 }): TDefaultLLMDeliveryPath {
@@ -258,6 +319,7 @@ export function resolveUploadLLMDeliveryPath({
     endpointConfig,
     fileConfig,
     endpoint,
+    endpointProvider,
     useResponsesApi,
     sttConfigured,
   });
@@ -291,6 +353,93 @@ export function canToolResourceConsume(toolResource: string, mimeType: string):
 const matchesMimeList = (mimeType: string, patterns: RegExp[]): boolean =>
   patterns.some((pattern) => pattern.test(mimeType));
 
+/**
+ * The file-reading tools one agent's turn runs. Each flag requires deployment capability,
+ * the caller's role grant, and a reader in the final loaded tool set.
+ */
+export interface TurnFileConsumers {
+  executeCode: boolean;
+  fileSearch: boolean;
+}
+
+/** Whether a tool this turn runs can read a file of this type. */
+export function hasTurnFileConsumer(mimeType: string, consumers: TurnFileConsumers): boolean {
+  return (
+    (consumers.executeCode && canToolResourceConsume(EToolResources.execute_code, mimeType)) ||
+    (consumers.fileSearch && canToolResourceConsume(EToolResources.file_search, mimeType))
+  );
+}
+
+/**
+ * The inputs that route every attachment for the agent running a turn. Initialization
+ * settles them once, after the provider swap and the Responses API decision, and every
+ * reader of a turn route consumes this value rather than deriving one from the agent.
+ */
+export interface TurnDeliveryRouting {
+  fileConfig: FileConfig;
+  endpointConfig: EndpointFileConfig;
+  /** The endpoint the file policy is configured under: a custom endpoint's own name, not
+   *  the client family initialization runs it as. */
+  endpoint: string;
+  /** The dialect a custom endpoint declares, which decides whether it receives OpenAI-format
+   *  media; undefined for a built-in or OpenAI-compatible endpoint. */
+  endpointProvider?: string;
+  useResponsesApi?: boolean;
+  sttConfigured: boolean;
+}
+
+/** The fields of an attachment record that decide its delivery on a turn. */
+export interface TurnDeliveryFile {
+  type?: string;
+  text?: string | null;
+  /** Stored as an upload-time inference, so any string may be read back. */
+  llmDeliveryPath?: string | null;
+  metadata?: { routingMimeType?: string; destinationChosen?: boolean } | null;
+}
+
+const isLLMDeliveryPath = (value: unknown): value is TDefaultLLMDeliveryPath =>
+  value === 'provider' || value === 'text' || value === 'none';
+
+/** Whether a record's stored route was inferred at upload, so each turn resolves it again. */
+export function hasInferredLLMDeliveryPath(file: TurnDeliveryFile): boolean {
+  return file.llmDeliveryPath != null && file.metadata?.destinationChosen !== true;
+}
+
+/**
+ * Delivery path for one attachment on one agent's turn.
+ *
+ * A record predating routing and a destination the user chose keep what they stored. An
+ * inferred route re-resolves against the endpoint handling the turn. A `none` route leaves
+ * the file for a tool; where the endpoint enables `textFallbackWithoutTools` and this turn
+ * runs no tool that can read the file, the text extracted at upload is delivered rather than
+ * the file reaching nothing. Consumers left undefined are unknown and not judged, as in
+ * {@link resolveUploadDestination}.
+ */
+export function resolveTurnLLMDeliveryPath(
+  routing: Partial<TurnDeliveryRouting> | undefined,
+  file: TurnDeliveryFile,
+  consumers?: TurnFileConsumers,
+): TDefaultLLMDeliveryPath | undefined {
+  if (routing == null || !hasInferredLLMDeliveryPath(file)) {
+    return isLLMDeliveryPath(file.llmDeliveryPath) ? file.llmDeliveryPath : undefined;
+  }
+  const { endpointConfig } = routing;
+  /* Conversion changes the stored type, so use the type routing originally saw. */
+  const mimeType = file.metadata?.routingMimeType ?? file.type ?? '';
+  const path = resolveUploadLLMDeliveryPath({ mimeType, ...routing });
+  const hasFallbackText = typeof file.text === 'string' && file.text.length > 0;
+  if (
+    path === 'none' &&
+    endpointConfig?.textFallbackWithoutTools === true &&
+    consumers != null &&
+    hasFallbackText &&
+    !hasTurnFileConsumer(mimeType, consumers)
+  ) {
+    return 'text';
+  }
+  return path;
+}
+
 /** Why an upload cannot be accepted, when nothing would be able to read it. */
 export type UploadRejection = 'no-agent-resource' | 'context-disabled' | 'no-consumer';
 
diff --git a/packages/data-provider/src/types/files.ts b/packages/data-provider/src/types/files.ts
index 3102c8ee72a..e7a80d81d6c 100644
--- a/packages/data-provider/src/types/files.ts
+++ b/packages/data-provider/src/types/files.ts
@@ -52,6 +52,9 @@ export type EndpointFileConfig = {
   supportedMimeTypes?: RegexLike[];
   defaultLLMDeliveryPath?: TDefaultLLMDeliveryPathConfig;
   legacyFileUploadUX?: boolean;
+  /** Delivers the text extracted at upload for a file routed to tools (`none`) on a turn that
+   *  runs no tool able to read it. Off by default, which leaves such a file out of the prompt. */
+  textFallbackWithoutTools?: boolean;
 };
 
 export type FileConfig = {
@@ -88,6 +91,9 @@ export type FileConfig = {
   checkType?: (fileType: string, supportedTypes: RegexLike[]) => boolean;
   defaultLLMDeliveryPath?: TDefaultLLMDeliveryPathConfig;
   legacyFileUploadUX?: boolean;
+  /** Delivers the text extracted at upload for a file routed to tools (`none`) on a turn that
+   *  runs no tool able to read it. Off by default, which leaves such a file out of the prompt. */
+  textFallbackWithoutTools?: boolean;
 };
 
 export type FileConfigInput = {
@@ -119,6 +125,9 @@ export type FileConfigInput = {
   checkType?: (fileType: string, supportedTypes: RegexLike[]) => boolean;
   defaultLLMDeliveryPath?: TDefaultLLMDeliveryPathConfig;
   legacyFileUploadUX?: boolean;
+  /** Delivers the text extracted at upload for a file routed to tools (`none`) on a turn that
+   *  runs no tool able to read it. Off by default, which leaves such a file out of the prompt. */
+  textFallbackWithoutTools?: boolean;
 };
 
 /** The immutable origin of a file explicitly published from an agent execution. */
diff --git a/packages/data-provider/src/types/queuedTurns.spec.ts b/packages/data-provider/src/types/queuedTurns.spec.ts
index b1ab7b4dc79..82336368bcb 100644
--- a/packages/data-provider/src/types/queuedTurns.spec.ts
+++ b/packages/data-provider/src/types/queuedTurns.spec.ts
@@ -11,7 +11,7 @@ const request = {
   parentMessageId: 'message-1',
   clientRequestId: 'request-1',
   text: 'Continue with this context',
-  files: [{ file_id: 'file-1', filename: 'context.txt' }],
+  files: [{ file_id: 'file-1', filename: 'context.txt', llmDeliveryPath: 'text' }],
   quotes: ['quoted context'],
   manualSkills: ['research'],
   expectedPredecessorCreatedAt: 42,
diff --git a/packages/data-provider/src/types/queuedTurns.ts b/packages/data-provider/src/types/queuedTurns.ts
index 19fe686dce0..a3d504b4fc2 100644
--- a/packages/data-provider/src/types/queuedTurns.ts
+++ b/packages/data-provider/src/types/queuedTurns.ts
@@ -18,6 +18,7 @@ export const agentQueuedTurnFileRefSchema = z.object({
   height: z.number().optional(),
   width: z.number().optional(),
   bytes: z.number().nonnegative().optional(),
+  llmDeliveryPath: z.enum(['provider', 'text', 'none']).optional(),
 });
 export type TAgentQueuedTurnFileRef = z.infer<typeof agentQueuedTurnFileRefSchema>;
 
diff --git a/packages/data-schemas/src/methods/queuedTurn.spec.ts b/packages/data-schemas/src/methods/queuedTurn.spec.ts
index b46b81f715a..ef28b4752d0 100644
--- a/packages/data-schemas/src/methods/queuedTurn.spec.ts
+++ b/packages/data-schemas/src/methods/queuedTurn.spec.ts
@@ -90,7 +90,7 @@ describe('agent queued turn methods', () => {
     const input = enqueueInput({
       text: '  follow up  ',
       files: [
-        { file_id: ' file-1 ', filename: ' report.pdf ' },
+        { file_id: ' file-1 ', filename: ' report.pdf ', llmDeliveryPath: 'text' },
         { file_id: 'file-1', filename: 'ignored duplicate' },
       ],
       quotes: [' quote ', '', 'second'],
@@ -102,6 +102,8 @@ describe('agent queued turn methods', () => {
     const replay = await methods.enqueueAgentQueuedTurn({
       ...input,
       text: 'follow up',
+      /** Older replicas do not know the display-only delivery marker; their retry
+       * must still replay the same accepted intent during a rolling deployment. */
       files: [{ file_id: 'file-1', filename: 'report.pdf' }],
       quotes: ['quote', 'second'],
       manualSkills: ['skill-a'],
@@ -115,7 +117,7 @@ describe('agent queued turn methods', () => {
       sequence: 1,
       status: 'queued',
       text: 'follow up',
-      files: [{ file_id: 'file-1', filename: 'report.pdf' }],
+      files: [{ file_id: 'file-1', filename: 'report.pdf', llmDeliveryPath: 'text' }],
       quotes: ['quote', 'second'],
       manualSkills: ['skill-a'],
       expectedPredecessorCreatedAt: 42,
diff --git a/packages/data-schemas/src/methods/queuedTurn.ts b/packages/data-schemas/src/methods/queuedTurn.ts
index 35c4dae5b4d..2dfeb210e30 100644
--- a/packages/data-schemas/src/methods/queuedTurn.ts
+++ b/packages/data-schemas/src/methods/queuedTurn.ts
@@ -397,6 +397,19 @@ function normalizeOptionalString(value: string | undefined, maxLength: number):
   return requireBoundedString(value, maxLength);
 }
 
+function normalizeDeliveryPath(
+  value: AgentQueuedTurnFileRef['llmDeliveryPath'],
+): AgentQueuedTurnFileRef['llmDeliveryPath'] {
+  if (value == null) {
+    return undefined;
+  }
+  const normalized = requireBoundedString(value, 32);
+  if (normalized !== 'provider' && normalized !== 'text' && normalized !== 'none') {
+    throw new TypeError('Agent queued turn file delivery path is invalid');
+  }
+  return normalized;
+}
+
 function normalizeFiles(files: readonly AgentQueuedTurnFileRef[] | undefined) {
   if (files == null || files.length === 0) {
     return undefined;
@@ -423,6 +436,9 @@ function normalizeFiles(files: readonly AgentQueuedTurnFileRef[] | undefined) {
       ...(normalizeOptionalString(file.filename, 1024) != null && {
         filename: normalizeOptionalString(file.filename, 1024),
       }),
+      ...(normalizeDeliveryPath(file.llmDeliveryPath) != null && {
+        llmDeliveryPath: normalizeDeliveryPath(file.llmDeliveryPath),
+      }),
       ...(file.height != null && {
         height: requireNonnegativeNumber(file.height),
       }),
@@ -525,7 +541,13 @@ function normalizeEnqueue(input: EnqueueAgentQueuedTurnInput) {
 }
 
 function fingerprint(payload: ReturnType<typeof normalizeEnqueue>): string {
-  return createHash('sha256').update(JSON.stringify(payload)).digest('base64url');
+  /** Delivery routing is display metadata, not user intent. Excluding it keeps
+   * retries compatible with replicas deployed before the field was persisted. */
+  const stableIntent = {
+    ...payload,
+    files: payload.files?.map(({ llmDeliveryPath: _displayMetadata, ...file }) => file),
+  };
+  return createHash('sha256').update(JSON.stringify(stableIntent)).digest('base64url');
 }
 
 function laneKey(input: AgentQueuedTurnConversationScope): string {
diff --git a/packages/data-schemas/src/methods/share.test.ts b/packages/data-schemas/src/methods/share.test.ts
index ab4d174d157..868b276f0a2 100644
--- a/packages/data-schemas/src/methods/share.test.ts
+++ b/packages/data-schemas/src/methods/share.test.ts
@@ -64,6 +64,7 @@ describe('Share Methods', () => {
         textFormat: { type: String, enum: ['html', 'text'] },
         status: { type: String, enum: ['pending', 'ready', 'failed'] },
         previewError: String,
+        llmDeliveryPath: { type: String, enum: ['provider', 'text', 'none'] },
         metadata: mongoose.Schema.Types.Mixed,
         tenantId: String,
       },
@@ -1112,6 +1113,7 @@ describe('Share Methods', () => {
         source: 'local',
         type: 'image/png',
         bytes: 2048,
+        llmDeliveryPath: 'text',
       });
 
       const message = await Message.create({
@@ -1157,6 +1159,7 @@ describe('Share Methods', () => {
       // share-scoped route, storage/identity internals stripped, ids anonymized.
       expect(steerFile.filepath).toBe(`/api/share/${shareId}/files/steer-file-2`);
       expect(steerFile).toMatchObject({ filename: 'steer.png', type: 'image/png' });
+      expect(steerFile.llmDeliveryPath).toBe('text');
       expect(steerFile).not.toHaveProperty('storageKey');
       expect(steerFile).not.toHaveProperty('user');
       expect(steerFile.conversationId).toBe(result?.conversationId);
@@ -1164,6 +1167,7 @@ describe('Share Methods', () => {
 
       const share = await SharedLink.findOne({ shareId }).lean();
       expect(share?.fileSnapshots?.map((snapshot) => snapshot.file_id)).toContain('steer-file-2');
+      expect(share?.fileSnapshots?.[0].llmDeliveryPath).toBe('text');
     });
 
     test('leaves safe non-steer content untouched (same array reference)', () => {
@@ -3321,6 +3325,123 @@ describe('Share Methods', () => {
       expect(result?.updatedAt?.getTime()).toBe(published?.updatedAt?.getTime());
     });
 
+    test('enriches delivery metadata in existing revision-matching snapshots', async () => {
+      const userId = new mongoose.Types.ObjectId().toString();
+      const conversationId = `conv_${nanoid()}`;
+      await seedConversation(userId, conversationId);
+      const docId = await createFile(userId, { llmDeliveryPath: 'text' });
+      const message = await Message.create({
+        messageId: `msg_${nanoid()}`,
+        conversationId,
+        user: userId,
+        text: '',
+        isCreatedByUser: false,
+        content: [
+          {
+            type: 'steer',
+            steerId: 'legacy-steer',
+            steer: 'read this',
+            files: [{ file_id: docId, filename: 'report.pdf', type: 'application/pdf' }],
+          },
+        ],
+      });
+      const shareId = `share_${nanoid()}`;
+      await SharedLink.create({
+        shareId,
+        conversationId,
+        user: userId,
+        messages: [message._id],
+        fileSnapshots: [
+          {
+            file_id: docId,
+            source: 'local',
+            filepath: `/uploads/${userId}/${docId}`,
+            filename: 'report.pdf',
+            type: 'application/pdf',
+            bytes: 1024,
+          },
+        ],
+      });
+      const published = await SharedLink.findOne({ shareId }).lean();
+
+      await expect(
+        shareMethods.getSharedMessages(shareId, undefined, {
+          preflight: async () => {
+            throw new Error('policy rejected');
+          },
+        }),
+      ).rejects.toThrow('policy rejected');
+      const afterRejectedPreflight = await SharedLink.findOne({ shareId }).lean();
+      expect(afterRejectedPreflight?.fileSnapshots?.[0].llmDeliveryPath).toBeUndefined();
+
+      const result = await shareMethods.getSharedMessages(shareId);
+      const content = result?.messages[0].content as Array<Record<string, unknown>>;
+      const file = (content[0].files as Array<Record<string, unknown>>)[0];
+      expect(file.llmDeliveryPath).toBe('text');
+
+      const saved = await SharedLink.findOne({ shareId }).lean();
+      expect(saved?.fileSnapshots?.[0].llmDeliveryPath).toBe('text');
+      expect(saved?.updatedAt?.getTime()).toBe(published?.updatedAt?.getTime());
+      const find = jest.spyOn(File, 'find');
+      await shareMethods.getSharedMessages(shareId);
+      expect(find).not.toHaveBeenCalled();
+      find.mockRestore();
+
+      await SharedLink.updateOne({ shareId }, { $unset: { 'fileSnapshots.0.llmDeliveryPath': 1 } });
+      await shareMethods.getSharedMessages(shareId, undefined, {
+        preflight: async () => {
+          await SharedLink.updateOne({ shareId }, { $set: { fileSnapshots: [] } });
+        },
+      });
+      const republished = await SharedLink.findOne({ shareId }).lean();
+      expect(republished?.fileSnapshots).toEqual([]);
+    });
+
+    test('does not enrich an existing snapshot after its file revision changes', async () => {
+      const userId = new mongoose.Types.ObjectId().toString();
+      const conversationId = `conv_${nanoid()}`;
+      await seedConversation(userId, conversationId);
+      const docId = await createFile(userId, {
+        llmDeliveryPath: 'text',
+        previewRevision: 'current-revision',
+      });
+      const message = await Message.create({
+        messageId: `msg_${nanoid()}`,
+        conversationId,
+        user: userId,
+        text: 'legacy file',
+        isCreatedByUser: true,
+        files: [{ file_id: docId, filename: 'report.pdf', type: 'application/pdf' }],
+      });
+      const shareId = `share_${nanoid()}`;
+      await SharedLink.create({
+        shareId,
+        conversationId,
+        user: userId,
+        messages: [message._id],
+        fileSnapshots: [
+          {
+            file_id: docId,
+            source: 'local',
+            filepath: `/uploads/${userId}/${docId}`,
+            filename: 'report.pdf',
+            type: 'application/pdf',
+            bytes: 1024,
+            previewRevision: 'published-revision',
+          },
+        ],
+      });
+
+      const result = await shareMethods.getSharedMessages(shareId);
+      expect(result?.messages[0].files?.[0].llmDeliveryPath).toBeUndefined();
+      const saved = await SharedLink.findOne({ shareId }).lean();
+      expect(saved?.fileSnapshots?.[0].llmDeliveryPath).toBeNull();
+      const find = jest.spyOn(File, 'find');
+      await shareMethods.getSharedMessages(shareId);
+      expect(find).not.toHaveBeenCalled();
+      find.mockRestore();
+    });
+
     test('runs public projection preflight before persisting a legacy backfill', async () => {
       const userId = new mongoose.Types.ObjectId().toString();
       const conversationId = `conv_${nanoid()}`;
diff --git a/packages/data-schemas/src/methods/share.ts b/packages/data-schemas/src/methods/share.ts
index 0d81d816b13..216c7daadd3 100644
--- a/packages/data-schemas/src/methods/share.ts
+++ b/packages/data-schemas/src/methods/share.ts
@@ -176,6 +176,12 @@ const SNAPSHOT_STREAMABLE_SOURCES = new Set<string>([
   FileSources.text,
 ]);
 
+function isLlmDeliveryPath(
+  value: unknown,
+): value is NonNullable<t.SharedFileSnapshot['llmDeliveryPath']> {
+  return value === 'provider' || value === 'text' || value === 'none';
+}
+
 /** Collect `file_id`s from a message's `files`/`attachments` array into `target`. */
 function collectFileIds(items: unknown, target: Set<string>): void {
   if (!Array.isArray(items)) {
@@ -238,12 +244,24 @@ async function buildFileSnapshots(
     collectSteerFileIds(message.content, fileIds);
   }
 
+  return readFileSnapshots(mongoose, fileIds, ownerId);
+}
+
+async function readFileSnapshots(
+  mongoose: typeof import('mongoose'),
+  fileIds: Set<string>,
+  ownerId: string,
+): Promise<t.SharedFileSnapshot[]> {
   if (fileIds.size === 0) {
     return [];
   }
 
   const File = mongoose.models.File as Model<t.IMongoFile>;
-  const files = await File.find({ file_id: { $in: Array.from(fileIds) }, user: ownerId }).lean();
+  const files = await File.find({ file_id: { $in: Array.from(fileIds) }, user: ownerId })
+    .select(
+      'file_id source storageKey filepath type filename bytes width height model llmDeliveryPath previewRevision metadata.sourceDispatchedAt tenantId',
+    )
+    .lean();
 
   const snapshots: t.SharedFileSnapshot[] = [];
   for (const file of files) {
@@ -262,6 +280,7 @@ async function buildFileSnapshots(
       width: file.width,
       height: file.height,
       model: file.model,
+      llmDeliveryPath: isLlmDeliveryPath(file.llmDeliveryPath) ? file.llmDeliveryPath : 'provider',
       previewRevision: file.previewRevision,
       sourceDispatchedAt: file.metadata?.sourceDispatchedAt,
       tenantId: file.tenantId,
@@ -394,6 +413,65 @@ async function persistBackfilledSnapshots(
   return current.fileSnapshots ?? [];
 }
 
+function snapshotMatchesCurrentVersion(
+  snapshot: t.SharedFileSnapshot,
+  current: t.SharedFileSnapshot,
+): boolean {
+  const revisionChanged = (snapshot.previewRevision ?? null) !== (current.previewRevision ?? null);
+  const sourceGenerationChanged =
+    snapshot.sourceDispatchedAt != null &&
+    snapshot.sourceDispatchedAt !== (current.sourceDispatchedAt ?? null);
+  const bytesChanged =
+    snapshot.bytes != null && current.bytes != null && snapshot.bytes !== current.bytes;
+  return !revisionChanged && !sourceGenerationChanged && !bytesChanged;
+}
+
+/**
+ * Add the delivery marker introduced after file snapshots shipped without changing
+ * what an existing link authorizes. Each marker is copied only when the live file
+ * still passes the same revision checks as the public file route. The caller persists
+ * after public-projection preflight with the full prior snapshot as a compare-and-set
+ * guard. A legacy file with no explicit marker used provider delivery, which remains
+ * the compatible fallback.
+ */
+async function enrichSnapshotDeliveryPaths(
+  mongoose: typeof import('mongoose'),
+  share: t.ISharedLink & { messages: t.IMessage[] },
+): Promise<{ snapshots: t.SharedFileSnapshot[]; changed: boolean }> {
+  const existing = share.fileSnapshots ?? [];
+  const missingIds = new Set(
+    existing
+      .filter((snapshot) => snapshot.llmDeliveryPath === undefined)
+      .map((snapshot) => snapshot.file_id),
+  );
+  if (missingIds.size === 0 || share._id == null || !share.user) {
+    return { snapshots: existing, changed: false };
+  }
+
+  const currentById = new Map(
+    (await readFileSnapshots(mongoose, missingIds, share.user)).map((snapshot) => [
+      snapshot.file_id,
+      snapshot,
+    ]),
+  );
+  let changed = false;
+  const enriched = existing.map((snapshot) => {
+    if (snapshot.llmDeliveryPath !== undefined) {
+      return snapshot;
+    }
+    const current = currentById.get(snapshot.file_id);
+    changed = true;
+    if (current == null || !snapshotMatchesCurrentVersion(snapshot, current)) {
+      return { ...snapshot, llmDeliveryPath: null };
+    }
+    return { ...snapshot, llmDeliveryPath: current.llmDeliveryPath ?? ('provider' as const) };
+  });
+  if (!changed) {
+    return { snapshots: existing, changed: false };
+  }
+  return { snapshots: enriched, changed: true };
+}
+
 /** Share-scoped file route that serves a snapshotted file independent of owner ACL. */
 function shareFileRoute(shareId: string, fileId: string): string {
   return `/api/share/${shareId}/files/${encodeURIComponent(fileId)}`;
@@ -408,6 +486,7 @@ function applyShareFileRoute(
   shareId: string,
   snapshotIds: Set<string>,
   textSourceIds?: Set<string>,
+  deliveryPathById?: ReadonlyMap<string, t.SharedFileSnapshot['llmDeliveryPath']>,
 ): t.SharedFile {
   const fileId = file.file_id;
   if (typeof fileId === 'string' && snapshotIds.has(fileId)) {
@@ -418,6 +497,9 @@ function applyShareFileRoute(
       // General storage sources stay private, but `text` is a render semantic:
       // clients must preview the database-backed payload as text, not the original MIME.
       ...(textSourceIds?.has(fileId) && { source: FileSources.text }),
+      ...(deliveryPathById?.get(fileId) != null && {
+        llmDeliveryPath: deliveryPathById.get(fileId),
+      }),
     };
     for (const key of ['preview', 'uri', 'url'] as const) {
       if (file[key] !== undefined) {
@@ -450,6 +532,7 @@ export function anonymizeSharedContent(
     shareId: string;
     snapshotIds: Set<string>;
     textSourceIds?: Set<string>;
+    deliveryPathById?: ReadonlyMap<string, t.SharedFileSnapshot['llmDeliveryPath']>;
     includeFiles: boolean;
     sanitizeUIResourceMarkers?: boolean;
   },
@@ -481,6 +564,7 @@ export function anonymizeSharedContent(
             params.shareId,
             params.snapshotIds,
             params.textSourceIds,
+            params.deliveryPathById,
           ),
         )
       : undefined;
@@ -518,6 +602,7 @@ function anonymizeMessages(
   shareId: string,
   snapshotIds: Set<string>,
   textSourceIds: Set<string>,
+  deliveryPathById: ReadonlyMap<string, t.SharedFileSnapshot['llmDeliveryPath']>,
   includeFiles: boolean,
   anonymizeMessageId: (id: string) => string,
   anonymizeAssistantId: (id: string) => string,
@@ -548,6 +633,7 @@ function anonymizeMessages(
             shareId,
             snapshotIds,
             textSourceIds,
+            deliveryPathById,
           ),
         )
       : undefined;
@@ -564,6 +650,7 @@ function anonymizeMessages(
             shareId,
             snapshotIds,
             textSourceIds,
+            deliveryPathById,
           ),
         )
       : undefined;
@@ -586,6 +673,7 @@ function anonymizeMessages(
         shareId,
         snapshotIds,
         textSourceIds,
+        deliveryPathById,
         includeFiles,
         sanitizeUIResourceMarkers: message.isCreatedByUser !== true,
       }),
@@ -904,10 +992,16 @@ export function createShareMethods(mongoose: typeof import('mongoose')): {
       const perLinkEnabled = share.snapshotFiles !== false;
       const includeFiles = adminEnabled && perLinkEnabled;
       let fileSnapshots = share.fileSnapshots;
+      const originalFileSnapshots = share.fileSnapshots;
+      let shouldPersistEnrichedDeliveryPaths = false;
       const shouldPersistFileSnapshots =
         includeFiles && fileSnapshots === undefined && share._id != null;
       if (shouldPersistFileSnapshots) {
         fileSnapshots = await buildFileSnapshots(mongoose, messagesToShare, share.user);
+      } else if (includeFiles && fileSnapshots !== undefined) {
+        const enriched = await enrichSnapshotDeliveryPaths(mongoose, share);
+        fileSnapshots = enriched.snapshots;
+        shouldPersistEnrichedDeliveryPaths = enriched.changed;
       }
 
       const snapshotIds = includeFiles
@@ -920,6 +1014,15 @@ export function createShareMethods(mongoose: typeof import('mongoose')): {
               .map((snapshot) => snapshot.file_id),
           )
         : new Set<string>();
+      const deliveryPathById = includeFiles
+        ? new Map(
+            (fileSnapshots ?? []).flatMap((snapshot) =>
+              snapshot.llmDeliveryPath == null
+                ? []
+                : [[snapshot.file_id, snapshot.llmDeliveryPath] as const],
+            ),
+          )
+        : new Map<string, t.SharedFileSnapshot['llmDeliveryPath']>();
       /** The share view has no conversation in scope, so whether this link may reveal a
        *  model travels in the payload — read off the very messages being returned. */
       const { messages, hasConfiguredSender } = anonymizeMessages(
@@ -928,6 +1031,7 @@ export function createShareMethods(mongoose: typeof import('mongoose')): {
         resolvedShareId,
         snapshotIds,
         textSourceIds,
+        deliveryPathById,
         includeFiles,
         anonymizeMessageId,
         anonymizeAssistantId,
@@ -951,6 +1055,20 @@ export function createShareMethods(mongoose: typeof import('mongoose')): {
 
       if (shouldPersistFileSnapshots) {
         await persistBackfilledSnapshots(SharedLink, { _id: share._id }, fileSnapshots ?? []);
+      } else if (
+        shouldPersistEnrichedDeliveryPaths &&
+        share._id != null &&
+        originalFileSnapshots !== undefined
+      ) {
+        await SharedLink.updateOne(
+          {
+            _id: share._id,
+            fileSnapshots: originalFileSnapshots,
+            snapshotFiles: { $ne: false },
+          },
+          { $set: { fileSnapshots } },
+          { timestamps: false },
+        );
       }
 
       return result;
diff --git a/packages/data-schemas/src/schema/queuedTurn.ts b/packages/data-schemas/src/schema/queuedTurn.ts
index be0f2001ba3..e191c8d9c5f 100644
--- a/packages/data-schemas/src/schema/queuedTurn.ts
+++ b/packages/data-schemas/src/schema/queuedTurn.ts
@@ -7,6 +7,7 @@ const fileRefSchema = new Schema(
     type: { type: String, maxlength: 256 },
     filepath: { type: String, maxlength: 2048 },
     filename: { type: String, maxlength: 1024 },
+    llmDeliveryPath: { type: String, enum: ['provider', 'text', 'none'] },
     height: { type: Number, min: 0 },
     width: { type: Number, min: 0 },
     bytes: { type: Number, min: 0 },
diff --git a/packages/data-schemas/src/schema/share.ts b/packages/data-schemas/src/schema/share.ts
index 808d977a8fe..f1cf0a6b332 100644
--- a/packages/data-schemas/src/schema/share.ts
+++ b/packages/data-schemas/src/schema/share.ts
@@ -34,6 +34,7 @@ const fileSnapshotSchema = new Schema<SharedFileSnapshot>(
     width: { type: Number },
     height: { type: Number },
     model: { type: String },
+    llmDeliveryPath: { type: String, enum: ['provider', 'text', 'none'] },
     previewRevision: { type: String },
     sourceDispatchedAt: { type: Number },
     tenantId: { type: String },
diff --git a/packages/data-schemas/src/types/queuedTurn.ts b/packages/data-schemas/src/types/queuedTurn.ts
index 7d66a74d14b..93dfc0a41ef 100644
--- a/packages/data-schemas/src/types/queuedTurn.ts
+++ b/packages/data-schemas/src/types/queuedTurn.ts
@@ -20,6 +20,7 @@ export interface AgentQueuedTurnFileRef {
   type?: string;
   filepath?: string;
   filename?: string;
+  llmDeliveryPath?: 'provider' | 'text' | 'none';
   height?: number;
   width?: number;
   bytes?: number;
diff --git a/packages/data-schemas/src/types/share.ts b/packages/data-schemas/src/types/share.ts
index cefb4561608..c0bfc4e532b 100644
--- a/packages/data-schemas/src/types/share.ts
+++ b/packages/data-schemas/src/types/share.ts
@@ -19,6 +19,10 @@ export interface SharedFileSnapshot {
   width?: number;
   height?: number;
   model?: string;
+  /** Determines whether the shared renderer previews the original object or
+   * the extracted text served by the share-scoped preview route. Null marks a
+   * legacy snapshot checked without a matching live file; do not retry on each view. */
+  llmDeliveryPath?: 'provider' | 'text' | 'none' | null;
   /** Deferred-preview generation marker captured at share time. The share routes
    * refuse to serve when the live file's revision no longer matches (the file_id
    * was reused/overwritten by a later turn), so a link can't surface post-share