@jeffreycao/copilot-api 1.9.4 → 1.9.6

package/dist/{server-D1nq9oGf.js → server-BiAUjFEP.js}

@@ -1,6 +1,6 @@
 import { PATHS } from "./paths-Cla6y5eD.js";
 import { COMPACT_AUTO_CONTINUE, COMPACT_REQUEST, HTTPError, cacheModels, compactAutoContinuePromptStarts, compactMessageSections, compactSummaryPromptStart, compactSystemPromptStarts, compactTextOnlyGuard, copilotBaseUrl, copilotHeaders, forwardError, generateRequestIdFromPayload, generateTraceId, getCopilotUsage, getRootSessionId, getUUID, isNullish, parseUserIdMetadata, prepareForCompact, prepareInteractionHeaders, prepareMessageProxyHeaders, requestContext, resolveTraceId as resolveTraceId$1, sleep, state } from "./utils-DEJvF68W.js";
-import { getAnthropicApiKey, getClaudeTokenMultiplier, getConfig, getExtraPromptForModel, getProviderConfig, getReasoningEffortForModel, getSmallModel, isMessagesApiEnabled, isResponsesApiContextManagementModel, isResponsesApiWebSearchEnabled } from "./config-BQvWqYh_.js";
+import { getAnthropicApiKey, getClaudeTokenMultiplier, getConfig, getExtraPromptForModel, getProviderConfig, getReasoningEffortForModel, getSmallModel, isMessagesApiEnabled, isResponsesApiContextManagementModel, isResponsesApiWebSearchEnabled } from "./config-BJt9unC0.js";
 import consola from "consola";
 import fs from "node:fs/promises";
 import path from "node:path";
