@dianshuv/copilot-api 0.4.0 → 0.4.1

package/dist/main.mjs

@@ -1020,7 +1020,7 @@ const patchClaude = defineCommand({
 
 //#endregion
 //#region package.json
-var version = "0.4.0";
+var version = "0.4.1";
 
 //#endregion
 //#region src/lib/adaptive-rate-limiter.ts
@@ -7445,50 +7445,229 @@ const containsVisionContent = (value) => {
 	if (Array.isArray(record.content)) return record.content.some((entry) => containsVisionContent(entry));
 	return false;
 };
+/** Convert Responses API input to history MessageContent format */
+function convertResponsesInputToMessages(input) {
+	if (!input) return [];
+	if (typeof input === "string") return [{
+		role: "user",
+		content: input
+	}];
+	const messages = [];
+	for (const item of input) {
+		const record = item;
+		switch (record.type) {
+			case "function_call": {
+				const fc = item;
+				messages.push({
+					role: "assistant",
+					content: "",
+					tool_calls: [{
+						id: fc.call_id,
+						type: "function",
+						function: {
+							name: fc.name,
+							arguments: fc.arguments
+						}
+					}]
+				});
+				break;
+			}
+			case "function_call_output": {
+				const fco = item;
+				messages.push({
+					role: "tool",
+					content: typeof fco.output === "string" ? fco.output : JSON.stringify(fco.output),
+					tool_call_id: fco.call_id
+				});
+				break;
+			}
+			case "reasoning": break;
+			default: if ("role" in record) {
+				const msg = item;
+				messages.push({
+					role: msg.role,
+					content: typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content)
+				});
+			}
+		}
+	}
+	return messages;
+}
+/** Convert Responses API tools to history ToolDefinition format */
+function convertResponsesToolsToDefinitions(tools) {
+	if (!tools) return [];
+	return tools.filter((t) => t.type === "function").map((t) => {
+		const ft = t;
+		const def = { name: ft.name };
+		if (ft.description) def.description = ft.description;
+		return def;
+	});
+}
+/** Extract response content and tool calls from ResponsesResult output in a single pass */
+function extractResponseData(result) {
+	if (result.output.length === 0) return {
+		content: null,
+		toolCalls: void 0
+	};
+	let text = "";
+	const contentToolCalls = [];
+	const historyToolCalls = [];
+	for (const item of result.output) if (item.type === "message" && "content" in item && item.content) {
+		for (const block of item.content) if ("text" in block && typeof block.text === "string") text += block.text;
+		else if ("refusal" in block && typeof block.refusal === "string") text += block.refusal;
+	} else if (item.type === "function_call") {
+		const fc = item;
+		contentToolCalls.push({
+			id: fc.call_id,
+			type: "function",
+			function: {
+				name: fc.name,
+				arguments: fc.arguments
+			}
+		});
+		historyToolCalls.push({
+			id: fc.call_id,
+			name: fc.name,
+			input: fc.arguments
+		});
+	}
+	if (!text && contentToolCalls.length === 0) return {
+		content: null,
+		toolCalls: void 0
+	};
+	const content = {
+		role: "assistant",
+		content: text
+	};
+	if (contentToolCalls.length > 0) content.tool_calls = contentToolCalls;
+	return {
+		content,
+		toolCalls: historyToolCalls.length > 0 ? historyToolCalls : void 0
+	};
+}
+/** Map ResponsesResult.status to a stop_reason string */
+function extractResponseStopReason(result) {
+	switch (result.status) {
+		case "completed": return "stop";
+		case "incomplete": return "length";
+		case "failed": return "error";
+		default: return result.status;
+	}
+}
 
 //#endregion
 //#region src/routes/responses/handler.ts
 const RESPONSES_ENDPOINT = "/responses";
+const TERMINAL_EVENTS = new Set([
+	"response.completed",
+	"response.incomplete",
+	"response.failed",
+	"error"
+]);
 const handleResponses = async (c) => {
 	const payload = await c.req.json();
 	consola.debug("Responses request payload:", JSON.stringify(payload));
 	const trackingId = c.get("trackingId");
+	const startTime = (trackingId ? requestTracker.getRequest(trackingId) : void 0)?.startTime ?? Date.now();
 	updateTrackerModel(trackingId, payload.model);
 	useFunctionApplyPatch(payload);
 	removeWebSearchTool(payload);
-	if (!((state.models?.data.find((model) => model.id === payload.model))?.supported_endpoints?.includes(RESPONSES_ENDPOINT) ?? false)) return c.json({ error: {
-		message: "This model does not support the responses endpoint. Please choose a different model.",
-		type: "invalid_request_error"
-	} }, 400);
+	const model = payload.model;
+	const stream = payload.stream ?? false;
+	const tools = convertResponsesToolsToDefinitions(payload.tools);
+	const historyId = recordRequest("openai", {
+		model,
+		messages: convertResponsesInputToMessages(payload.input),
+		stream,
+		tools: tools.length > 0 ? tools : void 0,
+		max_tokens: payload.max_output_tokens ?? void 0,
+		temperature: payload.temperature ?? void 0,
+		system: payload.instructions ?? void 0
+	});
+	const ctx = {
+		historyId,
+		trackingId,
+		startTime
+	};
+	if (!((state.models?.data.find((m) => m.id === payload.model))?.supported_endpoints?.includes(RESPONSES_ENDPOINT) ?? false)) {
+		recordErrorResponse(ctx, model, /* @__PURE__ */ new Error("This model does not support the responses endpoint."));
+		return c.json({ error: {
+			message: "This model does not support the responses endpoint. Please choose a different model.",
+			type: "invalid_request_error"
+		} }, 400);
+	}
 	const { vision, initiator } = getResponsesRequestOptions(payload);
 	if (state.manualApprove) await awaitApproval();
-	const { result: response } = await executeWithAdaptiveRateLimit(() => createResponses(payload, {
-		vision,
-		initiator
-	}));
-	if (isStreamingRequested(payload) && isAsyncIterable(response)) {
-		consola.debug("Forwarding native Responses stream");
-		return streamSSE(c, async (stream) => {
-			const idTracker = createStreamIdTracker();
-			try {
-				for await (const chunk of response) {
-					consola.debug("Responses stream chunk:", JSON.stringify(chunk));
-					const processedData = fixStreamIds(chunk.data ?? "", chunk.event, idTracker);
-					await stream.writeSSE({
-						id: chunk.id,
-						event: chunk.event,
-						data: processedData
+	try {
+		const { result: response, queueWaitMs } = await executeWithAdaptiveRateLimit(() => createResponses(payload, {
+			vision,
+			initiator
+		}));
+		ctx.queueWaitMs = queueWaitMs;
+		if (isStreamingRequested(payload) && isAsyncIterable(response)) {
+			consola.debug("Forwarding native Responses stream");
+			updateTrackerStatus(trackingId, "streaming");
+			return streamSSE(c, async (stream) => {
+				const idTracker = createStreamIdTracker();
+				let finalResult;
+				let streamErrorMessage;
+				try {
+					for await (const chunk of response) {
+						consola.debug("Responses stream chunk:", JSON.stringify(chunk));
+						const eventType = chunk.event;
+						const rawData = chunk.data ?? "";
+						if (eventType && TERMINAL_EVENTS.has(eventType)) try {
+							const parsed = JSON.parse(rawData);
+							if ("response" in parsed) finalResult = parsed.response;
+							else if (eventType === "error" && "message" in parsed) streamErrorMessage = parsed.message;
+						} catch {}
+						const processedData = fixStreamIds(rawData, eventType, idTracker);
+						await stream.writeSSE({
+							id: chunk.id,
+							event: eventType,
+							data: processedData
+						});
+					}
+					if (finalResult) {
+						recordResponseResult(finalResult, model, historyId, startTime);
+						const usage = finalResult.usage;
+						completeTracking(trackingId, usage?.input_tokens ?? 0, usage?.output_tokens ?? 0, queueWaitMs);
+					} else if (streamErrorMessage) {
+						recordResponse(historyId, {
+							success: false,
+							model,
+							usage: {
+								input_tokens: 0,
+								output_tokens: 0
+							},
+							error: streamErrorMessage,
+							content: null
+						}, Date.now() - startTime);
+						completeTracking(trackingId, 0, 0, queueWaitMs);
+					} else completeTracking(trackingId, 0, 0, queueWaitMs);
+				} catch (error) {
+					recordStreamError({
+						acc: { model: finalResult?.model || model },
+						fallbackModel: model,
+						ctx,
+						error
 					});
+					failTracking(trackingId, error);
+					throw error;
 				}
-				completeTracking(trackingId, 0, 0);
-			} catch (error) {
-				failTracking(trackingId, error);
-				throw error;
-			}
-		});
+			});
+		}
+		const result = response;
+		const usage = result.usage;
+		recordResponseResult(result, model, historyId, startTime);
+		completeTracking(trackingId, usage?.input_tokens ?? 0, usage?.output_tokens ?? 0, ctx.queueWaitMs);
+		consola.debug("Forwarding native Responses result:", JSON.stringify(result).slice(-400));
+		return c.json(result);
+	} catch (error) {
+		recordErrorResponse(ctx, model, error);
+		failTracking(trackingId, error);
+		throw error;
 	}
-	consola.debug("Forwarding native Responses result:", JSON.stringify(response).slice(-400));
-	return c.json(response);
 };
 const isAsyncIterable = (value) => Boolean(value) && typeof value[Symbol.asyncIterator] === "function";
 const isStreamingRequested = (payload) => Boolean(payload.stream);
@@ -7523,6 +7702,22 @@ const removeWebSearchTool = (payload) => {
 		return t.type !== "web_search";
 	});
 };
+/** Record a ResponsesResult to history */
+function recordResponseResult(result, fallbackModel, historyId, startTime) {
+	const usage = result.usage;
+	const { content, toolCalls } = extractResponseData(result);
+	recordResponse(historyId, {
+		success: result.status !== "failed",
+		model: result.model || fallbackModel,
+		usage: {
+			input_tokens: usage?.input_tokens ?? 0,
+			output_tokens: usage?.output_tokens ?? 0
+		},
+		stop_reason: extractResponseStopReason(result),
+		content,
+		toolCalls
+	}, Date.now() - startTime);
+}
 
 //#endregion
 //#region src/routes/responses/route.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dianshuv/copilot-api",
-  "version": "0.4.0",
+  "version": "0.4.1",
   "description": "Turn GitHub Copilot into OpenAI/Anthropic API compatible server. Usable with Claude Code!",
   "author": "dianshuv",
   "type": "module",