@gobing-ai/knowledge-kit 0.0.13 → 0.0.14

package/plugins/generations/image-gen/src/providers/google.ts

@@ -0,0 +1,268 @@
+import { Buffer } from 'node:buffer';
+import { execFileSync } from 'node:child_process';
+import { readBytes } from '../bytes';
+import { mimeForPath } from './refs';
+import type { ImageProvider, ImageRequest, ImageResult, ProviderFactory, ProviderOptions } from './types';
+
+/**
+ * Google Gemini / Imagen adapter (0115 R1) — port of
+ * vendors/baoyu-skills/skills/baoyu-image-gen/scripts/providers/google.ts
+ * (MIT © 2026 Jim Liu), mapped from `CliArgs` onto `ImageRequest`.
+ */
+
+const GOOGLE_MULTIMODAL_MODELS = [
+    'gemini-3-pro-image',
+    'gemini-3.1-flash-image',
+    'gemini-3-pro-image-preview',
+    'gemini-3-flash-preview',
+    'gemini-3.1-flash-image-preview',
+];
+const GOOGLE_IMAGEN_MODELS = ['imagen-3.0-generate-002', 'imagen-3.0-generate-001'];
+
+const DEFAULT_MODEL = 'gemini-3-pro-image';
+
+export function normalizeGoogleModelId(model: string): string {
+    return model.startsWith('models/') ? model.slice('models/'.length) : model;
+}
+
+export function isGoogleMultimodal(model: string): boolean {
+    const normalized = normalizeGoogleModelId(model);
+    return GOOGLE_MULTIMODAL_MODELS.some((fragment) => normalized.includes(fragment));
+}
+
+export function isGoogleImagen(model: string): boolean {
+    const normalized = normalizeGoogleModelId(model);
+    return GOOGLE_IMAGEN_MODELS.some((fragment) => normalized.includes(fragment));
+}
+
+export function buildGoogleUrl(base: string, pathname: string): string {
+    const cleaned = base.replace(/\/+$/g, '').replace(/^\/+/g, '');
+    const cleanedPath = pathname.replace(/^\/+/g, '');
+    if (cleaned.endsWith('/v1beta')) return `${cleaned}/${cleanedPath}`;
+    return `${cleaned}/v1beta/${cleanedPath}`;
+}
+
+/** Aspect hint appended verbatim; 2k adds the resolution segment (baoyu buildPromptWithAspect). */
+export function buildPromptWithAspect(
+    prompt: string,
+    aspectRatio: string | undefined,
+    quality: 'normal' | '2k' | undefined,
+): string {
+    let result = prompt;
+    if (aspectRatio !== undefined) result += ` Aspect ratio: ${aspectRatio}.`;
+    if (quality === '2k') result += ' High resolution 2048px.';
+    return result;
+}
+
+export function extractInlineImageData(response: {
+    candidates?: Array<{ content?: { parts?: Array<{ inlineData?: { data?: string } }> } }>;
+}): string | null {
+    for (const candidate of response.candidates ?? []) {
+        for (const part of candidate.content?.parts ?? []) {
+            const data = part.inlineData?.data;
+            if (typeof data === 'string' && data.length > 0) return data;
+        }
+    }
+    return null;
+}
+
+interface PredictedEntry {
+    imageBytes?: unknown;
+    bytesBase64Encoded?: unknown;
+    data?: unknown;
+    image?: unknown;
+}
+
+export function extractPredictedImageData(response: {
+    predictions?: PredictedEntry[];
+    generatedImages?: PredictedEntry[];
+}): string | null {
+    for (const candidate of [...(response.predictions ?? []), ...(response.generatedImages ?? [])]) {
+        if (candidate === null || typeof candidate !== 'object') continue;
+        const fields: string[] = [candidate.imageBytes, candidate.bytesBase64Encoded, candidate.data].flatMap(
+            (value) => (typeof value === 'string' && value.length > 0 ? [value] : []),
+        );
+        if (fields.length > 0) return fields[0] ?? null;
+        const image = candidate.image;
+        if (image !== null && typeof image === 'object') {
+            const record = image as PredictedEntry;
+            for (const value of [record.imageBytes, record.bytesBase64Encoded, record.data]) {
+                if (typeof value === 'string' && value.length > 0) return value;
+            }
+        }
+    }
+    return null;
+}
+
+function resolveSize(req: ImageRequest): '1K' | '2K' | '4K' | undefined {
+    if (req.width !== undefined && req.height !== undefined) {
+        return Math.max(req.width, req.height) <= 1024 ? '1K' : Math.max(req.width, req.height) <= 2048 ? '2K' : '4K';
+    }
+    return undefined;
+}
+
+function getHttpProxy(readEnv: (key: string) => string): string | null {
+    return (
+        readEnv('https_proxy') ||
+        readEnv('HTTPS_PROXY') ||
+        readEnv('http_proxy') ||
+        readEnv('HTTP_PROXY') ||
+        readEnv('ALL_PROXY') ||
+        null
+    );
+}
+
+interface GeminiResponse {
+    candidates?: Array<{ content?: { parts?: Array<{ inlineData?: { data?: string } }> } }>;
+}
+
+interface ImagenResponse {
+    predictions?: PredictedEntry[];
+    generatedImages?: PredictedEntry[];
+}
+
+export const createGoogle: ProviderFactory = (options?: ProviderOptions): ImageProvider => {
+    const fetchFn = options?.fetch ?? fetch;
+    const env = options?.env ?? process.env;
+    const readEnv = (key: string): string => env[key] ?? '';
+    const refModels = [
+        'gemini-3-pro-image',
+        'gemini-3.1-flash-image',
+        'gemini-3-pro-image-preview',
+        'gemini-3-flash-preview',
+        'gemini-3.1-flash-image-preview',
+    ];
+    const supportsRef = (model: string): boolean =>
+        refModels.some((fragment) => normalizeGoogleModelId(model).includes(fragment));
+
+    async function postGoogleJson<T>(pathname: string, body: unknown): Promise<T> {
+        const apiKey = readEnv('GOOGLE_API_KEY') || readEnv('GEMINI_API_KEY');
+        if (apiKey === '') throw new Error('GOOGLE_API_KEY or GEMINI_API_KEY is required');
+        const base = readEnv('GOOGLE_BASE_URL') || 'https://generativelanguage.googleapis.com';
+        const url = buildGoogleUrl(base, pathname);
+        const proxy = getHttpProxy(readEnv);
+        // Bun's fetch drops long-lived proxied sockets; upstream works around it with curl (0115 port).
+        if (proxy !== null && options?.fetch === undefined) {
+            const result = (() => {
+                try {
+                    return execFileSync(
+                        'curl',
+                        [
+                            '-s',
+                            '--connect-timeout',
+                            '30',
+                            '--max-time',
+                            '300',
+                            '-x',
+                            proxy,
+                            url,
+                            '-H',
+                            'Content-Type: application/json',
+                            '-H',
+                            `x-goog-api-key: ${apiKey}`,
+                            '-d',
+                            '@-',
+                        ],
+                        { input: JSON.stringify(body), encoding: 'utf8', timeout: 310_000 },
+                    );
+                } catch (error: unknown) {
+                    const e = error as { message?: string; stderr?: string | Buffer };
+                    const details =
+                        (typeof e.stderr === 'string' ? e.stderr.trim() : '') || e.message || 'curl request failed';
+                    throw new Error(`Google API request failed via curl: ${details}`);
+                }
+            })();
+            const parsed = JSON.parse(result) as T & { error?: { code?: string; message?: string } };
+            if (parsed.error !== undefined) {
+                throw new Error(`Google API error (${parsed.error.code}): ${parsed.error.message}`);
+            }
+            return parsed;
+        }
+        const res = await fetchFn(url, {
+            method: 'POST',
+            headers: { 'content-type': 'application/json', 'x-goog-api-key': apiKey },
+            body: JSON.stringify(body),
+        });
+        if (!res.ok) {
+            const err = await res.text();
+            throw new Error(`Google API error (${res.status}): ${err}`);
+        }
+        return (await res.json()) as T;
+    }
+
+    async function generateWithGemini(req: ImageRequest): Promise<Uint8Array> {
+        const promptWithAspect = buildPromptWithAspect(req.prompt, req.aspectRatio, req.quality);
+        const parts: Array<{ text?: string; inlineData?: { data: string; mimeType: string } }> = [];
+        for (const refPath of req.referenceImages ?? []) {
+            parts.push({
+                inlineData: {
+                    data: Buffer.from(await readBytes(refPath)).toString('base64'),
+                    mimeType: mimeForPath(refPath),
+                },
+            });
+        }
+        parts.push({ text: promptWithAspect });
+        const response = await postGoogleJson<GeminiResponse>(
+            `models/${normalizeGoogleModelId(req.model)}:generateContent`,
+            {
+                contents: [{ role: 'user', parts }],
+                generationConfig: {
+                    responseModalities: ['IMAGE'],
+                    imageConfig: { imageSize: resolveSize(req) ?? (req.quality === '2k' ? '2K' : '1K') },
+                },
+            },
+        );
+        const imageData = extractInlineImageData(response);
+        if (imageData !== null) return Uint8Array.from(Buffer.from(imageData, 'base64'));
+        throw new Error('No image in response');
+    }
+
+    async function generateWithImagen(req: ImageRequest): Promise<Uint8Array> {
+        const fullPrompt = buildPromptWithAspect(req.prompt, req.aspectRatio, req.quality);
+        const imageSize = resolveSize(req) ?? (req.quality === '2k' ? '2K' : '1K');
+        const parameters: Record<string, unknown> = { sampleCount: req.n ?? 1 };
+        if (req.aspectRatio !== undefined) parameters.aspectRatio = req.aspectRatio;
+        parameters.imageSize = imageSize === '4K' ? '2K' : imageSize;
+        const response = await postGoogleJson<ImagenResponse>(`models/${normalizeGoogleModelId(req.model)}:predict`, {
+            instances: [{ prompt: fullPrompt }],
+            parameters,
+        });
+        const imageData = extractPredictedImageData(response);
+        if (imageData !== null) return Uint8Array.from(Buffer.from(imageData, 'base64'));
+        throw new Error('No image in response');
+    }
+
+    async function generate(req: ImageRequest): Promise<ImageResult> {
+        const refs = req.referenceImages;
+        if (isGoogleImagen(req.model)) {
+            if (refs !== undefined && refs.length > 0) {
+                throw new Error(
+                    'Reference images are not supported with Imagen models. Use a Gemini multimodal model such as gemini-3-pro-image, gemini-3.1-flash-image, gemini-3-pro-image-preview, gemini-3-flash-preview, or gemini-3.1-flash-image-preview.',
+                );
+            }
+            return { bytes: await generateWithImagen(req), extension: 'png', provider: 'google', model: req.model };
+        }
+        if (!isGoogleMultimodal(req.model) && refs !== undefined && refs.length > 0) {
+            throw new Error(
+                'Reference images are only supported with Gemini multimodal models such as gemini-3-pro-image, gemini-3.1-flash-image, gemini-3-pro-image-preview, gemini-3-flash-preview, or gemini-3.1-flash-image-preview.',
+            );
+        }
+        const bytes = await generateWithGemini(req);
+        return { bytes, extension: 'png', provider: 'google', model: req.model };
+    }
+
+    return {
+        name: 'google',
+        defaultModel: () => DEFAULT_MODEL,
+        isAvailable: () => (readEnv('GOOGLE_API_KEY') || readEnv('GEMINI_API_KEY')) !== '',
+        supportsReferenceImages: supportsRef,
+        validate(req: ImageRequest): void {
+            if ((req.referenceImages?.length ?? 0) > 0 && !supportsRef(req.model)) {
+                throw new Error(
+                    `google model '${req.model}' does not accept reference images; use a Gemini multimodal model`,
+                );
+            }
+        },
+        generate,
+    };
+};

