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

package/dist/protocol-BTFLbI8m.js

@@ -0,0 +1,257 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+import { randomUUID } from "node:crypto";
+//#region qoder-bridge/errors.ts
+var BridgeError = class extends Error {
+	status;
+	code;
+	constructor(message, status = 400, code = "invalid_request_error") {
+		super(message);
+		this.status = status;
+		this.code = code;
+	}
+};
+function record(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+//#endregion
+//#region qoder-bridge/client-tools.ts
+function parseClientTools(value) {
+	if (value === void 0) return [];
+	if (!Array.isArray(value) || value.length > 128) throw new BridgeError("tools must be an array of at most 128 functions");
+	const names = /* @__PURE__ */ new Set();
+	return value.map((raw) => {
+		const tool = record(raw), fn = record(tool.function), schema = record(fn.parameters);
+		if (tool.type !== "function" || typeof fn.name !== "string" || !/^[A-Za-z0-9_.-]{1,128}$/.test(fn.name) || names.has(fn.name)) throw new BridgeError("Invalid or duplicate function tool");
+		if (schema.type !== "object") throw new BridgeError("Function parameters must be an object JSON schema");
+		if (fn.description !== void 0 && typeof fn.description !== "string") throw new BridgeError("Invalid tool description");
+		names.add(fn.name);
+		return {
+			name: fn.name,
+			description: fn.description,
+			parameters: schema
+		};
+	});
+}
+function clientToolServer(tools) {
+	const server = new McpServer({
+		name: "copilot-client",
+		version: "1.0.0"
+	}, { capabilities: { tools: {} } });
+	const names = /* @__PURE__ */ new Map();
+	const list = tools.map((tool, index) => {
+		const name = `client_${index}`;
+		names.set(name, tool.name);
+		names.set(`mcp__client__${name}`, tool.name);
+		return {
+			name,
+			description: tool.description ?? tool.name,
+			inputSchema: tool.parameters
+		};
+	});
+	const pending = /* @__PURE__ */ new Set();
+	server.server.setRequestHandler(ListToolsRequestSchema, () => ({ tools: list }));
+	server.server.setRequestHandler(CallToolRequestSchema, () => new Promise((resolve) => pending.add(resolve)));
+	return {
+		names,
+		config: {
+			type: "sdk",
+			name: "client",
+			instance: server,
+			tools: list.map((t) => ({
+				name: t.name,
+				exposedName: t.name,
+				alwaysLoad: true,
+				permission_policy: "always_allow"
+			}))
+		},
+		async close() {
+			for (const resolve of pending) resolve({
+				isError: true,
+				content: [{
+					type: "text",
+					text: "Tool delegated to the API client"
+				}]
+			});
+			pending.clear();
+			await server.close();
+		}
+	};
+}
+//#endregion
+//#region qoder-bridge/images.ts
+const MAX_IMAGE_BYTES = 5 * 1024 * 1024;
+const MAX_TOTAL_IMAGE_BYTES = 15 * 1024 * 1024;
+const MAX_IMAGE_REQUEST_BYTES = 22 * 1024 * 1024;
+function parseImagePart(part) {
+	if (Object.keys(part).some((key) => !["type", "image_url"].includes(key))) throw new BridgeError("Unsupported image block field");
+	const image = record(part.image_url);
+	if (typeof image.url !== "string" || !image.url) throw new BridgeError("image_url.url is required");
+	if (Object.keys(image).some((key) => !["url", "detail"].includes(key))) throw new BridgeError("Unsupported image_url field");
+	if (image.detail !== void 0 && image.detail !== "auto") throw new BridgeError("Only image_url.detail=auto is supported", 400, "unsupported_parameter");
+	if (image.url.startsWith("data:")) decodeDataImage(image.url);
+	else validateImageUrl(image.url);
+	return { url: image.url };
+}
+function validateImageUrl(raw) {
+	let url;
+	try {
+		url = new URL(raw);
+	} catch {
+		throw new BridgeError("Invalid image URL");
+	}
+	if (url.protocol !== "https:" || url.username || url.password || url.port && url.port !== "443") throw new BridgeError("Remote images require HTTPS without credentials on port 443");
+	return url;
+}
+function imageMediaType(data) {
+	const b = Buffer.from(data.buffer, data.byteOffset, data.byteLength);
+	if (b.length >= 8 && b.subarray(0, 8).equals(Buffer.from([
+		137,
+		80,
+		78,
+		71,
+		13,
+		10,
+		26,
+		10
+	]))) return "image/png";
+	if (b.length >= 3 && b[0] === 255 && b[1] === 216 && b[2] === 255) return "image/jpeg";
+	if (b.length >= 6 && ["GIF87a", "GIF89a"].includes(b.toString("ascii", 0, 6))) return "image/gif";
+	if (b.length >= 12 && b.toString("ascii", 0, 4) === "RIFF" && b.toString("ascii", 8, 12) === "WEBP") return "image/webp";
+	throw new BridgeError("Unsupported or invalid image bytes; expected PNG, JPEG, WebP or GIF");
+}
+function makeImage(data, mime) {
+	if (data.byteLength > 5242880) throw new BridgeError("Image exceeds the 5 MiB limit", 413);
+	const detected = imageMediaType(data);
+	if (mime.toLowerCase() !== detected) throw new BridgeError("Image content does not match its declared media type");
+	return {
+		type: "image",
+		source: {
+			type: "base64",
+			media_type: detected,
+			data: Buffer.from(data).toString("base64")
+		}
+	};
+}
+function decodeDataImage(raw) {
+	const match = /^data:(image\/(?:png|jpeg|webp|gif));base64,([A-Za-z0-9+/]*={0,2})$/i.exec(raw);
+	if (!match || !match[2] || match[2].length % 4 !== 0) throw new BridgeError("Expected a valid base64 PNG, JPEG, WebP or GIF data URL");
+	if (match[2].length > 4 * Math.ceil(5242880 / 3)) throw new BridgeError("Image exceeds the 5 MiB limit", 413);
+	const data = Buffer.from(match[2], "base64");
+	if (data.toString("base64") !== match[2]) throw new BridgeError("Invalid base64 image encoding");
+	return makeImage(data, match[1]);
+}
+//#endregion
+//#region qoder-bridge/protocol.ts
+const ALLOWED_FIELDS = new Set([
+	"model",
+	"messages",
+	"stream",
+	"stream_options",
+	"tools",
+	"tool_choice",
+	"n",
+	"max_completion_tokens",
+	"parallel_tool_calls",
+	"reasoning_effort",
+	"context_window",
+	"prompt_cache_key",
+	"user"
+]);
+function parseChat(value) {
+	const input = record(value);
+	for (const key of Object.keys(input)) if (!ALLOWED_FIELDS.has(key) && input[key] !== void 0 && input[key] !== null) throw new BridgeError(`Qoder bridge does not yet support '${key}'`, 400, "unsupported_parameter");
+	if (typeof input.model !== "string" || !input.model.trim()) throw new BridgeError("model is required");
+	if (input.stream !== void 0 && typeof input.stream !== "boolean") throw new BridgeError("stream must be boolean");
+	if (input.n !== void 0 && input.n !== 1) throw new BridgeError("Only n=1 is supported");
+	if (input.prompt_cache_key !== void 0 && typeof input.prompt_cache_key !== "string") throw new BridgeError("prompt_cache_key must be a string");
+	let tools = parseClientTools(input.tools);
+	const choice = input.tool_choice;
+	if (choice === "none") tools = [];
+	else if (choice !== void 0 && choice !== "auto") throw new BridgeError("Only tool_choice=auto or none is supported");
+	if (input.parallel_tool_calls !== void 0 && typeof input.parallel_tool_calls !== "boolean") throw new BridgeError("parallel_tool_calls must be boolean");
+	if (input.parallel_tool_calls === false && tools.length) throw new BridgeError("Serial-only tool selection is not supported");
+	if (input.max_completion_tokens !== void 0 && (!Number.isInteger(input.max_completion_tokens) || Number(input.max_completion_tokens) < 32e3)) throw new BridgeError("Qoder uses its native 32000-token output cap; smaller max_completion_tokens is not supported");
+	if (input.context_window !== void 0 && (!Number.isInteger(input.context_window) || Number(input.context_window) <= 0)) throw new BridgeError("context_window must be a positive integer");
+	if (input.reasoning_effort !== void 0 && typeof input.reasoning_effort !== "string") throw new BridgeError("Invalid reasoning_effort");
+	const streamOptions = record(input.stream_options);
+	if (input.stream_options !== void 0 && (input.stream_options === null || typeof input.stream_options !== "object" || Array.isArray(input.stream_options))) throw new BridgeError("Invalid stream_options");
+	if (Object.keys(streamOptions).some((key) => key !== "include_usage") || streamOptions.include_usage !== void 0 && typeof streamOptions.include_usage !== "boolean") throw new BridgeError("Only stream_options.include_usage is supported");
+	if (!Array.isArray(input.messages) || input.messages.length === 0) throw new BridgeError("messages must be a nonempty array");
+	const system = [];
+	const images = [];
+	const conversation = [];
+	for (const raw of input.messages) {
+		const message = record(raw);
+		if (Object.keys(message).some((key) => ![
+			"role",
+			"content",
+			"tool_calls",
+			"tool_call_id",
+			"reasoning_content"
+		].includes(key))) throw new BridgeError("Only message role and content are supported", 400, "unsupported_parameter");
+		if (![
+			"system",
+			"developer",
+			"user",
+			"assistant",
+			"tool"
+		].includes(String(message.role))) throw new BridgeError("Only system, developer, user and assistant roles are supported");
+		if (message.role === "tool" && typeof message.tool_call_id !== "string") throw new BridgeError("Tool results require tool_call_id");
+		if (message.tool_calls !== void 0 && (message.role !== "assistant" || !Array.isArray(message.tool_calls))) throw new BridgeError("Invalid assistant tool_calls");
+		let content = message.content ?? (message.role === "assistant" && message.tool_calls ? "" : void 0);
+		if (Array.isArray(content)) content = content.map((part) => {
+			const block = record(part);
+			if (block.type === "text" && typeof block.text === "string") return block.text;
+			if (block.type === "image_url") {
+				if (message.role !== "user") throw new BridgeError("Images are only supported in user messages");
+				if (images.length >= 4) throw new BridgeError(`At most 4 images are supported`, 413);
+				const image = parseImagePart(block);
+				const label = `Image ${images.length + 1}`;
+				images.push({
+					...image,
+					label
+				});
+				return `[${label}]`;
+			}
+			throw new BridgeError("Only text and image_url content blocks are supported", 400, "unsupported_parameter");
+		}).join("\n");
+		if (typeof content !== "string") throw new BridgeError("Message content must be text");
+		if (message.role === "system" || message.role === "developer") system.push(content);
+		else conversation.push({
+			role: String(message.role),
+			content,
+			...Array.isArray(message.tool_calls) ? { tool_calls: message.tool_calls } : {},
+			...typeof message.tool_call_id === "string" ? { tool_call_id: message.tool_call_id } : {}
+		});
+	}
+	if (!["user", "tool"].includes(conversation.at(-1)?.role ?? "")) throw new BridgeError("The last conversation message must be from the user");
+	if (Buffer.byteLength(system.join("\n") + JSON.stringify(conversation) + JSON.stringify(tools)) > 1024 * 1024) throw new BridgeError("Text exceeds the 1 MiB limit", 413);
+	const history = conversation.slice(0, -1);
+	const prompt = history.length ? `Previous conversation (JSON data):\n${JSON.stringify(history)}\n\nCurrent message (JSON data):\n${conversation.at(-1)?.role === "tool" ? JSON.stringify(conversation.at(-1)) : conversation.at(-1).content}` : conversation[0].content;
+	return {
+		model: input.model.trim(),
+		stream: input.stream === true,
+		includeUsage: streamOptions.include_usage === true,
+		systemPrompt: system.join("\n\n") || "Answer the user's question. Use only the provided client tools when needed.",
+		prompt,
+		tools,
+		...input.context_window !== void 0 ? { contextWindow: Number(input.context_window) } : {},
+		...typeof input.reasoning_effort === "string" ? { reasoningEffort: input.reasoning_effort } : {},
+		...images.length ? { images } : {}
+	};
+}
+function completionIdentity(model) {
+	return {
+		id: `chatcmpl-${randomUUID()}`,
+		created: Math.floor(Date.now() / 1e3),
+		model
+	};
+}
+/** Do not expose SDK error text: it may contain authentication responses or local paths. */
+function publicError(error) {
+	if (error instanceof BridgeError) return error;
+	return new BridgeError("Qoder request failed. Check the local CLI login or Qoder PAT and network settings.", 502, "qoder_upstream_error");
+}
+//#endregion
+export { MAX_IMAGE_REQUEST_BYTES as a, makeImage as c, BridgeError as d, record as f, MAX_IMAGE_BYTES as i, validateImageUrl as l, parseChat as n, MAX_TOTAL_IMAGE_BYTES as o, publicError as r, decodeDataImage as s, completionIdentity as t, clientToolServer as u };

package/dist/provider-proxy-BbLwvtD_.js

@@ -0,0 +1,263 @@
+import { O as getResponsesTransportConfig, u as isQoderSdkProvider } from "./config-DnMKoKrg.js";
+import { B as fetchResponsesWithLifecycle, K as state, L as requestContext, f as parseUserIdMetadata } from "./token-CQftvMU4.js";
+import consola from "consola";
+import { fetch as fetch$1, getGlobalDispatcher } from "undici";
+//#region src/lib/models.ts
+/**
+* Converts a Copilot upstream model ID to a client-friendly ID that Claude Code
+* and Claude Desktop recognize (dots in version replaced with hyphens).
+* e.g. "claude-sonnet-4.6" -> "claude-sonnet-4-6"
+* Non-Claude models are returned unchanged.
+*/
+const toClientModelId = (modelId) => {
+	const normalized = normalizeSdkModelId(modelId);
+	if (!normalized) return modelId;
+	const versionHyphenated = normalized.version.replaceAll(".", "-");
+	return `claude-${normalized.family}-${versionHyphenated}`;
+};
+const findEndpointModel = (sdkModelId) => {
+	const models = state.models?.data ?? [];
+	const exactMatch = models.find((m) => m.id === sdkModelId);
+	if (exactMatch) return exactMatch;
+	const normalized = normalizeSdkModelId(sdkModelId);
+	if (!normalized) return;
+	const modelName = `claude-${normalized.family}-${normalized.version}`;
+	const model = models.find((m) => m.id === modelName);
+	if (model) return model;
+};
+/**
+* Finds the latest available model for a given Claude family (e.g. "opus",
+* "sonnet", "haiku") among the models currently cached in `state.models`.
+* "Latest" is determined by the highest semantic version parsed from the model
+* ID. Returns `undefined` when no model of that family is available.
+*/
+const getLatestModelForFamily = (family) => {
+	const models = state.models?.data ?? [];
+	let best;
+	for (const model of models) {
+		const normalized = normalizeSdkModelId(model.id);
+		if (!normalized || normalized.family !== family) continue;
+		const [majorPart, minorPart = "0"] = normalized.version.split(".");
+		const major = Number.parseInt(majorPart, 10);
+		const minor = Number.parseInt(minorPart, 10);
+		if (Number.isNaN(major) || Number.isNaN(minor)) continue;
+		if (!best || major > best.major || major === best.major && minor > best.minor) best = {
+			model,
+			major,
+			minor
+		};
+	}
+	return best?.model;
+};
+/**
+* Normalizes an SDK model ID to extract the model family and version.
+* this method from github copilot extension
+* Examples:
+* - "claude-opus-4-5-20251101" -> { family: "opus", version: "4.5" }
+* - "claude-3-5-sonnet-20241022" -> { family: "sonnet", version: "3.5" }
+* - "claude-sonnet-4-20250514" -> { family: "sonnet", version: "4" }
+* - "claude-haiku-3-5-20250514" -> { family: "haiku", version: "3.5" }
+* - "claude-haiku-4.5" -> { family: "haiku", version: "4.5" }
+*/
+const normalizeSdkModelId = (sdkModelId) => {
+	const withoutDate = sdkModelId.toLowerCase().replace(/-\d{8}$/, "");
+	const pattern1 = withoutDate.match(/^claude-(\w+)-(\d+)\.(\d+)$/);
+	if (pattern1) return {
+		family: pattern1[1],
+		version: `${pattern1[2]}.${pattern1[3]}`
+	};
+	const pattern2 = withoutDate.match(/^claude-(\w+)-(\d+)-(\d+)$/);
+	if (pattern2) return {
+		family: pattern2[1],
+		version: `${pattern2[2]}.${pattern2[3]}`
+	};
+	const pattern3 = withoutDate.match(/^claude-(\d+)-(\d+)-(\w+)$/);
+	if (pattern3) return {
+		family: pattern3[3],
+		version: `${pattern3[1]}.${pattern3[2]}`
+	};
+	const pattern4 = withoutDate.match(/^claude-(\w+)-(\d+)$/);
+	if (pattern4) return {
+		family: pattern4[1],
+		version: pattern4[2]
+	};
+	const pattern5 = withoutDate.match(/^claude-(\d+)-(\w+)$/);
+	if (pattern5) return {
+		family: pattern5[2],
+		version: pattern5[1]
+	};
+};
+//#endregion
+//#region src/lib/timeout-dispatcher.ts
+/**
+* Node's global fetch keeps Undici's shorter default headers/body timeouts.
+* Wrap the global dispatcher so long-running requests (e.g. image
+* generation) get an explicit cap.
+*/
+const createTimeoutDispatcher = (timeoutMs) => ({ dispatch(options, handler) {
+	return getGlobalDispatcher().dispatch({
+		...options,
+		bodyTimeout: timeoutMs,
+		headersTimeout: timeoutMs
+	}, handler);
+} });
+//#endregion
+//#region src/services/providers/provider-proxy.ts
+async function providerFetch(provider, path, init) {
+	if (isQoderSdkProvider(provider)) {
+		const { forwardQoder } = await import("./transport-HOWgkXsv.js");
+		return forwardQoder(provider, path, init);
+	}
+	return fetch(`${provider.baseUrl}${path}`, init);
+}
+const SHARED_FORWARDABLE_HEADERS = ["accept", "user-agent"];
+const ANTHROPIC_FORWARDABLE_HEADERS = ["anthropic-version", "anthropic-beta"];
+const STRIPPED_RESPONSE_HEADERS = [
+	"connection",
+	"content-encoding",
+	"content-length",
+	"keep-alive",
+	"proxy-authenticate",
+	"proxy-authorization",
+	"te",
+	"trailer",
+	"transfer-encoding",
+	"upgrade"
+];
+function buildProviderUpstreamHeaders(providerConfig, requestHeaders) {
+	const authHeaders = {};
+	if (providerConfig.authType === "x-api-key") authHeaders["x-api-key"] = providerConfig.apiKey;
+	else authHeaders.authorization = `Bearer ${providerConfig.apiKey}`;
+	const headers = {
+		"content-type": "application/json",
+		accept: "application/json",
+		...authHeaders
+	};
+	for (const headerName of SHARED_FORWARDABLE_HEADERS) {
+		const headerValue = requestHeaders.get(headerName);
+		if (headerValue) headers[headerName] = headerValue;
+	}
+	if (providerConfig.type !== "anthropic") return headers;
+	for (const headerName of ANTHROPIC_FORWARDABLE_HEADERS) {
+		const headerValue = requestHeaders.get(headerName);
+		if (headerValue) headers[headerName] = headerValue;
+	}
+	return headers;
+}
+const OPENCODE_GO_PROVIDER_NAME = "opencode-go";
+const OPENCODE_SESSION_HEADER = "x-opencode-session";
+const resolveOpencodeMessagesSession = (payload) => {
+	const sessionAffinity = requestContext.getStore()?.sessionAffinity?.trim();
+	if (sessionAffinity) return sessionAffinity;
+	const userId = payload.metadata?.user_id;
+	if (!userId?.trim()) return;
+	const { sessionId } = parseUserIdMetadata(userId);
+	return sessionId ?? userId;
+};
+const applyOpencodeSessionHeader = (providerConfig, headers, session) => {
+	if (providerConfig.name !== OPENCODE_GO_PROVIDER_NAME || !session) return;
+	headers[OPENCODE_SESSION_HEADER] = session;
+};
+function createProviderProxyResponse(upstreamResponse, body) {
+	const headers = new Headers(upstreamResponse.headers);
+	for (const headerName of STRIPPED_RESPONSE_HEADERS) headers.delete(headerName);
+	return new Response(body ?? upstreamResponse.body, {
+		headers,
+		status: upstreamResponse.status,
+		statusText: upstreamResponse.statusText
+	});
+}
+async function forwardProviderMessages(providerConfig, payload, requestHeaders) {
+	consola.log(`<-- model: ${payload.model}`);
+	const headers = buildProviderUpstreamHeaders(providerConfig, requestHeaders);
+	applyOpencodeSessionHeader(providerConfig, headers, resolveOpencodeMessagesSession(payload));
+	return await providerFetch(providerConfig, "/v1/messages", {
+		method: "POST",
+		headers,
+		body: JSON.stringify(payload)
+	});
+}
+async function forwardProviderChatCompletions(providerConfig, payload, requestHeaders, options = {}) {
+	consola.log(`<-- model: ${payload.model}`);
+	const headers = buildProviderUpstreamHeaders(providerConfig, requestHeaders);
+	applyOpencodeSessionHeader(providerConfig, headers, payload.prompt_cache_key?.trim() || void 0);
+	return await providerFetch(providerConfig, "/v1/chat/completions", {
+		method: "POST",
+		signal: options.signal,
+		headers,
+		body: JSON.stringify(payload)
+	});
+}
+async function forwardProviderResponses(providerConfig, payload, requestHeaders, options = {}) {
+	consola.log(`<-- model: ${payload.model}`);
+	const transportConfig = getResponsesTransportConfig();
+	const headers = buildProviderUpstreamHeaders(providerConfig, requestHeaders);
+	applyOpencodeSessionHeader(providerConfig, headers, payload.prompt_cache_key?.trim() || void 0);
+	if (isQoderSdkProvider(providerConfig)) return providerFetch(providerConfig, "/v1/responses", {
+		method: "POST",
+		signal: options.signal
+	});
+	return await fetchResponsesWithLifecycle(`${providerConfig.baseUrl}/v1/responses`, {
+		method: "POST",
+		headers,
+		body: JSON.stringify(payload)
+	}, {
+		headersTimeoutMs: transportConfig.headersTimeoutMs,
+		signal: options.signal,
+		streamInactivityTimeoutMs: transportConfig.streamInactivityTimeoutMs
+	});
+}
+const PROVIDER_MODELS_TIMEOUT_MS = 15e3;
+async function forwardProviderModels(providerConfig, requestHeaders) {
+	return await providerFetch(providerConfig, "/v1/models", {
+		method: "GET",
+		headers: buildProviderUpstreamHeaders(providerConfig, requestHeaders),
+		signal: AbortSignal.timeout(PROVIDER_MODELS_TIMEOUT_MS)
+	});
+}
+/** Align with Codex images: long-running generation/edits need a generous cap. */
+const PROVIDER_IMAGES_TIMEOUT_MS = 900 * 1e3;
+const providerImagesDispatcher = createTimeoutDispatcher(PROVIDER_IMAGES_TIMEOUT_MS);
+function resolveProviderRequestUrl(providerConfig, requestUrl, path) {
+	const upstreamUrl = new URL(`${providerConfig.baseUrl}${path}`);
+	upstreamUrl.search = new URL(requestUrl, "http://localhost").search;
+	return upstreamUrl.toString();
+}
+async function forwardProviderAlphaSearch(providerConfig, request) {
+	if (isQoderSdkProvider(providerConfig)) return providerFetch(providerConfig, "/unsupported", {
+		method: "POST",
+		signal: request.signal
+	});
+	const headers = buildProviderUpstreamHeaders(providerConfig, request.headers);
+	const body = await request.arrayBuffer();
+	return await fetch(resolveProviderRequestUrl(providerConfig, request.url, "/v1/alpha/search"), {
+		method: "POST",
+		headers,
+		body
+	});
+}
+async function forwardProviderImages(providerConfig, request, operation) {
+	if (isQoderSdkProvider(providerConfig)) return providerFetch(providerConfig, "/unsupported", {
+		method: "POST",
+		signal: request.signal
+	});
+	const headers = buildProviderUpstreamHeaders(providerConfig, request.headers);
+	const contentType = request.headers.get("content-type");
+	if (contentType) headers["content-type"] = contentType;
+	else if (operation === "edits") delete headers["content-type"];
+	const init = {
+		method: "POST",
+		headers,
+		body: request.body,
+		duplex: "half",
+		signal: AbortSignal.timeout(PROVIDER_IMAGES_TIMEOUT_MS)
+	};
+	const upstreamUrl = resolveProviderRequestUrl(providerConfig, request.url, `/v1/images/${operation}`);
+	if (typeof Bun !== "undefined") return await fetch(upstreamUrl, init);
+	return await fetch$1(upstreamUrl, {
+		...init,
+		dispatcher: providerImagesDispatcher
+	});
+}
+//#endregion
+export { forwardProviderMessages as a, createTimeoutDispatcher as c, normalizeSdkModelId as d, toClientModelId as f, forwardProviderImages as i, findEndpointModel as l, forwardProviderAlphaSearch as n, forwardProviderModels as o, forwardProviderChatCompletions as r, forwardProviderResponses as s, createProviderProxyResponse as t, getLatestModelForFamily as u };