dsh-image-gen 0.1.0

package/lib/index.js

@@ -0,0 +1,525 @@
+import { credentialRef } from "@deepseek-ai/dsh-credentials";
+import { installSettingsSection, settingsNamespace } from "@deepseek-ai/dsh-settings";
+import { defineTool } from "@deepseek-ai/dsh-tools";
+import z from "@deepseek-ai/schemastery";
+//#region lib/types/shared.js
+/** Values shared by the Host and browser Bundle faces. */
+/** Browser route used by the generated-image card. */
+const IMAGE_ROUTE = "/plugins/dsh-image-gen/image";
+/** Namespace persisted through DSH Settings. */
+const IMAGE_GENERATION_NAMESPACE = "image-generation";
+/** Supported providers. */
+const IMAGE_PROVIDERS = [
+	"google",
+	"openai",
+	"seedream"
+];
+/** Default endpoints and base URLs. */
+const DEFAULT_GOOGLE_ENDPOINT = "https://generativelanguage.googleapis.com/v1beta/interactions";
+const DEFAULT_OPENAI_BASE_URL = "https://api.openai.com/v1";
+const DEFAULT_SEEDREAM_BASE_URL = "https://ark.cn-beijing.volces.com/api/v3";
+/** Default model names. */
+const DEFAULT_GOOGLE_MODEL = "gemini-3.1-flash-image";
+const DEFAULT_OPENAI_MODEL = "gpt-image-2";
+const DEFAULT_SEEDREAM_MODEL = "doubao-seedream-5-0-260128";
+//#endregion
+//#region lib/types/config.js
+/** User-facing configuration for supported image providers. */
+/** Google API credential reference. */
+const GOOGLE_API_KEY_ENV = "GEMINI_API_KEY";
+/** OpenAI Platform or compatible relay credential reference. */
+const OPENAI_API_KEY_ENV = "OPENAI_API_KEY";
+/** Volcengine Ark credential reference. */
+const SEEDREAM_API_KEY_ENV = "ARK_API_KEY";
+/** Cordis configuration schema. */
+const Config = z.object({
+	provider: z.union(IMAGE_PROVIDERS).default("google"),
+	googleModel: z.string().default(DEFAULT_GOOGLE_MODEL),
+	googleEndpoint: z.string().default(DEFAULT_GOOGLE_ENDPOINT),
+	openaiBaseURL: z.string().default(DEFAULT_OPENAI_BASE_URL),
+	openaiModel: z.string().default(DEFAULT_OPENAI_MODEL),
+	seedreamBaseURL: z.string().default(DEFAULT_SEEDREAM_BASE_URL),
+	seedreamModel: z.string().default(DEFAULT_SEEDREAM_MODEL)
+});
+/** Resolve exactly one provider profile for a tool call. */
+function resolveProvider(config) {
+	switch (config.provider ?? "google") {
+		case "openai": return {
+			provider: "openai",
+			apiKeyEnv: OPENAI_API_KEY_ENV,
+			model: config.openaiModel ?? "gpt-image-2",
+			baseURL: config.openaiBaseURL ?? "https://api.openai.com/v1",
+			imageSize: "1024x1024"
+		};
+		case "seedream": return {
+			provider: "seedream",
+			apiKeyEnv: SEEDREAM_API_KEY_ENV,
+			model: config.seedreamModel ?? "doubao-seedream-5-0-260128",
+			baseURL: config.seedreamBaseURL ?? "https://ark.cn-beijing.volces.com/api/v3",
+			imageSize: "2K"
+		};
+		case "google": return {
+			provider: "google",
+			apiKeyEnv: GOOGLE_API_KEY_ENV,
+			model: config.googleModel ?? "gemini-3.1-flash-image",
+			endpoint: config.googleEndpoint ?? "https://generativelanguage.googleapis.com/v1beta/interactions",
+			aspectRatio: "1:1",
+			imageSize: "1K"
+		};
+	}
+}
+//#endregion
+//#region lib/types/google.js
+const ERROR_LIMIT$1 = 4096;
+const REQUESTED_MEDIA_TYPE = "image/jpeg";
+/** Send one native Google image request and validate its inline image response. */
+async function generateGoogleImage(input) {
+	const response = await fetch(input.endpoint, {
+		method: "POST",
+		redirect: "error",
+		signal: input.signal,
+		headers: {
+			"content-type": "application/json",
+			"x-goog-api-key": input.apiKey
+		},
+		body: JSON.stringify({
+			model: input.model,
+			input: input.prompt,
+			response_format: {
+				type: "image",
+				mime_type: REQUESTED_MEDIA_TYPE,
+				aspect_ratio: input.aspectRatio,
+				image_size: input.imageSize
+			}
+		})
+	});
+	const text = await readBoundedText$1(response, Math.ceil(input.maxBytes * 1.4) + ERROR_LIMIT$1);
+	if (!response.ok) throw new Error(`Google image generation failed (${response.status}): ${text.slice(0, ERROR_LIMIT$1)}`);
+	let payload;
+	try {
+		payload = JSON.parse(text);
+	} catch {
+		throw new Error("Google image generation returned invalid JSON");
+	}
+	const image = outputImage(payload);
+	if (image === void 0) throw new Error(`Google image generation returned no image: ${text.slice(0, ERROR_LIMIT$1)}`);
+	const mediaType = mediaTypeOf(image.mime_type ?? REQUESTED_MEDIA_TYPE);
+	if (mediaType === void 0) throw new Error(`Google image generation returned unsupported media type ${JSON.stringify(image.mime_type)}`);
+	const data = decodeBase64$1(image.data);
+	if (data.byteLength > input.maxBytes) throw new Error(`Google image generation exceeded the ${String(input.maxBytes)} byte image limit`);
+	return {
+		data,
+		mediaType
+	};
+}
+function outputImage(value) {
+	const interaction = record$1(value);
+	if (interaction === void 0) return void 0;
+	const direct = imageContent(interaction.output_image, false);
+	if (direct !== void 0) return direct;
+	if (!Array.isArray(interaction.steps)) return void 0;
+	for (const step of interaction.steps) {
+		const modelOutput = record$1(step);
+		if (modelOutput?.type !== "model_output" || !Array.isArray(modelOutput.content)) continue;
+		for (const content of modelOutput.content) {
+			const image = imageContent(content, true);
+			if (image !== void 0) return image;
+		}
+	}
+}
+function imageContent(value, requiresImageType) {
+	const image = record$1(value);
+	if (image === void 0 || requiresImageType && image.type !== "image" || typeof image.data !== "string") return void 0;
+	return {
+		data: image.data,
+		mime_type: image.mime_type
+	};
+}
+function record$1(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
+}
+function mediaTypeOf(value) {
+	return value === "image/png" || value === "image/jpeg" || value === "image/webp" || value === "image/gif" ? value : void 0;
+}
+function decodeBase64$1(data) {
+	const clean = data.replace(/\s+/g, "");
+	if (clean.length === 0) throw new Error("Google image generation returned invalid base64 image data");
+	const decoded = Buffer.from(clean, "base64");
+	if (decoded.length === 0) throw new Error("Google image generation returned invalid base64 image data");
+	return new Uint8Array(decoded);
+}
+async function readBoundedText$1(response, maxBytes) {
+	if (response.body === null) return "";
+	const reader = response.body.getReader();
+	const chunks = [];
+	let bytes = 0;
+	try {
+		for (;;) {
+			const next = await reader.read();
+			if (next.done) break;
+			bytes += next.value.byteLength;
+			if (bytes > maxBytes) throw new Error(`Google image generation response exceeded the ${String(maxBytes)} byte limit`);
+			chunks.push(next.value);
+		}
+	} finally {
+		reader.releaseLock();
+	}
+	const joined = new Uint8Array(bytes);
+	let offset = 0;
+	for (const chunk of chunks) {
+		joined.set(chunk, offset);
+		offset += chunk.byteLength;
+	}
+	return new TextDecoder().decode(joined);
+}
+//#endregion
+//#region lib/types/image-route.js
+const MAX_BODY_BYTES = 4096;
+/** Serve one verified durable image reference to a same-origin browser request. */
+async function serveImage(req, res, deps) {
+	if (req.method !== "POST") return jsonError(res, 405, "method-not-allowed");
+	if (!(req.headers["content-type"] ?? "").toLowerCase().startsWith("application/json")) return jsonError(res, 415, "json-required");
+	const origin = req.headers.origin;
+	const host = req.headers.host;
+	if (origin !== void 0 && host !== void 0 && origin !== `http://${host}` && origin !== `https://${host}`) return jsonError(res, 403, "origin-rejected");
+	let body;
+	try {
+		body = JSON.parse(await readBody(req));
+	} catch {
+		return jsonError(res, 400, "invalid-request");
+	}
+	const attachment = attachmentFromRequest(body);
+	if (attachment === void 0) return jsonError(res, 400, "invalid-attachment");
+	try {
+		const stored = await deps.readImage(attachment);
+		res.writeHead(200, {
+			"content-type": stored.ref.mediaType,
+			"content-length": String(stored.data.byteLength),
+			"cache-control": "private, no-store",
+			"x-content-type-options": "nosniff"
+		});
+		res.end(stored.data);
+	} catch {
+		jsonError(res, 404, "image-unavailable");
+	}
+}
+/** Validate the persisted reference carried by a tool presentation. */
+function imageAttachmentFromMeta(meta) {
+	const value = record(meta);
+	if (value?.kind !== "dsh-image-gen") return void 0;
+	return imageAttachment(value.attachment);
+}
+function attachmentFromRequest(value) {
+	return imageAttachment(record(value)?.attachment);
+}
+function imageAttachment(value) {
+	const ref = record(value);
+	if (ref === void 0) return void 0;
+	if (typeof ref.attachmentId !== "string" || !mediaType(ref.mediaType) || typeof ref.bytes !== "number" || typeof ref.width !== "number" || typeof ref.height !== "number") return void 0;
+	if (ref.name !== void 0 && typeof ref.name !== "string") return void 0;
+	return ref;
+}
+function mediaType(value) {
+	return value === "image/png" || value === "image/jpeg" || value === "image/webp" || value === "image/gif";
+}
+function record(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
+}
+async function readBody(req) {
+	const chunks = [];
+	let bytes = 0;
+	for await (const chunk of req) {
+		const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+		bytes += buffer.byteLength;
+		if (bytes > MAX_BODY_BYTES) throw new Error("request too large");
+		chunks.push(buffer);
+	}
+	return Buffer.concat(chunks).toString("utf8");
+}
+function jsonError(res, status, code) {
+	res.writeHead(status, {
+		"content-type": "application/json",
+		"cache-control": "no-store"
+	});
+	res.end(JSON.stringify({ error: code }));
+}
+//#endregion
+//#region lib/types/openai-compatible.js
+const ERROR_LIMIT = 4096;
+/** Generate an image from an OpenAI-compatible endpoint. */
+async function generateOpenAICompatibleImage(input) {
+	const response = await fetch(imageEndpoint(input.baseURL), {
+		method: "POST",
+		redirect: "error",
+		signal: input.signal,
+		headers: {
+			authorization: `Bearer ${input.apiKey}`,
+			"content-type": "application/json"
+		},
+		body: JSON.stringify({
+			model: input.model,
+			prompt: input.prompt,
+			size: input.size,
+			...input.provider === "seedream" ? { response_format: "url" } : {}
+		})
+	});
+	const text = await readBoundedText(response, Math.ceil(input.maxBytes * 1.4) + ERROR_LIMIT);
+	if (!response.ok) throw new Error(`${input.provider} image generation failed (${response.status}): ${text.slice(0, ERROR_LIMIT)}`);
+	let payload;
+	try {
+		payload = JSON.parse(text);
+	} catch {
+		throw new Error(`${input.provider} image generation returned invalid JSON`);
+	}
+	const image = firstImage(payload);
+	if (image === void 0) throw new Error(`${input.provider} image generation returned no image: ${text.slice(0, ERROR_LIMIT)}`);
+	if (image.b64_json !== void 0) return {
+		data: decodeBase64(image.b64_json, input.provider),
+		mediaType: "image/png"
+	};
+	return downloadImage(image.url, input);
+}
+function imageEndpoint(baseURL) {
+	try {
+		return new URL("images/generations", baseURL.endsWith("/") ? baseURL : `${baseURL}/`).toString();
+	} catch {
+		throw new Error("Image generation endpoint must be an absolute URL");
+	}
+}
+function firstImage(value) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return void 0;
+	const data = value.data;
+	if (!Array.isArray(data) || data.length === 0) return void 0;
+	const candidate = data[0];
+	if (typeof candidate !== "object" || candidate === null || Array.isArray(candidate)) return void 0;
+	const item = candidate;
+	return typeof item.b64_json === "string" ? { b64_json: item.b64_json } : typeof item.url === "string" ? { url: item.url } : void 0;
+}
+async function downloadImage(url, input) {
+	if (url === void 0) throw new Error(`${input.provider} image generation returned no image data`);
+	const response = await fetch(url, {
+		redirect: "follow",
+		signal: input.signal
+	});
+	if (!response.ok) throw new Error(`${input.provider} image download failed (${response.status})`);
+	const mediaType = imageMediaType(response.headers.get("content-type"));
+	if (mediaType === void 0) throw new Error(`${input.provider} image download returned unsupported content type`);
+	return {
+		data: await readBoundedBytes(response, input.maxBytes),
+		mediaType
+	};
+}
+function decodeBase64(value, provider) {
+	const clean = value.replace(/\s+/g, "");
+	if (clean.length === 0) throw new Error(`${provider} image generation returned invalid base64 image data`);
+	const decoded = Buffer.from(clean, "base64");
+	if (decoded.length === 0) throw new Error(`${provider} image generation returned invalid base64 image data`);
+	return new Uint8Array(decoded);
+}
+function imageMediaType(value) {
+	const mediaType = value?.split(";", 1)[0]?.trim().toLowerCase();
+	return mediaType === "image/png" || mediaType === "image/jpeg" || mediaType === "image/webp" || mediaType === "image/gif" ? mediaType : void 0;
+}
+async function readBoundedText(response, maxBytes) {
+	return new TextDecoder().decode(await readBoundedBytes(response, maxBytes));
+}
+async function readBoundedBytes(response, maxBytes) {
+	if (response.body === null) return /* @__PURE__ */ new Uint8Array();
+	const reader = response.body.getReader();
+	const chunks = [];
+	let bytes = 0;
+	try {
+		for (;;) {
+			const next = await reader.read();
+			if (next.done) break;
+			bytes += next.value.byteLength;
+			if (bytes > maxBytes) throw new Error(`Image response exceeded the ${String(maxBytes)} byte limit`);
+			chunks.push(next.value);
+		}
+	} finally {
+		reader.releaseLock();
+	}
+	const joined = new Uint8Array(bytes);
+	let offset = 0;
+	for (const chunk of chunks) {
+		joined.set(chunk, offset);
+		offset += chunk.byteLength;
+	}
+	return joined;
+}
+//#endregion
+//#region lib/types/index.js
+/** Cordis plugin name. */
+const name = "dsh-image-gen";
+/** Host services required by the Bundle. */
+const inject = [
+	"tools",
+	"attachments",
+	"credentials",
+	"webServer"
+];
+/** Register settings, the image route, and the model-callable tool. */
+function apply(ctx, config = {}) {
+	let current = () => config;
+	installSettingsSection(ctx, settingsNamespace(IMAGE_GENERATION_NAMESPACE), Config, config, {
+		setSource: (source) => {
+			current = source;
+		},
+		onChange: () => {}
+	});
+	ctx.effect(() => ctx.webServer.register({
+		kind: "exact",
+		path: IMAGE_ROUTE,
+		handler: (req, res) => serveImage(req, res, { readImage: (ref) => ctx.attachments.readImage(ref) })
+	}), "dsh-image-gen: image route");
+	ctx.tools.register(defineTool({
+		name: "generate_image",
+		description: "Generate one image with the configured image provider. Use when the user explicitly asks to create or draw an image. Give a complete visual prompt including subject, composition, style, lighting, and any exact text that should appear. A successful image is already attached directly to the conversation and has no local file path; do not call read, glob, or other tools to locate or verify it.",
+		parameters: {
+			prompt: {
+				type: "string",
+				required: true,
+				description: "Complete description of the image to generate."
+			},
+			aspect_ratio: {
+				type: "string",
+				enum: [
+					"1:1",
+					"3:2",
+					"2:3",
+					"4:3",
+					"3:4",
+					"16:9",
+					"9:16"
+				],
+				description: "Optional output aspect ratio for Google Gemini."
+			},
+			image_size: {
+				type: "string",
+				enum: [
+					"1K",
+					"2K",
+					"4K"
+				],
+				description: "Optional output resolution for Google Gemini."
+			},
+			size: {
+				type: "string",
+				description: "Optional dimensions or size tier for OpenAI or Seedream."
+			}
+		},
+		output: {
+			schema: {
+				type: "object",
+				additionalProperties: false,
+				properties: {
+					attachment: {
+						type: "object",
+						required: true,
+						additionalProperties: false,
+						properties: {
+							attachmentId: {
+								type: "string",
+								required: true
+							},
+							mediaType: {
+								type: "string",
+								required: true
+							},
+							bytes: {
+								type: "integer",
+								required: true
+							},
+							width: {
+								type: "integer",
+								required: true
+							},
+							height: {
+								type: "integer",
+								required: true
+							},
+							name: { type: "string" }
+						}
+					},
+					provider: {
+						type: "string",
+						required: true
+					},
+					model: {
+						type: "string",
+						required: true
+					},
+					output: {
+						type: "string",
+						required: true
+					}
+				}
+			},
+			render: (_args, value) => [{
+				type: "text",
+				text: `Generated one image with ${value.provider}/${value.model} (${value.output}). It is already attached to the conversation with no local file path; respond to the user without reading or searching for it.`
+			}],
+			presentationMeta: (_args, value) => ({
+				kind: "dsh-image-gen",
+				attachment: value.attachment
+			})
+		},
+		async execute(args, exec) {
+			const active = resolveProvider(current());
+			const credential = await ctx.credentials.resolve(credentialRef(active.apiKeyEnv));
+			if (credential === void 0 || credential.value.length === 0) throw new Error(`generate_image requires the ${active.apiKeyEnv} credential; configure it in Settings > Plugins > Image generation.`);
+			if (active.provider === "google") {
+				const aspectRatio = args.aspect_ratio ?? active.aspectRatio;
+				const imageSize = args.image_size ?? active.imageSize;
+				return saveGenerated(ctx, await generateGoogleImage({
+					apiKey: credential.value,
+					endpoint: active.endpoint,
+					model: active.model,
+					prompt: args.prompt,
+					aspectRatio,
+					imageSize,
+					maxBytes: ctx.attachments.imageLimits.maxImageBytes,
+					signal: exec.signal
+				}), active.provider, active.model, `${aspectRatio}, ${imageSize}`);
+			}
+			const size = args.size ?? active.imageSize;
+			return saveGenerated(ctx, await generateOpenAICompatibleImage({
+				provider: active.provider,
+				apiKey: credential.value,
+				baseURL: active.baseURL,
+				model: active.model,
+				prompt: args.prompt,
+				size,
+				maxBytes: ctx.attachments.imageLimits.maxImageBytes,
+				signal: exec.signal
+			}), active.provider, active.model, size);
+		},
+		presentResult: (_args, result) => imagePresentation(result)
+	}));
+}
+async function saveGenerated(ctx, generated, provider, model, output) {
+	if (!ctx.attachments.imageLimits.mediaTypes.includes(generated.mediaType)) throw new Error(`This DSH deployment does not accept ${generated.mediaType} generated images`);
+	return {
+		attachment: await ctx.attachments.saveImage({
+			data: generated.data,
+			mediaType: generated.mediaType,
+			name: "generated-image"
+		}),
+		provider,
+		model,
+		output
+	};
+}
+function imagePresentation(result) {
+	const attachment = imageAttachmentFromMeta(result.meta);
+	return attachment === void 0 ? void 0 : {
+		card: "generic",
+		title: "Generated image",
+		content: [{
+			type: "image",
+			attachment
+		}]
+	};
+}
+//#endregion
+export { Config, IMAGE_ROUTE, apply, imageAttachmentFromMeta, inject, name };

