xiaodcs-copilot-api 2.3.9-public.3 → 2.5.1-public.2

package/dist/{start-FFVCi8su.js → start-WdcRgBSL.js}

@@ -1,12 +1,13 @@
-import { F as ensurePaths, M as mergeConfigWithDefaults, i as listEnabledProviders } from "./config-SytZjLq8.js";
-import { K as state, S as initOpencodeVersion, _ as copilotModelsHeaders, h as copilotBaseUrl, i as setupCopilotToken, j as getMissingApiKeysMessage, m as readGitHubToken, q as HTTPError, t as logUser } from "./token-D9svRIYW.js";
-import { i as runProviderSetup } from "./auth-BiVetBYt.js";
-import { n as getLatestModelForFamily } from "./models-YMUf33c-.js";
+import { I as mergeConfigWithDefaults, i as listEnabledProviders, t as getProviderConfig, u as isQoderSdkProvider, z as ensurePaths } from "./config-DnMKoKrg.js";
+import { A as getConfiguredApiKeys, K as state, S as initOpencodeVersion, _ as copilotModelsHeaders, h as copilotBaseUrl, i as setupCopilotToken, j as getMissingApiKeysMessage, m as readGitHubToken, q as HTTPError, t as logUser } from "./token-CQftvMU4.js";
+import { i as runProviderSetup } from "./auth-D-M3qCeV.js";
+import { o as forwardProviderModels, u as getLatestModelForFamily } from "./provider-proxy-BbLwvtD_.js";
+import { networkInterfaces } from "node:os";
+import path from "node:path";
+import { createHash, randomUUID } from "node:crypto";
+import { isIP } from "node:net";
 import { defineCommand } from "citty";
 import consola from "consola";
-import { createHash, randomUUID } from "node:crypto";
-import path from "node:path";
-import { networkInterfaces } from "node:os";
 import { getProxyForUrl } from "proxy-from-env";
 import { Agent, ProxyAgent, setGlobalDispatcher } from "undici";
 import { execSync } from "node:child_process";
@@ -64,6 +65,65 @@ function initProxyFromEnv() {
 	}
 }
 //#endregion