@@ -1052,7 +1052,10 @@ const calculateToolCallsTokens = (toolCalls, encoder, constants) => {
 const calculateContentPartsTokens = (contentParts, encoder) => {
 	let tokens = 0;
 	for (const part of contentParts) if (part.type === "image_url") tokens += encoder.encode(part.image_url.url).length + 85;
-	else if (part.text) tokens += encoder.encode(part.text).length;
+	else if (part.type === "file") {
+		tokens += encoder.encode(part.file.file_data).length;
+		if (part.file.filename) tokens += encoder.encode(part.file.filename).length;
+	} else if (part.text) tokens += encoder.encode(part.text).length;
 	return tokens;
 };
 /**
@@ -1304,13 +1307,19 @@ function mapOpenAIStopReasonToAnthropic(finishReason) {
 //#endregion
 //#region src/routes/messages/non-stream-translation.ts
 const THINKING_TEXT = "Thinking...";
-function translateToOpenAI(payload) {
+const RICH_TOOL_RESULT_MOVED_TEXT = "Rich tool result content was moved to a user message because this upstream does not support it in tool messages.";
+const COPILOT_TOOL_CONTENT_SUPPORT_TYPE = ["array", "image"];
+function translateToOpenAI(payload, options = {}) {
 	const modelId = payload.model;
 	const model = state.models?.data.find((m) => m.id === modelId);
 	const thinkingBudget = getThinkingBudget(payload, model);
+	const capabilities = {
+		supportPdf: options.supportPdf ?? false,
+		toolContentSupportType: options.toolContentSupportType ?? COPILOT_TOOL_CONTENT_SUPPORT_TYPE
+	};
 	return {
 		model: modelId,
-		messages: translateAnthropicMessagesToOpenAI(payload, modelId, thinkingBudget),
+		messages: translateAnthropicMessagesToOpenAI(payload, modelId, capabilities),
 		max_tokens: payload.max_tokens,
 		stop: payload.stop_sequences,
 		stream: payload.stream,
@@ -1333,9 +1342,9 @@ function getThinkingBudget(payload, model) {
 		}
 	}
 }
-function translateAnthropicMessagesToOpenAI(payload, modelId, _thinkingBudget) {
+function translateAnthropicMessagesToOpenAI(payload, modelId, capabilities) {
 	const systemMessages = handleSystemPrompt(payload.system);
-	const otherMessages = payload.messages.flatMap((message) => message.role === "user" ? handleUserMessage(message) : handleAssistantMessage(message, modelId));
+	const otherMessages = payload.messages.flatMap((message) => message.role === "user" ? handleUserMessage(message, capabilities) : handleAssistantMessage(message, modelId, capabilities));
 	return [...systemMessages, ...otherMessages];
 }
 function handleSystemPrompt(system) {
@@ -1351,19 +1360,21 @@ function handleSystemPrompt(system) {
 		}).join("\n\n")
 	}];
 }
-function handleUserMessage(message) {
+function handleUserMessage(message, capabilities) {
 	const newMessages = [];
 	if (Array.isArray(message.content)) {
 		const toolResultBlocks = message.content.filter((block) => block.type === "tool_result");
 		const otherBlocks = message.content.filter((block) => block.type !== "tool_result");
-		for (const block of toolResultBlocks) newMessages.push({
-			role: "tool",
-			tool_call_id: block.tool_use_id,
-			content: mapContent(block.content)
-		});
+		const movedToolResultUserMessages = [];
+		for (const block of toolResultBlocks) {
+			const result = handleToolResultBlock(block, capabilities);
+			newMessages.push(result.toolMessage);
+			if (result.movedUserMessage) movedToolResultUserMessages.push(result.movedUserMessage);
+		}
+		newMessages.push(...movedToolResultUserMessages);
 		if (otherBlocks.length > 0) newMessages.push({
 			role: "user",
-			content: mapContent(otherBlocks)
+			content: mapContent(otherBlocks, { supportPdf: capabilities.supportPdf })
 		});
 	} else newMessages.push({
 		role: "user",
@@ -1371,7 +1382,61 @@ function handleUserMessage(message) {
 	});
 	return newMessages;
 }
-function handleAssistantMessage(message, modelId) {
+function handleToolResultBlock(block, capabilities) {
+	if (typeof block.content === "string") return { toolMessage: createToolMessage(block.tool_use_id, block.content) };
+	if (!Array.isArray(block.content)) return { toolMessage: createToolMessage(block.tool_use_id, "") };
+	const support = getToolContentSupport(capabilities);
+	const hasImage = block.content.some((block$1) => block$1.type === "image");
+	const hasDocument = block.content.some((block$1) => block$1.type === "document");
+	const content = mapContent(block.content, { supportPdf: capabilities.supportPdf });
+	const hasPdfFile = hasDocument && capabilities.supportPdf;
+	const shouldMoveImageToUserMessage = hasImage && !support.image;
+	const shouldMovePdfToUserMessage = hasPdfFile && !support.pdf;
+	if (shouldMoveImageToUserMessage || shouldMovePdfToUserMessage) return {
+		movedUserMessage: createToolResultUserMessage(block, capabilities.supportPdf),
+		toolMessage: createToolMessage(block.tool_use_id, getTextToolContent(content) || RICH_TOOL_RESULT_MOVED_TEXT)
+	};
+	const hasRichContent = hasImage || hasPdfFile;
+	if (support.array || hasRichContent) return { toolMessage: createToolMessage(block.tool_use_id, content) };
+	return { toolMessage: createToolMessage(block.tool_use_id, getTextToolContent(content)) };
+}
+function getTextToolContent(content) {
+	if (!Array.isArray(content)) return content ?? "";
+	return content.flatMap((part) => part.type === "text" && part.text.length > 0 ? [part.text] : []).join("\n");
+}
+function getToolContentSupport(capabilities) {
+	return {
+		array: capabilities.toolContentSupportType.includes("array"),
+		image: capabilities.toolContentSupportType.includes("image"),
+		pdf: capabilities.supportPdf && capabilities.toolContentSupportType.includes("pdf")
+	};
+}
+function createToolMessage(toolCallId, content) {
+	return {
+		role: "tool",
+		tool_call_id: toolCallId,
+		content
+	};
+}
+function createToolResultUserMessage(block, supportPdf) {
+	const prefix = {
+		type: "text",
+		text: `Tool result for ${block.tool_use_id}:`
+	};
+	const content = mapContent(block.content, { supportPdf });
+	if (Array.isArray(content)) return {
+		role: "user",
+		content: [prefix, ...content]
+	};
+	return {
+		role: "user",
+		content: [prefix, {
+			type: "text",
+			text: content ?? ""
+		}]
+	};
+}
+function handleAssistantMessage(message, modelId, capabilities) {
 	if (!Array.isArray(message.content)) return [{
 		role: "assistant",
 		content: mapContent(message.content)
@@ -1384,7 +1449,7 @@ function handleAssistantMessage(message, modelId) {
 	const signature = thinkingBlocks.find((b) => b.signature)?.signature;
 	return toolUseBlocks.length > 0 ? [{
 		role: "assistant",
-		content: mapContent(message.content),
+		content: mapContent(message.content, { supportPdf: capabilities.supportPdf }),
 		reasoning_text: allThinkingContent,
 		reasoning_opaque: signature,
 		tool_calls: toolUseBlocks.map((toolUse) => ({
@@ -1397,12 +1462,12 @@ function handleAssistantMessage(message, modelId) {
 		}))
 	}] : [{
 		role: "assistant",
-		content: mapContent(message.content),
+		content: mapContent(message.content, { supportPdf: capabilities.supportPdf }),
 		reasoning_text: allThinkingContent,
 		reasoning_opaque: signature
 	}];
 }
-function mapContent(content) {
+function mapContent(content, options = {}) {
 	if (typeof content === "string") return content;
 	if (!Array.isArray(content)) return null;
 	const contentParts = [];
@@ -1420,7 +1485,7 @@ function mapContent(content) {
 			});
 			break;
 		case "document":
-			contentParts.push(createDocumentTextPart());
+			contentParts.push(options.supportPdf ? createDocumentFilePart(block) : createDocumentTextPart());
 			break;
 		case "tool_reference":
 			contentParts.push({
@@ -1434,7 +1499,16 @@ function mapContent(content) {
 function createDocumentTextPart() {
 	return {
 		type: "text",
-		text: "A PDF document was attached, but this api cannot send PDF inputs directly. Analyze using other tools."
+		text: "PDF/document content is not supported by this Chat Completions upstream. Use the available text extracted from the document."
+	};
+}
+function createDocumentFilePart(block) {
+	return {
+		type: "file",
+		file: {
+			file_data: `data:${block.source.media_type};base64,${block.source.data}`,
+			filename: block.title ?? "document.pdf"
+		}
 	};
 }
 function translateAnthropicToolsToOpenAI(anthropicTools) {
@@ -1479,7 +1553,7 @@ function translateToAnthropic(response) {
 	let stopReason = response.choices[0]?.finish_reason ?? null;
 	for (const choice of response.choices) {
 		const textBlocks = getAnthropicTextBlocks(choice.message.content);
-		const thinkBlocks = getAnthropicThinkBlocks(choice.message.reasoning_text, choice.message.reasoning_opaque);
+		const thinkBlocks = getAnthropicThinkBlocks(getOpenAIReasoningText(choice.message), choice.message.reasoning_opaque);
 		const toolUseBlocks = getAnthropicToolUseBlocks(choice.message.tool_calls);
 		assistantContentBlocks.push(...thinkBlocks, ...textBlocks, ...toolUseBlocks);
 		if (choice.finish_reason === "tool_calls" || stopReason === "stop") stopReason = choice.finish_reason;
@@ -1499,6 +1573,9 @@ function translateToAnthropic(response) {
 		}
 	};
 }
+function getOpenAIReasoningText(message) {
+	return message.reasoning_text ?? message.reasoning_content;
+}
 function getAnthropicTextBlocks(messageContent) {
 	if (typeof messageContent === "string" && messageContent.length > 0) return [{
 		type: "text",
@@ -2860,7 +2937,10 @@ function isToolBlockOpen(state$1) {
 }
 function translateChunkToAnthropicEvents(chunk, state$1) {
 	const events$1 = [];
-	if (chunk.choices.length === 0) return events$1;
+	if (chunk.choices.length === 0) {
+		completePendingMessage(state$1, events$1, chunk);
+		return events$1;
+	}
 	const choice = chunk.choices[0];
 	const { delta } = choice;
 	handleMessageStart(state$1, events$1, chunk);
@@ -2873,6 +2953,17 @@ function translateChunkToAnthropicEvents(chunk, state$1) {
 	});
 	return events$1;
 }
+function flushPendingAnthropicStreamEvents(state$1) {
+	const events$1 = [];
+	completePendingMessage(state$1, events$1);
+	return events$1;
+}
+function completePendingMessage(state$1, events$1, chunk) {
+	if (!state$1.pendingMessageDelta) return;
+	if (chunk?.usage) state$1.pendingMessageDelta.usage = getAnthropicUsageFromOpenAIChunk(chunk);
+	events$1.push(state$1.pendingMessageDelta, { type: "message_stop" });
+	state$1.pendingMessageDelta = void 0;
+}
 function handleFinish(choice, state$1, context) {
 	const { events: events$1, chunk } = context;
 	if (choice.finish_reason && choice.finish_reason.length > 0) {
@@ -2886,20 +2977,24 @@ function handleFinish(choice, state$1, context) {
 			state$1.contentBlockIndex++;
 			if (!toolBlockOpen) handleReasoningOpaque(choice.delta, events$1, state$1);
 		}
-		events$1.push({
+		state$1.pendingMessageDelta = {
 			type: "message_delta",
 			delta: {
 				stop_reason: mapOpenAIStopReasonToAnthropic(choice.finish_reason),
 				stop_sequence: null
 			},
-			usage: {
-				input_tokens: (chunk.usage?.prompt_tokens ?? 0) - (chunk.usage?.prompt_tokens_details?.cached_tokens ?? 0),
-				output_tokens: chunk.usage?.completion_tokens ?? 0,
-				...chunk.usage?.prompt_tokens_details?.cached_tokens !== void 0 && { cache_read_input_tokens: chunk.usage.prompt_tokens_details.cached_tokens }
-			}
-		}, { type: "message_stop" });
+			usage: getAnthropicUsageFromOpenAIChunk(chunk)
+		};
+		if (chunk.usage) completePendingMessage(state$1, events$1, chunk);
 	}
 }
+function getAnthropicUsageFromOpenAIChunk(chunk) {
+	return {
+		input_tokens: (chunk.usage?.prompt_tokens ?? 0) - (chunk.usage?.prompt_tokens_details?.cached_tokens ?? 0),
+		output_tokens: chunk.usage?.completion_tokens ?? 0,
+		...chunk.usage?.prompt_tokens_details?.cached_tokens !== void 0 && { cache_read_input_tokens: chunk.usage.prompt_tokens_details.cached_tokens }
+	};
+}
 function handleToolCalls(delta, state$1, events$1) {
 	if (delta.tool_calls && delta.tool_calls.length > 0) {
 		closeThinkingBlockIfOpen(state$1, events$1);
@@ -3057,10 +3152,12 @@ function handleReasoningOpaque(delta, events$1, state$1) {
 	}
 }
 function handleThinkingText(delta, state$1, events$1) {
-	if (delta.reasoning_text && delta.reasoning_text.length > 0) {
+	const reasoningText = delta.reasoning_text ?? delta.reasoning_content;
+	if (reasoningText && reasoningText.length > 0) {
 		if (state$1.contentBlockOpen) {
-			delta.content = delta.reasoning_text;
+			delta.content = reasoningText;
 			delta.reasoning_text = void 0;
+			delta.reasoning_content = void 0;
 			return;
 		}
 		if (!state$1.thinkingBlockOpen) {
@@ -3079,7 +3176,7 @@ function handleThinkingText(delta, state$1, events$1) {
 			index: state$1.contentBlockIndex,
 			delta: {
 				type: "thinking_delta",
-				thinking: delta.reasoning_text
+				thinking: reasoningText
 			}
 		});
 	}
@@ -3153,6 +3250,14 @@ const handleWithChatCompletions = async (c, anthropicPayload, options) => {
 				});
 			}
 		}
+		for (const event of flushPendingAnthropicStreamEvents(streamState)) {
+			const eventData = JSON.stringify(event);
+			debugLazy(logger$7, () => ["Translated Anthropic event:", eventData]);
+			await stream.writeSSE({
+				event: event.type,
+				data: eventData
+			});
+		}
 		recordUsage(usage);
 	});
 };
@@ -3419,16 +3524,19 @@ const modelRoutes = new Hono();
 modelRoutes.get("/", async (c) => {
 	try {
 		if (!state.models) await cacheModels();
-		const models = state.models?.data.map((model) => ({
-			...model,
-			id: model.id,
-			object: "model",
-			type: "model",
-			created: 0,
-			created_at: (/* @__PURE__ */ new Date(0)).toISOString(),
-			owned_by: model.vendor,
-			display_name: model.name
-		}));
+		const models = state.models?.data.map((model) => {
+			const is1m = model.capabilities.limits?.max_context_window_tokens === 1e6;
+			return {
+				...model,
+				id: is1m ? `${model.id}[1m]` : model.id,
+				object: "model",
+				type: "model",
+				created: 0,
+				created_at: (/* @__PURE__ */ new Date(0)).toISOString(),
+				owned_by: model.vendor,
+				display_name: model.name
+			};
+		});
 		return c.json({
 			object: "list",
 			data: models,
@@ -3463,8 +3571,14 @@ async function handleProviderCountTokens(c) {
 	const provider = c.req.param("provider");
 	try {
 		const anthropicPayload = await c.req.json();
-		const openAIPayload = translateToOpenAI(anthropicPayload);
 		const modelId = anthropicPayload.model.trim();
+		const providerConfig = getProviderConfig(provider);
+		const modelConfig = providerConfig?.models?.[modelId];
+		const translationOptions = providerConfig?.type === "openai-compatible" ? {
+			supportPdf: modelConfig?.supportPdf,
+			toolContentSupportType: modelConfig?.toolContentSupportType ?? []
+		} : void 0;
+		const openAIPayload = translateToOpenAI(anthropicPayload, translationOptions);
 		let selectedModel = state.models?.data.find((model) => model.id === modelId);
 		if (!selectedModel && modelId) selectedModel = createFallbackModel(modelId);
 		if (!selectedModel) {
@@ -3493,12 +3607,8 @@ async function handleProviderCountTokens(c) {
 
 //#endregion
 //#region src/services/providers/anthropic-proxy.ts
-const FORWARDABLE_HEADERS = [
-	"anthropic-version",
-	"anthropic-beta",
-	"accept",
-	"user-agent"
-];
+const SHARED_FORWARDABLE_HEADERS = ["accept", "user-agent"];
+const ANTHROPIC_FORWARDABLE_HEADERS = ["anthropic-version", "anthropic-beta"];
 const STRIPPED_RESPONSE_HEADERS = [
 	"connection",
 	"content-encoding",
@@ -3520,7 +3630,12 @@ function buildProviderUpstreamHeaders(providerConfig, requestHeaders) {
 		accept: "application/json",
 		...authHeaders
 	};
-	for (const headerName of FORWARDABLE_HEADERS) {
+	for (const headerName of SHARED_FORWARDABLE_HEADERS) {
+		const headerValue = requestHeaders.get(headerName);
+		if (headerValue) headers[headerName] = headerValue;
+	}
+	if (providerConfig.type !== "anthropic") return headers;
+	for (const headerName of ANTHROPIC_FORWARDABLE_HEADERS) {
 		const headerValue = requestHeaders.get(headerName);
 		if (headerValue) headers[headerName] = headerValue;
 	}
@@ -3542,6 +3657,13 @@ async function forwardProviderMessages(providerConfig, payload, requestHeaders)
 		body: JSON.stringify(payload)
 	});
 }
+async function forwardProviderChatCompletions(providerConfig, payload, requestHeaders) {
+	return await fetch(`${providerConfig.baseUrl}/v1/chat/completions`, {
+		method: "POST",
+		headers: buildProviderUpstreamHeaders(providerConfig, requestHeaders),
+		body: JSON.stringify(payload)
+	});
+}
 async function forwardProviderModels(providerConfig, requestHeaders) {
 	return await fetch(`${providerConfig.baseUrl}/v1/models`, {
 		method: "GET",
@@ -3562,13 +3684,18 @@ async function handleProviderMessages(c) {
 	try {
 		const payload = await c.req.json();
 		const modelConfig = providerConfig.models?.[payload.model];
-		payload.temperature ??= modelConfig?.temperature;
-		payload.top_p ??= modelConfig?.topP;
-		payload.top_k ??= modelConfig?.topK;
+		applyModelDefaults(payload, modelConfig);
 		debugJson(logger$3, "provider.messages.request", {
 			payload,
 			provider
 		});
+		if (providerConfig.type === "openai-compatible") return await handleOpenAICompatibleProviderMessages(c, {
+			modelConfig,
+			payload,
+			provider,
+			providerConfig
+		});
+		applyMissingExtraBody(payload, { extraBody: modelConfig?.extraBody });
 		const upstreamResponse = await forwardProviderMessages(providerConfig, payload, c.req.raw.headers);
 		if (!upstreamResponse.ok) {
 			logger$3.error("Failed to create responses", upstreamResponse);
@@ -3597,6 +3724,68 @@ async function handleProviderMessages(c) {
 		throw error;
 	}
 }
+const applyModelDefaults = (payload, modelConfig) => {
+	payload.temperature ??= modelConfig?.temperature;
+	payload.top_p ??= modelConfig?.topP;
+	payload.top_k ??= modelConfig?.topK;
+};
+const applyMissingExtraBody = (payload, options) => {
+	for (const [key, value] of Object.entries(options.extraBody ?? {})) if (!Object.hasOwn(payload, key)) payload[key] = value;
+};
+const handleOpenAICompatibleProviderMessages = async (c, options) => {
+	const { modelConfig, payload, provider, providerConfig } = options;
+	const openAIPayload = createOpenAICompatiblePayload(payload, modelConfig);
+	debugJson(logger$3, "provider.messages.openai_compatible.request", {
+		payload: openAIPayload,
+		provider
+	});
+	const upstreamResponse = await forwardProviderChatCompletions(providerConfig, openAIPayload, c.req.raw.headers);
+	if (!upstreamResponse.ok) {
+		logger$3.error("Failed to create openai-compatible responses", upstreamResponse);
+		throw new HTTPError("Failed to create openai-compatible responses", upstreamResponse);
+	}
+	const contentType = upstreamResponse.headers.get("content-type") ?? "";
+	if (Boolean(openAIPayload.stream) && contentType.includes("text/event-stream")) return streamOpenAICompatibleProviderMessages({
+		c,
+		payload,
+		provider,
+		upstreamResponse
+	});
+	const jsonBody = await upstreamResponse.json();
+	return respondOpenAICompatibleProviderMessagesJson(c, {
+		body: jsonBody,
+		payload,
+		provider
+	});
+};
+const createOpenAICompatiblePayload = (payload, modelConfig) => {
+	const openAIPayload = translateToOpenAI(payload, {
+		supportPdf: modelConfig?.supportPdf,
+		toolContentSupportType: modelConfig?.toolContentSupportType ?? []
+	});
+	if (payload.top_k !== void 0) openAIPayload.top_k = payload.top_k;
+	if (openAIPayload.stream) openAIPayload.stream_options = { include_usage: true };
+	normalizeOpenAICompatibleReasoningContent(openAIPayload);
+	applyOpenAICompatibleRequestOverrides(openAIPayload, {
+		extraBody: modelConfig?.extraBody,
+		source: payload
+	});
+	applyMissingExtraBody(openAIPayload, { extraBody: modelConfig?.extraBody });
+	if (!Object.hasOwn(openAIPayload, "parallel_tool_calls")) openAIPayload.parallel_tool_calls = true;
+	return openAIPayload;
+};
+const normalizeOpenAICompatibleReasoningContent = (payload) => {
+	for (const message of payload.messages) {
+		if (message.role !== "assistant") continue;
+		if (message.reasoning_content === void 0 && message.reasoning_text !== void 0) message.reasoning_content = message.reasoning_text;
+		delete message.reasoning_text;
+		delete message.reasoning_opaque;
+	}
+};
+const applyOpenAICompatibleRequestOverrides = (payload, options) => {
+	const allowedKeys = new Set(Object.keys(options.extraBody ?? {}));
+	for (const key of allowedKeys) if (Object.hasOwn(options.source, key)) payload[key] = options.source[key];
+};
 const streamProviderMessages = ({ c, payload, provider, providerConfig, upstreamResponse }) => {
 	logger$3.debug("provider.messages.streaming");
 	const recordUsage = createProviderMessagesUsageRecorder(payload, provider);
@@ -3628,6 +3817,66 @@ const streamProviderMessages = ({ c, payload, provider, providerConfig, upstream
 		recordUsage(usage);
 	});
 };
+const streamOpenAICompatibleProviderMessages = ({ c, payload, provider, upstreamResponse }) => {
+	logger$3.debug("provider.messages.openai_compatible.streaming");
+	const recordUsage = createProviderMessagesUsageRecorder(payload, provider);
+	return streamSSE(c, async (stream) => {
+		let usage = {};
+		const streamState = {
+			messageStartSent: false,
+			contentBlockIndex: 0,
+			contentBlockOpen: false,
+			toolCalls: {},
+			thinkingBlockOpen: false
+		};
+		for await (const chunk of events(upstreamResponse)) {
+			logger$3.debug("provider.messages.openai_compatible.raw_stream_event:", chunk.data);
+			if (chunk.event === "ping") {
+				await stream.writeSSE({
+					event: "ping",
+					data: "{\"type\":\"ping\"}"
+				});
+				continue;
+			}
+			if (!chunk.data || chunk.data === "[DONE]") {
+				if (chunk.data === "[DONE]") break;
+				continue;
+			}
+			const parsed = parseOpenAICompatibleStreamChunk(chunk.data);
+			if (!parsed) continue;
+			if (parsed.usage) usage = normalizeOpenAIUsage(parsed.usage);
+			const events$1 = translateChunkToAnthropicEvents(parsed, streamState);
+			for (const event of events$1) {
+				const eventData = JSON.stringify(event);
+				debugLazy(logger$3, () => ["provider.messages.openai_compatible.translated_event:", eventData]);
+				await stream.writeSSE({
+					event: event.type,
+					data: eventData
+				});
+			}
+		}
+		for (const event of flushPendingAnthropicStreamEvents(streamState)) {
+			const eventData = JSON.stringify(event);
+			debugLazy(logger$3, () => ["provider.messages.openai_compatible.translated_event:", eventData]);
+			await stream.writeSSE({
+				event: event.type,
+				data: eventData
+			});
+		}
+		recordUsage(usage);
+	});
+};
+const parseOpenAICompatibleStreamChunk = (data) => {
+	try {
+		return JSON.parse(data);
+	} catch (error) {
+		logger$3.error("provider.messages.openai_compatible.parse_chunk_error", {
+			data,
+			error
+		});
+		return null;
+	}
+};
 const parseProviderStreamEvent = (data, providerConfig) => {
 	try {
 		const parsed = JSON.parse(data);
@@ -3666,6 +3915,13 @@ const respondProviderMessagesJson = (c, options) => {
 	debugJson(logger$3, "provider.messages.no_stream result:", body);
 	return c.json(body);
 };
+const respondOpenAICompatibleProviderMessagesJson = (c, options) => {
+	const { body, payload, provider } = options;
+	createProviderMessagesUsageRecorder(payload, provider)(normalizeOpenAIUsage(body.usage));
+	const anthropicResponse = translateToAnthropic(body);
+	debugJson(logger$3, "provider.messages.openai_compatible.no_stream result:", anthropicResponse);
+	return c.json(anthropicResponse);
+};
 const createProviderMessagesUsageRecorder = (payload, provider) => createProviderTokenUsageRecorder({
 	endpoint: "provider_messages",
 	model: payload.model,
@@ -3985,4 +4241,4 @@ server.route("/:provider/v1/models", providerModelRoutes);
 
 //#endregion
 export { server };
-//# sourceMappingURL=server-D1nq9oGf.js.map
+//# sourceMappingURL=server-BiAUjFEP.js.map