@jeffreycao/copilot-api 1.10.3 → 1.10.5

package/dist/{server-UsHsMP_2.js → server-DsfYz_GE.js}

@@ -1,10 +1,12 @@
 import { t as PATHS } from "./paths-DC-mqCY3.js";
 import { D as generateTraceId, E as prepareMessageProxyHeaders, I as state, M as compactMessageSections, O as requestContext, P as compactSystemPromptStarts, T as prepareInteractionHeaders, _ as copilotWebSocketHeaders, c as getUUID, d as sleep, f as getCopilotUsage, g as copilotHeaders, h as copilotBaseUrl, j as compactAutoContinuePromptStarts, k as resolveTraceId$1, l as isNullish, m as forwardError, n as cacheModels, o as generateRequestIdFromPayload, p as HTTPError, s as getRootSessionId, u as parseUserIdMetadata, w as prepareForCompact } from "./utils-jHLgqAq2.js";
-import { _ as setModelMappings, a as getConfig, c as getProviderConfig, d as isMessagesApiEnabled, f as isResponsesApiContextManagementModel, g as resolveMappedModel, i as getClaudeTokenMultiplier, l as getReasoningEffortForModel, m as isResponsesApiWebSocketEnabled, o as getExtraPromptForModel, p as isResponsesApiWebSearchEnabled, r as getAnthropicApiKey, s as getModelMappings, t as getProxyEnvDispatcher, u as getSmallModel } from "./proxy-DQLzdeq3.js";
+import { a as isDeferredToolName, c as parseMcpToolSearchSentinel, d as shouldEnableResponsesToolSearch, i as isBridgeToolSearchName, l as resolveBridgeToolSearchName, o as listDeferredToolNames, r as formatToolSearchBridgeArguments, s as normalizeToolSearchBridgeArguments, t as BRIDGE_TOOL_SEARCH_NAME, u as selectDeferredToolsByNames } from "./tool-search-CKe6hqnv.js";
+import { _ as setModelMappings, a as getConfig, c as getProviderConfig, d as isMessagesApiEnabled, f as isResponsesApiContextManagementModel, g as resolveMappedModel, i as getClaudeTokenMultiplier, l as getReasoningEffortForModel, m as isResponsesApiWebSocketEnabled, o as getExtraPromptForModel, p as isResponsesApiWebSearchEnabled, r as getAnthropicApiKey, s as getModelMappings, t as getProxyEnvDispatcher, u as getSmallModel } from "./proxy-CSO5SLia.js";
 import consola from "consola";
 import fs from "node:fs/promises";
 import path from "node:path";
 import { createHash } from "node:crypto";
+import { z } from "zod";
 import { Hono } from "hono";
 import { cors } from "hono/cors";
 import { logger } from "hono/logger";
@@ -12,7 +14,6 @@ import fs$1, { readFileSync } from "node:fs";
 import { streamSSE } from "hono/streaming";
 import util from "node:util";
 import { events } from "fetch-event-stream";