package/lib/types/client/index.d.ts

@@ -0,0 +1,30 @@
+import type { Context } from '@deepseek-ai/cordis';
+import type { ConnectionHandle } from '@deepseek-ai/dsh-client-connection/client';
+import type { SettingsScope } from '@deepseek-ai/dsh-client-runtime/client';
+import type { InjectFace, PropsRuntime } from '@deepseek-ai/dsh-client-ui-slots';
+import { type ImageProvider } from '../shared.js';
+type Provider = ImageProvider;
+interface ImageSettings {
+    provider?: Provider;
+    googleModel?: string;
+    googleEndpoint?: string;
+    openaiBaseURL?: string;
+    openaiModel?: string;
+    seedreamBaseURL?: string;
+    seedreamModel?: string;
+}
+interface SettingsFace {
+    scope: SettingsScope<ImageSettings>;
+    credentials: ConnectionHandle['api']['credentials'];
+}
+type SettingsCardProps = PropsRuntime<'settings.plugin.item'> & InjectFace<SettingsFace>;
+type ImageCardProps = PropsRuntime<'tool.call.toolview'>;
+/** Required browser services. */
+export declare const inject: string[];
+/** Mount the settings card and generated-image card. */
+export declare function apply(ctx: Context): void;
+/** Edit provider settings and its write-only API credential. */
+export declare function ImageGenerationSettingsCard(props: SettingsCardProps): import("react").JSX.Element;
+/** Render the durable attachment referenced by a completed image tool call. */
+export declare function GeneratedImageCard(props: ImageCardProps): import("react").JSX.Element;
+export {};

