Deploy 653775e to Docker Space

Source: MisonL/gpt-image-playground-customer@653775e99286817989ad7a4dfb56eedae605cdcb

AGENTS.md

@@ -13,7 +13,7 @@
 
 - 项目是 Next.js 16 + React 19 的本地图片服务，默认端口 `4783`。
 - 包管理工具是 `npm`，锁文件是 `package-lock.json`。
-- Node 版本要求是 `>=20.0.0`。
+- Node 版本要求是 `>=20.9.0`。
 - 主要页面入口是 `src/app/page.tsx`。
 - 图片 API 入口是 `src/app/api/images/route.ts`。
 - Agent API 位于 `src/app/api/agent/`。

README.md

@@ -102,7 +102,7 @@ start-windows.bat
 | 默认后端 | `IMAGE_GENERATION_BACKEND` | 默认 `images-api`；可设为 `responses-image-generation`。 |
 | Responses 顶层模型 | `OPENAI_RESPONSES_API_MODEL` | 仅在 `responses-image-generation` 后端生效；作为 `/responses` 的顶层 `model`，例如 `gpt-5.4`。 |
 | 流式策略 | `IMAGE_STREAMING_STRATEGY` | 默认 `auto`；可设为 `off`、`openai-sse`、`responses-sse` 等。 |
-| 渠道请求方式 | `OPENAI_UPSTREAM_REQUEST_MODES`、`OPENAI_CHANNEL_N_REQUEST_MODES` | 可选。声明全局或单渠道可用方式：`images-non-stream`、`images-sse`、`responses-non-stream`、`responses-sse`；旧后端名别名仅为兼容输入，建议使用这四个规范值。 |
+| 渠道请求方式 | `OPENAI_UPSTREAM_REQUEST_MODES`、`OPENAI_CHANNEL_N_REQUEST_MODES` | 可选。声明全局或单渠道可用方式；每个渠道只保留真实 smoke 通过的模式。新上游若 `/v1/responses` 返回 `403 Image generation is not enabled for this group`，就不要把 `responses-non-stream`、`responses-sse` 放进该渠道白名单。 |
 | 并发容量 | `OPENAI_MAX_STREAMS_PER_CREDENTIAL` | 单个渠道凭证允许同时执行的图片请求数，默认 `1`。 |
 | 渠道队列 | `OPENAI_CHANNEL_QUEUE_ENABLED`、`OPENAI_CHANNEL_QUEUE_MAX_WAIT_MS`、`OPENAI_CHANNEL_QUEUE_MAX_SIZE` | 控制超出凭证容量时等待还是立即失败。 |
 | 失败冷却 | `OPENAI_CHANNEL_FAILURE_COOLDOWN_ENABLED`、`OPENAI_CHANNEL_FAILURE_COOLDOWN_MS` | 控制失败渠道、凭证或已识别请求方式是否临时移出路由池。 |
@@ -139,7 +139,7 @@ OPENAI_CHANNEL_3_UPSTREAM_PROFILE=matsca
 注意：
 
 - 自定义 API URL 必须同时填写自定义 API Key，避免服务端密钥被发送到未知地址。
-- `OPENAI_CHANNEL_N_REQUEST_MODES` 是管理员基于真实上游 smoke 设置的服务端白名单；全局默认可用 `OPENAI_UPSTREAM_REQUEST_MODES`。`/api/runtime-capabilities` 的 `channelRouting.requestModeControls`、`channelRouting.requestModeHealth` 和 Agent capabilities 的 `request_mode_controls` 会暴露配置入口、健康覆盖和对应真实 smoke gate。Agent 客户端只提交业务意图，不应自行选择 Images、Responses、SSE 或非流式路径。`stream_mode=auto` 可由服务端在 SSE 不可用时显式退到非流式并标记 fallback；`stream_mode=stream` 或显式页面 SSE 诊断必须失败可见，不会静默降级。真实执行后可从 `execution.channel_request_mode`、`execution.channel_request_mode_fallback_applied` 和 `execution.route_decision` 读取服务端实际选路结果；失败冷却若能关联到本次服务端 request mode，会只冷却该渠道或凭证的对应 request mode，并在 `error.diagnostics.cooldown_target.request_mode` 暴露。
+- `OPENAI_CHANNEL_N_REQUEST_MODES` 是管理员基于真实上游 smoke 设置的服务端白名单；全局默认可用 `OPENAI_UPSTREAM_REQUEST_MODES`。`/api/runtime-capabilities` 的 `channelRouting.requestModeControls`、`channelRouting.requestModeHealth` 和 Agent capabilities 的 `request_mode_controls` 会暴露配置入口、健康覆盖和对应真实 smoke gate。Agent 客户端只提交业务意图，不应自行选择 Images、Responses、SSE 或非流式路径。`stream_mode=auto` 可由服务端在 SSE 不可用时显式退到非流式并标记 fallback；`stream_mode=stream` 或显式页面 SSE 诊断必须失败可见，不会静默降级。真实执行后可从 `execution.channel_request_mode`、`execution.channel_request_mode_fallback_applied` 和 `execution.route_decision` 读取服务端实际选路结果；失败冷却若能关联到本次服务端 request mode，会只冷却该渠道或凭证的对应 request mode，并在 `error.diagnostics.cooldown_target.request_mode` 暴露。新上游接入时先用真实 smoke 确认每个请求方式，再把 `OPENAI_CHANNEL_N_REQUEST_MODES` 收窄到通过的最小集合。
 - 渠道恢复探测使用非计费 `GET /models` 只确认 host、鉴权和 models 端点恢复；它不能替代 request mode 的真实 Images/Responses/SSE smoke。管理员应以真实 smoke 结果决定 `OPENAI_CHANNEL_N_REQUEST_MODES`。
 - Docker compose 本身不把默认图片后端改成 Responses；未在 `.env.local` 显式配置时仍是 `images-api` 和 `auto`。
 - Responses image backend 需要 `ENABLE_RESPONSES_IMAGE_BACKEND=true` 和 `OPENAI_RESPONSES_API_MODEL`。生成意图也可以用 `responsesModel`、`responses_model`、`gptModel` 或 `gpt_model` 覆盖单次 `/responses` 顶层模型；这些字段只影响本项目的 `responses-image-generation` 路径，不会改变兼容上游自身 `/v1/images/generations` 桥接层内部选择的模型。
