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
TypeScript aianthropicartifactsawsazurechatgptchatgpt-cloneclaudeclonedeepseekgeminigooglegpt-5librechatmcpo1openairesponses-apivisionwebui
🎽 fix: Hand Same-Batch Code Calls the Files a Skill Just Loaded (#16115)
lia-by-librechat[bot]feb8682dec41
diff --git a/packages/api/src/agents/handlers.spec.ts b/packages/api/src/agents/handlers.spec.tsindex 53927c17ea..b25a137ea5 100644--- a/packages/api/src/agents/handlers.spec.ts+++ b/packages/api/src/agents/handlers.spec.ts@@ -2827,6 +2827,309 @@ describe('createToolExecuteHandler', () => {});});+ describe('same-batch skill file handoff to code calls', () => {+ /** Code API batch-upload response shape: one bundled file plus the+ * SKILL.md the handler excludes from the artifact. */+ function uploadFor(skillName: string) {+ return {+ storage_session_id: `session-${skillName}`,+ files: [+ { fileId: `file-${skillName}`, filename: `skills/${skillName}/references/style.md` },+ { fileId: `skillmd-${skillName}`, filename: `skills/${skillName}/SKILL.md` },+ ],+ };+ }++ /** The artifact ref `primeSkillFiles` derives from {@link uploadFor}. */+ function primedRefFor(skillName: string) {+ return {+ id: `file-${skillName}`,+ resource_id: `${skillName}-id`,+ storage_session_id: `session-${skillName}`,+ name: `skills/${skillName}/references/style.md`,+ kind: 'skill',+ version: 1,+ };+ }++ /** A skill with one bundled file and every dependency the priming gate+ * needs, loaded alongside real code tools so one batch carries both. */+ function makeHandler(params: {+ batchUploadCodeEnvFiles: jest.Mock;+ tools?: unknown[];+ configurable?: Record<string, unknown>;+ options?: Partial<ToolExecuteOptions>;+ }) {+ const loadTools: ToolExecuteOptions['loadTools'] = jest.fn(async () => ({+ loadedTools: (params.tools ?? []) as never[],+ configurable: {+ accessibleSkillIds: skillsInScope(),+ codeEnvAvailable: true,+ req: {+ user: { id: 'user-1', tenantId: 'tenant-1' },+ app: { locals: { codeApiUploadRegistry: createCodeApiUploadRegistry() } },+ config: {+ endpoints: {+ agents: { codeApiUploadConcurrency: 2, codeApiMaxRetryWaitMs: 1_000 },+ },+ },+ },+ ...(params.configurable ?? {}),+ },+ }));+ return createToolExecuteHandler({+ loadTools,+ getSkillByName: jest.fn(async (name) => ({+ _id: `${name}-id` as unknown as never,+ name: name as string,+ body: 'skill body',+ fileCount: 1,+ version: 1,+ })) as unknown as ToolExecuteOptions['getSkillByName'],+ listSkillFiles: jest.fn(async (skillId: unknown) => [+ {+ relativePath: 'references/style.md',+ filename: 'style.md',+ filepath: `/storage/${String(skillId)}/references/style.md`,+ source: 's3',+ bytes: 256,+ },+ ]) as unknown as ToolExecuteOptions['listSkillFiles'],+ getStrategyFunctions: jest.fn(() => ({+ getDownloadStream: jest.fn(async () => Readable.from(Buffer.from(''))),+ })) as unknown as ToolExecuteOptions['getStrategyFunctions'],+ batchUploadCodeEnvFiles:+ params.batchUploadCodeEnvFiles as unknown as ToolExecuteOptions['batchUploadCodeEnvFiles'],+ ...(params.options ?? {}),+ });+ }++ it('injects the files a skill just uploaded into an execute_code call in the same batch', async () => {+ const capturedConfigs: Record<string, unknown>[] = [];+ const batchUploadCodeEnvFiles = jest.fn(async ({ id }: { id: string }) =>+ uploadFor(id.replace(/-id$/, '')),+ );+ const handler = makeHandler({+ batchUploadCodeEnvFiles,+ tools: [createMockTool(Constants.EXECUTE_CODE, capturedConfigs)],+ });++ const results = await invokeHandler(handler, [+ { id: 'call_skill', name: Constants.SKILL_TOOL, args: { skillName: 'brand-kit' } },+ {+ id: 'call_code',+ name: Constants.EXECUTE_CODE,+ args: { lang: 'python', code: 'print(1)' },+ },+ ]);++ expect(results.map((result) => result.status)).toEqual(['success', 'success']);+ expect(capturedConfigs).toHaveLength(1);+ expect(capturedConfigs[0].session_id).toBe('session-brand-kit');+ expect(capturedConfigs[0]._injected_files).toEqual([primedRefFor('brand-kit')]);+ });++ it('injects the files of every skill invoked in the batch', async () => {+ const capturedConfigs: Record<string, unknown>[] = [];+ const batchUploadCodeEnvFiles = jest.fn(async ({ id }: { id: string }) =>+ uploadFor(id.replace(/-id$/, '')),+ );+ const handler = makeHandler({+ batchUploadCodeEnvFiles,+ tools: [createMockTool(Constants.EXECUTE_CODE, capturedConfigs)],+ });++ const results = await invokeHandler(handler, [+ { id: 'call_skill_a', name: Constants.SKILL_TOOL, args: { skillName: 'brand-kit' } },+ { id: 'call_skill_b', name: Constants.SKILL_TOOL, args: { skillName: 'chart-lib' } },+ {+ id: 'call_code',+ name: Constants.EXECUTE_CODE,+ args: { lang: 'python', code: 'print(1)' },+ },+ ]);++ expect(results.map((result) => result.status)).toEqual(['success', 'success', 'success']);+ expect(capturedConfigs[0]._injected_files).toEqual(+ expect.arrayContaining([primedRefFor('brand-kit'), primedRefFor('chart-lib')]),+ );+ expect(capturedConfigs[0]._injected_files).toHaveLength(2);+ });++ it('hands the files to a backgrounded code call and to a sandbox authoring call', async () => {+ const capturedConfigs: Record<string, unknown>[] = [];+ const batchUploadCodeEnvFiles = jest.fn(async ({ id }: { id: string }) =>+ uploadFor(id.replace(/-id$/, '')),+ );+ const writeSandboxFile = jest.fn(async () => ({+ stdout: 'WROTE 11 bytes to /mnt/data/new.txt\n',+ session_id: 'sess-new',+ files: [{ id: 'file-new', name: 'new.txt', storage_session_id: 'sess-new' }],+ }));+ const handler = makeHandler({+ batchUploadCodeEnvFiles,+ tools: [createMockTool(Constants.EXECUTE_CODE, capturedConfigs)],+ configurable: {+ backgroundToolNames: [Constants.EXECUTE_CODE],+ fileAuthoringToolNames: new Set(['create_file', 'edit_file']),+ },+ options: {+ persistBackgroundCodeResult: jest.fn(async () => ({ attachments: [] })),+ readSandboxFile: jest.fn(async () => {+ throw new Error('cat: /mnt/data/new.txt: No such file or directory');+ }),+ writeSandboxFile,+ } as unknown as Partial<ToolExecuteOptions>,+ });++ const results = await invokeHandlerWithConfig(+ handler,+ [+ { id: 'call_skill', name: Constants.SKILL_TOOL, args: { skillName: 'brand-kit' } },+ {+ id: 'call_code_background',+ name: Constants.EXECUTE_CODE,+ args: { lang: 'python', code: 'print(1)', run_in_background: true },+ },+ {+ id: 'call_create_sandbox',+ name: 'create_file',+ args: { path: '/mnt/data/new.txt', content: 'hello world' },+ },+ ],+ { thread_id: 'convo-1' },+ );++ expect(results.map((result) => result.status)).toEqual(['success', 'success', 'success']);+ /* The sandbox authoring call sends the context it cloned. */+ expect(writeSandboxFile).toHaveBeenCalledWith(+ expect.objectContaining({+ file_path: '/mnt/data/new.txt',+ session_id: 'session-brand-kit',+ files: [primedRefFor('brand-kit')],+ }),+ );+ /* The detached code invoke starts after the dispatch returns its handle. */+ await new Promise((resolve) => setImmediate(resolve));+ await new Promise((resolve) => setImmediate(resolve));+ expect(capturedConfigs).toHaveLength(1);+ expect(capturedConfigs[0]._injected_files).toEqual([primedRefFor('brand-kit')]);+ });++ it('runs the code call with its original files when the skill upload fails', async () => {+ const capturedConfigs: Record<string, unknown>[] = [];+ const batchUploadCodeEnvFiles = jest.fn(async () => {+ throw new Error('Request failed with status code 500');+ });+ const handler = makeHandler({+ batchUploadCodeEnvFiles,+ tools: [createMockTool(Constants.EXECUTE_CODE, capturedConfigs)],+ });++ const ownFile = {+ storage_session_id: 'sess-own',+ id: 'own-1',+ resource_id: 'user_alice',+ name: 'data.parquet',+ kind: 'user' as const,+ };+ const [skillResult, codeResult] = await invokeHandler(handler, [+ { id: 'call_skill', name: Constants.SKILL_TOOL, args: { skillName: 'brand-kit' } },+ {+ id: 'call_code',+ name: Constants.EXECUTE_CODE,+ args: { lang: 'python', code: 'print(1)' },+ codeSessionContext: { session_id: 'sess-own', files: [ownFile] },+ },+ ]);++ expect(skillResult.status).toBe('success');+ expect(skillResult.content).toContain('could not be loaded into the code environment');+ expect(codeResult.status).toBe('success');+ expect(capturedConfigs).toHaveLength(1);+ expect(capturedConfigs[0].session_id).toBe('sess-own');+ expect(capturedConfigs[0]._injected_files).toEqual([ownFile]);+ });++ it('keeps code calls concurrent when the batch has no skill call', async () => {+ const order: string[] = [];+ let releaseFirst: () => void = () => undefined;+ const secondStarted = new Promise<void>((resolve) => {+ releaseFirst = resolve;+ });+ const codeTool = {+ name: Constants.EXECUTE_CODE,+ invoke: jest.fn(async (_args: unknown, config: Record<string, unknown>) => {+ const callId = (config.toolCall as { id: string }).id;+ order.push(`start:${callId}`);+ if (callId === 'call_code_a') {+ await secondStarted;+ } else {+ releaseFirst();+ }+ order.push(`end:${callId}`);+ return { content: 'ok' };+ }),+ };+ const handler = makeHandler({+ batchUploadCodeEnvFiles: jest.fn(),+ tools: [codeTool],+ });++ const results = await invokeHandler(handler, [+ { id: 'call_code_a', name: Constants.EXECUTE_CODE, args: { lang: 'python', code: 'a()' } },+ { id: 'call_code_b', name: Constants.EXECUTE_CODE, args: { lang: 'python', code: 'b()' } },+ ]);++ expect(results.map((result) => result.status)).toEqual(['success', 'success']);+ /* The second call ran to completion while the first was still in+ flight: a batch without a skill call serializes nothing. */+ expect(order).toEqual([+ 'start:call_code_a',+ 'start:call_code_b',+ 'end:call_code_b',+ 'end:call_code_a',+ ]);+ });++ it('does not start the code call when the run is aborted while skill files load', async () => {+ const capturedConfigs: Record<string, unknown>[] = [];+ const controller = new AbortController();+ const batchUploadCodeEnvFiles = jest.fn(+ ({ signal }: { signal?: AbortSignal }) =>+ new Promise<never>((_resolve, reject) => {+ signal?.addEventListener('abort', () => reject(signal.reason), { once: true });+ }),+ );+ const codeTool = createMockTool(Constants.EXECUTE_CODE, capturedConfigs);+ const handler = makeHandler({ batchUploadCodeEnvFiles, tools: [codeTool] });++ const resultsPromise = new Promise<ToolExecuteResult[]>((resolve, reject) => {+ handler.handle('on_tool_execute', {+ toolCalls: [+ { id: 'call_skill', name: Constants.SKILL_TOOL, args: { skillName: 'brand-kit' } },+ {+ id: 'call_code',+ name: Constants.EXECUTE_CODE,+ args: { lang: 'python', code: 'print(1)' },+ },+ ],+ signal: controller.signal,+ resolve,+ reject,+ } as ToolExecuteBatchRequest);+ });+ setTimeout(() => controller.abort(), 10);++ const [skillResult, codeResult] = await resultsPromise;++ expect(skillResult.status).toBe('error');+ expect(codeResult.status).toBe('error');+ expect(codeTool.invoke).not.toHaveBeenCalled();+ expect(capturedConfigs).toHaveLength(0);+ });+ });+describe('file authoring tools for skills', () => {const { Types } = jest.requireActual('mongoose') as typeof import('mongoose');const SKILL_ID = new Types.ObjectId();diff --git a/packages/api/src/agents/handlers.ts b/packages/api/src/agents/handlers.tsindex 6489a26ad5..f991418273 100644--- a/packages/api/src/agents/handlers.ts+++ b/packages/api/src/agents/handlers.ts@@ -5411,6 +5411,80 @@ function buildToolCallConfig(return toolCallConfig;}+/**+ * One-shot handoff of the files a `skill` call uploads to the code calls that+ * share its batch.+ *+ * The graph hands every call in a batch the code-session snapshot it took when+ * it planned the batch, and folds a `skill` call's artifact back into the+ * session only after the whole batch settles. A code call dispatched beside a+ * `skill` call therefore reads a context with none of the skill's bundled+ * files: `_injected_files` omits them and the sandbox has no+ * `/mnt/data/skills/<name>/` for that batch. Waiting here, then merging the+ * uploaded refs into the code call's own context, is what makes the files+ * visible on the turn that loaded them.+ */+interface SkillFilesHandoff {+ /** Records a settled `skill` call; the last one releases every waiter. */+ record(result: ToolExecuteResult): void;+ /** Resolves once every `skill` call in the batch has settled, then merges+ * their uploaded files into this call's own code-session context. Never+ * rejects: a skill whose files failed to load contributes nothing and the+ * waiting call runs with the context it already had. */+ applyTo(tc: ToolCallRequest): Promise<void>;+}++function createSkillFilesHandoff(+ skillToolCallIds: ReadonlySet<string>,+ signal?: AbortSignal,+): SkillFilesHandoff {+ const pendingSkillCallIds = new Set(skillToolCallIds);+ const uploadedFiles: CodeEnvFile[] = [];+ let release!: () => void;+ const settled = new Promise<void>((resolve) => {+ release = resolve;+ });+ /** A Stop ends the turn for every call in the batch, so waiters are released+ * the moment it lands instead of riding out the upload's own cancellation. */+ const onAbort = (): void => release();+ if (signal?.aborted === true) {+ release();+ } else {+ signal?.addEventListener('abort', onAbort, { once: true });+ }+ return {+ record(result: ToolExecuteResult): void {+ if (!pendingSkillCallIds.delete(result.toolCallId)) {+ return;+ }+ const files =+ result.status === 'success'+ ? (result.artifact as { files?: CodeEnvFile[] } | undefined)?.files+ : undefined;+ if (files && files.length > 0) {+ uploadedFiles.push(...files);+ }+ if (pendingSkillCallIds.size === 0) {+ signal?.removeEventListener('abort', onAbort);+ release();+ }+ },+ async applyTo(tc: ToolCallRequest): Promise<void> {+ await settled;+ /* Same call shape as the provisioned-attachment fold in the executor, so+ * identity (`storage_session_id` + `id`) and destination rules stay+ * consistent. Returns undefined when no skill contributed a file. */+ const merged = mergeCodeFilesIntoContext(+ tc.codeSessionContext as CodeSessionContext | undefined,+ uploadedFiles,+ );+ if (merged) {+ tc.codeSessionContext = merged;+ }+ },+ };+}+export function createToolExecuteHandler(options: ToolExecuteOptions): EventHandler {const {runSignal: hostRunSignal,@@ -5491,10 +5565,18 @@ export function createToolExecuteHandler(options: ToolExecuteOptions): EventHandonResult?: (result: ToolExecuteResult) => void;}).onResult;+ /** Set only for a batch that mixes `skill` calls with code calls (see+ * {@link createSkillFilesHandoff}); `undefined` leaves every other batch+ * fully concurrent. */+ let skillFilesHandoff: SkillFilesHandoff | undefined;/** Reports a settled result so the agent graph can emit that call's* completion immediately instead of waiting for the whole batch;* `resolve` below remains the authoritative batch outcome. */const reportResult = (result: ToolExecuteResult): ToolExecuteResult => {+ /* Every per-call return in the batch funnels through here, so this is+ * the one place that observes a `skill` call settling whatever path+ * produced its result, including the filtered and error paths. */+ skillFilesHandoff?.record(result);try {onResult?.(result);} catch (callbackError) {@@ -5583,6 +5665,21 @@ export function createToolExecuteHandler(options: ToolExecuteOptions): EventHand}}+ /* A code call in this batch reads its code-session context when it+ * executes, while the `skill` call beside it is still uploading the+ * files that belong in that context. Only a batch carrying both+ * kinds of call waits; every other batch stays fully concurrent. */+ const waitsForSkillFiles = (tc: ToolCallRequest): boolean =>+ tc.name !== Constants.SKILL_TOOL &&+ (isCodeSessionAwareToolCall(tc.name, mergedConfigurable) ||+ (runFileSharingActive && isCodeFileToolName(tc.name)));+ const skillToolCallIds = new Set(+ allowedToolCalls.filter((tc) => tc.name === Constants.SKILL_TOOL).map((tc) => tc.id),+ );+ if (skillToolCallIds.size > 0 && allowedToolCalls.some(waitsForSkillFiles)) {+ skillFilesHandoff = createSkillFilesHandoff(skillToolCallIds, runSignal);+ }+const codeExecutionContext = getCodeExecutionContext(mergedConfigurable);const runtimeSessionHint = codeExecutionContext?.runtimeSessionHint;if (runFileSharingActive && executionContext != null) {@@ -6789,6 +6886,20 @@ export function createToolExecuteHandler(options: ToolExecuteOptions): EventHand);}+ /* Before the background dispatch and before the sandbox+ * authoring context is cloned below: both capture this call's+ * code-session context, and a copy taken now would stay the+ * pre-skill snapshot for the rest of the call's life. */+ if (skillFilesHandoff != null && waitsForSkillFiles(tc)) {+ await skillFilesHandoff.applyTo(tc);+ if (runSignal?.aborted === true) {+ /** The Stop landed while the skill upload held this call.+ * Starting the tool now would send a request the turn has+ * already abandoned. */+ return reportResult(errorResult(tc, 'This operation was aborted'));+ }+ }+if (backgroundToolSet.has(tc.name) &&isBackgroundRequested(tc.args) &&