Deploy bf62eed to Docker Space

Source: MisonL/gpt-image-playground-customer@bf62eed15cedbc56fb8df227f2d76273004d494e

public/hf-space-deploy-marker.json

@@ -1,6 +1,6 @@
 {
   "schema_version": 1,
-  "local_sha": "ea6a3d8444044cb6d5357f63688e29b8448df8c1",
-  "created_at": "2026-06-26T08:40:21.663Z",
-  "deploy_id": "6abe5272-c17b-447f-8990-e37a807c71aa"
+  "local_sha": "bf62eed15cedbc56fb8df227f2d76273004d494e",
+  "created_at": "2026-06-26T09:26:30.691Z",
+  "deploy_id": "5b30e427-0d60-4ce4-b6ce-667ada74c8c0"
 }

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

@@ -785,6 +785,42 @@ describe('Agent route integration', () => {
         }
     });
 
+    it('marks Responses image_generation-disabled 403s as unavailable request modes', async () => {
+        process.env.AGENT_STATE_BACKEND = 'memory';
+        delete process.env.AGENT_SQLITE_PATH;
+        const { generateImage } = await loadAgentRoutes();
+        const upstream = await startResponsesImageJsonUpstream(403, {
+            error: { message: 'Image generation is not enabled for this group' }
+        });
+        process.env.ENABLE_RESPONSES_IMAGE_BACKEND = 'true';
+        process.env.OPENAI_RESPONSES_API_MODEL = 'gpt-5.4';
+        process.env.OPENAI_API_KEY = 'test-key';
+        process.env.OPENAI_API_BASE_URL = upstream.baseUrl;
+
+        try {
+            const response = await generateImage(
+                agentJsonRequest('agent-responses-image-disabled-key', {
+                    prompt: 'agent responses disabled',
+                    image_backend: 'responses-image-generation',
+                    streaming_strategy: 'responses-sse',
+                    partial_images: 2
+                })
+            );
+
+            assert.equal(response.status, 502);
+            const body = await response.json();
+            assert.equal(body.error.code, 'upstream_unavailable');
+            assert.equal(body.error.upstream_status, 403);
+            assert.equal(body.error.diagnostics.channel_request_mode, 'responses-sse');
+            assert.equal(body.error.diagnostics.channel_cooldown_scope, 'channel');
+            assert.equal(body.error.diagnostics.cooldown_target.channel_id, 'default');
+            assert.equal(body.error.diagnostics.cooldown_target.request_mode, 'responses-sse');
+            assert.equal(JSON.stringify(body).includes('test-key'), false);
+        } finally {
+            await upstream.close();
+        }
+    });
+
     it('uses force-sse for Agent Responses image_generation SSE while keeping the final JSON contract', async () => {
         const { generateImage } = await loadAgentRoutes();
         let upstreamBody = '';
@@ -3462,6 +3498,29 @@ async function startStreamingResponsesImageUpstream(
     };
 }
 
+async function startResponsesImageJsonUpstream(
+    status: number,
+    body: unknown
+): Promise<{ baseUrl: string; close: () => Promise<void> }> {
+    const server = http.createServer((request, response) => {
+        if (request.method !== 'POST' || !request.url?.endsWith('/responses')) {
+            response.writeHead(404, { 'Content-Type': 'application/json' });
+            response.end(JSON.stringify({ error: { message: 'not found' } }));
+            return;
+        }
+        request.resume();
+        response.writeHead(status, { 'Content-Type': 'application/json' });
+        response.end(JSON.stringify(body));
+    });
+    await new Promise<void>((resolve) => server.listen(0, '127.0.0.1', resolve));
+    const address = server.address();
+    assert.ok(address && typeof address === 'object');
+    return {
+        baseUrl: `http://127.0.0.1:${address.port}/v1`,
+        close: () => new Promise((resolve, reject) => server.close((error) => (error ? reject(error) : resolve())))
+    };
+}
+
 function readStoredResponseJson(idempotencyKey: string): string {
     const db = new Database(path.join(tempDir, 'agent.sqlite'), { readonly: true });
     try {

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

@@ -1,6 +1,6 @@
 import { NextResponse } from 'next/server';
 
-const deployMarker = {"schema_version":1,"local_sha":"ea6a3d8444044cb6d5357f63688e29b8448df8c1","created_at":"2026-06-26T08:40:21.663Z","deploy_id":"6abe5272-c17b-447f-8990-e37a807c71aa"} as const;
+const deployMarker = {"schema_version":1,"local_sha":"bf62eed15cedbc56fb8df227f2d76273004d494e","created_at":"2026-06-26T09:26:30.691Z","deploy_id":"5b30e427-0d60-4ce4-b6ce-667ada74c8c0"} as const;
 
 export const dynamic = 'force-dynamic';
 

src/lib/agent-image-service.ts

@@ -45,6 +45,7 @@ import {
     type ChannelFailureReport,
     describeChannelFailure,
     isChannelFailure,
+    isChannelRequestModeFailure,
     isCredentialFailure,
     resolveEffectiveCredential
 } from './channel-router';
@@ -1067,6 +1068,20 @@ function reportServerCredentialFailure(
 ): ChannelFailureReport | undefined {
     const serverChannelRouter = getServerChannelState().router;
     if (!credential || !serverChannelRouter) return undefined;
+    if (isChannelRequestModeFailure(error, requestMode)) {
+        const reason = {
+            ...describeChannelFailure(error, 'channel'),
+            ...(requestMode ? { requestMode } : {})
+        };
+        const report = serverChannelRouter.reportFailure(credential, { scope: 'channel', requestMode, reason });
+        appLogger.warn(
+            report.cooldownApplied
+                ? `Temporarily cooling down API channel request mode: ${credential.channelId}/${requestMode}`
+                : `Recording API channel request mode failure without cooldown: ${credential.channelId}/${requestMode}`,
+            reason
+        );
+        return report;
+    }
     if (isChannelFailure(error)) {
         const reason = {
             ...describeChannelFailure(error, 'channel'),

src/lib/api-error-response.test.ts

@@ -7,6 +7,7 @@ import {
     toTerminalAgentErrorBody
 } from './api-error-response';
 import { RequestValidationError } from './image-request-utils';
+import { type ChannelRequestMode } from './channel-request-mode';
 import assert from 'node:assert/strict';
 import { describe, it } from 'node:test';
 
@@ -76,6 +77,23 @@ describe('normalizeAgentError', () => {
         assert.equal(error.diagnostics?.channel_cooldown_scope, 'channel');
     });
 
+    it('maps Responses image generation disabled 403s to unavailable channel failures', () => {
+        const error = normalizeAgentError(
+            Object.assign(new Error('status_code=403, Image generation is not enabled for this group'), {
+                status: 403
+            }),
+            {
+                channel_request_mode: 'responses-sse' as ChannelRequestMode
+            }
+        );
+
+        assert.equal(error.code, 'upstream_unavailable');
+        assert.equal(error.status, 502);
+        assert.equal(error.retryable, true);
+        assert.equal(error.upstreamStatus, 403);
+        assert.equal(error.diagnostics?.channel_cooldown_scope, 'channel');
+    });
+
     it('classifies transport failures into machine-readable kinds', () => {
         assert.equal(
             normalizeAgentError(Object.assign(new Error('fetch failed'), { code: 'ENOTFOUND' })).diagnostics

src/lib/api-error-response.ts

@@ -1,5 +1,5 @@
 import { RequestValidationError } from './image-request-utils';
-import { isChannelFailure } from './channel-router';
+import { isChannelFailure, isChannelRequestModeFailure } from './channel-router';
 import { ChannelCapacityQueueError } from './channel-capacity-queue';
 import {
     CHANNEL_REQUEST_MODES,
@@ -469,6 +469,23 @@ export function normalizeAgentError(error: unknown, diagnostics: AgentErrorDiagn
 
     const status = readNumberField(error, 'status') ?? readNumberField(error, 'statusCode');
     const message = error instanceof Error ? error.message : (readStringField(error, 'message') ?? '发生未知错误。');
+    if (isChannelRequestModeFailure(error, diagnostics.channel_request_mode)) {
+        const retryAfterSeconds = readRetryAfterSeconds(error) ?? 15;
+        return new AgentApiError({
+            code: 'upstream_unavailable',
+            message,
+            status: 502,
+            retryable: true,
+            upstreamStatus: 403,
+            retryAfterSeconds,
+            diagnostics: buildDiagnostics(error, {
+                ...diagnostics,
+                upstreamStatus: 403,
+                retryAfterSeconds,
+                channel_cooldown_scope: 'channel'
+            })
+        });
+    }
     if (error instanceof ChannelCapacityQueueError) {
         const retryAfterSeconds = Math.max(1, Math.ceil(Number(error.details.max_wait_ms ?? 30_000) / 1000));
         return new AgentApiError({

src/lib/channel-router.test.ts

@@ -3,6 +3,7 @@ import {
     describeChannelFailure,
     getChannelPoolSummary,
     isChannelFailure,
+    isChannelRequestModeFailure,
     isCredentialFailure,
     parseChannelPoolConfig,
     resolveEffectiveCredential,
@@ -1559,6 +1560,35 @@ describe('isCredentialFailure', () => {
     });
 });
 
+describe('isChannelRequestModeFailure', () => {
+    it('treats Responses image_generation-disabled 403 as a request-mode failure', () => {
+        assert.equal(
+            isChannelRequestModeFailure(
+                new Error('status_code=403, Image generation is not enabled for this group'),
+                'responses-sse'
+            ),
+            true
+        );
+        assert.equal(
+            isChannelRequestModeFailure(
+                { status: 403, error: { message: 'Image generation is not enabled for this group' } },
+                'responses-non-stream'
+            ),
+            true
+        );
+    });
+
+    it('does not apply the Responses image_generation-disabled rule to Images API modes', () => {
+        assert.equal(
+            isChannelRequestModeFailure(
+                { status: 403, message: 'Image generation is not enabled for this group' },
+                'images-sse'
+            ),
+            false
+        );
+    });
+});
+
 describe('isChannelFailure', () => {
     it('treats upstream 5xx and CDN timeout statuses as channel failures', () => {
         [500, 502, 503, 504, 520, 522, 523, 524].forEach((status) => {

src/lib/channel-router.ts

@@ -755,6 +755,18 @@ export function isCredentialFailure(error: unknown): boolean {
     );
 }
 
+export function isChannelRequestModeFailure(error: unknown, requestMode?: ChannelRequestMode): boolean {
+    if (!requestMode || !requestMode.startsWith('responses-')) {
+        return false;
+    }
+    const status = readErrorStatusCode(error);
+    if (status !== 403) {
+        return false;
+    }
+    const message = readErrorMessage(error);
+    return /image generation is not enabled for this group/i.test(message);
+}
+
 export function isChannelFailure(error: unknown): boolean {
     if (error instanceof ChannelCapacityQueueError) {
         return false;
@@ -1044,7 +1056,7 @@ function readErrorNumber(error: unknown, fieldName: string): number | undefined
 }
 
 function readStatusField(error: unknown): { status?: number } {
-    const value = readErrorNumber(error, 'status') ?? readNestedErrorNumber(error, 'status');
+    const value = readErrorStatusCode(error);
     return value === undefined ? {} : { status: value };
 }
 
@@ -1090,6 +1102,39 @@ function readNestedErrorNumber(error: unknown, fieldName: string): number | unde
     return readErrorNumber((error as { error?: unknown }).error, fieldName);
 }
 
+function readErrorStatusCode(error: unknown): number | undefined {
+    return (
+        readErrorNumber(error, 'status') ??
+        readErrorNumber(error, 'statusCode') ??
+        readErrorNumber(error, 'status_code') ??
+        readNestedErrorNumber(error, 'status') ??
+        readNestedErrorNumber(error, 'statusCode') ??
+        readNestedErrorNumber(error, 'status_code') ??
+        readStatusCodeFromMessage(readErrorMessage(error))
+    );
+}
+
+function readErrorMessage(error: unknown): string {
+    if (typeof error === 'string') return error;
+    return [
+        readErrorString(error, 'message'),
+        readNestedErrorString(error, 'message'),
+        readErrorString(error, 'detail'),
+        readNestedErrorString(error, 'detail'),
+        readErrorString(error, 'raw'),
+        readNestedErrorString(error, 'raw')
+    ]
+        .filter((value): value is string => Boolean(value))
+        .join('\n');
+}
+
+function readStatusCodeFromMessage(message: string): number | undefined {
+    const match = /\bstatus(?:_code)?\s*=\s*(\d{3})\b/i.exec(message);
+    if (!match) return undefined;
+    const status = Number(match[1]);
+    return Number.isInteger(status) ? status : undefined;
+}
+
 function isConnectionFailure(error: unknown): boolean {
     const name = readErrorString(error, 'name') || readConstructorName(error);
     if (name === 'APIConnectionError' || name === 'APIConnectionTimeoutError') {

src/lib/image-route-support.ts

@@ -4,6 +4,7 @@ import {
     type ChannelCredential,
     describeChannelFailure,
     isChannelFailure,
+    isChannelRequestModeFailure,
     isCredentialFailure
 } from './channel-router';
 import type { ChannelRequestMode } from './channel-request-mode';
@@ -52,6 +53,20 @@ export function reportServerCredentialFailure(
 ) {
     const serverChannelRouter = getServerChannelState().router;
     if (!credential || !serverChannelRouter) return;
+    if (isChannelRequestModeFailure(error, requestMode)) {
+        const reason = {
+            ...describeChannelFailure(error, 'channel'),
+            ...(requestMode ? { requestMode } : {})
+        };
+        const report = serverChannelRouter.reportFailure(credential, { scope: 'channel', requestMode, reason });
+        appLogger.warn(
+            report.cooldownApplied
+                ? `暂时冷却 API 渠道请求方式：${credential.channelId}/${requestMode}`
+                : `记录 API 渠道请求方式失败，未启用冷却：${credential.channelId}/${requestMode}`,
+            reason
+        );
+        return;
+    }
     if (isChannelFailure(error)) {
         const reason = {
             ...describeChannelFailure(error, 'channel'),