-import { z } from "zod";
 import { WebSocket } from "undici";
 //#region src/lib/request-auth.ts
 function normalizeApiKeys(apiKeys) {
@@ -2705,7 +2706,7 @@ const buildResponsesWebSocketPoolKey = (payload, { requestId, subagentMarker })
 const getResponsesWebSocketInitiator = (preparedHeaders) => {
 	return getHeaderValue(preparedHeaders, "x-initiator")?.toLowerCase() === "agent" ? "agent" : "user";
 };
-const createPooledResponsesWebSocketStream = (request) => runResponsesWebSocketPoolRequest(request);
+const createPooledResponsesWebSocketStream = (request) => runResponsesWebSocketRequest(request);
 const buildResponsesWebSocketPayload = (payload, initiator) => {
 	const websocketPayload = {
 		...payload,
@@ -2724,11 +2725,12 @@ const buildResponsesWebSocketUrl = (baseUrl) => {
 	return url.toString();
 };
 const responsesWebSocketPool = /* @__PURE__ */ new Map();
-const runResponsesWebSocketPoolRequest = async function* (request) {
-	const entry = getResponsesWebSocketPoolEntry(request);
-	const release = await acquireResponsesWebSocketPoolEntry(request.poolKey, entry);
+const responsesWebSocketActiveRequests = /* @__PURE__ */ new Map();
+const runResponsesWebSocketRequest = async function* (request) {
+	const { entry, pooled } = getResponsesWebSocketRequestTarget(request);
+	const release = acquireResponsesWebSocketEntry(request.poolKey, entry, pooled);
 	try {
-		const websocket = await entry.websocketPromise;
+		const websocket = await getReadyResponsesWebSocket(request.poolKey, entry, pooled);
 		websocket.send(JSON.stringify(request.payload));
 		for await (const data of createWebSocketMessageStream(websocket)) {
 			const chunk = createResponsesWebSocketStreamChunk(data);
@@ -2744,21 +2746,31 @@ const runResponsesWebSocketPoolRequest = async function* (request) {
 		release();
 	}
 };
-const getResponsesWebSocketPoolEntry = (request) => {
+const getResponsesWebSocketRequestTarget = (request) => {
+	if (getResponsesWebSocketActiveRequestCount(request.poolKey) > 0) return {
+		entry: createResponsesWebSocketEntry(request),
+		pooled: false
+	};
 	const existing = responsesWebSocketPool.get(request.poolKey);
 	if (existing && !existing.closed) {
 		clearResponsesWebSocketIdleTimer(existing);
-		return existing;
+		return {
+			entry: existing,
+			pooled: true
+		};
 	}
-	const entry = createResponsesWebSocketPoolEntry(request);
+	const entry = createResponsesWebSocketEntry(request);
 	responsesWebSocketPool.set(request.poolKey, entry);
-	return entry;
+	return {
+		entry,
+		pooled: true
+	};
 };
-const createResponsesWebSocketPoolEntry = (request) => {
+const createResponsesWebSocketEntry = (request) => {
 	const entry = {
 		closed: false,
 		idleTimer: null,
-		lock: Promise.resolve(),
+		requestCount: 0,
 		websocketPromise: openResponsesWebSocket({
 			headers: request.headers,
 			url: buildResponsesWebSocketUrl(copilotBaseUrl(state))
@@ -2776,23 +2788,34 @@ const createResponsesWebSocketPoolEntry = (request) => {
 	});
 	return entry;
 };
-const acquireResponsesWebSocketPoolEntry = async (poolKey, entry) => {
-	clearResponsesWebSocketIdleTimer(entry);
-	let releaseCurrent;
-	const previousLock = entry.lock;
-	entry.lock = new Promise((resolve) => {
-		releaseCurrent = resolve;
-	});
-	await previousLock;
+const acquireResponsesWebSocketEntry = (poolKey, entry, pooled) => {
 	clearResponsesWebSocketIdleTimer(entry);
+	incrementResponsesWebSocketActiveRequestCount(poolKey);
+	entry.requestCount += 1;
 	let released = false;
 	return () => {
 		if (released) return;
 		released = true;
-		releaseCurrent();
-		if (!entry.closed) scheduleResponsesWebSocketIdleClose(poolKey, entry);
+		entry.requestCount -= 1;
+		decrementResponsesWebSocketActiveRequestCount(poolKey);
+		if (entry.closed || entry.requestCount > 0) return;
+		if (pooled && responsesWebSocketPool.get(poolKey) === entry) {
+			scheduleResponsesWebSocketIdleClose(poolKey, entry);
+			return;
+		}
+		removeResponsesWebSocketPoolEntry(poolKey, entry);
 	};
 };
+const getReadyResponsesWebSocket = async (poolKey, entry, pooled) => {
+	if (entry.closed) throw new Error("Responses websocket became unavailable before the request started");
+	const websocket = await entry.websocketPromise;
+	if (entry.closed || pooled && responsesWebSocketPool.get(poolKey) !== entry) throw new Error("Responses websocket became unavailable before the request started");
+	if (websocket.readyState !== WebSocket.OPEN) {
+		removeResponsesWebSocketPoolEntry(poolKey, entry);
+		throw new Error("Responses websocket became unavailable before the request started");
+	}
+	return websocket;
+};
 const scheduleResponsesWebSocketIdleClose = (poolKey, entry) => {
 	clearResponsesWebSocketIdleTimer(entry);
 	entry.idleTimer = setTimeout(() => {
@@ -2806,9 +2829,21 @@ const clearResponsesWebSocketIdleTimer = (entry) => {
 		entry.idleTimer = null;
 	}
 };
+const getResponsesWebSocketActiveRequestCount = (poolKey) => responsesWebSocketActiveRequests.get(poolKey) ?? 0;
+const incrementResponsesWebSocketActiveRequestCount = (poolKey) => {
+	responsesWebSocketActiveRequests.set(poolKey, getResponsesWebSocketActiveRequestCount(poolKey) + 1);
+};
+const decrementResponsesWebSocketActiveRequestCount = (poolKey) => {
+	const nextCount = getResponsesWebSocketActiveRequestCount(poolKey) - 1;
+	if (nextCount <= 0) {
+		responsesWebSocketActiveRequests.delete(poolKey);
+		return;
+	}
+	responsesWebSocketActiveRequests.set(poolKey, nextCount);
+};
 const removeResponsesWebSocketPoolEntry = (poolKey, entry) => {
-	if (responsesWebSocketPool.get(poolKey) !== entry) return;
-	responsesWebSocketPool.delete(poolKey);
+	if (responsesWebSocketPool.get(poolKey) === entry) responsesWebSocketPool.delete(poolKey);
+	if (entry.closed) return;
 	entry.closed = true;
 	clearResponsesWebSocketIdleTimer(entry);
 	entry.websocketPromise.then(closeResponsesWebSocket).catch(() => {});
@@ -2959,10 +2994,19 @@ const buildPromptCacheKey = (basePromptCacheKey, subagentAgentId) => {
 const translateAnthropicMessagesToResponsesPayload = (payload, subagentAgentId) => {
 	const input = [];
 	const applyPhase = shouldApplyPhase(payload.model);
-	for (const message of payload.messages) input.push(...translateMessage(message, payload.model, applyPhase));
+	const toolSearchEnabled = shouldEnableResponsesToolSearch({
+		model: payload.model,
+		tools: payload.tools
+	});
+	const translationState = {
+		originalTools: payload.tools ?? [],
+		toolSearchEnabled,
+		toolUseNameById: /* @__PURE__ */ new Map()
+	};
+	for (const message of payload.messages) input.push(...translateMessage(message, payload.model, applyPhase, translationState));
 	const hasOriginalTools = Array.isArray(payload.tools) && payload.tools.length > 0;
-	const translatedTools = convertAnthropicTools(payload.tools);
-	const toolChoice = convertAnthropicToolChoice(payload.tool_choice);
+	const translatedTools = convertAnthropicTools(payload.tools, toolSearchEnabled);
+	const toolChoice = convertAnthropicToolChoice(payload.tool_choice, toolSearchEnabled);
 	const { sessionId: metadataPromptCacheKey } = parseUserIdMetadata(payload.metadata?.user_id);
 	const sessionAffinity = requestContext.getStore()?.sessionAffinity?.trim() || null;
 	const promptCacheKey = buildPromptCacheKey(metadataPromptCacheKey ?? sessionAffinity, subagentAgentId);
@@ -3005,11 +3049,11 @@ const decodeCompactionCarrierSignature = (signature) => {
 		};
 	}
 };
-const translateMessage = (message, model, applyPhase) => {
-	if (message.role === "user") return translateUserMessage(message);
-	return translateAssistantMessage(message, model, applyPhase);
+const translateMessage = (message, model, applyPhase, state) => {
+	if (message.role === "user") return translateUserMessage(message, state);
+	return translateAssistantMessage(message, model, applyPhase, state);
 };
-const translateUserMessage = (message) => {
+const translateUserMessage = (message, state) => {
 	if (typeof message.content === "string") return [createMessage("user", message.content)];
 	if (!Array.isArray(message.content)) return [];
 	const items = [];
@@ -3017,7 +3061,7 @@ const translateUserMessage = (message) => {
 	for (const block of message.content) {
 		if (block.type === "tool_result") {
 			flushPendingContent(pendingContent, items, { role: "user" });
-			items.push(createFunctionCallOutput(block));
+			items.push(createToolCallOutput(block, state));
 			continue;
 		}
 		const converted = translateUserContentBlock(block);
@@ -3026,7 +3070,7 @@ const translateUserMessage = (message) => {
 	flushPendingContent(pendingContent, items, { role: "user" });
 	return items;
 };
-const translateAssistantMessage = (message, model, applyPhase) => {
+const translateAssistantMessage = (message, model, applyPhase, state) => {
 	const assistantPhase = resolveAssistantPhase(model, message.content, applyPhase);
 	if (typeof message.content === "string") return [createMessage("assistant", message.content, assistantPhase)];
 	if (!Array.isArray(message.content)) return [];
@@ -3034,11 +3078,12 @@ const translateAssistantMessage = (message, model, applyPhase) => {
 	const pendingContent = [];
 	for (const block of message.content) {
 		if (block.type === "tool_use") {
+			state.toolUseNameById.set(block.id, block.name);
 			flushPendingContent(pendingContent, items, {
 				role: "assistant",
 				phase: assistantPhase
 			});
-			items.push(createFunctionToolCall(block));
+			items.push(createToolCall(block, state));
 			continue;
 		}
 		if (block.type === "thinking" && block.signature) {
@@ -3156,19 +3201,79 @@ const parseReasoningSignature = (signature) => {
 		id: signature.slice(splitIndex + 1)
 	};
 };
-const createFunctionToolCall = (block) => ({
+const createFunctionToolCall = (block, state) => ({
 	type: "function_call",
 	call_id: block.id,
 	name: block.name,
 	arguments: JSON.stringify(block.input),
+	status: "completed",
+	...state.toolSearchEnabled && isDeferredToolName(block.name) ? { namespace: block.name } : {}
+});
+const createToolSearchCall = (block) => ({
+	type: "tool_search_call",
+	call_id: block.id,
+	arguments: normalizeToolSearchBridgeArguments(block.input),
+	execution: "client",
 	status: "completed"
 });
+const createToolCall = (block, state) => {
+	if (state.toolSearchEnabled && isBridgeToolSearchName(block.name)) return createToolSearchCall(block);
+	return createFunctionToolCall(block, state);
+};
 const createFunctionCallOutput = (block) => ({
 	type: "function_call_output",
 	call_id: block.tool_use_id,
 	output: convertToolResultContent(block.content),
 	status: block.is_error ? "incomplete" : "completed"
 });
+const createToolCallOutput = (block, state) => {
+	const toolUseName = state.toolUseNameById.get(block.tool_use_id);
+	if (state.toolSearchEnabled && isBridgeToolSearchName(toolUseName ?? "")) return createToolSearchOutput(block, state.originalTools);
+	return createFunctionCallOutput(block);
+};
+const createToolSearchOutput = (block, originalTools) => {
+	const referencedToolNames = resolveToolSearchReferencedToolNames(block.content, originalTools);
+	return {
+		type: "tool_search_output",
+		call_id: block.tool_use_id,
+		tools: referencedToolNames.map((toolName) => convertDeferredToolToNamespace(resolveDeferredTool(toolName, originalTools))),
+		execution: "client",
+		status: block.is_error ? "incomplete" : "completed"
+	};
+};
+const resolveToolSearchReferencedToolNames = (content, originalTools) => {
+	const explicitReferences = extractToolReferenceNames(content);
+	if (explicitReferences.length > 0) return uniqueToolNames(explicitReferences);
+	const sentinel = extractMcpToolSearchSentinel(content);
+	if (sentinel) return selectDeferredToolsByNames(sentinel.names, originalTools).map((tool) => tool.name);
+	return [];
+};
+const extractToolReferenceNames = (content) => {
+	if (!Array.isArray(content)) return [];
+	return content.flatMap((block) => block.type === "tool_reference" ? [block.tool_name] : []);
+};
+const extractMcpToolSearchSentinel = (content) => {
+	if (typeof content === "string") return parseMcpToolSearchSentinel(content);
+	for (const block of content) {
+		if (block.type !== "text") continue;
+		const sentinel = parseMcpToolSearchSentinel(block.text);
+		if (sentinel) return sentinel;
+	}
+	return null;
+};
+const resolveDeferredTool = (toolName, originalTools) => {
+	const tool = originalTools.find((candidate) => candidate.name === toolName);
+	if (tool && isDeferredToolName(tool.name)) return tool;
+	throw createInvalidRequestError(`Tool reference '${toolName}' has no corresponding deferred tool definition`);
+};
+const uniqueToolNames = (toolNames) => [...new Set(toolNames)];
+const createInvalidRequestError = (message) => new HTTPError(message, new Response(JSON.stringify({ error: {
+	message,
+	type: "invalid_request_error"
+} }), {
+	status: 400,
+	headers: { "content-type": "application/json" }
+}));
 const translateSystemPrompt = (system, model) => {
 	if (!system) return null;
 	const extraPrompt = getExtraPromptForModel(model);
@@ -3179,31 +3284,83 @@ const translateSystemPrompt = (system, model) => {
 	}).join(" ");
 	return text.length > 0 ? text : null;
 };
-const convertAnthropicTools = (tools) => {
+const convertAnthropicTools = (tools, toolSearchEnabled) => {
 	if (!tools || tools.length === 0) return null;
-	return tools.map((tool) => ({
+	const converted = [];
+	let addedToolSearch = false;
+	const searchableToolNames = toolSearchEnabled ? listDeferredToolNames(tools) : [];
+	for (const tool of tools) {
+		if (isBridgeToolSearchName(tool.name)) {
+			if (toolSearchEnabled && !addedToolSearch) {
+				converted.push(createResponsesToolSearchDefinition(searchableToolNames));
+				addedToolSearch = true;
+			}
+			continue;
+		}
+		if (toolSearchEnabled && isDeferredToolName(tool.name)) {
+			converted.push(convertDeferredToolToNamespace(tool));
+			continue;
+		}
+		converted.push(convertToolToFunction(tool));
+	}
+	return converted;
+};
+const createResponsesToolSearchDefinition = (searchableToolNames) => ({
+	type: "tool_search",
+	execution: "client",
+	description: "Load deferred tools by exact name before using them. Return only the searchable tool names you need for the next step.",
+	parameters: {
+		type: "object",
+		properties: { names: {
+			type: "array",
+			description: "Exact deferred tool names to load.",
+			items: {
+				type: "string",
+				enum: searchableToolNames
+			},
+			minItems: 1
+		} },
+		required: ["names"],
+		additionalProperties: false
+	}
+});
+const convertToolToFunction = (tool) => ({
+	type: "function",
+	name: tool.name,
+	parameters: normalizeToolSchema(tool.input_schema),
+	strict: false,
+	...tool.description ? { description: tool.description } : {}
+});
+const convertDeferredToolToNamespace = (tool) => ({
+	type: "namespace",
+	name: tool.name,
+	...tool.description ? { description: tool.description } : {},
+	tools: [{
 		type: "function",
 		name: tool.name,
 		parameters: normalizeToolSchema(tool.input_schema),
 		strict: false,
+		defer_loading: true,
 		...tool.description ? { description: tool.description } : {}
-	}));
-};
-const convertAnthropicToolChoice = (choice) => {
+	}]
+});
+const convertAnthropicToolChoice = (choice, toolSearchEnabled) => {
 	if (!choice) return "auto";
 	switch (choice.type) {
 		case "auto": return "auto";
 		case "any": return "required";
-		case "tool": return choice.name ? {
-			type: "function",
-			name: choice.name
-		} : "auto";
+		case "tool":
+			if (toolSearchEnabled && choice.name && isBridgeToolSearchName(choice.name)) return "auto";
+			return choice.name ? {
+				type: "function",
+				name: choice.name
+			} : "auto";
 		case "none": return "none";
 		default: return "auto";
 	}
 };
-const translateResponsesResultToAnthropic = (response) => {
-	const contentBlocks = mapOutputToAnthropicContent(response.output);
+const translateResponsesResultToAnthropic = (response, options) => {
+	const contentBlocks = mapOutputToAnthropicContent(response.output, options);
 	const usage = mapResponsesUsage(response);
 	let anthropicContent = fallbackContentBlocks(response.output_text);
 	if (contentBlocks.length > 0) anthropicContent = contentBlocks;
@@ -3219,7 +3376,7 @@ const translateResponsesResultToAnthropic = (response) => {
 		usage
 	};
 };
-const mapOutputToAnthropicContent = (output) => {
+const mapOutputToAnthropicContent = (output, options) => {
 	const contentBlocks = [];
 	for (const item of output) switch (item.type) {
 		case "reasoning": {
@@ -3236,6 +3393,12 @@ const mapOutputToAnthropicContent = (output) => {
 			if (toolUseBlock) contentBlocks.push(toolUseBlock);
 			break;
 		}
+		case "tool_search_call": {
+			const toolUseBlock = createToolSearchUseContentBlock(item, options?.toolSearchName);
+			if (toolUseBlock) contentBlocks.push(toolUseBlock);
+			break;
+		}
+		case "tool_search_output": break;
 		case "message": {
 			const combinedText = combineMessageTextContent(item.content);
 			if (combinedText.length > 0) contentBlocks.push({
@@ -3297,15 +3460,29 @@ const extractReasoningText = (item) => {
 };
 const createToolUseContentBlock = (call) => {
 	const toolId = call.call_id;
-	if (!call.name || !toolId) return null;
-	const input = parseFunctionCallArguments(call.arguments);
+	const toolName = resolveToolUseName(call);
+	if (!toolName || !toolId) return null;
+	return {
+		type: "tool_use",
+		id: toolId,
+		name: toolName,
+		input: parseFunctionCallArguments(call.arguments)
+	};
+};
+const createToolSearchUseContentBlock = (call, toolSearchName = BRIDGE_TOOL_SEARCH_NAME) => {
+	const toolId = call.call_id;
+	if (!toolId) return null;
 	return {
 		type: "tool_use",
 		id: toolId,
-		name: call.name,
-		input
+		name: toolSearchName,
+		input: parseToolSearchArguments(call.arguments)
 	};
 };
+const resolveToolUseName = (call) => {
+	if (typeof call.namespace === "string" && call.namespace.length > 0) return call.namespace;
+	return call.name;
+};
 const createCompactionThinkingBlock = (item) => {
 	if (!item.id || !item.encrypted_content) return null;
 	return {
@@ -3331,6 +3508,9 @@ const parseFunctionCallArguments = (rawArguments) => {
 	}
 	return { raw_arguments: rawArguments };
 };
+const parseToolSearchArguments = (argumentsValue) => {
+	return formatToolSearchBridgeArguments(argumentsValue);
+};
 const fallbackContentBlocks = (outputText) => {
 	if (!outputText) return [];
 	return [{
@@ -3341,7 +3521,7 @@ const fallbackContentBlocks = (outputText) => {
 const mapResponsesStopReason = (response) => {
 	const { status, incomplete_details: incompleteDetails } = response;
 	if (status === "completed") {
-		if (response.output.some((item) => item.type === "function_call")) return "tool_use";
+		if (response.output.some((item) => item.type === "function_call" || item.type === "tool_search_call")) return "tool_use";
 		return "end_turn";
 	}
 	if (status === "incomplete") {
@@ -3412,14 +3592,15 @@ const updateWhitespaceRunState = (previousCount, chunk) => {
 		exceeded: false
 	};
 };
-const createResponsesStreamState = () => ({
+const createResponsesStreamState = (options) => ({
 	messageStartSent: false,
 	messageCompleted: false,
 	nextContentBlockIndex: 0,
 	blockIndexByKey: /* @__PURE__ */ new Map(),
 	openBlocks: /* @__PURE__ */ new Set(),
 	blockHasDelta: /* @__PURE__ */ new Set(),
-	functionCallStateByOutputIndex: /* @__PURE__ */ new Map()
+	functionCallStateByOutputIndex: /* @__PURE__ */ new Map(),
+	toolSearchName: options?.toolSearchName ?? "mcp__tool_search__search"
 });
 const translateResponsesStreamEvent = (rawEvent, state) => {
 	switch (rawEvent.type) {
@@ -3444,7 +3625,7 @@ const handleResponseCreated = (rawEvent, state) => {
 };
 const handleOutputItemAdded$1 = (rawEvent, state) => {
 	const events = new Array();
-	const functionCallDetails = extractFunctionCallDetails(rawEvent);
+	const functionCallDetails = extractFunctionCallDetails(rawEvent, state);
 	if (!functionCallDetails) return events;
 	const { outputIndex, toolCallId, name, initialArguments } = functionCallDetails;
 	const blockIndex = openFunctionCallBlock(state, {
@@ -3471,6 +3652,28 @@ const handleOutputItemDone$1 = (rawEvent, state) => {
 	const item = rawEvent.item;
 	const itemType = item.type;
 	const outputIndex = rawEvent.output_index;
+	if (itemType === "tool_search_call") {
+		const blockIndex = openFunctionCallBlock(state, {
+			outputIndex,
+			toolCallId: item.call_id,
+			name: state.toolSearchName,
+			events
+		});
+		const finalArguments = stringifyToolSearchArguments(item.arguments);
+		if (!state.blockHasDelta.has(blockIndex) && finalArguments) {
+			events.push({
+				type: "content_block_delta",
+				index: blockIndex,
+				delta: {
+					type: "input_json_delta",
+					partial_json: finalArguments
+				}
+			});
+			state.blockHasDelta.add(blockIndex);
+		}
+		state.functionCallStateByOutputIndex.delete(outputIndex);
+		return events;
+	}
 	if (itemType === "compaction") {
 		if (!item.id || !item.encrypted_content) return events;
 		const blockIndex = openThinkingBlockIfNeeded(state, outputIndex, events);
@@ -3799,16 +4002,30 @@ const openFunctionCallBlock = (state, params) => {
 	}
 	return blockIndex;
 };
-const extractFunctionCallDetails = (rawEvent) => {
+const extractFunctionCallDetails = (rawEvent, state) => {
 	const item = rawEvent.item;
-	if (item.type !== "function_call") return;
+	const itemType = item.type;
+	if (itemType === "tool_search_call") return {
+		outputIndex: rawEvent.output_index,
+		toolCallId: item.call_id,
+		name: state.toolSearchName,
+		initialArguments: ""
+	};
+	if (itemType !== "function_call") return;
 	return {
 		outputIndex: rawEvent.output_index,
 		toolCallId: item.call_id,
-		name: item.name,
+		name: resolveToolUseName(item),
 		initialArguments: item.arguments
 	};
 };
+const stringifyToolSearchArguments = (argumentsValue) => {
+	try {
+		return JSON.stringify(formatToolSearchBridgeArguments(argumentsValue));
+	} catch {
+		return;
+	}
+};
 //#endregion
 //#region src/services/copilot/create-messages.ts
 const INTERLEAVED_THINKING_BETA = "interleaved-thinking-2025-05-14";
@@ -4192,7 +4409,7 @@ const handleWithResponsesApi = async (c, anthropicPayload, options) => {
 	if (responsesPayload.stream && isAsyncIterable$1(response)) {
 		logger.debug("Streaming response from Copilot (Responses API)");
 		return streamSSE(c, async (stream) => {
-			const streamState = createResponsesStreamState();
+			const streamState = createResponsesStreamState({ toolSearchName: resolveBridgeToolSearchName(anthropicPayload.tools) });
 			let usage = {};
 			for await (const chunk of response) {
 				if (chunk.event === "ping") {
@@ -4236,7 +4453,7 @@ const handleWithResponsesApi = async (c, anthropicPayload, options) => {
 		value: response,
 		tailLength: 400
 	});
-	const anthropicResponse = translateResponsesResultToAnthropic(response);
+	const anthropicResponse = translateResponsesResultToAnthropic(response, { toolSearchName: resolveBridgeToolSearchName(anthropicPayload.tools) });
 	recordUsage(normalizeResponsesUsage(response.usage));
 	debugJson(logger, "Translated Anthropic response:", anthropicResponse);
 	return c.json(anthropicResponse);
@@ -4802,4 +5019,4 @@ server.route("/:provider/v1/models", providerModelRoutes);
 //#endregion
 export { server };
 
-//# sourceMappingURL=server-UsHsMP_2.js.map
+//# sourceMappingURL=server-DsfYz_GE.js.map