infinite-canvas-local-proxy 0.2.1 → 0.2.3

package/README.md

@@ -56,8 +56,8 @@ http://127.0.0.1:23210/https://api.openai.com/v1/models
 - 默认数据目录为用户主目录下的 `.canvas-proxy`（Windows 为 `%USERPROFILE%\.canvas-proxy`），包括 `tasks.sqlite`、SQLite 日志文件和 `results/` 响应文件。备份时需停止代理后复制整个目录。
 - API Key、请求头和请求体仅在代理内存中用于上游请求；任务请求体、脚本上下文及 API Key 不写入数据库或任务日志。若上游响应或脚本错误中发现已识别的凭证原文，该结果不会保存或会在错误中脱敏。
 - 图片/视频脚本请求支持 JSON、文本、URL 编码和 multipart/form-data；multipart 文件在本地任务创建请求中临时 Base64 编码，代理端重建为 multipart 后发送。请求体总大小上限 80 MiB；独立二进制请求体不支持。
-- 默认最多同时执行 2 个任务、最多保留 4 个排队/运行任务；请求体上限 80 MiB、上游响应上限 100 MiB、单任务等待上限 30 分钟，成功/失败记录保留 24 小时。
-- 可通过环境变量 `CANVAS_PROXY_DATA_DIR`、`CANVAS_PROXY_TASK_CONCURRENCY`、`CANVAS_PROXY_TASK_OUTSTANDING_LIMIT`、`CANVAS_PROXY_TASK_REQUEST_LIMIT_BYTES`、`CANVAS_PROXY_TASK_RESPONSE_LIMIT_BYTES`、`CANVAS_PROXY_TASK_TIMEOUT_MS` 和 `CANVAS_PROXY_TASK_RETENTION_MS` 调整目录与限制。
+- 任务数量、并发数和单个生成脚本的请求次数均不设上限；任务提交后会立即启动。生成任务仍受单任务 60 分钟等待时限、单次上游请求 30 分钟超时、80 MiB 请求体和 100 MiB 响应大小限制。成功/失败记录保留 24 小时。
+- 可通过环境变量 `CANVAS_PROXY_DATA_DIR`、`CANVAS_PROXY_TASK_REQUEST_LIMIT_BYTES`、`CANVAS_PROXY_TASK_RESPONSE_LIMIT_BYTES`、`CANVAS_PROXY_TASK_TIMEOUT_MS` 和 `CANVAS_PROXY_TASK_RETENTION_MS` 调整目录与限制。
 - 代理进程重启时，原来排队或运行中的任务标记为“结果未知”，不会自动再次提交上游请求，以避免重复计费。已完成结果仍可从数据库记录和响应文件恢复，直至过期。
 - 代理只报告 queued/running/polling/完成/失败等本地状态，不提供或伪造供应商生成百分比。代理必须保持运行，才能在浏览器关闭后继续执行代理持有的请求或自定义脚本轮询。
 
@@ -106,4 +106,3 @@ Node 22.5 及以上首次加载内置 SQLite 时会打印一行 `ExperimentalWar
 rmdir /s /q "%LocalAppData%\npm-cache\_npx"     # Windows
 npm cache clean --force
 ```
-

package/index.js

