From 6b7a1d419cbffb893995f690edff18173c712b55 Mon Sep 17 00:00:00 2001 From: Kit Langton Date: Fri, 28 Aug 2026 22:14:13 -0400 Subject: [PATCH] fix(core): preserve Responses tool identities (#45658) --- .../openai-responses-language-model.ts | 81 ++-- .../openai-responses-prepare-tools.ts | 95 +++- .../openai-responses-language-model.test.ts | 420 +++++++++++++++++- .../openai-responses-prepare-tools.test.ts | 201 ++++++++- 4 files changed, 740 insertions(+), 57 deletions(-) diff --git a/packages/core/src/github-copilot/responses/openai-responses-language-model.ts b/packages/core/src/github-copilot/responses/openai-responses-language-model.ts index b14aa6b2f17..53667db090b 100644 --- a/packages/core/src/github-copilot/responses/openai-responses-language-model.ts +++ b/packages/core/src/github-copilot/responses/openai-responses-language-model.ts @@ -4,7 +4,6 @@ import { type LanguageModelV3, type LanguageModelV3CallOptions, type LanguageModelV3Content, - type LanguageModelV3ProviderTool, type LanguageModelV3StreamPart, type SharedV3ProviderMetadata, type SharedV3Warning, @@ -27,7 +26,7 @@ import { imageGenerationOutputSchema } from "./tool/image-generation.js" import { convertToOpenAIResponsesInput } from "./convert-to-openai-responses-input.js" import { mapOpenAIResponseFinishReason } from "./map-openai-responses-finish-reason.js" import type { OpenAIResponsesIncludeOptions, OpenAIResponsesIncludeValue } from "./openai-responses-api-types.js" -import { prepareResponsesTools } from "./openai-responses-prepare-tools.js" +import { prepareResponsesTools, type ResponsesHostedTool } from "./openai-responses-prepare-tools.js" import type { OpenAIResponsesModelId } from "./openai-responses-settings.js" const webSearchCallItem = z.object({ @@ -221,15 +220,23 @@ export class OpenAIResponsesLanguageModel implements LanguageModelV3 { addInclude("message.output_text.logprobs") } - // when a web search tool is present, automatically include the sources: - const webSearchToolName = ( - tools?.find( - (tool) => - tool.type === "provider" && (tool.id === "openai.web_search" || tool.id === "openai.web_search_preview"), - ) as LanguageModelV3ProviderTool | undefined - )?.name + const { + tools: openaiTools, + toolChoice: openaiToolChoice, + hostedTools, + selectedHostedTool, + toolWarnings, + } = prepareResponsesTools({ + tools, + toolChoice, + strictJsonSchema, + }) + const getHostedToolName = (responseType: ResponsesHostedTool["responseType"]) => { + if (selectedHostedTool?.responseType === responseType) return selectedHostedTool.name + return hostedTools.find((tool) => tool.responseType === responseType)?.name ?? responseType + } - if (webSearchToolName) { + if (hostedTools.some((tool) => tool.responseType === "web_search")) { addInclude("web_search_call.action.sources") } @@ -357,18 +364,8 @@ export class OpenAIResponsesLanguageModel implements LanguageModelV3 { baseArgs.service_tier = undefined } - const { - tools: openaiTools, - toolChoice: openaiToolChoice, - toolWarnings, - } = prepareResponsesTools({ - tools, - toolChoice, - strictJsonSchema, - }) - return { - webSearchToolName, + getHostedToolName, args: { ...baseArgs, tools: openaiTools, @@ -379,7 +376,7 @@ export class OpenAIResponsesLanguageModel implements LanguageModelV3 { } async doGenerate(options: LanguageModelV3CallOptions) { - const { args: body, warnings, webSearchToolName } = await this.getArgs(options) + const { args: body, warnings, getHostedToolName } = await this.getArgs(options) const url = this.config.url({ path: "/responses", modelId: this.modelId, @@ -526,7 +523,7 @@ export class OpenAIResponsesLanguageModel implements LanguageModelV3 { content.push({ type: "tool-call", toolCallId: part.id, - toolName: "image_generation", + toolName: getHostedToolName("image_generation"), input: "{}", providerExecuted: true, }) @@ -534,7 +531,7 @@ export class OpenAIResponsesLanguageModel implements LanguageModelV3 { content.push({ type: "tool-result", toolCallId: part.id, - toolName: "image_generation", + toolName: getHostedToolName("image_generation"), result: { result: part.result, } satisfies z.infer, @@ -605,7 +602,7 @@ export class OpenAIResponsesLanguageModel implements LanguageModelV3 { content.push({ type: "tool-call", toolCallId: part.id, - toolName: webSearchToolName ?? "web_search", + toolName: getHostedToolName("web_search"), input: JSON.stringify({ action: part.action }), providerExecuted: true, }) @@ -613,7 +610,7 @@ export class OpenAIResponsesLanguageModel implements LanguageModelV3 { content.push({ type: "tool-result", toolCallId: part.id, - toolName: webSearchToolName ?? "web_search", + toolName: getHostedToolName("web_search"), result: { status: part.status }, }) @@ -645,7 +642,7 @@ export class OpenAIResponsesLanguageModel implements LanguageModelV3 { content.push({ type: "tool-call", toolCallId: part.id, - toolName: "file_search", + toolName: getHostedToolName("file_search"), input: "{}", providerExecuted: true, }) @@ -653,7 +650,7 @@ export class OpenAIResponsesLanguageModel implements LanguageModelV3 { content.push({ type: "tool-result", toolCallId: part.id, - toolName: "file_search", + toolName: getHostedToolName("file_search"), result: { queries: part.queries, results: @@ -673,7 +670,7 @@ export class OpenAIResponsesLanguageModel implements LanguageModelV3 { content.push({ type: "tool-call", toolCallId: part.id, - toolName: "code_interpreter", + toolName: getHostedToolName("code_interpreter"), input: JSON.stringify({ code: part.code, containerId: part.container_id, @@ -684,7 +681,7 @@ export class OpenAIResponsesLanguageModel implements LanguageModelV3 { content.push({ type: "tool-result", toolCallId: part.id, - toolName: "code_interpreter", + toolName: getHostedToolName("code_interpreter"), result: { outputs: part.outputs, } satisfies z.infer, @@ -746,7 +743,7 @@ export class OpenAIResponsesLanguageModel implements LanguageModelV3 { } async doStream(options: LanguageModelV3CallOptions) { - const { args: body, warnings, webSearchToolName } = await this.getArgs(options) + const { args: body, warnings, getHostedToolName } = await this.getArgs(options) const { responseHeaders, value: response } = await postJsonToApi({ url: this.config.url({ @@ -866,7 +863,7 @@ export class OpenAIResponsesLanguageModel implements LanguageModelV3 { controller.enqueue({ type: "tool-input-start", id: value.item.id, - toolName: webSearchToolName ?? "web_search", + toolName: getHostedToolName("web_search"), }) } else if (value.item.type === "computer_call") { ongoingToolCalls[value.output_index] = { @@ -889,7 +886,7 @@ export class OpenAIResponsesLanguageModel implements LanguageModelV3 { controller.enqueue({ type: "tool-input-start", id: value.item.id, - toolName: "code_interpreter", + toolName: getHostedToolName("code_interpreter"), }) controller.enqueue({ @@ -901,7 +898,7 @@ export class OpenAIResponsesLanguageModel implements LanguageModelV3 { controller.enqueue({ type: "tool-call", toolCallId: value.item.id, - toolName: "file_search", + toolName: getHostedToolName("file_search"), input: "{}", providerExecuted: true, }) @@ -909,7 +906,7 @@ export class OpenAIResponsesLanguageModel implements LanguageModelV3 { controller.enqueue({ type: "tool-call", toolCallId: value.item.id, - toolName: "image_generation", + toolName: getHostedToolName("image_generation"), input: "{}", providerExecuted: true, }) @@ -980,7 +977,7 @@ export class OpenAIResponsesLanguageModel implements LanguageModelV3 { controller.enqueue({ type: "tool-call", toolCallId: value.item.id, - toolName: "web_search", + toolName: getHostedToolName("web_search"), input: JSON.stringify({ action: value.item.action }), providerExecuted: true, }) @@ -988,7 +985,7 @@ export class OpenAIResponsesLanguageModel implements LanguageModelV3 { controller.enqueue({ type: "tool-result", toolCallId: value.item.id, - toolName: "web_search", + toolName: getHostedToolName("web_search"), result: { status: value.item.status }, }) } else if (value.item.type === "computer_call") { @@ -1022,7 +1019,7 @@ export class OpenAIResponsesLanguageModel implements LanguageModelV3 { controller.enqueue({ type: "tool-result", toolCallId: value.item.id, - toolName: "file_search", + toolName: getHostedToolName("file_search"), result: { queries: value.item.queries, results: @@ -1041,7 +1038,7 @@ export class OpenAIResponsesLanguageModel implements LanguageModelV3 { controller.enqueue({ type: "tool-result", toolCallId: value.item.id, - toolName: "code_interpreter", + toolName: getHostedToolName("code_interpreter"), result: { outputs: value.item.outputs, } satisfies z.infer, @@ -1050,7 +1047,7 @@ export class OpenAIResponsesLanguageModel implements LanguageModelV3 { controller.enqueue({ type: "tool-result", toolCallId: value.item.id, - toolName: "image_generation", + toolName: getHostedToolName("image_generation"), result: { result: value.item.result, } satisfies z.infer, @@ -1099,7 +1096,7 @@ export class OpenAIResponsesLanguageModel implements LanguageModelV3 { controller.enqueue({ type: "tool-result", toolCallId: value.item_id, - toolName: "image_generation", + toolName: getHostedToolName("image_generation"), result: { result: value.partial_image_b64, } satisfies z.infer, @@ -1135,7 +1132,7 @@ export class OpenAIResponsesLanguageModel implements LanguageModelV3 { controller.enqueue({ type: "tool-call", toolCallId: toolCall.toolCallId, - toolName: "code_interpreter", + toolName: getHostedToolName("code_interpreter"), input: JSON.stringify({ code: value.code, containerId: toolCall.codeInterpreter!.containerId, diff --git a/packages/core/src/github-copilot/responses/openai-responses-prepare-tools.ts b/packages/core/src/github-copilot/responses/openai-responses-prepare-tools.ts index f87c53aa1a1..e69deea3ad8 100644 --- a/packages/core/src/github-copilot/responses/openai-responses-prepare-tools.ts +++ b/packages/core/src/github-copilot/responses/openai-responses-prepare-tools.ts @@ -1,4 +1,9 @@ -import { type LanguageModelV3CallOptions, type SharedV3Warning, UnsupportedFunctionalityError } from "@ai-sdk/provider" +import { + type LanguageModelV3CallOptions, + type LanguageModelV3ProviderTool, + type SharedV3Warning, + UnsupportedFunctionalityError, +} from "@ai-sdk/provider" import { codeInterpreterArgsSchema } from "./tool/code-interpreter.js" import { fileSearchArgsSchema } from "./tool/file-search.js" import { webSearchArgsSchema } from "./tool/web-search.js" @@ -6,6 +11,28 @@ import { webSearchPreviewArgsSchema } from "./tool/web-search-preview.js" import { imageGenerationArgsSchema } from "./tool/image-generation.js" import type { OpenAIResponsesTool } from "./openai-responses-api-types.js" +export type ResponsesHostedTool = { + name: string + type: "file_search" | "web_search_preview" | "web_search" | "code_interpreter" | "image_generation" + responseType: "file_search" | "web_search" | "code_interpreter" | "image_generation" +} + +export function getResponsesHostedTool(tool: LanguageModelV3ProviderTool): ResponsesHostedTool | undefined { + switch (tool.id) { + case "openai.file_search": + return { name: tool.name, type: "file_search", responseType: "file_search" } + case "openai.web_search_preview": + return { name: tool.name, type: "web_search_preview", responseType: "web_search" } + case "openai.web_search": + return { name: tool.name, type: "web_search", responseType: "web_search" } + case "openai.code_interpreter": + return { name: tool.name, type: "code_interpreter", responseType: "code_interpreter" } + case "openai.image_generation": + return { name: tool.name, type: "image_generation", responseType: "image_generation" } + } + return undefined +} + export function prepareResponsesTools({ tools, toolChoice, @@ -26,6 +53,8 @@ export function prepareResponsesTools({ | { type: "function"; name: string } | { type: "code_interpreter" } | { type: "image_generation" } + hostedTools: ResponsesHostedTool[] + selectedHostedTool?: ResponsesHostedTool toolWarnings: SharedV3Warning[] } { // when the tools array is empty, change it to undefined to prevent errors: @@ -34,7 +63,49 @@ export function prepareResponsesTools({ const toolWarnings: SharedV3Warning[] = [] if (tools == null) { - return { tools: undefined, toolChoice: undefined, toolWarnings } + return { tools: undefined, toolChoice: undefined, hostedTools: [], toolWarnings } + } + + const hostedTools = tools.flatMap((tool) => { + if (tool.type !== "provider") return [] + const hostedTool = getResponsesHostedTool(tool) + return hostedTool ? [hostedTool] : [] + }) + const selectedToolName = toolChoice?.type === "tool" ? toolChoice.toolName : undefined + const selectedTools = selectedToolName === undefined ? [] : tools.filter((tool) => tool.name === selectedToolName) + if (selectedTools.length > 1) { + throw new UnsupportedFunctionalityError({ + functionality: `ambiguous tool choice '${selectedToolName}': multiple tool definitions share this name`, + }) + } + const selectedHostedTool = + selectedTools[0]?.type === "provider" ? getResponsesHostedTool(selectedTools[0]) : undefined + + const ambiguousHostedResponse = + toolChoice?.type === "none" || toolChoice?.type === "tool" + ? undefined + : hostedTools.find( + (tool) => + new Set( + hostedTools.filter((candidate) => candidate.responseType === tool.responseType).map((item) => item.name), + ).size > 1, + ) + if (ambiguousHostedResponse) { + const names = new Set( + hostedTools.filter((tool) => tool.responseType === ambiguousHostedResponse.responseType).map((tool) => tool.name), + ) + throw new UnsupportedFunctionalityError({ + functionality: `ambiguous ${ambiguousHostedResponse.responseType} response for hosted tools: ${[...names].join(", ")}`, + }) + } + + if (selectedHostedTool) { + const names = new Set(hostedTools.filter((tool) => tool.type === selectedHostedTool.type).map((tool) => tool.name)) + if (names.size > 1) { + throw new UnsupportedFunctionalityError({ + functionality: `ambiguous ${selectedHostedTool.type} tool choice for hosted tools: ${[...names].join(", ")}`, + }) + } } const openaiTools: Array = [] @@ -134,7 +205,7 @@ export function prepareResponsesTools({ } if (toolChoice == null) { - return { tools: openaiTools, toolChoice: undefined, toolWarnings } + return { tools: openaiTools, toolChoice: undefined, hostedTools, selectedHostedTool, toolWarnings } } const type = toolChoice.type @@ -143,20 +214,18 @@ export function prepareResponsesTools({ case "auto": case "none": case "required": - return { tools: openaiTools, toolChoice: type, toolWarnings } - case "tool": + return { tools: openaiTools, toolChoice: type, hostedTools, selectedHostedTool, toolWarnings } + case "tool": { return { tools: openaiTools, - toolChoice: - toolChoice.toolName === "code_interpreter" || - toolChoice.toolName === "file_search" || - toolChoice.toolName === "image_generation" || - toolChoice.toolName === "web_search_preview" || - toolChoice.toolName === "web_search" - ? { type: toolChoice.toolName } - : { type: "function", name: toolChoice.toolName }, + toolChoice: selectedHostedTool + ? { type: selectedHostedTool.type } + : { type: "function", name: toolChoice.toolName }, + hostedTools, + selectedHostedTool, toolWarnings, } + } default: { const _exhaustiveCheck: never = type throw new UnsupportedFunctionalityError({ diff --git a/packages/core/test/github-copilot/openai-responses-language-model.test.ts b/packages/core/test/github-copilot/openai-responses-language-model.test.ts index 71bb78f2864..a68c8f469bc 100644 --- a/packages/core/test/github-copilot/openai-responses-language-model.test.ts +++ b/packages/core/test/github-copilot/openai-responses-language-model.test.ts @@ -1,10 +1,197 @@ import { OpenAIResponsesLanguageModel } from "@opencode-ai/core/github-copilot/responses/openai-responses-language-model" import { convertToOpenAIResponsesInput } from "@opencode-ai/core/github-copilot/responses/convert-to-openai-responses-input" import { describe, test, expect, mock } from "bun:test" -import type { LanguageModelV3Prompt, LanguageModelV3StreamPart } from "@ai-sdk/provider" +import type { LanguageModelV3Prompt, LanguageModelV3ProviderTool, LanguageModelV3StreamPart } from "@ai-sdk/provider" const TEST_PROMPT: LanguageModelV3Prompt = [{ role: "user", content: [{ type: "text", text: "Hello" }] }] +const HOSTED_TOOL_CASES = [ + { + id: "openai.web_search", + name: "current_web", + args: {}, + wireType: "web_search", + output: { + type: "web_search_call", + id: "web_1", + status: "completed", + action: { type: "search", query: "news" }, + }, + stream: [ + { + type: "response.output_item.added", + output_index: 0, + item: { + type: "web_search_call", + id: "web_1", + status: "in_progress", + action: { type: "search", query: "news" }, + }, + }, + { + type: "response.output_item.done", + output_index: 0, + item: { + type: "web_search_call", + id: "web_1", + status: "completed", + action: { type: "search", query: "news" }, + }, + }, + ], + streamEventTypes: ["tool-input-start", "tool-input-end", "tool-call", "tool-result"], + eventTypes: ["tool-input-start", "tool-call", "tool-result"], + }, + { + id: "openai.web_search_preview", + name: "preview_web", + args: {}, + wireType: "web_search_preview", + output: { + type: "web_search_call", + id: "preview_1", + status: "completed", + action: { type: "search", query: "news" }, + }, + stream: [ + { + type: "response.output_item.added", + output_index: 0, + item: { + type: "web_search_call", + id: "preview_1", + status: "in_progress", + action: { type: "search", query: "news" }, + }, + }, + { + type: "response.output_item.done", + output_index: 0, + item: { + type: "web_search_call", + id: "preview_1", + status: "completed", + action: { type: "search", query: "news" }, + }, + }, + ], + streamEventTypes: ["tool-input-start", "tool-input-end", "tool-call", "tool-result"], + eventTypes: ["tool-input-start", "tool-call", "tool-result"], + }, + { + id: "openai.file_search", + name: "documents", + args: { vectorStoreIds: ["store_1"] }, + wireType: "file_search", + output: { type: "file_search_call", id: "file_1", queries: ["news"], results: null }, + stream: [ + { + type: "response.output_item.added", + output_index: 0, + item: { type: "file_search_call", id: "file_1" }, + }, + { + type: "response.output_item.done", + output_index: 0, + item: { type: "file_search_call", id: "file_1", queries: ["news"], results: null }, + }, + ], + streamEventTypes: ["tool-call", "tool-result"], + eventTypes: ["tool-call", "tool-result"], + }, + { + id: "openai.code_interpreter", + name: "python", + args: {}, + wireType: "code_interpreter", + output: { + type: "code_interpreter_call", + id: "code_1", + code: "print(1)", + container_id: "container_1", + outputs: null, + }, + stream: [ + { + type: "response.output_item.added", + output_index: 0, + item: { + type: "code_interpreter_call", + id: "code_1", + code: null, + container_id: "container_1", + outputs: null, + status: "in_progress", + }, + }, + { + type: "response.code_interpreter_call_code.delta", + item_id: "code_1", + output_index: 0, + delta: "print(", + }, + { + type: "response.code_interpreter_call_code.done", + item_id: "code_1", + output_index: 0, + code: "print(1)", + }, + { + type: "response.output_item.done", + output_index: 0, + item: { + type: "code_interpreter_call", + id: "code_1", + code: "print(1)", + container_id: "container_1", + outputs: null, + }, + }, + ], + streamEventTypes: [ + "tool-input-start", + "tool-input-delta", + "tool-input-delta", + "tool-input-delta", + "tool-input-end", + "tool-call", + "tool-result", + ], + eventTypes: ["tool-input-start", "tool-call", "tool-result"], + }, + { + id: "openai.image_generation", + name: "illustrate", + args: {}, + wireType: "image_generation", + output: { type: "image_generation_call", id: "image_1", result: "final-image" }, + stream: [ + { + type: "response.output_item.added", + output_index: 0, + item: { type: "image_generation_call", id: "image_1" }, + }, + { + type: "response.image_generation_call.partial_image", + item_id: "image_1", + output_index: 0, + partial_image_b64: "partial-image", + }, + { + type: "response.output_item.done", + output_index: 0, + item: { type: "image_generation_call", id: "image_1", result: "final-image" }, + }, + ], + streamEventTypes: ["tool-call", "tool-result", "tool-result"], + eventTypes: ["tool-call", "tool-result", "tool-result"], + }, +] as const + +function hostedTool(testCase: (typeof HOSTED_TOOL_CASES)[number]): LanguageModelV3ProviderTool { + return { type: "provider", id: testCase.id, name: testCase.name, args: testCase.args } +} + function createMockFetch(body: unknown) { return mock( async () => new Response(JSON.stringify(body), { status: 200, headers: { "Content-Type": "application/json" } }), @@ -30,12 +217,144 @@ function createModel(fetchFn: ReturnType) { }) } +async function readStream(stream: ReadableStream) { + const reader = stream.getReader() + const events: LanguageModelV3StreamPart[] = [] + while (true) { + const item = await reader.read() + if (item.done) return events + events.push(item.value) + } +} + // GitHub Copilot's Responses model echoes item metadata (itemId, reasoningEncryptedContent, // responseId, ...) under the "copilot" providerOptions/providerMetadata namespace, matching the // namespace request options already use. It used to echo this metadata under "openai" (a leftover // from forking the OpenAI Responses model), which left it unreachable by anything reading the // "copilot" namespace and let stale itemIds slip past stripping meant for that namespace. describe("doGenerate", () => { + test.each([...HOSTED_TOOL_CASES])("forces $id by its declared logical name", async (testCase) => { + const requests: unknown[] = [] + const model = createModel( + mock(async (_input: Parameters[0], init?: RequestInit) => { + requests.push(await new Response(init?.body).json()) + return new Response( + JSON.stringify({ + id: "resp_1", + created_at: 0, + model: "test-model", + output: [], + usage: { input_tokens: 1, output_tokens: 1 }, + }), + { status: 200, headers: { "Content-Type": "application/json" } }, + ) + }), + ) + + await model.doGenerate({ + prompt: TEST_PROMPT, + tools: [hostedTool(testCase)], + toolChoice: { type: "tool", toolName: testCase.name }, + }) + + expect(requests[0]).toMatchObject({ tool_choice: { type: testCase.wireType } }) + }) + + test("does not mistake a colliding function name for a hosted tool", async () => { + const requests: unknown[] = [] + const model = createModel( + mock(async (_input: Parameters[0], init?: RequestInit) => { + requests.push(await new Response(init?.body).json()) + return new Response( + JSON.stringify({ + id: "resp_1", + created_at: 0, + model: "test-model", + output: [], + usage: { input_tokens: 1, output_tokens: 1 }, + }), + { status: 200, headers: { "Content-Type": "application/json" } }, + ) + }), + ) + await model.doGenerate({ + prompt: TEST_PROMPT, + tools: [ + { type: "provider", id: "openai.web_search", name: "lookup", args: {} }, + { type: "function", name: "web_search", inputSchema: { type: "object" } }, + ], + toolChoice: { type: "tool", toolName: "web_search" }, + }) + + expect(requests[0]).toMatchObject({ tool_choice: { type: "function", name: "web_search" } }) + }) + + test.each([...HOSTED_TOOL_CASES])("uses $name for generated $id calls and results", async (testCase) => { + const model = createModel( + createMockFetch({ + id: "resp_1", + created_at: 0, + model: "test-model", + output: [testCase.output], + usage: { input_tokens: 1, output_tokens: 1 }, + }), + ) + + const result = await model.doGenerate({ prompt: TEST_PROMPT, tools: [hostedTool(testCase)] }) + + expect(result.content.filter((part) => part.type === "tool-call" || part.type === "tool-result")).toMatchObject([ + { type: "tool-call", toolName: testCase.name }, + { type: "tool-result", toolName: testCase.name }, + ]) + }) + + test("uses canonical names only when no hosted declaration matches", async () => { + const model = createModel( + createMockFetch({ + id: "resp_1", + created_at: 0, + model: "test-model", + output: [ + HOSTED_TOOL_CASES[0].output, + HOSTED_TOOL_CASES[2].output, + HOSTED_TOOL_CASES[3].output, + HOSTED_TOOL_CASES[4].output, + { type: "computer_call", id: "computer_1", status: "completed" }, + ], + usage: { input_tokens: 1, output_tokens: 1 }, + }), + ) + + const result = await model.doGenerate({ prompt: TEST_PROMPT }) + + expect(result.content.filter((part) => part.type === "tool-call").map((part) => part.toolName)).toEqual([ + "web_search", + "file_search", + "code_interpreter", + "image_generation", + "computer_use", + ]) + }) + + test("rejects an automatic web response when both variants have different logical names", async () => { + const model = createModel( + createMockFetch({ + id: "resp_1", + created_at: 0, + model: "test-model", + output: [HOSTED_TOOL_CASES[0].output], + usage: { input_tokens: 1, output_tokens: 1 }, + }), + ) + + await expect( + model.doGenerate({ + prompt: TEST_PROMPT, + tools: [hostedTool(HOSTED_TOOL_CASES[0]), hostedTool(HOSTED_TOOL_CASES[1])], + }), + ).rejects.toThrow("ambiguous web_search response for hosted tools: current_web, preview_web") + }) + test("attaches item metadata under the copilot namespace, not openai", async () => { const mockFetch = createMockFetch({ id: "resp_1", @@ -129,6 +448,105 @@ describe("doGenerate", () => { }) describe("doStream", () => { + test.each([...HOSTED_TOOL_CASES])("uses $name for every streamed $id identity event", async (testCase) => { + const model = createModel(createStreamFetch(testCase.stream)) + const result = await model.doStream({ + prompt: TEST_PROMPT, + tools: [hostedTool(testCase)], + }) + const streamEvents = (await readStream(result.stream)).filter( + (event) => event.type !== "stream-start" && event.type !== "finish", + ) + const events = streamEvents.filter((event) => "toolName" in event) + + expect(streamEvents.map((event) => event.type)).toEqual([...testCase.streamEventTypes]) + expect(events.map((event) => event.type)).toEqual([...testCase.eventTypes]) + expect(events.map((event) => event.toolName)).toEqual(testCase.eventTypes.map(() => testCase.name)) + }) + + test("uses the forced web variant's logical name when both variants are declared", async () => { + const model = createModel(createStreamFetch(HOSTED_TOOL_CASES[1].stream)) + + const result = await model.doStream({ + prompt: TEST_PROMPT, + tools: [hostedTool(HOSTED_TOOL_CASES[0]), hostedTool(HOSTED_TOOL_CASES[1])], + toolChoice: { type: "tool", toolName: "preview_web" }, + }) + const events = (await readStream(result.stream)).filter((event) => "toolName" in event) + + expect(events.map((event) => event.toolName)).toEqual(["preview_web", "preview_web", "preview_web"]) + }) + + test("rejects ambiguous web variants before fetching or exposing a stream", async () => { + const fetchFn = createStreamFetch(HOSTED_TOOL_CASES[0].stream) + const model = createModel(fetchFn) + + await expect( + model.doStream({ + prompt: TEST_PROMPT, + tools: [hostedTool(HOSTED_TOOL_CASES[0]), hostedTool(HOSTED_TOOL_CASES[1])], + }), + ).rejects.toThrow("ambiguous web_search response for hosted tools") + expect(fetchFn).not.toHaveBeenCalled() + }) + + test("rejects an ambiguous forced wire choice before fetching or exposing a stream", async () => { + const fetchFn = createStreamFetch(HOSTED_TOOL_CASES[0].stream) + const model = createModel(fetchFn) + + await expect( + model.doStream({ + prompt: TEST_PROMPT, + tools: [hostedTool(HOSTED_TOOL_CASES[0]), { ...hostedTool(HOSTED_TOOL_CASES[0]), name: "backup_web" }], + toolChoice: { type: "tool", toolName: HOSTED_TOOL_CASES[0].name }, + }), + ).rejects.toThrow("ambiguous web_search tool choice for hosted tools") + expect(fetchFn).not.toHaveBeenCalled() + }) + + test("streams a shared logical name for both web variants", async () => { + const model = createModel(createStreamFetch(HOSTED_TOOL_CASES[0].stream)) + const tools = [hostedTool(HOSTED_TOOL_CASES[0]), hostedTool(HOSTED_TOOL_CASES[1])].map((tool) => ({ + ...tool, + name: "web", + })) + + const result = await model.doStream({ prompt: TEST_PROMPT, tools }) + const events = (await readStream(result.stream)).filter((event) => "toolName" in event) + + expect(events.map((event) => event.toolName)).toEqual(["web", "web", "web"]) + }) + + test("uses canonical names for undeclared streamed web and computer calls", async () => { + const model = createModel( + createStreamFetch([ + ...HOSTED_TOOL_CASES[0].stream, + { + type: "response.output_item.added", + output_index: 1, + item: { type: "computer_call", id: "computer_1", status: "in_progress" }, + }, + { + type: "response.output_item.done", + output_index: 1, + item: { type: "computer_call", id: "computer_1", status: "completed" }, + }, + ]), + ) + + const result = await model.doStream({ prompt: TEST_PROMPT }) + const events = (await readStream(result.stream)).filter((event) => "toolName" in event) + + expect(events.map((event) => event.toolName)).toEqual([ + "web_search", + "web_search", + "web_search", + "computer_use", + "computer_use", + "computer_use", + ]) + }) + test("streams sequential Copilot reasoning summary blocks", async () => { const model = createModel( createStreamFetch([ diff --git a/packages/core/test/github-copilot/openai-responses-prepare-tools.test.ts b/packages/core/test/github-copilot/openai-responses-prepare-tools.test.ts index 011a538a0bb..154392662de 100644 --- a/packages/core/test/github-copilot/openai-responses-prepare-tools.test.ts +++ b/packages/core/test/github-copilot/openai-responses-prepare-tools.test.ts @@ -1,5 +1,9 @@ import { expect, test } from "bun:test" -import type { LanguageModelV3FunctionTool } from "@ai-sdk/provider" +import type { + LanguageModelV3CallOptions, + LanguageModelV3FunctionTool, + LanguageModelV3ProviderTool, +} from "@ai-sdk/provider" import { prepareResponsesTools } from "@opencode-ai/core/github-copilot/responses/openai-responses-prepare-tools" function prepare(strict: boolean | undefined, strictJsonSchema: boolean) { @@ -18,3 +22,198 @@ test("function tools prefer explicit strictness over the global fallback", () => expect(prepare(undefined, true)).toMatchObject({ type: "function", strict: true }) expect(prepare(undefined, false)).toMatchObject({ type: "function", strict: false }) }) + +const webTools: LanguageModelV3ProviderTool[] = [ + { type: "provider", id: "openai.web_search", name: "current_web", args: {} }, + { type: "provider", id: "openai.web_search_preview", name: "preview_web", args: {} }, +] + +test.each([ + { order: webTools, toolChoice: undefined }, + { order: webTools.toReversed(), toolChoice: undefined }, + { order: webTools, toolChoice: { type: "auto" as const } }, + { order: webTools.toReversed(), toolChoice: { type: "auto" as const } }, + { order: webTools, toolChoice: { type: "required" as const } }, + { order: webTools.toReversed(), toolChoice: { type: "required" as const } }, +])("rejects differently named web variants before automatic or required selection", ({ order, toolChoice }) => { + expect(() => prepareResponsesTools({ tools: order, toolChoice, strictJsonSchema: false })).toThrow( + "ambiguous web_search response for hosted tools", + ) +}) + +test.each([ + { order: webTools, name: "current_web", wireType: "web_search" }, + { order: webTools.toReversed(), name: "current_web", wireType: "web_search" }, + { order: webTools, name: "preview_web", wireType: "web_search_preview" }, + { order: webTools.toReversed(), name: "preview_web", wireType: "web_search_preview" }, +])("uses the uniquely forced web variant independent of declaration order", ({ order, name, wireType }) => { + const result = prepareResponsesTools({ + tools: order, + toolChoice: { type: "tool", toolName: name }, + strictJsonSchema: false, + }) + + expect(result.toolChoice).toEqual({ type: wireType }) + expect(result.selectedHostedTool).toMatchObject({ name, type: wireType, responseType: "web_search" }) +}) + +test.each([{ order: webTools }, { order: webTools.toReversed() }])( + "allows indistinguishable web variants when they share one logical name", + ({ order }) => { + const tools = order.map((tool) => ({ ...tool, name: "web" })) + const result = prepareResponsesTools({ tools, toolChoice: { type: "required" }, strictJsonSchema: false }) + + expect(result.hostedTools.map((tool) => tool.name)).toEqual(["web", "web"]) + }, +) + +const duplicateToolCases = [ + [ + { type: "function", name: "lookup", inputSchema: { type: "object" } }, + { type: "provider", id: "openai.web_search", name: "lookup", args: {} }, + ], + [ + { type: "provider", id: "other.unsupported", name: "lookup", args: {} }, + { type: "provider", id: "openai.web_search", name: "lookup", args: {} }, + ], + [ + { type: "provider", id: "openai.web_search", name: "lookup", args: {} }, + { type: "provider", id: "openai.web_search_preview", name: "lookup", args: {} }, + ], +] satisfies Array> + +test.each(duplicateToolCases.flatMap((tools) => [{ tools }, { tools: tools.toReversed() }]))( + "rejects duplicate forced definitions independent of type and order", + ({ tools }) => { + expect(() => + prepareResponsesTools({ + tools, + toolChoice: { type: "tool", toolName: "lookup" }, + strictJsonSchema: false, + }), + ).toThrow("multiple tool definitions share this name") + }, +) + +const duplicateHostedToolCases = [ + { id: "openai.web_search", responseType: "web_search", args: {} }, + { id: "openai.web_search_preview", responseType: "web_search", args: {} }, + { id: "openai.file_search", responseType: "file_search", args: { vectorStoreIds: ["store_1"] } }, + { id: "openai.code_interpreter", responseType: "code_interpreter", args: {} }, + { id: "openai.image_generation", responseType: "image_generation", args: {} }, +] as const + +function duplicateHostedTools(testCase: (typeof duplicateHostedToolCases)[number], sameName = false) { + return [ + { type: "provider" as const, id: testCase.id, name: `${testCase.responseType}_one`, args: testCase.args }, + { + type: "provider" as const, + id: testCase.id, + name: sameName ? `${testCase.responseType}_one` : `${testCase.responseType}_two`, + args: testCase.args, + }, + ] +} + +test.each( + duplicateHostedToolCases.flatMap((testCase) => + [undefined, { type: "auto" as const }, { type: "required" as const }].flatMap((toolChoice) => { + const tools = duplicateHostedTools(testCase) + return [ + { testCase, tools, toolChoice, selection: toolChoice?.type ?? "default" }, + { testCase, tools: tools.toReversed(), toolChoice, selection: toolChoice?.type ?? "default" }, + ] + }), + ), +)( + "rejects differently named duplicate $testCase.id responses for $selection selection", + ({ testCase, tools, toolChoice }) => { + expect(() => prepareResponsesTools({ tools, toolChoice, strictJsonSchema: false })).toThrow( + `ambiguous ${testCase.responseType} response for hosted tools`, + ) + }, +) + +test.each( + duplicateHostedToolCases.flatMap((testCase) => { + const tools = duplicateHostedTools(testCase, true) + return [ + { testCase, tools }, + { testCase, tools: tools.toReversed() }, + ] + }), +)("allows duplicate $testCase.id responses with the same logical name", ({ tools }) => { + expect( + prepareResponsesTools({ tools, toolChoice: { type: "required" }, strictJsonSchema: false }).hostedTools.map( + (tool) => tool.name, + ), + ).toEqual([tools[0].name, tools[0].name]) +}) + +test.each( + duplicateHostedToolCases.flatMap((testCase) => { + const tools = duplicateHostedTools(testCase) + return [ + { testCase, tools }, + { testCase, tools: tools.toReversed() }, + ] + }), +)("rejects a forced $testCase.id wire choice with multiple logical identities", ({ testCase, tools }) => { + expect(() => + prepareResponsesTools({ + tools, + toolChoice: { type: "tool", toolName: `${testCase.responseType}_one` }, + strictJsonSchema: false, + }), + ).toThrow(`ambiguous ${tools[0].id.replace("openai.", "")} tool choice for hosted tools`) +}) + +test.each( + duplicateHostedToolCases.flatMap((testCase) => { + const tools = duplicateHostedTools(testCase, true) + return [{ tools }, { tools: tools.toReversed() }] + }), +)("rejects a forced logical name shared by duplicate same-wire definitions", ({ tools }) => { + expect(() => + prepareResponsesTools({ + tools, + toolChoice: { type: "tool", toolName: tools[0].name }, + strictJsonSchema: false, + }), + ).toThrow("multiple tool definitions share this name") +}) + +test.each([...duplicateHostedToolCases])("skips ambiguous $id responses when tool choice is none", (testCase) => { + expect( + prepareResponsesTools({ + tools: duplicateHostedTools(testCase), + toolChoice: { type: "none" }, + strictJsonSchema: false, + }).toolChoice, + ).toBe("none") +}) + +test.each([...duplicateHostedToolCases])("skips ambiguous $id responses for a uniquely forced function", (testCase) => { + expect( + prepareResponsesTools({ + tools: [...duplicateHostedTools(testCase), { type: "function", name: "local", inputSchema: { type: "object" } }], + toolChoice: { type: "tool", toolName: "local" }, + strictJsonSchema: false, + }).toolChoice, + ).toEqual({ type: "function", name: "local" }) +}) + +test.each([{ ambiguousWebTools: duplicateHostedTools(duplicateHostedToolCases[0]) }, { ambiguousWebTools: webTools }])( + "validates only the selected wire choice for a forced unrelated hosted tool", + ({ ambiguousWebTools }) => { + const selected = duplicateHostedTools(duplicateHostedToolCases[2], true)[0] + const result = prepareResponsesTools({ + tools: [...ambiguousWebTools, selected], + toolChoice: { type: "tool", toolName: selected.name }, + strictJsonSchema: false, + }) + + expect(result.toolChoice).toEqual({ type: "file_search" }) + expect(result.selectedHostedTool).toMatchObject({ name: selected.name, type: "file_search" }) + }, +)