package/plugins/generations/image-gen/src/providers/huggingface.ts

@@ -0,0 +1,59 @@
+import type { ImageProvider, ImageRequest, ImageResult, ProviderFactory, ProviderOptions } from './types';
+
+/**
+ * HuggingFace Inference adapter (0116 R1) — port of wt-image-generate's
+ * `HuggingFaceBackend.generate()` (scripts/image_generator.py:142). POST JSON
+ * {inputs, parameters:{width,height,num_inference_steps}} to
+ * https://api-inference.huggingface.co/models/<model>; HTTP 200 returns raw image
+ * bytes, 503 means the model is still cold-loading (loud error, wt parity).
+ * Text-to-image only — wt's backend has no image-to-image path.
+ */
+
+const DEFAULT_MODEL = 'stabilityai/stable-diffusion-xl-base-1.0';
+const BASE_URL = 'https://api-inference.huggingface.co/models';
+
+export const buildPayload = (
+    req: Pick<ImageRequest, 'prompt' | 'width' | 'height' | 'quality'>,
+): Record<string, unknown> => ({
+    inputs: req.prompt,
+    parameters: {
+        width: req.width ?? 1024,
+        height: req.height ?? 1024,
+        num_inference_steps: req.quality === 'normal' ? 30 : 50,
+    },
+});
+
+export const createHuggingface: ProviderFactory = (options?: ProviderOptions): ImageProvider => {
+    const fetchFn = options?.fetch ?? fetch;
+    const env = options?.env ?? process.env;
+    const readEnv = (key: string): string => env[key] ?? '';
+
+    return {
+        name: 'huggingface',
+        defaultModel: () => readEnv('HUGGINGFACE_MODEL') || DEFAULT_MODEL,
+        isAvailable: () => readEnv('HUGGINGFACE_API_TOKEN') !== '',
+        supportsReferenceImages: () => false,
+
+        async generate(req: ImageRequest): Promise<ImageResult> {
+            const token = readEnv('HUGGINGFACE_API_TOKEN');
+            if (token === '') {
+                throw new Error('HUGGINGFACE_API_TOKEN is required. Get one at https://huggingface.co/settings/tokens');
+            }
+            const model = req.model.startsWith('hf:') ? req.model.slice(3) : req.model;
+            const res = await fetchFn(`${BASE_URL}/${model}`, {
+                method: 'POST',
+                headers: { authorization: `Bearer ${token}`, 'content-type': 'application/json' },
+                body: JSON.stringify(buildPayload(req)),
+            });
+            if (!res.ok) {
+                const text = (await res.text()).slice(0, 200);
+                if (res.status === 503) throw new Error(`HuggingFace model loading (HTTP 503): ${text}`);
+                throw new Error(`HuggingFace HTTP ${res.status}: ${text}`);
+            }
+            const bytes = new Uint8Array(await res.arrayBuffer());
+            const ct = res.headers.get('content-type') ?? '';
+            const extension = ct.includes('jpeg') ? 'jpg' : ct.includes('webp') ? 'webp' : 'png';
+            return { bytes, extension, provider: 'huggingface', model };
+        },
+    };
+};