@@ -24,12 +24,11 @@ const CORS_HEADERS = {
 const SKIP_REQUEST_HEADERS = new Set(["host", "connection", "content-length", "accept-encoding", "origin", "referer", "sec-fetch-dest", "sec-fetch-mode", "sec-fetch-site"]);
 /** fetch() already decoded and re-framed the body, so the upstream framing headers no longer apply. */
 const SKIP_RESPONSE_HEADERS = new Set(["content-encoding", "content-length", "transfer-encoding", "connection", "keep-alive"]);
-const TASK_TIMEOUT_MS = 30 * 60 * 1000;
+/** 异步生成任务的总生命周期：长视频、多轮素材处理都要能跑完，与 script-runner 的脚本超时对齐。 */
+const TASK_TIMEOUT_MS = 60 * 60 * 1000;
 const TASK_RETENTION_MS = 24 * 60 * 60 * 1000;
 const TASK_REQUEST_LIMIT = 80 * 1024 * 1024;
 const TASK_RESPONSE_LIMIT = 100 * 1024 * 1024;
-const TASK_CONCURRENCY = 2;
-const TASK_OUTSTANDING_LIMIT = 4;
 
 function positiveInteger(value, fallback) {
     const parsed = Number(value);
@@ -236,20 +235,16 @@ export function createProxyServer(options = {}) {
     const taskRetentionMs = positiveInteger(options.taskRetentionMs ?? process.env.CANVAS_PROXY_TASK_RETENTION_MS, TASK_RETENTION_MS);
     const taskRequestLimit = positiveInteger(options.taskRequestLimit ?? process.env.CANVAS_PROXY_TASK_REQUEST_LIMIT_BYTES, TASK_REQUEST_LIMIT);
     const taskResponseLimit = positiveInteger(options.taskResponseLimit ?? process.env.CANVAS_PROXY_TASK_RESPONSE_LIMIT_BYTES, TASK_RESPONSE_LIMIT);
-    const taskConcurrency = positiveInteger(options.taskConcurrency ?? process.env.CANVAS_PROXY_TASK_CONCURRENCY, TASK_CONCURRENCY);
-    const taskOutstandingLimit = positiveInteger(options.taskOutstandingLimit ?? process.env.CANVAS_PROXY_TASK_OUTSTANDING_LIMIT, TASK_OUTSTANDING_LIMIT);
     const queuedRequests = new Map();
-    let runningTasks = 0;
 
     const sendTaskError = (res, status, error) => sendJson(res, status, { error });
 
     const startQueuedTasks = () => {
-        while (runningTasks < taskConcurrency) {
+        while (true) {
             const next = queuedRequests.entries().next();
             if (next.done) return;
             const [taskId, taskRequest] = next.value;
             queuedRequests.delete(taskId);
-            runningTasks += 1;
             const execute = taskRequest.runner === "script" ? executeScriptTask : taskRequest.runner === "video" ? executeVideoTask : executeTask;
             void execute(taskId, taskRequest)
                 .catch(() => {
@@ -260,10 +255,7 @@ export function createProxyServer(options = {}) {
                     }
                     console.error("Persistent task worker failed; it will not be retried automatically.");
                 })
-                .finally(() => {
-                    runningTasks -= 1;
-                    startQueuedTasks();
-                });
+                .finally(startQueuedTasks);
         }
     };
 
@@ -327,7 +319,11 @@ export function createProxyServer(options = {}) {
         store.setStatus(taskId, "running", startedAt);
         const controller = new AbortController();
         const credentials = new Set(taskRequest.credentials);
-        const timeout = setTimeout(() => controller.abort(), taskTimeoutMs);
+        let timedOut = false;
+        const timeout = setTimeout(() => {
+            timedOut = true;
+            controller.abort();
+        }, taskTimeoutMs);
         try {
             const result = await runGenerationScriptTask(taskRequest.task, {
                 signal: controller.signal,
@@ -352,7 +348,17 @@ export function createProxyServer(options = {}) {
             store.setSucceeded(taskId, Date.now(), 200, "application/json; charset=utf-8", path.basename(responsePath));
             console.log(`${new Date().toLocaleTimeString()} task ${taskId.slice(0, 8)} -> completed ${((Date.now() - startedAt) / 1000).toFixed(1)}s`);
         } catch (error) {
-            const message = error && typeof error.message === "string" ? error.message : typeof error === "string" ? error : "Generation script failed.";
+            const rawMessage = String(
+                error && typeof error.message === "string" ? error.message : typeof error === "string" ? error : "Generation script failed.",
+            ).replace(/^Error:\s*/, "");
+            // 超时被 abort 时原始错误只是一句 Aborted，改成能看出是任务时长耗尽
+            const baseMessage = timedOut ? `Generation task exceeded the ${taskTimeoutMs >= 60000 ? `${Math.round(taskTimeoutMs / 60000)} minute` : `${Math.round(taskTimeoutMs / 1000)} second`} lifetime.` : rawMessage;
+            const upstream = error && typeof error === "object" ? error.upstream : null;
+            // 上游失败时把状态码与响应片段一并写进错误，否则只剩一句"脚本失败"，真因无从判断
+            const message =
+                upstream && !baseMessage.includes(`HTTP ${upstream.status}`)
+                    ? `${baseMessage.length > 300 ? `${baseMessage.slice(0, 300)}…` : baseMessage} | upstream ${upstream.status}${upstream.snippet ? `: ${upstream.snippet}` : ""}`
+                    : baseMessage;
             const safeMessage = [...credentials].filter(Boolean).reduce((text, credential) => text.replaceAll(credential, "[redacted]"), message).slice(0, 500);
             store.setStatus(taskId, controller.signal.aborted ? "failed" : "failed", Date.now(), safeMessage);
             console.log(`${new Date().toLocaleTimeString()} task ${taskId.slice(0, 8)} -> failed ${((Date.now() - startedAt) / 1000).toFixed(1)}s`);
@@ -713,10 +719,6 @@ export function createProxyServer(options = {}) {
                         return;
                     }
                 }
-                if (runningTasks + queuedRequests.size >= taskOutstandingLimit) {
-                    sendTaskError(res, 429, "The local image task queue is full.");
-                    return;
-                }
                 const taskId = randomBytes(32).toString("base64url");
                 const createdAt = Date.now();
                 const created = store.createOrGet({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "infinite-canvas-local-proxy",
-  "version": "0.2.1",
+  "version": "0.2.3",
   "description": "Minimal local forwarding proxy that lets the Infinite Canvas web app call AI provider APIs without CORS restrictions.",
   "license": "MIT",
   "type": "module",

package/script-runner.js

@@ -2,11 +2,31 @@ import { File } from "node:buffer";
 import { createHash } from "node:crypto";
 import vm from "node:vm";
 
-const SCRIPT_TIMEOUT_MS = 30 * 60 * 1000;
-const REQUEST_TIMEOUT_MS = 10 * 60 * 1000;
-const MAX_SCRIPT_REQUESTS = 32;
+/** 生成脚本的轮询生命周期上限：与 index.js 的任务总生命周期保持一致（60 分钟）。 */
+const SCRIPT_TIMEOUT_MS = 60 * 60 * 1000;
+/** 脚本内单次上游 HTTP 请求的超时：长任务里一次素材下载或视频渲染回调可能耗时较久。 */
+const REQUEST_TIMEOUT_MS = 30 * 60 * 1000;
 const mediaUploadCache = new Map();
 const MEDIA_UPLOAD_CACHE_LIMIT = 500;
+const abortPromises = new WeakMap();
+
+/** 每个任务信号只注册一次 abort 监听：轮询会反复执行脚本，逐次注册会累积成内存泄漏。 */
+function abortPromiseFor(signal) {
+    if (!signal) return new Promise(() => {});
+    const cached = abortPromises.get(signal);
+    if (cached) return cached;
+    const promise = new Promise((_, reject) => {
+        const fail = () => reject(new DOMException("Aborted", "AbortError"));
+        if (signal.aborted) {
+            fail();
+            return;
+        }
+        signal.addEventListener("abort", fail, { once: true });
+    });
+    promise.catch(() => {});
+    abortPromises.set(signal, promise);
+    return promise;
+}
 
 class ScriptFileReader {
     result = null;
@@ -75,6 +95,100 @@ function makeFile(value, fallbackName) {
     });
 }
 
+function sniffMime(bytes) {
+    const ascii = (start, end) => bytes.toString("ascii", start, end);
+    if (bytes.subarray(0, 8).equals(Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]))) return "image/png";
+    if (bytes[0] === 0xff && bytes[1] === 0xd8 && bytes[2] === 0xff) return "image/jpeg";
+    if (ascii(0, 4) === "RIFF" && ascii(8, 12) === "WEBP") return "image/webp";
+    if (ascii(0, 4) === "GIF8") return "image/gif";
+    if (ascii(0, 4) === "RIFF" && ascii(8, 12) === "WAVE") return "audio/wav";
+    if (ascii(0, 3) === "ID3" || (bytes[0] === 0xff && (bytes[1] & 0xe0) === 0xe0 && (bytes[1] & 0x06) !== 0)) return "audio/mpeg";
+    if (bytes.subarray(0, 4).equals(Buffer.from([0x1a, 0x45, 0xdf, 0xa3]))) return "video/webm";
+    if (ascii(0, 4) === "OggS") return "audio/ogg";
+    if (ascii(4, 8) === "ftyp") {
+        const brands = [ascii(8, 12), ...Array.from({ length: Math.floor(Math.max(0, bytes.length - 16) / 4) }, (_, index) => ascii(16 + index * 4, 20 + index * 4))];
+        if (brands.includes("qt  ")) return "video/quicktime";
+        if (brands.some((brand) => ["M4A ", "M4B ", "M4P "].includes(brand))) return "audio/mp4";
+        if (brands.some((brand) => ["avif", "avis"].includes(brand))) return "image/avif";
+        if (brands.some((brand) => ["heic", "heix", "hevc", "hevx"].includes(brand))) return "image/heic";
+        if (brands.some((brand) => ["mif1", "msf1"].includes(brand))) return "image/heif";
+        return "video/mp4";
+    }
+    return null;
+}
+
+export function createScriptOssUploader(endpoint, namespace, scriptFetch, signal) {
+    const mimeExtensions = {
+        "image/avif": "avif",
+        "image/gif": "gif",
+        "image/heic": "heic",
+        "image/heif": "heif",
+        "image/jpeg": "jpg",
+        "image/png": "png",
+        "image/webp": "webp",
+        "video/mp4": "mp4",
+        "video/quicktime": "mov",
+        "video/webm": "webm",
+        "audio/mp4": "m4a",
+        "audio/mpeg": "mp3",
+        "audio/ogg": "ogg",
+        "audio/wav": "wav",
+        "audio/x-wav": "wav",
+    };
+    return async (file) => {
+        if (!(file instanceof Blob)) throw new Error("uploadToOss requires a Blob or File.");
+        if (typeof endpoint !== "string" || !endpoint.trim()) throw new Error("The application OSS presign endpoint was not provided to the local proxy.");
+        let presignEndpoint;
+        try {
+            presignEndpoint = new URL(endpoint);
+        } catch {
+            throw new Error("The application OSS presign endpoint must be an absolute URL.");
+        }
+        if (!["http:", "https:"].includes(presignEndpoint.protocol)) throw new Error("The application OSS presign endpoint must use HTTP or HTTPS.");
+        return cacheMediaUpload(file, `${namespace}:oss-mime-v2`, async () => {
+            const declaredType = file.type.split(";", 1)[0].trim().toLowerCase();
+            const contentType = declaredType && declaredType !== "application/octet-stream" ? declaredType : sniffMime(Buffer.from(await file.slice(0, 32).arrayBuffer()));
+            if (!contentType) throw new Error("Could not identify the reference media type from its content.");
+            const extension = mimeExtensions[contentType];
+            if (!extension) throw new Error(`OSS upload does not support MIME type "${contentType}".`);
+            const originalName = typeof file.name === "string" ? file.name : "reference";
+            const basename = originalName.split(/[\\/]/).at(-1)?.replace(/\.[^.]*$/, "") || "reference";
+            const presignResponse = await scriptFetch(endpoint, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({ filename: `${basename}.${extension}`, contentType }),
+                signal,
+            });
+            const presignText = await presignResponse.text();
+            let presign;
+            try {
+                presign = presignText ? JSON.parse(presignText) : {};
+            } catch {
+                throw new Error(`OSS presign returned non-JSON (HTTP ${presignResponse.status}).`);
+            }
+            if (!presignResponse.ok) {
+                const detail = typeof presign.error === "string" ? presign.error : typeof presign.message === "string" ? presign.message : "";
+                throw new Error(detail || `Could not get OSS upload URL (HTTP ${presignResponse.status}).`);
+            }
+            if (typeof presign.uploadUrl !== "string" || typeof presign.publicUrl !== "string") {
+                throw new Error("OSS presign response must include uploadUrl and publicUrl.");
+            }
+            if (new URL(presign.uploadUrl).protocol !== "https:" || new URL(presign.publicUrl).protocol !== "https:") {
+                throw new Error("OSS upload and public media URLs must use HTTPS.");
+            }
+            const uploadContentType = typeof presign.contentType === "string" && presign.contentType ? presign.contentType : contentType;
+            const uploaded = await scriptFetch(presign.uploadUrl, {
+                method: "PUT",
+                headers: { "Content-Type": uploadContentType },
+                body: file,
+                signal,
+            });
+            if (!uploaded.ok) throw new Error(`OSS upload failed: HTTP ${uploaded.status}.`);
+            return presign.publicUrl;
+        });
+    };
+}
+
 function bodySize(data) {
     if (data === undefined || data === null) return 0;
     if (typeof data === "string") return Buffer.byteLength(data);
@@ -90,6 +204,29 @@ function bodySize(data) {
     return Buffer.byteLength(JSON.stringify(data));
 }
 
+function composeAbortSignal(signals, timeoutMs) {
+    const controller = new AbortController();
+    const listeners = [];
+    for (const signal of signals) {
+        if (!signal) continue;
+        if (signal.aborted) {
+            controller.abort(signal.reason);
+            break;
+        }
+        const abort = () => controller.abort(signal.reason);
+        signal.addEventListener("abort", abort, { once: true });
+        listeners.push([signal, abort]);
+    }
+    const timeout = setTimeout(() => controller.abort(new DOMException("The operation timed out.", "TimeoutError")), timeoutMs);
+    return {
+        signal: controller.signal,
+        dispose() {
+            clearTimeout(timeout);
+            for (const [signal, abort] of listeners) signal.removeEventListener("abort", abort);
+        },
+    };
+}
+
 async function responseData(response, responseType, limitBytes) {
     const contentType = response.headers.get("content-type") || "";
     const bytes = Buffer.from(await response.arrayBuffer());
@@ -107,12 +244,37 @@ async function responseData(response, responseType, limitBytes) {
     return text;
 }
 
-function createRequest({ signal, requestLimitBytes, responseLimitBytes, credentials, baseUrl }) {
-    let requestCount = 0;
-    const countRequest = () => {
-        requestCount += 1;
-        if (requestCount > MAX_SCRIPT_REQUESTS) throw new Error("A generation script exceeded the request count limit.");
-    };
+/**
+ * 记录最后一次上游失败响应的状态码与响应体片段，供任务失败时附加到错误信息里。
+ * 只读前 512 字节并立即取消，避免把整页错误 HTML 读进内存。
+ */
+function noteUpstreamFailure(trace, response, url) {
+    if (!trace || !response || response.ok) return;
+    const entry = { status: response.status, url: String(url || response.url || ""), snippet: "" };
+    trace.last = entry;
+    const reader = response.clone().body?.getReader();
+    if (!reader) return;
+    const decoder = new TextDecoder();
+    const chunks = [];
+    let bytes = 0;
+    (async () => {
+        try {
+            while (bytes < 512 && entry.snippet.length < 200) {
+                const { done, value } = await reader.read();
+                if (done) break;
+                bytes += value.byteLength;
+                chunks.push(decoder.decode(value, { stream: true }));
+                entry.snippet = chunks.join("").replace(/\s+/g, " ").trim().slice(0, 200);
+            }
+        } catch {
+            // 片段抓取失败不影响任务本身
+        } finally {
+            reader.cancel().catch(() => {});
+        }
+    })();
+}
+
+function createRequest({ signal, requestLimitBytes, responseLimitBytes, credentials, baseUrl, upstreamTrace }) {
     const recordCredentials = (target, headers) => {
         for (const [name, value] of headers.entries()) {
             if (/authorization|api.?key/i.test(name)) credentials.add(value.replace(/^bearer\s+/i, ""));
@@ -124,7 +286,6 @@ function createRequest({ signal, requestLimitBytes, responseLimitBytes, credenti
         }
     };
     const request = async (options) => {
-        countRequest();
         if (!isRecord(options) || typeof options.url !== "string") throw new Error("A generation script request needs a URL.");
         const requestBase = String(baseUrl || "").trim();
         const target = /^https?:\/\//i.test(options.url) ? new URL(options.url) : new URL(options.url, `${requestBase.replace(/\/+$/, "")}/`);
@@ -166,6 +327,7 @@ function createRequest({ signal, requestLimitBytes, responseLimitBytes, credenti
             const data = await responseData(response, options.responseType, responseLimitBytes);
             if (!response.ok) {
                 const detail = typeof data === "string" ? data.slice(0, 300) : JSON.stringify(data).slice(0, 300);
+                if (upstreamTrace) upstreamTrace.last = { status: response.status, url: target.href, snippet: String(detail || "").slice(0, 200) };
                 throw new Error(`Upstream request failed (HTTP ${response.status})${detail ? `: ${detail}` : ""}`);
             }
             return {
@@ -180,7 +342,6 @@ function createRequest({ signal, requestLimitBytes, responseLimitBytes, credenti
         }
     };
     const scriptFetch = async (input, init = {}) => {
-        countRequest();
         const requestInput = input instanceof Request ? input : null;
         const target = new URL(requestInput ? requestInput.url : String(input));
         if (!["http:", "https:", "data:"].includes(target.protocol)) throw new Error("Generation scripts may only fetch HTTP, HTTPS or data URLs.");
@@ -190,17 +351,54 @@ function createRequest({ signal, requestLimitBytes, responseLimitBytes, credenti
         if (init.body instanceof FormData && /^multipart\/form-data\s*$/i.test(headers.get("content-type") || "")) headers.delete("content-type");
         recordCredentials(target, headers);
         if (bodySize(init.body) > requestLimitBytes) throw new Error("Generation script request exceeds the configured size limit.");
-        const signals = [signal, init.signal || requestInput?.signal, AbortSignal.timeout(REQUEST_TIMEOUT_MS)].filter(Boolean);
-        const response = await fetch(input, { ...init, headers, signal: AbortSignal.any(signals) });
-        if (!response.body) return response;
+        const composed = composeAbortSignal([signal, init.signal || requestInput?.signal], REQUEST_TIMEOUT_MS);
+        let response;
+        try {
+            response = await fetch(input, { ...init, headers, signal: composed.signal });
+        } catch (error) {
+            composed.dispose();
+            throw error;
+        }
+        noteUpstreamFailure(upstreamTrace, response, target);
+        if (!response.body) {
+            composed.dispose();
+            return response;
+        }
+        const reader = response.body.getReader();
         let received = 0;
-        const limited = response.body.pipeThrough(new TransformStream({
-            transform(chunk, controller) {
-                received += chunk.byteLength;
-                if (received > responseLimitBytes) throw new Error("Script response exceeds the configured size limit.");
-                controller.enqueue(chunk);
+        const limited = new ReadableStream({
+            async pull(controller) {
+                try {
+                    const { done, value } = await reader.read();
+                    if (done) {
+                        controller.close();
+                        composed.dispose();
+                        return;
+                    }
+                    received += value.byteLength;
+                    if (received > responseLimitBytes) {
+                        try {
+                            await reader.cancel();
+                        } finally {
+                            composed.dispose();
+                        }
+                        controller.error(new Error("Script response exceeds the configured size limit."));
+                        return;
+                    }
+                    controller.enqueue(value);
+                } catch (error) {
+                    controller.error(error);
+                    composed.dispose();
+                }
             },
-        }));
+            async cancel(reason) {
+                try {
+                    await reader.cancel(reason);
+                } finally {
+                    composed.dispose();
+                }
+            },
+        });
         const wrapped = new Response(limited, { status: response.status, statusText: response.statusText, headers: response.headers });
         Object.defineProperties(wrapped, {
             url: { value: response.url },
@@ -282,6 +480,7 @@ async function runScript(script, input, request, scriptFetch, signal, timeoutMs)
         sleep,
         signal,
         cacheMediaUpload,
+        uploadToOss: createScriptOssUploader(input.ossPresignUrl, input.baseUrl, scriptFetch, signal),
         console: Object.freeze({ log() {}, warn() {}, error() {} }),
     });
     const context = vm.createContext(sandbox, { codeGeneration: { strings: false, wasm: false } });
@@ -291,7 +490,7 @@ async function runScript(script, input, request, scriptFetch, signal, timeoutMs)
     const timedOut = new Promise((_, reject) => {
         timeout = setTimeout(() => reject(new Error("Generation script timed out.")), timeoutMs);
     });
-    const aborted = signal ? new Promise((_, reject) => signal.addEventListener("abort", () => reject(new DOMException("Aborted", "AbortError")), { once: true })) : new Promise(() => {});
+    const aborted = abortPromiseFor(signal);
     try {
         return await Promise.race([result, timedOut, aborted]);
     } finally {
@@ -321,13 +520,43 @@ async function cacheMediaUpload(file, namespace, upload) {
     }
 }
 
+function throwIfTaskFailed(result, kind) {
+    if (kind === "image" ? hasImageResult(result) : hasVideoResult(result)) return;
+    const status = isRecord(result) ? String(result.status || "").toLowerCase() : "";
+    if (["failed", "error", "cancelled", "canceled"].includes(status)) {
+        const detail = result.error;
+        const message =
+            typeof detail === "string"
+                ? detail
+                : detail && typeof detail === "object"
+                  ? String(detail.message || JSON.stringify(detail))
+                  : String(result.message || "Generation task failed.");
+        throw new Error(message.slice(0, 500));
+    }
+    if (status && !isPending(result) && !["completed", "succeeded", "success", "done"].includes(status)) {
+        throw new Error("Generation script returned an unsupported task status.");
+    }
+}
+
+function decorateUpstreamFailure(error, upstreamTrace) {
+    const last = upstreamTrace?.last;
+    if (!last) return error;
+    const target = error instanceof Error ? error : new Error(String(error));
+    if (target.upstream) return target;
+    Object.defineProperty(target, "upstream", { value: last, enumerable: true, writable: true });
+    return target;
+}
+
 export async function runGenerationScriptTask(task, options) {
     if (!isRecord(task) || typeof task.script !== "string" || task.script.length > 256 * 1024) throw new Error("Generation script is missing or too large.");
     if (task.kind !== "image" && task.kind !== "video") throw new Error("Generation task kind is unsupported.");
     if (!isRecord(task.context)) throw new Error("Generation script context is invalid.");
-    const timeoutMs = options.timeoutMs;
+    // 调用方未传或传入非法值时回落到默认生命周期；否则 deadline 会被压成 1ms，任务瞬间失败
+    const requestedTimeoutMs = Number(options.timeoutMs);
+    const timeoutMs = Number.isFinite(requestedTimeoutMs) && requestedTimeoutMs > 0 ? requestedTimeoutMs : SCRIPT_TIMEOUT_MS;
     const credentials = options.credentials instanceof Set ? options.credentials : new Set(options.credentials || []);
-    const { request, scriptFetch } = createRequest({ ...options, credentials, baseUrl: task.context.baseUrl });
+    const upstreamTrace = { last: null };
+    const { request, scriptFetch } = createRequest({ ...options, credentials, baseUrl: task.context.baseUrl, upstreamTrace });
     options.credentials = credentials;
     const images = Array.isArray(task.context.images) ? task.context.images : [];
     const videos = Array.isArray(task.context.videos) ? task.context.videos.map((item, index) => makeFile(item, `video-${index + 1}`)) : [];
@@ -344,30 +573,34 @@ export async function runGenerationScriptTask(task, options) {
         apiKey: String(task.context.apiKey || ""),
         systemPrompt: String(task.context.systemPrompt || ""),
         reasoningEffort: String(task.context.reasoningEffort || ""),
+        ossPresignUrl: task.context.ossPresignUrl,
     };
-    let params = isRecord(task.context.params) ? { ...task.context.params, taskAction: "create" } : { taskAction: "create" };
-    let result = await runScript(task.script, { ...common, params }, request, scriptFetch, options.signal, timeoutMs);
-    let handle = taskHandle(result);
-    let polls = 0;
-    while (handle && polls < 1800) {
-        if (task.kind === "image" ? hasImageResult(result) : hasVideoResult(result)) break;
-        const status = isRecord(result) ? String(result.status || "").toLowerCase() : "";
-        if (["failed", "error", "cancelled", "canceled"].includes(status)) throw new Error(String(result.error?.message || result.error || result.message || "Generation task failed."));
-        if (status && !isPending(result) && !["completed", "succeeded", "success", "done"].includes(status)) throw new Error("Generation script returned an unsupported task status.");
-        options.onStatus?.("polling");
-        params = {
-            ...params,
-            taskAction: "poll",
-            taskId: handle.taskId,
-            ...(handle.taskData ? { taskData: handle.taskData } : {}),
-        };
-        await new Promise((resolve) => setTimeout(resolve, options.pollIntervalMs));
-        result = await runScript(task.script, { ...common, params }, request, scriptFetch, options.signal, timeoutMs);
-        handle = taskHandle(result) || handle;
-        polls += 1;
-    }
-    if (handle && polls >= 1800 && ! (task.kind === "image" ? hasImageResult(result) : hasVideoResult(result))) {
-        throw new Error("Generation script polling exceeded the task lifetime.");
+    const pollIntervalMs = Math.max(0, Number(options.pollIntervalMs) || 0);
+    // 护栏只表达时间：任务总时长由 timeoutMs 决定，不再用"第 N 次轮询"这种累计次数
+    const deadline = Date.now() + Math.max(1, Number(timeoutMs) || 0);
+    try {
+        let params = isRecord(task.context.params) ? { ...task.context.params, taskAction: "create" } : { taskAction: "create" };
+        let result = await runScript(task.script, { ...common, params }, request, scriptFetch, options.signal, timeoutMs);
+        throwIfTaskFailed(result, task.kind);
+        let handle = taskHandle(result);
+        while (handle) {
+            if (task.kind === "image" ? hasImageResult(result) : hasVideoResult(result)) break;
+            const remaining = deadline - Date.now();
+            if (remaining <= 0) throw new Error("Generation script polling exceeded the task lifetime.");
+            options.onStatus?.("polling");
+            params = {
+                ...params,
+                taskAction: "poll",
+                taskId: handle.taskId,
+                ...(handle.taskData ? { taskData: handle.taskData } : {}),
+            };
+            await new Promise((resolve) => setTimeout(resolve, Math.min(pollIntervalMs, remaining)));
+            result = await runScript(task.script, { ...common, params }, request, scriptFetch, options.signal, timeoutMs);
+            throwIfTaskFailed(result, task.kind);
+            handle = taskHandle(result) || handle;
+        }
+        return result;
+    } catch (error) {
+        throw decorateUpstreamFailure(error, upstreamTrace);
     }
-    return result;
 }