package/lib/types/config.d.ts

@@ -0,0 +1,48 @@
+/** User-facing configuration for supported image providers. */
+import z from '@deepseek-ai/schemastery';
+import { DEFAULT_GOOGLE_ENDPOINT, DEFAULT_GOOGLE_MODEL, DEFAULT_OPENAI_BASE_URL, DEFAULT_OPENAI_MODEL, DEFAULT_SEEDREAM_BASE_URL, DEFAULT_SEEDREAM_MODEL, IMAGE_PROVIDERS, type ImageProvider } from './shared.js';
+export { DEFAULT_GOOGLE_ENDPOINT, DEFAULT_GOOGLE_MODEL, DEFAULT_OPENAI_BASE_URL, DEFAULT_OPENAI_MODEL, DEFAULT_SEEDREAM_BASE_URL, DEFAULT_SEEDREAM_MODEL, IMAGE_PROVIDERS, type ImageProvider, };
+/** Google API credential reference. */
+export declare const GOOGLE_API_KEY_ENV = "GEMINI_API_KEY";
+/** OpenAI Platform or compatible relay credential reference. */
+export declare const OPENAI_API_KEY_ENV = "OPENAI_API_KEY";
+/** Volcengine Ark credential reference. */
+export declare const SEEDREAM_API_KEY_ENV = "ARK_API_KEY";
+/** Google tool-level controls. */
+export declare const ASPECT_RATIOS: readonly ["1:1", "3:2", "2:3", "4:3", "3:4", "16:9", "9:16"];
+export declare const IMAGE_SIZES: readonly ["1K", "2K", "4K"];
+export type AspectRatio = typeof ASPECT_RATIOS[number];
+export type ImageSize = typeof IMAGE_SIZES[number];
+/** Bundle configuration from the profile patch and the Web settings page. */
+export interface Config {
+    provider?: ImageProvider;
+    googleModel?: string;
+    googleEndpoint?: string;
+    openaiBaseURL?: string;
+    openaiModel?: string;
+    seedreamBaseURL?: string;
+    seedreamModel?: string;
+}
+/** Cordis configuration schema. */
+export declare const Config: z<Config>;
+/** Resolve exactly one provider profile for a tool call. */
+export declare function resolveProvider(config: Config): {
+    provider: 'google';
+    apiKeyEnv: string;
+    model: string;
+    endpoint: string;
+    aspectRatio: AspectRatio;
+    imageSize: ImageSize;
+} | {
+    provider: 'openai';
+    apiKeyEnv: string;
+    model: string;
+    baseURL: string;
+    imageSize: string;
+} | {
+    provider: 'seedream';
+    apiKeyEnv: string;
+    model: string;
+    baseURL: string;
+    imageSize: string;
+};

