@dianshuv/copilot-api 0.3.0 → 0.4.1

package/README.md

@@ -10,6 +10,11 @@
 
 - **Responses API endpoint**: `/v1/responses` passthrough for codex models (e.g., `gpt-5.2-codex`, `gpt-5.3-codex`) used by tools like OpenCode. Includes stream ID synchronization for `@ai-sdk/openai` compatibility.
 - **SubagentStart marker support**: Detects `__SUBAGENT_MARKER__` injected by Claude Code hooks to override `X-Initiator` header to `"agent"` for subagent requests, ensuring correct credit tier usage. Includes a ready-to-use Claude plugin (`claude-plugin/`).
+- **Token analytics tab**: The `/history` page includes a Tokens tab with per-model token usage summary table and cumulative ECharts line chart for visualizing API consumption over time.
+- **Real-time history updates**: The `/history` UI uses WebSocket for live updates instead of polling, with automatic fallback to polling and exponential backoff reconnection.
+- **Graceful shutdown**: 4-phase shutdown sequence — stops accepting requests, waits for in-flight requests to complete, sends abort signal, then force-closes. Configurable via `--shutdown-graceful-wait` and `--shutdown-abort-wait`.
+- **Stream repetition detection**: Detects when models get stuck in repetitive output loops using KMP-based pattern matching and logs a warning.
+- **Stale request reaping**: Automatically force-fails requests that exceed a configurable maximum age (default 600s) to prevent resource leaks.
 
 ## Quick Start
 

package/dist/main.mjs

@@ -50,7 +50,10 @@ const state = {
 	autoTruncate: true,
 	compressToolResults: false,
 	redirectAnthropic: false,
-	rewriteAnthropicTools: true
+	rewriteAnthropicTools: true,
+	staleRequestMaxAge: 600,
+	shutdownGracefulWait: 60,
+	shutdownAbortWait: 120
 };
 
 //#endregion
