Skip to content

Enhanced ChatGPT Clone: Features Agents, MCP, Skills, DeepSeek, Anthropic, AWS, OpenAI, Responses API, Azure, Groq, o1, GPT-5, Mistral, OpenRouter, Vertex AI, Gemini, Artifacts, AI model switching, message search, Code Interpreter, langchain, DALL-E-3, OpenAPI Actions, Functions, Secure Multi-User Auth, Presets, open-source for self-hosting. Active

📭 fix: Deliver Attachment Text Until a File Tool Holds It (#16027)

lia-by-librechat[bot]9e83b10545e7
diff --git a/api/app/clients/specs/BaseClient.test.js b/api/app/clients/specs/BaseClient.test.js
index 53c22c33dc..7277e63487 100644
--- a/api/app/clients/specs/BaseClient.test.js
+++ b/api/app/clients/specs/BaseClient.test.js
@@ -2661,14 +2661,30 @@ describe('BaseClient', () => {
metadata: { destinationChosen: false },
};
+ /** A tool serves a file only once it holds it, so a record left to the sandbox needs the
+ * reference provisioning writes for that tool to count as its reader. */
+ const sandboxCsv = {
+ ...routedCsv,
+ metadata: {
+ destinationChosen: false,
+ codeEnvRef: {
+ kind: 'user',
+ id: 'user-1',
+ storage_session_id: 'session-1',
+ file_id: 'sandbox-csv-file',
+ },
+ },
+ };
+
const replayCsv = async (
fileConsumers,
endpointConfig = {
defaultLLMDeliveryPath: { overrides: { 'text/csv': 'none' } },
textFallbackWithoutTools: true,
},
+ file = routedCsv,
) => {
- getFiles.mockResolvedValueOnce([routedCsv]);
+ getFiles.mockResolvedValueOnce([file]);
TestClient.options.req.config = {
fileConfig: { endpoints: { [EModelEndpoint.openAI]: endpointConfig } },
};
@@ -2743,13 +2759,30 @@ describe('BaseClient', () => {
]);
});
- test('keeps the file off the prompt when this turn can read it with code', async () => {
- const message = await replayCsv({ executeCode: true, fileSearch: false });
+ test('keeps the file off the prompt when the sandbox running it holds the file', async () => {
+ const message = await replayCsv(
+ { executeCode: true, fileSearch: false },
+ undefined,
+ sandboxCsv,
+ );
expect(TestClient.assertHistoricalAttachmentLimits).toHaveBeenCalledWith([]);
expect(TestClient.addFileContextToMessage).not.toHaveBeenCalled();
expect(message.fileContext).toBeUndefined();
});
+
+ test('replays the stored text when file search never received the file', async () => {
+ /* An earlier turn's upload that named no destination was filed under no tool, so the
+ * vector store holds nothing to search. Withholding the text for the enabled tool left
+ * the file unreadable on every later turn as well as the one it arrived on. */
+ const message = await replayCsv({ executeCode: false, fileSearch: true });
+ const replayed = { ...routedCsv, llmDeliveryPath: 'text' };
+
+ expect(TestClient.assertHistoricalAttachmentLimits).toHaveBeenCalledWith([replayed]);
+ expect(TestClient.addFileContextToMessage).toHaveBeenCalledWith(message, [replayed]);
+ expect(message.fileContext).toBe('region,total');
+ expect(routedCsv.llmDeliveryPath).toBe('none');
+ });
});
test('rehydrates historical file refs from owner-scoped DB rows only', async () => {
@@ -3520,7 +3553,7 @@ describe('BaseClient', () => {
});
});
- test('keeps a tool-routed file off the prompt when this turn can read it with code', () => {
+ test('keeps a tool-routed file off the prompt when the sandbox running it holds the file', () => {
routeCsvToTools();
TestClient.options.agent = {
provider: EModelEndpoint.openAI,
@@ -3536,13 +3569,51 @@ describe('BaseClient', () => {
type: 'text/csv',
text: 'region,total',
llmDeliveryPath: 'none',
- metadata: { destinationChosen: false },
+ metadata: {
+ destinationChosen: false,
+ codeEnvRef: {
+ kind: 'user',
+ id: 'user-1',
+ storage_session_id: 'session-1',
+ file_id: 'sandbox-code-csv',
+ },
+ },
};
expect(TestClient.getAttachmentDeliveryPath(file)).toBe('none');
expect(TestClient.getTextContextAttachments([file])).toEqual([]);
});
+ test('delivers the text when the tool that would read the file has yet to receive it', () => {
+ /* An upload that named no destination is filed under no tool, so the enabled tool alone
+ * cannot serve it and withholding the text left it readable by nothing. */
+ routeCsvToTools();
+ TestClient.options.agent = {
+ provider: EModelEndpoint.openAI,
+ fileConsumers: { executeCode: true, fileSearch: true },
+ };
+ TestClient.options.agent.deliveryRouting = resolveTurnDeliveryRouting({
+ agent: TestClient.options.agent,
+ config: TestClient.options.req?.config,
+ });
+ const file = {
+ file_id: 'unprovisioned-csv',
+ filename: 'sales.csv',
+ type: 'text/csv',
+ text: 'region,total',
+ llmDeliveryPath: 'none',
+ metadata: { destinationChosen: false },
+ };
+
+ expect(TestClient.getAttachmentDeliveryPath(file)).toBe('text');
+ /* The filter selects records by the route this turn resolves, so it returns the record as
+ * stored; marking the copy admission reads is `resolveTurnAttachments`. */
+ expect(TestClient.getTextContextAttachments([file])).toEqual([file]);
+ expect(TestClient.resolveTurnAttachments([file])).toEqual([
+ { ...file, llmDeliveryPath: 'text' },
+ ]);
+ });
+
test('does not fall back on an endpoint that has not enabled it', () => {
routeCsvToTools({ textFallbackWithoutTools: false });
TestClient.options.agent = {
diff --git a/api/server/controllers/agents/client.test.js b/api/server/controllers/agents/client.test.js
index c084201298..60b8561dbf 100644
--- a/api/server/controllers/agents/client.test.js
+++ b/api/server/controllers/agents/client.test.js
@@ -6718,7 +6718,18 @@ describe('AgentClient - titleConvo', () => {
...makeUploadedFile('fallback-file', 'sales.csv', 'text/csv'),
text: 'handoff fallback content',
llmDeliveryPath: 'none',
- metadata: { destinationChosen: false },
+ /* The primary agent runs code, and a tool serves a file only once it holds it, so the
+ * sandbox reference is what keeps the text out of the primary prompt while the handoff
+ * agent, which runs no reader at all, still receives it. */
+ metadata: {
+ destinationChosen: false,
+ codeEnvRef: {
+ kind: 'user',
+ id: 'user-1',
+ storage_session_id: 'session-1',
+ file_id: 'sandbox-fallback-file',
+ },
+ },
};
const { resolveTurnDeliveryRouting } = jest.requireActual('@librechat/api');
client.options.req.config.fileConfig = {
diff --git a/packages/api/src/agents/__tests__/initialize.test.ts b/packages/api/src/agents/__tests__/initialize.test.ts
index 70129505c2..91764ea1ad 100644
--- a/packages/api/src/agents/__tests__/initialize.test.ts
+++ b/packages/api/src/agents/__tests__/initialize.test.ts
@@ -4593,6 +4593,23 @@ describe('initializeAgent tool-routed text fallback', () => {
metadata: { destinationChosen: false },
}) as IMongoFile;
+ /** A tool serves a file only once it holds it, so these carry the evidence provisioning
+ * writes: vectors for file search, a sandbox pointer for code execution. */
+ const embeddedCsv = () => ({ ...routedCsv(), embedded: true }) as IMongoFile;
+ const sandboxCsv = () =>
+ ({
+ ...routedCsv(),
+ metadata: {
+ destinationChosen: false,
+ codeEnvRef: {
+ kind: 'user',
+ id: 'user_1',
+ storage_session_id: 'session_1',
+ file_id: 'sandbox_file_1',
+ },
+ },
+ }) as IMongoFile;
+
async function initializeWith({
tools,
csv,
@@ -4701,13 +4718,24 @@ describe('initializeAgent tool-routed text fallback', () => {
},
);
- it('keeps fallback out of the prompt when file search loads successfully', async () => {
- const csv = routedCsv();
+ it('keeps fallback out of the prompt when file search loads and holds the file', async () => {
+ const csv = embeddedCsv();
const { result } = await initializeWith({ tools: [EToolResources.file_search], csv });
expect(result.fileConsumers).toEqual({ executeCode: false, fileSearch: true });
expect(result.requestAttachments).toEqual([csv]);
});
+ it('delivers fallback text when file search runs but never received the file', async () => {
+ /* The plain-chat File Search toggle: the upload names no destination, so nothing files it
+ * under a tool resource and the vector store stays empty. Withholding the text for the
+ * toggle alone left the attachment readable by neither the model nor the tool. */
+ 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, llmDeliveryPath: 'text' }]);
+ expect(csv.llmDeliveryPath).toBe('none');
+ });
+
it('falls back after file search soft-fails and admits the returned text copy', async () => {
const csv = routedCsv();
const { result } = await initializeWith({
@@ -4828,8 +4856,8 @@ describe('initializeAgent tool-routed text fallback', () => {
);
});
- it('leaves the file to Run Code when the agent can run code', async () => {
- const csv = routedCsv();
+ it('leaves the file to Run Code when the sandbox already holds it', async () => {
+ const csv = sandboxCsv();
const { result, filterFilesByEndpointRuntimeConfig } = await initializeWith({
tools: [EToolResources.execute_code],
diff --git a/packages/api/src/agents/files/delivery.spec.ts b/packages/api/src/agents/files/delivery.spec.ts
index fb5c490daf..d36fa721d6 100644
--- a/packages/api/src/agents/files/delivery.spec.ts
+++ b/packages/api/src/agents/files/delivery.spec.ts
@@ -36,6 +36,21 @@ const config = {
const noReader: TurnFileConsumers = { executeCode: false, fileSearch: false };
const runsCode: TurnFileConsumers = { executeCode: true, fileSearch: false };
+/** A tool serves a file only once it holds it, so a record left to the sandbox needs the
+ * reference provisioning writes for that tool to count as its reader. */
+const inSandbox = <T extends { metadata?: Record<string, unknown> }>(file: T): T => ({
+ ...file,
+ metadata: {
+ ...file.metadata,
+ codeEnvRef: {
+ kind: 'user' as const,
+ id: 'user_1',
+ storage_session_id: 'session_1',
+ file_id: 'sandbox_file_1',
+ },
+ },
+});
+
describe('resolveTurnDeliveryRouting', () => {
it('routes under the endpoint an agent names before its provider', () => {
expect(resolveTurnDeliveryRouting({ agent: { provider: 'openAI' }, config }).endpoint).toBe(
@@ -97,12 +112,20 @@ describe('applyTurnDelivery', () => {
expect(csv.llmDeliveryPath).toBe('none');
});
- it('returns the same array when a tool this turn runs can read every file', () => {
- const files = [csv, pdf];
+ it('returns the same array when a tool this turn runs holds every file', () => {
+ const files = [inSandbox(csv), pdf];
expect(applyTurnDelivery(files, { agent, config, consumers: runsCode })).toBe(files);
});
+ it('delivers text for a file the tool that would read it has yet to receive', () => {
+ /* An upload that named no destination is filed under no tool, so the enabled tool alone is
+ * not what serves it: withholding the text on that basis left it readable by nothing. */
+ expect(applyTurnDelivery([csv], { agent, config, consumers: runsCode })).toEqual([
+ { ...csv, llmDeliveryPath: 'text' },
+ ]);
+ });
+
it('marks nothing where the endpoint has not enabled the fallback', () => {
const files = [csv];
const disabled = {
@@ -199,10 +222,11 @@ describe('applyTurnDelivery', () => {
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' }];
+ const held = inSandbox(csv);
+ const files = [{ ...held, llmDeliveryPath: 'text' }];
expect(applyTurnDelivery(files, { agent, config, consumers: runsCode })).toEqual([
- { ...csv, llmDeliveryPath: 'none' },
+ { ...held, llmDeliveryPath: 'none' },
]);
});
diff --git a/packages/api/src/agents/files/encode.spec.ts b/packages/api/src/agents/files/encode.spec.ts
index f0982f7ac7..d999273ead 100644
--- a/packages/api/src/agents/files/encode.spec.ts
+++ b/packages/api/src/agents/files/encode.spec.ts
@@ -184,14 +184,31 @@ describe('createRunFileMessageEncoder', () => {
},
});
- const [noReader, runsCode, unknown] = await Promise.all([
+ /* A tool serves a file only once it holds it, so the child that runs code keeps the file off
+ * its prompt for the copy the sandbox has, and receives the text for the one it does not. */
+ const sandboxCsv: TFile = {
+ ...csv,
+ metadata: {
+ destinationChosen: false,
+ codeEnvRef: {
+ kind: 'user',
+ id: 'user-1',
+ storage_session_id: 'session-1',
+ file_id: 'sandbox-input-csv',
+ },
+ },
+ };
+
+ const [noReader, runsCode, unprovisioned, unknown] = await Promise.all([
harness.encode([csv], 'noReader'),
+ harness.encode([sandboxCsv], 'runsCode'),
harness.encode([csv], 'runsCode'),
harness.encode([csv], 'unknown'),
]);
expect(JSON.stringify(noReader[0].content)).toContain('region,total');
expect(runsCode).toEqual([]);
+ expect(JSON.stringify(unprovisioned[0].content)).toContain('region,total');
expect(unknown).toEqual([]);
expect(harness.extractText).toHaveBeenCalledWith(
expect.objectContaining({ attachments: [{ ...csv, llmDeliveryPath: 'text' }] }),
diff --git a/packages/api/src/agents/resources.ts b/packages/api/src/agents/resources.ts
index 6b7e0b69a6..394e564a84 100644
--- a/packages/api/src/agents/resources.ts
+++ b/packages/api/src/agents/resources.ts
@@ -7,6 +7,7 @@ import {
FileSources,
getCodeEnvRefs,
canToolResourceConsume,
+ hasToolResourceProvisioning,
} from 'librechat-data-provider';
import type {
AgentToolResources,
@@ -441,12 +442,10 @@ const computeProvisionState = async ({
/** What the record itself shows about where it was sent. A message attachment is never
* in the agent's resources, so a reference or an embedding is the only evidence that
* the chooser picked that destination, and it is proof: nothing else creates one. */
- const carriesEvidenceFor = (file: TFile, resourceType: EToolResources): boolean => {
- if (resourceType === EToolResources.execute_code) {
- return getCodeEnvRefs(file.metadata).length > 0;
- }
- return file.embedded === true || (file.metadata?.embeddedEntities?.length ?? 0) > 0;
- };
+ /* The predicate the turn's delivery decision reads too, so a file this queue has yet to
+ * provision is never one the prompt withheld its text for. */
+ const carriesEvidenceFor = (file: TFile, resourceType: EToolResources): boolean =>
+ hasToolResourceProvisioning(file, resourceType);
const allowsResource = (file: TFile, resourceType: EToolResources): boolean => {
if (!cameFromChooser(file)) {
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 9fb477bfa0..bc147bfd0f 100644
--- a/packages/data-provider/src/resolve-llm-delivery-path.spec.ts
+++ b/packages/data-provider/src/resolve-llm-delivery-path.spec.ts
@@ -9,6 +9,7 @@ import type { TEndpoint } from './config';
import {
hasTurnFileConsumer,
isNativelyReadableText,
+ hasToolResourceProvisioning,
canToolResourceConsume,
resolveUploadDestination,
getCustomEndpointProvider,
@@ -19,6 +20,7 @@ import {
SYSTEM_LLM_DELIVERY_DEFAULTS,
} from './resolve-llm-delivery-path';
import { mergeFileConfig, supportedMimeTypes, getEndpointFileConfig } from './file-config';
+import { EToolResources } from './types/tools';
function resolveTurnLLMDeliveryPath({
file,
@@ -771,6 +773,15 @@ describe('provider document capability', () => {
});
});
+const codeRef = {
+ kind: 'user' as const,
+ id: 'user_1',
+ storage_session_id: 'session_1',
+ file_id: 'sandbox_file_1',
+};
+/** File search reads an email export and the code interpreter's list does not offer it. */
+const eml = 'message/rfc822';
+
describe('hasTurnFileConsumer', () => {
it('finds a reader only among the tools this turn runs', () => {
expect(hasTurnFileConsumer('text/csv', { executeCode: false, fileSearch: false })).toBe(false);
@@ -781,6 +792,72 @@ describe('hasTurnFileConsumer', () => {
it('does not count a tool that cannot read the type', () => {
expect(hasTurnFileConsumer('video/mp4', { executeCode: false, fileSearch: true })).toBe(false);
});
+
+ it('counts an enabled tool only where the record shows it holds the file', () => {
+ const consumers = { executeCode: false, fileSearch: true };
+ expect(hasTurnFileConsumer('text/csv', consumers, { embedded: true })).toBe(true);
+ expect(hasTurnFileConsumer('text/csv', consumers, { embedded: false })).toBe(false);
+ expect(hasTurnFileConsumer('text/csv', consumers, {})).toBe(false);
+ });
+
+ it('pairs the evidence with the tool that can read the type', () => {
+ /* Only the sandbox holds this file, so the tool that can read an email export is the one
+ * without a copy of it, while csv is served by the tool that has one. */
+ const held = { metadata: { codeEnvRef: codeRef } };
+ const both = { executeCode: true, fileSearch: true };
+ expect(hasTurnFileConsumer(eml, both, held)).toBe(false);
+ expect(hasTurnFileConsumer('text/csv', both, held)).toBe(true);
+ });
+});
+
+describe('hasToolResourceProvisioning', () => {
+ it('reads vectors for file search and a sandbox pointer for code', () => {
+ expect(hasToolResourceProvisioning({ embedded: true }, EToolResources.file_search)).toBe(true);
+ expect(
+ hasToolResourceProvisioning(
+ { metadata: { embeddedEntities: ['agent_1'] } },
+ EToolResources.file_search,
+ ),
+ ).toBe(true);
+ expect(
+ hasToolResourceProvisioning(
+ { metadata: { codeEnvRef: codeRef } },
+ EToolResources.execute_code,
+ ),
+ ).toBe(true);
+ expect(
+ hasToolResourceProvisioning(
+ { metadata: { codeEnvRefs: { default: codeRef } } },
+ EToolResources.execute_code,
+ ),
+ ).toBe(true);
+ });
+
+ it("does not read one tool's store as the other's", () => {
+ expect(hasToolResourceProvisioning({ embedded: true }, EToolResources.execute_code)).toBe(
+ false,
+ );
+ expect(
+ hasToolResourceProvisioning(
+ { metadata: { codeEnvRef: codeRef } },
+ EToolResources.file_search,
+ ),
+ ).toBe(false);
+ });
+
+ it('treats a record with neither as unprovisioned', () => {
+ expect(hasToolResourceProvisioning({}, EToolResources.file_search)).toBe(false);
+ expect(hasToolResourceProvisioning({ embedded: false }, EToolResources.file_search)).toBe(
+ false,
+ );
+ expect(
+ hasToolResourceProvisioning(
+ { metadata: { embeddedEntities: [] } },
+ EToolResources.file_search,
+ ),
+ ).toBe(false);
+ expect(hasToolResourceProvisioning({ metadata: {} }, EToolResources.execute_code)).toBe(false);
+ });
});
describe('hasInferredLLMDeliveryPath', () => {
@@ -838,24 +915,71 @@ describe('resolveTurnLLMDeliveryPath', () => {
).toBe('none');
});
- it('leaves the file to Run Code when the turn can read it with code', () => {
+ it('leaves the file to Run Code when the sandbox it runs on holds the file', () => {
expect(
resolveTurnLLMDeliveryPath({
- file: routedCsv,
+ file: { ...routedCsv, metadata: { ...routedCsv.metadata, codeEnvRef: codeRef } },
consumers: { executeCode: true, fileSearch: false },
endpointConfig,
}),
).toBe('none');
});
- it('leaves the file to File Search when the turn can read it by retrieval', () => {
+ it('leaves the file to File Search once the vector store holds it', () => {
expect(
resolveTurnLLMDeliveryPath({
- file: routedCsv,
+ file: { ...routedCsv, embedded: true },
consumers: { executeCode: false, fileSearch: true },
endpointConfig,
}),
).toBe('none');
+ expect(
+ resolveTurnLLMDeliveryPath({
+ file: { ...routedCsv, metadata: { ...routedCsv.metadata, embeddedEntities: ['agent_1'] } },
+ consumers: { executeCode: false, fileSearch: true },
+ endpointConfig,
+ }),
+ ).toBe('none');
+ });
+
+ it('delivers text when File Search is on but never received the file', () => {
+ /* The plain-chat File Search toggle: the upload names no destination, so nothing files it
+ * under a tool resource and it is never embedded. Withholding the text on the strength of
+ * the toggle alone left the attachment readable by nothing at all. */
+ expect(
+ resolveTurnLLMDeliveryPath({
+ file: routedCsv,
+ consumers: { executeCode: false, fileSearch: true },
+ endpointConfig,
+ }),
+ ).toBe('text');
+ });
+
+ it('delivers text when Run Code is on but no sandbox holds the file', () => {
+ /* A promoted destination is not uploaded to the sandbox at upload time, so the turn the
+ * file arrives on carries no reference either. */
+ expect(
+ resolveTurnLLMDeliveryPath({
+ file: routedCsv,
+ consumers: { executeCode: true, fileSearch: false },
+ endpointConfig,
+ }),
+ ).toBe('text');
+ });
+
+ it('delivers text where the tool holding the file cannot read this type', () => {
+ /* The vectors belong to file search, which this turn does not run, and code execution both
+ * lacks a copy and cannot read an email export, so nothing here serves the file. */
+ expect(
+ resolveTurnLLMDeliveryPath({
+ file: { ...routedCsv, type: eml, embedded: true },
+ consumers: { executeCode: true, fileSearch: false },
+ endpointConfig: {
+ ...endpointConfig,
+ defaultLLMDeliveryPath: { overrides: { [eml]: 'none' } },
+ },
+ }),
+ ).toBe('text');
});
it('does not judge a turn whose tools are unknown', () => {
@@ -934,6 +1058,7 @@ describe('resolveTurnLLMDeliveryPath', () => {
const converted = {
...routedCsv,
type: 'image/png',
+ embedded: true,
metadata: { destinationChosen: false, routingMimeType: 'text/csv' },
};
diff --git a/packages/data-provider/src/resolve-llm-delivery-path.ts b/packages/data-provider/src/resolve-llm-delivery-path.ts
index 25fe9ab48f..1ea941bc55 100644
--- a/packages/data-provider/src/resolve-llm-delivery-path.ts
+++ b/packages/data-provider/src/resolve-llm-delivery-path.ts
@@ -1,5 +1,6 @@
import type { TDefaultLLMDeliveryPath, TDefaultLLMDeliveryPathConfig } from './file-config';
import type { EndpointFileConfig, FileConfig, RegexLike } from './types/files';
+import type { CodeEnvReferenceSet } from './codeEnvRef';
import type { TEndpoint } from './config';
import {
retrievalMimeTypes,
@@ -17,6 +18,7 @@ import {
} from './schemas';
import { normalizeEndpointName } from './utils';
import { EToolResources } from './types/tools';
+import { getCodeEnvRefs } from './codeEnvRef';
/**
* The native provider a custom endpoint declares, when it declares one. A custom endpoint
@@ -362,11 +364,42 @@ export interface TurnFileConsumers {
fileSearch: boolean;
}
-/** Whether a tool this turn runs can read a file of this type. */
-export function hasTurnFileConsumer(mimeType: string, consumers: TurnFileConsumers): boolean {
+/**
+ * Whether the record shows this file reached a tool's own store: vectors for file search, a
+ * sandbox pointer for code execution. Nothing else writes either, so their presence is proof
+ * the file was provisioned and their absence proof it was not. The same evidence deferred
+ * provisioning reads before queueing a file, so a turn cannot withhold content for a tool that
+ * provisioning has yet to serve.
+ */
+export function hasToolResourceProvisioning(file: TurnDeliveryFile, toolResource: string): boolean {
+ if (toolResource === EToolResources.execute_code) {
+ return getCodeEnvRefs(file.metadata).length > 0;
+ }
+ return file.embedded === true || (file.metadata?.embeddedEntities?.length ?? 0) > 0;
+}
+
+/**
+ * Whether a tool this turn runs can read a file of this type.
+ *
+ * Passing the record asks the stricter question a delivery decision needs: a tool serves a file
+ * only once it holds it. A file tool being enabled is not the same as the file having reached
+ * it, and an upload that named no destination is filed under no tool at all, so judging the
+ * tool set alone reads an empty vector store as a reader.
+ */
+export function hasTurnFileConsumer(
+ mimeType: string,
+ consumers: TurnFileConsumers,
+ file?: TurnDeliveryFile,
+): boolean {
+ const holds = (toolResource: EToolResources): boolean =>
+ file == null || hasToolResourceProvisioning(file, toolResource);
return (
- (consumers.executeCode && canToolResourceConsume(EToolResources.execute_code, mimeType)) ||
- (consumers.fileSearch && canToolResourceConsume(EToolResources.file_search, mimeType))
+ (consumers.executeCode &&
+ canToolResourceConsume(EToolResources.execute_code, mimeType) &&
+ holds(EToolResources.execute_code)) ||
+ (consumers.fileSearch &&
+ canToolResourceConsume(EToolResources.file_search, mimeType) &&
+ holds(EToolResources.file_search))
);
}
@@ -394,7 +427,17 @@ export interface TurnDeliveryFile {
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;
+ /** Whether a vector store holds this file, which is what lets file search serve it.
+ * Records predating namespace tracking carry only this flag. */
+ embedded?: boolean | null;
+ metadata?:
+ | ({
+ routingMimeType?: string;
+ destinationChosen?: boolean;
+ /** Vector namespaces holding this file, written as each embedding succeeds. */
+ embeddedEntities?: string[];
+ } & CodeEnvReferenceSet)
+ | null;
}
const isLLMDeliveryPath = (value: unknown): value is TDefaultLLMDeliveryPath =>
@@ -410,10 +453,16 @@ export function hasInferredLLMDeliveryPath(file: TurnDeliveryFile): boolean {
*
* 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}.
+ * the file for a tool; where the endpoint enables `textFallbackWithoutTools` and no tool this
+ * turn runs both reads the file and already holds it, 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}.
+ *
+ * Holding the file is asked of the record rather than of the tool set, because the two disagree
+ * for the upload that needs the fallback most: one that named no destination is filed under no
+ * tool, so enabling file search would otherwise withhold the text for a vector store that never
+ * received the file, leaving the attachment readable by nothing. Deferred provisioning still
+ * fills that store on first use, which delivering the text does not prevent.
*/
export function resolveTurnLLMDeliveryPath(
routing: Partial<TurnDeliveryRouting> | undefined,
@@ -433,7 +482,7 @@ export function resolveTurnLLMDeliveryPath(
endpointConfig?.textFallbackWithoutTools === true &&
consumers != null &&
hasFallbackText &&
- !hasTurnFileConsumer(mimeType, consumers)
+ !hasTurnFileConsumer(mimeType, consumers, file)
) {
return 'text';
}