copilot-api-plus 1.0.11 → 1.0.13

package/dist/main.js

@@ -681,6 +681,165 @@ const apiKeyAuthMiddleware = async (c, next) => {
 	await next();
 };
 
+//#endregion
+//#region src/services/antigravity/stream-parser.ts
+/**
+* Create initial stream state
+*/
+function createStreamState() {
+	return {
+		buffer: "",
+		inputTokens: 0,
+		outputTokens: 0,
+		contentBlockIndex: 0,
+		thinkingBlockStarted: false,
+		textBlockStarted: false
+	};
+}
+/**
+* Parse a single SSE line and return the JSON data if valid
+*/
+function parseSSELine(line) {
+	if (!line.startsWith("data: ")) return null;
+	const data = line.slice(6).trim();
+	if (data === "[DONE]" || data === "") return null;
+	try {
+		return JSON.parse(data);
+	} catch {
+		return null;
+	}
+}
+/**
+* Extract candidates and usage from parsed data
+*/
+function extractFromData(data) {
+	const candidates = data.response?.candidates || data.candidates || [];
+	const usage = data.response?.usageMetadata || data.usageMetadata;
+	return {
+		candidates,
+		usage
+	};
+}
+/**
+* Process a single part and emit events
+*/
+function processPart(part, state$1, emit) {
+	if (part.thought && part.text) {
+		processThinkingPart(part.text, state$1, emit);
+		return;
+	}
+	if (part.text && !part.thought) {
+		processTextPart(part.text, state$1, emit);
+		return;
+	}
+	if (part.functionCall) processToolPart(part.functionCall, state$1, emit);
+}
+/**
+* Process thinking content
+*/
+function processThinkingPart(text, state$1, emit) {
+	if (!state$1.thinkingBlockStarted) {
+		emit({
+			type: "thinking_start",
+			index: state$1.contentBlockIndex
+		});
+		state$1.thinkingBlockStarted = true;
+	}
+	emit({
+		type: "thinking_delta",
+		index: state$1.contentBlockIndex,
+		text
+	});
+}
+/**
+* Process text content
+*/
+function processTextPart(text, state$1, emit) {
+	if (state$1.thinkingBlockStarted && !state$1.textBlockStarted) {
+		emit({
+			type: "thinking_stop",
+			index: state$1.contentBlockIndex
+		});
+		state$1.contentBlockIndex++;
+		state$1.thinkingBlockStarted = false;
+	}
+	if (!state$1.textBlockStarted) {
+		emit({
+			type: "text_start",
+			index: state$1.contentBlockIndex
+		});
+		state$1.textBlockStarted = true;
+	}
+	emit({
+		type: "text_delta",
+		index: state$1.contentBlockIndex,
+		text
+	});
+}
+/**
+* Process tool/function call
+*/
+function processToolPart(functionCall, state$1, emit) {
+	if (state$1.textBlockStarted) {
+		emit({
+			type: "text_stop",
+			index: state$1.contentBlockIndex
+		});
+		state$1.contentBlockIndex++;
+		state$1.textBlockStarted = false;
+	} else if (state$1.thinkingBlockStarted) {
+		emit({
+			type: "thinking_stop",
+			index: state$1.contentBlockIndex
+		});
+		state$1.contentBlockIndex++;
+		state$1.thinkingBlockStarted = false;
+	}
+	emit({
+		type: "tool_use",
+		index: state$1.contentBlockIndex,
+		name: functionCall.name,
+		args: functionCall.args
+	});
+	state$1.contentBlockIndex++;
+}
+/**
+* Handle finish reason and close open blocks
+*/
+function handleFinish(state$1, emit) {
+	if (state$1.textBlockStarted) {
+		emit({
+			type: "text_stop",
+			index: state$1.contentBlockIndex
+		});
+		state$1.textBlockStarted = false;
+	} else if (state$1.thinkingBlockStarted) {
+		emit({
+			type: "thinking_stop",
+			index: state$1.contentBlockIndex
+		});
+		state$1.thinkingBlockStarted = false;
+	}
+	emit({
+		type: "usage",
+		inputTokens: state$1.inputTokens,
+		outputTokens: state$1.outputTokens
+	});
+	emit({
+		type: "finish",
+		stopReason: "end_turn"
+	});
+}
+/**
+* Process chunk and update buffer, returning complete lines
+*/
+function processChunk(chunk, state$1) {
+	state$1.buffer += chunk;
+	const lines = state$1.buffer.split("\n");
+	state$1.buffer = lines.pop() || "";
+	return lines;
+}
+
 //#endregion
 //#region src/services/antigravity/create-chat-completions.ts
 const ANTIGRAVITY_API_HOST$1 = "daily-cloudcode-pa.sandbox.googleapis.com";