package/lib/types/google.d.ts

@@ -0,0 +1,19 @@
+/** Google Gemini Interactions API adapter. */
+import type { ImageMediaType } from '@deepseek-ai/dsh-attachment';
+import type { AspectRatio, ImageSize } from './config.js';
+/** Image bytes returned before Attachment persistence. */
+export interface GeneratedImage {
+    data: Uint8Array;
+    mediaType: ImageMediaType;
+}
+/** Send one native Google image request and validate its inline image response. */
+export declare function generateGoogleImage(input: {
+    apiKey: string;
+    endpoint: string;
+    model: string;
+    prompt: string;
+    aspectRatio: AspectRatio;
+    imageSize: ImageSize;
+    maxBytes: number;
+    signal: AbortSignal;
+}): Promise<GeneratedImage>;

package/lib/types/image-route.d.ts

@@ -0,0 +1,12 @@
+/** Same-origin HTTP bridge from the Web result card to the Attachment service. */
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import type { ImageAttachmentRef, StoredImageAttachment } from '@deepseek-ai/dsh-attachment';
+export { IMAGE_ROUTE } from './shared.js';
+/** Dependencies required by the image route. */
+export interface ImageRouteDeps {
+    readImage(ref: ImageAttachmentRef): Promise<StoredImageAttachment>;
+}
+/** Serve one verified durable image reference to a same-origin browser request. */
+export declare function serveImage(req: IncomingMessage, res: ServerResponse, deps: ImageRouteDeps): Promise<void>;
+/** Validate the persisted reference carried by a tool presentation. */
+export declare function imageAttachmentFromMeta(meta: unknown): ImageAttachmentRef | undefined;