@@ -359,7 +359,7 @@ Hugging Face Space 免费层部署见 [docs/deployment/huggingface-space-free.md
 
 | 问题 | 处理 |
 | --- | --- |
-| 未检测到 Node.js | 安装 Node.js 20 或更高版本。 |
+| 未检测到 Node.js | 安装 Node.js >=20.9.0。 |
 | 依赖安装失败 | 检查 npm 网络后重新执行 `npm install`。 |
 | API 返回 HTML | API URL 填成了网��或管理后台；应填写 OpenAI 兼容 `/v1` 根地址。 |
 | 提示需要 API Key | 在 `.env.local` 写入 `OPENAI_API_KEY`，或在页面 `API 设置` 中填写。 |

docs/deployment/huggingface-space-free.md

@@ -42,7 +42,7 @@ hf auth whoami
 
 要求：
 
-- Node.js 20 或更高版本。
+- Node.js >=20.9.0。
 - npm 随 Node.js 一起可用。
 - Hugging Face CLI 使用当前官方 `hf` 命令。
 - `hf auth login` 使用 Hugging Face Access Token，不是账号密码。

public/hf-space-deploy-marker.json

@@ -1,6 +1,6 @@
 {
   "schema_version": 1,
-  "local_sha": "c2357572329b70e2e3b953be74f8d0cedafef5f5",
-  "created_at": "2026-06-29T10:57:33.027Z",
-  "deploy_id": "a2febf58-db5e-4d67-a4b0-7968d3d42118"
+  "local_sha": "653775e99286817989ad7a4dfb56eedae605cdcb",
+  "created_at": "2026-06-30T11:54:17.314Z",
+  "deploy_id": "5a7966ca-fd3b-44a4-aea7-e7a5a4566be3"
 }

scripts/agent-doctor.mjs

@@ -12,6 +12,8 @@ import { CHANNEL_REQUEST_MODES, CHANNEL_REQUEST_MODE_SMOKE_CASES } from '../src/
 const GENERATE_SCRIPT = fileURLToPath(new URL('../skills/gpt-image-playground-agent/scripts/generate-image.mjs', import.meta.url));
 const EDIT_SCRIPT = fileURLToPath(new URL('../skills/gpt-image-playground-agent/scripts/edit-image.mjs', import.meta.url));
 const AGENT_DOCTOR_TIMEOUT_MS = 75_000;
+const ORCHESTRATION_GENERATE_SMOKE_NAME = 'orchestration_generate_1k';
+const AGENT_GENERATE_SMOKE_NAME = 'agent_generate_1k';
 const PAGE_SSE_GENERATE_SMOKE_NAME = 'responses_page_sse_generate_1k';
 const RESPONSES_AGENT_GENERATE_SMOKE_NAME = 'responses_agent_generate_1k';
 
@@ -131,7 +133,8 @@ function buildSkippedSmoke(options) {
         skipped: true,
         reason: 'requires --allow-billable',
         checks: [
-            { name: 'generate_1k', skipped: true, reason: 'requires --allow-billable' },
+            { name: ORCHESTRATION_GENERATE_SMOKE_NAME, skipped: true, reason: 'requires --allow-billable' },
+            { name: AGENT_GENERATE_SMOKE_NAME, skipped: true, reason: 'requires --allow-billable' },
             { name: PAGE_SSE_GENERATE_SMOKE_NAME, skipped: true, reason: 'requires --allow-billable' },
             { name: RESPONSES_AGENT_GENERATE_SMOKE_NAME, skipped: true, reason: 'requires --allow-billable' },
             {
@@ -150,7 +153,26 @@ function buildSkippedSmoke(options) {
 
 function runBillableSmoke(options, baseUrl) {
     const checks = [
-        runSmokeCommand('generate_1k', [
+        runSmokeCommand(ORCHESTRATION_GENERATE_SMOKE_NAME, [
+            GENERATE_SCRIPT,
+            '--base-url',
+            baseUrl,
+            '--allow-billable',
+            '--timeout-ms',
+            String(options.timeoutMs),
+            '--size',
+            '1024x1024',
+            '--quality',
+            'low',
+            '--image-backend',
+            'images-api',
+            '--stream-mode',
+            'non_stream',
+            '--idempotency-key',
+            `agent-doctor-orchestration-generate-${Date.now()}`,
+            'agent doctor orchestration 1k generate smoke'
+        ]),
+        runSmokeCommand(AGENT_GENERATE_SMOKE_NAME, [
             GENERATE_SCRIPT,
             '--base-url',
             baseUrl,
@@ -162,9 +184,13 @@ function runBillableSmoke(options, baseUrl) {
             '1024x1024',
             '--quality',
             'low',
+            '--image-backend',
+            'images-api',
+            '--stream-mode',
+            'non_stream',
             '--idempotency-key',
-            `agent-doctor-generate-${Date.now()}`,
-            'agent doctor 1k generate smoke'
+            `agent-doctor-agent-generate-${Date.now()}`,
+            'agent doctor agent JSON 1k generate smoke'
         ]),
         runSmokeCommand(PAGE_SSE_GENERATE_SMOKE_NAME, [
             GENERATE_SCRIPT,
@@ -383,6 +409,8 @@ function buildSummary({ capabilities, runtime, contract, smoke }) {
                 ? Boolean(process.env.GPT_IMAGE_APP_PASSWORD_HASH)
                 : capabilities.ok,
         page_sse_real_smoke: summarizePageSseSmoke(smoke),
+        orchestration_generate_smoke: summarizeSmokeCheck(smoke, ORCHESTRATION_GENERATE_SMOKE_NAME),
+        agent_generate_smoke: summarizeSmokeCheck(smoke, AGENT_GENERATE_SMOKE_NAME),
         responses_page_sse_generate_smoke: summarizeSmokeCheck(smoke, PAGE_SSE_GENERATE_SMOKE_NAME),
         responses_agent_generate_smoke: summarizeSmokeCheck(smoke, RESPONSES_AGENT_GENERATE_SMOKE_NAME),
         real_smoke_checks: summarizeSmokeChecks(smoke),
@@ -442,7 +470,8 @@ function summarizePageSseSmoke(smoke) {
 
 function summarizeSmokeChecks(smoke) {
     return {
-        agent_generate_1k: summarizeSmokeCheck(smoke, 'generate_1k'),
+        orchestration_generate_1k: summarizeSmokeCheck(smoke, ORCHESTRATION_GENERATE_SMOKE_NAME),
+        agent_generate_1k: summarizeSmokeCheck(smoke, AGENT_GENERATE_SMOKE_NAME),
         responses_page_sse_generate_1k: summarizeSmokeCheck(smoke, PAGE_SSE_GENERATE_SMOKE_NAME),
         responses_agent_generate_1k: summarizeSmokeCheck(smoke, RESPONSES_AGENT_GENERATE_SMOKE_NAME),
         agent_edit_1k: summarizeSmokeCheck(smoke, 'edit_1k'),

scripts/command-center.test.mjs

@@ -586,6 +586,14 @@ describe('Command center scripts', () => {
                         has_password_hash: false,
                         has_any_auth: true
                     });
+                    assert.deepEqual(report.agent_auth_service, {
+                        required: true,
+                        required_schemes: ['bearer'],
+                        ready: true,
+                        has_token: true,
+                        has_password_hash: false,
+                        has_any_auth: true
+                    });
                     assert.deepEqual(report.private_agent_env, {
                         exists: true,
                         has_token: true,
@@ -633,6 +641,55 @@ describe('Command center scripts', () => {
         );
     });
 
+    it('treats bearer-required services as not ready when only APP_PASSWORD is loaded', async () => {
+        const tempDir = await mkdtemp(path.join(os.tmpdir(), 'first-run-auth-bearer-'));
+        await writeFile(path.join(tempDir, 'package.json'), JSON.stringify({ name: 'demo', version: '1.0.0' }));
+        await withServer(
+            (_request, response) => {
+                response.writeHead(200, { 'content-type': 'application/json' });
+                response.end(
+                    JSON.stringify({
+                        auth: { schemes: ['bearer'] },
+                        defaults: { state_backend: 'memory' }
+                    })
+                );
+            },
+            async (baseUrl) => {
+                try {
+                    const report = await buildFirstRunReport(
+                        {
+                            cwd: tempDir,
+                            baseUrl,
+                            envFiles: ['.env.agent.local'],
+                            timeoutMs: 1000
+                        },
+                        { GPT_IMAGE_APP_PASSWORD_HASH: 'shell-secret' }
+                    );
+
+                    assert.deepEqual(report.agent_auth_process, {
+                        has_token: false,
+                        has_password_hash: true,
+                        has_any_auth: true
+                    });
+                    assert.deepEqual(report.agent_auth_service, {
+                        required: true,
+                        required_schemes: ['bearer'],
+                        ready: false,
+                        has_token: false,
+                        has_password_hash: false,
+                        has_any_auth: false
+                    });
+                    assert.match(formatFirstRunText(report), /当前进程鉴权：已加载访问码哈希/);
+                    assert.match(formatFirstRunText(report), /服务鉴权：未满足当前服务鉴权要求/);
+                    assert.match(JSON.stringify(report.next_actions), /GPT_IMAGE_AGENT_TOKEN/);
+                    assert.doesNotMatch(JSON.stringify(report.next_actions), /GPT_IMAGE_APP_PASSWORD_HASH/);
+                } finally {
+                    await rm(tempDir, { recursive: true, force: true });
+                }
+            }
+        );
+    });
+
     it('formats first-run as human-readable text by default', async () => {
         const report = await buildFirstRunReport(
             { cwd: process.cwd(), baseUrl: 'not a url', envFiles: [] },
@@ -889,8 +946,11 @@ describe('Command center scripts', () => {
                 assert.equal(body.summary.page_sse_auth_ready, false);
                 assert.equal(body.summary.page_sse_declared_supported, true);
                 assert.equal(body.summary.page_sse_real_smoke, 'skipped');
+                assert.equal(body.summary.orchestration_generate_smoke, 'skipped');
+                assert.equal(body.summary.agent_generate_smoke, 'skipped');
                 assert.equal(body.summary.responses_page_sse_generate_smoke, 'skipped');
                 assert.deepEqual(body.summary.real_smoke_checks, {
+                    orchestration_generate_1k: 'skipped',
                     agent_generate_1k: 'skipped',
                     responses_page_sse_generate_1k: 'skipped',
                     responses_agent_generate_1k: 'skipped',
@@ -908,6 +968,10 @@ describe('Command center scripts', () => {
                 assert.deepEqual(body.summary.request_modes.smoke['responses-non-stream'].checks, [
                     'responses_agent_generate_1k'
                 ]);
+                assert.deepEqual(body.summary.request_modes.smoke['images-non-stream'].checks, [
+                    'orchestration_generate_1k',
+                    'edit_1k'
+                ]);
                 assert.equal(body.summary.request_modes.smoke['responses-non-stream'].state, 'skipped');
                 assert.equal(body.summary.request_modes.smoke['responses-sse'].state, 'skipped');
                 assert.equal(body.summary.request_modes.smoke['responses-sse'].billable, false);
@@ -1071,26 +1135,85 @@ describe('Command center scripts', () => {
                     return;
                 }
                 if (request.url === '/api/agent/image-requests') {
-                    response.writeHead(400, { 'content-type': 'application/json' });
+                    if (request.headers['idempotency-key']) {
+                        response.writeHead(202, { 'content-type': 'application/json' });
+                        response.end(
+                            JSON.stringify({
+                                job: {
+                                    id: 'doctor-orchestration-job',
+                                    state: 'running',
+                                    result_url: '/api/agent/jobs/doctor-orchestration-job/result',
+                                    retry_after_seconds: 1
+                                }
+                            })
+                        );
+                    } else {
+                        response.writeHead(400, { 'content-type': 'application/json' });
+                        response.end(
+                            JSON.stringify({
+                                error: {
+                                    code: 'idempotency_key_required',
+                                    message: 'missing key',
+                                    retryable: false
+                                }
+                            })
+                        );
+                    }
+                    return;
+                }
+                if (request.url === '/api/agent/jobs/doctor-orchestration-job/result') {
+                    response.writeHead(200, { 'content-type': 'application/json' });
                     response.end(
                         JSON.stringify({
-                            error: {
-                                code: 'idempotency_key_required',
-                                message: 'missing key',
-                                retryable: false
+                            request_id: 'doctor-orchestration-job',
+                            idempotency_key: 'agent-doctor-orchestration-generate',
+                            cached: false,
+                            images: [{ id: 'doctor-orchestration', filename: 'doctor-orchestration.png' }],
+                            execution: {
+                                transport: 'server_orchestrated',
+                                endpoint: '/api/agent/image-requests',
+                                route_mode: 'auto',
+                                image_backend: 'images-api',
+                                stream_mode: 'non_stream',
+                                streaming_strategy: 'off',
+                                channel_request_mode: 'images-non-stream',
+                                channel_request_mode_fallback_applied: false
                             }
                         })
                     );
                     return;
                 }
                 if (request.url === '/api/agent/jobs/images/generate') {
-                    response.writeHead(400, { 'content-type': 'application/json' });
+                    response.writeHead(202, { 'content-type': 'application/json' });
                     response.end(
                         JSON.stringify({
-                            error: {
-                                code: 'idempotency_key_required',
-                                message: 'missing key',
-                                retryable: false
+                            job: {
+                                id: 'doctor-agent-job',
+                                state: 'running',
+                                result_url: '/api/agent/jobs/doctor-agent-job/result',
+                                retry_after_seconds: 1
+                            }
+                        })
+                    );
+                    return;
+                }
+                if (request.url === '/api/agent/jobs/doctor-agent-job/result') {
+                    response.writeHead(200, { 'content-type': 'application/json' });
+                    response.end(
+                        JSON.stringify({
+                            request_id: 'doctor-agent-job',
+                            idempotency_key: 'agent-doctor-agent-generate',
+                            cached: false,
+                            images: [{ id: 'doctor-agent', filename: 'doctor-agent.png' }],
+                            execution: {
+                                transport: 'agent_json',
+                                endpoint: '/api/agent/jobs/images/generate',
+                                route_mode: 'agent',
+                                image_backend: 'images-api',
+                                stream_mode: 'non_stream',
+                                streaming_strategy: 'off',
+                                channel_request_mode: 'images-non-stream',
+                                channel_request_mode_fallback_applied: false
                             }
                         })
                     );
@@ -1110,8 +1233,11 @@ describe('Command center scripts', () => {
                 assert.equal(body.service_base_url_source, 'user_provided');
                 assert.equal(body.interactive_confirmation_required, false);
                 assert.equal(body.summary.page_sse_real_smoke, 'passed');
+                assert.equal(body.summary.orchestration_generate_smoke, 'passed');
+                assert.equal(body.summary.agent_generate_smoke, 'passed');
                 assert.equal(body.summary.responses_page_sse_generate_smoke, 'passed');
                 assert.equal(body.summary.responses_agent_generate_smoke, 'passed');
+                assert.equal(body.summary.real_smoke_checks.orchestration_generate_1k, 'passed');
                 assert.equal(body.summary.real_smoke_checks.agent_generate_1k, 'passed');
                 assert.equal(body.summary.real_smoke_checks.responses_page_sse_generate_1k, 'passed');
                 assert.equal(body.summary.real_smoke_checks.responses_agent_generate_1k, 'passed');
@@ -1136,6 +1262,11 @@ describe('Command center scripts', () => {
                         JSON.stringify({
                             defaults: { state_backend: 'memory' },
                             storage: { image_storage_mode: 'indexeddb', postgres_configured: false },
+                            orchestration: {
+                                supported: true,
+                                endpoint: '/api/agent/image-requests',
+                                transport_selection: 'server_owned'
+                            },
                             agent_streaming: { page_sse: { supported: true } },
                             agent_jobs: { supported: true },
                             routing_rules: {},
@@ -1171,6 +1302,55 @@ describe('Command center scripts', () => {
                     response.end(JSON.stringify({ images: [{ id: 'doctor-generate', filename: 'doctor.png' }] }));
                     return;
                 }
+                if (request.url === '/api/agent/image-requests') {
+                    if (request.headers['idempotency-key']) {
+                        response.writeHead(202, { 'content-type': 'application/json' });
+                        response.end(
+                            JSON.stringify({
+                                job: {
+                                    id: 'doctor-orchestration-job',
+                                    state: 'running',
+                                    result_url: '/api/agent/jobs/doctor-orchestration-job/result',
+                                    retry_after_seconds: 1
+                                }
+                            })
+                        );
+                    } else {
+                        response.writeHead(400, { 'content-type': 'application/json' });
+                        response.end(
+                            JSON.stringify({
+                                error: {
+                                    code: 'idempotency_key_required',
+                                    message: 'missing key',
+                                    retryable: false
+                                }
+                            })
+                        );
+                    }
+                    return;
+                }
+                if (request.url === '/api/agent/jobs/doctor-orchestration-job/result') {
+                    response.writeHead(200, { 'content-type': 'application/json' });
+                    response.end(
+                        JSON.stringify({
+                            request_id: 'doctor-orchestration-job',
+                            idempotency_key: 'agent-doctor-orchestration-generate',
+                            cached: false,
+                            images: [{ id: 'doctor-orchestration', filename: 'doctor-orchestration.png' }],
+                            execution: {
+                                transport: 'server_orchestrated',
+                                endpoint: '/api/agent/image-requests',
+                                route_mode: 'auto',
+                                image_backend: 'images-api',
+                                stream_mode: 'non_stream',
+                                streaming_strategy: 'off',
+                                channel_request_mode: 'images-non-stream',
+                                channel_request_mode_fallback_applied: false
+                            }
+                        })
+                    );
+                    return;
+                }
                 if (request.url === '/api/images') {
                     (async () => {
                         const requestText = await readRequestText(request);
@@ -1214,8 +1394,11 @@ describe('Command center scripts', () => {
                 assert.equal(body.ok, false);
                 assert.equal(body.summary.billable_smoke, 'failed');
                 assert.equal(body.summary.page_sse_real_smoke, 'failed');
+                assert.equal(body.summary.orchestration_generate_smoke, 'passed');
+                assert.equal(body.summary.agent_generate_smoke, 'passed');
                 assert.equal(body.summary.responses_page_sse_generate_smoke, 'failed');
                 assert.equal(body.summary.responses_agent_generate_smoke, 'passed');
+                assert.equal(body.summary.real_smoke_checks.orchestration_generate_1k, 'passed');
                 assert.equal(body.summary.real_smoke_checks.agent_generate_1k, 'passed');
                 assert.equal(body.summary.real_smoke_checks.responses_page_sse_generate_1k, 'failed');
                 assert.equal(body.summary.real_smoke_checks.responses_agent_generate_1k, 'passed');

scripts/doctor-hf-space.mjs

@@ -14,7 +14,7 @@ import {
     validateSpaceUrl
 } from './hf-space-doctor-utils.mjs';
 
-const MIN_NODE_MAJOR = 20;
+const MIN_NODE_VERSION = '>=20.9.0';
 const REQUIRED_SPACE_VARIABLES = ['AGENT_STATE_BACKEND', 'NEXT_PUBLIC_IMAGE_STORAGE_MODE'];
 const RECOMMENDED_SPACE_VARIABLES = ['APP_LOG_LEVEL'];
 const REQUIRED_SPACE_VARIABLE_VALUES = new Map([
@@ -46,12 +46,14 @@ function addCheck(checks, status, name, message, details = {}) {
 }
 
 function checkNode(checks) {
-    const major = Number.parseInt(process.versions.node.split('.')[0], 10);
-    if (major >= MIN_NODE_MAJOR) {
+    const match = process.version.match(/^v(\d+)\.(\d+)\./);
+    const major = match ? Number(match[1]) : 0;
+    const minor = match ? Number(match[2]) : 0;
+    if (major > 20 || (major === 20 && minor >= 9)) {
         addCheck(checks, 'pass', 'node', `Node.js ${process.version} is supported.`);
         return;
     }
-    addCheck(checks, 'fail', 'node', `Node.js ${process.version} is too old. Install Node.js ${MIN_NODE_MAJOR} or newer.`);
+    addCheck(checks, 'fail', 'node', `Node.js ${process.version} is too old. Install Node.js ${MIN_NODE_VERSION} or newer.`);
 }
 
 function checkCommand(checks, name, command, args, failureAction) {
@@ -179,7 +181,7 @@ function main() {
 
     const checks = [];
     checkNode(checks);
-    checkCommand(checks, 'npm', 'npm', ['--version'], 'npm is missing. Install Node.js 20 or newer with npm.');
+    checkCommand(checks, 'npm', 'npm', ['--version'], `npm is missing. Install Node.js ${MIN_NODE_VERSION} or newer with npm.`);
     const hfAvailable = checkCommand(checks, 'hf-cli', 'hf', ['version'], 'hf CLI is missing. Install the Hugging Face CLI.');
     const hfAuth = hfAvailable ? runDoctorCommand('hf', ['auth', 'whoami']) : { ok: false };
     if (hfAvailable && hfAuth.ok) {

scripts/first-run.mjs

@@ -12,6 +12,7 @@ import {
 
 const DEFAULT_TIMEOUT_MS = 3000;
 const DEFAULT_ENV_FILES = ['.env.local', '.env.agent.local'];
+const MIN_NODE_VERSION = '>=20.9.0';
 
 function parseArgs(argv) {
     const parsed = {
@@ -58,7 +59,7 @@ export async function buildFirstRunReport(options = {}, env = process.env) {
               timeoutMs: options.timeoutMs || DEFAULT_TIMEOUT_MS,
               headers: authHeaders(env)
           });
-    const agentAuth = readAgentAuthState(env, envSummary);
+    const agentAuth = readAgentAuthState(env, envSummary, service);
     const checks = buildChecks({
         cwd,
         env,
@@ -76,6 +77,7 @@ export async function buildFirstRunReport(options = {}, env = process.env) {
         service_base_url_source: base.source,
         interactive_confirmation_required: base.interactive_confirmation_required,
         agent_auth_process: agentAuth.process,
+        agent_auth_service: agentAuth.service,
         private_agent_env: agentAuth.privateEnv,
         checks,
         env_sources: envSummary.map((source) => summarizeEnvSource(source, cwd)),
@@ -139,12 +141,11 @@ function buildChecks({ cwd, env, envSummary, service, base, validationError }) {
     const packageJson = readPackageJson(cwd);
     const packageLock = existsSync(join(cwd, 'package-lock.json'));
     const nodeModules = existsSync(join(cwd, 'node_modules'));
-    const currentToken = Boolean(env.GPT_IMAGE_AGENT_TOKEN || env.GPT_IMAGE_APP_PASSWORD_HASH);
-    const fileToken = envSummary.some((source) =>
-        ['GPT_IMAGE_AGENT_TOKEN', 'GPT_IMAGE_APP_PASSWORD_HASH'].some((name) => sourceHasSetVariable(source, name))
-    );
+    const agentAuthSchemes = readAgentAuthSchemes(service);
+    const currentAgentAuth = hasAnyConfiguredAgentAuth(env, agentAuthSchemes);
+    const fileAgentAuth = envSummary.some((source) => hasAnyConfiguredAgentAuthSource(source, agentAuthSchemes));
     return [
-        { name: 'node_version', ok: node.ok, current: node.current, required: '>=20.0.0' },
+        { name: 'node_version', ok: node.ok, current: node.current, required: MIN_NODE_VERSION },
         { name: 'package_lock', ok: packageLock },
         {
             name: 'dependencies_installed',
@@ -159,9 +160,10 @@ function buildChecks({ cwd, env, envSummary, service, base, validationError }) {
         },
         {
             name: 'agent_auth_available_to_process',
-            ok: currentToken,
+            ok: currentAgentAuth,
             skipped: !requiresAgentAuth(service),
-            auth_in_private_env_file: fileToken
+            auth_in_private_env_file: fileAgentAuth,
+            required_schemes: agentAuthSchemes
         },
         {
             name: 'page_sse_auth_available_to_process',
@@ -203,16 +205,26 @@ function buildChecks({ cwd, env, envSummary, service, base, validationError }) {
     ];
 }
 
-function readAgentAuthState(env, envSummary) {
+function readAgentAuthState(env, envSummary, service) {
     const hasToken = Boolean(env.GPT_IMAGE_AGENT_TOKEN);
     const hasPasswordHash = Boolean(env.GPT_IMAGE_APP_PASSWORD_HASH);
     const privateSource = envSummary.find((source) => source.path.endsWith('.env.agent.local'));
+    const requiredSchemes = readAgentAuthSchemes(service);
+    const serviceRequiresAuth = requiresAgentAuth(service);
     return {
         process: {
             has_token: hasToken,
             has_password_hash: hasPasswordHash,
             has_any_auth: hasToken || hasPasswordHash
         },
+        service: {
+            required: serviceRequiresAuth,
+            required_schemes: requiredSchemes,
+            ready: serviceRequiresAuth ? hasAnyConfiguredAgentAuth(env, requiredSchemes) : false,
+            has_token: requiredSchemes.includes('bearer') ? hasToken : false,
+            has_password_hash: requiredSchemes.includes('x-app-password-hash') ? hasPasswordHash : false,
+            has_any_auth: serviceRequiresAuth ? hasAnyConfiguredAgentAuth(env, requiredSchemes) : false
+        },
         privateEnv: {
             exists: privateSource?.exists === true,
             has_token: privateSource ? sourceHasSetVariable(privateSource, 'GPT_IMAGE_AGENT_TOKEN') : false,
@@ -223,11 +235,10 @@ function readAgentAuthState(env, envSummary) {
 
 function buildNextActions({ checks, base, service, env, envSummary, validationError }) {
     const actions = [];
-    const hasCurrentAuth = Boolean(env.GPT_IMAGE_AGENT_TOKEN || env.GPT_IMAGE_APP_PASSWORD_HASH);
-    const hasFileAuth = envSummary.some((source) =>
-        ['GPT_IMAGE_AGENT_TOKEN', 'GPT_IMAGE_APP_PASSWORD_HASH'].some((name) => sourceHasSetVariable(source, name))
-    );
-    if (!findCheck(checks, 'node_version').ok) actions.push('安装 Node.js 20 或更新版本。');
+    const agentAuthSchemes = readAgentAuthSchemes(service);
+    const hasCurrentAgentAuth = hasAnyConfiguredAgentAuth(env, agentAuthSchemes);
+    const hasFileAgentAuth = envSummary.some((source) => hasAnyConfiguredAgentAuthSource(source, agentAuthSchemes));
+    if (!findCheck(checks, 'node_version').ok) actions.push(`安装 Node.js ${MIN_NODE_VERSION} 或更新版本。`);
     if (!findCheck(checks, 'dependencies_installed').ok) actions.push('运行 npm install。');
     if (!findCheck(checks, 'env_files').ok) {
         actions.push('复制 .env.example 为 .env.local，或在页面设置里配置默认上游。');
@@ -236,10 +247,8 @@ function buildNextActions({ checks, base, service, env, envSummary, validationEr
         actions.push('把 GPT_IMAGE_PLAYGROUND_URL 或 --base-url 设为不含凭据、查询参数或片段的 http/https 地址。');
         return actions;
     }
-    if (!hasCurrentAuth && requiresAgentAuth(service) && !hasFileAuth) {
-        actions.push(
-            '在仓库外导出 GPT_IMAGE_AGENT_TOKEN 或 GPT_IMAGE_APP_PASSWORD_HASH，再运行受保护的 Agent 脚本。'
-        );
+    if (!hasCurrentAgentAuth && requiresAgentAuth(service) && !hasFileAgentAuth) {
+        actions.push(buildAgentAuthAction(agentAuthSchemes));
     }
     if (requiresPageSsePasswordHash(service) && !env.GPT_IMAGE_APP_PASSWORD_HASH) {
         actions.push(
@@ -252,10 +261,10 @@ function buildNextActions({ checks, base, service, env, envSummary, validationEr
     if (base.interactive_confirmation_required) {
         actions.push('在交互式 Agent 任务里，先和用户确认探测到的服务地址，再发真实请求。');
     }
-    if (!hasCurrentAuth && hasFileAuth) {
+    if (!hasCurrentAgentAuth && hasFileAgentAuth) {
         actions.push('Agent 脚本会自动读取 .env.agent.local；如果仍提示缺少鉴权，请确认文件位于当前仓库根目录且变量名正确。');
     }
-    if (service.ok && hasCurrentAuth) {
+    if (service.ok && hasCurrentAgentAuth) {
         actions.push('运行 npm run agent:doctor 做完整的非计费 Agent 合同检查。');
     }
     return actions;
@@ -271,6 +280,36 @@ function requiresPageSsePasswordHash(service) {
     return service.capabilities?.body?.agent_streaming?.page_sse?.auth?.required === true;
 }
 
+function readAgentAuthSchemes(service) {
+    const schemes = service.capabilities?.body?.auth?.schemes;
+    if (!Array.isArray(schemes)) return [];
+    return schemes.filter((scheme) => typeof scheme === 'string');
+}
+
+function hasAnyConfiguredAgentAuth(env, schemes) {
+    if (schemes.includes('bearer')) return Boolean(env.GPT_IMAGE_AGENT_TOKEN);
+    if (schemes.includes('x-app-password-hash')) return Boolean(env.GPT_IMAGE_APP_PASSWORD_HASH);
+    return Boolean(env.GPT_IMAGE_AGENT_TOKEN || env.GPT_IMAGE_APP_PASSWORD_HASH);
+}
+
+function hasAnyConfiguredAgentAuthSource(source, schemes) {
+    if (schemes.includes('bearer')) return sourceHasSetVariable(source, 'GPT_IMAGE_AGENT_TOKEN');
+    if (schemes.includes('x-app-password-hash')) return sourceHasSetVariable(source, 'GPT_IMAGE_APP_PASSWORD_HASH');
+    return (
+        sourceHasSetVariable(source, 'GPT_IMAGE_AGENT_TOKEN') || sourceHasSetVariable(source, 'GPT_IMAGE_APP_PASSWORD_HASH')
+    );
+}
+
+function buildAgentAuthAction(schemes) {
+    if (schemes.includes('bearer')) {
+        return '在仓库外导出 GPT_IMAGE_AGENT_TOKEN，再运行受保护的 Agent 脚本。';
+    }
+    if (schemes.includes('x-app-password-hash')) {
+        return '在仓库外导出 GPT_IMAGE_APP_PASSWORD_HASH，再运行受保护的 Agent 脚本。';
+    }
+    return '在仓库外导出 GPT_IMAGE_AGENT_TOKEN 或 GPT_IMAGE_APP_PASSWORD_HASH，再运行受保护的 Agent 脚本。';
+}
+
 function sourceHasSetVariable(source, name) {
     return source.exists && source.variables.some((item) => item.name === name && item.set === true);
 }
@@ -355,9 +394,10 @@ function findCheck(checks, name) {
 }
 
 function readNodeCheck() {
-    const match = process.version.match(/^v(\d+)\./);
+    const match = process.version.match(/^v(\d+)\.(\d+)\./);
     const major = match ? Number(match[1]) : 0;
-    return { ok: major >= 20, current: process.version };
+    const minor = match ? Number(match[2]) : 0;
+    return { ok: major > 20 || (major === 20 && minor >= 9), current: process.version };
 }
 
 function readPackageJson(cwd) {
@@ -405,6 +445,7 @@ export function formatFirstRunText(report) {
     }
     lines.push(`交互式确认：${report.interactive_confirmation_required ? '需要' : '不需要'}`);
     lines.push(`当前进程鉴权：${formatAuthState(report.agent_auth_process)}`);
+    lines.push(`服务鉴权：${formatServiceAuthState(report.agent_auth_service)}`);
     lines.push(`私有 Agent env：${formatPrivateEnvState(report.private_agent_env)}`);
     lines.push('');
     lines.push('检查项：');
@@ -479,11 +520,18 @@ function buildNotRunSmokeStatus(reason) {
 
 function formatAuthState(auth) {
     if (!auth) return '未知';
+    if (auth.has_token && auth.has_password_hash) return '已加载 token + 访问码哈希';
     if (auth.has_token) return '已加载 token';
     if (auth.has_password_hash) return '已加载访问码哈希';
     return '未加载';
 }
 
+function formatServiceAuthState(auth) {
+    if (!auth) return '未知';
+    if (auth.required === true) return auth.ready ? '已满足当前服务鉴权要求' : '未满足当前服务鉴权要求';
+    return '不需要';
+}
+
 function formatPrivateEnvState(privateEnv) {
     if (!privateEnv?.exists) return '不存在';
     if (privateEnv.has_token) return '存在，含 token';

scripts/hf-space-doctor-utils.mjs

@@ -111,8 +111,8 @@ export function classifyRequiredAndRecommendedNames(names, requiredNames, recomm
 }
 
 const NEXT_ACTIONS = new Map([
-    ['node', 'Install Node.js 20 or newer, then reopen the terminal.'],
-    ['npm', 'Install Node.js 20 or newer with npm.'],
+    ['node', 'Install Node.js >=20.9.0, then reopen the terminal.'],
+    ['npm', 'Install Node.js >=20.9.0 with npm.'],
     ['hf-cli', 'Install the Hugging Face CLI from the official documentation; avoid piping remote install scripts directly to a shell.'],
     ['hf-auth', 'Check network/proxy access to Hugging Face, then run hf auth login if the token is missing or expired.'],
     ['node-modules', 'Run npm install.'],

skills/gpt-image-playground-agent/SKILL.md

@@ -16,7 +16,7 @@ Agent API 是给自动化客户端使用的机器接口，不是自治 Agent 平
 - 批量 generate/edit：优先运行 `scripts/batch-images.mjs`，用 JSONL 输入和 append-only manifest 管理续跑。
 - 转换本地图片格式：优先运行 `scripts/convert-image-format.mjs`。
 - 查询页面请求的结果反馈或日志诊断摘要：优先运行 `scripts/diagnose-request.mjs`。
-- 诊断上游图片接口：优先运行 `scripts/probe-upstream-image.mjs`。
+- 诊断上游图片接口：优先运行 `scripts/probe-upstream-image.mjs`。接入新上游渠道时，先确认 `/models` 和 `/images/generations` 能通，再用 `npm run smoke:image-upstream-real -- --allow-billable` 逐个验证 `original-images-json`、`sub2api-images-sse`、`sub2api-responses-json`、`gpt2image-responses-sse`；如果 `/v1/responses` 返回 `403 Image generation is not enabled for this group`，就把该渠道的 `responses-non-stream`、`responses-sse` 从 `OPENAI_CHANNEL_N_REQUEST_MODES` 移除。
 - 不要临时编写 Node/Python/shell 脚本、curl 命令或手写 fetch/FormData 来重复实现这些脚本已经覆盖的 API 调用。
 - 只有在内置脚本缺少用户明确需要的能力时，才修改或扩展 `scripts/` 内的预置脚本，并同步补测试；不要在仓库外留下 ad hoc 调用脚本。
 - 先用 dry-run、`--check-remote` 或 `--contract-check` 检查请求、路由、鉴权和服务声明的默认编排入口；只有用户明确允许真实计费时才加 `--allow-billable`。
@@ -151,9 +151,11 @@ Authorization: Bearer <token>
 | `page_sse_real_smoke_status` | `first-run --json` | 结构化说明 `first-run` 未执行真实 `/api/images` smoke；`state=not_run` 且 `billable=false` 表示它只是只读就绪检查。 |
 | `responses_image_backend_real_smoke_status` | `first-run --json` | 结构化说明 `first-run` 未执行真实 Responses image_generation smoke；不要把声明支持当作实测通过。 |
 | `summary.page_sse_real_smoke` | `agent:doctor` | Page SSE 真实 smoke 的兼容聚合状态；任一 Page SSE smoke 失败为 `failed`，任一通过且无失败为 `passed`，全部跳过为 `skipped`；精确判断优先看 `summary.real_smoke_checks`。 |
+| `summary.orchestration_generate_smoke` | `agent:doctor` | `--allow-billable` 时默认 generate 主链 `/api/agent/image-requests` 的真实 smoke 状态；这是普通 generate 在 server-owned orchestration 下的主编排口径。 |
+| `summary.agent_generate_smoke` | `agent:doctor` | `--allow-billable` 时显式 `--agent` 的 Agent JSON 文生图 smoke 状态；用于诊断直连 Agent JSON，不代表默认主链。 |
 | `summary.responses_page_sse_generate_smoke` | `agent:doctor` | `--allow-billable` 时对 `responses-image-generation` + page SSE + `responses-sse` 这条文生图路径的真实 smoke 状态；非计费时为 `skipped`。 |
 | `summary.responses_agent_generate_smoke` | `agent:doctor` | `--allow-billable` 时对 `responses-image-generation` + Agent JSON + `responses-non-stream` 这条文生图路径的真实 smoke 状态；非计费时为 `skipped`。 |
-| `summary.real_smoke_checks` | `agent:doctor` | 各真实 smoke 的状态汇总，包含 `agent_generate_1k`、`responses_page_sse_generate_1k`、`responses_agent_generate_1k`、`agent_edit_1k` 和 `page_sse_edit_2k`。 |
+| `summary.real_smoke_checks` | `agent:doctor` | 各真实 smoke 的状态汇总，包含 `orchestration_generate_1k`、`agent_generate_1k`、`responses_page_sse_generate_1k`、`responses_agent_generate_1k`、`agent_edit_1k` 和 `page_sse_edit_2k`。 |
 | `summary.request_modes` | `agent:doctor` | 管理员 request mode 的配置和真实 smoke 摘要；`billable=false` 时只能证明配置可见，不能当作真实上游通过。 |
 | `request_mode_controls` | `capabilities` | 管理员 request mode 白名单控制面；包含 `OPENAI_UPSTREAM_REQUEST_MODES`、`OPENAI_CHANNEL_N_REQUEST_MODES`、真实 smoke gate 和 `agent_client_policy=diagnostics_only`。 |
 | `private_agent_env.exists` | `first-run --json` | 本机是否存在 `.env.agent.local` 私有配置；Agent CLI 默认从当前仓库根目录读取该文件。 |

skills/gpt-image-playground-agent/references/api.md

@@ -210,7 +210,7 @@ GET /api/agent/capabilities
 - `supported.request_modes`：服务端支持的上游请求方式枚举，当前为 `images-non-stream`、`images-sse`、`responses-non-stream`、`responses-sse`。该字段描述服务端能力全集，不代表每个管理员渠道都已真实 smoke 通过。
 - `upstream_request_headers.default`：默认上游请求头摘要，包含 `user_agent_effective`、`has_extra_headers`、`allowed_header_names` 和 `configured_header_names`。
 - `upstream_request_headers.channels`：每个服务端渠道的脱敏请求头摘要。该字段不包含 API key、Authorization 值、Matsca app secret 值或任意 header value。
-- `request_mode_controls`：管理员 request mode 白名单控制面，声明 `OPENAI_UPSTREAM_REQUEST_MODES`、`OPENAI_CHANNEL_N_REQUEST_MODES`、真实 smoke gate 和 `agent_client_policy=diagnostics_only`；Agent 客户端只能用于解释执行结果，不应据此自行选择上游请求方式。
+- `request_mode_controls`：管理员 request mode 白名单控制面，声明 `OPENAI_UPSTREAM_REQUEST_MODES`、`OPENAI_CHANNEL_N_REQUEST_MODES`、真实 smoke gate 和 `agent_client_policy=diagnostics_only`；Agent 客户端只能用于解释执行结果，不应据此自行选择上游请求方式。接入新渠道时，先用 `scripts/probe-upstream-image.mjs` 验证 `/models` 和 `/images/generations`，再用 `npm run smoke:image-upstream-real -- --allow-billable` 跑 `original-images-json`、`sub2api-images-sse`、`sub2api-responses-json`、`gpt2image-responses-sse` 之类的真实 smoke；如果 `/v1/responses` 返回 `403 Image generation is not enabled for this group`，就把该渠道的 `responses-non-stream` 和 `responses-sse` 从白名单里删掉，只保留通过的 `images-*` 模式。
 - `routing_rules.high_resolution_edit`：`edit` 且最大边大于 `2048` 时默认优先使用页面端 `/api/images` SSE，页面流式有问题时显式回退。
 - `routing_rules.complex_ui_batch`：复杂 UI 批量出图推荐使用页面端 `/api/images` SSE。
 - `routing_rules.long_image_recovery`：长图恢复或续跑锚点场景推荐使用页面端 `/api/images` SSE。
@@ -588,9 +588,11 @@ node "<skill-root>/scripts/diagnose-request.mjs" --base-url https://your-space.h
 | `page_sse_real_smoke_status` | `first-run --json` | 结构化说明 `first-run` 未执行真实 `/api/images` smoke；`state=not_run` 且 `billable=false` 表示它只是只读就绪检查。 |
 | `responses_image_backend_real_smoke_status` | `first-run --json` | 结构化说明 `first-run` 未执行真实 Responses image_generation smoke；不要把声明支持当作实测通过。 |
 | `summary.page_sse_real_smoke` | `agent:doctor` | Page SSE 真实 smoke 的兼容聚合状态；任一 Page SSE smoke 失败为 `failed`，任一通过且无失败为 `passed`，全部跳过为 `skipped`；精确判断优先看 `summary.real_smoke_checks`。 |
+| `summary.orchestration_generate_smoke` | `agent:doctor` | `--allow-billable` 时默认 generate 主链 `/api/agent/image-requests` 的真实 smoke 状态；这是普通 generate 在 server-owned orchestration 下的主编排口径。 |
+| `summary.agent_generate_smoke` | `agent:doctor` | `--allow-billable` 时显式 `--agent` 的 Agent JSON 文生图 smoke 状态；用于诊断直连 Agent JSON，不代表默认主链。 |
 | `summary.responses_page_sse_generate_smoke` | `agent:doctor` | `--allow-billable` 时对 `responses-image-generation` + page SSE + `responses-sse` 这条文生图路径的真实 smoke 状态；非计费时为 `skipped`。 |
 | `summary.responses_agent_generate_smoke` | `agent:doctor` | `--allow-billable` 时对 `responses-image-generation` + Agent JSON + `responses-non-stream` 这条文生图路径的真实 smoke 状态；非计费时为 `skipped`。 |
-| `summary.real_smoke_checks` | `agent:doctor` | 各真实 smoke 的状态汇总，包含 `agent_generate_1k`、`responses_page_sse_generate_1k`、`responses_agent_generate_1k`、`agent_edit_1k` 和 `page_sse_edit_2k`。 |
+| `summary.real_smoke_checks` | `agent:doctor` | 各真实 smoke 的状态汇总，包含 `orchestration_generate_1k`、`agent_generate_1k`、`responses_page_sse_generate_1k`、`responses_agent_generate_1k`、`agent_edit_1k` 和 `page_sse_edit_2k`。 |
 | `summary.request_modes` | `agent:doctor` | 管理员 request mode 的配置和真实 smoke 摘要；`billable=false` 时只能证明配置可见，不能当作真实上游通过。 |
 | `request_mode_controls` | `capabilities` | 管理员 request mode 白名单控制面；包含 `OPENAI_UPSTREAM_REQUEST_MODES`、`OPENAI_CHANNEL_N_REQUEST_MODES`、真实 smoke gate 和 `agent_client_policy=diagnostics_only`。 |
 | `private_agent_env.exists` | `first-run --json` | 本机是否存在 `.env.agent.local` 私有配置；Agent CLI 默认从当前仓库根目录读取该文件。 |

src/app/api/deploy-marker/route.ts

@@ -1,6 +1,6 @@
 import { NextResponse } from 'next/server';
 
-const deployMarker = {"schema_version":1,"local_sha":"c2357572329b70e2e3b953be74f8d0cedafef5f5","created_at":"2026-06-29T10:57:33.027Z","deploy_id":"a2febf58-db5e-4d67-a4b0-7968d3d42118"} as const;
+const deployMarker = {"schema_version":1,"local_sha":"653775e99286817989ad7a4dfb56eedae605cdcb","created_at":"2026-06-30T11:54:17.314Z","deploy_id":"5a7966ca-fd3b-44a4-aea7-e7a5a4566be3"} as const;
 
 export const dynamic = 'force-dynamic';
 

src/app/page-regressions.test.ts

@@ -24,4 +24,36 @@ describe('page state regressions', () => {
             /const allowResponsesImageBackend = isResponsesImageBackendRuntimeEnabled\(runtimeCapabilities \?\? \{\}\)/
         );
     });
+
+    it('treats request-level API key as an override while rejecting base URL-only settings', async () => {
+        const source = await readFile(new URL('./page.tsx', import.meta.url), 'utf8');
+        const runtimeStatusCall = source.match(/resolveRuntimeHealthStatus\(\{([\s\S]*?)\n\s*\}\)/)?.[1] ?? '';
+
+        assert.match(source, /const hasRequestApiKey = apiSettings\.apiKey\.trim\(\)\.length > 0;/);
+        assert.match(source, /const hasRequestApiOverride = hasRequestApiKey;/);
+        assert.match(runtimeStatusCall, /hasRequestApiOverride/);
+        assert.match(runtimeStatusCall, /imageBackend: activeWorkbenchBackend/);
+        assert.match(source, /if \(settings\.baseUrl && !settings\.apiKey\) \{\s*throw new Error\(t\('api\.urlPairRequired'\)\);\s*\}/);
+        assert.match(source, /if \(apiSettings\.baseUrl && apiSettings\.apiKey\) \{/);
+        assert.doesNotMatch(source, /hasPairedRequestApiOverride/);
+    });
+
+    it('cleans stale local request API overrides that only persisted a base URL', async () => {
+        const source = await readFile(new URL('./page.tsx', import.meta.url), 'utf8');
+
+        assert.match(source, /function normalizeStoredApiSettings\(settings: Partial<ApiSettings>\): StoredApiSettingsReadResult/);
+        assert.match(source, /if \(!apiKey && baseUrl\) \{\s*return \{ settings: emptyApiSettings, shouldPersist: false, shouldRemove: true \};\s*\}/);
+        assert.match(source, /const storedApiSettings = readStoredApiSettings\(\);/);
+        assert.match(source, /if \(storedApiSettings\.shouldRemove\) \{\s*window\.localStorage\.removeItem\(apiSettingsLocalStorageKey\);\s*\}/);
+        assert.match(source, /else if \(storedApiSettings\.shouldPersist\) \{\s*window\.localStorage\.setItem\(apiSettingsLocalStorageKey, JSON\.stringify\(storedApiSettings\.settings\)\);\s*\}/);
+    });
+
+    it('shows the current form route in the status strip instead of inferring from server capability modes', async () => {
+        const source = await readFile(new URL('./page.tsx', import.meta.url), 'utf8');
+
+        assert.match(source, /const activeWorkbenchBackend = usesEditControls \? editImageBackend : genImageBackend;/);
+        assert.match(source, /const activeRouteLabel = getWorkbenchRouteLabel\(activeWorkbenchBackend, t\);/);
+        assert.match(source, /routeLabel=\{activeRouteLabel\}/);
+        assert.doesNotMatch(source, /const activeRequestModeLabel = React\.useMemo/);
+    });
 });

src/app/page.tsx

@@ -89,6 +89,7 @@ import type { ImageStreamMode, ImageStreamingStrategy } from '@/lib/image-upstre
 import { resolveMobileCreationSheetGesture } from '@/lib/mobile-creation-sheet-gesture';
 import { resolveMobilePrimaryDisabledReason } from '@/lib/mobile-primary-action-state';
 import { hasPreservedDisplayedAuthError, isPagePasswordAuthErrorCode } from '@/lib/page-password-auth';
+import { resolveRuntimeHealthStatus, type RuntimeHealthStatus } from '@/lib/runtime-health-status';
 import { sha256Hex } from '@/lib/sha256';
 import { createImageShareFromBlob } from '@/lib/share-client';
 import { getPresetDimensions, validateGptImage2Size, validatePositiveIntegerImageSize } from '@/lib/size-utils';
@@ -154,6 +155,11 @@ type FeedbackSyncPayload = HistoryFeedbackSyncPayload;
 type FeedbackSyncScheduleOptions = {
     pruneQueuedTargets?: boolean;
 };
+type StoredApiSettingsReadResult = {
+    settings: ApiSettings;
+    shouldPersist: boolean;
+    shouldRemove: boolean;
+};
 
 function createFeedbackRequestSignal(signal: AbortSignal): { signal: AbortSignal; cleanup: () => void } {
     const controller = new AbortController();
@@ -173,7 +179,7 @@ function createFeedbackRequestSignal(signal: AbortSignal): { signal: AbortSignal
     };
 }
 
-function getImageBackendLabel(backend: ImageUpstreamFormBackend, t: (key: string) => string): string {
+function getWorkbenchRouteLabel(backend: ImageUpstreamFormBackend, t: (key: string) => string): string {
     if (backend === 'images-api') return t('upstream.backendImages');
     if (backend === 'responses-image-generation') return t('upstream.backendResponses');
     return t('upstream.workbenchDefaultRoute');
@@ -221,19 +227,35 @@ function readStoredHistory(): HistoryMetadata[] {
     return [];
 }
 
-function readStoredApiSettings(): ApiSettings {
+function normalizeStoredApiSettings(settings: Partial<ApiSettings>): StoredApiSettingsReadResult {
+    const apiKey = typeof settings.apiKey === 'string' ? settings.apiKey.trim() : '';
+    const baseUrl = typeof settings.baseUrl === 'string' ? settings.baseUrl.trim() : '';
+    if (!apiKey && !baseUrl) {
+        return { settings: emptyApiSettings, shouldPersist: false, shouldRemove: true };
+    }
+    if (!apiKey && baseUrl) {
+        return { settings: emptyApiSettings, shouldPersist: false, shouldRemove: true };
+    }
+    const normalizedSettings: ApiSettings = { apiKey, baseUrl };
+    return {
+        settings: normalizedSettings,
+        shouldPersist: normalizedSettings.apiKey !== settings.apiKey || normalizedSettings.baseUrl !== settings.baseUrl,
+        shouldRemove: false
+    };
+}
+
+function readStoredApiSettings(): StoredApiSettingsReadResult {
     const storedApiSettings = readLocalStorageValue(apiSettingsLocalStorageKey);
-    if (!storedApiSettings) return emptyApiSettings;
+    if (!storedApiSettings) {
+        return { settings: emptyApiSettings, shouldPersist: false, shouldRemove: false };
+    }
     try {
         const parsedSettings = JSON.parse(storedApiSettings) as Partial<ApiSettings>;
-        return {
-            apiKey: typeof parsedSettings.apiKey === 'string' ? parsedSettings.apiKey : '',
-            baseUrl: typeof parsedSettings.baseUrl === 'string' ? parsedSettings.baseUrl : ''
-        };
+        return normalizeStoredApiSettings(parsedSettings);
     } catch (error) {
         console.error('从 localStorage 加载 API 设置失败：', error);
         window.localStorage.removeItem(apiSettingsLocalStorageKey);
-        return emptyApiSettings;
+        return { settings: emptyApiSettings, shouldPersist: false, shouldRemove: false };
     }
 }
 
@@ -320,6 +342,7 @@ type ApiUsage = {
 
 type RuntimeCapabilities = {
     streaming?: {
+        defaultBackend?: 'images-api' | 'responses-image-generation';
         defaultMode?: ImageStreamMode;
         defaultStrategy?: ImageStreamingStrategy;
     };
@@ -348,6 +371,17 @@ type RuntimeCapabilities = {
     };
     channelRouting?: {
         effectiveRequestModes?: string[];
+        requestModeHealth?: Array<{
+            mode: string;
+            configuredCredentialCount: number;
+            healthyCredentialCount: number;
+            configuredChannelCount: number;
+            healthyChannelCount: number;
+        }>;
+        effectiveRequestModesByChannel?: Array<{
+            channelId: string;
+            requestModes: string[];
+        }>;
     };
     upstreamProfile?: {
         activeProfile: ImageUpstreamProfileId;
@@ -612,13 +646,13 @@ export default function HomePage() {
             ? [runtimeCapabilities.upstreamProfile.serverProfile]
             : []
     });
-    const hasRequestApiBaseUrl = apiSettings.baseUrl.trim().length > 0;
-    const hasRequestApiOverride = apiSettings.apiKey.trim().length > 0 || hasRequestApiBaseUrl;
-    const activeUpstreamProfile = hasRequestApiBaseUrl
+    const hasRequestApiKey = apiSettings.apiKey.trim().length > 0;
+    const hasRequestApiOverride = hasRequestApiKey;
+    const activeUpstreamProfile = hasRequestApiOverride
         ? activeUpstreamProfileSummary.activeConstraints
         : runtimeCapabilities?.upstreamProfile?.activeConstraints || IMAGE_UPSTREAM_PROFILES['openai-compatible'];
     const activeUpstreamProfileMixed =
-        !hasRequestApiBaseUrl && runtimeCapabilities?.upstreamProfile?.serverProfileMixed === true;
+        !hasRequestApiOverride && runtimeCapabilities?.upstreamProfile?.serverProfileMixed === true;
     const allowResponsesImageBackend = shouldAllowResponsesImageBackend({
         runtimeCapabilities,
         hasRequestApiOverride
@@ -666,7 +700,14 @@ export default function HomePage() {
         activeWorkbenchStreamingStrategy === IMAGE_UPSTREAM_FORM_SERVER_DEFAULT
             ? defaultStreamingStrategy
             : activeWorkbenchStreamingStrategy;
-    const activeWorkbenchBackendLabel = getImageBackendLabel(activeWorkbenchBackend, t);
+    const activeRouteLabel = getWorkbenchRouteLabel(activeWorkbenchBackend, t);
+    const activeRuntimeHealthStatus: RuntimeHealthStatus = resolveRuntimeHealthStatus({
+        runtimeCapabilities,
+        hasRequestApiOverride,
+        imageBackend: activeWorkbenchBackend,
+        streamingStrategy: activeEffectiveStreamingStrategy,
+        streamMode
+    });
     const activeTaskCount =
         mode === 'generate' && workbenchMode === 'batch'
             ? readBatchPromptLines(genBatchPromptText).length
@@ -1143,7 +1184,13 @@ export default function HomePage() {
 
         fetchAuthStatus();
         queueMicrotask(() => {
-            setApiSettings(readStoredApiSettings());
+            const storedApiSettings = readStoredApiSettings();
+            setApiSettings(storedApiSettings.settings);
+            if (storedApiSettings.shouldRemove) {
+                window.localStorage.removeItem(apiSettingsLocalStorageKey);
+            } else if (storedApiSettings.shouldPersist) {
+                window.localStorage.setItem(apiSettingsLocalStorageKey, JSON.stringify(storedApiSettings.settings));
+            }
         });
     }, [createErrorNotice, t, verifyEntryPasswordHash]);
 
@@ -1154,6 +1201,9 @@ export default function HomePage() {
                 throw new Error('获取运行时能力失败');
             }
             const data = (await response.json()) as RuntimeCapabilities;
+            if (data === null || typeof data !== 'object') {
+                throw new Error('获取运行时能力失败');
+            }
             setRuntimeCapabilities(data);
             return data;
         } catch (error) {
@@ -1290,6 +1340,9 @@ export default function HomePage() {
     };
 
     const handleSaveApiSettings = (settings: ApiSettings) => {
+        if (settings.baseUrl && !settings.apiKey) {
+            throw new Error(t('api.urlPairRequired'));
+        }
         setApiSettings(settings);
         if (settings.apiKey || settings.baseUrl) {
             localStorage.setItem(apiSettingsLocalStorageKey, JSON.stringify(settings));
@@ -1411,7 +1464,7 @@ export default function HomePage() {
             if (apiSettings.apiKey) {
                 apiFormData.append('apiKey', apiSettings.apiKey);
             }
-            if (apiSettings.baseUrl) {
+            if (apiSettings.baseUrl && apiSettings.apiKey) {
                 apiFormData.append('apiBaseUrl', apiSettings.baseUrl);
             }
 
@@ -3332,10 +3385,11 @@ export default function HomePage() {
                             <div className='flex flex-wrap items-center gap-4 sm:justify-end'>
                                 <WorkbenchStatusStrip
                                     model={activeWorkbenchModel}
-                                    channelLabel={activeWorkbenchBackendLabel}
+                                    routeLabel={activeRouteLabel}
                                     streamStatus={getStreamingStatusLabel(streamMode, t)}
                                     parallelBatchEnabled={activeParallelBatchVisible}
                                     costLabel={activeEstimatedCostLabel}
+                                    runtimeHealthStatus={activeRuntimeHealthStatus}
                                 />
                                 <div className='text-muted-foreground hidden items-center gap-4 sm:flex'>
                                     <HelpCircle className='h-4 w-4' aria-hidden='true' />

src/app/share/[token]/page-regressions.test.ts

@@ -11,5 +11,8 @@ describe('share page regressions', () => {
         assert.match(source, /name='accessCode'/);
         assert.match(source, /autoComplete='current-password'/);
         assert.match(source, /share\.accessCodeRequiredHint/);
+        assert.match(source, /aria-describedby=\{accessCode\.trim\(\)\.length === 0 \? 'share-page-access-code-hint' : undefined\}/);
+        assert.match(source, /id='share-page-access-code-hint'/);
+        assert.match(source, /if \(accessCode\.trim\(\)\.length === 0\) \{\s*return;\s*\}/);
     });
 });

src/app/share/[token]/page.tsx

@@ -133,6 +133,9 @@ export default function SharePage({ params }: { params: Promise<{ token: string
                         className='max-w-sm space-y-2'
                         onSubmit={(event) => {
                             event.preventDefault();
+                            if (accessCode.trim().length === 0) {
+                                return;
+                            }
                             void loadImage();
                         }}>
                         <Label htmlFor='share-page-access-code'>{t('share.accessCode')}</Label>
@@ -140,6 +143,7 @@ export default function SharePage({ params }: { params: Promise<{ token: string
                             <Input
                                 id='share-page-access-code'
                                 name='accessCode'
+                                aria-describedby={accessCode.trim().length === 0 ? 'share-page-access-code-hint' : undefined}
                                 value={accessCode}
                                 onChange={(event) => setAccessCode(event.target.value)}
                                 placeholder={t('share.accessCodePlaceholder')}
@@ -155,7 +159,9 @@ export default function SharePage({ params }: { params: Promise<{ token: string
                             </Button>
                         </div>
                         {accessCode.trim().length === 0 ? (
-                            <p className='text-muted-foreground text-xs'>{t('share.accessCodeRequiredHint')}</p>
+                            <p id='share-page-access-code-hint' className='text-muted-foreground text-xs'>
+                                {t('share.accessCodeRequiredHint')}
+                            </p>
                         ) : null}
                     </form>
                 ) : null}

src/components/api-settings-dialog.tsx

@@ -30,6 +30,7 @@ export function ApiSettingsDialog({ isOpen, onOpenChange, settings, onSave }: Ap
     const { t } = useI18n();
     const [draft, setDraft] = React.useState<ApiSettings>(settings);
     const [saveStatus, setSaveStatus] = React.useState<'idle' | 'saved' | 'error'>('idle');
+    const [validationMessage, setValidationMessage] = React.useState<string | null>(null);
     const closeTimerRef = React.useRef<number | null>(null);
 
     const clearCloseTimer = React.useCallback(() => {
@@ -44,6 +45,7 @@ export function ApiSettingsDialog({ isOpen, onOpenChange, settings, onSave }: Ap
         if (open) {
             clearCloseTimer();
             setSaveStatus('idle');
+            setValidationMessage(null);
             setDraft(settings);
         }
         onOpenChange(open);
@@ -58,16 +60,25 @@ export function ApiSettingsDialog({ isOpen, onOpenChange, settings, onSave }: Ap
     };
 
     const handleSave = () => {
+        const trimmedApiKey = draft.apiKey.trim();
+        const trimmedBaseUrl = draft.baseUrl.trim();
+        if (trimmedBaseUrl.length > 0 && trimmedApiKey.length === 0) {
+            setSaveStatus('error');
+            setValidationMessage(t('api.urlPairRequired'));
+            return;
+        }
         try {
             onSave({
-                apiKey: draft.apiKey.trim(),
-                baseUrl: draft.baseUrl.trim()
+                apiKey: trimmedApiKey,
+                baseUrl: trimmedBaseUrl
             });
+            setValidationMessage(null);
             setSaveStatus('saved');
             closeAfterSaved();
         } catch (error) {
             console.error('Failed to save API settings.', error);
             setSaveStatus('error');
+            setValidationMessage(null);
         }
     };
 
@@ -81,11 +92,13 @@ export function ApiSettingsDialog({ isOpen, onOpenChange, settings, onSave }: Ap
         try {
             setDraft(emptySettings);
             onSave(emptySettings);
+            setValidationMessage(null);
             setSaveStatus('saved');
             closeAfterSaved();
         } catch (error) {
             console.error('Failed to clear API settings.', error);
             setSaveStatus('error');
+            setValidationMessage(null);
         }
     };
 
@@ -109,9 +122,10 @@ export function ApiSettingsDialog({ isOpen, onOpenChange, settings, onSave }: Ap
                                 placeholder='sk-...'
                                 value={draft.apiKey}
                                 className='min-h-11 sm:min-h-9'
-                                onChange={(event) =>
-                                    setDraft((current) => ({ ...current, apiKey: event.target.value }))
-                                }
+                                onChange={(event) => {
+                                    setValidationMessage(null);
+                                    setDraft((current) => ({ ...current, apiKey: event.target.value }));
+                                }}
                             />
                         </div>
                         <div className='grid gap-2'>
@@ -126,11 +140,13 @@ export function ApiSettingsDialog({ isOpen, onOpenChange, settings, onSave }: Ap
                                 placeholder='https://api.openai.com/v1'
                                 value={draft.baseUrl}
                                 className='min-h-11 sm:min-h-9'
-                                onChange={(event) =>
-                                    setDraft((current) => ({ ...current, baseUrl: event.target.value }))
-                                }
+                                onChange={(event) => {
+                                    setValidationMessage(null);
+                                    setDraft((current) => ({ ...current, baseUrl: event.target.value }));
+                                }}
                             />
                             <p className='text-muted-foreground text-xs leading-5'>{t('api.urlHint')}</p>
+                            <p className='text-muted-foreground text-xs leading-5'>{t('api.urlPairHint')}</p>
                         </div>
                     </div>
                     <DialogFooter>
@@ -143,7 +159,7 @@ export function ApiSettingsDialog({ isOpen, onOpenChange, settings, onSave }: Ap
                         )}
                         {saveStatus === 'error' && (
                             <p className='text-destructive mr-auto self-center text-sm' aria-live='polite'>
-                                {t('api.saveFailed')}
+                                {validationMessage ?? t('api.saveFailed')}
                             </p>
                         )}
                         <Button

src/components/history-panel.test.tsx

@@ -7,6 +7,7 @@ import {
 import type { HistoryMetadata } from '@/lib/history-metadata';
 import { I18nProvider } from '@/lib/i18n';
 import assert from 'node:assert/strict';
+import { readFile } from 'node:fs/promises';
 import { describe, it } from 'node:test';
 import * as React from 'react';
 import { renderToStaticMarkup } from 'react-dom/server';
@@ -128,6 +129,16 @@ describe('HistoryPanel recent history actions', () => {
         assert.match(html, /aria-label="标记本次结果需要修改"/);
     });
 
+    it('formats summary and token counters with the active locale', async () => {
+        const source = await readFile(new URL('./history-panel.tsx', import.meta.url), 'utf8');
+
+        assert.match(source, /totalImages\.toLocaleString\(locale\)/);
+        assert.match(source, /actualQuota\.toLocaleString\(\s*locale\s*\)/);
+        assert.match(source, /text_input_tokens\.toLocaleString\(\s*locale\s*\)/);
+        assert.match(source, /image_input_tokens\.toLocaleString\(\s*locale\s*\)/);
+        assert.match(source, /image_output_tokens\.toLocaleString\(\s*locale\s*\)/);
+    });
+
     it('renders saved result feedback on completed history cards', () => {
         const html = renderHistoryPanel([
             {

src/components/history-panel.tsx

@@ -391,7 +391,7 @@ function HistoryPanelImpl({
                                 <div className='text-muted-foreground space-y-2 py-4 text-sm'>
                                     <div className='flex justify-between'>
                                         <span>{t('history.totalImages')}</span>{' '}
-                                        <span className='ui-stat'>{totalImages.toLocaleString()}</span>
+                                        <span className='ui-stat'>{totalImages.toLocaleString(locale)}</span>
                                     </div>
                                     <div className='flex justify-between'>
                                         <span>{t('history.averageCost')}</span>{' '}
@@ -782,7 +782,9 @@ function HistoryPanelImpl({
                                                                                         {t('history.actualQuota')}
                                                                                     </span>
                                                                                     <span className='ui-stat'>
-                                                                                        {item.actualCostDetails.actualQuota.toLocaleString()}
+                                                                                        {item.actualCostDetails.actualQuota.toLocaleString(
+                                                                                            locale
+                                                                                        )}
                                                                                     </span>
                                                                                 </div>
                                                                             )}
@@ -814,7 +816,9 @@ function HistoryPanelImpl({
                                                                                     {t('history.textInputTokens')}
                                                                                 </span>{' '}
                                                                                 <span className='ui-stat'>
-                                                                                    {item.costDetails.text_input_tokens.toLocaleString()}{' '}
+                                                                                    {item.costDetails.text_input_tokens.toLocaleString(
+                                                                                        locale
+                                                                                    )}{' '}
                                                                                     (
                                                                                     {formatEstimatedTokenCost(
                                                                                         item.costDetails
@@ -831,7 +835,9 @@ function HistoryPanelImpl({
                                                                                         {t('history.imageInputTokens')}
                                                                                     </span>{' '}
                                                                                     <span className='ui-stat'>
-                                                                                        {item.costDetails.image_input_tokens.toLocaleString()}{' '}
+                                                                                        {item.costDetails.image_input_tokens.toLocaleString(
+                                                                                            locale
+                                                                                        )}{' '}
                                                                                         (
                                                                                         {formatEstimatedTokenCost(
                                                                                             item.costDetails
@@ -847,7 +853,9 @@ function HistoryPanelImpl({
                                                                                     {t('history.imageOutputTokens')}
                                                                                 </span>{' '}
                                                                                 <span className='ui-stat'>
-                                                                                    {item.costDetails.image_output_tokens.toLocaleString()}{' '}
+                                                                                    {item.costDetails.image_output_tokens.toLocaleString(
+                                                                                        locale
+                                                                                    )}{' '}
                                                                                     (
                                                                                     {formatEstimatedTokenCost(
                                                                                         item.costDetails

src/components/image-output.tsx

@@ -461,7 +461,7 @@ export function ImageOutput({
                 {isLoading ? (
                     streamingPreviewImages && streamingPreviewImages.size > 0 ? (
                         // 展示流式预览图，单图时和最终视图一样居中。
-                        <div className='photo-paper relative flex aspect-[4/3] w-full max-w-[720px] items-center justify-center p-3'>
+                        <div className='photo-paper relative flex aspect-[4/3] w-full max-w-[780px] items-center justify-center p-3 2xl:max-w-[860px]'>
                             {/* 展示最新的预览图，也就是最大索引图片。 */}
                             {(() => {
                                 const entries = Array.from(streamingPreviewImages.entries());
@@ -486,7 +486,7 @@ export function ImageOutput({
                             </div>
                         </div>
                     ) : currentMode === 'edit' && baseImagePreviewUrl ? (
-                        <div className='photo-paper relative flex aspect-[4/3] w-full max-w-[720px] items-center justify-center p-3'>
+                        <div className='photo-paper relative flex aspect-[4/3] w-full max-w-[780px] items-center justify-center p-3 2xl:max-w-[860px]'>
                             <Image
                                 src={baseImagePreviewUrl}
                                 alt={t('output.editing')}
@@ -507,7 +507,7 @@ export function ImageOutput({
                         </div>
                     )
                 ) : hasFailure ? (
-                    <div className='photo-paper relative flex aspect-[4/3] w-full max-w-[720px] flex-col justify-between p-5 sm:p-6'>
+                    <div className='photo-paper relative flex aspect-[4/3] w-full max-w-[780px] flex-col justify-between p-5 sm:p-6 2xl:max-w-[860px]'>
                         <div className='space-y-3'>
                             <div className='text-muted-foreground text-xs'>{t('output.failedKicker')}</div>
                             <div className='space-y-2'>
@@ -545,7 +545,8 @@ export function ImageOutput({
                     />
                 ) : imageBatch && imageBatch.length > 0 ? (
                     viewMode === 'grid' ? (
-                        <div className={`grid ${getGridColsClass(imageBatch.length)} w-full max-w-[720px] gap-2`}>
+                        <div
+                            className={`grid ${getGridColsClass(imageBatch.length)} w-full max-w-[780px] gap-2 2xl:max-w-[860px]`}>
                             {imageBatch.map((img, index) => (
                                 <button
                                     type='button'
@@ -572,12 +573,12 @@ export function ImageOutput({
                             ))}
                         </div>
                     ) : imageBatch[viewMode] ? (
-                        <div className='photo-paper relative aspect-[4/3] w-full max-w-[720px] p-3'>
+                        <div className='photo-paper relative aspect-[4/3] w-full max-w-[780px] p-3 2xl:max-w-[860px]'>
                             <Image
                                 src={imageBatch[viewMode].path}
                                 alt={altText}
                                 fill
-                                sizes='(max-width: 768px) 92vw, (max-width: 1800px) 44vw, 720px'
+                                sizes='(max-width: 768px) 92vw, (max-width: 1536px) 44vw, 860px'
                                 className='image-edge rounded-md object-contain'
                                 onLoad={(event) => handleImageLoad(imageBatch[viewMode].filename, event)}
                                 unoptimized
@@ -591,14 +592,14 @@ export function ImageOutput({
                 ) : (
                     <>
                         {currentMode === 'edit' ? (
-                            <div className='photo-paper relative flex aspect-[4/3] w-full max-w-[720px] flex-col justify-between p-5 sm:p-6'>
+                            <div className='photo-paper relative flex aspect-[4/3] w-full max-w-[780px] flex-col justify-between p-5 sm:p-6 2xl:max-w-[860px]'>
                                 {baseImagePreviewUrl ? (
                                     <>
                                         <Image
                                             src={baseImagePreviewUrl}
                                             alt={t('output.editReferenceAlt')}
                                             fill
-                                            sizes='(max-width: 768px) 92vw, (max-width: 1800px) 44vw, 720px'
+                                            sizes='(max-width: 768px) 92vw, (max-width: 1536px) 44vw, 860px'
                                             className='image-edge rounded-md object-contain p-3'
                                             unoptimized
                                         />
@@ -628,7 +629,7 @@ export function ImageOutput({
                                 )}
                             </div>
                         ) : (
-                            <div className='photo-paper relative flex aspect-[4/3] w-full max-w-[720px] flex-col justify-between p-5 sm:p-6'>
+                            <div className='photo-paper relative flex aspect-[4/3] w-full max-w-[780px] flex-col justify-between p-5 sm:p-6 2xl:max-w-[860px]'>
                                 <div className='space-y-3'>
                                     <div className='text-muted-foreground text-xs'>{t('output.previewEyebrow')}</div>
                                     <div className='space-y-2'>

src/components/workbench-status-strip.test.tsx

@@ -6,21 +6,21 @@ import * as React from 'react';
 import { renderToStaticMarkup } from 'react-dom/server';
 
 describe('WorkbenchStatusStrip', () => {
-    it('shows model, channel, streaming status, cost, and API state before generation', () => {
+    it('shows model, request route, streaming status, cost, and runtime state before generation', () => {
         const html = renderToStaticMarkup(
             <I18nProvider>
                 <WorkbenchStatusStrip
                     model='gpt-image-2'
-                    channelLabel='默认线路'
+                    routeLabel='images-sse'
                     streamStatus='流式可用'
                     costLabel='预计 0.12 积分'
                 />
             </I18nProvider>
         );
 
-        assert.match(html, /API 连接正常/);
+        assert.match(html, /运行时可用/);
         assert.match(html, /gpt-image-2/);
-        assert.match(html, /默认线路/);
+        assert.match(html, /images-sse/);
         assert.match(html, /流式可用/);
         assert.match(html, /预计 0\.12 积分/);
     });
@@ -30,7 +30,7 @@ describe('WorkbenchStatusStrip', () => {
             <I18nProvider>
                 <WorkbenchStatusStrip
                     model='gpt-image-2'
-                    channelLabel='默认线路'
+                    routeLabel='默认线路'
                     streamStatus='流式可用'
                     parallelBatchEnabled
                     costLabel='预计 0.24 积分'
@@ -40,4 +40,44 @@ describe('WorkbenchStatusStrip', () => {
 
         assert.match(html, /并发已启用/);
     });
+
+    it('renders disconnected, route-limited, and custom override runtime states explicitly', () => {
+        const disconnectedHtml = renderToStaticMarkup(
+            <I18nProvider>
+                <WorkbenchStatusStrip
+                    model='gpt-image-2'
+                    routeLabel='服务器默认'
+                    streamStatus='普通生成'
+                    costLabel='预计 0.12 积分'
+                    runtimeHealthStatus='disconnected'
+                />
+            </I18nProvider>
+        );
+        const routeLimitedHtml = renderToStaticMarkup(
+            <I18nProvider>
+                <WorkbenchStatusStrip
+                    model='gpt-image-2'
+                    routeLabel='服务器默认'
+                    streamStatus='流式可用'
+                    costLabel='预计 0.12 积分'
+                    runtimeHealthStatus='route-limited'
+                />
+            </I18nProvider>
+        );
+        const customOverrideHtml = renderToStaticMarkup(
+            <I18nProvider>
+                <WorkbenchStatusStrip
+                    model='gpt-image-2'
+                    routeLabel='使用自定义上游'
+                    streamStatus='普通生成'
+                    costLabel='预计 0.12 积分'
+                    runtimeHealthStatus='custom-override'
+                />
+            </I18nProvider>
+        );
+
+        assert.match(disconnectedHtml, /运行时未连接/);
+        assert.match(routeLimitedHtml, /运行态受限/);
+        assert.match(customOverrideHtml, /使用自定义上游/);
+    });
 });

src/components/workbench-status-strip.tsx

@@ -1,27 +1,46 @@
 'use client';
 
 import { useI18n } from '@/lib/i18n';
+import type { RuntimeHealthStatus } from '@/lib/runtime-health-status';
 import { cn } from '@/lib/utils';
 import { CircleCheck } from 'lucide-react';
 
 type WorkbenchStatusStripProps = {
     model: string;
-    channelLabel: string;
+    routeLabel: string;
     streamStatus: string;
     parallelBatchEnabled?: boolean;
     costLabel: string;
+    runtimeHealthStatus?: RuntimeHealthStatus;
     className?: string;
 };
 
 export function WorkbenchStatusStrip({
     model,
-    channelLabel,
+    routeLabel,
     streamStatus,
     parallelBatchEnabled = false,
     costLabel,
+    runtimeHealthStatus = 'runtime-ready',
     className
 }: WorkbenchStatusStripProps) {
     const { t } = useI18n();
+    const runtimeStatusLabel =
+        runtimeHealthStatus === 'custom-override'
+            ? t('app.apiCustomOverride')
+            : runtimeHealthStatus === 'runtime-ready'
+              ? t('app.apiRuntimeReady')
+              : runtimeHealthStatus === 'route-limited'
+                ? t('app.apiRouteLimited')
+                : t('app.apiDisconnected');
+    const runtimeStatusColorClass =
+        runtimeHealthStatus === 'custom-override'
+            ? 'text-[oklch(0.44_0.08_55)]'
+            : runtimeHealthStatus === 'runtime-ready'
+              ? 'text-[oklch(0.5_0.12_150)]'
+              : runtimeHealthStatus === 'route-limited'
+                ? 'text-[oklch(0.56_0.12_82)]'
+                : 'text-[oklch(0.58_0.02_55)]';
 
     return (
         <div
@@ -30,14 +49,14 @@ export function WorkbenchStatusStrip({
                 className
             )}>
             <span className='border-border bg-card/70 inline-flex min-h-6 items-center gap-1.5 rounded-full border px-2 py-0.5 sm:min-h-7 sm:gap-2 sm:px-2.5 sm:py-1'>
-                <CircleCheck className='h-3.5 w-3.5 text-[oklch(0.5_0.12_150)]' />
-                {t('app.apiConnected')}
+                <CircleCheck className={cn('h-3.5 w-3.5', runtimeStatusColorClass)} />
+                {runtimeStatusLabel}
             </span>
             <span className='border-border bg-card/70 inline-flex min-h-6 items-center rounded-full border px-2 py-0.5 sm:min-h-7 sm:px-2.5 sm:py-1'>
                 {model}
             </span>
             <span className='border-border bg-card/70 inline-flex min-h-6 items-center rounded-full border px-2 py-0.5 sm:min-h-7 sm:px-2.5 sm:py-1'>
-                {channelLabel}
+                {routeLabel}
             </span>
             <span className='inline-flex min-h-6 items-center rounded-full border border-[oklch(0.78_0.055_205)] bg-[oklch(0.94_0.028_205)] px-2 py-0.5 text-[oklch(0.38_0.065_218)] sm:min-h-7 sm:px-2.5 sm:py-1'>
                 {streamStatus}

src/lib/channel-request-mode-values.mjs

@@ -6,7 +6,7 @@ export const CHANNEL_REQUEST_MODES = Object.freeze([
 ]);
 
 export const CHANNEL_REQUEST_MODE_SMOKE_CASES = Object.freeze({
-    'images-non-stream': Object.freeze(['generate_1k', 'edit_1k']),
+    'images-non-stream': Object.freeze(['orchestration_generate_1k', 'edit_1k']),
     'images-sse': Object.freeze(['page_sse_edit_2k']),
     'responses-non-stream': Object.freeze(['responses_agent_generate_1k']),
     'responses-sse': Object.freeze(['responses_page_sse_generate_1k'])

src/lib/i18n.tsx

@@ -19,7 +19,10 @@ const messages: Record<Locale, Record<string, string>> = {
         'app.studioSubtitle': '今天想做什么画面？',
         'app.creationControls': '创作参数',
         'app.canvasPreview': '画布预览',
-        'app.apiConnected': 'API 连接正常',
+        'app.apiRuntimeReady': '运行时可用',
+        'app.apiRouteLimited': '运行态受限',
+        'app.apiDisconnected': '运行时未连接',
+        'app.apiCustomOverride': '使用自定义上游',
         'mode.generate': '文生图',
         'mode.edit': '图生图',
         'mode.batch': '批量',
@@ -463,6 +466,8 @@ const messages: Record<Locale, Record<string, string>> = {
         'api.key': 'API Key',
         'api.url': 'API URL',
         'api.urlHint': '填 OpenAI 兼容接口根地址，通常以 /v1 结尾；不要填管理后台网页地址。',
+        'api.urlPairHint': '自定义 API URL 必须和自定义 API Key 一起填写，避免把服务端密钥发送到未知上游。',
+        'api.urlPairRequired': '自定义 API URL 必须同时填写自定义 API Key。',
         'api.saved': '已保存',
         'api.saveFailed': '保存失败',
         'password.configure': '配置访问码',
@@ -537,7 +542,10 @@ const messages: Record<Locale, Record<string, string>> = {
         'app.studioSubtitle': 'What image are we making today?',
         'app.creationControls': 'Creation controls',
         'app.canvasPreview': 'Canvas preview',
-        'app.apiConnected': 'API connected',
+        'app.apiRuntimeReady': 'Runtime ready',
+        'app.apiRouteLimited': 'Route limited',
+        'app.apiDisconnected': 'Runtime disconnected',
+        'app.apiCustomOverride': 'Custom upstream',
         'mode.generate': 'Text to image',
         'mode.edit': 'Image edit',
         'mode.batch': 'Batch',
@@ -1006,6 +1014,9 @@ const messages: Record<Locale, Record<string, string>> = {
         'api.url': 'API URL',
         'api.urlHint':
             'Use the OpenAI-compatible API root, usually ending with /v1. Do not enter an admin dashboard URL.',
+        'api.urlPairHint':
+            'A custom API URL must be paired with a custom API key so the server never forwards its own credentials to an unknown upstream.',
+        'api.urlPairRequired': 'A custom API URL requires a custom API key.',
         'api.saved': 'Saved',
         'api.saveFailed': 'Save failed',
         'password.configure': 'Configure Access Code',

src/lib/runtime-health-status.test.ts

@@ -0,0 +1,122 @@
+import assert from 'node:assert/strict';
+import { describe, it } from 'node:test';
+import { resolveRuntimeHealthStatus } from './runtime-health-status';
+
+describe('resolveRuntimeHealthStatus', () => {
+    it('treats a healthy declared route as ready for the current form request', () => {
+        assert.equal(
+            resolveRuntimeHealthStatus({
+                runtimeCapabilities: {
+                    streaming: { defaultBackend: 'images-api' },
+                    responsesImageBackend: { enabled: true },
+                    channelRouting: {
+                        effectiveRequestModes: ['images-non-stream', 'images-sse'],
+                        requestModeHealth: [
+                            {
+                                mode: 'images-sse',
+                                configuredCredentialCount: 1,
+                                healthyCredentialCount: 1,
+                                configuredChannelCount: 1,
+                                healthyChannelCount: 1
+                            }
+                        ]
+                    }
+                },
+                hasRequestApiOverride: false,
+                imageBackend: 'images-api',
+                streamingStrategy: 'auto',
+                streamMode: 'stream'
+            }),
+            'runtime-ready'
+        );
+    });
+
+    it('keeps auto streaming ready when only the non-stream fallback is healthy', () => {
+        assert.equal(
+            resolveRuntimeHealthStatus({
+                runtimeCapabilities: {
+                    streaming: { defaultBackend: 'responses-image-generation' },
+                    responsesImageBackend: { enabled: true },
+                    channelRouting: {
+                        effectiveRequestModes: ['responses-non-stream'],
+                        requestModeHealth: [
+                            {
+                                mode: 'responses-non-stream',
+                                configuredCredentialCount: 1,
+                                healthyCredentialCount: 1,
+                                configuredChannelCount: 1,
+                                healthyChannelCount: 1
+                            }
+                        ]
+                    }
+                },
+                hasRequestApiOverride: false,
+                imageBackend: 'server-default',
+                streamingStrategy: 'auto',
+                streamMode: 'auto'
+            }),
+            'runtime-ready'
+        );
+    });
+
+    it('marks custom overrides before runtime readiness checks', () => {
+        assert.equal(
+            resolveRuntimeHealthStatus({
+                runtimeCapabilities: null,
+                hasRequestApiOverride: true,
+                imageBackend: 'images-api',
+                streamingStrategy: 'auto',
+                streamMode: 'auto'
+            }),
+            'custom-override'
+        );
+    });
+
+    it('marks a missing requested route as limited when no healthy mode can satisfy it', () => {
+        assert.equal(
+            resolveRuntimeHealthStatus({
+                runtimeCapabilities: {
+                    streaming: { defaultBackend: 'responses-image-generation' },
+                    responsesImageBackend: { enabled: false },
+                    channelRouting: {
+                        effectiveRequestModes: ['images-non-stream'],
+                        requestModeHealth: [
+                            {
+                                mode: 'images-non-stream',
+                                configuredCredentialCount: 1,
+                                healthyCredentialCount: 0,
+                                configuredChannelCount: 1,
+                                healthyChannelCount: 0
+                            }
+                        ]
+                    }
+                },
+                hasRequestApiOverride: false,
+                imageBackend: 'responses-image-generation',
+                streamingStrategy: 'auto',
+                streamMode: 'stream'
+            }),
+            'route-limited'
+        );
+    });
+
+    it('marks request API key-only overrides before server route health checks', () => {
+        assert.equal(
+            resolveRuntimeHealthStatus({
+                runtimeCapabilities: {
+                    streaming: { defaultBackend: 'images-api' },
+                    responsesImageBackend: { enabled: true },
+                    channelRouting: {
+                        effectiveRequestModes: [],
+                        requestModeHealth: []
+                    }
+                },
+                hasRequestApiOverride: true,
+                imageBackend: 'images-api',
+                streamingStrategy: 'auto',
+                streamMode: 'auto'
+            }),
+            'custom-override'
+        );
+    });
+});

src/lib/runtime-health-status.ts

@@ -0,0 +1,110 @@
+import { IMAGE_UPSTREAM_FORM_SERVER_DEFAULT, type ImageUpstreamFormBackend } from './image-upstream-form';
+import type { ImageGenerationBackend, ImageStreamMode, ImageStreamingStrategy } from './image-upstream-strategy';
+
+type RuntimeRequestMode = 'images-non-stream' | 'images-sse' | 'responses-non-stream' | 'responses-sse';
+
+export type RuntimeHealthStatus = 'runtime-ready' | 'route-limited' | 'disconnected' | 'custom-override';
+
+export type RuntimeHealthCapabilities = {
+    streaming?: {
+        defaultBackend?: ImageGenerationBackend | null;
+    } | null;
+    responsesImageBackend?: {
+        enabled?: boolean | null;
+    } | null;
+    channelRouting?: {
+        effectiveRequestModes?: readonly string[] | null;
+        requestModeHealth?: Array<{
+            mode: string;
+            healthyCredentialCount: number;
+            healthyChannelCount: number;
+        }> | null;
+    } | null;
+};
+
+function resolveRequestedBackend(input: {
+    runtimeCapabilities: RuntimeHealthCapabilities | null;
+    imageBackend: ImageUpstreamFormBackend;
+}): ImageGenerationBackend {
+    if (input.imageBackend !== IMAGE_UPSTREAM_FORM_SERVER_DEFAULT) {
+        return input.imageBackend;
+    }
+    return input.runtimeCapabilities?.streaming?.defaultBackend === 'responses-image-generation'
+        ? 'responses-image-generation'
+        : 'images-api';
+}
+
+function resolvePreferredRequestMode(input: {
+    runtimeCapabilities: RuntimeHealthCapabilities | null;
+    imageBackend: ImageUpstreamFormBackend;
+    streamingStrategy: ImageStreamingStrategy;
+    streamMode: ImageStreamMode;
+}): RuntimeRequestMode {
+    const backend = resolveRequestedBackend({
+        runtimeCapabilities: input.runtimeCapabilities,
+        imageBackend: input.imageBackend
+    });
+    const streamEnabled = input.streamMode === 'stream' || (input.streamMode === 'auto' && input.streamingStrategy !== 'off');
+    if (backend === 'responses-image-generation') {
+        return streamEnabled ? 'responses-sse' : 'responses-non-stream';
+    }
+    return streamEnabled ? 'images-sse' : 'images-non-stream';
+}
+
+function resolveFallbackRequestMode(input: {
+    runtimeCapabilities: RuntimeHealthCapabilities | null;
+    imageBackend: ImageUpstreamFormBackend;
+    streamingStrategy: ImageStreamingStrategy;
+    streamMode: ImageStreamMode;
+}): RuntimeRequestMode | null {
+    if (input.streamMode !== 'auto' || input.streamingStrategy === 'off') return null;
+    const backend = resolveRequestedBackend({
+        runtimeCapabilities: input.runtimeCapabilities,
+        imageBackend: input.imageBackend
+    });
+    return backend === 'responses-image-generation' ? 'responses-non-stream' : 'images-non-stream';
+}
+
+function hasHealthyRequestMode(
+    runtimeCapabilities: RuntimeHealthCapabilities | null,
+    requestMode: RuntimeRequestMode
+): boolean {
+    const healthItems = runtimeCapabilities?.channelRouting?.requestModeHealth;
+    if (Array.isArray(healthItems)) {
+        const healthItem = healthItems.find((item) => item.mode === requestMode);
+        if (healthItem) {
+            return healthItem.healthyCredentialCount > 0 && healthItem.healthyChannelCount > 0;
+        }
+    }
+    return runtimeCapabilities?.channelRouting?.effectiveRequestModes?.includes(requestMode) === true;
+}
+
+export function resolveRuntimeHealthStatus(input: {
+    runtimeCapabilities: RuntimeHealthCapabilities | null;
+    hasRequestApiOverride: boolean;
+    imageBackend: ImageUpstreamFormBackend;
+    streamingStrategy: ImageStreamingStrategy;
+    streamMode: ImageStreamMode;
+}): RuntimeHealthStatus {
+    if (input.hasRequestApiOverride) return 'custom-override';
+    if (input.runtimeCapabilities === null) return 'disconnected';
+    const requestedBackend = resolveRequestedBackend({
+        runtimeCapabilities: input.runtimeCapabilities,
+        imageBackend: input.imageBackend
+    });
+    if (
+        requestedBackend === 'responses-image-generation' &&
+        input.runtimeCapabilities.responsesImageBackend?.enabled !== true
+    ) {
+        return 'route-limited';
+    }
+    const preferredRequestMode = resolvePreferredRequestMode(input);
+    if (hasHealthyRequestMode(input.runtimeCapabilities, preferredRequestMode)) {
+        return 'runtime-ready';
+    }
+    const fallbackRequestMode = resolveFallbackRequestMode(input);
+    if (fallbackRequestMode && hasHealthyRequestMode(input.runtimeCapabilities, fallbackRequestMode)) {
+        return 'runtime-ready';
+    }
+    return 'route-limited';
+}