@wuyaos/pi-model-config 0.1.4 → 0.1.5

package/README.md

@@ -127,7 +127,7 @@ Chat 写入 Pi 标准 `models.json`。Classifier 和 image 通过 Pi 的原生 m
 - `xai-images`（xAI Images；默认 `https://api.x.ai/v1`；当前将 base64 结果标为 `image/jpeg`，待真实服务商响应验证）
 - `dashscope-images`（DashScope 同步 multimodal-generation；默认 `https://dashscope.aliyuncs.com/api/v1`）
 
-这四个新增协议由本插件直接实现请求级 `generateImages()`，**不经过宿主图像管线**。模型级 Base URL 优先，其次服务商 Base URL，最后才采用上列协议默认值；`openrouter-images` 与未知/自定义协议没有默认 URL，必须由用户明确填写。图像响应不计算 token/cost usage（保持为空）。DashScope 固定使用同步 `/services/aigc/multimodal-generation/generation`，解析 `output.choices[0].message.content[].image`（URL 字符串或 `{ url }`）；不发送 `X-DashScope-Async`。返回 URL 会经同源重定向、内网地址、30 秒和 10 MiB 限制后下载。
+这四个新增协议由本插件直接实现请求级 `generateImages()`，**不经过宿主图像管线**。模型级 Base URL 优先，其次服务商 Base URL，最后才采用上列协议默认值；`openrouter-images` 与未知/自定义协议没有默认 URL，必须由用户明确填写。图像响应不计算 token/cost usage（保持为空）。OpenAI 兼容网关的 `data[].url`（包括 `b64_json: null`）及 DashScope 的 `output.choices[0].message.content[].image`（URL 字符串或 `{ url }`）都会下载并转为 data URL；下载不携带认证头，逐跳重验私网/CGNAT/mapped-IPv6，允许公开对象存储跨源跳转，并有 30 秒和 10 MiB 限制。DashScope 不发送 `X-DashScope-Async`。
 
 支持的 chat API：
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wuyaos/pi-model-config",
-  "version": "0.1.4",
+  "version": "0.1.5",
   "type": "module",
   "description": "Pi provider 连接、远程发现与 chat/classifier/image 模型配置 TUI",
   "keywords": [

package/src/image-apis/common.ts

@@ -155,16 +155,16 @@ function timedSignal(signal: AbortSignal | undefined, timeoutMs: number): { sign
   const abort = () => controller.abort(signal?.reason);
   if (signal?.aborted) abort();
   else signal?.addEventListener("abort", abort, { once: true });
-  const timer = setTimeout(() => controller.abort(new Error("DashScope image download timed out")), timeoutMs);
+  const timer = setTimeout(() => controller.abort(new Error("Image download timed out")), timeoutMs);
   return { signal: controller.signal, dispose: () => { clearTimeout(timer); signal?.removeEventListener("abort", abort); } };
 }
 
 async function readLimitedBody(response: Response, limit: number): Promise<Uint8Array> {
   const contentLength = Number(response.headers.get("content-length"));
-  if (Number.isFinite(contentLength) && contentLength > limit) throw new Error(`DashScope image exceeds ${limit} byte limit`);
+  if (Number.isFinite(contentLength) && contentLength > limit) throw new Error(`Image download exceeds ${limit} byte limit`);
   if (!response.body) {
     const bytes = new Uint8Array(await response.arrayBuffer());
-    if (bytes.byteLength > limit) throw new Error(`DashScope image exceeds ${limit} byte limit`);
+    if (bytes.byteLength > limit) throw new Error(`Image download exceeds ${limit} byte limit`);
     return bytes;
   }
   const reader = response.body.getReader();
@@ -175,7 +175,7 @@ async function readLimitedBody(response: Response, limit: number): Promise<Uint8
       const next = await reader.read();
       if (next.done) break;
       size += next.value.byteLength;
-      if (size > limit) { await reader.cancel(); throw new Error(`DashScope image exceeds ${limit} byte limit`); }
+      if (size > limit) { await reader.cancel(); throw new Error(`Image download exceeds ${limit} byte limit`); }
       chunks.push(next.value);
     }
   } finally {
@@ -187,32 +187,46 @@ async function readLimitedBody(response: Response, limit: number): Promise<Uint8
   return bytes;
 }
 
