Deploy 3203c24 to Docker Space

Source: MisonL/gpt-image-playground-customer@3203c24f5434c569bbfec2fb425430d3e45fcbc3

public/hf-space-deploy-marker.json

@@ -1,6 +1,6 @@
 {
   "schema_version": 1,
-  "local_sha": "a623efcc28ea071e4a51a2753173829a0ee01002",
-  "created_at": "2026-06-21T06:16:41.993Z",
-  "deploy_id": "83a9c54d-c4df-43fc-8045-97fe4feadb16"
+  "local_sha": "3203c24f5434c569bbfec2fb425430d3e45fcbc3",
+  "created_at": "2026-06-23T13:55:49.360Z",
+  "deploy_id": "dea5a9f7-24bf-4297-a091-f730901c220a"
 }

scripts/agent-skill-scripts.test.mjs

@@ -18,6 +18,28 @@ const repoRoot = fileURLToPath(new URL('..', import.meta.url));
 const skillRoot = join(repoRoot, 'skills/gpt-image-playground-agent');
 const skillScriptsRoot = join(repoRoot, 'skills/gpt-image-playground-agent/scripts');
 
+function agentGenerateCapabilities(extra = {}) {
+    return {
+        orchestration: {
+            supported: true,
+            transport_selection: 'server_owned',
+            endpoint: '/api/agent/image-requests'
+        },
+        agent_jobs: { supported: true, mode: 'job_polling' },
+        limits: {
+            generate_images: { min: 1, max: 4 },
+            partial_images: { min: 0, max: 4 },
+            partial_images_by_backend: {
+                'images-api': { min: 0, max: 4 },
+                'responses-image-generation': { min: 1, max: 3 }
+            },
+            upload_images: { max: 8 }
+        },
+        defaults: { partial_images: 2 },
+        ...extra
+    };
+}
+
 describe('Agent skill script argument validation', () => {
     it('rejects invalid generate numeric options before dry-run output', () => {
         const result = runSkillScript('generate-image.mjs', ['--n', 'abc', 'prompt']);
@@ -583,20 +605,249 @@ describe('Agent skill script argument validation', () => {
         assert.equal(result.stderr.trim(), '');
     });
 
-    it('prints page SSE routing guidance for high-resolution generate dry-runs', () => {
+    it('prints server orchestration guidance for high-resolution generate dry-runs', () => {
         const result = runSkillScript('generate-image.mjs', ['--size', '3072x2048', '--quality', 'high', 'prompt']);
 
         assert.equal(result.status, 0);
         const body = JSON.parse(result.stdout);
-        assert.equal(body.endpoint, 'http://localhost:4783/api/images');
-        assert.equal(body.routing_guidance.recommended_endpoint, '/api/images');
-        assert.equal(body.routing_guidance.transport, 'page_sse');
-        assert.equal(body.routing_guidance.fallback_endpoint, '/api/agent/images/generate');
-        assert.equal(body.routing_guidance.fallback_mode, 'manual_after_diagnosis');
-        assert.equal(body.routing_guidance.reason.includes('max_edge>2048'), true);
+        assert.equal(body.endpoint, 'http://localhost:4783/api/agent/image-requests');
+        assert.equal(body.routing_guidance.recommended_endpoint, '/api/agent/image-requests');
+        assert.equal(body.routing_guidance.transport, 'server_orchestrated');
+        assert.equal(body.routing_guidance.result_mode, 'job_polling');
+        assert.match(body.routing_guidance.reason, /服务端负责选择内部执行路径/);
+        assert.equal(result.stderr.trim(), '');
+    });
+
+    it('prints server orchestration guidance for remote HTTPS small generate dry-runs', () => {
+        const result = runSkillScript('generate-image.mjs', ['--base-url', 'https://space.example.test', 'prompt']);
+
+        assert.equal(result.status, 0);
+        const body = JSON.parse(result.stdout);
+        assert.equal(body.endpoint, 'https://space.example.test/api/agent/image-requests');
+        assert.equal(body.routing_guidance.recommended_endpoint, '/api/agent/image-requests');
+        assert.equal(body.routing_guidance.transport, 'server_orchestrated');
+        assert.equal(body.routing_guidance.strength, 'recommended');
+        assert.match(body.routing_guidance.reason, /只提交生成意图/);
         assert.equal(result.stderr.trim(), '');
     });
 
+    it('uses the server orchestration endpoint for default billable generate requests', async () => {
+        const requests = [];
+        let imageRequestBody = '';
+        await withServer(
+            async (request, response) => {
+                requests.push({ method: request.method, url: request.url });
+                if (request.url === '/api/agent/capabilities') {
+                    response.writeHead(200, { 'content-type': 'application/json' });
+                    response.end(JSON.stringify(agentGenerateCapabilities()));
+                    return;
+                }
+                if (request.url === '/api/agent/image-requests') {
+                    imageRequestBody = await readRequestText(request);
+                    response.writeHead(202, { 'content-type': 'application/json', 'retry-after': '1' });
+                    response.end(
+                        JSON.stringify({
+                            job: {
+                                id: 'job-orchestrated-1',
+                                state: 'running',
+                                result_url: '/api/agent/jobs/job-orchestrated-1/result',
+                                retry_after_seconds: 1
+                            }
+                        })
+                    );
+                    return;
+                }
+                if (request.url === '/api/agent/jobs/job-orchestrated-1/result') {
+                    response.writeHead(200, { 'content-type': 'application/json' });
+                    response.end(
+                        JSON.stringify({
+                            request_id: 'job-orchestrated-1',
+                            idempotency_key: 'orchestrated-key',
+                            cached: false,
+                            images: [
+                                {
+                                    id: 'artifact-orchestrated-1',
+                                    filename: 'orchestrated.webp',
+                                    content_url: '/api/agent/artifacts/artifact-orchestrated-1/content',
+                                    width: 1254,
+                                    height: 1254
+                                }
+                            ],
+                            execution: {
+                                transport: 'agent_job_polling',
+                                endpoint: '/api/agent/image-requests',
+                                route_mode: 'job',
+                                image_backend: 'images-api',
+                                stream_mode: 'non_stream',
+                                streaming_strategy: 'off'
+                            },
+                            timing: { server_elapsed_ms: 1234 }
+                        })
+                    );
+                    return;
+                }
+                if (request.url === '/api/agent/images/generate' || request.url === '/api/images') {
+                    response.writeHead(500, { 'content-type': 'application/json' });
+                    response.end(JSON.stringify({ error: 'unexpected client-selected route' }));
+                    return;
+                }
+                response.writeHead(404, { 'content-type': 'application/json' });
+                response.end(JSON.stringify({ error: 'missing' }));
+            },
+            async (baseUrl) => {
+                const result = await runSkillScriptAsync(
+                    'generate-image.mjs',
+                    [
+                        '--allow-billable',
+                        '--idempotency-key',
+                        'orchestrated-key',
+                        '--size',
+                        '3072x2048',
+                        '--streaming-strategy',
+                        'off',
+                        'prompt'
+                    ],
+                    { GPT_IMAGE_PLAYGROUND_URL: baseUrl }
+                );
+
+                assert.equal(result.status, 0);
+                assert.equal(result.stderr.trim(), '');
+                const body = JSON.parse(result.stdout);
+                assert.deepEqual(body.routing, {
+                    transport: 'server_orchestrated',
+                    endpoint: '/api/agent/image-requests'
+                });
+                assert.equal(body.summary.transport, 'agent_job_polling');
+                assert.equal(body.summary.endpoint, '/api/agent/image-requests');
+                assert.equal(body.summary.route_mode, 'job');
+                assert.deepEqual(body.summary.content_urls, ['/api/agent/artifacts/artifact-orchestrated-1/content']);
+                assert.deepEqual(body.summary.actual_dimensions, { width: 1254, height: 1254 });
+                assert.deepEqual(
+                    requests.map((item) => `${item.method} ${item.url}`),
+                    [
+                        'GET /api/agent/capabilities',
+                        'POST /api/agent/image-requests',
+                        'GET /api/agent/jobs/job-orchestrated-1/result'
+                    ]
+                );
+                const requestBody = JSON.parse(imageRequestBody);
+                assert.equal(requestBody.size, '3072x2048');
+                assert.equal(requestBody.streaming_strategy, 'off');
+            }
+        );
+    });
+
+    it('checks the server orchestration endpoint during generate contract checks', async () => {
+        const requests = [];
+        await withServer(
+            (request, response) => {
+                requests.push({ method: request.method, url: request.url });
+                if (request.url === '/api/agent/capabilities') {
+                    response.writeHead(200, { 'content-type': 'application/json' });
+                    response.end(JSON.stringify(agentGenerateCapabilities()));
+                    return;
+                }
+                if (
+                    request.url === '/api/agent/images/generate' ||
+                    request.url === '/api/agent/image-requests' ||
+                    request.url === '/api/agent/jobs/images/generate'
+                ) {
+                    response.writeHead(400, { 'content-type': 'application/json' });
+                    response.end(
+                        JSON.stringify({
+                            error: {
+                                code: 'idempotency_key_required',
+                                message: 'missing key',
+                                retryable: false
+                            }
+                        })
+                    );
+                    return;
+                }
+                response.writeHead(404, { 'content-type': 'application/json' });
+                response.end(JSON.stringify({ error: 'missing' }));
+            },
+            async (baseUrl) => {
+                const result = await runSkillScriptAsync(
+                    'generate-image.mjs',
+                    ['--contract-check', 'contract check'],
+                    { GPT_IMAGE_PLAYGROUND_URL: baseUrl }
+                );
+
+                assert.equal(result.status, 0);
+                assert.equal(result.stderr.trim(), '');
+                const body = JSON.parse(result.stdout);
+                assert.deepEqual(
+                    body.checks.map((check) => check.endpoint),
+                    [
+                        '/api/agent/images/generate',
+                        '/api/agent/image-requests',
+                        '/api/agent/jobs/images/generate'
+                    ]
+                );
+                assert.deepEqual(
+                    requests.map((item) => `${item.method} ${item.url}`),
+                    [
+                        'GET /api/agent/capabilities',
+                        'POST /api/agent/images/generate',
+                        'POST /api/agent/image-requests',
+                        'POST /api/agent/jobs/images/generate'
+                    ]
+                );
+            }
+        );
+    });
+
+    it('fails generate contract checks when the default orchestration contract is missing', async () => {
+        const requests = [];
+        await withServer(
+            (request, response) => {
+                requests.push({ method: request.method, url: request.url });
+                if (request.url === '/api/agent/capabilities') {
+                    response.writeHead(200, { 'content-type': 'application/json' });
+                    response.end(
+                        JSON.stringify(agentGenerateCapabilities({ orchestration: undefined }))
+                    );
+                    return;
+                }
+                if (request.url === '/api/agent/images/generate') {
+                    response.writeHead(400, { 'content-type': 'application/json' });
+                    response.end(
+                        JSON.stringify({
+                            error: {
+                                code: 'idempotency_key_required',
+                                message: 'missing key',
+                                retryable: false
+                            }
+                        })
+                    );
+                    return;
+                }
+                response.writeHead(500, { 'content-type': 'application/json' });
+                response.end(JSON.stringify({ error: 'unexpected contract probe' }));
+            },
+            async (baseUrl) => {
+                const result = await runSkillScriptAsync(
+                    'generate-image.mjs',
+                    ['--contract-check', 'contract check'],
+                    { GPT_IMAGE_PLAYGROUND_URL: baseUrl }
+                );
+
+                assert.equal(result.status, 1);
+                assert.equal(result.stdout.trim(), '');
+                const body = JSON.parse(result.stderr);
+                assert.equal(body.error.code, 'orchestration_required');
+                assert.deepEqual(
+                    requests.map((item) => `${item.method} ${item.url}`),
+                    [
+                        'GET /api/agent/capabilities',
+                        'POST /api/agent/images/generate'
+                    ]
+                );
+            }
+        );
+    });
+
     it('expands generate presets into concrete dry-run request fields', () => {
         const agentResult = runSkillScript('generate-image.mjs', ['--preset', '4k-agent-nonstream', 'prompt']);
         assert.equal(agentResult.status, 0);
@@ -616,7 +867,7 @@ describe('Agent skill script argument validation', () => {
         assert.equal(upstreamSseBody.request.partial_images, 2);
     });
 
-    it('does not automatically fall back after a billable page SSE generate failure', async () => {
+    it('does not automatically fall back after an explicit billable page SSE generate failure', async () => {
         const requests = [];
         await withServer(
             (request, response) => {
@@ -649,7 +900,7 @@ describe('Agent skill script argument validation', () => {
             async (baseUrl) => {
                 const result = await runSkillScriptAsync(
                     'generate-image.mjs',
-                    ['--allow-billable', '--size', '3072x2048', '--quality', 'high', 'prompt'],
+                    ['--allow-billable', '--page-sse', '--size', '3072x2048', '--quality', 'high', 'prompt'],
                     { GPT_IMAGE_PLAYGROUND_URL: baseUrl }
                 );
 
@@ -698,7 +949,7 @@ describe('Agent skill script argument validation', () => {
             async (baseUrl) => {
                 const result = await runSkillScriptAsync(
                     'generate-image.mjs',
-                    ['--allow-billable', '--size', '3072x2048', '--quality', 'invalid-quality', 'prompt'],
+                    ['--allow-billable', '--page-sse', '--size', '3072x2048', '--quality', 'invalid-quality', 'prompt'],
                     { GPT_IMAGE_PLAYGROUND_URL: baseUrl }
                 );
 
@@ -744,7 +995,7 @@ describe('Agent skill script argument validation', () => {
             async (baseUrl) => {
                 const result = await runSkillScriptAsync(
                     'generate-image.mjs',
-                    ['--allow-billable', '--size', '3072x2048', '--quality', 'high', 'prompt'],
+                    ['--allow-billable', '--page-sse', '--size', '3072x2048', '--quality', 'high', 'prompt'],
                     { GPT_IMAGE_PLAYGROUND_URL: baseUrl }
                 );
 
@@ -786,7 +1037,7 @@ describe('Agent skill script argument validation', () => {
             async (baseUrl) => {
                 const result = await runSkillScriptAsync(
                     'generate-image.mjs',
-                    ['--allow-billable', '--size', '3072x2048', '--quality', 'high', 'prompt'],
+                    ['--allow-billable', '--page-sse', '--size', '3072x2048', '--quality', 'high', 'prompt'],
                     { GPT_IMAGE_PLAYGROUND_URL: baseUrl }
                 );
 
@@ -834,7 +1085,7 @@ describe('Agent skill script argument validation', () => {
             async (baseUrl) => {
                 const result = await runSkillScriptAsync(
                     'generate-image.mjs',
-                    ['--allow-billable', '--size', '3072x2048', '--quality', 'high', 'prompt'],
+                    ['--allow-billable', '--page-sse', '--size', '3072x2048', '--quality', 'high', 'prompt'],
                     { GPT_IMAGE_PLAYGROUND_URL: baseUrl }
                 );
 
@@ -873,7 +1124,7 @@ describe('Agent skill script argument validation', () => {
             async (baseUrl) => {
                 const result = await runSkillScriptAsync(
                     'generate-image.mjs',
-                    ['--allow-billable', '--size', '3072x2048', '--quality', 'high', 'prompt'],
+                    ['--allow-billable', '--page-sse', '--size', '3072x2048', '--quality', 'high', 'prompt'],
                     { GPT_IMAGE_PLAYGROUND_URL: baseUrl }
                 );
 
@@ -922,7 +1173,7 @@ describe('Agent skill script argument validation', () => {
             async (baseUrl) => {
                 const result = await runSkillScriptAsync(
                     'generate-image.mjs',
-                    ['--allow-billable', '--size', '3072x2048', '--quality', 'high', 'prompt'],
+                    ['--allow-billable', '--page-sse', '--size', '3072x2048', '--quality', 'high', 'prompt'],
                     { GPT_IMAGE_PLAYGROUND_URL: baseUrl }
                 );
 
@@ -1131,7 +1382,7 @@ describe('Agent skill script argument validation', () => {
             async (baseUrl) => {
                 const result = await runSkillScriptAsync(
                     'generate-image.mjs',
-                    ['--allow-billable', '--size', '3072x2048', '--quality', 'high', 'prompt'],
+                    ['--allow-billable', '--page-sse', '--size', '3072x2048', '--quality', 'high', 'prompt'],
                     { GPT_IMAGE_PLAYGROUND_URL: baseUrl }
                 );
 
@@ -1268,7 +1519,7 @@ describe('Agent skill script argument validation', () => {
             async (baseUrl) => {
                 const result = await runSkillScriptAsync(
                     'generate-image.mjs',
-                    ['--allow-billable', '--idempotency-key', 'diag-generate-key', '--size', '1024x1024', 'prompt'],
+                    ['--allow-billable', '--agent', '--idempotency-key', 'diag-generate-key', '--size', '1024x1024', 'prompt'],
                     { GPT_IMAGE_PLAYGROUND_URL: baseUrl }
                 );
 
@@ -1336,7 +1587,7 @@ describe('Agent skill script argument validation', () => {
             async (baseUrl) => {
                 const result = await runSkillScriptAsync(
                     'generate-image.mjs',
-                    ['--allow-billable', '--idempotency-key', 'path-diag-key', '--size', '1024x1024', 'prompt'],
+                    ['--allow-billable', '--agent', '--idempotency-key', 'path-diag-key', '--size', '1024x1024', 'prompt'],
                     { GPT_IMAGE_PLAYGROUND_URL: `${baseUrl}/playground` }
                 );
 
@@ -1401,7 +1652,7 @@ describe('Agent skill script argument validation', () => {
             async (baseUrl) => {
                 const result = await runSkillScriptAsync(
                     'generate-image.mjs',
-                    ['--allow-billable', '--idempotency-key', 'terminal-diag-key', '--size', '1024x1024', 'prompt'],
+                    ['--allow-billable', '--agent', '--idempotency-key', 'terminal-diag-key', '--size', '1024x1024', 'prompt'],
                     {
                         GPT_IMAGE_AGENT_MAX_ATTEMPTS: '1',
                         GPT_IMAGE_PLAYGROUND_URL: baseUrl
@@ -1443,7 +1694,7 @@ describe('Agent skill script argument validation', () => {
             async (baseUrl) => {
                 const result = await runSkillScriptAsync(
                     'generate-image.mjs',
-                    ['--allow-billable', '--idempotency-key', 'diag-unavailable-key', '--size', '1024x1024', 'prompt'],
+                    ['--allow-billable', '--agent', '--idempotency-key', 'diag-unavailable-key', '--size', '1024x1024', 'prompt'],
                     { GPT_IMAGE_PLAYGROUND_URL: baseUrl }
                 );
 
@@ -1557,7 +1808,7 @@ describe('Agent skill script argument validation', () => {
             async (baseUrl) => {
                 const result = await runSkillScriptAsync(
                     'generate-image.mjs',
-                    ['--allow-billable', '--size', '3072x2048', '--quality', 'high', 'prompt'],
+                    ['--allow-billable', '--page-sse', '--size', '3072x2048', '--quality', 'high', 'prompt'],
                     { GPT_IMAGE_PLAYGROUND_URL: baseUrl }
                 );
 
@@ -1616,6 +1867,7 @@ describe('Agent skill script argument validation', () => {
                     'generate-image.mjs',
                     [
                         '--allow-billable',
+                        '--page-sse',
                         '--size',
                         '3072x2048',
                         '--quality',
@@ -1785,7 +2037,7 @@ describe('Agent skill script argument validation', () => {
             async (baseUrl) => {
                 const result = await runSkillScriptAsync(
                     'generate-image.mjs',
-                    ['--allow-billable', '--size', '3072x2048', '--quality', 'high', 'prompt'],
+                    ['--allow-billable', '--page-sse', '--size', '3072x2048', '--quality', 'high', 'prompt'],
                     {
                         GPT_IMAGE_PLAYGROUND_URL: baseUrl,
                         GPT_IMAGE_APP_PASSWORD_HASH: 'hash-for-page-sse'
@@ -1837,7 +2089,7 @@ describe('Agent skill script argument validation', () => {
             async (baseUrl) => {
                 const result = await runSkillScriptAsync(
                     'generate-image.mjs',
-                    ['--allow-billable', '--size', '3072x2048', '--quality', 'high', 'prompt'],
+                    ['--allow-billable', '--page-sse', '--size', '3072x2048', '--quality', 'high', 'prompt'],
                     { GPT_IMAGE_PLAYGROUND_URL: baseUrl }
                 );
 
@@ -1892,7 +2144,7 @@ describe('Agent skill script argument validation', () => {
             async (baseUrl) => {
                 const result = await runSkillScriptAsync(
                     'generate-image.mjs',
-                    ['--allow-billable', '--size', '3072x2048', '--quality', 'high', 'prompt'],
+                    ['--allow-billable', '--page-sse', '--size', '3072x2048', '--quality', 'high', 'prompt'],
                     { GPT_IMAGE_PLAYGROUND_URL: baseUrl }
                 );
 
@@ -1909,7 +2161,7 @@ describe('Agent skill script argument validation', () => {
         );
     });
 
-    it('uses Agent JSON for billable large generate requests when streaming strategy is off', async () => {
+    it('passes streaming strategy off through explicit Agent JSON generate requests', async () => {
         const requests = [];
         let agentRequestBody = '';
         await withServer(
@@ -1959,6 +2211,7 @@ describe('Agent skill script argument validation', () => {
                     'generate-image.mjs',
                     [
                         '--allow-billable',
+                        '--agent',
                         '--size',
                         '3072x2048',
                         '--quality',
@@ -3081,8 +3334,9 @@ describe('Agent skill script argument validation', () => {
         ]);
         assert.equal(disabledAutoPageSse.status, 0);
         const disabledAutoPageSseBody = JSON.parse(disabledAutoPageSse.stdout);
-        assert.equal(disabledAutoPageSseBody.endpoint, 'http://localhost:4783/api/agent/images/generate');
-        assert.equal(disabledAutoPageSseBody.routing_guidance.recommended_endpoint, '/api/agent/images/generate');
+        assert.equal(disabledAutoPageSseBody.endpoint, 'http://localhost:4783/api/agent/image-requests');
+        assert.equal(disabledAutoPageSseBody.routing_guidance.recommended_endpoint, '/api/agent/image-requests');
+        assert.equal(disabledAutoPageSseBody.routing_guidance.transport, 'server_orchestrated');
         assert.equal(disabledAutoPageSse.stderr.trim(), '');
 
         const disabledPageSse = runSkillScript('generate-image.mjs', [

scripts/command-center.test.mjs

@@ -731,6 +731,11 @@ describe('Command center scripts', () => {
                                 }
                             },
                             agent_jobs: { supported: true },
+                            orchestration: {
+                                supported: true,
+                                endpoint: '/api/agent/image-requests',
+                                transport_selection: 'server_owned'
+                            },
                             routing_rules: {
                                 high_resolution_edit: {
                                     conditions: { operation: 'edit', max_edge: { operator: 'gt', value: 2048 } }
@@ -781,6 +786,19 @@ describe('Command center scripts', () => {
                     );
                     return;
                 }
+                if (request.url === '/proxy/api/agent/image-requests') {
+                    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 === '/proxy/api/agent/jobs/images/generate') {
                     response.writeHead(400, { 'content-type': 'application/json' });
                     response.end(
@@ -859,6 +877,11 @@ describe('Command center scripts', () => {
                             storage: { image_storage_mode: 'indexeddb', postgres_configured: false },
                             agent_streaming: { page_sse: { supported: true } },
                             agent_jobs: { supported: true },
+                            orchestration: {
+                                supported: true,
+                                endpoint: '/api/agent/image-requests',
+                                transport_selection: 'server_owned'
+                            },
                             routing_rules: {
                                 high_resolution_edit: {
                                     conditions: { operation: 'edit', max_edge: { operator: 'gt', value: 2048 } }
@@ -922,6 +945,19 @@ describe('Command center scripts', () => {
                     );
                     return;
                 }
+                if (request.url === '/api/agent/image-requests') {
+                    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/images/generate') {
                     response.writeHead(400, { 'content-type': 'application/json' });
                     response.end(
@@ -955,6 +991,7 @@ describe('Command center scripts', () => {
                 assert.equal(body.summary.real_smoke_checks.agent_edit_1k, 'skipped');
                 assert.equal(body.summary.real_smoke_checks.page_sse_edit_2k, 'skipped');
                 assert.ok(hits.includes('/api/agent/images/generate'));
+                assert.ok(hits.includes('/api/agent/image-requests'));
                 assert.ok(hits.includes('/api/images'));
             }
         );

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

@@ -5,7 +5,7 @@ description: 当用户需要通过已部署的 GPT Image Playground 生成、编
 
 # GPT Image Playground Agent
 
-通过用户已部署的 GPT Image Playground 生成、编辑、批量处理或诊断图片接口。不要假设服务一定在本机；不要模拟网页表单；优先运行本 Skill 内置脚本，让脚本处理 Agent API 契约、capabilities、幂等键、路由选择和产物 URL。
+通过用户已部署的 GPT Image Playground 生成、编辑、批量处理或诊断图片接口。不要假设服务一定在本机；不要模拟网页表单；优先运行本 Skill 内置脚本，让脚本处理 Agent API 契约、capabilities、幂等键、服务端编排入口和产物 URL。
 
 Agent API 是给自动化客户端使用的机器接口，不是自治 Agent 平台。
 
@@ -19,7 +19,7 @@ Agent API 是给自动化客户端使用的机器接口，不是自治 Agent 平
 - 诊断上游图片接口：优先运行 `scripts/probe-upstream-image.mjs`。
 - 不要临时编写 Node/Python/shell 脚本、curl 命令或手写 fetch/FormData 来重复实现这些脚本已经覆盖的 API 调用。
 - 只有在内置脚本缺少用户明确需要的能力时，才修改或扩展 `scripts/` 内的预置脚本，并同步补测试；不要在仓库外留下 ad hoc 调用脚本。
-- 先用 dry-run 或 `--contract-check` 检查请求、路由和鉴权；只有用户明确允许真实计费时才加 `--allow-billable`。
+- 先用 dry-run 或 `--contract-check` 检查请求、路由、鉴权和服务声明的默认编排入口；只有用户明确允许真实计费时才加 `--allow-billable`。
 - 真实调用成功或失败后，优先读取脚本输出的 `summary`。它是面向 Agent 的机器摘要，包含 `billable`、请求 ID、幂等键、产物 URL、耗时、耗时拆分、路由、渠道、上游 host、脱敏请求头、重试和下一步动作；Agent JSON 失败时脚本会按幂等键做一次只读 Agent state 诊断补采样，补充 `agent_diagnostics_checked`、`agent_diagnostics_found`、`agent_diagnostics_unavailable_reason`、`agent_diagnostics_http_status`、`request_id`、渠道和上游 host。不要再先手查 SQLite、Docker logs 或上游后台。
 - 新增 probe、diagnostics、路由健康或请求旅程能力时，先在服务端定义机器 API 契约，并通过 `GET /api/agent/capabilities`、`GET /api/agent/openapi.json` 或明确的 `/api/agent/diagnostics/*` 端点声明；Skill 脚本只做薄封装，不能复制页面 API、运行态 API 和 Agent API 的边界判断。
 
@@ -31,14 +31,14 @@ Agent API 只作为自动化客户端接口，不作为首战场景或用户验
 
 ## 路由规则
 
-- 先读取 `GET /api/agent/capabilities` 的 `routing_rules`，按机器可读规则选择端点。
+- 先读取 `GET /api/agent/capabilities` 的 `orchestration` 与 `routing_rules`。普通文生图默认提交业务意图到 `orchestration.endpoint`，当前为 `POST /api/agent/image-requests`；服务端负责选择内部执行路径、上游策略和 job polling。Agent 客户端不要按尺寸、远端 HTTPS 或流式策略自行选择 `/api/images`、`/api/agent/images/generate` 或 job endpoint。
 - 默认 WebP edit 使用页面端 `POST /api/images` form-data SSE 路径，因为 Agent edit 不接收输出格式字段。需要 Responses image_generation edit 时也必须使用页面 SSE，不要用 `--agent`。显式 `--agent` 才使用 `/api/agent/images/edit` Agent multipart 最终 JSON，输出格式固定为 Agent 契约；如果页面流式不可用或失败，先诊断结构化错误，再用新的 `Idempotency-Key` 显式决定是否用 Agent edit 对照。Agent edit 只是对照路径，不保证与页面 SSE 的输出格式和像素尺寸完全一致；尺寸敏感任务必须用 `--dimension-check` 或下载后校验。
-- `capabilities` 里声明的 `page_sse_supported=true`、`agent_streaming.upstream_sse.supported=true` 只表示路径被声明支持，不表示当前渠道每次实测都能成功；如果页面 SSE 或 Responses 路径返回 `503`、断流，或 `summary` 里 `selected_channel_id`、`upstream_host` 为空，先诊断结构化错误，再用新的 `Idempotency-Key` 显式切换到 Agent JSON 或 job，不自动回退。
+- `capabilities` 里声明的 `page_sse_supported=true`、`agent_streaming.upstream_sse.supported=true` 只表示路径被声明支持，不表示当前渠道每次实测都能成功；如果页面 SSE、Responses 路径或服务端编排入口返回 `503`、断流，或 `summary` 里 `selected_channel_id`、`upstream_host` 为空，先诊断结构化错误，再用新的 `Idempotency-Key` 显式选择诊断路径，不自动回退。
 - 复杂 UI 批量出图优先使用页面端 `POST /api/images` SSE 和 `scripts/batch-images.mjs`；不要手动并行启动多个单张脚本，因为这会绕过 manifest、`--resume`、`capacity_feedback` 和尺寸门禁。需要并发时显式设置 `--concurrency N` 或页面“并发批量”开关，并记录切换原因、失败清单和续跑锚点。
 - 真实批量并发前先看 `GET /api/runtime-capabilities` 的 `channelQueue.capacityPerCredential` 和 `streamingBatch.recommendedConcurrency`。如果服务端建议并发为 `1`，或返回 `channel_capacity_queue_aborted` / `retry_after_seconds`，同一渠道任务保持 `--concurrency 1`，不要用多个 shell 进程绕过限流。
 - 复杂 UI、长 prompt、高质量图生图遇到 5 分钟级超时、连接中断或上游 503 时，不要把失败归因到提示词质量；先读 `summary` 和诊断，再用新 key 显式尝试压缩 prompt 或改为 `quality=medium` 的对照请求，并记录这是稳定性取舍。
 - 长图恢复或需要续跑锚点的生产请求优先使用页面端 `POST /api/images` SSE，保留局部进度和缺最终图诊断。
-- 普通小图单次文生图使用 `/api/agent/images/generate`；`max_edge>2048` 的单次文生图默认优先走页面端 `/api/images` SSE，流式失败后先诊断，再显式选择 Agent JSON 或 job 路径，不自动回退。
+- 普通单次文生图默认使用 `POST /api/agent/image-requests`。`--agent`、`--job`、`--page-sse` 是显式诊断或兼容开关：`--agent` 直连 `/api/agent/images/generate`，`--job` 直连 `/api/agent/jobs/images/generate`，`--page-sse` 直连页面端 `/api/images` SSE。不要把这些显式开关当成默认自动路由。
 - 单张文生图使用 `--responses-model`/`--gpt-model`、`--thinking`、`--prompt-optimization` 或 `--force-web` 时走页面端 `/api/images` SSE，因为这些是页面高级字段，不属于 Agent JSON schema。`--responses-model` 覆盖本次请求的 Responses 顶层模型；未传时使用服务端 `OPENAI_RESPONSES_API_MODEL`。该字段只影响本项目 `responses-image-generation` 路径，不改变兼容上游自身 Images API 桥接层内部选择的模型。`--responses-model` 必须同时设置 `--image-backend responses-image-generation` 或兼容别名 `responses`；显式 `--agent`、`--job`、`stream_mode=non_stream` 或 `streaming_strategy=off` 会被脚本前置拒绝。
 - 同一个已进入终态 `failed` 的 `Idempotency-Key` 只会回放失败；重新尝试必须先诊断原因，再创建新的业务操作和新的 key。
 
@@ -50,13 +50,13 @@ Agent API 只作为自动化客户端接口，不作为首战场景或用户验
 4. 非交互式任务无法向用户确认时，按“用户提供 URL > `GPT_IMAGE_PLAYGROUND_URL` > 默认本地探测地址”的顺序执行，并在输出里标明服务地址来源和是否只是自动发现。
 5. 位于仓库根目录且用户是首次配置、换机器、服务地址不确定或 token 不确定时，先运行 `npm run first-run`。该命令只读、非计费、不写 env 文件，默认输出中文摘要；`-- --json` 输出机器可读 JSON。它会报告 `service_base_url_source`、`interactive_confirmation_required`、服务可达性、当前进程是否拿到 Agent 鉴权、页面 SSE 鉴权是否可用，以及 `.env.agent.local` 是否存在私有鉴权配置。Agent CLI 默认从当前仓库根目录自动读取 `.env.agent.local`，shell 环境变量优先；如需禁用自动读取，设置 `GPT_IMAGE_AGENT_LOAD_ENV_FILE=0`。
 6. 让脚本请求 `GET /api/agent/capabilities`。如果所选地址不可达、404、不是 JSON 或不是 Agent capabilities 响应，交互式任务中向用户询问实际部署地址、端口、域名和是否需要鉴权；非交互式任务中显式失败并输出下一步动作。
-7. 读取 capabilities 中的认证方式、模型、模型级限制、`image_transport`、`routing_rules`、Agent 流式边界、页面 SSE 鉴权、后端 runtime enablement、状态后端和端点路径；不要硬编码假设部署方式。
+7. 读取 capabilities 中的认证方式、模型、模型级限制、`image_transport`、`orchestration`、`routing_rules`、Agent 流式边界、页面 SSE 鉴权、后端 runtime enablement、状态后端和端点路径；不要硬编码假设部署方式。
 8. 为每个业务操作生成稳定的 `Idempotency-Key`。网络中断、运行中轮询或非终态重试复用原 key；同一 key 已进入 `failed` 终态后不再用于触发新执行，必须先诊断原因，再创建新的业务操作和新的 key。
-9. 文生图使用 `POST /api/agent/images/generate`，请求体为 JSON。该 Agent 端点对外始终返回最终 `AgentImageResponse` JSON；如 capabilities 声明 `agent_streaming.upstream_sse.supported=true`，可通过 `image_backend`、`stream_mode`、`streaming_strategy`、`partial_images` 控制内部上游 SSE 消费。不要把 `responsesModel`、`thinking`、`promptOptimization` 或 `force_web` 发送到 Agent JSON；这些字段需要页面端 `/api/images` form-data 路径。
+9. 文生图默认使用 `POST /api/agent/image-requests`，请求体为 JSON 业务意图，服务端返回 job 状态并由脚本轮询 `job.result_url`。服务端内部仍会返回标准 `AgentImageResponse`，并在 `execution` 中暴露真实执行路径。显式 `--agent` 才使用 `POST /api/agent/images/generate`；不要把 `responsesModel`、`thinking`、`promptOptimization` 或 `force_web` 发送到 Agent JSON，这些字段需要页面端 `/api/images` form-data 路径。
 10. 图片编辑若走 Agent edit，使用 `POST /api/agent/images/edit`，请求体为 `multipart/form-data`，源图字段必须使用从 `image_0` 开始的连续字段，最大数量以 capabilities 的 `limits.upload_images.max` 为准；跳号、超过当前 profile 上限、`image_01` 或 `image_foo` 会被显式拒绝。该 Agent 端点同样是非流式端点；上游 SSE 字段按 `agent_streaming.upstream_sse.request_fields_by_mode.edit` 发送，不要给 Agent edit 传 `image_backend`。需要 `image_backend=responses-image-generation` 或页面表单字段 `image_streaming_strategy=responses-sse` 的 edit，一律走页面端 `/api/images` form-data SSE；脚本参数仍写作 `--streaming-strategy responses-sse`。
 11. 默认使用 `response_mode: "path"`，只在用户明确需要图片内联数据时使用 `base64` 或 `both`。
-12. 不要把页面端 `POST /api/images` 当成普通 Agent JSON 路径。它是页面表单和 SSE 路径，capabilities 会以 `agent_streaming.page_sse` 单独声明；仅在 `routing_rules` 命中高分辨率 edit、大图单次文生图、复杂 UI 批量、长图恢复、显式页面参数或明确诊断后切换。
-13. 读取 `agent_jobs`。job 路径只在显式选择时使用；`max_edge>2048` 的单次文生图默认优先走页面端 `/api/images` SSE。
+12. 不要把页面端 `POST /api/images` 当成普通 Agent JSON 路径。它是页面表单和 SSE 路径，capabilities 会以 `agent_streaming.page_sse` 单独声明；仅在默认 WebP edit、复杂 UI 批量、长图恢复、页面高级字段、显式 `--page-sse` 或明确诊断后使用。
+13. 读取 `agent_jobs` 只用于理解服务端编排结果和显式 `--job` 诊断路径。普通 generate 不再由 Agent 客户端根据本地/远端或尺寸选择 Agent JSON、page SSE 或 job。
 14. 处理失败时读取结构化 `error.code`、`error.retryable`、`error.diagnostics` 和 `Retry-After`。仅当 `retryable=true` 时等待后重试。页面 SSE 返回 `503`、断流，或 `summary` 里的 `selected_channel_id`、`upstream_host` 为空时，先按结构化失败诊断，再用新 key 显式换路径，不要把它当成已自动回退成功。
 15. 返回结果时优先给出 `summary`、`content_url`、`metadata_url`、`absolute_content_url`、`absolute_metadata_url`、产物 ID、尺寸、格式和是否命中幂等缓存。回答“4K 非流式花了多久”时优先读 `summary.elapsed_ms`，服务端返回 timing 时也读 `summary.server_elapsed_ms`。
 16. 需要查询页面请求后的人工反馈或日志摘要时，使用页面 SSE 的 `clientRequestId` 或脚本复用的 `Idempotency-Key` 调用 `scripts/diagnose-request.mjs --client-request-id ...`；不要直接调用 `/api/logs`。需要查询 Agent state 请求状态时，使用 `scripts/diagnose-request.mjs --agent-request-id ...` 或 `--idempotency-key ...`。
@@ -86,14 +86,14 @@ Authorization: Bearer <token>
 - 不要在没有 `Idempotency-Key` 的情况下调用生成或编辑接口。
 - 不要对同一个已进入终态 `failed` 的 `Idempotency-Key` 继续重试。终态失败回放会返回 `retryable=false`；需要重新尝试时，先确认失败原因，再创建新的业务操作和新的 `Idempotency-Key`。
 - 不要把 `agent_streaming.page_sse.supported=true` 解读为 `/api/agent/images/generate` 会对客户端返回 SSE；Agent generate/edit 对外仍是最终 JSON。`agent_streaming.upstream_sse` 仅表示服务端内部可消费上游 SSE 并保存最终 artifact。
-- 不要调用 job endpoints，除非 capabilities 明确返回 `agent_jobs.supported=true` 且 `mode=job_polling`。
+- 不要直接调用 job endpoints，除非 capabilities 明确返回 `agent_jobs.supported=true` 且 `mode=job_polling`，并且本次是显式 `--job` 诊断或兼容场景。默认 generate 使用 `orchestration.endpoint`。
 - 不要把一次高分辨率、高质量长耗时失败归纳为全局不可用。优先查看 `error.diagnostics.upstream_status`、`upstream_event_type`、`partial_image_count`、`transport_error`、`selected_channel_id`、`channel_cooldown_scope` 和 `retry_after_seconds`。
 - 不要在 `error.retryable=false` 时依据历史 `retry_after_seconds` 继续重试同一个 key；终态失败需要新业务操作和新 key。
 - 不要把 `/api/runtime-capabilities`、`/api/feedback`、`/api/shares`、`/api/logs` 或 `/api/image-delete` 当成 Agent API。它们是页面运行态或页面工作流端点，鉴权和字段契约与 `/api/agent/*` 不同；反馈和诊断的 Agent 只读入口是 `/api/agent/page-requests/{id}/feedback`、`/api/agent/page-requests/feedback`、`/api/agent/diagnostics/page-requests/{id}` 和 `/api/agent/diagnostics/page-requests`。
 
 ## Job Polling
 
-当 `agent_jobs.supported=true` 时，显式 job 路径可使用：
+默认 generate 不直接调用 job endpoint；服务端编排入口会在内部使用 job polling 并返回 `job.result_url`。当 `agent_jobs.supported=true` 且需要显式诊断或兼容旧流程时，job 路径可使用：
 
 1. `POST /api/agent/jobs/images/generate` 创建 job，仍必须提供 `Idempotency-Key`。
 2. `GET /api/agent/jobs/{id}` 轮询状态。
@@ -101,20 +101,20 @@ Authorization: Bearer <token>
 
 `GET /result` 在 job 运行中会返回 `request_in_progress` 和 `Retry-After`；不存在返回 `job_not_found`；过期返回 `job_expired`。同一业务操作重试创建 job 时复用原 `Idempotency-Key`，服务会返回同一个 job。
 
-当前 job polling 是同一服务实例内的后台任务，结果和错误写入 Agent 状态后端；它不是跨实例持久队列。若服务进程在 job 结束前重启，客户端应按状态和错误码继续轮询或重新创建同一 `Idempotency-Key` 的 job。若 job 已进入 `failed` 终态，`GET /result` 和状态摘要都会返回 `retryable=false`，并保留 `code`、`message`、`upstream_status` 和 `diagnostics` 用于定位原因，但同一个 key 不会触发新执行。需要重新尝试时，先确认失败原因，再以新的业务操作和新的 `Idempotency-Key` 创建 job。默认大图单次文生图已经切到页面端 `/api/images` SSE，job 不是默认路径。
+当前 job polling 是同一服务实例内的后台任务，结果和错误写入 Agent 状态后端；它不是跨实例持久队列。若服务进程在 job 结束前重启，客户端应按状态和错误码继续轮询或重新提交同一业务意图与同一 `Idempotency-Key`，避免重复业务操作。若 job 已进入 `failed` 终态，`GET /result` 和状态摘要都会返回 `retryable=false`，并保留 `code`、`message`、`upstream_status` 和 `diagnostics` 用于定位原因，但同一个 key 不会触发新执行。需要重新尝试时，先确认失败原因，再以新的业务操作和新的 `Idempotency-Key` 创建 job。
 
 ## 可用脚本
 
 以下脚本都位于当前 Skill 目录的 `scripts/` 下。不要硬编码本机安装路径；由运行环境按当前 `SKILL.md` 所在目录解析脚本路径。
 
-- `scripts/generate-image.mjs`：JSON 文生图调用。默认 dry-run，不消耗额度；必须添加 `--allow-billable` 才会真实生图。
+- `scripts/generate-image.mjs`：文生图调用。默认 dry-run，不消耗额度；真实执行默认提交到服务端编排入口，必须添加 `--allow-billable` 才会真实生图。
 - `scripts/edit-image.mjs`：multipart 编辑调用。默认 dry-run，不消耗额度；必须添加 `--allow-billable` 才会真实编辑。
 - `scripts/batch-images.mjs`：JSONL 批量 generate/edit 调用。默认 dry-run，不消耗额度；必须添加 `--allow-billable` 才会真实执行，支持 append-only manifest、`--resume`、`--ordered-prefix`、`--dimension-check`、`--max-attempts`、`--concurrency` 和顺序执行下的 `--max-consecutive-failures`。`--concurrency` 默认 `1`，大于 `1` 时并发执行并按输入顺序输出结果。
 - `scripts/convert-image-format.mjs`：本地 PNG/JPEG/WebP 互转。默认输出 WebP，质量 `100`；JPEG 会把透明背景铺成白色，PNG/WebP 保留透明。
 - `scripts/diagnose-request.mjs`：按一个或多个页面 `clientRequestId` 只读查询结果反馈和脱敏日志诊断摘要，也可按 Agent `request_id` 或 `idempotency_key` 查询 Agent state 请求诊断；支持读取批量 manifest 和 `--base-url`，不触发生图计费。
 - `scripts/probe-upstream-image.mjs`：直接探测上游图片接口连通性。默认只检查 DNS、TLS 和 `/models`，必须添加 `--allow-billable` 才会真实调用 `/images/generations`。
 
-生成、编辑和批量脚本的 dry-run 输出会包含 `verification_scope.mode=local_planning_only`，表示只验证了本地请求构造、参数归一化和静态路由规划；它不会读取远端 capabilities，不会验证远端鉴权、渠道容量或 manifest 写入。生成和编辑 dry-run 还会包含 `routing_guidance`，用于在真实计费前检查当前请求应走 Agent JSON、页面 SSE，或在页面流式失败后先诊断再手动选定后续路径。批量 dry-run 还会包含 `guardrails`，提示真实执行要复用同一个 `--ordered-prefix`，固定尺寸任务是否建议加 `--dimension-check`。真实执行输出会包含 `summary`；成功摘要含 `ok=true`、`billable`、`request_id`、`idempotency_key`、`artifact_ids`、`content_urls`、`absolute_content_urls`、`image_dimensions`、`actual_dimensions`、`cached`、`elapsed_ms`、`server_elapsed_ms`、`elapsed_source`、`elapsed_breakdown`、`transport`、`endpoint`、`route_mode`、`image_backend`、`stream_mode`、`streaming_strategy`、`selected_channel_id`、`upstream_host` 和脱敏 `request_headers`。失败摘要含 `transport_error_kind`、`retry_after_ms`、`cooldown_until`、`cooldown_target`、`retryable`、`dimension_check_failed`、`expected_dimensions`、`actual_dimensions`、`agent_diagnostics_checked`、`agent_diagnostics_found`、`agent_diagnostics_unavailable_reason`、`agent_diagnostics_http_status` 和 `next_action`；尺寸门禁失败时还会保留���生成产物的 `artifact_ids`、`content_urls`、`absolute_content_urls` 和 `image_dimensions`，便于人工审查。
+生成、编辑和批量脚本的 dry-run 输出会包含 `verification_scope.mode=local_planning_only`，表示只验证了本地请求构造、参数归一化和静态路由规划；它不会读取远端 capabilities，不会验证远端鉴权、渠道容量或 manifest 写入。生成 dry-run 默认 `routing_guidance.transport=server_orchestrated`，表示真实请求只提交业务意图到服务端编排入口；显式 `--agent`、`--job`、`--page-sse` 才会显示对应诊断路径。批量 dry-run 还会包含 `guardrails`，提示真实执行要复用同一个 `--ordered-prefix`，固定尺寸任务是否建议加 `--dimension-check`。真实执行输出会包含 `summary`；成功摘要含 `ok=true`、`billable`、`request_id`、`idempotency_key`、`artifact_ids`、`content_urls`、`absolute_content_urls`、`image_dimensions`、`actual_dimensions`、`cached`、`elapsed_ms`、`server_elapsed_ms`、`elapsed_source`、`elapsed_breakdown`、`transport`、`endpoint`、`route_mode`、`image_backend`、`stream_mode`、`streaming_strategy`、`selected_channel_id`、`upstream_host` 和脱敏 `request_headers`。失败摘要含 `transport_error_kind`、`retry_after_ms`、`cooldown_until`、`cooldown_target`、`retryable`、`dimension_check_failed`、`expected_dimensions`、`actual_dimensions`、`agent_diagnostics_checked`、`agent_diagnostics_found`、`agent_diagnostics_unavailable_reason`、`agent_diagnostics_http_status` 和 `next_action`；尺寸门禁失败时还会保留已生成产物的 `artifact_ids`、`content_urls`、`absolute_content_urls` 和 `image_dimensions`，便于人工审查。
 所有生成、编辑、批量和探针脚本在 dry-run 或真实请求前都会校验尺寸参数。`gpt-image-2` 支持 `auto` 或任意正整数 `WIDTHxHEIGHT`；默认 OpenAI-compatible 上游的更严格尺寸边界由服务端 profile 或真实上游显式报错。非 `gpt-image-2` 模型只接受 `auto`、`1024x1024`、`1536x1024` 或 `1024x1536`。生成、页面编辑、批量页面 SSE 和上游探针默认请求 `output_format=webp`、`output_compression=100`；普通 Agent edit 不发送输出格式字段，输出格式固定为 Agent 契约。
 
 如果当前上下文位于仓库根目录，管理员侧优先使用顶层命令：
@@ -180,7 +180,7 @@ node "<skill-root>/scripts/convert-image-format.mjs" --format webp --quality 100
 node "<skill-root>/scripts/convert-image-format.mjs" --format png --output ./source.png ./source.webp --overwrite
 ```
 
-生成脚本会对 `max_edge>2048` 的单次文生图默认优先走页面端 `/api/images` SSE；如果 capabilities 未声明 `agent_streaming.page_sse.supported=true`，脚本会显式失败，不会静默降级到 Agent JSON。如果页面流式失败，脚本会返回结构化失败结果，先诊断再决定是否用 `--agent` 或 `--job` 重新执行，不会自动发起第二次请求。单张 generate 也支持 `--responses-model`/`--gpt-model`、`--thinking`、`--prompt-optimization` 和 `--force-web`；这些字段会进入页面 SSE form-data，dry-run 会显示 page SSE 路由，真实请求会发送 `responsesModel`、`thinking`、`promptOptimization` 和 `force_web`。默认 WebP edit 走页面 SSE；显式 `--agent` 才走 Agent multipart 最终 JSON，输出格式固定为 Agent 契约。Responses image_generation edit 属于页面 SSE 路径：可显式传 `--page-sse --image-backend responses-image-generation --streaming-strategy responses-sse`；如果运行时已显式配置 `IMAGE_GENERATION_BACKEND=responses-image-generation` 或兼容别名 `responses`，且 `IMAGE_STREAMING_STRATEGY=responses-sse`，也可以依赖服务端默认值。Docker compose 本身不设置这两个默认值，未配置 `.env.local` 时仍是 `images-api` 和 `auto`。不要为 Responses edit 加 `--agent`。显式传 `--streaming-strategy off` 或 `--stream-mode non_stream` 时，大图 generate 保持 Agent JSON 非流式路径；默认 WebP edit 与非流式策略冲突时脚本前置拒绝，除非显式添加 `--agent` 做 Agent JSON 对照。页面高级 edit 字段与非流式策略冲突时脚本同样前置拒绝。上游流式字段优先读取 `agent_streaming.upstream_sse.request_fields_by_mode`：generate 支持 `--image-backend`、`--stream-mode`、`--streaming-strategy`、`--partial-images`；Agent edit 只支持 `--stream-mode`、`--streaming-strategy`、`--partial-images`。页面 SSE edit 可发送 `image_backend` 和表单字段 `image_streaming_strategy`；CLI 参数是 `--streaming-strategy`，batch JSONL 字段是 `streaming_strategy`。
+生成脚本默认把文生图业务意图提交到服务端编排入口 `/api/agent/image-requests`；服务端内部决定使用 Agent JSON、内部上游 SSE、job polling 或其他可观测路径。脚本不再根据 `max_edge>2048`、公网 HTTPS 或 `streaming_strategy=off` 自行切换默认端点。单张 generate 仍支持 `--responses-model`/`--gpt-model`、`--thinking`、`--prompt-optimization` 和 `--force-web`；这些字段属于页面 SSE form-data，dry-run 会显示 page SSE 路由，真实请求会发送 `responsesModel`、`thinking`、`promptOptimization` 和 `force_web`。`--agent`、`--job`、`--page-sse` 是显式诊断或兼容开关，使用时必须记录原因，并用新的 `Idempotency-Key` 避免混淆业务操作。默认 WebP edit 走页面 SSE；显式 `--agent` 才走 Agent multipart 最终 JSON，输出格式固定为 Agent 契约。Responses image_generation edit 属于页面 SSE 路径：可显式传 `--page-sse --image-backend responses-image-generation --streaming-strategy responses-sse`；如果运行时已显式配置 `IMAGE_GENERATION_BACKEND=responses-image-generation` 或兼容别名 `responses`，且 `IMAGE_STREAMING_STRATEGY=responses-sse`，也可以依赖服务端默认值。Docker compose 本身不设置这两个默认值，未配置 `.env.local` 时仍是 `images-api` 和 `auto`。不要为 Responses edit 加 `--agent`。默认 WebP edit 与非流式策略冲突时脚本前置拒绝，除非显式添加 `--agent` 做 Agent JSON 对照。页面高级 edit 字段与非流式策略冲突时脚本同样前置拒绝。上游流式字段优先读取 `agent_streaming.upstream_sse.request_fields_by_mode`：generate 支持 `--image-backend`、`--stream-mode`、`--streaming-strategy`、`--partial-images`；Agent edit 只支持 `--stream-mode`、`--streaming-strategy`、`--partial-images`。页面 SSE edit 可发送 `image_backend` 和表单字段 `image_streaming_strategy`；CLI 参数是 `--streaming-strategy`，batch JSONL 字段是 `streaming_strategy`。
 
 generate 或页面 SSE 请求包含 `image_backend` 时，`partial_images` 必须先按 `limits.partial_images_by_backend[image_backend]` 校验；capabilities 没有该字段时才退回 `limits.partial_images`。Agent edit 不接受 `image_backend`，其内部上游流式字段按默认 Images API/profile 范围校验；Responses backend edit 需要页面 SSE。不要把 Matsca `limits.partial_images=0..4` 误套到 `responses-image-generation`，Responses backend 当前使用自己的 `1..3` 范围。
 

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

@@ -29,9 +29,9 @@ Agent API 是给自动化客户端使用的机器接口，不是自治 Agent 平
 - `scripts/diagnose-request.mjs`：按页面 `clientRequestId` 只读查询结果反馈和脱敏日志诊断摘要，也可按 Agent `request_id` 或 `idempotency_key` 查询 Agent state 请求诊断，支持 `--base-url` 固定目标服务。
 - `scripts/probe-upstream-image.mjs`：上游图片接口连通性探针。
 
-生成、编辑和批量脚本默认只做 dry-run，不触发真实生图或编辑。dry-run 输出的 `verification_scope.mode=local_planning_only` 表示只完成本地请求构造、参数归一化和静态路由规划；它不会读取远端 capabilities，不会验证远端鉴权、渠道容量或 manifest 写入。必须显式添加 `--allow-billable` 才会按 capabilities 路由规则调用 `/api/agent/images/generate`、`/api/agent/images/edit`、`/api/agent/jobs/images/generate` 或页面端 `/api/images` SSE。
+生成、编辑和批量脚本默认只做 dry-run，不触发真实生图或编辑。dry-run 输出的 `verification_scope.mode=local_planning_only` 表示只完成本地请求构造、参数归一化和静态路由规划；它不会读取远端 capabilities，不会验证远端鉴权、渠道容量或 manifest 写入。必须显式添加 `--allow-billable` 才会调用真实端点。generate 默认提交到 `/api/agent/image-requests` 服务端编排入口；`--agent`、`--job`、`--page-sse` 才会显式改用 `/api/agent/images/generate`、`/api/agent/jobs/images/generate` 或页面端 `/api/images` SSE。
 上游探针默认只检查 DNS、TLS 和 `/models`，必须显式添加 `--allow-billable` 才会调用上游 `/images/generations`。
-脚本支持 `GPT_IMAGE_AGENT_CONTRACT_CHECK=1` 或 `--contract-check` 做只读契约检查，不触发真实生图或编辑。
+脚本支持 `GPT_IMAGE_AGENT_CONTRACT_CHECK=1` 或 `--contract-check` 做只读契约检查，会覆盖服务声明的默认编排入口，不触发真实生图或编辑。
 位于仓库根目录且是首次配置、换机器、服务地址不确定或 token 不确定时，先运行 `npm run first-run`。它只读、非计费、不写 env 文件，默认输出中文摘要，并报告 `service_base_url_source`、`interactive_confirmation_required`、服务可达性、当前进程鉴权、页面 SSE 鉴权和下一步动作。
 自动化消费时使用 `npm run first-run -- --json`。
 Agent 端点鉴权以 capabilities 的 `auth.schemes` 为准。配置 `AGENT_API_TOKEN` 时只接受 Bearer token；只有未配置 `AGENT_API_TOKEN` 且配置了 `APP_PASSWORD` 时，Agent 端点才接受访问码哈希 `GPT_IMAGE_APP_PASSWORD_HASH`。页面端 `/api/images` SSE 另看 `agent_streaming.page_sse.auth`；当其声明 `required=true` 时，form-data 必须包含 `passwordHash`。`GPT_IMAGE_AGENT_TOKEN` 不能替代页面 SSE 表单鉴权。
@@ -69,16 +69,16 @@ npm run env:summary -- --file .env.local --container gpt-image-playground-custom
 - `--timeout-ms`：未显式指定时，脚本先用 `420000ms` 读取 capabilities；真实请求会采用 `420000ms` 与 `capabilities.image_transport.upstream_timeout_ms` 中较大的值。
 - `--prompt-file`：从文本文件读取 prompt。
 - `--idempotency-key`：指定稳定幂等键。
-- `--page-sse`：强制使用页面端 `/api/images` form-data SSE。
-- `--agent`：强制使用 `/api/agent/images/generate` 非流式 JSON。
-- `--job`：强制使用 Agent job polling。
+- `--page-sse`：诊断或兼容开关，强制使用页面端 `/api/images` form-data SSE。
+- `--agent`：诊断或兼容开关，强制使用 `/api/agent/images/generate` 非流式 JSON。
+- `--job`：诊断或兼容开关，强制使用 Agent job polling。
 - `--dry-run`：只输出将要发送的 JSON。
 - `--allow-billable`：允许真实调用生图端点。
 - `--preset`：常用 dry-run/真实调用参数集，当前包括 `1k-smoke-agent`、`4k-agent-nonstream`、`4k-page-sse` 和 `4k-upstream-sse-newapi`。dry-run 会展开真实请求字段，不触发计费。
 
-`max_edge>2048` 的单次文生图默认优先走页面端 `/api/images` SSE；如果显式传 `--streaming-strategy off`，即使是大图也保持 `/api/agent/images/generate` 非流式 JSON 路径，用于诊断对照。
+普通单次文生图默认提交到 `/api/agent/image-requests` 服务端编排入口；脚本不再按 `max_edge>2048`、公网 HTTPS 或 `--streaming-strategy off` 自行选择 page SSE、Agent JSON 或 job endpoint。需要对照时显式使用 `--page-sse`、`--agent` 或 `--job`。
 单张 generate 脚本使用 `--responses-model`/`--gpt-model`、`--thinking`、`--prompt-optimization` 或 `--force-web` 时会选择页面端 `/api/images` SSE。显式 `--agent`、`--job`、`stream_mode=non_stream` 或 `streaming_strategy=off` 与这些页面高级字段同时出现时会在网络请求前失败，避免字段被 Agent JSON 忽略。
-当服务端默认 `IMAGE_STREAMING_STRATEGY=off` 且请求未覆盖 `streaming_strategy` 时，运行时默认策略为 `off`；WebUI 会把 server-default 流式请求切到 `non_stream`，并发批量开关不可用。脚本显式传 `--streaming-strategy off` 时同样保持非流式诊断路径。
+当服务端默认 `IMAGE_STREAMING_STRATEGY=off` 且请求未覆盖 `streaming_strategy` 时，运行时默认策略为 `off`；WebUI 会把 server-default 流式请求切到 `non_stream`，并发批量开关不可用。generate 脚本显式传 `--streaming-strategy off` 时仍提交给服务端编排入口，除非同时显式使用 `--agent`。
 
 编辑脚本参数：
 
@@ -200,7 +200,7 @@ GET /api/agent/capabilities
 - `agent_streaming.upstream_sse.streaming_strategies`：支持 `off`、`auto`、`openai-sse`、`newapi-keepalive-sse`、`responses-sse`、`force-sse`。
 - `agent_streaming.upstream_sse.stream_modes`：支持 `auto`、`stream`、`non_stream`。
 - `agent_streaming.upstream_sse.activation_strategies`：会真正向上游发送 `stream=true` 的策略，当前包含 `auto`、`openai-sse`、`newapi-keepalive-sse`、`responses-sse`、`force-sse`。
-- `agent_streaming.page_sse`：页面端 `/api/images` 的 form-data SSE 能力，不代表 Agent generate/edit 支持流式。即使该字段为 `supported=true`，页面 SSE 仍可能在当前渠道返回 `503`、断流或没有选中渠道；这时应先诊断，再显式切换到 Agent JSON 或 job，不自动回退。
+- `agent_streaming.page_sse`：页面端 `/api/images` 的 form-data SSE 能力，不代表 Agent generate/edit 支持流式。即使该字段为 `supported=true`，页面 SSE 仍可能在当前渠道返回 `503`、断流或没有选中渠道；这时应先诊断，再显式选择诊断路径，不自动回退。
 - `agent_streaming.page_sse.auth`：页面 SSE 的独立表单鉴权。`APP_PASSWORD` 已配置时为 `required=true`、`schemes=["form-password-hash"]`、`form_field="passwordHash"`。
 - `agent_streaming.page_sse.client_request_id`：页面 SSE 的请求 ID 契约。脚本会把 `Idempotency-Key` 写入 form-data `clientRequestId`，最大长度以 `max_length` 为准，当前为 `128`。
 - 页面 SSE 或 Responses 路径失败时，如果 `selected_channel_id`、`upstream_host` 为空，通常表示请求没有真正落到可执行渠道；先诊断结构化错误，再用新的 `Idempotency-Key` 显式改路由。
@@ -209,8 +209,12 @@ GET /api/agent/capabilities
 - `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。
-- `routing_rules.agent_generate_small_smoke`：普通小图单次文生图默认使用 `/api/agent/images/generate`。
-- `routing_rules.page_sse_large_generate`：`max_edge>2048` 的单次文生图推荐优先使用 `/api/images` SSE，失败后先诊断，再显式选择 `/api/agent/images/generate` 或 job 路径；不要把页面 SSE 的失败解释成自动回退到 Agent JSON 成功。
+- `orchestration.supported`：当前为 `true`，表示普通 generate 默认由服务端编排。
+- `orchestration.endpoint`：当前为 `POST /api/agent/image-requests`，客户端只提交业务意图，不选择内部传输路径。
+- `orchestration.transport_selection`：当前为 `server_owned`，表示 Agent 客户端不应按尺寸、远端 HTTPS 或流式参数自行选择 page SSE、Agent JSON 或 job endpoint。
+- `orchestration.result_mode`：当前为 `job_polling`，脚本会轮询 `job.result_url` 并输出标准 `AgentImageResponse`。
+- `routing_rules.agent_generate_small_smoke`：`strength=explicit`，兼容旧客户端和显式 `--agent` 诊断路径；不是普通 generate 默认入口。
+- `routing_rules.page_sse_large_generate`：`strength=explicit`，显式 page SSE 诊断和页面工作台路径的参考规则；普通 generate 默认仍走 `orchestration.endpoint`。
 - `routing_rules.retry_recovery`：终态失败不会用同一 `Idempotency-Key` 重新执行，必须诊断后创建新的业务操作和新的 key。
 - 批量 JSONL 路由控制字段：`page_sse`、`complex_ui`、`long_image`、`resume_or_recover` 必须是 JSON 布尔值，`transport` 目前只接受 `page_sse`；脚本会在 dry-run 阶段拒绝字符串布尔值和未知 transport。
 - `GET /api/runtime-capabilities` 不属于 Agent capabilities。它是页面工作台读取的运行态能力摘要，用于展示流式默认值、图片上游传输配置、渠道健康、渠道队列、并发建议、Responses 后端 enablement 和缺失环境变量，不进入 Agent OpenAPI。
@@ -235,7 +239,7 @@ GET /api/agent/capabilities
 - `agent_jobs.states`：状态机为 `queued`、`running`、`succeeded`、`failed`、`expired`。
 - `agent_request_diagnostics`：Agent state 请求诊断能力。`endpoints.lookup` 支持 `request_id` 或 `idempotency_key` 查询参数；`endpoints.single` 支持按 `request_id` 路径查询；`retention.ttl_seconds` 与 Agent request TTL 一致。
 
-当 `agent_jobs.supported=true` 且 `mode=job_polling` 时，job 路径仍然可用，但普通大图单次文生图的默认路径已经切到页面端 `/api/images` SSE。高分辨率 edit 和复杂 UI 批量生产默认优先按 `routing_rules` 使用页面端 `/api/images` SSE；页面流式有问题时，先诊断再显式选择 Agent JSON、Agent edit 或 job 路径。当前 job polling 是同一服务实例内的后台任务，结果和错误写入 Agent 状态后端；它不是跨实例持久队列。大图页面流式失败后不自动回退，先诊断再显式选新路径。
+普通 generate 默认使用 `orchestration.endpoint`，不是客户端直接选择 job endpoint。`agent_jobs.supported=true` 且 `mode=job_polling` 表示服务端编排和显式 `--job` 诊断路径可使用同一套 job 状态机。高分辨率 edit 和复杂 UI 批量生产仍按页面/批量规则使用页面端 `/api/images` SSE；页面流式有问题时，先诊断再显式选择 Agent JSON、Agent edit 或 job 路径。当前 job polling 是同一服务实例内的后台任务，结果和错误写入 Agent 状态后端；它不是跨实例持久队列。
 
 上游请求头策略由服务端统一执行。默认 `User-Agent` 是 `gpt-image-playground/<package-version>`；可用 `OPENAI_UPSTREAM_USER_AGENT` 或 `UPSTREAM_USER_AGENT` 覆盖全局 UA，也可用 `OPENAI_CHANNEL_N_USER_AGENT` 和 `OPENAI_CHANNEL_N_UPSTREAM_HEADERS_JSON` 覆盖单渠道安全 header。`Authorization`、`Accept`、`Content-Type`、`Content-Length` 和 `Host` 等协议头不可由 extra headers 覆盖；固定业务头和鉴权头始终由调用路径设置。
 
@@ -248,7 +252,7 @@ Idempotency-Key: <stable-key>
 Content-Type: application/json
 ```
 
-请求体与 `POST /api/agent/images/generate` 相同。创建成功后返回：
+请求体与 `POST /api/agent/image-requests` / `POST /api/agent/images/generate` 相同。创建成功后返回：
 
 ```json
 {
@@ -287,6 +291,17 @@ GET /api/agent/jobs/{id}/result
 
 ## 生成图片
 
+默认服务端编排入口：
+
+```http
+POST /api/agent/image-requests
+Authorization: Bearer <token>
+Idempotency-Key: <stable-key>
+Content-Type: application/json
+```
+
+该入口返回 `AgentJobStatusResponse`，脚本会继续轮询 `job.result_url` 并输出标准 `AgentImageResponse`。显式诊断或兼容旧流程时才直连 Agent JSON：
+
 ```http
 POST /api/agent/images/generate
 Authorization: Bearer <token>
@@ -315,12 +330,12 @@ Content-Type: application/json
 }
 ```
 
-Agent 生成端点对外始终返回最终 JSON，不会对客户端返回 SSE。不要向该端点发送 `stream: true`。
+Agent JSON 生成端点对外始终返回最终 JSON，不会对客户端返回 SSE。普通客户端默认不直接调用它，而是使用 `/api/agent/image-requests`。不要向该端点发送 `stream: true`。
 
 - 页面 SSE 使用独立的 `POST /api/images` form-data 路径。
 - 若 capabilities 中 `agent_streaming.upstream_sse.supported=true`，generate 可通过 `request_fields_by_mode.generate` 声明的字段控制服务端内部上游 SSE 消费。Agent JSON 的 `image_backend=responses-image-generation` 当前只支持 generate；Responses backend edit 使用页面端 `/api/images` form-data SSE。
 - 不要向 Agent 生成端点发送 `responsesModel`、`gptModel`、`gpt_model`、`thinking`、`promptOptimization`、`prompt_optimization`、`force_web` 或 `forceWeb`。这些是页面 form-data 高级字段；单张 generate 脚本会在需要时走 `/api/images` SSE。
-- Agent 生成端点最终响应仍是 `AgentImageResponse`。
+- `/api/agent/image-requests` 的最终轮询结果和 Agent JSON 生成端点最终响应都使用 `AgentImageResponse`。
 - `stream_mode=stream` 强制流式并直接暴露失败。
 - `stream_mode=non_stream` 直接非流式。
 - `stream_mode=auto` 允许显式可观测回退。
@@ -354,9 +369,9 @@ Agent 生成端点对外始终返回最终 JSON，不会对客户端返回 SSE
     "server_elapsed_ms": 64000
   },
   "execution": {
-    "transport": "agent_json",
-    "endpoint": "/api/agent/images/generate",
-    "route_mode": "agent",
+    "transport": "agent_job_polling",
+    "endpoint": "/api/agent/image-requests",
+    "route_mode": "job",
     "operation": "generate",
     "image_backend": "images-api",
     "stream_mode": "non_stream",
@@ -626,8 +641,8 @@ node "<skill-root>/scripts/diagnose-request.mjs" --base-url https://your-space.h
 
 | 前端能力或端点 | 归属契约 | 进入 Agent OpenAPI | 自动化口径 |
 | --- | --- | --- | --- |
-| `POST /api/agent/images/generate`、`POST /api/agent/images/edit`、Agent jobs、Agent artifacts | Agent JSON API | 是 | 通过 skill 脚本和 Agent 鉴权调用。 |
-| `POST /api/images` | 页面 form-data SSE API | 否 | 仅在大图、复杂 UI 批量、页面高级字段或路由规则要求时由 skill 显式选择。 |
+| `POST /api/agent/image-requests`、`POST /api/agent/images/generate`、`POST /api/agent/images/edit`、Agent jobs、Agent artifacts | Agent API | 是 | 普通 generate 默认用 image-requests；其他 Agent 端点通过 skill 脚本和 Agent 鉴权调用。 |
+| `POST /api/images` | 页面 form-data SSE API | 否 | 仅在默认 WebP edit、复杂 UI 批量、页面高级字段或显式 `--page-sse` 诊断时由 skill 选择。 |
 | `GET /api/runtime-capabilities` | 页面运行态能力 API | 否 | 页面展示运行态默认值、图片上游传输配置、渠道健康和后端 enablement；不是 Agent capabilities。 |
 | `PUT/DELETE /api/feedback` | 页面结果反馈写入和清理 API | 否 | 页面写入最近生成的结果反馈；删除历史时清理对应反馈。 |
 | `POST /api/agent/page-requests/feedback` | Agent 结果反馈批量只读 API | 是 | 按多个页面 `clientRequestId` 批量查询最新反馈。 |

skills/gpt-image-playground-agent/scripts/generate-image.mjs

@@ -45,6 +45,7 @@ const DEFAULT_OUTPUT_FORMAT = 'webp';
 const DEFAULT_OUTPUT_COMPRESSION = 100;
 const DEFAULT_PAGE_SSE_CLIENT_REQUEST_ID_MAX_LENGTH = 128;
 const PAGE_SSE_ENDPOINT = '/api/images';
+const SERVER_ORCHESTRATED_TRANSPORT = 'server_orchestrated';
 const GENERATE_PRESETS = {
     '1k-smoke-agent': ['--agent', '--size', '1024x1024', '--quality', 'low', '--stream-mode', 'non_stream'],
     '4k-agent-nonstream': ['--agent', '--size', '3840x2160', '--quality', 'high', '--stream-mode', 'non_stream'],
@@ -182,8 +183,22 @@ try {
 }
 
 try {
-    if (shouldUseJobPolling(capabilities, options.routeMode)) {
-        await runGenerateJob();
+    if (shouldUseServerOrchestration(capabilities, requestBody, options.routeMode)) {
+        await runGenerateJob({
+            createEndpoint: AGENT_ENDPOINTS.create_image_request,
+            routing: {
+                transport: SERVER_ORCHESTRATED_TRANSPORT,
+                endpoint: AGENT_ENDPOINTS.create_image_request
+            }
+        });
+    } else if (shouldUseJobPolling(capabilities, options.routeMode)) {
+        await runGenerateJob({
+            createEndpoint: AGENT_ENDPOINTS.create_generate_job,
+            routing: {
+                transport: 'agent_job_polling',
+                endpoint: AGENT_ENDPOINTS.create_generate_job
+            }
+        });
     } else if (shouldUsePageSse(capabilities, requestBody, options.routeMode)) {
         try {
             const result = await runPageSseRequest();
@@ -497,6 +512,9 @@ function buildDryRunVerificationScope() {
 }
 
 function dryRunEndpoint(body, routeMode) {
+    if (routeMode === 'auto' && shouldPreferServerOrchestration(body)) {
+        return `${baseUrl}${AGENT_ENDPOINTS.create_image_request}`;
+    }
     if (routeMode === 'job') return `${baseUrl}${AGENT_ENDPOINTS.create_generate_job}`;
     if (routeMode === 'agent') return `${baseUrl}${AGENT_ENDPOINTS.generate}`;
     if (routeMode === 'page_sse') return `${baseUrl}${PAGE_SSE_ENDPOINT}`;
@@ -506,6 +524,15 @@ function dryRunEndpoint(body, routeMode) {
 }
 
 function buildGenerateRoutingGuidance(body, routeMode) {
+    if (routeMode === 'auto' && shouldPreferServerOrchestration(body)) {
+        return {
+            recommended_endpoint: AGENT_ENDPOINTS.create_image_request,
+            transport: SERVER_ORCHESTRATED_TRANSPORT,
+            strength: 'recommended',
+            result_mode: 'job_polling',
+            reason: 'Agent 客户端只提交生成意图；服务端负责选择内部执行路径和轮询结果。'
+        };
+    }
     if (routeMode === 'job') {
         return {
             recommended_endpoint: AGENT_ENDPOINTS.create_generate_job,
@@ -1147,12 +1174,14 @@ function buildPageSseDiagnostics(state) {
     };
 }
 
-async function runGenerateJob() {
+async function runGenerateJob(options = {}) {
+    const createEndpoint = options.createEndpoint || AGENT_ENDPOINTS.create_generate_job;
+    const routing = options.routing || { transport: 'agent_job_polling', endpoint: createEndpoint };
     let lastResult;
     let lastRetryAfter = null;
 
     for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
-        const { response, result } = await fetchJson(`${baseUrl}${AGENT_ENDPOINTS.create_generate_job}`, {
+        const { response, result } = await fetchJson(`${baseUrl}${createEndpoint}`, {
             method: 'POST',
             headers: {
                 'Content-Type': 'application/json',
@@ -1167,10 +1196,7 @@ async function runGenerateJob() {
             const jobResult = await pollJobResult(result?.job);
             console.log(
                 JSON.stringify(
-                    buildSuccessOutput(enrichImageUrls(jobResult), {
-                        transport: 'agent_job_polling',
-                        endpoint: AGENT_ENDPOINTS.create_generate_job
-                    }, completeScriptTiming(scriptTiming)),
+                    buildSuccessOutput(enrichImageUrls(jobResult), routing, completeScriptTiming(scriptTiming)),
                     null,
                     2
                 )
@@ -1189,7 +1215,7 @@ async function runGenerateJob() {
         JSON.stringify(
             buildFailureOutput(
                 { ...lastResult, retry_after: lastRetryAfter },
-                { transport: 'agent_job_polling', endpoint: AGENT_ENDPOINTS.create_generate_job }
+                routing
             ),
             null,
             2
@@ -1240,7 +1266,23 @@ async function pollJobResult(job) {
 
 async function runContractCheck(capabilitiesValue) {
     const checks = [];
-    const { response, result } = await fetchJson(`${baseUrl}${AGENT_ENDPOINTS.generate}`, {
+    checks.push(await checkContractEndpoint(AGENT_ENDPOINTS.generate));
+
+    if (shouldRequireServerOrchestrationContract()) {
+        checks.push(await checkContractEndpoint(readRequiredOrchestrationEndpoint(capabilitiesValue)));
+    } else if (supportsServerOrchestration(capabilitiesValue)) {
+        checks.push(await checkContractEndpoint(readOrchestrationEndpoint(capabilitiesValue)));
+    }
+
+    if (supportsJobPolling(capabilitiesValue)) {
+        checks.push(await checkContractEndpoint(AGENT_ENDPOINTS.create_generate_job));
+    }
+
+    console.log(JSON.stringify({ ok: true, billable: false, checks }, null, 2));
+}
+
+async function checkContractEndpoint(endpoint) {
+    const { response, result } = await fetchJson(`${baseUrl}${endpoint}`, {
         method: 'POST',
         headers: {
             'Content-Type': 'application/json',
@@ -1249,41 +1291,61 @@ async function runContractCheck(capabilitiesValue) {
         body: JSON.stringify(requestBody),
         timeoutMs
     });
-    if (response.status === 400 && result?.error?.code === 'idempotency_key_required') {
-        checks.push({ endpoint: AGENT_ENDPOINTS.generate, status: response.status, error_code: result.error.code });
-    } else {
-        console.error(JSON.stringify({ ok: false, billable: false, status: response.status, result }, null, 2));
+    if (response.status !== 400 || result?.error?.code !== 'idempotency_key_required') {
+        console.error(JSON.stringify({ ok: false, billable: false, endpoint, status: response.status, result }, null, 2));
         process.exit(1);
     }
+    return { endpoint, status: response.status, error_code: result.error.code };
+}
 
-    if (supportsJobPolling(capabilitiesValue)) {
-        const jobCheck = await fetchJson(`${baseUrl}${AGENT_ENDPOINTS.create_generate_job}`, {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-                ...authHeaders()
-            },
-            body: JSON.stringify(requestBody),
-            timeoutMs
-        });
-        if (jobCheck.response.status !== 400 || jobCheck.result?.error?.code !== 'idempotency_key_required') {
-            console.error(
-                JSON.stringify(
-                    { ok: false, billable: false, status: jobCheck.response.status, result: jobCheck.result },
-                    null,
-                    2
-                )
-            );
-            process.exit(1);
-        }
-        checks.push({
-            endpoint: AGENT_ENDPOINTS.create_generate_job,
-            status: jobCheck.response.status,
-            error_code: jobCheck.result.error.code
-        });
+function readOrchestrationEndpoint(capabilitiesValue) {
+    const endpoint = capabilitiesValue?.orchestration?.endpoint;
+    if (typeof endpoint !== 'string' || !endpoint.startsWith('/')) {
+        console.error(
+            JSON.stringify(
+                {
+                    ok: false,
+                    billable: false,
+                    error: {
+                        code: 'invalid_orchestration_endpoint',
+                        message: 'capabilities.orchestration.endpoint 必须是以 / 开头的路径。'
+                    },
+                    orchestration: capabilitiesValue?.orchestration ?? null
+                },
+                null,
+                2
+            )
+        );
+        process.exit(1);
     }
+    return endpoint;
+}
 
-    console.log(JSON.stringify({ ok: true, billable: false, checks }, null, 2));
+function shouldRequireServerOrchestrationContract() {
+    return options.routeMode === 'auto' && shouldPreferServerOrchestration(requestBody);
+}
+
+function readRequiredOrchestrationEndpoint(capabilitiesValue) {
+    if (!supportsServerOrchestration(capabilitiesValue)) {
+        console.error(
+            JSON.stringify(
+                {
+                    ok: false,
+                    billable: false,
+                    error: {
+                        code: 'orchestration_required',
+                        message:
+                            '默认 generate 需要 capabilities.orchestration.supported=true 且 transport_selection=server_owned。'
+                    },
+                    orchestration: capabilitiesValue?.orchestration ?? null
+                },
+                null,
+                2
+            )
+        );
+        process.exit(1);
+    }
+    return readOrchestrationEndpoint(capabilitiesValue);
 }
 
 async function fetchJson(url, init) {
@@ -1349,10 +1411,25 @@ function supportsJobPolling(capabilitiesValue) {
     );
 }
 
+function supportsServerOrchestration(capabilitiesValue) {
+    return Boolean(
+        capabilitiesValue?.orchestration?.supported === true &&
+            capabilitiesValue.orchestration.transport_selection === 'server_owned'
+    );
+}
+
 function supportsPageSse(capabilitiesValue) {
     return Boolean(capabilitiesValue?.agent_streaming?.page_sse?.supported === true);
 }
 
+function shouldUseServerOrchestration(capabilitiesValue, request, routeMode) {
+    if (routeMode !== 'auto' || !shouldPreferServerOrchestration(request)) return false;
+    if (!supportsServerOrchestration(capabilitiesValue)) {
+        throw new Error('服务 capabilities 未声明 orchestration.supported=true，不能调用统一生成入口。');
+    }
+    return true;
+}
+
 function shouldUseJobPolling(capabilitiesValue, routeMode) {
     if (routeMode !== 'job') return false;
     if (!supportsJobPolling(capabilitiesValue)) {
@@ -1380,6 +1457,10 @@ function isLargeGenerate(request) {
     return readMaxImageEdge(request.size) > 2048;
 }
 
+function shouldPreferServerOrchestration(request) {
+    return !hasPageOnlyGenerateOptions(request);
+}
+
 function isPageSseAllowed(request) {
     const streamingStrategy = request.streaming_strategy ?? request.streamingStrategy;
     const streamMode = request.stream_mode ?? request.streamMode;

skills/gpt-image-playground-agent/scripts/lib/agent-api-paths.mjs

@@ -1,6 +1,7 @@
 export const AGENT_ENDPOINTS = Object.freeze({
     capabilities: '/api/agent/capabilities',
     openapi: '/api/agent/openapi.json',
+    create_image_request: '/api/agent/image-requests',
     generate: '/api/agent/images/generate',
     edit: '/api/agent/images/edit',
     create_generate_job: '/api/agent/jobs/images/generate',

skills/gpt-image-playground-agent/scripts/lib/script-summary.mjs

@@ -156,6 +156,7 @@ function readNonNegativeNumber(value) {
 function readRouteMode(routing) {
   if (typeof routing?.route_mode === 'string' && routing.route_mode) return routing.route_mode;
   if (routing?.transport === 'page_sse') return 'page_sse';
+  if (routing?.transport === 'server_orchestrated') return 'orchestrated';
   if (routing?.transport === 'agent_job_polling') return 'job';
   if (routing?.transport === 'agent_json') return 'agent';
   return undefined;

src/app/api/agent/agent-routes.test.ts

@@ -1113,6 +1113,40 @@ describe('Agent route integration', () => {
         }
     });
 
+    it('creates a server-orchestrated image request job and records the orchestration endpoint', async () => {
+        const { createImageRequest, getJobResult } = await loadAgentRoutes();
+        let upstreamCalls = 0;
+        const upstream = await startImageUpstream(() => {
+            upstreamCalls += 1;
+            return { data: [{ b64_json: PNG_BASE64 }] };
+        });
+        process.env.OPENAI_API_KEY = 'test-key';
+        process.env.OPENAI_API_BASE_URL = upstream.baseUrl;
+
+        try {
+            const created = await createImageRequest(
+                agentImageRequest('route-orchestrated-key', { prompt: 'server orchestrated generate' })
+            );
+            assert.equal(created.status, 202);
+            const createdBody = await created.json();
+            assert.equal(createdBody.job.state, 'running');
+            assert.equal(createdBody.job.idempotency_key, 'route-orchestrated-key');
+
+            const result = await waitForJobResult(getJobResult, createdBody.job.id);
+            assert.equal(result.status, 200);
+            const resultBody = await result.json();
+            assert.equal(resultBody.request_id, createdBody.job.id);
+            assert.equal(resultBody.cached, false);
+            assert.equal(resultBody.images.length, 1);
+            assert.equal(resultBody.execution.transport, 'agent_job_polling');
+            assert.equal(resultBody.execution.endpoint, '/api/agent/image-requests');
+            assert.equal(resultBody.execution.route_mode, 'job');
+            assert.equal(upstreamCalls, 1);
+        } finally {
+            await upstream.close();
+        }
+    });
+
     it('does not consume generate job idempotency keys for local profile validation failures', async () => {
         const { createGenerateJob, getJobResult } = await loadAgentRoutes();
         let upstreamCalls = 0;
@@ -2320,7 +2354,7 @@ describe('Agent route integration', () => {
             { params: Promise.resolve({ id: artifactId }) }
         );
         assert.equal(allowed.status, 200);
-        assert.equal(allowed.headers.get('content-type'), 'image/webp');
+        assert.equal(allowed.headers.get('content-type'), 'image/png');
         assert.ok((await allowed.arrayBuffer()).byteLength > 0);
 
         const metadata = await getArtifact(
@@ -2332,6 +2366,8 @@ describe('Agent route integration', () => {
         assert.equal(metadata.status, 200);
         const metadataBody = await metadata.json();
         assert.equal(metadataBody.artifact.id, artifactId);
+        assert.equal(metadataBody.artifact.output_format, 'png');
+        assert.equal(metadataBody.artifact.mime_type, 'image/png');
         assert.equal('filepath' in metadataBody.artifact, false);
 
         const deleted = await deleteArtifact(
@@ -3012,6 +3048,7 @@ async function loadAgentRoutes() {
     const artifactRoute = await import('./artifacts/[id]/route');
     const artifactContentRoute = await import('./artifacts/[id]/content/route');
     const capabilitiesRoute = await import('./capabilities/route');
+    const imageRequestRoute = await import('./image-requests/route');
     const createGenerateJobRoute = await import('./jobs/images/generate/route');
     const jobRoute = await import('./jobs/[id]/route');
     const jobResultRoute = await import('./jobs/[id]/result/route');
@@ -3026,6 +3063,7 @@ async function loadAgentRoutes() {
         getCapabilities: () => capabilitiesRoute.GET(),
         generateImage: (request: Request) => generateRoute.POST(asNextRequest(request)),
         editImage: (request: Request) => editRoute.POST(asNextRequest(request)),
+        createImageRequest: (request: Request) => imageRequestRoute.POST(asNextRequest(request)),
         createGenerateJob: (request: Request) => createGenerateJobRoute.POST(asNextRequest(request)),
         getJob: (request: Request, context: AgentRouteContext) => jobRoute.GET(asNextRequest(request), context),
         getJobResult: (request: Request, context: AgentRouteContext) =>
@@ -3090,6 +3128,24 @@ function agentJobJsonRequest(
     });
 }
 
+function agentImageRequest(
+    idempotencyKey: string,
+    body: Record<string, unknown>,
+    headers: Record<string, string> = {}
+) {
+    const requestBody =
+        'stream_mode' in body || 'streaming_strategy' in body ? body : { ...body, stream_mode: 'non_stream' };
+    return new Request('http://localhost/api/agent/image-requests', {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            'Idempotency-Key': idempotencyKey,
+            ...headers
+        },
+        body: JSON.stringify(requestBody)
+    });
+}
+
 type AgentEditRequestFields = {
     image_0?: Buffer;
     mask?: Buffer;

src/app/api/agent/image-requests/route.ts

@@ -0,0 +1,9 @@
+import { createAgentGenerateJobResponse } from '@/lib/agent-generate-job-route';
+import { AGENT_ENDPOINTS } from '@/lib/agent-api-paths.mjs';
+import type { NextRequest } from 'next/server';
+
+export async function POST(request: NextRequest) {
+    return createAgentGenerateJobResponse(request, {
+        transportEndpoint: AGENT_ENDPOINTS.create_image_request
+    });
+}

src/app/api/agent/jobs/images/generate/route.ts

@@ -1,96 +1,9 @@
-import { buildAgentJobStatusResponse, startAgentGenerateJob } from '@/lib/agent-job-service';
-import {
-    buildGenerateRequestHash,
-    parseAgentGenerateRequest,
-    prepareAgentGenerate,
-    resolveExistingAgentRequest,
-    readIdempotencyKey
-} from '@/lib/agent-image-service';
-import { readAgentLeaseMs, readAgentRequestTtlSeconds } from '@/lib/agent-api-contracts';
-import { AgentApiError, agentErrorResponse, normalizeAgentError } from '@/lib/api-error-response';
-import { assertAgentAuthorized } from '@/lib/agent-auth';
-import { ensureAgentStateStoreReady } from '@/lib/agent-state-runtime';
-import { createRequestId, type BeginAgentRequestResult } from '@/lib/agent-state-store';
-import { NextRequest, NextResponse } from 'next/server';
+import { createAgentGenerateJobResponse } from '@/lib/agent-generate-job-route';
+import { AGENT_ENDPOINTS } from '@/lib/agent-api-paths.mjs';
+import type { NextRequest } from 'next/server';
 
 export async function POST(request: NextRequest) {
-    let requestId = createRequestId();
-    try {
-        assertAgentAuthorized(request.headers);
-        const imageRequest = await parseAgentGenerateRequest(request);
-        const idempotencyKey = readIdempotencyKey(request.headers);
-        const requestHash = buildGenerateRequestHash(imageRequest);
-        const store = await ensureAgentStateStoreReady();
-        const existingResponse = jobBeginResultResponse(
-            resolveExistingAgentRequest(
-                await store.getRequestByIdempotencyKey(idempotencyKey),
-                requestHash
-            )
-        );
-        if (existingResponse) return existingResponse;
-        const preparation = prepareAgentGenerate(imageRequest, request.headers);
-        const leaseMs = readAgentLeaseMs(process.env);
-        const beginResult = await store.beginRequest({
-            idempotencyKey,
-            requestHash,
-            mode: 'generate',
-            requestJson: imageRequest,
-            leaseMs,
-            ttlSeconds: readAgentRequestTtlSeconds(process.env)
-        });
-
-        const storedResponse = jobBeginResultResponse(beginResult);
-        if (storedResponse) return storedResponse;
-
-        requestId = beginResult.record.requestId;
-        startAgentGenerateJob({
-            store,
-            request: imageRequest,
-            headers: new Headers(request.headers),
-            requestId,
-            idempotencyKey,
-            leaseMs,
-            preparation
-        });
-        return runningJobResponse(beginResult.record, 5, false);
-    } catch (error) {
-        return agentErrorResponse(normalizeAgentError(error), requestId);
-    }
-}
-
-function createIdempotencyConflictError(): AgentApiError {
-    return new AgentApiError({
-        code: 'idempotency_conflict',
-        message: 'Idempotency-Key 已被不同请求正文使用。',
-        status: 409,
-        retryable: false
-    });
-}
-
-function jobBeginResultResponse(beginResult: BeginAgentRequestResult | undefined): NextResponse | undefined {
-    if (!beginResult || beginResult.type === 'acquired') return undefined;
-    if (beginResult.type === 'conflict') {
-        throw createIdempotencyConflictError();
-    }
-    if (beginResult.type === 'replay' || beginResult.type === 'failed') {
-        return NextResponse.json(buildAgentJobStatusResponse(beginResult.record), {
-            status: 202,
-            headers: {
-                'X-Idempotent-Replay': 'true',
-                'X-Request-Id': beginResult.record.requestId
-            }
-        });
-    }
-    return runningJobResponse(beginResult.record, beginResult.retryAfterSeconds, true);
-}
-
-function runningJobResponse(record: Parameters<typeof buildAgentJobStatusResponse>[0], retryAfterSeconds: number, replay: boolean) {
-    return NextResponse.json(buildAgentJobStatusResponse(record, { retryAfterSeconds }), {
-        status: 202,
-        headers: {
-            'Retry-After': String(retryAfterSeconds),
-            'X-Request-Id': record.requestId,
-            ...(replay ? { 'X-Idempotent-Replay': 'true' } : {})
-        }
+    return createAgentGenerateJobResponse(request, {
+        transportEndpoint: AGENT_ENDPOINTS.create_generate_job
     });
 }

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

@@ -1,6 +1,6 @@
 import { NextResponse } from 'next/server';
 
-const deployMarker = {"schema_version":1,"local_sha":"a623efcc28ea071e4a51a2753173829a0ee01002","created_at":"2026-06-21T06:16:41.993Z","deploy_id":"83a9c54d-c4df-43fc-8045-97fe4feadb16"} as const;
+const deployMarker = {"schema_version":1,"local_sha":"3203c24f5434c569bbfec2fb425430d3e45fcbc3","created_at":"2026-06-23T13:55:49.360Z","deploy_id":"dea5a9f7-24bf-4297-a091-f730901c220a"} as const;
 
 export const dynamic = 'force-dynamic';
 

src/lib/agent-api-contracts.test.ts

@@ -439,7 +439,7 @@ describe('buildAgentCapabilities', () => {
         });
         assert.equal(
             capabilities.agent_streaming.page_sse.agent_usage,
-            'recommended_for_high_resolution_generate_edit_and_complex_batch'
+            'explicit_for_generate_recommended_for_high_resolution_edit_and_complex_batch'
         );
         assert.deepEqual(capabilities.upstream_request_headers.default, {
             user_agent_effective: 'gpt-image-playground/2.1.0',
@@ -480,16 +480,18 @@ describe('buildAgentCapabilities', () => {
             resume_or_recover: true
         });
         assert.equal(capabilities.routing_rules.agent_generate_small_smoke.endpoint, AGENT_ENDPOINTS.generate);
+        assert.equal(capabilities.routing_rules.agent_generate_small_smoke.strength, 'explicit');
         assert.deepEqual(capabilities.routing_rules.agent_generate_small_smoke.action, {
             endpoint: AGENT_ENDPOINTS.generate,
             transport: 'agent_json',
-            strength: 'default',
+            strength: 'explicit',
             requires_new_idempotency_key_on_retry: true,
             no_automatic_fallback: true
         });
         assert.equal(capabilities.routing_rules.page_sse_large_generate.endpoint, '/api/images');
         assert.equal(capabilities.routing_rules.page_sse_large_generate.transport, 'page_sse');
-        assert.equal(capabilities.routing_rules.page_sse_large_generate.strength, 'recommended');
+        assert.equal(capabilities.routing_rules.page_sse_large_generate.strength, 'explicit');
+        assert.equal(capabilities.routing_rules.page_sse_large_generate.action.strength, 'explicit');
         assert.deepEqual(capabilities.routing_rules.page_sse_large_generate.conditions, {
             operation: 'generate',
             max_edge: { operator: 'gt', value: 2048 },
@@ -497,6 +499,17 @@ describe('buildAgentCapabilities', () => {
         });
         assert.equal(capabilities.routing_rules.retry_recovery.reuse_failed_idempotency_key, false);
         assert.match(capabilities.routing_rules.retry_recovery.new_attempt_guidance, /new Idempotency-Key/);
+        assert.equal(capabilities.orchestration.supported, true);
+        assert.equal(capabilities.orchestration.policy, 'server_orchestrated_generate_v1');
+        assert.equal(capabilities.orchestration.endpoint, AGENT_ENDPOINTS.create_image_request);
+        assert.equal(capabilities.orchestration.client_contract, 'intent_only');
+        assert.equal(capabilities.orchestration.transport_selection, 'server_owned');
+        assert.equal(capabilities.orchestration.result_mode, 'job_polling');
+        assert.deepEqual(capabilities.orchestration.diagnostics, {
+            job_result: AGENT_ENDPOINTS.job_result,
+            request_lookup: AGENT_ENDPOINTS.agent_request_diagnostics_lookup
+        });
+        assert.match(capabilities.orchestration.current_guidance, /只提交生成意图/);
         assert.deepEqual(capabilities.supported.image_backends, ['images-api', 'responses-image-generation']);
         assert.deepEqual(capabilities.supported.enabled_image_backends, ['images-api']);
         assert.deepEqual(capabilities.supported.image_backend_requirements['images-api'], {
@@ -521,6 +534,7 @@ describe('buildAgentCapabilities', () => {
         ]);
         assert.deepEqual(capabilities.supported.stream_modes, ['auto', 'stream', 'non_stream']);
         assert.equal(capabilities.endpoints.create_generate_job, AGENT_ENDPOINTS.create_generate_job);
+        assert.equal(capabilities.endpoints.create_image_request, AGENT_ENDPOINTS.create_image_request);
         assert.equal(capabilities.endpoints.page_request_feedback_batch, AGENT_ENDPOINTS.page_request_feedback_batch);
         assert.equal(capabilities.endpoints.page_request_feedback, AGENT_ENDPOINTS.page_request_feedback);
         assert.equal(
@@ -542,8 +556,7 @@ describe('buildAgentCapabilities', () => {
         ]);
         assert.equal(capabilities.agent_jobs.endpoints.create_generate_job, AGENT_JOB_ENDPOINTS.create_generate_job);
         assert.deepEqual(capabilities.agent_jobs.states, ['queued', 'running', 'succeeded', 'failed', 'expired']);
-        assert.match(capabilities.agent_jobs.current_guidance, /\/api\/images SSE/);
-        assert.match(capabilities.agent_jobs.current_guidance, /不自动回退/);
+        assert.match(capabilities.agent_jobs.current_guidance, /orchestration\.endpoint/);
         assert.match(capabilities.agent_jobs.current_guidance, /job/);
     });
 
@@ -767,6 +780,7 @@ describe('buildAgentCapabilities', () => {
         assert.equal(document.openapi, '3.1.0');
         assert.deepEqual(document.servers, [{ url: 'https://images.example.test' }]);
         assert.ok(AGENT_ENDPOINTS.openapi in document.paths);
+        assert.ok(AGENT_ENDPOINTS.create_image_request in document.paths);
         assert.ok(AGENT_ENDPOINTS.generate in document.paths);
         assert.ok(AGENT_ENDPOINTS.create_generate_job in document.paths);
         assert.ok(AGENT_ENDPOINTS.job in document.paths);
@@ -800,6 +814,7 @@ describe('buildAgentCapabilities', () => {
         assert.ok('AgentPageRequestDiagnosticsCapabilities' in document.components.schemas);
         assert.ok('AppLogRetentionMetadata' in document.components.schemas);
         assert.ok('AgentJobCapabilities' in document.components.schemas);
+        assert.ok('AgentOrchestrationCapabilities' in document.components.schemas);
         assert.ok('AgentRoutingRules' in document.components.schemas);
         assert.ok('AgentRoutingRule' in document.components.schemas);
         assert.ok('AgentErrorDiagnostics' in document.components.schemas);
@@ -814,6 +829,8 @@ describe('buildAgentCapabilities', () => {
         assert.ok(document.paths[AGENT_ENDPOINTS.generate].post.responses['403']);
         assert.ok(document.paths[AGENT_ENDPOINTS.generate].post.responses['429']);
         assert.ok(document.paths[AGENT_ENDPOINTS.generate].post.responses['422']);
+        assert.ok(document.paths[AGENT_ENDPOINTS.create_image_request].post.responses['202']);
+        assert.ok(document.paths[AGENT_ENDPOINTS.create_image_request].post.responses['409']);
         assert.ok(document.paths[AGENT_ENDPOINTS.create_generate_job].post.responses['202']);
         assert.ok(document.paths[AGENT_ENDPOINTS.job_result].get.responses['200']);
         assert.ok(document.paths[AGENT_ENDPOINTS.job_result].get.responses['409']);

src/lib/agent-api-contracts.ts

@@ -102,7 +102,8 @@ export type AgentBackground = (typeof AGENT_BACKGROUNDS)[number];
 export type AgentModeration = (typeof AGENT_MODERATIONS)[number];
 export type AgentJobState = (typeof AGENT_JOB_STATES)[number];
 export type AgentRoutingTransport = 'agent_json' | 'agent_job_polling' | 'page_sse';
-export type AgentRoutingStrength = 'default' | 'recommended';
+export type AgentRoutingStrength = 'default' | 'recommended' | 'explicit';
+export type AgentOrchestrationPolicy = 'server_orchestrated_generate_v1';
 export type ImageBackendRuntimeRequirement = {
     supported: true;
     enabled: boolean;
@@ -314,9 +315,23 @@ export type AgentCapabilities = {
                 source_header: 'Idempotency-Key';
                 max_length: number;
             };
-            agent_usage: 'recommended_for_high_resolution_generate_edit_and_complex_batch';
+            agent_usage: 'explicit_for_generate_recommended_for_high_resolution_edit_and_complex_batch';
         };
     };
+    orchestration: {
+        supported: true;
+        policy: AgentOrchestrationPolicy;
+        endpoint: string;
+        client_contract: 'intent_only';
+        transport_selection: 'server_owned';
+        result_mode: 'job_polling';
+        hidden_controls: readonly string[];
+        diagnostics: {
+            job_result: string;
+            request_lookup: string;
+        };
+        current_guidance: string;
+    };
     routing_rules: {
         high_resolution_edit: AgentRoutingRule;
         complex_ui_batch: AgentRoutingRule;
@@ -977,9 +992,24 @@ export function buildAgentCapabilities(env: Record<string, string | undefined>):
                     source_header: 'Idempotency-Key',
                     max_length: PAGE_SSE_CLIENT_REQUEST_ID_MAX_LENGTH
                 },
-                agent_usage: 'recommended_for_high_resolution_generate_edit_and_complex_batch'
+                agent_usage: 'explicit_for_generate_recommended_for_high_resolution_edit_and_complex_batch'
             }
         },
+        orchestration: {
+            supported: true,
+            policy: 'server_orchestrated_generate_v1',
+            endpoint: AGENT_ENDPOINTS.create_image_request,
+            client_contract: 'intent_only',
+            transport_selection: 'server_owned',
+            result_mode: 'job_polling',
+            hidden_controls: ['transport', 'route_mode', 'client_endpoint_selection'],
+            diagnostics: {
+                job_result: AGENT_ENDPOINTS.job_result,
+                request_lookup: AGENT_ENDPOINTS.agent_request_diagnostics_lookup
+            },
+            current_guidance:
+                'Agent 客户端默认只提交生成意图到 /api/agent/image-requests；服务端负责选择内部执行路径、上游策略和轮询结果。显式 /api/images、Agent JSON 或 job endpoint 仅作为诊断/兼容入口。'
+        },
         routing_rules: {
             high_resolution_edit: {
                 when: ['operation=edit', 'max_edge>2048'],
@@ -1050,15 +1080,15 @@ export function buildAgentCapabilities(env: Record<string, string | undefined>):
                 },
                 endpoint: AGENT_ENDPOINTS.generate,
                 transport: 'agent_json',
-                strength: 'default',
+                strength: 'explicit',
                 action: {
                     endpoint: AGENT_ENDPOINTS.generate,
                     transport: 'agent_json',
-                    strength: 'default',
+                    strength: 'explicit',
                     requires_new_idempotency_key_on_retry: true,
                     no_automatic_fallback: true
                 },
-                reason: 'Agent JSON generate remains the stable contract and smoke path for normal single-image requests.'
+                reason: 'Agent JSON generate remains available for compatibility and explicit diagnostics; ordinary generate clients should use orchestration.endpoint.'
             },
             page_sse_large_generate: {
                 when: ['operation=generate', 'max_edge>2048', 'single_request=true'],
@@ -1069,17 +1099,17 @@ export function buildAgentCapabilities(env: Record<string, string | undefined>):
                 },
                 endpoint: '/api/images',
                 transport: 'page_sse',
-                strength: 'recommended',
+                strength: 'explicit',
                 action: {
                     endpoint: '/api/images',
                     transport: 'page_sse',
-                    strength: 'recommended',
+                    strength: 'explicit',
                     fallback_endpoint: AGENT_ENDPOINTS.generate,
                     fallback_mode: 'manual_after_diagnosis',
                     requires_new_idempotency_key_on_retry: true,
                     no_automatic_fallback: true
                 },
-                reason: 'Page form-data SSE keeps large generate requests observable; if the stream fails, diagnose first and choose any Agent JSON retry explicitly.'
+                reason: 'Page form-data SSE is available for explicit page-workbench or diagnostic large generate runs; ordinary generate clients should use orchestration.endpoint.'
             },
             retry_recovery: {
                 reuse_failed_idempotency_key: false,
@@ -1098,7 +1128,7 @@ export function buildAgentCapabilities(env: Record<string, string | undefined>):
             endpoints: { ...AGENT_JOB_ENDPOINTS },
             states: AGENT_JOB_STATES,
             current_guidance:
-                '对 max_edge>2048 的单次文生图请求优先使用页面端 /api/images SSE；如果页面流式失败，先诊断再显式选择 Agent JSON 或 job 路径，不自动回退。job polling 仅用于显式 job 路径。当前执行模型为同实例后台任务，不是跨实例持久队列。'
+                'Agent 客户端默认使用 orchestration.endpoint；直接创建 job 是兼容和诊断入口。当前执行模型为同实例后台任务，不是跨实例持久队列。'
         },
         supported: {
             models: AGENT_MODELS,

src/lib/agent-api-paths.mjs

@@ -1,6 +1,7 @@
 export const AGENT_ENDPOINTS = Object.freeze({
     capabilities: '/api/agent/capabilities',
     openapi: '/api/agent/openapi.json',
+    create_image_request: '/api/agent/image-requests',
     generate: '/api/agent/images/generate',
     edit: '/api/agent/images/edit',
     create_generate_job: '/api/agent/jobs/images/generate',

src/lib/agent-file-utils.test.ts

@@ -1,4 +1,5 @@
 import {
+    detectImageFormat,
     discardArtifactFiles,
     discardMovedFile,
     moveArtifactFilesForDeletion,
@@ -14,11 +15,12 @@ import os from 'node:os';
 import path from 'node:path';
 import { describe, it } from 'node:test';
 
+const PNG_BASE64 = 'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mP8/x8AAwMCAO+/p9sAAAAASUVORK5CYII=';
+
 describe('readImageDimensions', () => {
     it('reads PNG dimensions without external image libraries', () => {
         const buffer = Buffer.alloc(24);
-        buffer[0] = 0x89;
-        buffer.write('PNG', 1, 'ascii');
+        Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]).copy(buffer, 0);
         buffer.write('IHDR', 12, 'ascii');
         buffer.writeUInt32BE(64, 16);
         buffer.writeUInt32BE(32, 20);
@@ -31,6 +33,24 @@ describe('readImageDimensions', () => {
     });
 });
 
+describe('detectImageFormat', () => {
+    it('uses image bytes instead of requested output format', () => {
+        const buffer = Buffer.from(PNG_BASE64, 'base64');
+
+        assert.deepEqual(detectImageFormat(buffer, 'webp'), {
+            outputFormat: 'png',
+            mimeType: 'image/png'
+        });
+    });
+
+    it('falls back to the requested format for unknown bytes', () => {
+        assert.deepEqual(detectImageFormat(Buffer.from('not an image'), 'webp'), {
+            outputFormat: 'webp',
+            mimeType: 'image/webp'
+        });
+    });
+});
+
 describe('writeFileAtomic', () => {
     it('removes temporary files when the final rename fails', async () => {
         const tempDir = await mkdtemp(path.join(os.tmpdir(), 'agent-atomic-'));

src/lib/agent-file-utils.ts

@@ -9,12 +9,30 @@ export type ImageDimensions = {
     height: number | null;
 };
 
+export type DetectedImageFormat = {
+    outputFormat: 'png' | 'jpeg' | 'webp';
+    mimeType: string;
+};
+
+type ImageFormatFallback = DetectedImageFormat['outputFormat'] | 'jpg';
+
 export function mimeTypeForOutputFormat(outputFormat: string): string {
     if (outputFormat === 'jpeg' || outputFormat === 'jpg') return 'image/jpeg';
     if (outputFormat === 'webp') return 'image/webp';
     return 'image/png';
 }
 
+export function detectImageFormat(buffer: Buffer, fallbackOutputFormat: ImageFormatFallback): DetectedImageFormat {
+    if (isPng(buffer)) return { outputFormat: 'png', mimeType: 'image/png' };
+    if (isJpeg(buffer)) return { outputFormat: 'jpeg', mimeType: 'image/jpeg' };
+    if (isWebp(buffer)) return { outputFormat: 'webp', mimeType: 'image/webp' };
+    const outputFormat = fallbackOutputFormat === 'jpg' ? 'jpeg' : fallbackOutputFormat;
+    return {
+        outputFormat,
+        mimeType: mimeTypeForOutputFormat(fallbackOutputFormat)
+    };
+}
+
 export async function writeFileAtomic(filepath: string, buffer: Buffer): Promise<void> {
     await fs.mkdir(path.dirname(filepath), { recursive: true });
     const tmpPath = `${filepath}.tmp-${crypto.randomUUID()}`;
@@ -124,12 +142,7 @@ export function readImageDimensions(buffer: Buffer): ImageDimensions {
 }
 
 function readPngDimensions(buffer: Buffer): ImageDimensions {
-    if (
-        buffer.length >= 24 &&
-        buffer[0] === 0x89 &&
-        buffer.toString('ascii', 1, 4) === 'PNG' &&
-        buffer.toString('ascii', 12, 16) === 'IHDR'
-    ) {
+    if (buffer.length >= 24 && isPng(buffer) && buffer.toString('ascii', 12, 16) === 'IHDR') {
         return {
             width: buffer.readUInt32BE(16),
             height: buffer.readUInt32BE(20)
@@ -139,7 +152,7 @@ function readPngDimensions(buffer: Buffer): ImageDimensions {
 }
 
 function readJpegDimensions(buffer: Buffer): ImageDimensions {
-    if (buffer.length < 4 || buffer[0] !== 0xff || buffer[1] !== 0xd8) {
+    if (!isJpeg(buffer)) {
         return { width: null, height: null };
     }
     let offset = 2;
@@ -163,7 +176,7 @@ function readJpegDimensions(buffer: Buffer): ImageDimensions {
 }
 
 function readWebpDimensions(buffer: Buffer): ImageDimensions {
-    if (buffer.length < 30 || buffer.toString('ascii', 0, 4) !== 'RIFF' || buffer.toString('ascii', 8, 12) !== 'WEBP') {
+    if (!isWebp(buffer) || buffer.length < 30) {
         return { width: null, height: null };
     }
     const chunk = buffer.toString('ascii', 12, 16);
@@ -191,3 +204,25 @@ function readWebpDimensions(buffer: Buffer): ImageDimensions {
     }
     return { width: null, height: null };
 }
+
+function isPng(buffer: Buffer): boolean {
+    return (
+        buffer.length >= 8 &&
+        buffer[0] === 0x89 &&
+        buffer[1] === 0x50 &&
+        buffer[2] === 0x4e &&
+        buffer[3] === 0x47 &&
+        buffer[4] === 0x0d &&
+        buffer[5] === 0x0a &&
+        buffer[6] === 0x1a &&
+        buffer[7] === 0x0a
+    );
+}
+
+function isJpeg(buffer: Buffer): boolean {
+    return buffer.length >= 4 && buffer[0] === 0xff && buffer[1] === 0xd8;
+}
+
+function isWebp(buffer: Buffer): boolean {
+    return buffer.length >= 12 && buffer.toString('ascii', 0, 4) === 'RIFF' && buffer.toString('ascii', 8, 12) === 'WEBP';
+}

src/lib/agent-generate-job-route.ts

@@ -0,0 +1,101 @@
+import { buildAgentJobStatusResponse, startAgentGenerateJob } from './agent-job-service';
+import {
+    buildGenerateRequestHash,
+    parseAgentGenerateRequest,
+    prepareAgentGenerate,
+    resolveExistingAgentRequest,
+    readIdempotencyKey
+} from './agent-image-service';
+import { readAgentLeaseMs, readAgentRequestTtlSeconds } from './agent-api-contracts';
+import { AgentApiError, agentErrorResponse, normalizeAgentError } from './api-error-response';
+import { assertAgentAuthorized } from './agent-auth';
+import { ensureAgentStateStoreReady } from './agent-state-runtime';
+import { createRequestId, type BeginAgentRequestResult } from './agent-state-store';
+import { NextRequest, NextResponse } from 'next/server';
+
+export async function createAgentGenerateJobResponse(
+    request: NextRequest,
+    options: { transportEndpoint: string }
+): Promise<NextResponse> {
+    let requestId = createRequestId();
+    try {
+        assertAgentAuthorized(request.headers);
+        const imageRequest = await parseAgentGenerateRequest(request);
+        const idempotencyKey = readIdempotencyKey(request.headers);
+        const requestHash = buildGenerateRequestHash(imageRequest);
+        const store = await ensureAgentStateStoreReady();
+        const existingResponse = jobBeginResultResponse(
+            resolveExistingAgentRequest(await store.getRequestByIdempotencyKey(idempotencyKey), requestHash)
+        );
+        if (existingResponse) return existingResponse;
+        const preparation = prepareAgentGenerate(imageRequest, request.headers);
+        const leaseMs = readAgentLeaseMs(process.env);
+        const beginResult = await store.beginRequest({
+            idempotencyKey,
+            requestHash,
+            mode: 'generate',
+            requestJson: imageRequest,
+            leaseMs,
+            ttlSeconds: readAgentRequestTtlSeconds(process.env)
+        });
+
+        const storedResponse = jobBeginResultResponse(beginResult);
+        if (storedResponse) return storedResponse;
+
+        requestId = beginResult.record.requestId;
+        startAgentGenerateJob({
+            store,
+            request: imageRequest,
+            headers: new Headers(request.headers),
+            requestId,
+            idempotencyKey,
+            leaseMs,
+            preparation,
+            transportEndpoint: options.transportEndpoint
+        });
+        return runningJobResponse(beginResult.record, 5, false);
+    } catch (error) {
+        return agentErrorResponse(normalizeAgentError(error), requestId);
+    }
+}
+
+function createIdempotencyConflictError(): AgentApiError {
+    return new AgentApiError({
+        code: 'idempotency_conflict',
+        message: 'Idempotency-Key 已被不同请求正文使用。',
+        status: 409,
+        retryable: false
+    });
+}
+
+function jobBeginResultResponse(beginResult: BeginAgentRequestResult | undefined): NextResponse | undefined {
+    if (!beginResult || beginResult.type === 'acquired') return undefined;
+    if (beginResult.type === 'conflict') {
+        throw createIdempotencyConflictError();
+    }
+    if (beginResult.type === 'replay' || beginResult.type === 'failed') {
+        return NextResponse.json(buildAgentJobStatusResponse(beginResult.record), {
+            status: 202,
+            headers: {
+                'X-Idempotent-Replay': 'true',
+                'X-Request-Id': beginResult.record.requestId
+            }
+        });
+    }
+    return runningJobResponse(beginResult.record, beginResult.retryAfterSeconds, true);
+}
+
+function runningJobResponse(
+    record: Parameters<typeof buildAgentJobStatusResponse>[0],
+    retryAfterSeconds: number,
+    replay: boolean
+) {
+    return NextResponse.json(buildAgentJobStatusResponse(record, { retryAfterSeconds }), {
+        status: 202,
+        headers: {
+            'Retry-After': String(retryAfterSeconds),
+            'X-Request-Id': record.requestId,
+            ...(replay ? { 'X-Idempotent-Replay': 'true' } : {})
+        }
+    });
+}

src/lib/agent-image-service.ts

@@ -1075,7 +1075,7 @@ async function persistOpenAiImages(options: {
             filepath: persistedImage.filepath,
             contentUrl,
             metadataUrl,
-            outputFormat: options.outputFormat,
+            outputFormat: persistedImage.outputFormat,
             mimeType: persistedImage.mimeType,
             sizeBytes: persistedImage.sizeBytes,
             width: persistedImage.width,

src/lib/agent-job-service.ts

@@ -97,6 +97,7 @@ export function startAgentGenerateJob(options: {
     idempotencyKey: string;
     leaseMs: number;
     preparation?: AgentGeneratePreparation;
+    transportEndpoint?: string;
 }): void {
     void runAgentGenerateJob(options).catch((error) => {
         appLogger.error('Agent generate job 后台执行失败。', error);
@@ -116,6 +117,7 @@ async function runAgentGenerateJob(options: {
     idempotencyKey: string;
     leaseMs: number;
     preparation?: AgentGeneratePreparation;
+    transportEndpoint?: string;
 }): Promise<void> {
     let heartbeat: { stop: () => void } | undefined;
     try {
@@ -129,7 +131,7 @@ async function runAgentGenerateJob(options: {
             preparation: options.preparation,
             transport: {
                 transport: 'agent_job_polling',
-                endpoint: AGENT_ENDPOINTS.create_generate_job,
+                endpoint: options.transportEndpoint ?? AGENT_ENDPOINTS.create_generate_job,
                 route_mode: 'job'
             }
         });

src/lib/agent-openapi.ts

@@ -145,6 +145,31 @@ export function buildAgentOpenApiDocument(env: Record<string, string | undefined
                     }
                 }
             },
+            [AGENT_ENDPOINTS.create_image_request]: {
+                post: {
+                    summary: '提交服务端编排的 Agent 图片生成意图',
+                    security: agentSecurity,
+                    parameters: [{ $ref: '#/components/parameters/IdempotencyKey' }],
+                    requestBody: {
+                        required: true,
+                        ...jsonContent('#/components/schemas/GenerateRequest')
+                    },
+                    responses: {
+                        '200': jsonContent('#/components/schemas/AgentJobStatusResponse'),
+                        '202': {
+                            ...jsonContent('#/components/schemas/AgentJobStatusResponse'),
+                            headers: {
+                                'Retry-After': { schema: { type: 'integer', minimum: 1 } }
+                            }
+                        },
+                        '400': jsonContent('#/components/schemas/AgentError'),
+                        '409': jsonContent('#/components/schemas/AgentError'),
+                        ...commonAgentErrors,
+                        '422': jsonContent('#/components/schemas/AgentError'),
+                        '500': jsonContent('#/components/schemas/AgentError')
+                    }
+                }
+            },
             [AGENT_ENDPOINTS.create_generate_job]: {
                 post: {
                     summary: '创建 Agent 图片生成 job',
@@ -408,6 +433,7 @@ export function buildAgentOpenApiDocument(env: Record<string, string | undefined
                         'limits',
                         'model_limits',
                         'agent_streaming',
+                        'orchestration',
                         'routing_rules',
                         'agent_jobs',
                         'supported',
@@ -624,6 +650,7 @@ export function buildAgentOpenApiDocument(env: Record<string, string | undefined
                         },
                         model_limits: { $ref: '#/components/schemas/AgentModelLimits' },
                         agent_streaming: { $ref: '#/components/schemas/AgentStreamingCapabilities' },
+                        orchestration: { $ref: '#/components/schemas/AgentOrchestrationCapabilities' },
                         routing_rules: { $ref: '#/components/schemas/AgentRoutingRules' },
                         agent_jobs: { $ref: '#/components/schemas/AgentJobCapabilities' },
                         supported: {
@@ -1045,7 +1072,7 @@ export function buildAgentOpenApiDocument(env: Record<string, string | undefined
                                 },
                                 agent_usage: {
                                     type: 'string',
-                                    enum: ['recommended_for_high_resolution_generate_edit_and_complex_batch']
+                                    enum: ['explicit_for_generate_recommended_for_high_resolution_edit_and_complex_batch']
                                 }
                             }
                         }
@@ -1090,7 +1117,7 @@ export function buildAgentOpenApiDocument(env: Record<string, string | undefined
                         },
                         strength: {
                             type: 'string',
-                            enum: ['default', 'recommended'] satisfies AgentRoutingStrength[]
+                            enum: ['default', 'recommended', 'explicit'] satisfies AgentRoutingStrength[]
                         },
                         action: { $ref: '#/components/schemas/AgentRoutingAction' },
                         reason: { type: 'string' }
@@ -1137,7 +1164,7 @@ export function buildAgentOpenApiDocument(env: Record<string, string | undefined
                         },
                         strength: {
                             type: 'string',
-                            enum: ['default', 'recommended'] satisfies AgentRoutingStrength[]
+                            enum: ['default', 'recommended', 'explicit'] satisfies AgentRoutingStrength[]
                         },
                         fallback_endpoint: { type: 'string' },
                         fallback_mode: {
@@ -1178,6 +1205,46 @@ export function buildAgentOpenApiDocument(env: Record<string, string | undefined
                         current_guidance: { type: 'string' }
                     }
                 },
+                AgentOrchestrationCapabilities: {
+                    type: 'object',
+                    required: [
+                        'supported',
+                        'policy',
+                        'endpoint',
+                        'client_contract',
+                        'transport_selection',
+                        'result_mode',
+                        'hidden_controls',
+                        'diagnostics',
+                        'current_guidance'
+                    ],
+                    properties: {
+                        supported: { type: 'boolean', const: true },
+                        policy: {
+                            type: 'string',
+                            enum: ['server_orchestrated_generate_v1']
+                        },
+                        endpoint: { type: 'string', const: AGENT_ENDPOINTS.create_image_request },
+                        client_contract: { type: 'string', enum: ['intent_only'] },
+                        transport_selection: { type: 'string', enum: ['server_owned'] },
+                        result_mode: { type: 'string', enum: ['job_polling'] },
+                        hidden_controls: { type: 'array', items: { type: 'string' } },
+                        diagnostics: {
+                            type: 'object',
+                            required: ['job_result', 'request_lookup'],
+                            properties: {
+                                job_result: { type: 'string', const: AGENT_ENDPOINTS.job_result },
+                                request_lookup: {
+                                    type: 'string',
+                                    const: AGENT_ENDPOINTS.agent_request_diagnostics_lookup
+                                }
+                            },
+                            additionalProperties: false
+                        },
+                        current_guidance: { type: 'string' }
+                    },
+                    additionalProperties: false
+                },
                 GenerateRequest: {
                     type: 'object',
                     required: ['prompt'],

src/lib/image-service.ts

@@ -1,4 +1,4 @@
-import { mimeTypeForOutputFormat, readImageDimensions, writeFileAtomic } from './agent-file-utils';
+import { detectImageFormat, readImageDimensions, writeFileAtomic } from './agent-file-utils';
 import {
     createImageResult,
     type StorageMode,
@@ -92,21 +92,22 @@ export async function persistOpenAiImages(options: {
             throw new MissingOpenAiImageDataError(index);
         }
         const buffer = Buffer.from(b64Json, 'base64');
-        const filename = createImageFilename(batchId, index, options.outputFormat);
+        const detectedFormat = detectImageFormat(buffer, options.outputFormat);
+        const filename = createImageFilename(batchId, index, detectedFormat.outputFormat);
         const filepath = path.join(outputDir, filename);
         if (options.storageMode === 'fs') {
             await writeFileAtomic(filepath, buffer);
         }
         const dimensions = readImageDimensions(buffer);
-        const legacyResult = createImageResult(filename, b64Json, options.outputFormat, options.storageMode);
+        const legacyResult = createImageResult(filename, b64Json, detectedFormat.outputFormat, options.storageMode);
         persisted.push({
             filename,
             b64Json,
             ...(options.includeBase64 ? { responseJson: b64Json } : {}),
             ...(legacyResult.path ? { path: legacyResult.path } : {}),
-            outputFormat: options.outputFormat,
+            outputFormat: detectedFormat.outputFormat,
             filepath,
-            mimeType: mimeTypeForOutputFormat(options.outputFormat),
+            mimeType: detectedFormat.mimeType,
             sizeBytes: buffer.byteLength,
             width: dimensions.width,
             height: dimensions.height