package/lib/types/index.d.ts

@@ -0,0 +1,11 @@
+/** Multi-provider image-generation Bundle for DeepSeek Harness. */
+import type { Context } from '@deepseek-ai/cordis';
+import { Config } from './config.js';
+export { Config } from './config.js';
+export { IMAGE_ROUTE, imageAttachmentFromMeta } from './image-route.js';
+/** Cordis plugin name. */
+export declare const name = "dsh-image-gen";
+/** Host services required by the Bundle. */
+export declare const inject: string[];
+/** Register settings, the image route, and the model-callable tool. */
+export declare function apply(ctx: Context, config?: Config): void;

package/lib/types/openai-compatible.d.ts

@@ -0,0 +1,18 @@
+/** OpenAI Images API and Volcengine Ark/Seedream response adapter. */
+import type { ImageMediaType } from '@deepseek-ai/dsh-attachment';
+/** One generated raster normalized before Attachment persistence. */
+export interface GeneratedCompatibleImage {
+    data: Uint8Array;
+    mediaType: ImageMediaType;
+}
+/** Generate an image from an OpenAI-compatible endpoint. */
+export declare function generateOpenAICompatibleImage(input: {
+    provider: 'openai' | 'seedream';
+    apiKey: string;
+    baseURL: string;
+    model: string;
+    prompt: string;
+    size: string;
+    maxBytes: number;
+    signal: AbortSignal;
+}): Promise<GeneratedCompatibleImage>;

