@dianshuv/copilot-api 0.4.0 → 0.4.2

package/README.md

@@ -65,6 +65,7 @@ copilot-api start
 | `--compress-tool-results` | Compress old tool results before truncating | false |
 | `--redirect-anthropic` | Force Anthropic through OpenAI translation | false |
 | `--no-rewrite-anthropic-tools` | Don't rewrite server-side tools | false |
+| `--timezone-offset` | Timezone offset in hours from UTC for log timestamps (e.g., +8, -5, 0) | +8 |
 
 ### Patch-Claude Command Options
 

package/dist/main.mjs

@@ -52,6 +52,7 @@ const state = {
 	redirectAnthropic: false,
 	rewriteAnthropicTools: true,
 	staleRequestMaxAge: 600,
+	timezoneOffset: 8,
 	shutdownGracefulWait: 60,
 	shutdownAbortWait: 120
 };
@@ -1020,7 +1021,7 @@ const patchClaude = defineCommand({
 
 //#endregion
 //#region package.json
-var version = "0.4.0";
+var version = "0.4.2";
 
 //#endregion
 //#region src/lib/adaptive-rate-limiter.ts
@@ -2199,7 +2200,8 @@ function setupShutdownHandlers() {
 //#region src/lib/tui/console-renderer.ts
 const CLEAR_LINE = "\x1B[2K\r";
 function formatTime(date = /* @__PURE__ */ new Date()) {
-	return `${String(date.getHours()).padStart(2, "0")}:${String(date.getMinutes()).padStart(2, "0")}:${String(date.getSeconds()).padStart(2, "0")}`;
+	const adjusted = new Date(date.getTime() + state.timezoneOffset * 60 * 60 * 1e3);
+	return `${String(adjusted.getUTCHours()).padStart(2, "0")}:${String(adjusted.getUTCMinutes()).padStart(2, "0")}:${String(adjusted.getUTCSeconds()).padStart(2, "0")}`;
 }
 function formatDuration(ms) {
 	if (ms < 1e3) return `${ms}ms`;
@@ -7445,50 +7447,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 +7704,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
@@ -7620,6 +7817,7 @@ async function runServer(options) {
 	state.compressToolResults = options.compressToolResults;
 	state.redirectAnthropic = options.redirectAnthropic;
 	state.rewriteAnthropicTools = options.rewriteAnthropicTools;
+	state.timezoneOffset = options.timezoneOffset;
 	if (options.rateLimit) initAdaptiveRateLimiter({
 		baseRetryIntervalSeconds: options.retryInterval,
 		requestIntervalSeconds: options.requestInterval,
@@ -7684,6 +7882,12 @@ async function runServer(options) {
 		hostname: options.host
 	}));
 }
+function parseTimezoneOffset(value) {
+	if (typeof value !== "string") return 8;
+	const n = Number(value);
+	if (!Number.isFinite(n)) return 8;
+	return n;
+}
 const start = defineCommand({
 	meta: {
 		name: "start",
@@ -7793,6 +7997,11 @@ const start = defineCommand({
 			type: "boolean",
 			default: false,
 			description: "Don't rewrite Anthropic server-side tools (web_search, etc.) to custom tool format"
+		},
+		"timezone-offset": {
+			type: "string",
+			default: "+8",
+			description: "Timezone offset in hours from UTC for log timestamps (e.g., +8, -5, 0)"
 		}
 	},
 	run({ args }) {
@@ -7816,7 +8025,8 @@ const start = defineCommand({
 			autoTruncate: !args["no-auto-truncate"],
 			compressToolResults: args["compress-tool-results"],
 			redirectAnthropic: args["redirect-anthropic"],
-			rewriteAnthropicTools: !args["no-rewrite-anthropic-tools"]
+			rewriteAnthropicTools: !args["no-rewrite-anthropic-tools"],
+			timezoneOffset: parseTimezoneOffset(args["timezone-offset"])
 		});
 	}
 });

package/package.json

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