-/** Downloads only public HTTP(S) URLs, preserves origin across at most five manual redirects, and sends no API headers. */
-export async function downloadDashScopeImage(urlValue: string, fetcher: FetchFunction, signal?: AbortSignal): Promise<{ mimeType: string; data: string }> {
+function sniffImageMime(bytes: Uint8Array): string | undefined {
+  if (bytes[0] === 0xff && bytes[1] === 0xd8) return "image/jpeg";
+  if (bytes[0] === 0x89 && bytes[1] === 0x50 && bytes[2] === 0x4e && bytes[3] === 0x47) return "image/png";
+  return undefined;
+}
+
+export interface DownloadImageUrlOptions {
+  fetch?: FetchFunction;
+  signal?: AbortSignal;
+  timeoutMs?: number;
+  sizeLimit?: number;
+}
+
+/** Downloads a public image without credentials. Every manually followed redirect is revalidated for SSRF. */
+export async function downloadImageUrl(urlValue: string, options: DownloadImageUrlOptions = {}): Promise<{ mimeType: string; data: string }> {
   const initial = validatePublicImageUrl(urlValue);
-  const origin = initial.origin;
-  const timed = timedSignal(signal, 30_000);
+  const fetcher = options.fetch ?? (globalThis.fetch as FetchFunction);
+  const timed = timedSignal(options.signal, options.timeoutMs ?? 30_000);
+  const sizeLimit = options.sizeLimit ?? 10 * 1024 * 1024;
   try {
     let current = initial;
     for (let redirects = 0; redirects <= 5; redirects++) {
       const response = await fetcher(current, { method: "GET", redirect: "manual", signal: timed.signal });
       if (redirectStatus(response.status)) {
-        if (redirects === 5) throw new Error("DashScope image redirect limit exceeded");
+        if (redirects === 5) throw new Error("Image download redirect limit exceeded");
         const location = response.headers.get("location");
-        if (!location) throw new Error(`DashScope image redirect ${response.status} lacks Location`);
+        if (!location) throw new Error(`Image download redirect ${response.status} lacks Location`);
+        // Signed-image CDNs may change public origins; each redirect must still pass URL and SSRF validation.
         const next = validatePublicImageUrl(new URL(location, current).toString());
-        if (next.origin !== origin) throw new Error("DashScope image redirect changed origin");
         await response.body?.cancel();
         current = next;
         continue;
       }
-      if (!response.ok) throw new Error(`DashScope image download failed: HTTP ${response.status}`);
-      const bytes = await readLimitedBody(response, 10 * 1024 * 1024);
+      if (!response.ok) throw new Error(`Image download failed: HTTP ${response.status}`);
+      const bytes = await readLimitedBody(response, sizeLimit);
       const contentType = response.headers.get("content-type")?.split(";", 1)[0]?.trim();
-      const mimeType = contentType?.startsWith("image/") ? contentType : "image/png";
+      const mimeType = contentType?.startsWith("image/") ? contentType : sniffImageMime(bytes) ?? "image/jpeg";
       return { mimeType, data: dataUrl(mimeType, Buffer.from(bytes).toString("base64")) };
     }
-    throw new Error("DashScope image redirect limit exceeded");
+    throw new Error("Image download redirect limit exceeded");
   } finally {
     timed.dispose();
   }

package/src/image-apis/dashscope.ts

@@ -1,5 +1,5 @@
 import type { AssistantImages, ImageModel, ImagesContext, ImagesOptions } from "@earendil-works/pi-ai";
-import { apiKey, downloadDashScopeImage, failedImageResult, fetchFor, imageResult, normalizeBaseUrl, promptFromContext, records, requestHeaders, resolveImageBaseUrl, responseJson } from "./common.ts";
+import { apiKey, downloadImageUrl, failedImageResult, fetchFor, imageResult, normalizeBaseUrl, promptFromContext, records, requestHeaders, resolveImageBaseUrl, responseJson } from "./common.ts";
 
 /** DashScope multimodal-generation synchronous endpoint. Deliberately does not set X-DashScope-Async. */
 export async function generateImages(model: ImageModel<string>, context: ImagesContext, options?: ImagesOptions, activeSecrets: readonly string[] = []): Promise<AssistantImages> {
@@ -31,7 +31,7 @@ export async function generateImages(model: ImageModel<string>, context: ImagesC
           ? String((imageField as Record<string, unknown>).url)
           : undefined;
       if (!url) continue;
-      const image = await downloadDashScopeImage(url, fetcher, options?.signal);
+      const image = await downloadImageUrl(url, { fetch: fetcher, signal: options?.signal });
       result.output.push({ type: "image", mimeType: image.mimeType, data: image.data });
     }
     if (!result.output.length) throw new Error("DashScope Images returned no downloadable image URLs");

package/src/image-apis/openai.ts

@@ -1,5 +1,5 @@
 import type { AssistantImages, ImageModel, ImagesContext, ImagesOptions } from "@earendil-works/pi-ai";
-import { apiKey, dataUrl, failedImageResult, fetchFor, imageResult, normalizeBaseUrl, promptFromContext, records, requestHeaders, resolveImageBaseUrl, responseJson } from "./common.ts";
+import { apiKey, dataUrl, downloadImageUrl, failedImageResult, fetchFor, imageResult, normalizeBaseUrl, promptFromContext, records, requestHeaders, resolveImageBaseUrl, responseJson } from "./common.ts";
 
 /** OpenAI Images API; this is a small request-local adapter, not Pi's host image pipeline. */
 export async function generateImages(model: ImageModel<string>, context: ImagesContext, options?: ImagesOptions, activeSecrets: readonly string[] = []): Promise<AssistantImages> {
@@ -20,11 +20,19 @@ export async function generateImages(model: ImageModel<string>, context: ImagesC
     });
     const json = await responseJson(response, options, activeSecrets) as Record<string, unknown>;
     const result = imageResult(model);
+    const fetcher = fetchFor(options);
     for (const item of records(json.data)) {
-      const encoded = typeof item.b64_json === "string" ? item.b64_json : undefined;
-      if (encoded) result.output.push({ type: "image", data: dataUrl("image/png", encoded), mimeType: "image/png" });
+      const encoded = typeof item.b64_json === "string" && item.b64_json ? item.b64_json : undefined;
+      if (encoded) {
+        result.output.push({ type: "image", data: dataUrl("image/png", encoded), mimeType: "image/png" });
+        continue;
+      }
+      if (typeof item.url === "string" && item.url) {
+        const image = await downloadImageUrl(item.url, { fetch: fetcher, signal: options?.signal });
+        result.output.push({ type: "image", data: image.data, mimeType: image.mimeType });
+      }
     }
-    if (!result.output.length) throw new Error("OpenAI Images returned no base64 image data");
+    if (!result.output.length) throw new Error("OpenAI Images returned no usable b64_json or url image data");
     return result;
   } catch (error) {
     return failedImageResult(model, error, options, activeSecrets);