+//#region src/lib/server-host-shared.ts
+const INVALID_HOST_CHARACTERS = /[\s/?#]/;
+const NORMALIZED_WILDCARD_HOSTS = new Set(["0.0.0.0", "::"]);
+function stripIpv6Brackets(hostname) {
+	if (hostname.startsWith("[") && hostname.endsWith("]")) return hostname.slice(1, -1);
+	return hostname;
+}
+function normalizeHostnameBase(hostname) {
+	const normalized = stripIpv6Brackets(hostname.trim());
+	if (!normalized || INVALID_HOST_CHARACTERS.test(normalized)) throw new Error(`Invalid server host: ${JSON.stringify(hostname)}`);
+	return normalized;
+}
+function isWildcardHostname(hostname) {
+	return NORMALIZED_WILDCARD_HOSTS.has(stripIpv6Brackets(hostname.trim()));
+}
+//#endregion
+//#region src/lib/server-host.ts
+const DEFAULT_SERVER_HOST = "127.0.0.1";
+function isLoopbackIpv4(hostname) {
+	return isIP(hostname) === 4 && hostname.split(".", 1)[0] === "127";
+}
+function isLoopbackMappedIpv4(hostname) {
+	try {
+		const mappedIpv4 = new URL(`http://[${hostname}]/`).hostname.slice(1, -1).match(/^::ffff:([\da-f]{1,4}):[\da-f]{1,4}$/);
+		if (!mappedIpv4) return false;
+		return (Number.parseInt(mappedIpv4[1], 16) & 65280) === 32512;
+	} catch {
+		return false;
+	}
+}
+function normalizeServerHostname(hostname) {
+	return normalizeHostnameBase(hostname);
+}
+function isLoopbackHostname(hostname) {
+	const normalized = normalizeServerHostname(hostname).toLowerCase();
+	if (normalized === "localhost" || normalized === "localhost.") return true;
+	if (isLoopbackIpv4(normalized)) return true;
+	if (isIP(normalized) !== 6) return false;
+	if (normalized === "::1" || normalized === "0:0:0:0:0:0:0:1") return true;
+	return isLoopbackMappedIpv4(normalized);
+}
+function resolveServerBinding(hostname, hasApiKeys) {
+	const normalizedHostname = normalizeServerHostname(hostname);
+	const networkExposed = !isLoopbackHostname(normalizedHostname);
+	if (networkExposed && !hasApiKeys) throw new Error(`Refusing to listen on non-loopback host ${JSON.stringify(normalizedHostname)} without gateway API keys. Run \`npx copilot-api auth keys --add <key>\` first, or use \`--host ${DEFAULT_SERVER_HOST}\`.`);
+	return {
+		hostname: normalizedHostname,
+		clientHostname: resolveClientHostname(normalizedHostname),
+		networkExposed
+	};
+}
+function resolveClientHostname(hostname) {
+	const normalizedHostname = normalizeServerHostname(hostname);
+	return isWildcardHostname(normalizedHostname) ? DEFAULT_SERVER_HOST : normalizedHostname.toLowerCase();
+}
+function formatServerUrl(hostname, port) {
+	return `http://${isIP(hostname) === 6 ? `[${hostname.replace("%", "%25")}]` : hostname}:${port}`;
+}
+//#endregion
 //#region src/lib/shell.ts
 function getShell() {
 	const { platform, ppid, env } = process$1;
@@ -115,6 +175,33 @@ function generateEnvScript(envVars, commandToRun = "") {
 	return commandBlock || commandToRun;
 }
 //#endregion
+//#region src/services/qoder/startup-models.ts
+async function loadQoderStartupModels(provider, fetchModels = forwardProviderModels, bunVersion = process.versions.bun) {
+	if (!provider || !isQoderSdkProvider(provider)) return { models: [] };
+	if (bunVersion) return {
+		models: [],
+		warning: "Qoder SDK Worker is not supported by this Bun startup path. Use `bun run start` (builds and runs with Node), or `node dist/main.js start`."
+	};
+	try {
+		const response = await fetchModels(provider, new Headers());
+		if (!response.ok) return {
+			models: [],
+			warning: `Qoder model discovery failed (HTTP ${response.status}). Check PAT and SDK runtime.`
+		};
+		const body = await response.json();
+		const models = Array.isArray(body.data) ? body.data.flatMap((m) => typeof m?.id === "string" && m.id.trim() ? [`qoder/${m.id}`] : []) : [];
+		return models.length ? { models } : {
+			models: [],
+			warning: "Qoder returned no available models."
+		};
+	} catch {
+		return {
+			models: [],
+			warning: "Qoder model discovery failed. Check PAT, SDK runtime and network settings."
+		};
+	}
+}
+//#endregion
 //#region src/services/copilot/get-models.ts
 const getModels = async () => {
 	consola.info(`Fetching models from ${copilotBaseUrl(state)}/models`);
@@ -447,9 +534,11 @@ async function setupProviderMode(serverUrl, claudeCode) {
 	consola.info(`Configured providers: ${providersAfterSetup.join(", ")}`);
 }
 async function runServer(options) {
-	(await import("./tls-Aq1Dd8E2.js")).enableSystemCACompat();
+	(await import("./tls-B5VJAJJM.js")).enableSystemCACompat();
 	consola.options.throttle = 0;
 	mergeConfigWithDefaults();
+	const configuredApiKeys = getConfiguredApiKeys();
+	const binding = resolveServerBinding(options.host, configuredApiKeys.length > 0);
 	const missingApiKeysMessage = getMissingApiKeysMessage();
 	if (missingApiKeysMessage) consola.info(missingApiKeysMessage);
 	await initOpencodeVersion();
@@ -461,14 +550,18 @@ async function runServer(options) {
 	}
 	state.showToken = options.showToken;
 	await ensurePaths();
-	const serverUrl = `http://localhost:${options.port}`;
+	const serverUrl = formatServerUrl(binding.clientHostname, options.port);
 	const githubToken = options.githubToken || await readGitHubToken();
 	if (githubToken) await setupCopilotMode(githubToken, Boolean(options.githubToken), serverUrl, options.claudeCode);
 	else await setupProviderMode(serverUrl, options.claudeCode);
+	const qoder = await loadQoderStartupModels(getProviderConfig("qoder"));
+	if (qoder.warning) consola.warn(qoder.warning);
+	if (qoder.models.length) consola.info(`Qoder models (${qoder.models.length}):\n${qoder.models.map((model) => `- ${model}`).join("\n")}`);
 	consola.box(`🌐 Usage Viewer: ${serverUrl}/usage-viewer?endpoint=${serverUrl}/usage`);
-	const { server } = await import("./server-CFQmvoAJ.js");
+	const { createServer } = await import("./server-DmKNMBLd.js");
 	serve({
-		fetch: server.fetch,
+		fetch: createServer({ networkExposed: binding.networkExposed }).fetch,
+		hostname: binding.hostname,
 		port: options.port,
 		bun: { idleTimeout: 0 }
 	});
@@ -479,6 +572,11 @@ const start = defineCommand({
 		description: "Start the Copilot API server"
 	},
 	args: {
+		host: {
+			type: "string",
+			default: process.env.HOST?.trim() || "127.0.0.1",
+			description: "Host to listen on"
+		},
 		port: {
 			alias: "p",
 			type: "string",
@@ -515,6 +613,7 @@ const start = defineCommand({
 	},
 	run({ args }) {
 		return runServer({
+			host: args.host,
 			port: Number.parseInt(args.port, 10),
 			verbose: args.verbose,
 			githubToken: args["github-token"],

package/dist/{token-D9svRIYW.js → token-CQftvMU4.js}

@@ -1,8 +1,8 @@
-import { E as getResponsesTransportConfig, P as PATHS, c as setProviderConfig, j as isResponsesApiWebSocketEnabled, n as getRawProviderConfig, w as getConfig } from "./config-SytZjLq8.js";
-import consola from "consola";
-import { createHash, randomBytes, randomUUID } from "node:crypto";
-import path from "node:path";
+import { A as isCodexResponsesApiWebSocketEnabled, B as writeFileAtomically, E as getConfig, O as getResponsesTransportConfig, R as PATHS, c as setProviderConfig, n as getRawProviderConfig } from "./config-DnMKoKrg.js";
 import fs, { readFile } from "node:fs/promises";
+import path from "node:path";
+import { createHash, randomBytes, randomUUID } from "node:crypto";
+import consola from "consola";
 import { createServer } from "node:http";
 import { getProxyForUrl } from "proxy-from-env";
 import { WebSocket } from "undici";
@@ -142,6 +142,7 @@ const runPooledWebSocketRequest = async function* (request, options) {
 		throwIfAborted(request.signal);
 		messageStream = createWebSocketMessageStream(websocket, request.signal, options);
 		messageStream.start();
+		options.onBeforeSend?.();
 		websocket.send(JSON.stringify(request.payload));
 		for await (const data of messageStream.iterable) {
 			const chunk = options.createChunk(data);
@@ -785,7 +786,7 @@ function buildCodexRequestHeaders(requestHeaders) {
 	return headers;
 }
 function resolveCodexResponsesTransport(transport) {
-	return transport ?? (isResponsesApiWebSocketEnabled() ? "websocket" : "http");
+	return transport ?? (isCodexResponsesApiWebSocketEnabled() ? "websocket" : "http");
 }
 function buildCodexResponsesWebSocketHeaders(requestHeaders) {
 	const headers = buildCodexResponsesHeaders(requestHeaders);
@@ -818,6 +819,11 @@ async function forwardCodexResponses(payload, requestHeaders, baseUrl = CODEX_AP
 	consola.log(`<-- model: ${payload.model}`);
 	const transport = resolveCodexResponsesTransport(options.transport);
 	if (payload.stream && transport === "websocket") return forwardCodexResponsesOverWebSocket(payload, requestHeaders, baseUrl, options.signal);
+	const response = await fetchCodexResponsesOverHttp(payload, requestHeaders, baseUrl, options.signal);
+	if (payload.stream) return createResponsesSafeStream(createResponsesHttpEventStream(response, options.signal), { signal: options.signal });
+	return await response.json();
+}
+const fetchCodexResponsesOverHttp = async (payload, requestHeaders, baseUrl, signal) => {
 	const normalizedPayload = normalizeCodexResponsesPayload(payload);
 	const transportConfig = getResponsesTransportConfig();
 	const response = await fetchResponsesWithLifecycle(resolveCodexResponsesUrl(baseUrl), {
@@ -826,13 +832,12 @@ async function forwardCodexResponses(payload, requestHeaders, baseUrl = CODEX_AP
 		body: JSON.stringify(normalizedPayload)
 	}, {
 		headersTimeoutMs: transportConfig.headersTimeoutMs,
-		signal: options.signal,
+		signal,
 		streamInactivityTimeoutMs: transportConfig.streamInactivityTimeoutMs
 	});
 	if (!response.ok) throw new HTTPError("Failed to create codex responses", response);
-	if (normalizedPayload.stream) return createResponsesSafeStream(createResponsesHttpEventStream(response, options.signal), { signal: options.signal });
-	return await response.json();
-}
+	return response;
+};
 const normalizeCodexResponsesPayload = (payload) => {
 	const normalizedPayload = {
 		...payload,
@@ -897,22 +902,36 @@ const buildCodexResponsesWebSocketPoolKey = (payload, headers, baseUrl) => {
 	].map(encodePoolKeyPart).join("|");
 };
 const forwardCodexResponsesOverWebSocket = (payload, requestHeaders, baseUrl, signal) => {
-	return createCodexResponsesWebSocketStream(prepareCodexResponsesWebSocketRequest(payload, requestHeaders, baseUrl, signal));
+	return createResponsesSafeStream(createCodexResponsesStreamWithFallback(prepareCodexResponsesWebSocketRequest(payload, requestHeaders, baseUrl, signal), payload, requestHeaders, baseUrl), { signal });
 };
-const createCodexResponsesWebSocketStream = (request) => {
+const createCodexResponsesStreamWithFallback = async function* (request, payload, requestHeaders, baseUrl) {
+	let sendAttempted = false;
+	try {
+		yield* createCodexResponsesWebSocketStream(request, () => {
+			sendAttempted = true;
+		});
+		return;
+	} catch (error) {
+		if (sendAttempted || request.signal?.aborted || error instanceof Error && error.name === "AbortError" || payload.previous_response_id != null || payload.conversation != null) throw error;
+		consola.warn("Codex websocket failed before sending the request; falling back to HTTP once");
+	}
+	yield* createResponsesHttpEventStream(await fetchCodexResponsesOverHttp(payload, requestHeaders, baseUrl, request.signal), request.signal);
+};
+const createCodexResponsesWebSocketStream = (request, onBeforeSend) => {
 	const transportConfig = getResponsesTransportConfig();
-	return createResponsesSafeStream(createPooledWebSocketStream(request, {
+	return createPooledWebSocketStream(request, {
 		createChunk: createCodexResponsesWebSocketStreamChunk,
 		maxBufferedBytes: transportConfig.websocketMaxBufferedBytes,
 		maxBufferedMessages: transportConfig.websocketMaxBufferedMessages,
 		isTerminalChunk: isTerminalResponsesStreamChunk,
 		openErrorMessage: "Failed to create codex responses websocket",
 		openTimeoutMs: transportConfig.websocketOpenTimeoutMs,
+		onBeforeSend,
 		poolIdleTimeoutMs: transportConfig.websocketPoolIdleTimeoutMs,
 		streamInactivityTimeoutMs: transportConfig.streamInactivityTimeoutMs,
 		streamErrorMessage: "Upstream connection lost, Codex responses websocket stream error",
 		terminalChunkMissingMessage: "Codex responses websocket ended without a terminal response, retry your request."
-	}), { signal: request.signal });
+	});
 };
 const createCodexResponsesWebSocketStreamChunk = (data) => {
 	if (data === "[DONE]") return { data };
@@ -1080,7 +1099,7 @@ async function exchangeAuthorizationCode(code, verifier) {
 		throw new Error(`Codex token exchange failed (${response.status}): ${details || response.statusText}`);
 	}
 	const payload = await response.json();
-	if (typeof payload.access_token !== "string" || typeof payload.refresh_token !== "string" || typeof payload.expires_in !== "number") throw new TypeError(`Codex token exchange response missing fields: ${JSON.stringify(payload)}`);
+	if (typeof payload.access_token !== "string" || typeof payload.refresh_token !== "string" || typeof payload.expires_in !== "number") throw new TypeError("Codex token exchange response missing required fields");
 	return {
 		accessToken: payload.access_token,
 		refreshToken: payload.refresh_token,
@@ -1102,7 +1121,7 @@ async function refreshAccessToken(refreshToken) {
 		throw new Error(`Codex token refresh failed (${response.status}): ${details || response.statusText}`);
 	}
 	const payload = await response.json();
-	if (typeof payload.access_token !== "string" || typeof payload.refresh_token !== "string" || typeof payload.expires_in !== "number") throw new TypeError(`Codex token refresh response missing fields: ${JSON.stringify(payload)}`);
+	if (typeof payload.access_token !== "string" || typeof payload.refresh_token !== "string" || typeof payload.expires_in !== "number") throw new TypeError("Codex token refresh response missing required fields");
 	return {
 		accessToken: payload.access_token,
 		refreshToken: payload.refresh_token,
@@ -1565,14 +1584,8 @@ async function readOptionalFile(filePath) {
 		throw error;
 	}
 }
-async function writeProtectedFile(filePath, content) {
-	await fs.mkdir(path.dirname(filePath), { recursive: true });
-	await fs.writeFile(filePath, content, "utf8");
-	try {
-		await fs.chmod(filePath, 384);
-	} catch {
-		return;
-	}
+function writeProtectedFile(filePath, content) {
+	return Promise.resolve().then(() => writeFileAtomically(filePath, content));
 }
 function normalizeCodexCredentials(credentials) {
 	if (!credentials || typeof credentials !== "object") return null;
@@ -1744,7 +1757,7 @@ async function pollAccessToken(deviceCode) {
 			continue;
 		}
 		const json = await response.json();
-		consola.debug("Polling access token response:", json);
+		consola.debug("Polling access token response received");
 		const { access_token } = json;
 		if (access_token) return access_token;
 		else await sleep(sleepDuration);
@@ -1754,6 +1767,10 @@ async function pollAccessToken(deviceCode) {
 //#region src/lib/token.ts
 let copilotRefreshLoopController = null;
 let codexRefreshLoopController = null;
+const defaultCopilotTokenDependencies = {
+	getCopilotToken,
+	getCopilotUsage
+};
 const stopCopilotRefreshLoop = () => {
 	if (!copilotRefreshLoopController) return;
 	copilotRefreshLoopController.abort();
@@ -1801,7 +1818,7 @@ const applyCopilotTokenResponse = (response) => {
 	state.copilotToken = response.token;
 	if (response.endpoints?.api) state.copilotApiUrl = response.endpoints.api;
 };
-const setupCopilotToken = async () => {
+const setupCopilotToken = async (dependencies = defaultCopilotTokenDependencies) => {
 	if (isOpencodeOauthApp()) {
 		if (!state.githubToken) throw new Error(`opencode token not found`);
 		state.copilotToken = state.githubToken;
@@ -1810,14 +1827,14 @@ const setupCopilotToken = async () => {
 		stopCopilotRefreshLoop();
 		return;
 	}
-	const response = await getCopilotToken();
+	const response = await dependencies.getCopilotToken();
 	applyCopilotTokenResponse(response);
 	consola.debug("GitHub Copilot Token fetched successfully!");
 	if (state.showToken) consola.info("Copilot token:", state.copilotToken);
 	stopCopilotRefreshLoop();
 	const controller = new AbortController();
 	copilotRefreshLoopController = controller;
-	runCopilotRefreshLoop(response.refresh_in, controller.signal).catch(() => {
+	runCopilotRefreshLoop(response.refresh_in, controller.signal, dependencies).catch(() => {
 		consola.warn("Copilot token refresh loop stopped");
 	}).finally(() => {
 		if (copilotRefreshLoopController === controller) copilotRefreshLoopController = null;
@@ -1856,7 +1873,7 @@ const RETRY_REFRESH_JITTER_MS = 15e3;
 const MIN_REFRESH_DELAY_MS = 1e3;
 const getRefreshDeadlineMs = (refreshIn, nowMs = Date.now()) => nowMs + Math.max(refreshIn * 1e3 - EARLY_REFRESH_BUFFER_MS, MIN_REFRESH_DELAY_MS);
 const getRefreshPollDelayMs = (refreshAtMs, nowMs = Date.now()) => Math.min(Math.max(refreshAtMs - nowMs, 0), REFRESH_POLL_INTERVAL_MS);
-const runCopilotRefreshLoop = async (refreshIn, signal) => {
+const runCopilotRefreshLoop = async (refreshIn, signal, dependencies) => {
 	let refreshAtMs = getRefreshDeadlineMs(refreshIn);
 	let retryDelayMs = RETRY_REFRESH_DELAY_MS;
 	while (!signal.aborted) {
@@ -1867,7 +1884,7 @@ const runCopilotRefreshLoop = async (refreshIn, signal) => {
 		}
 		consola.debug("Refreshing Copilot token");
 		try {
-			const response = await getCopilotToken();
+			const response = await dependencies.getCopilotToken();
 			applyCopilotTokenResponse(response);
 			refreshAtMs = getRefreshDeadlineMs(response.refresh_in);
 			retryDelayMs = RETRY_REFRESH_DELAY_MS;
@@ -1938,8 +1955,8 @@ async function setupGitHubToken(options) {
 		throw error;
 	}
 }
-async function logUser() {
-	const copilotUser = await getCopilotUsage();
+async function logUser(dependencies = defaultCopilotTokenDependencies) {
+	const copilotUser = await dependencies.getCopilotUsage();
 	if (!copilotUser) throw new Error("GitHub token not found");
 	state.userName = copilotUser.login;
 	consola.info(`Logged in as ${copilotUser.login}`);

package/dist/transport-DE8Q0wU-.js

@@ -0,0 +1,252 @@
+import { d as BridgeError, n as parseChat, r as publicError, t as completionIdentity } from "./protocol-BTFLbI8m.js";
+import { randomBytes, timingSafeEqual } from "node:crypto";
+import { Hono } from "hono";
+import { streamSSE } from "hono/streaming";
+import { bodyLimit } from "hono/body-limit";
+//#region qoder-bridge/app.ts
+function authorized(header, key) {
+	const actual = Buffer.from(header ?? "");
+	const expected = Buffer.from(`Bearer ${key}`);
+	return actual.length === expected.length && timingSafeEqual(actual, expected);
+}
+function abortable(promise, signal) {
+	return new Promise((resolve, reject) => {
+		const abort = () => reject(signal.reason instanceof Error ? signal.reason : new BridgeError("Request cancelled", 502, "cancelled"));
+		if (signal.aborted) {
+			abort();
+			return;
+		}
+		signal.addEventListener("abort", abort, { once: true });
+		promise.then(resolve, reject).finally(() => signal.removeEventListener("abort", abort)).catch(() => {});
+	});
+}
+function createBridge(backend, options) {
+	if (!options.apiKey.trim()) throw new Error("QODER_BRIDGE_API_KEY is required");
+	const app = new Hono();
+	let active = 0;
+	app.get("/health", (c) => c.json({
+		status: "ok",
+		service: "qoder-bridge",
+		capabilities: [
+			"text",
+			"image-input",
+			"chat-completions",
+			"client-tool-calls",
+			"streaming",
+			"models",
+			"credits"
+		]
+	}));
+	app.use("*", async (c, next) => {
+		if (!authorized(c.req.header("authorization"), options.apiKey)) return c.json({ error: {
+			message: "Invalid bridge API key",
+			type: "authentication_error"
+		} }, 401);
+		await next();
+	});
+	app.use("*", bodyLimit({
+		maxSize: options.maxBodyBytes ?? 23068672,
+		onError: (c) => c.json({ error: {
+			message: "Request body too large",
+			type: "invalid_request_error"
+		} }, 413)
+	}));
+	app.onError((error, c) => {
+		const failure = publicError(error);
+		return c.json({ error: {
+			message: failure.message,
+			type: failure.code
+		} }, failure.status);
+	});
+	function lease(signal) {
+		if (active >= (options.maxConcurrent ?? 2)) throw new BridgeError("Qoder bridge is busy", 429, "rate_limit_error");
+		active++;
+		const controller = new AbortController();
+		const abort = () => controller.abort(signal.reason);
+		signal.addEventListener("abort", abort, { once: true });
+		if (signal.aborted) abort();
+		const timer = setTimeout(() => controller.abort(new BridgeError("Qoder request timed out", 504, "timeout")), options.timeoutMs ?? 12e4);
+		let released = false;
+		return {
+			signal: controller.signal,
+			abort: () => controller.abort(),
+			release: () => {
+				if (released) return;
+				released = true;
+				clearTimeout(timer);
+				signal.removeEventListener("abort", abort);
+				active--;
+			}
+		};
+	}
+	for (const path of ["/v1/models", "/usage"]) app.get(path, async (c) => {
+		const session = lease(c.req.raw.signal);
+		try {
+			const result = await abortable(backend.catalog(session.signal), session.signal);
+			if (path === "/usage") return c.json({
+				provider: "qoder",
+				usage: result.usage
+			});
+			return c.json({
+				object: "list",
+				data: result.models.map((m) => ({
+					...m,
+					id: m.id,
+					object: "model",
+					created: 0,
+					owned_by: "qoder",
+					name: m.name ?? m.id
+				}))
+			});
+		} finally {
+			session.release();
+		}
+	});
+	app.post("/v1/chat/completions", async (c) => {
+		let json;
+		try {
+			json = await c.req.json();
+		} catch {
+			throw new BridgeError("Invalid JSON request");
+		}
+		const input = parseChat(json);
+		const session = lease(c.req.raw.signal);
+		const identity = completionIdentity(input.model);
+		const iterator = backend.turn(input, session.signal)[Symbol.asyncIterator]();
+		async function* consume() {
+			try {
+				let completed = false;
+				while (true) {
+					const item = await abortable(iterator.next(), session.signal);
+					if (item.done) break;
+					if (completed) throw new BridgeError("Qoder sent data after completion", 502, "invalid_stream");
+					completed = item.value.type === "complete";
+					yield item.value;
+				}
+				if (!completed) throw new BridgeError("Qoder stream ended before completion", 502, "incomplete_stream");
+			} finally {
+				session.abort();
+				iterator.return?.().catch(() => {});
+				session.release();
+			}
+		}
+		if (input.stream) return streamSSE(c, async (stream) => {
+			stream.onAbort(session.abort);
+			const chunk = (choices, extra = {}) => JSON.stringify({
+				...identity,
+				object: "chat.completion.chunk",
+				choices,
+				...extra
+			});
+			try {
+				await stream.writeSSE({ data: chunk([{
+					index: 0,
+					delta: { role: "assistant" },
+					finish_reason: null
+				}]) });
+				let info;
+				let hasTools = false;
+				for await (const event of consume()) if (event.type === "text") await stream.writeSSE({ data: chunk([{
+					index: 0,
+					delta: { content: event.text },
+					finish_reason: null
+				}]) });
+				else if (event.type === "tool_calls") {
+					hasTools = true;
+					await stream.writeSSE({ data: chunk([{
+						index: 0,
+						delta: { tool_calls: event.calls.map((call, index) => ({
+							...call,
+							index
+						})) },
+						finish_reason: null
+					}]) });
+				} else info = event.info;
+				await stream.writeSSE({ data: chunk([{
+					index: 0,
+					delta: {},
+					finish_reason: hasTools ? "tool_calls" : "stop"
+				}], { qoder_usage: info?.qoder_usage }) });
+				if (input.includeUsage) await stream.writeSSE({ data: chunk([], {
+					usage: info?.usage ?? null,
+					qoder_usage: info?.qoder_usage
+				}) });
+				await stream.writeSSE({ data: "[DONE]" });
+			} catch (error) {
+				const failure = publicError(error);
+				if (!stream.aborted) await stream.writeSSE({ data: JSON.stringify({ error: {
+					message: failure.message,
+					type: failure.code
+				} }) });
+			} finally {
+				session.abort();
+				session.release();
+			}
+		});
+		let text = "";
+		let calls = [];
+		let info;
+		for await (const event of consume()) if (event.type === "text") text += event.text;
+		else if (event.type === "tool_calls") calls = event.calls;
+		else info = event.info;
+		return c.json({
+			...identity,
+			object: "chat.completion",
+			choices: [{
+				index: 0,
+				message: {
+					role: "assistant",
+					content: text || null,
+					...calls.length ? { tool_calls: calls } : {}
+				},
+				finish_reason: calls.length ? "tool_calls" : "stop"
+			}],
+			...info
+		});
+	});
+	return app;
+}
+//#endregion
+//#region src/services/qoder/transport.ts
+async function sdkBackend(token) {
+	const { createBackend } = await import("./runtime-CWU5BNBf.js");
+	return createBackend(void 0, token);
+}
+function createQoderTransport(loadBackend = sdkBackend) {
+	let current;
+	const localKey = randomBytes(32).toString("hex");
+	return async (provider, path, init = {}) => {
+		const token = provider.apiKey.trim();
+		if (!token) return Response.json({ error: {
+			message: "Configure Qoder with auth login --provider qoder",
+			type: "authentication_error"
+		} }, { status: 401 });
+		if (!current || current.token !== token) {
+			const entry = {
+				token,
+				app: loadBackend(token).then((backend) => createBridge(backend, { apiKey: localKey }))
+			};
+			current = entry;
+			entry.app.catch(() => {
+				if (current === entry) current = void 0;
+			});
+		}
+		try {
+			const app = await current.app;
+			const headers = new Headers(init.headers);
+			headers.set("authorization", `Bearer ${localKey}`);
+			return await app.fetch(new Request(`http://qoder.internal${path}`, {
+				...init,
+				headers
+			}));
+		} catch {
+			return Response.json({ error: {
+				message: "Qoder SDK could not start. Reinstall the package with npm install scripts enabled, then retry.",
+				type: "qoder_runtime_error"
+			} }, { status: 502 });
+		}
+	};
+}
+const forwardQoder = createQoderTransport();
+//#endregion
+export { forwardQoder as n, createQoderTransport as t };

package/dist/transport-HOWgkXsv.js

@@ -0,0 +1,2 @@
+import { n as forwardQoder } from "./transport-DE8Q0wU-.js";
+export { forwardQoder };