Skip to content

CanvasAnvil is an open source AI diagram maker and flowchart generator - an infinite-canvas diagram editor and self-hosted drawio alternative that writes editable .drawio files. Text to diagram, then fix nodes, layout and labels in place. Also AI presentations, interior design CAD/BOM, posters and infographics.

feat(ai): refine provider routing and image model support

codingFeng101e8176cbe9da8
diff --git a/src/components/SettingsDialog.tsx b/src/components/SettingsDialog.tsx
index 24339bf..891bb46 100644
--- a/src/components/SettingsDialog.tsx
+++ b/src/components/SettingsDialog.tsx
@@ -45,11 +45,7 @@ const IMAGE_PROVIDER_LINKS: Partial<Record<AIProviderId, string>> = {
aliyun: "https://bailian.console.aliyun.com/?tab=model#/api-key",
tencent: "https://console.cloud.tencent.com/hunyuan/api-key",
bytedance: "https://console.volcengine.com/ark/region:ark+cn-beijing/apiKey",
- zhipu: "https://open.bigmodel.cn/usercenter/apikeys",
google: "https://console.cloud.google.com/vertex-ai/publishers/google/model-garden/imagen",
- xai: "https://console.x.ai/",
- bfl: "https://docs.bfl.ai/",
- adobe: "https://developer.adobe.com/console",
};
const MINERU_LINK = "https://mineru.net/";
diff --git a/src/lib/ai/gateway.ts b/src/lib/ai/gateway.ts
index c6633a4..4849ff9 100644
--- a/src/lib/ai/gateway.ts
+++ b/src/lib/ai/gateway.ts
@@ -34,6 +34,10 @@ function shouldUseEditFlow(req: ImageGatewayRequest, capabilities?: { supportsEd
return Boolean(req.referenceImageUrl && capabilities?.supportsEdits);
}
+function getProvider(req: ImageGatewayRequest) {
+ return String(req.channel.provider || "").toLowerCase();
+}
+
function joinUrl(baseUrl: string, endpoint: string): string {
const base = String(baseUrl || "").trim().replace(/\/+$/, "");
const path = String(endpoint || "").trim();
@@ -135,6 +139,84 @@ function extractTextFromOpenAIContent(content: any): string {
return "";
}
+function splitSystemMessages(messages: GatewayChatMessage[]) {
+ const system = messages
+ .filter((message) => message.role === "system")
+ .map((message) => extractTextFromOpenAIContent(message.content))
+ .filter(Boolean)
+ .join("\n\n");
+ const nonSystem = messages.filter((message) => message.role !== "system");
+ return { system, nonSystem };
+}
+
+function toGoogleParts(content: any): any[] {
+ if (Array.isArray(content)) {
+ return content
+ .map((part) => {
+ if (typeof part === "string") return { text: part };
+ if (part?.type === "text" && typeof part.text === "string") return { text: part.text };
+ if (part?.type === "image_url" && typeof part?.image_url?.url === "string") {
+ const match = String(part.image_url.url).match(/^data:([^;]+);base64,(.*)$/);
+ if (match) {
+ return {
+ inlineData: {
+ mimeType: match[1],
+ data: match[2],
+ },
+ };
+ }
+ }
+ return null;
+ })
+ .filter(Boolean);
+ }
+ return [{ text: extractTextFromOpenAIContent(content) }];
+}
+
+function toAnthropicContent(content: any): any {
+ if (Array.isArray(content)) {
+ return content
+ .map((part) => {
+ if (typeof part === "string") return { type: "text", text: part };
+ if (part?.type === "text" && typeof part.text === "string") return { type: "text", text: part.text };
+ if (part?.type === "image_url" && typeof part?.image_url?.url === "string") {
+ const match = String(part.image_url.url).match(/^data:([^;]+);base64,(.*)$/);
+ if (match) {
+ return {
+ type: "image",
+ source: {
+ type: "base64",
+ media_type: match[1],
+ data: match[2],
+ },
+ };
+ }
+ }
+ return null;
+ })
+ .filter(Boolean);
+ }
+ return extractTextFromOpenAIContent(content);
+}
+
+function extractTextFromGoogleResponse(parsed: any): string {
+ return (
+ parsed?.candidates?.[0]?.content?.parts
+ ?.map((part: any) => (typeof part?.text === "string" ? part.text : ""))
+ .filter(Boolean)
+ .join("\n") || ""
+ );
+}
+
+function extractTextFromAnthropicResponse(parsed: any): string {
+ return (
+ parsed?.content
+ ?.map((part: any) => (part?.type === "text" && typeof part?.text === "string" ? part.text : ""))
+ .filter(Boolean)
+ .join("\n") || ""
+ );
+}
+
function extractImageUrlFromOpenAIContent(content: any): string | null {
if (Array.isArray(content)) {
const imagePart = content.find((part) => part?.type === "image_url" && part?.image_url?.url);
@@ -188,6 +270,50 @@ async function convertRemoteImageToDataUrl(url: string): Promise<string> {
return `data:${contentType};base64,${buffer.toString("base64")}`;
}
+function extractFirstImageValue(input: any): string | null {
+ if (!input) return null;
+ if (typeof input === "string") {
+ if (/^https?:\/\//i.test(input) || input.startsWith("data:image")) return input;
+ return null;
+ }
+ if (Array.isArray(input)) {
+ for (const item of input) {
+ const found = extractFirstImageValue(item);
+ if (found) return found;
+ }
+ return null;
+ }
+ if (typeof input === "object") {
+ for (const key of [
+ "url",
+ "image_url",
+ "imageUrl",
+ "b64_json",
+ "base64",
+ "bytesBase64Encoded",
+ "image",
+ "result_image",
+ "resultImage",
+ ]) {
+ const value = input[key];
+ if (typeof value === "string") {
+ if (key === "b64_json" || key === "base64" || key === "bytesBase64Encoded") return `data:image/png;base64,${value}`;
+ if (/^https?:\/\//i.test(value) || value.startsWith("data:image")) return value;
+ }
+ }
+ for (const value of Object.values(input)) {
+ const found = extractFirstImageValue(value);
+ if (found) return found;
+ }
+ }
+ return null;
+}
+
+async function outputImage(value: string | null, providerName: string): Promise<string> {
+ if (!value) throw new Error(`${providerName} image request succeeded but returned no image data.`);
+ return value.startsWith("data:image") ? value : await convertRemoteImageToDataUrl(value);
+}
+
async function dataUrlToFile(dataUrl: string, filename: string): Promise<File> {
const normalized = dataUrl.startsWith("data:")
? dataUrl
@@ -372,6 +498,176 @@ async function requestAliyunImage(req: ImageGatewayRequest): Promise<string> {
return await convertRemoteImageToDataUrl(url);
}
+async function requestAliyunImageEdit(req: ImageGatewayRequest): Promise<string> {
+ if (!req.referenceImageUrl) return await requestAliyunImage(req);
+ return await requestAliyunImage(req);
+}
+
+async function requestOpenAICompatibleImage(req: ImageGatewayRequest, providerName: string): Promise<string> {
+ const response = await fetch(joinUrl(req.channel.baseUrl, "/images/generations"), {
+ method: "POST",
+ headers: {
+ Authorization: `Bearer ${req.channel.apiKey}`,
+ "Content-Type": "application/json",
+ },
+ body: JSON.stringify({
+ model: req.channel.model,
+ prompt: req.prompt,
+ }),
+ });
+
+ const text = await response.text();
+ let parsed: any = null;
+ try {
+ parsed = text ? JSON.parse(text) : null;
+ } catch {
+ parsed = null;
+ }
+ if (!response.ok) {
+ throw new Error(parsed?.error?.message || parsed?.error || text || `Request failed with status ${response.status}`);
+ }
+
+ return await outputImage(extractFirstImageValue(parsed?.data?.[0] || parsed), providerName);
+}
+
+async function requestBytedanceImage(req: ImageGatewayRequest): Promise<string> {
+ const response = await fetch(joinUrl(req.channel.baseUrl, "/images/generations"), {
+ method: "POST",
+ headers: {
+ Authorization: `Bearer ${req.channel.apiKey}`,
+ "Content-Type": "application/json",
+ },
+ body: JSON.stringify({
+ model: req.channel.model,
+ prompt: req.prompt,
+ response_format: "url",
+ }),
+ });
+
+ const text = await response.text();
+ let parsed: any = null;
+ try {
+ parsed = text ? JSON.parse(text) : null;
+ } catch {
+ parsed = null;
+ }
+ if (!response.ok) {
+ throw new Error(parsed?.error?.message || parsed?.error || text || `Request failed with status ${response.status}`);
+ }
+
+ return await outputImage(extractFirstImageValue(parsed?.data?.[0] || parsed), "Bytedance Seedream");
+}
+
+async function requestBytedanceImageEdit(req: ImageGatewayRequest): Promise<string> {
+ if (!req.referenceImageUrl) return await requestBytedanceImage(req);
+ const response = await fetch(joinUrl(req.channel.baseUrl, "/images/generations"), {
+ method: "POST",
+ headers: {
+ Authorization: `Bearer ${req.channel.apiKey}`,
+ "Content-Type": "application/json",
+ },
+ body: JSON.stringify({
+ model: req.channel.model,
+ prompt: req.prompt,
+ image: req.referenceImageUrl,
+ images: [
+ req.referenceImageUrl,
+ ...(req.additionalReferenceImageUrls || []),
+ ].filter(Boolean),
+ response_format: "url",
+ }),
+ });
+
+ const text = await response.text();
+ let parsed: any = null;
+ try {
+ parsed = text ? JSON.parse(text) : null;
+ } catch {
+ parsed = null;
+ }
+ if (!response.ok) {
+ throw new Error(parsed?.error?.message || parsed?.error || text || `Request failed with status ${response.status}`);
+ }
+
+ return await outputImage(extractFirstImageValue(parsed?.data?.[0] || parsed), "Bytedance Seedream edit");
+}
+
+async function requestTencentImage(req: ImageGatewayRequest): Promise<string> {
+ return await requestOpenAICompatibleImage(req, "Tencent Hunyuan Image");
+}
+
+async function requestTencentImageEdit(req: ImageGatewayRequest): Promise<string> {
+ if (!req.referenceImageUrl) return await requestTencentImage(req);
+ const response = await fetch(joinUrl(req.channel.baseUrl, "/images/edits"), {
+ method: "POST",
+ headers: {
+ Authorization: `Bearer ${req.channel.apiKey}`,
+ "Content-Type": "application/json",
+ },
+ body: JSON.stringify({
+ model: req.channel.model,
+ prompt: req.prompt,
+ image: req.referenceImageUrl,
+ }),
+ });
+
+ const text = await response.text();
+ let parsed: any = null;
+ try {
+ parsed = text ? JSON.parse(text) : null;
+ } catch {
+ parsed = null;
+ }
+ if (!response.ok) {
+ throw new Error(parsed?.error?.message || parsed?.error || text || `Request failed with status ${response.status}`);
+ }
+
+ return await outputImage(extractFirstImageValue(parsed?.data?.[0] || parsed), "Tencent Hunyuan Image edit");
+}
+
+async function requestGoogleImagen(req: ImageGatewayRequest, mode: "generation" | "edit"): Promise<string> {
+ const model = req.channel.model || "imagen-4.0-generate-001";
+ const baseUrl = req.channel.baseUrl.includes(":predict")
+ ? req.channel.baseUrl
+ : joinUrl(req.channel.baseUrl, `${model}:predict`);
+ const instance: Record<string, any> = {
+ prompt: req.prompt,
+ };
+ if (mode === "edit" && req.referenceImageUrl) {
+ const dataUrl = req.referenceImageUrl.startsWith("data:")
+ ? req.referenceImageUrl
+ : await convertRemoteImageToDataUrl(req.referenceImageUrl);
+ instance.image = { bytesBase64Encoded: dataUrl.split(",").pop() || dataUrl };
+ }
+
+ const response = await fetch(baseUrl, {
+ method: "POST",
+ headers: {
+ "Content-Type": "application/json",
+ "x-goog-api-key": req.channel.apiKey,
+ },
+ body: JSON.stringify({
+ instances: [instance],
+ parameters: {
+ sampleCount: 1,
+ },
+ }),
+ });
+
+ const text = await response.text();
+ let parsed: any = null;
+ try {
+ parsed = text ? JSON.parse(text) : null;
+ } catch {
+ parsed = null;
+ }
+ if (!response.ok) {
+ throw new Error(parsed?.error?.message || parsed?.error || text || `Request failed with status ${response.status}`);
+ }
+
+ return await outputImage(extractFirstImageValue(parsed?.predictions?.[0] || parsed), "Google Imagen");
+}
+
const openaiImageAdapter: ImageAdapter = {
supports: (req) => String(req.channel.provider || "").toLowerCase() === "openai",
generate: async (req) => {
@@ -383,26 +679,49 @@ const openaiImageAdapter: ImageAdapter = {
},
};
-const xaiImageAdapter: ImageAdapter = {
- supports: (req) => String(req.channel.provider || "").toLowerCase() === "xai",
+const aliyunImageAdapter: ImageAdapter = {
+ supports: (req) => getProvider(req) === "aliyun",
generate: async (req) => {
- // xAI image APIs are OpenAI-style at the transport layer in current provider support.
- const capabilities = resolveImageCapabilities(req.channel);
- if (shouldUseEditFlow(req, capabilities)) {
- return await requestOpenAIImageEdit(req);
- }
- return await requestOpenAIImages(req);
+ return shouldUseEditFlow(req, resolveImageCapabilities(req.channel))
+ ? await requestAliyunImageEdit(req)
+ : await requestAliyunImage(req);
},
};
-const aliyunImageAdapter: ImageAdapter = {
- supports: (req) => String(req.channel.provider || "").toLowerCase() === "aliyun",
+const tencentImageAdapter: ImageAdapter = {
+ supports: (req) => getProvider(req) === "tencent",
generate: async (req) => {
- return await requestAliyunImage(req);
+ return shouldUseEditFlow(req, resolveImageCapabilities(req.channel))
+ ? await requestTencentImageEdit(req)
+ : await requestTencentImage(req);
},
};
-const imageAdapters: ImageAdapter[] = [openaiImageAdapter, xaiImageAdapter, aliyunImageAdapter];
+const bytedanceImageAdapter: ImageAdapter = {
+ supports: (req) => getProvider(req) === "bytedance",
+ generate: async (req) => {
+ return shouldUseEditFlow(req, resolveImageCapabilities(req.channel))
+ ? await requestBytedanceImageEdit(req)
+ : await requestBytedanceImage(req);
+ },
+};
+
+const googleImageAdapter: ImageAdapter = {
+ supports: (req) => getProvider(req) === "google",
+ generate: async (req) => {
+ return shouldUseEditFlow(req, resolveImageCapabilities(req.channel))
+ ? await requestGoogleImagen(req, "edit")
+ : await requestGoogleImagen(req, "generation");
+ },
+};
+
+const imageAdapters: ImageAdapter[] = [
+ openaiImageAdapter,
+ aliyunImageAdapter,
+ tencentImageAdapter,
+ bytedanceImageAdapter,
+ googleImageAdapter,
+];
function findImageAdapter(req: ImageGatewayRequest): ImageAdapter | null {
return imageAdapters.find((adapter) => adapter.supports(req)) || null;
@@ -427,6 +746,69 @@ export async function generateTextThroughGateway(req: TextGatewayRequest): Promi
return typeof result === "string" ? result : JSON.stringify(result ?? "");
}
+ if (route.protocol === "google-gemini") {
+ const { system, nonSystem } = splitSystemMessages(req.messages);
+ const response = await fetch(joinUrl(req.channel.baseUrl, `/models/${req.channel.model}:generateContent`), {
+ method: "POST",
+ headers: {
+ "Content-Type": "application/json",
+ "x-goog-api-key": req.channel.apiKey,
+ },
+ body: JSON.stringify({
+ ...(system ? { systemInstruction: { parts: [{ text: system }] } } : {}),
+ contents: nonSystem.map((message) => ({
+ role: message.role === "assistant" ? "model" : "user",
+ parts: toGoogleParts(message.content),
+ })),
+ }),
+ });
+
+ const text = await response.text();
+ let parsed: any = null;
+ try {
+ parsed = text ? JSON.parse(text) : null;
+ } catch {
+ parsed = null;
+ }
+ if (!response.ok) {
+ throw new Error(parsed?.error?.message || parsed?.error || text || `Request failed with status ${response.status}`);
+ }
+ return extractTextFromGoogleResponse(parsed);
+ }
+
+ if (route.protocol === "anthropic-messages") {
+ const { system, nonSystem } = splitSystemMessages(req.messages);
+ const response = await fetch(joinUrl(req.channel.baseUrl, "/messages"), {
+ method: "POST",
+ headers: {
+ "Content-Type": "application/json",
+ "x-api-key": req.channel.apiKey,
+ "anthropic-version": "2023-06-01",
+ },
+ body: JSON.stringify({
+ model: req.channel.model,
+ max_tokens: 4096,
+ ...(system ? { system } : {}),
+ messages: nonSystem.map((message) => ({
+ role: message.role === "assistant" ? "assistant" : "user",
+ content: toAnthropicContent(message.content),
+ })),
+ }),
+ });
+
+ const text = await response.text();
+ let parsed: any = null;
+ try {
+ parsed = text ? JSON.parse(text) : null;
+ } catch {
+ parsed = null;
+ }
+ if (!response.ok) {
+ throw new Error(parsed?.error?.message || parsed?.error || text || `Request failed with status ${response.status}`);
+ }
+ return extractTextFromAnthropicResponse(parsed);
+ }
+
const response = await fetch(joinUrl(req.channel.baseUrl, "/chat/completions"), {
method: "POST",
headers: {
diff --git a/src/lib/ai/provider-registry.ts b/src/lib/ai/provider-registry.ts
index bcf8fb1..8688a52 100644
--- a/src/lib/ai/provider-registry.ts
+++ b/src/lib/ai/provider-registry.ts
@@ -12,11 +12,9 @@ export type AIProviderId =
| "xai"
| "google"
| "anthropic"
- | "bfl"
- | "adobe"
| "custom";
-export type TextProtocol = "openai-chat" | "custom";
+export type TextProtocol = "openai-chat" | "google-gemini" | "anthropic-messages" | "custom";
export type ImageProtocol = "openai-images" | "openai-chat-image" | "openai-images-fallback-chat-image" | "custom";
export interface CustomProviderMappingSpec {
@@ -151,10 +149,6 @@ const IMAGE_REFERENCE_RULES: Array<{ provider: AIProviderId; patterns: RegExp[]
provider: "bytedance",
patterns: [/seedream/i],
},
- {
- provider: "zhipu",
- patterns: [/glm-image/i, /cogview/i],
- },
{
provider: "tencent",
patterns: [/hunyuan/i],
@@ -199,17 +193,6 @@ const IMAGE_CAPABILITY_RULES: Array<{
supportsMultiReferenceImages: true,
},
},
- {
- provider: "zhipu",
- patterns: [/glm-image/i, /cogview/i],
- capabilities: {
- supportsGeneration: true,
- supportsEdits: true,
- supportsMask: false,
- supportsReferenceImages: true,
- supportsMultiReferenceImages: false,
- },
- },
{
provider: "tencent",
patterns: [/hunyuan/i],
@@ -232,39 +215,6 @@ const IMAGE_CAPABILITY_RULES: Array<{
supportsMultiReferenceImages: false,
},
},
- {
- provider: "xai",
- patterns: [/grok/i],
- capabilities: {
- supportsGeneration: true,
- supportsEdits: true,
- supportsMask: false,
- supportsReferenceImages: true,
- supportsMultiReferenceImages: false,
- },
- },
- {
- provider: "bfl",
- patterns: [/flux/i],
- capabilities: {
- supportsGeneration: true,
- supportsEdits: true,
- supportsMask: true,
- supportsReferenceImages: true,
- supportsMultiReferenceImages: true,
- },
- },
- {
- provider: "adobe",
- patterns: [/firefly/i],
- capabilities: {
- supportsGeneration: true,
- supportsEdits: true,
- supportsMask: true,
- supportsReferenceImages: true,
- supportsMultiReferenceImages: false,
- },
- },
];
export const TEXT_PROVIDER_OPTIONS: ProviderOption[] = [
@@ -272,27 +222,23 @@ export const TEXT_PROVIDER_OPTIONS: ProviderOption[] = [
{ id: "ollama", label: "Ollama", defaultBaseUrl: "http://localhost:11434/v1" },
{ id: "deepseek", label: "DeepSeek", defaultBaseUrl: "https://api.deepseek.com/v1" },
{ id: "kimi", label: "Kimi", defaultBaseUrl: "https://api.moonshot.cn/v1" },
- { id: "aliyun", label: "Alibaba Bailian" },
- { id: "tencent", label: "Tencent Hunyuan" },
- { id: "bytedance", label: "Bytedance Ark" },
- { id: "zhipu", label: "Zhipu" },
- { id: "baidu", label: "Baidu Qianfan" },
- { id: "minimax", label: "MiniMax" },
- { id: "xai", label: "xAI" },
- { id: "google", label: "Google" },
- { id: "anthropic", label: "Anthropic" },
+ { id: "aliyun", label: "Alibaba Bailian", defaultBaseUrl: "https://dashscope.aliyuncs.com/compatible-mode/v1" },
+ { id: "tencent", label: "Tencent Hunyuan", defaultBaseUrl: "https://api.hunyuan.cloud.tencent.com/v1" },
+ { id: "bytedance", label: "Bytedance Ark", defaultBaseUrl: "https://ark.cn-beijing.volces.com/api/v3" },
+ { id: "zhipu", label: "Zhipu", defaultBaseUrl: "https://open.bigmodel.cn/api/paas/v4" },
+ { id: "baidu", label: "Baidu Qianfan", defaultBaseUrl: "https://qianfan.baidubce.com/v2" },
+ { id: "minimax", label: "MiniMax", defaultBaseUrl: "https://api.minimax.io/v1" },
+ { id: "xai", label: "xAI", defaultBaseUrl: "https://api.x.ai/v1" },
+ { id: "google", label: "Google", defaultBaseUrl: "https://generativelanguage.googleapis.com/v1beta" },
+ { id: "anthropic", label: "Anthropic", defaultBaseUrl: "https://api.anthropic.com/v1" },
];
export const IMAGE_PROVIDER_OPTIONS: ProviderOption[] = [
{ id: "openai", label: "OpenAI", defaultBaseUrl: "https://api.openai.com/v1" },
- { id: "aliyun", label: "Alibaba Wanx" },
- { id: "tencent", label: "Tencent Hunyuan Image" },
- { id: "bytedance", label: "Bytedance Seedream" },
- { id: "zhipu", label: "Zhipu" },
- { id: "google", label: "Google Imagen" },
- { id: "xai", label: "xAI" },
- { id: "bfl", label: "Black Forest Labs" },
- { id: "adobe", label: "Adobe Firefly" },
+ { id: "aliyun", label: "Alibaba Wanx", defaultBaseUrl: "https://dashscope.aliyuncs.com/api/v1" },
+ { id: "tencent", label: "Tencent Hunyuan Image", defaultBaseUrl: "https://tokenhub.tencentmaas.com/v1/api/image/lite" },
+ { id: "bytedance", label: "Bytedance Seedream", defaultBaseUrl: "https://ark.cn-beijing.volces.com/api/v3" },
+ { id: "google", label: "Google Imagen", defaultBaseUrl: "https://generativelanguage.googleapis.com/v1beta" },
];
function matchesRule(provider: string, model: string, rules: Array<{ provider: AIProviderId; patterns: RegExp[] }>) {
@@ -330,6 +276,20 @@ export function resolveTextRoute(channel: AIChannelConfig): TextRoute {
};
}
+ if (provider === "google") {
+ return {
+ protocol: "google-gemini",
+ supportsVision: true,
+ };
+ }
+
+ if (provider === "anthropic") {
+ return {
+ protocol: "anthropic-messages",
+ supportsVision: true,
+ };
+ }
+
return {
protocol: "openai-chat",
supportsVision: matchesRule(provider, channel.model, TEXT_VISION_RULES),
@@ -425,7 +385,9 @@ export function normalizeAIConfig(rawConfig: Partial<AIConfig> | null | undefine
const requestedTextProvider = String((raw.textProvider || "openai") as string).trim() || "openai";
const requestedImageProvider = String((raw.imageProvider || "openai") as string).trim() || "openai";
const textProvider = requestedTextProvider === "custom" ? "openai" : requestedTextProvider;
- const imageProvider = requestedImageProvider === "custom" ? "openai" : requestedImageProvider;
+ const imageProvider = IMAGE_PROVIDER_OPTIONS.some((option) => option.id === requestedImageProvider)
+ ? requestedImageProvider
+ : "openai";
const textApiKey = String((raw.textApiKey || raw.apiKey || "") as string).trim();
const imageApiKey = String((raw.imageApiKey || raw.apiKey || "") as string).trim();
const textBaseUrl =
diff --git a/tests/ai-gateway-request-shape.test.ts b/tests/ai-gateway-request-shape.test.ts
new file mode 100644
index 0000000..5d51c5d
--- /dev/null
+++ b/tests/ai-gateway-request-shape.test.ts
@@ -0,0 +1,131 @@
+import assert from "node:assert/strict";
+import { generateImageThroughGateway, generateTextThroughGateway } from "../src/lib/ai/gateway";
+
+type CapturedRequest = {
+ url: string;
+ init: RequestInit;
+ body: any;
+};
+
+const captured: CapturedRequest[] = [];
+const originalFetch = globalThis.fetch;
+
+function mockJsonResponse(payload: any, ok = true) {
+ return {
+ ok,
+ status: ok ? 200 : 400,
+ headers: new Headers({ "content-type": "application/json" }),
+ text: async () => JSON.stringify(payload),
+ arrayBuffer: async () => new ArrayBuffer(0),
+ } as Response;
+}
+
+globalThis.fetch = (async (url: any, init?: RequestInit) => {
+ const bodyText = typeof init?.body === "string" ? init.body : "";
+ const body = bodyText ? JSON.parse(bodyText) : null;
+ captured.push({ url: String(url), init: init || {}, body });
+
+ if (String(url).includes(":generateContent")) {
+ return mockJsonResponse({ candidates: [{ content: { parts: [{ text: "ok" }] } }] });
+ }
+ if (String(url).endsWith("/messages")) {
+ return mockJsonResponse({ content: [{ type: "text", text: "ok" }] });
+ }
+ if (String(url).includes(":predict")) {
+ return mockJsonResponse({ predictions: [{ bytesBase64Encoded: "aGVsbG8=" }] });
+ }
+ if (String(url).includes("/services/aigc/multimodal-generation/generation")) {
+ return mockJsonResponse({
+ output: {
+ choices: [
+ {
+ message: {
+ content: [{ image: "data:image/png;base64,aGVsbG8=" }],
+ },
+ },
+ ],
+ },
+ });
+ }
+ return mockJsonResponse({ data: [{ b64_json: "aGVsbG8=" }] });
+}) as typeof fetch;
+
+function lastRequest() {
+ const request = captured[captured.length - 1];
+ assert.ok(request, "expected a captured request");
+ return request;
+}
+
+async function assertImageRequest(provider: string, expectedPath: string, referenceImageUrl?: string) {
+ const model =
+ provider === "openai"
+ ? "gpt-image-1"
+ : provider === "aliyun"
+ ? "wan2.2-image"
+ : provider === "tencent"
+ ? "hunyuan-image"
+ : provider === "bytedance"
+ ? "doubao-seedream-4-0"
+ : "imagen-4.0-generate-001";
+
+ captured.length = 0;
+ await generateImageThroughGateway({
+ channel: {
+ provider,
+ apiKey: "test-key",
+ baseUrl: provider === "google" ? "https://generativelanguage.googleapis.com/v1beta/models" : "https://example.test/v1",
+ model,
+ },
+ prompt: "draw a square",
+ referenceImageUrl,
+ });
+
+ const request = lastRequest();
+ assert.ok(request.url.includes(expectedPath), `${provider} should call ${expectedPath}, got ${request.url}`);
+ if (provider === "google") {
+ assert.equal((request.init.headers as Record<string, string>)["x-goog-api-key"], "test-key");
+ } else {
+ assert.equal((request.init.headers as Record<string, string>).Authorization, "Bearer test-key");
+ }
+}
+
+await assertImageRequest("openai", "/images/generations");
+await assertImageRequest("openai", "/images/edits", "data:image/png;base64,aGVsbG8=");
+await assertImageRequest("aliyun", "/services/aigc/multimodal-generation/generation");
+await assertImageRequest("aliyun", "/services/aigc/multimodal-generation/generation", "data:image/png;base64,aGVsbG8=");
+await assertImageRequest("tencent", "/images/generations");
+await assertImageRequest("tencent", "/images/edits", "data:image/png;base64,aGVsbG8=");
+await assertImageRequest("bytedance", "/images/generations");
+await assertImageRequest("bytedance", "/images/generations", "data:image/png;base64,aGVsbG8=");
+await assertImageRequest("google", ":predict");
+await assertImageRequest("google", ":predict", "data:image/png;base64,aGVsbG8=");
+
+captured.length = 0;
+await generateTextThroughGateway({
+ channel: {
+ provider: "google",
+ apiKey: "google-key",
+ baseUrl: "https://generativelanguage.googleapis.com/v1beta",
+ model: "gemini-2.5-flash",
+ },
+ messages: [{ role: "user", content: "hello" }],
+});
+assert.ok(lastRequest().url.endsWith("/models/gemini-2.5-flash:generateContent"));
+assert.equal((lastRequest().init.headers as Record<string, string>)["x-goog-api-key"], "google-key");
+
+captured.length = 0;
+await generateTextThroughGateway({
+ channel: {
+ provider: "anthropic",
+ apiKey: "anthropic-key",
+ baseUrl: "https://api.anthropic.com/v1",
+ model: "claude-sonnet-4-5",
+ },
+ messages: [{ role: "user", content: "hello" }],
+});
+assert.ok(lastRequest().url.endsWith("/messages"));
+assert.equal((lastRequest().init.headers as Record<string, string>)["x-api-key"], "anthropic-key");
+
+globalThis.fetch = originalFetch;
+
+console.log("ai-gateway request-shape tests passed");
diff --git a/tests/ai-provider-registry.test.ts b/tests/ai-provider-registry.test.ts
new file mode 100644
index 0000000..ce450d8
--- /dev/null
+++ b/tests/ai-provider-registry.test.ts
@@ -0,0 +1,61 @@
+import assert from "node:assert/strict";
+import {
+ IMAGE_PROVIDER_OPTIONS,
+ TEXT_PROVIDER_OPTIONS,
+ getDefaultBaseUrl,
+ normalizeAIConfig,
+ resolveImageCapabilities,
+ resolveTextRoute,
+} from "../src/lib/ai/provider-registry";
+
+const imageProviderIds = IMAGE_PROVIDER_OPTIONS.map((option) => option.id);
+
+assert.deepEqual(imageProviderIds, [
+ "openai",
+ "aliyun",
+ "tencent",
+ "bytedance",
+ "google",
+]);
+
+assert.equal(normalizeAIConfig({ imageProvider: "zhipu" }).imageProvider, "openai");
+assert.equal(normalizeAIConfig({ imageProvider: "bfl" }).imageProvider, "openai");
+
+assert.ok(TEXT_PROVIDER_OPTIONS.length > 0, "text providers should remain available");
+
+assert.equal(resolveTextRoute({
+ provider: "google",
+ apiKey: "test",
+ baseUrl: getDefaultBaseUrl("google", "text"),
+ model: "gemini-2.5-flash",
+}).protocol, "google-gemini");
+
+assert.equal(resolveTextRoute({
+ provider: "anthropic",
+ apiKey: "test",
+ baseUrl: getDefaultBaseUrl("anthropic", "text"),
+ model: "claude-sonnet-4-5",
+}).protocol, "anthropic-messages");
+
+for (const provider of imageProviderIds) {
+ const capabilities = resolveImageCapabilities({
+ provider,
+ apiKey: "test",
+ baseUrl: "https://example.com",
+ model:
+ provider === "openai"
+ ? "gpt-image-1"
+ : provider === "aliyun"
+ ? "wan2.7-image"
+ : provider === "tencent"
+ ? "hunyuan-image"
+ : provider === "bytedance"
+ ? "doubao-seedream-4.0"
+ : "imagen-4.0-generate-001",
+ });
+
+ assert.equal(capabilities.supportsGeneration, true, `${provider} should support generation`);
+ assert.equal(capabilities.supportsEdits, true, `${provider} should expose an edit branch`);
+}
+
+console.log("ai-provider-registry tests passed");