@@ -1017,11 +1020,11 @@ const patchClaude = defineCommand({
 
 //#endregion
 //#region package.json
-var version = "0.3.0";
+var version = "0.4.1";
 
 //#endregion
 //#region src/lib/adaptive-rate-limiter.ts
-const DEFAULT_CONFIG = {
+const DEFAULT_CONFIG$1 = {
 	baseRetryIntervalSeconds: 10,
 	maxRetryIntervalSeconds: 120,
 	requestIntervalSeconds: 10,
@@ -1050,7 +1053,7 @@ var AdaptiveRateLimiter = class {
 	recoveryStepIndex = 0;
 	constructor(config = {}) {
 		this.config = {
-			...DEFAULT_CONFIG,
+			...DEFAULT_CONFIG$1,
 			...config
 		};
 	}
@@ -1272,6 +1275,16 @@ var AdaptiveRateLimiter = class {
 		return new Promise((resolve) => setTimeout(resolve, ms));
 	}
 	/**
+	* Reject all currently queued requests during shutdown.
+	* Returns the number of requests that were rejected.
+	*/
+	rejectQueued() {
+		const count = this.queue.length;
+		for (const request of this.queue) request.reject(/* @__PURE__ */ new Error("Server is shutting down"));
+		this.queue = [];
+		return count;
+	}
+	/**
 	* Get current status for debugging/monitoring
 	*/
 	getStatus() {
@@ -1289,15 +1302,21 @@ let rateLimiterInstance = null;
 */
 function initAdaptiveRateLimiter(config = {}) {
 	rateLimiterInstance = new AdaptiveRateLimiter(config);
-	const baseRetry = config.baseRetryIntervalSeconds ?? DEFAULT_CONFIG.baseRetryIntervalSeconds;
-	const maxRetry = config.maxRetryIntervalSeconds ?? DEFAULT_CONFIG.maxRetryIntervalSeconds;
-	const interval = config.requestIntervalSeconds ?? DEFAULT_CONFIG.requestIntervalSeconds;
-	const recovery = config.recoveryTimeoutMinutes ?? DEFAULT_CONFIG.recoveryTimeoutMinutes;
-	const successes = config.consecutiveSuccessesForRecovery ?? DEFAULT_CONFIG.consecutiveSuccessesForRecovery;
-	const steps = config.gradualRecoverySteps ?? DEFAULT_CONFIG.gradualRecoverySteps;
+	const baseRetry = config.baseRetryIntervalSeconds ?? DEFAULT_CONFIG$1.baseRetryIntervalSeconds;
+	const maxRetry = config.maxRetryIntervalSeconds ?? DEFAULT_CONFIG$1.maxRetryIntervalSeconds;
+	const interval = config.requestIntervalSeconds ?? DEFAULT_CONFIG$1.requestIntervalSeconds;
+	const recovery = config.recoveryTimeoutMinutes ?? DEFAULT_CONFIG$1.recoveryTimeoutMinutes;
+	const successes = config.consecutiveSuccessesForRecovery ?? DEFAULT_CONFIG$1.consecutiveSuccessesForRecovery;
+	const steps = config.gradualRecoverySteps ?? DEFAULT_CONFIG$1.gradualRecoverySteps;
 	consola.info(`[RateLimiter] Initialized (backoff: ${baseRetry}s-${maxRetry}s, interval: ${interval}s, recovery: ${recovery}min or ${successes} successes, gradual: [${steps.join("s, ")}s])`);
 }
 /**
+* Get the rate limiter instance
+*/
+function getAdaptiveRateLimiter() {
+	return rateLimiterInstance;
+}
+/**
 * Execute a request with adaptive rate limiting.
 * If rate limiter is not initialized, executes immediately.
 * Returns the result along with queue wait time.
@@ -1310,6 +1329,292 @@ async function executeWithAdaptiveRateLimit(fn) {
 	return rateLimiterInstance.execute(fn);
 }
 
+//#endregion
+//#region src/lib/context/request.ts
+let idCounter = 0;
+function createRequestContext(opts) {
+	const id = `req_${Date.now()}_${++idCounter}`;
+	const startTime = Date.now();
+	const onEvent = opts.onEvent;
+	let _state = "pending";
+	let _originalRequest = null;
+	let _response = null;
+	let settled = false;
+	function emit(event) {
+		try {
+			onEvent(event);
+		} catch {}
+	}
+	const ctx = {
+		id,
+		tuiLogId: opts.tuiLogId,
+		startTime,
+		endpoint: opts.endpoint,
+		get state() {
+			return _state;
+		},
+		get durationMs() {
+			return Date.now() - startTime;
+		},
+		get settled() {
+			return settled;
+		},
+		get originalRequest() {
+			return _originalRequest;
+		},
+		get response() {
+			return _response;
+		},
+		setOriginalRequest(req) {
+			_originalRequest = req;
+			emit({
+				type: "updated",
+				context: ctx,
+				field: "originalRequest"
+			});
+		},
+		transition(newState) {
+			const previousState = _state;
+			_state = newState;
+			emit({
+				type: "state_changed",
+				context: ctx,
+				previousState
+			});
+		},
+		complete(response) {
+			if (settled) return;
+			settled = true;
+			_response = response;
+			_state = "completed";
+			emit({
+				type: "completed",
+				context: ctx,
+				entry: ctx.toHistoryEntry()
+			});
+		},
+		fail(model, error) {
+			if (settled) return;
+			settled = true;
+			_response = {
+				success: false,
+				model,
+				usage: {
+					input_tokens: 0,
+					output_tokens: 0
+				},
+				error: error instanceof Error ? error.message : String(error),
+				content: null
+			};
+			_state = "failed";
+			emit({
+				type: "failed",
+				context: ctx,
+				entry: ctx.toHistoryEntry()
+			});
+		},
+		toHistoryEntry() {
+			const entry = {
+				id,
+				endpoint: opts.endpoint,
+				timestamp: startTime,
+				durationMs: Date.now() - startTime,
+				request: {
+					model: _originalRequest?.model,
+					messages: _originalRequest?.messages,
+					stream: _originalRequest?.stream,
+					tools: _originalRequest?.tools,
+					system: _originalRequest?.system
+				}
+			};
+			if (_response) entry.response = _response;
+			return entry;
+		}
+	};
+	return ctx;
+}
+
+//#endregion
+//#region src/lib/context/manager.ts
+/**
+* RequestContextManager — Active request management
+*
+* Manages all in-flight RequestContext instances. Publishes events for
+* WebSocket push and history persistence.
+*/
+let _manager = null;
+function initRequestContextManager(staleMaxAgeSec) {
+	_manager = createRequestContextManager(staleMaxAgeSec);
+	return _manager;
+}
+const REAPER_INTERVAL_MS = 6e4;
+const DEFAULT_STALE_MAX_AGE_SEC = 600;
+function createRequestContextManager(staleMaxAgeSec) {
+	const maxAgeSec = staleMaxAgeSec ?? DEFAULT_STALE_MAX_AGE_SEC;
+	const activeContexts = /* @__PURE__ */ new Map();
+	const listeners = /* @__PURE__ */ new Set();
+	let reaperTimer = null;
+	function runReaperOnce() {
+		if (maxAgeSec <= 0) return;
+		const maxAgeMs = maxAgeSec * 1e3;
+		for (const [id, ctx] of activeContexts) if (ctx.durationMs > maxAgeMs) {
+			consola.warn(`[context] Force-failing stale request ${id} (endpoint: ${ctx.endpoint}, model: ${ctx.originalRequest?.model ?? "unknown"}, state: ${ctx.state}, age: ${Math.round(ctx.durationMs / 1e3)}s, max: ${maxAgeSec}s)`);
+			ctx.fail(ctx.originalRequest?.model ?? "unknown", /* @__PURE__ */ new Error(`Request exceeded maximum age of ${maxAgeSec}s (stale context reaper)`));
+		}
+	}
+	function startReaper() {
+		if (reaperTimer) return;
+		reaperTimer = setInterval(runReaperOnce, REAPER_INTERVAL_MS);
+	}
+	function stopReaper() {
+		if (reaperTimer) {
+			clearInterval(reaperTimer);
+			reaperTimer = null;
+		}
+	}
+	function emit(event) {
+		for (const listener of listeners) try {
+			listener(event);
+		} catch {}
+	}
+	function handleContextEvent(rawEvent) {
+		const { type, context } = rawEvent;
+		switch (type) {
+			case "state_changed":
+				if (rawEvent.previousState) emit({
+					type: "state_changed",
+					context,
+					previousState: rawEvent.previousState
+				});
+				break;
+			case "updated":
+				if (rawEvent.field) emit({
+					type: "updated",
+					context,
+					field: rawEvent.field
+				});
+				break;
+			case "completed":
+				if (rawEvent.entry) emit({
+					type: "completed",
+					context,
+					entry: rawEvent.entry
+				});
+				activeContexts.delete(context.id);
+				break;
+			case "failed":
+				if (rawEvent.entry) emit({
+					type: "failed",
+					context,
+					entry: rawEvent.entry
+				});
+				activeContexts.delete(context.id);
+				break;
+			default: break;
+		}
+	}
+	return {
+		create(opts) {
+			const ctx = createRequestContext({
+				endpoint: opts.endpoint,
+				tuiLogId: opts.tuiLogId,
+				onEvent: handleContextEvent
+			});
+			activeContexts.set(ctx.id, ctx);
+			emit({
+				type: "created",
+				context: ctx
+			});
+			return ctx;
+		},
+		get(id) {
+			return activeContexts.get(id);
+		},
+		getAll() {
+			return Array.from(activeContexts.values());
+		},
+		get activeCount() {
+			return activeContexts.size;
+		},
+		on(_event, listener) {
+			listeners.add(listener);
+		},
+		off(_event, listener) {
+			listeners.delete(listener);
+		},
+		startReaper,
+		stopReaper,
+		_runReaperOnce: runReaperOnce
+	};
+}
+
+//#endregion
+//#region src/lib/history-ws.ts
+/**
+* WebSocket support for History API.
+* Enables real-time updates when new requests are recorded.
+*/
+const clients = /* @__PURE__ */ new Set();
+function getClientCount() {
+	return clients.size;
+}
+function closeAllClients() {
+	for (const client of clients) try {
+		client.close(1001, "Server shutting down");
+	} catch {}
+	clients.clear();
+}
+function broadcast(message) {
+	const data = JSON.stringify(message);
+	for (const client of clients) try {
+		if (client.readyState === WebSocket.OPEN) client.send(data);
+		else clients.delete(client);
+	} catch (error) {
+		consola.debug("WebSocket send failed, removing client:", error);
+		clients.delete(client);
+	}
+}
+function notifyEntryAdded(summary) {
+	if (clients.size === 0) return;
+	broadcast({
+		type: "entry_added",
+		data: summary,
+		timestamp: Date.now()
+	});
+}
+function notifyEntryUpdated(summary) {
+	if (clients.size === 0) return;
+	broadcast({
+		type: "entry_updated",
+		data: summary,
+		timestamp: Date.now()
+	});
+}
+function notifyStatsUpdated(stats) {
+	if (clients.size === 0) return;
+	broadcast({
+		type: "stats_updated",
+		data: stats,
+		timestamp: Date.now()
+	});
+}
+function notifyHistoryCleared() {
+	if (clients.size === 0) return;
+	broadcast({
+		type: "history_cleared",
+		data: null,
+		timestamp: Date.now()
+	});
+}
+function notifySessionDeleted(sessionId) {
+	if (clients.size === 0) return;
+	broadcast({
+		type: "session_deleted",
+		data: { sessionId },
+		timestamp: Date.now()
+	});
+}
+
 //#endregion
 //#region src/lib/history.ts
 function generateId$1() {
@@ -1389,6 +1694,13 @@ function recordRequest(endpoint, request) {
 			if (historyState.entries.filter((e) => e.sessionId === removed.sessionId).length === 0) historyState.sessions.delete(removed.sessionId);
 		}
 	}
+	notifyEntryAdded({
+		id: entry.id,
+		endpoint,
+		model: request.model,
+		stream: request.stream,
+		timestamp: entry.timestamp
+	});
 	return entry.id;
 }
 function recordResponse(id, response, durationMs) {
@@ -1403,6 +1715,20 @@ function recordResponse(id, response, durationMs) {
 			session.totalOutputTokens += response.usage.output_tokens;
 			session.lastActivity = Date.now();
 		}
+		notifyEntryUpdated({
+			id: entry.id,
+			endpoint: entry.endpoint,
+			model: response.model,
+			success: response.success,
+			durationMs,
+			inputTokens: response.usage.input_tokens,
+			outputTokens: response.usage.output_tokens
+		});
+		notifyStatsUpdated({
+			totalRequests: historyState.entries.length,
+			totalInputTokens: session?.totalInputTokens ?? 0,
+			totalOutputTokens: session?.totalOutputTokens ?? 0
+		});
 	}
 }
 function getHistory(options = {}) {
@@ -1477,12 +1803,14 @@ function clearHistory() {
 	historyState.entries = [];
 	historyState.sessions = /* @__PURE__ */ new Map();
 	historyState.currentSessionId = generateId$1();
+	notifyHistoryCleared();
 }
 function deleteSession(sessionId) {
 	if (!historyState.sessions.has(sessionId)) return false;
 	historyState.entries = historyState.entries.filter((e) => e.sessionId !== sessionId);
 	historyState.sessions.delete(sessionId);
 	if (historyState.currentSessionId === sessionId) historyState.currentSessionId = generateId$1();
+	notifySessionDeleted(sessionId);
 	return true;
 }
 function getStats() {
@@ -1731,6 +2059,142 @@ function generateEnvScript(envVars, commandToRun = "") {
 	return commandBlock || commandToRun;
 }
 
+//#endregion
+//#region src/lib/shutdown.ts
+const DRAIN_POLL_INTERVAL_MS = 500;
+const DRAIN_PROGRESS_INTERVAL_MS = 5e3;
+let serverInstance = null;
+let _isShuttingDown = false;
+let shutdownResolve = null;
+let shutdownAbortController = null;
+function getIsShuttingDown() {
+	return _isShuttingDown;
+}
+function setServerInstance(server) {
+	serverInstance = server;
+}
+function formatActiveRequestsSummary(requests) {
+	const now = Date.now();
+	const lines = requests.map((req) => {
+		const age = Math.round((now - req.startTime) / 1e3);
+		const model = req.model || "unknown";
+		const tags = req.tags?.length ? ` [${req.tags.join(", ")}]` : "";
+		return `  ${req.method} ${req.path} ${model} (${req.status}, ${age}s)${tags}`;
+	});
+	return `Waiting for ${requests.length} active request(s):\n${lines.join("\n")}`;
+}
+async function drainActiveRequests(timeoutMs, tracker, opts) {
+	const pollInterval = opts?.pollIntervalMs ?? DRAIN_POLL_INTERVAL_MS;
+	const progressInterval = opts?.progressIntervalMs ?? DRAIN_PROGRESS_INTERVAL_MS;
+	const deadline = Date.now() + timeoutMs;
+	let lastProgressLog = 0;
+	while (Date.now() < deadline) {
+		const active = tracker.getActiveRequests();
+		if (active.length === 0) return "drained";
+		const now = Date.now();
+		if (now - lastProgressLog >= progressInterval) {
+			lastProgressLog = now;
+			consola.info(formatActiveRequestsSummary(active));
+		}
+		await new Promise((resolve) => setTimeout(resolve, pollInterval));
+	}
+	return "timeout";
+}
+async function gracefulShutdown(signal, deps) {
+	const tracker = deps?.tracker;
+	const server = deps?.server ?? serverInstance;
+	const rateLimiter = deps?.rateLimiter !== void 0 ? deps.rateLimiter : getAdaptiveRateLimiter();
+	const stopRefresh = deps?.stopTokenRefreshFn ?? (() => {});
+	const closeWsClients = deps?.closeAllClientsFn ?? closeAllClients;
+	const getWsCount = deps?.getClientCountFn ?? getClientCount;
+	const gracefulWaitMs = deps?.gracefulWaitMs ?? state.shutdownGracefulWait * 1e3;
+	const abortWaitMs = deps?.abortWaitMs ?? state.shutdownAbortWait * 1e3;
+	const drainOpts = {
+		pollIntervalMs: deps?.drainPollIntervalMs ?? DRAIN_POLL_INTERVAL_MS,
+		progressIntervalMs: deps?.drainProgressIntervalMs ?? DRAIN_PROGRESS_INTERVAL_MS
+	};
+	_isShuttingDown = true;
+	shutdownAbortController = new AbortController();
+	consola.info(`Received ${signal}, shutting down gracefully...`);
+	try {
+		deps?.contextManager?.stopReaper();
+	} catch {}
+	stopRefresh();
+	const wsClients = getWsCount();
+	if (wsClients > 0) {
+		closeWsClients();
+		consola.info(`Disconnected ${wsClients} WebSocket client(s)`);
+	}
+	if (rateLimiter) {
+		const rejected = rateLimiter.rejectQueued();
+		if (rejected > 0) consola.info(`Rejected ${rejected} queued request(s) from rate limiter`);
+	}
+	if (server) {
+		server.close(false).catch((error) => {
+			consola.error("Error stopping listener:", error);
+		});
+		consola.info("Stopped accepting new connections");
+	}
+	if (tracker) {
+		const activeCount = tracker.getActiveRequests().length;
+		if (activeCount > 0) {
+			consola.info(`Phase 2: Waiting up to ${gracefulWaitMs / 1e3}s for ${activeCount} active request(s)...`);
+			try {
+				if (await drainActiveRequests(gracefulWaitMs, tracker, drainOpts) === "drained") {
+					consola.info("All requests completed naturally");
+					finalize(tracker);
+					return;
+				}
+			} catch (error) {
+				consola.error("Error during Phase 2 drain:", error);
+			}
+			const remaining = tracker.getActiveRequests().length;
+			consola.info(`Phase 3: Sending abort signal to ${remaining} remaining request(s), waiting up to ${abortWaitMs / 1e3}s...`);
+			shutdownAbortController.abort();
+			try {
+				if (await drainActiveRequests(abortWaitMs, tracker, drainOpts) === "drained") {
+					consola.info("All requests completed after abort signal");
+					finalize(tracker);
+					return;
+				}
+			} catch (error) {
+				consola.error("Error during Phase 3 drain:", error);
+			}
+			const forceRemaining = tracker.getActiveRequests().length;
+			consola.warn(`Phase 4: Force-closing ${forceRemaining} remaining request(s)`);
+			if (server) try {
+				await server.close(true);
+			} catch (error) {
+				consola.error("Error force-closing server:", error);
+			}
+		}
+		finalize(tracker);
+	} else {
+		consola.info("Shutdown complete");
+		shutdownResolve?.();
+	}
+}
+function finalize(tracker) {
+	tracker.destroy();
+	consola.info("Shutdown complete");
+	shutdownResolve?.();
+}
+function setupShutdownHandlers() {
+	const handler = (signal) => {
+		if (_isShuttingDown) {
+			consola.warn("Second signal received, forcing immediate exit");
+			process.exit(1);
+		}
+		gracefulShutdown(signal).catch((error) => {
+			consola.error("Fatal error during shutdown:", error);
+			shutdownResolve?.();
+			process.exit(1);
+		});
+	};
+	process.on("SIGINT", () => handler("SIGINT"));
+	process.on("SIGTERM", () => handler("SIGTERM"));
+}
+
 //#endregion
 //#region src/lib/tui/console-renderer.ts
 const CLEAR_LINE = "\x1B[2K\r";
@@ -2091,6 +2555,7 @@ const requestTracker = new RequestTracker();
 */
 function tuiLogger() {
 	return async (c, next) => {
+		if (getIsShuttingDown()) return c.json({ error: "Server is shutting down" }, 503);
 		const method = c.req.method;
 		const path = c.req.path;
 		const isHistoryAccess = path.startsWith("/history");
@@ -2814,6 +3279,127 @@ function createTruncationResponseMarkerOpenAI(result) {
 	return `\n\n---\n[Auto-truncated: ${result.removedMessageCount} messages removed, ${result.originalTokens} → ${result.compactedTokens} tokens (${percentage}% reduction)]`;
 }
 
+//#endregion
+//#region src/lib/repetition-detector.ts
+/**
+* Stream repetition detector.
+*
+* Uses the KMP failure function (prefix function) to detect repeated patterns
+* in streaming text output. When a model gets stuck in a repetitive loop,
+* it wastes tokens producing the same content over and over. This detector
+* identifies such loops early so the caller can take action (log warning,
+* abort stream, etc.).
+*
+* The algorithm works by maintaining a sliding buffer of recent text and
+* computing the longest proper prefix that is also a suffix — if this
+* length exceeds `(text.length - period) >= minRepetitions * period`,
+* it means a pattern of length `period` has repeated enough times.
+*/
+const DEFAULT_CONFIG = {
+	minPatternLength: 10,
+	minRepetitions: 3,
+	maxBufferSize: 5e3
+};
+var RepetitionDetector = class {
+	buffer = "";
+	config;
+	detected = false;
+	constructor(config) {
+		this.config = {
+			...DEFAULT_CONFIG,
+			...config
+		};
+	}
+	/**
+	* Feed a text chunk into the detector.
+	* Returns `true` if repetition has been detected (now or previously).
+	* Once detected, subsequent calls return `true` without further analysis.
+	*/
+	feed(text) {
+		if (this.detected) return true;
+		if (!text) return false;
+		this.buffer += text;
+		if (this.buffer.length > this.config.maxBufferSize) this.buffer = this.buffer.slice(-this.config.maxBufferSize);
+		const minRequired = this.config.minPatternLength * this.config.minRepetitions;
+		if (this.buffer.length < minRequired) return false;
+		this.detected = detectRepetition(this.buffer, this.config.minPatternLength, this.config.minRepetitions);
+		return this.detected;
+	}
+	/** Reset detector state for a new stream */
+	reset() {
+		this.buffer = "";
+		this.detected = false;
+	}
+	/** Whether repetition has been detected */
+	get isDetected() {
+		return this.detected;
+	}
+};
+/**
+* Detect if the tail of `text` contains a repeating pattern.
+*
+* Uses the KMP prefix function: for a string S, the prefix function π[i]
+* gives the length of the longest proper prefix of S[0..i] that is also
+* a suffix. If π[n-1] ≥ (n - period) where period = n - π[n-1], then
+* the string is composed of a repeating unit of length `period`.
+*
+* We check the suffix of the buffer (last `checkLength` chars) to detect
+* if a pattern of at least `minPatternLength` chars repeats at least
+* `minRepetitions` times.
+*/
+function detectRepetition(text, minPatternLength, minRepetitions) {
+	const minWindow = minPatternLength * minRepetitions;
+	const maxWindow = Math.min(text.length, 2e3);
+	const windowSizes = [
+		minWindow,
+		Math.floor(maxWindow * .5),
+		maxWindow
+	].filter((w) => w >= minWindow && w <= text.length);
+	for (const windowSize of windowSizes) {
+		const window = text.slice(-windowSize);
+		const period = findRepeatingPeriod(window);
+		if (period >= minPatternLength) {
+			if (Math.floor(window.length / period) >= minRepetitions) return true;
+		}
+	}
+	return false;
+}
+/**
+* Find the shortest repeating period in a string using KMP prefix function.
+* Returns the period length, or the string length if no repetition found.
+*/
+function findRepeatingPeriod(s) {
+	const n = s.length;
+	if (n === 0) return 0;
+	const pi = new Int32Array(n);
+	for (let i = 1; i < n; i++) {
+		let j = pi[i - 1] ?? 0;
+		while (j > 0 && s[i] !== s[j]) j = pi[j - 1] ?? 0;
+		if (s[i] === s[j]) j++;
+		pi[i] = j;
+	}
+	const period = n - pi[n - 1];
+	if (period < n && n % period === 0) return period;
+	if (period < n && pi[n - 1] >= period) return period;
+	return n;
+}
+/**
+* Create a repetition detector callback for use in stream processing.
+* Returns a function that accepts text deltas and logs a warning on first detection.
+*/
+function createStreamRepetitionChecker(label, config) {
+	const detector = new RepetitionDetector(config);
+	let warned = false;
+	return (textDelta) => {
+		const isRepetitive = detector.feed(textDelta);
+		if (isRepetitive && !warned) {
+			warned = true;
+			consola.warn(`[RepetitionDetector] ${label}: Repetitive output detected in stream`);
+		}
+		return isRepetitive;
+	};
+}
+
 //#endregion
 //#region src/services/copilot/create-chat-completions.ts
 const createChatCompletions = async (payload, options) => {
@@ -3150,6 +3736,7 @@ function createStreamAccumulator() {
 async function handleStreamingResponse$1(opts) {
 	const { stream, response, payload, ctx } = opts;
 	const acc = createStreamAccumulator();
+	const checkRepetition = createStreamRepetitionChecker(`openai:${payload.model}`);
 	try {
 		if (state.verbose && ctx.truncateResult?.wasCompacted) {
 			const marker = createTruncationResponseMarkerOpenAI(ctx.truncateResult);
@@ -3173,7 +3760,7 @@ async function handleStreamingResponse$1(opts) {
 		}
 		for await (const chunk of response) {
 			consola.debug("Streaming chunk:", JSON.stringify(chunk));
-			parseStreamChunk(chunk, acc);
+			parseStreamChunk(chunk, acc, checkRepetition);
 			await stream.writeSSE(chunk);
 		}
 		recordStreamSuccess(acc, payload.model, ctx);
@@ -3189,7 +3776,7 @@ async function handleStreamingResponse$1(opts) {
 		throw error;
 	}
 }
-function parseStreamChunk(chunk, acc) {
+function parseStreamChunk(chunk, acc, checkRepetition) {
 	if (!chunk.data || chunk.data === "[DONE]") return;
 	try {
 		const parsed = JSON.parse(chunk.data);
@@ -3200,7 +3787,10 @@ function parseStreamChunk(chunk, acc) {
 		}
 		const choice = parsed.choices[0];
 		if (choice) {
-			if (choice.delta.content) acc.content += choice.delta.content;
+			if (choice.delta.content) {
+				acc.content += choice.delta.content;
+				checkRepetition(choice.delta.content);
+			}
 			if (choice.delta.tool_calls) for (const tc of choice.delta.tool_calls) {
 				const idx = tc.index;
 				if (!acc.toolCallMap.has(idx)) acc.toolCallMap.set(idx, {
@@ -3939,12 +4529,78 @@ document.addEventListener('keydown', (e) => {
   }
 });
 
-// Auto-refresh every 10 seconds
-setInterval(() => {
+// Auto-refresh every 10 seconds (fallback when WebSocket is not available)
+let autoRefreshTimer = setInterval(() => {
   loadStats();
   loadSessions();
 }, 10000);
 
+// WebSocket real-time updates
+let reconnectAttempts = 0;
+function connectWebSocket() {
+  const protocol = window.location.protocol === 'https:' ? 'wss:' : 'ws:';
+  const wsUrl = protocol + '//' + window.location.host + '/history/ws';
+
+  try {
+    const ws = new WebSocket(wsUrl);
+
+    ws.onopen = function() {
+      console.log('[History] WebSocket connected');
+      reconnectAttempts = 0;
+      // Disable polling when WS is active
+      clearInterval(autoRefreshTimer);
+    };
+
+    ws.onmessage = function(event) {
+      try {
+        const msg = JSON.parse(event.data);
+        switch (msg.type) {
+          case 'entry_added':
+          case 'entry_updated':
+            loadSessions();
+            loadStats();
+            break;
+          case 'stats_updated':
+            loadStats();
+            break;
+          case 'history_cleared':
+          case 'session_deleted':
+            loadSessions();
+            loadStats();
+            break;
+        }
+      } catch (e) {
+        console.warn('[History] Failed to parse WS message:', e);
+      }
+    };
+
+    ws.onclose = function() {
+      console.log('[History] WebSocket disconnected, falling back to polling');
+      // Re-enable polling as fallback (clear first to avoid duplicates)
+      clearInterval(autoRefreshTimer);
+      autoRefreshTimer = setInterval(() => {
+        loadStats();
+        loadSessions();
+      }, 10000);
+      // Reconnect with exponential backoff, max 10 attempts
+      if (reconnectAttempts < 10) {
+        const delay = Math.min(5000 * Math.pow(2, reconnectAttempts), 60000);
+        reconnectAttempts++;
+        setTimeout(connectWebSocket, delay);
+      }
+    };
+
+    ws.onerror = function() {
+      // Will trigger onclose
+    };
+  } catch (e) {
+    console.warn('[History] WebSocket not available:', e);
+  }
+}
+
+// Start WebSocket connection
+connectWebSocket();
+
 // Tab switching
 function switchTab(tab) {
   document.querySelectorAll('.tab-item').forEach(t => t.classList.remove('active'));
@@ -4741,6 +5397,11 @@ historyRoutes.get("/api/export", handleExport);
 historyRoutes.get("/api/sessions", handleGetSessions);
 historyRoutes.get("/api/sessions/:id", handleGetSession);
 historyRoutes.delete("/api/sessions/:id", handleDeleteSession);
+historyRoutes.get("/ws", (c) => {
+	if (c.req.header("Upgrade") !== "websocket") return c.text("Expected WebSocket upgrade", 426);
+	if (c.env?.server?.upgrade(c.req.raw)) return new Response(null, { status: 101 });
+	return c.text("WebSocket upgrade failed", 500);
+});
 historyRoutes.get("/", (c) => {
 	return c.html(getHistoryUI());
 });
@@ -6192,6 +6853,7 @@ function prependMarkerToAnthropicResponse$1(response, marker) {
 async function handleDirectAnthropicStreamingResponse(opts) {
 	const { stream, response, anthropicPayload, ctx } = opts;
 	const acc = createAnthropicStreamAccumulator();
+	const checkRepetition = createStreamRepetitionChecker(`anthropic:${anthropicPayload.model}`);
 	try {
 		for await (const rawEvent of response) {
 			consola.debug("Direct Anthropic raw stream event:", JSON.stringify(rawEvent));
@@ -6205,6 +6867,7 @@ async function handleDirectAnthropicStreamingResponse(opts) {
 				continue;
 			}
 			processAnthropicEvent(event, acc);
+			if (event.type === "content_block_delta" && event.delta.type === "text_delta") checkRepetition(event.delta.text);
 			await stream.writeSSE({
 				event: rawEvent.event || event.type,
 				data: rawEvent.data
@@ -6404,6 +7067,7 @@ async function handleStreamingResponse(opts) {
 		toolCalls: {}
 	};
 	const acc = createAnthropicStreamAccumulator();
+	const checkRepetition = createStreamRepetitionChecker(`translated:${anthropicPayload.model}`);
 	try {
 		if (ctx.truncateResult?.wasCompacted) {
 			const marker = createTruncationResponseMarkerOpenAI(ctx.truncateResult);
@@ -6415,7 +7079,8 @@ async function handleStreamingResponse(opts) {
 			response,
 			toolNameMapping,
 			streamState,
-			acc
+			acc,
+			checkRepetition
 		});
 		recordStreamingResponse(acc, anthropicPayload.model, ctx);
 		completeTracking(ctx.trackingId, acc.inputTokens, acc.outputTokens, ctx.queueWaitMs);
@@ -6471,7 +7136,7 @@ async function sendTruncationMarkerEvent(stream, streamState, marker) {
 	streamState.contentBlockIndex++;
 }
 async function processStreamChunks(opts) {
-	const { stream, response, toolNameMapping, streamState, acc } = opts;
+	const { stream, response, toolNameMapping, streamState, acc, checkRepetition } = opts;
 	for await (const rawEvent of response) {
 		consola.debug("Copilot raw stream event:", JSON.stringify(rawEvent));
 		if (rawEvent.data === "[DONE]") break;
@@ -6488,6 +7153,7 @@ async function processStreamChunks(opts) {
 		for (const event of events) {
 			consola.debug("Translated Anthropic event:", JSON.stringify(event));
 			processAnthropicEvent(event, acc);
+			if (event.type === "content_block_delta" && event.delta.type === "text_delta") checkRepetition(event.delta.text);
 			await stream.writeSSE({
 				event: event.type,
 				data: JSON.stringify(event)
@@ -6779,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);
@@ -6857,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
@@ -6971,6 +7832,7 @@ async function runServer(options) {
 		consola.info(`History recording enabled (${limitText} entries)`);
 	}
 	initTui({ enabled: true });
+	initRequestContextManager(state.staleRequestMaxAge).startReaper();
 	await ensurePaths();
 	await cacheVSCodeVersion();
 	if (options.githubToken) {
@@ -7010,11 +7872,12 @@ async function runServer(options) {
 		}
 	}
 	consola.box(`🌐 Usage Viewer: https://ericc-ch.github.io/copilot-api?endpoint=${serverUrl}/usage${options.history ? `\n📜 History UI: ${serverUrl}/history` : ""}`);
-	serve({
+	setupShutdownHandlers();
+	setServerInstance(serve({
 		fetch: server.fetch,
 		port: options.port,
 		hostname: options.host
-	});
+	}));
 }
 const start = defineCommand({
 	meta: {

package/package.json

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