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

package/dist/runtime-CWU5BNBf.js

@@ -0,0 +1,442 @@
+import { c as makeImage, d as BridgeError, f as record, l as validateImageUrl, s as decodeDataImage, u as clientToolServer } from "./protocol-BTFLbI8m.js";
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { accessToken, qodercliAuth, query } from "@qoder-ai/qoder-agent-sdk";
+import { lookup } from "node:dns/promises";
+import { request } from "node:https";
+import { BlockList, isIP } from "node:net";
+import { Readable } from "node:stream";
+//#region qoder-bridge/model-policy.ts
+function qoderModelPolicy(input) {
+	return (context) => {
+		const model = context.availableModels.find((m) => m.value === input.model);
+		if (input.contextWindow && !model?.availableContextWindows?.includes(input.contextWindow)) throw new BridgeError("Unsupported Qoder context window");
+		const efforts = model?.efforts ?? [];
+		let effort = input.reasoningEffort;
+		if (!efforts.length || effort === "none") effort = void 0;
+		else if (effort && !efforts.includes(effort)) {
+			if (![
+				"ultra",
+				"max",
+				"xhigh"
+			].includes(effort)) throw new BridgeError("Unsupported Qoder reasoning effort");
+			effort = [
+				"max",
+				"xhigh",
+				"high",
+				"medium",
+				"low"
+			].find((e) => efforts.includes(e));
+			if (!effort) throw new BridgeError("Unsupported Qoder reasoning effort");
+		}
+		return {
+			model: input.model,
+			parameters: {
+				...input.contextWindow ? { contextWindow: input.contextWindow } : {},
+				...effort ? { reasoningEffort: effort } : {}
+			}
+		};
+	};
+}
+//#endregion
+//#region qoder-bridge/remote-images.ts
+const denied = new BlockList();
+for (const [address, prefix] of [
+	["0.0.0.0", 8],
+	["10.0.0.0", 8],
+	["100.64.0.0", 10],
+	["127.0.0.0", 8],
+	["169.254.0.0", 16],
+	["172.16.0.0", 12],
+	["192.0.0.0", 24],
+	["192.0.2.0", 24],
+	["192.88.99.0", 24],
+	["192.168.0.0", 16],
+	["198.18.0.0", 15],
+	["198.51.100.0", 24],
+	["203.0.113.0", 24],
+	["224.0.0.0", 4],
+	["240.0.0.0", 4]
+]) denied.addSubnet(address, prefix, "ipv4");
+for (const [address, prefix] of [
+	["2001::", 23],
+	["2001:db8::", 32],
+	["2002::", 16],
+	["3fff::", 20]
+]) denied.addSubnet(address, prefix, "ipv6");
+function isPublicAddress(address) {
+	const family = isIP(address);
+	if (family === 4) return !denied.check(address, "ipv4");
+	return family === 6 && /^[23][0-9a-f]{3}:/i.test(address) && !denied.check(address, "ipv6");
+}
+function fetchPinned(url, address, signal, send = request) {
+	return new Promise((resolve, reject) => {
+		const hostname = url.hostname.replace(/^\[|\]$/g, "");
+		const req = send({
+			hostname: address,
+			port: 443,
+			servername: isIP(hostname) ? void 0 : hostname,
+			path: url.pathname + url.search,
+			method: "GET",
+			headers: {
+				host: url.host,
+				accept: "image/png,image/jpeg,image/webp,image/gif"
+			},
+			agent: false,
+			signal
+		}, (response) => {
+			const headers = new Headers();
+			for (const [key, value] of Object.entries(response.headers)) if (value !== void 0) headers.set(key, Array.isArray(value) ? value.join(",") : value);
+			try {
+				const status = response.statusCode ?? 502;
+				const empty = [
+					204,
+					205,
+					304
+				].includes(status);
+				if (empty) response.resume();
+				resolve(new Response(empty ? null : Readable.toWeb(response), {
+					status,
+					headers
+				}));
+			} catch (error) {
+				response.destroy();
+				reject(error instanceof Error ? error : /* @__PURE__ */ new Error("Invalid image response"));
+			}
+		});
+		req.on("error", reject);
+		req.end();
+	});
+}
+function resolveImageHost(hostname) {
+	return lookup(hostname, { all: true });
+}
+const defaults = {
+	resolve: resolveImageHost,
+	fetchPinned
+};
+async function loadRemoteImage(raw, signal, deps = defaults) {
+	const bounded = AbortSignal.any([signal, AbortSignal.timeout(15e3)]);
+	let url = validateImageUrl(raw);
+	try {
+		for (let redirects = 0; redirects <= 3; redirects++) {
+			bounded.throwIfAborted();
+			const hostname = url.hostname.replace(/^\[|\]$/g, "");
+			const addresses = await deps.resolve(hostname);
+			bounded.throwIfAborted();
+			if (!addresses.length || addresses.some((item) => !isPublicAddress(item.address))) throw new BridgeError("Image URL must resolve exclusively to public IP addresses");
+			const response = await deps.fetchPinned(url, addresses[0].address, bounded);
+			if ([
+				301,
+				302,
+				303,
+				307,
+				308
+			].includes(response.status)) {
+				await response.body?.cancel();
+				const location = response.headers.get("location");
+				if (!location || redirects === 3) throw new BridgeError("Image URL redirect limit exceeded or missing location");
+				url = validateImageUrl(new URL(location, url).href);
+				continue;
+			}
+			if (!response.ok) {
+				await response.body?.cancel();
+				throw new BridgeError("Image URL returned an unsuccessful HTTP status");
+			}
+			if (Number(response.headers.get("content-length")) > 5242880) {
+				await response.body?.cancel();
+				throw new BridgeError("Image exceeds the 5 MiB limit", 413);
+			}
+			if (!response.body) throw new BridgeError("Image URL returned an empty body");
+			const reader = response.body.getReader();
+			const chunks = [];
+			let size = 0;
+			try {
+				while (true) {
+					bounded.throwIfAborted();
+					const { done, value } = await reader.read();
+					if (done) break;
+					size += value.byteLength;
+					if (size > 5242880) throw new BridgeError("Image exceeds the 5 MiB limit", 413);
+					chunks.push(value);
+				}
+			} finally {
+				await reader.cancel().catch(() => {});
+				reader.releaseLock();
+			}
+			return makeImage(Buffer.concat(chunks), response.headers.get("content-type")?.split(";", 1)[0].trim() ?? "");
+		}
+		throw new BridgeError("Image URL redirect limit exceeded");
+	} catch (error) {
+		if (error instanceof BridgeError) throw error;
+		throw new BridgeError(bounded.aborted ? "Image download cancelled or timed out" : "Image download failed");
+	}
+}
+//#endregion
+//#region qoder-bridge/image-prompt.ts
+async function buildSdkPrompt(input, signal, download = loadRemoteImage) {
+	if (!input.images?.length) return input.prompt;
+	const content = [{
+		type: "text",
+		text: input.prompt
+	}];
+	let total = 0;
+	for (const item of input.images) {
+		signal.throwIfAborted();
+		const image = item.url.startsWith("data:") ? decodeDataImage(item.url) : await download(item.url, signal);
+		total += Buffer.from(image.source.data, "base64").byteLength;
+		if (total > 15728640) throw new BridgeError("Combined images exceed the 15 MiB limit", 413);
+		content.push({
+			type: "text",
+			text: `[${item.label}]`
+		}, image);
+	}
+	return (async function* () {
+		signal.throwIfAborted();
+		yield {
+			type: "user",
+			message: {
+				role: "user",
+				content
+			},
+			parent_tool_use_id: null
+		};
+	})();
+}
+//#endregion
+//#region qoder-bridge/runtime.ts
+function sdkOptions(cwd, controller, personalAccessToken) {
+	const token = (personalAccessToken ?? process.env.QODER_PERSONAL_ACCESS_TOKEN)?.trim();
+	return {
+		auth: token ? accessToken(token) : qodercliAuth(),
+		cwd,
+		abortController: controller,
+		tools: [],
+		allowedTools: [],
+		skills: [],
+		plugins: [],
+		extensions: [],
+		agents: {},
+		mcpServers: {},
+		allowedMcpServerNames: [],
+		strictMcpConfig: true,
+		settingSources: [],
+		persistSession: false,
+		includePartialMessages: true,
+		maxTurns: 1,
+		permissionMode: "default",
+		canUseTool: () => Promise.resolve({
+			behavior: "deny",
+			message: "Tools are disabled in this gateway"
+		}),
+		memory: {
+			mode: "custom",
+			projectScope: false,
+			userScope: false,
+			generation: { enabled: false },
+			consumption: { enabled: false }
+		},
+		evolution: { skill: {
+			mode: "custom",
+			generation: { enabled: false }
+		} },
+		proxy: process.env.QODER_PROXY ?? process.env.HTTPS_PROXY ?? process.env.HTTP_PROXY,
+		...process.env.QODERCLI_PATH ? { pathToQoderCLIExecutable: process.env.QODERCLI_PATH } : {}
+	};
+}
+var EventTranslator = class {
+	clientNames;
+	constructor(clientNames = /* @__PURE__ */ new Map()) {
+		this.clientNames = clientNames;
+	}
+	streamed = false;
+	completed = false;
+	*accept(value) {
+		if (this.completed) return;
+		const message = record(value);
+		if (message.type === "stream_event") {
+			const event = record(message.event);
+			if (event.type === "message_start") this.streamed = false;
+			const delta = record(event.delta);
+			if (delta.type === "text_delta" && typeof delta.text === "string") {
+				this.streamed = true;
+				yield {
+					type: "text",
+					text: delta.text
+				};
+			}
+			if (record(event.content_block).type === "tool_use" && !this.clientNames.has(String(record(event.content_block).name))) throw new BridgeError("Qoder attempted an unsupported tool call", 502, "unsupported_tool_call");
+		}
+		if (message.type === "assistant") {
+			const content = record(message.message).content;
+			const calls = [];
+			if (Array.isArray(content)) for (const part of content) {
+				const block = record(part);
+				if (block.type === "tool_use" && this.clientNames.has(String(block.name))) {
+					if (typeof block.id !== "string") throw new BridgeError("Qoder tool call is missing an id", 502);
+					calls.push({
+						id: block.id,
+						type: "function",
+						function: {
+							name: this.clientNames.get(String(block.name)),
+							arguments: JSON.stringify(block.input ?? {})
+						}
+					});
+					continue;
+				}
+				if (block.type === "tool_use") throw new BridgeError("Qoder attempted an unsupported tool call", 502, "unsupported_tool_call");
+				if (!this.streamed && block.type === "text" && typeof block.text === "string") yield {
+					type: "text",
+					text: block.text
+				};
+			}
+			if (calls.length) yield {
+				type: "tool_calls",
+				calls
+			};
+		}
+		if (message.type === "result") {
+			if (message.subtype !== "success" || message.is_error === true) throw new BridgeError("Qoder did not complete the request successfully", 502, "qoder_result_error");
+			this.completed = true;
+			const info = { qoder_usage: {} };
+			if (typeof message.total_credits === "number" && Number.isFinite(message.total_credits) && message.total_credits >= 0) info.qoder_usage.total_credits = message.total_credits;
+			if (message.modelUsage) info.qoder_usage.model_usage = record(message.modelUsage);
+			const usage = record(message.usage);
+			const counters = [
+				usage.input_tokens,
+				usage.output_tokens,
+				usage.cache_read_input_tokens ?? 0,
+				usage.cache_creation_input_tokens ?? 0
+			];
+			if (counters.every((n) => typeof n === "number" && Number.isFinite(n) && n >= 0)) {
+				const [input, output, cacheRead, cacheWrite] = counters;
+				if (input + output + cacheRead + cacheWrite > 0) info.usage = {
+					prompt_tokens: input + cacheRead + cacheWrite,
+					completion_tokens: output,
+					total_tokens: input + output + cacheRead + cacheWrite
+				};
+			}
+			yield {
+				type: "complete",
+				info
+			};
+		}
+	}
+	assertComplete() {
+		if (!this.completed) throw new BridgeError("Qoder stream ended without a successful result", 502, "incomplete_stream");
+	}
+};
+async function workspace(signal, token) {
+	signal.throwIfAborted();
+	const cwd = await mkdtemp(join(tmpdir(), "copilot-qoder-"));
+	const controller = new AbortController();
+	const abort = () => controller.abort(signal.reason);
+	signal.addEventListener("abort", abort, { once: true });
+	if (signal.aborted) abort();
+	return {
+		options: sdkOptions(cwd, controller, token),
+		cleanup: async () => {
+			signal.removeEventListener("abort", abort);
+			await rm(cwd, {
+				recursive: true,
+				force: true
+			});
+		}
+	};
+}
+function createBackend(runQuery = query, token) {
+	return {
+		async catalog(signal) {
+			const session = await workspace(signal, token);
+			let release = () => {};
+			const idle = new Promise((resolve) => {
+				release = resolve;
+			});
+			let q;
+			try {
+				q = runQuery({
+					prompt: (async function* () {
+						await idle;
+					})(),
+					options: session.options
+				});
+				await q.initializationResult();
+				const models = await q.getAvailableModels({ fetchStrategy: "live" });
+				const usage = await q.getUsageInfo();
+				return {
+					models: models.filter((m) => m.isEnabled !== false).map((m) => ({
+						id: m.value,
+						name: m.displayName,
+						context_window: m.defaultContextWindow ?? Math.min(...m.availableContextWindows?.length ? m.availableContextWindows : [m.maxInputTokens ?? 128e3]),
+						max_input_tokens: m.maxInputTokens,
+						max_output_tokens: m.maxOutputTokens,
+						available_context_windows: m.availableContextWindows,
+						input_modalities: m.isVl ? ["text", "image"] : ["text"]
+					})),
+					usage
+				};
+			} finally {
+				release();
+				try {
+					await q?.close();
+				} finally {
+					await session.cleanup();
+				}
+			}
+		},
+		async *turn(input, signal) {
+			const session = await workspace(signal, token);
+			let q;
+			const client = clientToolServer(input.tools ?? []);
+			const translator = new EventTranslator(client.names);
+			try {
+				q = runQuery({
+					prompt: await buildSdkPrompt(input, signal),
+					options: {
+						...session.options,
+						model: input.model,
+						...input.tools?.length ? {
+							mcpServers: { client: client.config },
+							allowedMcpServerNames: ["client"],
+							allowedTools: [...client.names.keys()],
+							canUseTool: (name, args) => Promise.resolve(client.names.has(name) ? {
+								behavior: "allow",
+								updatedInput: args
+							} : {
+								behavior: "deny",
+								message: "Only client tools are allowed"
+							})
+						} : {},
+						...input.contextWindow || input.reasoningEffort ? { resolveModel: qoderModelPolicy(input) } : {},
+						systemPrompt: input.systemPrompt
+					}
+				});
+				for await (const message of q) {
+					signal.throwIfAborted();
+					for (const event of translator.accept(message)) {
+						yield event;
+						if (event.type === "tool_calls") {
+							yield {
+								type: "complete",
+								info: { qoder_usage: {} }
+							};
+							return;
+						}
+					}
+				}
+				translator.assertComplete();
+			} finally {
+				try {
+					session.options.abortController?.abort();
+					await client.close();
+					await q?.close();
+				} finally {
+					await session.cleanup();
+				}
+			}
+		}
+	};
+}
+//#endregion
+export { createBackend };