@@ -692,38 +851,18 @@ const ANTIGRAVITY_USER_AGENT$1 = "antigravity/1.11.3 windows/amd64";
 */
 function convertMessages$1(messages) {
 	const contents = [];
-	let systemInstruction = void 0;
+	let systemInstruction;
 	for (const message of messages) {
 		if (message.role === "system") {
-			systemInstruction = {
-				role: "user",
-				parts: [{ text: typeof message.content === "string" ? message.content : message.content.map((c) => c.text || "").join("") }]
-			};
+			systemInstruction = buildSystemInstruction(message.content);
 			continue;
 		}
 		const role = message.role === "assistant" ? "model" : "user";
-		if (typeof message.content === "string") contents.push({
+		const parts = buildMessageParts(message.content);
+		contents.push({
 			role,
-			parts: [{ text: message.content }]
+			parts
 		});
-		else {
-			const parts = [];
-			for (const part of message.content) if (part.type === "text") parts.push({ text: part.text });
-			else if (part.type === "image_url" && part.image_url?.url) {
-				const url = part.image_url.url;
-				if (url.startsWith("data:")) {
-					const match = url.match(/^data:([^;]+);base64,(.+)$/);
-					if (match) parts.push({ inlineData: {
-						mimeType: match[1],
-						data: match[2]
-					} });
-				}
-			}
-			contents.push({
-				role,
-				parts
-			});
-		}
 	}
 	return {
 		contents,
@@ -731,10 +870,44 @@ function convertMessages$1(messages) {
 	};
 }
 /**
+* Build system instruction from content
+*/
+function buildSystemInstruction(content) {
+	return {
+		role: "user",
+		parts: [{ text: typeof content === "string" ? content : content.map((c) => c.text || "").join("") }]
+	};
+}
+/**
+* Build message parts from content
+*/
+function buildMessageParts(content) {
+	if (typeof content === "string") return [{ text: content }];
+	const parts = [];
+	for (const part of content) if (part.type === "text") parts.push({ text: part.text });
+	else if (part.type === "image_url" && part.image_url?.url) {
+		const imageData = parseBase64Image(part.image_url.url);
+		if (imageData) parts.push({ inlineData: imageData });
+	}
+	return parts;
+}
+/**
+* Parse base64 image URL
+*/
+function parseBase64Image(url) {
+	if (!url.startsWith("data:")) return null;
+	const match = url.match(/^data:([^;]+);base64,(.+)$/);
+	if (!match) return null;
+	return {
+		mimeType: match[1],
+		data: match[2]
+	};
+}
+/**
 * Convert tools to Antigravity format
 */
 function convertTools$1(tools) {
-	if (!tools || tools.length === 0) return;
+	if (!tools || tools.length === 0) return void 0;
 	return tools.map((tool) => {
 		const t = tool;
 		if (t.type === "function" && t.function) return { functionDeclarations: [{
@@ -746,20 +919,12 @@ function convertTools$1(tools) {
 	});
 }
 /**
-* Create chat completion with Antigravity
+* Build Antigravity request body
 */
-async function createAntigravityChatCompletion(request) {
-	const accessToken = await getValidAccessToken();
-	if (!accessToken) return new Response(JSON.stringify({ error: {
-		message: "No valid Antigravity access token available. Please run login first.",
-		type: "auth_error"
-	} }), {
-		status: 401,
-		headers: { "Content-Type": "application/json" }
-	});
+function buildRequestBody(request) {
 	const { contents, systemInstruction } = convertMessages$1(request.messages);
 	const tools = convertTools$1(request.tools);
-	const antigravityRequest = {
+	const body = {
 		model: request.model,
 		contents,
 		generationConfig: {
@@ -769,13 +934,36 @@ async function createAntigravityChatCompletion(request) {
 			maxOutputTokens: request.max_tokens ?? 8096
 		}
 	};
-	if (systemInstruction) antigravityRequest.systemInstruction = systemInstruction;
-	if (tools) antigravityRequest.tools = tools;
-	if (isThinkingModel(request.model)) antigravityRequest.generationConfig = {
-		...antigravityRequest.generationConfig,
+	if (systemInstruction) body.systemInstruction = systemInstruction;
+	if (tools) body.tools = tools;
+	if (isThinkingModel(request.model)) body.generationConfig = {
+		...body.generationConfig,
 		thinkingConfig: { includeThoughts: true }
 	};
+	return body;
+}
+/**
+* Create error response
+*/
+function createErrorResponse$1(message, type, status, details) {
+	const error = {
+		message,
+		type
+	};
+	if (details) error.details = details;
+	return new Response(JSON.stringify({ error }), {
+		status,
+		headers: { "Content-Type": "application/json" }
+	});
+}
+/**
+* Create chat completion with Antigravity
+*/
+async function createAntigravityChatCompletion(request) {
+	const accessToken = await getValidAccessToken();
+	if (!accessToken) return createErrorResponse$1("No valid Antigravity access token available. Please run login first.", "auth_error", 401);
 	const endpoint = request.stream ? ANTIGRAVITY_STREAM_URL$1 : ANTIGRAVITY_NO_STREAM_URL$1;
+	const body = buildRequestBody(request);
 	consola.debug(`Antigravity request to ${endpoint} with model ${request.model}`);
 	try {
 		const response = await fetch(endpoint, {
@@ -787,120 +975,46 @@ async function createAntigravityChatCompletion(request) {
 				"Content-Type": "application/json",
 				"Accept-Encoding": "gzip"
 			},
-			body: JSON.stringify(antigravityRequest)
+			body: JSON.stringify(body)
 		});
-		if (!response.ok) {
-			const errorText = await response.text();
-			consola.error(`Antigravity error: ${response.status} ${errorText}`);
-			if (response.status === 403) await disableCurrentAccount();
-			if (response.status === 429 || response.status === 503) await rotateAccount();
-			return new Response(JSON.stringify({ error: {
-				message: `Antigravity API error: ${response.status}`,
-				type: "api_error",
-				details: errorText
-			} }), {
-				status: response.status,
-				headers: { "Content-Type": "application/json" }
-			});
-		}
-		if (request.stream) return transformStreamResponse(response, request.model);
-		else return transformNonStreamResponse(response, request.model);
+		if (!response.ok) return await handleApiError$1(response);
+		return request.stream ? transformStreamResponse$1(response, request.model) : await transformNonStreamResponse$1(response, request.model);
 	} catch (error) {
 		consola.error("Antigravity request error:", error);
-		return new Response(JSON.stringify({ error: {
-			message: `Request failed: ${error}`,
-			type: "request_error"
-		} }), {
-			status: 500,
-			headers: { "Content-Type": "application/json" }
-		});
+		return createErrorResponse$1(`Request failed: ${String(error)}`, "request_error", 500);
 	}
 }
 /**
+* Handle API error response
+*/
+async function handleApiError$1(response) {
+	const errorText = await response.text();
+	consola.error(`Antigravity error: ${response.status} ${errorText}`);
+	if (response.status === 403) await disableCurrentAccount();
+	if (response.status === 429 || response.status === 503) await rotateAccount();
+	return createErrorResponse$1(`Antigravity API error: ${response.status}`, "api_error", response.status, errorText);
+}
+/**
+* Generate request ID
+*/
+function generateRequestId() {
+	return `chatcmpl-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
+}
+/**
 * Transform Antigravity stream response to OpenAI format
 */
-function transformStreamResponse(response, model) {
+function transformStreamResponse$1(response, model) {
 	const reader = response.body?.getReader();
 	if (!reader) return new Response("No response body", { status: 500 });
-	const encoder = new TextEncoder();
+	const encoder$1 = new TextEncoder();
 	const decoder = new TextDecoder();
+	const requestId = generateRequestId();
 	const stream = new ReadableStream({ async start(controller) {
-		let buffer = "";
-		const requestId = `chatcmpl-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
+		const state$1 = createStreamState();
 		try {
-			while (true) {
-				const { done, value } = await reader.read();
-				if (done) {
-					controller.enqueue(encoder.encode("data: [DONE]\n\n"));
-					controller.close();
-					break;
-				}
-				buffer += decoder.decode(value, { stream: true });
-				const lines = buffer.split("\n");
-				buffer = lines.pop() || "";
-				for (const line of lines) if (line.startsWith("data: ")) {
-					const data = line.slice(6).trim();
-					if (data === "[DONE]" || data === "") continue;
-					try {
-						const parsed = JSON.parse(data);
-						const candidate = (parsed.response?.candidates || parsed.candidates)?.[0];
-						const parts = candidate?.content?.parts || [];
-						for (const part of parts) {
-							if (part.thought && part.text) {
-								const chunk = {
-									id: requestId,
-									object: "chat.completion.chunk",
-									created: Math.floor(Date.now() / 1e3),
-									model,
-									choices: [{
-										index: 0,
-										delta: { reasoning_content: part.text },
-										finish_reason: null
-									}]
-								};
-								controller.enqueue(encoder.encode(`data: ${JSON.stringify(chunk)}\n\n`));
-								continue;
-							}
-							if (part.text) {
-								const chunk = {
-									id: requestId,
-									object: "chat.completion.chunk",
-									created: Math.floor(Date.now() / 1e3),
-									model,
-									choices: [{
-										index: 0,
-										delta: { content: part.text },
-										finish_reason: candidate?.finishReason === "STOP" ? "stop" : null
-									}]
-								};
-								controller.enqueue(encoder.encode(`data: ${JSON.stringify(chunk)}\n\n`));
-							}
-							if (part.functionCall) {
-								const chunk = {
-									id: requestId,
-									object: "chat.completion.chunk",
-									created: Math.floor(Date.now() / 1e3),
-									model,
-									choices: [{
-										index: 0,
-										delta: { tool_calls: [{
-											index: 0,
-											id: `call_${Date.now()}`,
-											type: "function",
-											function: {
-												name: part.functionCall.name,
-												arguments: JSON.stringify(part.functionCall.args)
-											}
-										}] },
-										finish_reason: null
-									}]
-								};
-								controller.enqueue(encoder.encode(`data: ${JSON.stringify(chunk)}\n\n`));
-							}
-						}
-					} catch {}
-				}
-			}
+			await processOpenAIStream(reader, decoder, state$1, controller, encoder$1, requestId, model);
+			controller.enqueue(encoder$1.encode("data: [DONE]\n\n"));
+			controller.close();
 		} catch (error) {
 			consola.error("Stream transform error:", error);
 			controller.error(error);
@@ -913,27 +1027,78 @@ function transformStreamResponse(response, model) {
 	} });
 }
 /**
-* Transform Antigravity non-stream response to OpenAI format
+* Process stream and emit OpenAI format chunks
 */
-async function transformNonStreamResponse(response, model) {
-	const data = await response.json();
-	const candidate = data.candidates?.[0];
-	const parts = candidate?.content?.parts || [];
-	let content = "";
-	let reasoningContent = "";
-	const toolCalls = [];
-	for (const part of parts) {
-		if (part.thought && part.text) reasoningContent += part.text;
-		else if (part.text) content += part.text;
-		if (part.functionCall) toolCalls.push({
-			id: `call_${Date.now()}`,
-			type: "function",
-			function: {
-				name: part.functionCall.name,
-				arguments: JSON.stringify(part.functionCall.args)
+async function processOpenAIStream(reader, decoder, state$1, controller, encoder$1, requestId, model) {
+	while (true) {
+		const { done, value } = await reader.read();
+		if (done) break;
+		const chunk = decoder.decode(value, { stream: true });
+		const lines = processChunk(chunk, state$1);
+		for (const line of lines) {
+			const data = parseSSELine(line);
+			if (!data) continue;
+			const { candidates } = extractFromData(data);
+			const candidate = candidates[0];
+			const parts = candidate?.content?.parts ?? [];
+			for (const part of parts) {
+				const chunkData = buildOpenAIChunk(part, requestId, model, candidate?.finishReason);
+				if (chunkData) controller.enqueue(encoder$1.encode(`data: ${JSON.stringify(chunkData)}\n\n`));
 			}
-		});
+		}
 	}
+}
+/**
+* Build OpenAI format chunk from part
+*/
+function buildOpenAIChunk(part, requestId, model, finishReason) {
+	const baseChunk = {
+		id: requestId,
+		object: "chat.completion.chunk",
+		created: Math.floor(Date.now() / 1e3),
+		model
+	};
+	if (part.thought && part.text) return {
+		...baseChunk,
+		choices: [{
+			index: 0,
+			delta: { reasoning_content: part.text },
+			finish_reason: null
+		}]
+	};
+	if (part.text && !part.thought) return {
+		...baseChunk,
+		choices: [{
+			index: 0,
+			delta: { content: part.text },
+			finish_reason: finishReason === "STOP" ? "stop" : null
+		}]
+	};
+	if (part.functionCall) return {
+		...baseChunk,
+		choices: [{
+			index: 0,
+			delta: { tool_calls: [{
+				index: 0,
+				id: `call_${Date.now()}`,
+				type: "function",
+				function: {
+					name: part.functionCall.name,
+					arguments: JSON.stringify(part.functionCall.args)
+				}
+			}] },
+			finish_reason: null
+		}]
+	};
+	return null;
+}
+/**
+* Transform Antigravity non-stream response to OpenAI format
+*/
+async function transformNonStreamResponse$1(response, model) {
+	const data = await response.json();
+	const parts = (data.candidates?.[0])?.content?.parts ?? [];
+	const { content, reasoningContent, toolCalls } = extractNonStreamContent(parts);
 	const message = {
 		role: "assistant",
 		content: content || null
@@ -941,23 +1106,48 @@ async function transformNonStreamResponse(response, model) {
 	if (reasoningContent) message.reasoning_content = reasoningContent;
 	if (toolCalls.length > 0) message.tool_calls = toolCalls;
 	const openaiResponse = {
-		id: `chatcmpl-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`,
+		id: generateRequestId(),
 		object: "chat.completion",
 		created: Math.floor(Date.now() / 1e3),
 		model,
 		choices: [{
 			index: 0,
 			message,
-			finish_reason: candidate?.finishReason === "STOP" ? "stop" : "stop"
+			finish_reason: "stop"
 		}],
 		usage: {
-			prompt_tokens: data.usageMetadata?.promptTokenCount || 0,
-			completion_tokens: data.usageMetadata?.candidatesTokenCount || 0,
-			total_tokens: data.usageMetadata?.totalTokenCount || 0
+			prompt_tokens: data.usageMetadata?.promptTokenCount ?? 0,
+			completion_tokens: data.usageMetadata?.candidatesTokenCount ?? 0,
+			total_tokens: data.usageMetadata?.totalTokenCount ?? 0
 		}
 	};
 	return new Response(JSON.stringify(openaiResponse), { headers: { "Content-Type": "application/json" } });
 }
+/**
+* Extract content from non-stream response parts
+*/
+function extractNonStreamContent(parts) {
+	let content = "";
+	let reasoningContent = "";
+	const toolCalls = [];
+	for (const part of parts) {
+		if (part.thought && part.text) reasoningContent += part.text;
+		else if (part.text) content += part.text;
+		if (part.functionCall) toolCalls.push({
+			id: `call_${Date.now()}`,
+			type: "function",
+			function: {
+				name: part.functionCall.name,
+				arguments: JSON.stringify(part.functionCall.args)
+			}
+		});
+	}
+	return {
+		content,
+		reasoningContent,
+		toolCalls
+	};
+}
 
 //#endregion
 //#region src/routes/antigravity/chat-completions/route.ts
@@ -977,6 +1167,166 @@ app$1.post("/", async (c) => {
 });
 const antigravityChatCompletionsRoute = app$1;
 
+//#endregion
+//#region src/services/antigravity/anthropic-events.ts
+/**
+* Anthropic SSE Event Builder
+*
+* Builds Anthropic-compatible SSE events for streaming responses.
+* Extracted for better code organization and reusability.
+*/
+const encoder = new TextEncoder();
+/**
+* Create message_start event
+*/
+function createMessageStart(messageId, model) {
+	const event = {
+		type: "message_start",
+		message: {
+			id: messageId,
+			type: "message",
+			role: "assistant",
+			content: [],
+			model,
+			stop_reason: null,
+			stop_sequence: null,
+			usage: {
+				input_tokens: 0,
+				output_tokens: 0
+			}
+		}
+	};
+	return encoder.encode(`event: message_start\ndata: ${JSON.stringify(event)}\n\n`);
+}
+/**
+* Create message_stop event
+*/
+function createMessageStop() {
+	return encoder.encode(`event: message_stop\ndata: ${JSON.stringify({ type: "message_stop" })}\n\n`);
+}
+/**
+* Create content_block_start event for thinking
+*/
+function createThinkingBlockStart(index) {
+	const event = {
+		type: "content_block_start",
+		index,
+		content_block: {
+			type: "thinking",
+			thinking: ""
+		}
+	};
+	return encoder.encode(`event: content_block_start\ndata: ${JSON.stringify(event)}\n\n`);
+}
+/**
+* Create content_block_delta event for thinking
+*/
+function createThinkingDelta(index, text) {
+	const event = {
+		type: "content_block_delta",
+		index,
+		delta: {
+			type: "thinking_delta",
+			thinking: text
+		}
+	};
+	return encoder.encode(`event: content_block_delta\ndata: ${JSON.stringify(event)}\n\n`);
+}
+/**
+* Create content_block_start event for text
+*/
+function createTextBlockStart(index) {
+	const event = {
+		type: "content_block_start",
+		index,
+		content_block: {
+			type: "text",
+			text: ""
+		}
+	};
+	return encoder.encode(`event: content_block_start\ndata: ${JSON.stringify(event)}\n\n`);
+}
+/**
+* Create content_block_delta event for text
+*/
+function createTextDelta(index, text) {
+	const event = {
+		type: "content_block_delta",
+		index,
+		delta: {
+			type: "text_delta",
+			text
+		}
+	};
+	return encoder.encode(`event: content_block_delta\ndata: ${JSON.stringify(event)}\n\n`);
+}
+/**
+* Create content_block_stop event
+*/
+function createBlockStop(index) {
+	const event = {
+		type: "content_block_stop",
+		index
+	};
+	return encoder.encode(`event: content_block_stop\ndata: ${JSON.stringify(event)}\n\n`);
+}
+/**
+* Create content_block_start event for tool_use
+*/
+function createToolBlockStart(index, toolId, name) {
+	const event = {
+		type: "content_block_start",
+		index,
+		content_block: {
+			type: "tool_use",
+			id: toolId,
+			name,
+			input: {}
+		}
+	};
+	return encoder.encode(`event: content_block_start\ndata: ${JSON.stringify(event)}\n\n`);
+}
+/**
+* Create content_block_delta event for tool input
+*/
+function createToolDelta(index, args) {
+	const event = {
+		type: "content_block_delta",
+		index,
+		delta: {
+			type: "input_json_delta",
+			partial_json: JSON.stringify(args)
+		}
+	};
+	return encoder.encode(`event: content_block_delta\ndata: ${JSON.stringify(event)}\n\n`);
+}
+/**
+* Create message_delta event with stop reason and usage
+*/
+function createMessageDelta(stopReason, outputTokens) {
+	const event = {
+		type: "message_delta",
+		delta: {
+			stop_reason: stopReason,
+			stop_sequence: null
+		},
+		usage: { output_tokens: outputTokens }
+	};
+	return encoder.encode(`event: message_delta\ndata: ${JSON.stringify(event)}\n\n`);
+}
+/**
+* Generate a unique message ID
+*/
+function generateMessageId() {
+	return `msg_${Date.now()}_${Math.random().toString(36).slice(2, 9)}`;
+}
+/**
+* Generate a unique tool ID
+*/
+function generateToolId() {
+	return `toolu_${Date.now()}`;
+}
+
 //#endregion
 //#region src/services/antigravity/create-messages.ts
 const ANTIGRAVITY_API_HOST = "daily-cloudcode-pa.sandbox.googleapis.com";
@@ -988,29 +1338,18 @@ const ANTIGRAVITY_USER_AGENT = "antigravity/1.11.3 windows/amd64";
 */
 function convertMessages(messages, system) {
 	const contents = [];
-	let systemInstruction = void 0;
+	let systemInstruction;
 	if (system) systemInstruction = {
 		role: "user",
 		parts: [{ text: system }]
 	};
 	for (const message of messages) {
 		const role = message.role === "assistant" ? "model" : "user";
-		if (typeof message.content === "string") contents.push({
+		const parts = buildParts(message.content);
+		if (parts.length > 0) contents.push({
 			role,
-			parts: [{ text: message.content }]
+			parts
 		});
-		else {
-			const parts = [];
-			for (const block of message.content) if (block.type === "text" && block.text) parts.push({ text: block.text });
-			else if (block.type === "image" && block.source) parts.push({ inlineData: {
-				mimeType: block.source.media_type,
-				data: block.source.data
-			} });
-			if (parts.length > 0) contents.push({
-				role,
-				parts
-			});
-		}
 	}
 	return {
 		contents,
@@ -1018,10 +1357,23 @@ function convertMessages(messages, system) {
 	};
 }
 /**
+* Build parts array from message content
+*/
+function buildParts(content) {
+	if (typeof content === "string") return [{ text: content }];
+	const parts = [];
+	for (const block of content) if (block.type === "text" && block.text) parts.push({ text: block.text });
+	else if (block.type === "image" && block.source) parts.push({ inlineData: {
+		mimeType: block.source.media_type,
+		data: block.source.data
+	} });
+	return parts;
+}
+/**
 * Convert tools to Antigravity format
 */
 function convertTools(tools) {
-	if (!tools || tools.length === 0) return;
+	if (!tools || tools.length === 0) return void 0;
 	return tools.map((tool) => {
 		const t = tool;
 		return { functionDeclarations: [{
@@ -1032,23 +1384,12 @@ function convertTools(tools) {
 	});
 }
 /**
-* Create Anthropic-compatible message response using Antigravity
+* Build Antigravity request body
 */
-async function createAntigravityMessages(request) {
-	const accessToken = await getValidAccessToken();
-	if (!accessToken) return new Response(JSON.stringify({
-		type: "error",
-		error: {
-			type: "authentication_error",
-			message: "No valid Antigravity access token available. Please run login first."
-		}
-	}), {
-		status: 401,
-		headers: { "Content-Type": "application/json" }
-	});
+function buildAntigravityRequest(request) {
 	const { contents, systemInstruction } = convertMessages(request.messages, request.system);
 	const tools = convertTools(request.tools);
-	const antigravityRequest = {
+	const body = {
 		model: request.model,
 		contents,
 		generationConfig: {
@@ -1058,13 +1399,37 @@ async function createAntigravityMessages(request) {
 			maxOutputTokens: request.max_tokens ?? 8096
 		}
 	};
-	if (systemInstruction) antigravityRequest.systemInstruction = systemInstruction;
-	if (tools) antigravityRequest.tools = tools;
-	if (isThinkingModel(request.model)) antigravityRequest.generationConfig = {
-		...antigravityRequest.generationConfig,
+	if (systemInstruction) body.systemInstruction = systemInstruction;
+	if (tools) body.tools = tools;
+	if (isThinkingModel(request.model)) body.generationConfig = {
+		...body.generationConfig,
 		thinkingConfig: { includeThoughts: true }
 	};
+	return body;
+}
+/**
+* Create error response
+*/
+function createErrorResponse(type, message, status) {
+	return new Response(JSON.stringify({
+		type: "error",
+		error: {
+			type,
+			message
+		}
+	}), {
+		status,
+		headers: { "Content-Type": "application/json" }
+	});
+}
+/**
+* Create Anthropic-compatible message response using Antigravity
+*/
+async function createAntigravityMessages(request) {
+	const accessToken = await getValidAccessToken();
+	if (!accessToken) return createErrorResponse("authentication_error", "No valid Antigravity access token available. Please run login first.", 401);
 	const endpoint = request.stream ? ANTIGRAVITY_STREAM_URL : ANTIGRAVITY_NO_STREAM_URL;
+	const body = buildAntigravityRequest(request);
 	consola.debug(`Antigravity messages request to ${endpoint} with model ${request.model}`);
 	try {
 		const response = await fetch(endpoint, {
@@ -1076,212 +1441,84 @@ async function createAntigravityMessages(request) {
 				"Content-Type": "application/json",
 				"Accept-Encoding": "gzip"
 			},
-			body: JSON.stringify(antigravityRequest)
+			body: JSON.stringify(body)
 		});
-		if (!response.ok) {
-			const errorText = await response.text();
-			consola.error(`Antigravity error: ${response.status} ${errorText}`);
-			if (response.status === 403) await disableCurrentAccount();
-			if (response.status === 429 || response.status === 503) await rotateAccount();
-			return new Response(JSON.stringify({
-				type: "error",
-				error: {
-					type: "api_error",
-					message: `Antigravity API error: ${response.status}`
-				}
-			}), {
-				status: response.status,
-				headers: { "Content-Type": "application/json" }
-			});
-		}
-		if (request.stream) return transformStreamToAnthropic(response, request.model);
-		else return transformNonStreamToAnthropic(response, request.model);
+		if (!response.ok) return await handleApiError(response);
+		return request.stream ? transformStreamResponse(response, request.model) : await transformNonStreamResponse(response, request.model);
 	} catch (error) {
 		consola.error("Antigravity messages request error:", error);
-		return new Response(JSON.stringify({
-			type: "error",
-			error: {
-				type: "api_error",
-				message: `Request failed: ${error}`
-			}
-		}), {
-			status: 500,
-			headers: { "Content-Type": "application/json" }
-		});
+		return createErrorResponse("api_error", `Request failed: ${String(error)}`, 500);
+	}
+}
+/**
+* Handle API error response
+*/
+async function handleApiError(response) {
+	const errorText = await response.text();
+	consola.error(`Antigravity error: ${response.status} ${errorText}`);
+	if (response.status === 403) await disableCurrentAccount();
+	if (response.status === 429 || response.status === 503) await rotateAccount();
+	return createErrorResponse("api_error", `Antigravity API error: ${response.status}`, response.status);
+}
+/**
+* Emit SSE event to controller based on stream event type
+*/
+function emitSSEEvent(event, controller, state$1) {
+	switch (event.type) {
+		case "thinking_start":
+			controller.enqueue(createThinkingBlockStart(event.index));
+			break;
+		case "thinking_delta":
+			controller.enqueue(createThinkingDelta(event.index, event.text));
+			break;
+		case "thinking_stop":
+			controller.enqueue(createBlockStop(event.index));
+			break;
+		case "text_start":
+			controller.enqueue(createTextBlockStart(event.index));
+			break;
+		case "text_delta":
+			controller.enqueue(createTextDelta(event.index, event.text));
+			break;
+		case "text_stop":
+			controller.enqueue(createBlockStop(event.index));
+			break;
+		case "tool_use":
+			emitToolUseEvents(event, controller);
+			break;
+		case "usage":
+			state$1.inputTokens = event.inputTokens;
+			state$1.outputTokens = event.outputTokens;
+			break;
+		case "finish":
+			controller.enqueue(createMessageDelta(event.stopReason, state$1.outputTokens));
+			break;
 	}
 }
 /**
+* Emit tool use events
+*/
+function emitToolUseEvents(event, controller) {
+	const toolId = generateToolId();
+	controller.enqueue(createToolBlockStart(event.index, toolId, event.name));
+	controller.enqueue(createToolDelta(event.index, event.args));
+	controller.enqueue(createBlockStop(event.index));
+}
+/**
 * Transform Antigravity stream response to Anthropic format
 */
-function transformStreamToAnthropic(response, model) {
+function transformStreamResponse(response, model) {
 	const reader = response.body?.getReader();
 	if (!reader) return new Response("No response body", { status: 500 });
-	const encoder = new TextEncoder();
 	const decoder = new TextDecoder();
+	const messageId = generateMessageId();
 	const stream = new ReadableStream({ async start(controller) {
-		let buffer = "";
-		const messageId = `msg_${Date.now()}_${Math.random().toString(36).slice(2, 9)}`;
-		let inputTokens = 0;
-		let outputTokens = 0;
-		let contentBlockIndex = 0;
-		let thinkingBlockStarted = false;
-		let textBlockStarted = false;
-		const messageStart = {
-			type: "message_start",
-			message: {
-				id: messageId,
-				type: "message",
-				role: "assistant",
-				content: [],
-				model,
-				stop_reason: null,
-				stop_sequence: null,
-				usage: {
-					input_tokens: 0,
-					output_tokens: 0
-				}
-			}
-		};
-		controller.enqueue(encoder.encode(`event: message_start\ndata: ${JSON.stringify(messageStart)}\n\n`));
+		const state$1 = createStreamState();
+		controller.enqueue(createMessageStart(messageId, model));
 		try {
-			while (true) {
-				const { done, value } = await reader.read();
-				if (done) {
-					controller.enqueue(encoder.encode(`event: message_stop\ndata: ${JSON.stringify({ type: "message_stop" })}\n\n`));
-					controller.close();
-					break;
-				}
-				buffer += decoder.decode(value, { stream: true });
-				const lines = buffer.split("\n");
-				buffer = lines.pop() || "";
-				for (const line of lines) if (line.startsWith("data: ")) {
-					const data = line.slice(6).trim();
-					if (data === "[DONE]" || data === "") continue;
-					try {
-						const parsed = JSON.parse(data);
-						const candidate = (parsed.response?.candidates || parsed.candidates)?.[0];
-						const parts = candidate?.content?.parts || [];
-						const usage = parsed.response?.usageMetadata || parsed.usageMetadata;
-						if (usage) {
-							inputTokens = usage.promptTokenCount || inputTokens;
-							outputTokens = usage.candidatesTokenCount || outputTokens;
-						}
-						for (const part of parts) {
-							if (part.thought && part.text) {
-								if (!thinkingBlockStarted) {
-									const blockStart = {
-										type: "content_block_start",
-										index: contentBlockIndex,
-										content_block: {
-											type: "thinking",
-											thinking: ""
-										}
-									};
-									controller.enqueue(encoder.encode(`event: content_block_start\ndata: ${JSON.stringify(blockStart)}\n\n`));
-									thinkingBlockStarted = true;
-								}
-								const thinkingDelta = {
-									type: "content_block_delta",
-									index: contentBlockIndex,
-									delta: {
-										type: "thinking_delta",
-										thinking: part.text
-									}
-								};
-								controller.enqueue(encoder.encode(`event: content_block_delta\ndata: ${JSON.stringify(thinkingDelta)}\n\n`));
-								continue;
-							}
-							if (part.text && !part.thought) {
-								if (thinkingBlockStarted && !textBlockStarted) {
-									const blockStop = {
-										type: "content_block_stop",
-										index: contentBlockIndex
-									};
-									controller.enqueue(encoder.encode(`event: content_block_stop\ndata: ${JSON.stringify(blockStop)}\n\n`));
-									contentBlockIndex++;
-								}
-								if (!textBlockStarted) {
-									const blockStart = {
-										type: "content_block_start",
-										index: contentBlockIndex,
-										content_block: {
-											type: "text",
-											text: ""
-										}
-									};
-									controller.enqueue(encoder.encode(`event: content_block_start\ndata: ${JSON.stringify(blockStart)}\n\n`));
-									textBlockStarted = true;
-								}
-								const textDelta = {
-									type: "content_block_delta",
-									index: contentBlockIndex,
-									delta: {
-										type: "text_delta",
-										text: part.text
-									}
-								};
-								controller.enqueue(encoder.encode(`event: content_block_delta\ndata: ${JSON.stringify(textDelta)}\n\n`));
-							}
-							if (part.functionCall) {
-								if (textBlockStarted || thinkingBlockStarted) {
-									const blockStop = {
-										type: "content_block_stop",
-										index: contentBlockIndex
-									};
-									controller.enqueue(encoder.encode(`event: content_block_stop\ndata: ${JSON.stringify(blockStop)}\n\n`));
-									contentBlockIndex++;
-									textBlockStarted = false;
-									thinkingBlockStarted = false;
-								}
-								const toolBlockStart = {
-									type: "content_block_start",
-									index: contentBlockIndex,
-									content_block: {
-										type: "tool_use",
-										id: `toolu_${Date.now()}`,
-										name: part.functionCall.name,
-										input: {}
-									}
-								};
-								controller.enqueue(encoder.encode(`event: content_block_start\ndata: ${JSON.stringify(toolBlockStart)}\n\n`));
-								const toolDelta = {
-									type: "content_block_delta",
-									index: contentBlockIndex,
-									delta: {
-										type: "input_json_delta",
-										partial_json: JSON.stringify(part.functionCall.args)
-									}
-								};
-								controller.enqueue(encoder.encode(`event: content_block_delta\ndata: ${JSON.stringify(toolDelta)}\n\n`));
-								const toolBlockStop = {
-									type: "content_block_stop",
-									index: contentBlockIndex
-								};
-								controller.enqueue(encoder.encode(`event: content_block_stop\ndata: ${JSON.stringify(toolBlockStop)}\n\n`));
-								contentBlockIndex++;
-							}
-						}
-						if (candidate?.finishReason === "STOP") {
-							if (textBlockStarted || thinkingBlockStarted) {
-								const blockStop = {
-									type: "content_block_stop",
-									index: contentBlockIndex
-								};
-								controller.enqueue(encoder.encode(`event: content_block_stop\ndata: ${JSON.stringify(blockStop)}\n\n`));
-							}
-							const messageDelta = {
-								type: "message_delta",
-								delta: {
-									stop_reason: "end_turn",
-									stop_sequence: null
-								},
-								usage: { output_tokens: outputTokens }
-							};
-							controller.enqueue(encoder.encode(`event: message_delta\ndata: ${JSON.stringify(messageDelta)}\n\n`));
-						}
-					} catch {}
-				}
-			}
+			await processStream(reader, decoder, state$1, controller);
+			controller.enqueue(createMessageStop());
+			controller.close();
 		} catch (error) {
 			consola.error("Stream transform error:", error);
 			controller.error(error);
@@ -1294,12 +1531,56 @@ function transformStreamToAnthropic(response, model) {
 	} });
 }
 /**
+* Process the stream and emit events
+*/
+async function processStream(reader, decoder, state$1, controller) {
+	const emit = (event) => emitSSEEvent(event, controller, state$1);
+	while (true) {
+		const { done, value } = await reader.read();
+		if (done) break;
+		const chunk = decoder.decode(value, { stream: true });
+		const lines = processChunk(chunk, state$1);
+		for (const line of lines) {
+			const data = parseSSELine(line);
+			if (!data) continue;
+			const { candidates, usage } = extractFromData(data);
+			if (usage) {
+				state$1.inputTokens = usage.promptTokenCount ?? state$1.inputTokens;
+				state$1.outputTokens = usage.candidatesTokenCount ?? state$1.outputTokens;
+			}
+			const candidate = candidates[0];
+			const parts = candidate?.content?.parts ?? [];
+			for (const part of parts) processPart(part, state$1, emit);
+			if (candidate?.finishReason === "STOP") handleFinish(state$1, emit);
+		}
+	}
+}
+/**
 * Transform Antigravity non-stream response to Anthropic format
 */
-async function transformNonStreamToAnthropic(response, model) {
+async function transformNonStreamResponse(response, model) {
 	const data = await response.json();
-	const candidate = data.candidates?.[0];
-	const parts = candidate?.content?.parts || [];
+	const parts = (data.candidates?.[0])?.content?.parts ?? [];
+	const content = buildNonStreamContent(parts);
+	const anthropicResponse = {
+		id: generateMessageId(),
+		type: "message",
+		role: "assistant",
+		content,
+		model,
+		stop_reason: "end_turn",
+		stop_sequence: null,
+		usage: {
+			input_tokens: data.usageMetadata?.promptTokenCount ?? 0,
+			output_tokens: data.usageMetadata?.candidatesTokenCount ?? 0
+		}
+	};
+	return new Response(JSON.stringify(anthropicResponse), { headers: { "Content-Type": "application/json" } });
+}
+/**
+* Build content array for non-stream response
+*/
+function buildNonStreamContent(parts) {
 	const content = [];
 	for (const part of parts) {
 		if (part.thought && part.text) content.push({
@@ -1312,25 +1593,12 @@ async function transformNonStreamToAnthropic(response, model) {
 		});
 		if (part.functionCall) content.push({
 			type: "tool_use",
-			id: `toolu_${Date.now()}`,
+			id: generateToolId(),
 			name: part.functionCall.name,
 			input: part.functionCall.args
 		});
 	}
-	const anthropicResponse = {
-		id: `msg_${Date.now()}_${Math.random().toString(36).slice(2, 9)}`,
-		type: "message",
-		role: "assistant",
-		content,
-		model,
-		stop_reason: candidate?.finishReason === "STOP" ? "end_turn" : "end_turn",
-		stop_sequence: null,
-		usage: {
-			input_tokens: data.usageMetadata?.promptTokenCount || 0,
-			output_tokens: data.usageMetadata?.candidatesTokenCount || 0
-		}
-	};
-	return new Response(JSON.stringify(anthropicResponse), { headers: { "Content-Type": "application/json" } });
+	return content;
 }
 
 //#endregion
@@ -1420,11 +1688,11 @@ const encodingCache = /* @__PURE__ */ new Map();
 /**
 * Calculate tokens for tool calls
 */
-const calculateToolCallsTokens = (toolCalls, encoder, constants) => {
+const calculateToolCallsTokens = (toolCalls, encoder$1, constants) => {
 	let tokens = 0;
 	for (const toolCall of toolCalls) {
 		tokens += constants.funcInit;
-		tokens += encoder.encode(JSON.stringify(toolCall)).length;
+		tokens += encoder$1.encode(JSON.stringify(toolCall)).length;
 	}
 	tokens += constants.funcEnd;
 	return tokens;
@@ -1432,34 +1700,34 @@ const calculateToolCallsTokens = (toolCalls, encoder, constants) => {
 /**
 * Calculate tokens for content parts
 */
-const calculateContentPartsTokens = (contentParts, encoder) => {
+const calculateContentPartsTokens = (contentParts, encoder$1) => {
 	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;
+	for (const part of contentParts) if (part.type === "image_url") tokens += encoder$1.encode(part.image_url.url).length + 85;
+	else if (part.text) tokens += encoder$1.encode(part.text).length;
 	return tokens;
 };
 /**
 * Calculate tokens for a single message
 */
-const calculateMessageTokens = (message, encoder, constants) => {
+const calculateMessageTokens = (message, encoder$1, constants) => {
 	const tokensPerMessage = 3;
 	const tokensPerName = 1;
 	let tokens = tokensPerMessage;
 	for (const [key, value] of Object.entries(message)) {
-		if (typeof value === "string") tokens += encoder.encode(value).length;
+		if (typeof value === "string") tokens += encoder$1.encode(value).length;
 		if (key === "name") tokens += tokensPerName;
-		if (key === "tool_calls") tokens += calculateToolCallsTokens(value, encoder, constants);
-		if (key === "content" && Array.isArray(value)) tokens += calculateContentPartsTokens(value, encoder);
+		if (key === "tool_calls") tokens += calculateToolCallsTokens(value, encoder$1, constants);
+		if (key === "content" && Array.isArray(value)) tokens += calculateContentPartsTokens(value, encoder$1);
 	}
 	return tokens;
 };
 /**
 * Calculate tokens using custom algorithm
 */
-const calculateTokens = (messages, encoder, constants) => {
+const calculateTokens = (messages, encoder$1, constants) => {
 	if (messages.length === 0) return 0;
 	let numTokens = 0;
-	for (const message of messages) numTokens += calculateMessageTokens(message, encoder, constants);
+	for (const message of messages) numTokens += calculateMessageTokens(message, encoder$1, constants);
 	numTokens += 3;
 	return numTokens;
 };
@@ -1511,7 +1779,7 @@ const getModelConstants = (model) => {
 * Calculate tokens for a single parameter
 */
 const calculateParameterTokens = (key, prop, context) => {
-	const { encoder, constants } = context;
+	const { encoder: encoder$1, constants } = context;
 	let tokens = constants.propKey;
 	if (typeof prop !== "object" || prop === null) return tokens;
 	const param = prop;
@@ -1522,12 +1790,12 @@ const calculateParameterTokens = (key, prop, context) => {
 		tokens += constants.enumInit;
 		for (const item of param.enum) {
 			tokens += constants.enumItem;
-			tokens += encoder.encode(String(item)).length;
+			tokens += encoder$1.encode(String(item)).length;
 		}
 	}
 	if (paramDesc.endsWith(".")) paramDesc = paramDesc.slice(0, -1);
 	const line = `${paramName}:${paramType}:${paramDesc}`;
-	tokens += encoder.encode(line).length;
+	tokens += encoder$1.encode(line).length;
 	const excludedKeys = new Set([
 		"type",
 		"description",
@@ -1536,14 +1804,14 @@ const calculateParameterTokens = (key, prop, context) => {
 	for (const propertyName of Object.keys(param)) if (!excludedKeys.has(propertyName)) {
 		const propertyValue = param[propertyName];
 		const propertyText = typeof propertyValue === "string" ? propertyValue : JSON.stringify(propertyValue);
-		tokens += encoder.encode(`${propertyName}:${propertyText}`).length;
+		tokens += encoder$1.encode(`${propertyName}:${propertyText}`).length;
 	}
 	return tokens;
 };
 /**
 * Calculate tokens for function parameters
 */
-const calculateParametersTokens = (parameters, encoder, constants) => {
+const calculateParametersTokens = (parameters, encoder$1, constants) => {
 	if (!parameters || typeof parameters !== "object") return 0;
 	const params = parameters;
 	let tokens = 0;
@@ -1552,36 +1820,36 @@ const calculateParametersTokens = (parameters, encoder, constants) => {
 		if (Object.keys(properties).length > 0) {
 			tokens += constants.propInit;
 			for (const propKey of Object.keys(properties)) tokens += calculateParameterTokens(propKey, properties[propKey], {
-				encoder,
+				encoder: encoder$1,
 				constants
 			});
 		}
 	} else {
 		const paramText = typeof value === "string" ? value : JSON.stringify(value);
-		tokens += encoder.encode(`${key}:${paramText}`).length;
+		tokens += encoder$1.encode(`${key}:${paramText}`).length;
 	}
 	return tokens;
 };
 /**
 * Calculate tokens for a single tool
 */
-const calculateToolTokens = (tool, encoder, constants) => {
+const calculateToolTokens = (tool, encoder$1, constants) => {
 	let tokens = constants.funcInit;
 	const func = tool.function;
 	const fName = func.name;
 	let fDesc = func.description || "";
 	if (fDesc.endsWith(".")) fDesc = fDesc.slice(0, -1);
 	const line = fName + ":" + fDesc;
-	tokens += encoder.encode(line).length;
-	if (typeof func.parameters === "object" && func.parameters !== null) tokens += calculateParametersTokens(func.parameters, encoder, constants);
+	tokens += encoder$1.encode(line).length;
+	if (typeof func.parameters === "object" && func.parameters !== null) tokens += calculateParametersTokens(func.parameters, encoder$1, constants);
 	return tokens;
 };
 /**
 * Calculate token count for tools based on model
 */
-const numTokensForTools = (tools, encoder, constants) => {
+const numTokensForTools = (tools, encoder$1, constants) => {
 	let funcTokenCount = 0;
-	for (const tool of tools) funcTokenCount += calculateToolTokens(tool, encoder, constants);
+	for (const tool of tools) funcTokenCount += calculateToolTokens(tool, encoder$1, constants);
 	funcTokenCount += constants.funcEnd;
 	return funcTokenCount;
 };
@@ -1590,14 +1858,14 @@ const numTokensForTools = (tools, encoder, constants) => {
 */
 const getTokenCount = async (payload, model) => {
 	const tokenizer = getTokenizerFromModel(model);
-	const encoder = await getEncodeChatFunction(tokenizer);
+	const encoder$1 = await getEncodeChatFunction(tokenizer);
 	const simplifiedMessages = payload.messages;
 	const inputMessages = simplifiedMessages.filter((msg) => msg.role !== "assistant");
 	const outputMessages = simplifiedMessages.filter((msg) => msg.role === "assistant");
 	const constants = getModelConstants(model);
-	let inputTokens = calculateTokens(inputMessages, encoder, constants);
-	if (payload.tools && payload.tools.length > 0) inputTokens += numTokensForTools(payload.tools, encoder, constants);
-	const outputTokens = calculateTokens(outputMessages, encoder, constants);
+	let inputTokens = calculateTokens(inputMessages, encoder$1, constants);
+	if (payload.tools && payload.tools.length > 0) inputTokens += numTokensForTools(payload.tools, encoder$1, constants);
+	const outputTokens = calculateTokens(outputMessages, encoder$1, constants);
 	return {
 		input: inputTokens,
 		output: outputTokens