package/lib/types/shared.d.ts

@@ -0,0 +1,18 @@
+/** Values shared by the Host and browser Bundle faces. */
+/** Browser route used by the generated-image card. */
+export declare const IMAGE_ROUTE = "/plugins/dsh-image-gen/image";
+/** Namespace persisted through DSH Settings. */
+export declare const IMAGE_GENERATION_NAMESPACE = "image-generation";
+/** Supported providers. */
+export declare const IMAGE_PROVIDERS: readonly ["google", "openai", "seedream"];
+export type ImageProvider = typeof IMAGE_PROVIDERS[number];
+/** Default endpoints and base URLs. */
+export declare const DEFAULT_GOOGLE_ENDPOINT = "https://generativelanguage.googleapis.com/v1beta/interactions";
+export declare const DEFAULT_OPENAI_BASE_URL = "https://api.openai.com/v1";
+export declare const DEFAULT_SEEDREAM_BASE_URL = "https://ark.cn-beijing.volces.com/api/v3";
+/** Default model names. */
+export declare const DEFAULT_GOOGLE_MODEL = "gemini-3.1-flash-image";
+export declare const DEFAULT_OPENAI_MODEL = "gpt-image-2";
+export declare const DEFAULT_SEEDREAM_MODEL = "doubao-seedream-5-0-260128";
+export declare const DEFAULT_MODELS: Record<ImageProvider, string>;
+export declare const DEFAULT_BASE_URLS: Record<ImageProvider, string>;