package/plugins/generations/image-gen/src/providers/jimeng.ts

@@ -0,0 +1,259 @@
+import * as crypto from 'node:crypto';
+import type { ImageProvider, ImageRequest, ImageResult, ProviderFactory, ProviderOptions } from './types';
+
+/**
+ * Volcengine Jimeng adapter (0115 R1) — port of
+ * vendors/baoyu-skills/skills/baoyu-image-gen/scripts/providers/jimeng.ts
+ * (MIT © 2026 Jim Liu). Text-to-image only; signed submit + poll (HMAC-SHA256,
+ * https://www.volcengine.com/docs/85621/1817045).
+ */
+
+const DEFAULT_MODEL = 'jimeng_t2i_v40';
+
+type JimengSizePreset = 'normal' | '2k' | '4k';
+
+const SIZE_PRESETS: Record<JimengSizePreset, Record<string, string>> = {
+    normal: {
+        '1:1': '1024x1024',
+        '4:3': '1360x1020',
+        '16:9': '1536x864',
+        '3:2': '1440x960',
+        '21:9': '1920x824',
+    },
+    '2k': {
+        '1:1': '2048x2048',
+        '4:3': '2304x1728',
+        '16:9': '2560x1440',
+        '3:2': '2496x1664',
+        '21:9': '3024x1296',
+    },
+    '4k': {
+        '1:1': '4096x4096',
+        '4:3': '4694x3520',
+        '16:9': '5404x3040',
+        '3:2': '4992x3328',
+        '21:9': '6198x2656',
+    },
+};
+
+export function generateSignature(
+    method: string,
+    query: Record<string, string>,
+    headers: Record<string, string>,
+    body: string,
+    accessKey: string,
+    secretKey: string,
+    region: string,
+    service: string,
+    canonicalUri: string,
+): string {
+    const sortedQuery = Object.entries(query)
+        .sort(([a], [b]) => a.localeCompare(b))
+        .map(([k, v]) => `${encodeURIComponent(k)}=${encodeURIComponent(v)}`)
+        .join('&');
+    const sortedHeaders = Object.entries(headers)
+        .sort(([a], [b]) => a.localeCompare(b))
+        .map(([k, v]) => `${k.toLowerCase()}:${v.trim()}\n`)
+        .join('');
+    const signedHeaders = Object.keys(headers)
+        .sort()
+        .map((k) => k.toLowerCase())
+        .join(';');
+    const hashedPayload = crypto.createHash('sha256').update(body, 'utf8').digest('hex');
+    const canonicalRequest = [method, canonicalUri, sortedQuery, sortedHeaders, signedHeaders, hashedPayload].join(
+        '\n',
+    );
+    const hashedCanonicalRequest = crypto.createHash('sha256').update(canonicalRequest, 'utf8').digest('hex');
+
+    const algorithm = 'HMAC-SHA256';
+    const timestamp = headers['X-Date'] ?? headers['x-date'];
+    if (timestamp === undefined) throw new Error('Jimeng signature generation requires an X-Date header.');
+    const dateStamp = timestamp.slice(0, 8);
+    const credentialScope = `${dateStamp}/${region}/${service}/request`;
+    const stringToSign = [algorithm, timestamp, credentialScope, hashedCanonicalRequest].join('\n');
+
+    const kDate = crypto.createHmac('sha256', secretKey).update(dateStamp).digest();
+    const kRegion = crypto.createHmac('sha256', kDate).update(region).digest();
+    const kService = crypto.createHmac('sha256', kRegion).update(service).digest();
+    const kSigning = crypto.createHmac('sha256', kService).update('request').digest();
+    const signature = crypto.createHmac('sha256', kSigning).update(stringToSign).digest('hex');
+
+    return `${algorithm} Credential=${accessKey}/${credentialScope}, SignedHeaders=${signedHeaders}, Signature=${signature}`;
+}
+
+function resolveEndpoint(
+    baseUrl: string,
+    query: Record<string, string>,
+): { url: string; host: string; canonicalUri: string } {
+    let parsed: URL;
+    try {
+        parsed = new URL(baseUrl);
+    } catch {
+        throw new Error(`Invalid JIMENG_BASE_URL: ${baseUrl}`);
+    }
+    parsed.search = '';
+    for (const [key, value] of Object.entries(query).sort(([a], [b]) => a.localeCompare(b))) {
+        parsed.searchParams.set(key, value);
+    }
+    return { url: parsed.toString(), host: parsed.host, canonicalUri: parsed.pathname || '/' };
+}
+
+function getClosestPresetSize(ar: string | undefined, qualityLevel: JimengSizePreset): string {
+    const presets = SIZE_PRESETS[qualityLevel];
+    const defaultSize = presets['1:1'] as string;
+    if (ar === undefined) return defaultSize;
+    const match = ar.match(/^(\d+(?:\.\d+)?):(\d+(?:\.\d+)?)$/);
+    if (match === null) return defaultSize;
+    const targetRatio = Number(match[1]) / Number(match[2]);
+    let bestMatch = defaultSize;
+    let bestDiff = Number.POSITIVE_INFINITY;
+    for (const [ratio, size] of Object.entries(presets)) {
+        const [w, h] = ratio.split(':').map(Number) as [number, number];
+        const diff = Math.abs(w / h - targetRatio);
+        if (diff < bestDiff) {
+            bestDiff = diff;
+            bestMatch = size;
+        }
+    }
+    return bestMatch;
+}
+
+/** Explicit pixels win; else the quality-level preset closest to the aspect ratio. */
+export function getImageSize(
+    ar: string | undefined,
+    quality: 'normal' | '2k' | undefined,
+    width?: number,
+    height?: number,
+): string {
+    if (width !== undefined && height !== undefined) return `${width}x${height}`;
+    const qualityLevel: JimengSizePreset = quality === 'normal' ? 'normal' : '2k';
+    return getClosestPresetSize(ar, qualityLevel);
+}
+
+function timestampHeader(): string {
+    return new Date().toISOString().replace(/[:-]|\.\d{3}/g, '');
+}
+
+interface JimengTaskResponse {
+    code?: number;
+    message?: string;
+    data?: { task_id?: string; status?: string; image_urls?: string[]; binary_data_base64?: string[] };
+}
+
+export const createJimeng: ProviderFactory = (options?: ProviderOptions): ImageProvider => {
+    const fetchFn = options?.fetch ?? fetch;
+    const env = options?.env ?? process.env;
+    const readEnv = (key: string): string => env[key] ?? '';
+
+    async function signedPost(
+        query: Record<string, string>,
+        body: string,
+        accessKey: string,
+        secretKey: string,
+        region: string,
+    ): Promise<Response> {
+        const base = readEnv('JIMENG_BASE_URL') || 'https://visual.volcengineapi.com';
+        const endpoint = resolveEndpoint(base, query);
+        const headers: Record<string, string> = {
+            'content-type': 'application/json',
+            'X-Date': timestampHeader(),
+            Host: endpoint.host,
+        };
+        const authorization = generateSignature(
+            'POST',
+            query,
+            headers,
+            body,
+            accessKey,
+            secretKey,
+            region,
+            'cv',
+            endpoint.canonicalUri,
+        );
+        return fetchFn(endpoint.url, { method: 'POST', headers: { ...headers, authorization }, body });
+    }
+
+    async function submitTask(
+        req: ImageRequest,
+        size: string,
+        accessKey: string,
+        secretKey: string,
+        region: string,
+    ): Promise<string> {
+        const query = { Action: 'CVSync2AsyncSubmitTask', Version: '2022-08-31' };
+        const [width, height] = size.split('x').map(Number) as [number, number];
+        const body = JSON.stringify({ req_key: req.model, prompt: req.prompt, width, height });
+        const res = await signedPost(query, body, accessKey, secretKey, region);
+        if (!res.ok) throw new Error(`Jimeng API submit error (${res.status}): ${await res.text()}`);
+        const result = (await res.json()) as JimengTaskResponse;
+        if (result.code !== 10_000 || result.data?.task_id === undefined) {
+            throw new Error(`Failed to submit task: ${result.message ?? 'Unknown error'}`);
+        }
+        return result.data.task_id;
+    }
+
+    async function pollForResult(
+        taskId: string,
+        req: ImageRequest,
+        accessKey: string,
+        secretKey: string,
+        region: string,
+    ): Promise<Uint8Array> {
+        const maxAttempts = 60;
+        const pollIntervalMs = 2000;
+        for (let attempt = 0; attempt < maxAttempts; attempt++) {
+            const query = { Action: 'CVSync2AsyncGetResult', Version: '2022-08-31' };
+            const body = JSON.stringify({ req_key: req.model, task_id: taskId });
+            const res = await signedPost(query, body, accessKey, secretKey, region);
+            if (!res.ok) throw new Error(`Jimeng API poll error (${res.status}): ${await res.text()}`);
+            const result = (await res.json()) as JimengTaskResponse;
+            if (result.code === 10_000 && result.data !== undefined) {
+                const { status, image_urls, binary_data_base64 } = result.data;
+                if (binary_data_base64 !== undefined && binary_data_base64.length > 0) {
+                    return new Uint8Array(Buffer.from(binary_data_base64[0] as string, 'base64'));
+                }
+                if (status === 'done' && image_urls !== undefined && image_urls.length > 0) {
+                    const url = image_urls[0] as string;
+                    const imgRes = await fetchFn(url);
+                    if (!imgRes.ok) throw new Error(`Failed to download image from ${url}`);
+                    return new Uint8Array(await imgRes.arrayBuffer());
+                }
+                if (status === 'in_queue' || status === 'generating') {
+                    await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
+                    continue;
+                }
+                if (status === 'fail') throw new Error(`Jimeng task failed: ${result.message ?? 'Generation failed'}`);
+            }
+            throw new Error(`Unexpected response during polling: ${result.message ?? 'Unknown error'}`);
+        }
+        throw new Error('Task timeout: image generation took too long');
+    }
+
+    async function generate(req: ImageRequest): Promise<ImageResult> {
+        if ((req.referenceImages?.length ?? 0) > 0) {
+            throw new Error(
+                'Jimeng does not support reference images. Use --provider google, openai, openrouter, or replicate.',
+            );
+        }
+        const accessKey = readEnv('JIMENG_ACCESS_KEY_ID');
+        const secretKey = readEnv('JIMENG_SECRET_ACCESS_KEY');
+        if (accessKey === '' || secretKey === '') {
+            throw new Error(
+                'JIMENG_ACCESS_KEY_ID and JIMENG_SECRET_ACCESS_KEY are required. Get your credentials from https://console.volcengine.com/iam/keymanage',
+            );
+        }
+        const region = readEnv('JIMENG_REGION') || 'cn-north-1';
+        const size = getImageSize(req.aspectRatio, req.quality, req.width, req.height);
+        const taskId = await submitTask(req, size, accessKey, secretKey, region);
+        const bytes = await pollForResult(taskId, req, accessKey, secretKey, region);
+        return { bytes, extension: 'png', provider: 'jimeng', model: req.model };
+    }
+
+    return {
+        name: 'jimeng',
+        defaultModel: () => DEFAULT_MODEL,
+        isAvailable: () => readEnv('JIMENG_ACCESS_KEY_ID') !== '' && readEnv('JIMENG_SECRET_ACCESS_KEY') !== '',
+        supportsReferenceImages: () => true,
+        generate,
+    };
+};