codefree-proxy 0.1.3 → 0.1.4

package/dist/proxy/openai-routes.js

@@ -1,6 +1,30 @@
 import { transformOpenAIStream } from '../compat/zed-tool-call-stream.js';
-import { SUPPORTED_MODELS, mapModel } from './model-map.js';
+import { SUPPORTED_MODELS, resolveModel, toUpstreamModel, unsupportedModelMessage } from './model-map.js';
 import { postUpstreamJson } from './upstream-client.js';
+import { errorMessage, fetchUpstreamWithRetry as fetchUpstreamWithRetryBase, formatUpstreamError, } from './upstream-retry.js';
+/* codefree-image-strip */
+import { sanitizeUpstreamBody } from './image-sanitize.js';
+function applyImageStrip(body, label = 'upstream') {
+    // Vision-capable models; preserve their image parts.
+    // DeepSeek-V4-Flash-0731 was being skipped too, but upstream rejects image
+    // payloads on it with a bare "400 Bad Request" (verified: a single tool
+    // message carrying image_url fails, the same message with string content
+    // succeeds), so it must be stripped like every other text-only model.
+    // TeleXing4.0-29B-A4B explicitly rejects image input, so it is stripped too.
+    const visionModel = typeof body?.model === 'string' ? body.model.replace(/-TokenPlan$/, '') : '';
+    // GLM-5.3-TokenPlan returns HTTP 400 for direct image payloads; native
+    // codefree-o can instead invoke a separate Vision-Inner Agent.
+    if (visionModel === 'Qwen3.8-27B' || visionModel === 'DeepSeek-V4.1-Flash-1017')
+        return body;
+    const { body: next, stripped } = sanitizeUpstreamBody(body);
+    if (stripped > 0)
+        console.log(`[debug] ${label} stripped ${stripped} image part(s) (upstream rejects multimodal)`);
+    return next;
+}
+
+const COMPACTION_PROMPT_MARKER = 'You are compacting this conversation into a handoff for another agent';
+const COMPACTION_TRANSCRIPT_LIMIT = 48_000;
+const COMPACTION_HISTORY_THRESHOLD = 20;
 function logRequest(body) {
     const model = body.model ?? 'none';
     const stream = body.stream ?? false;
@@ -8,8 +32,8 @@ function logRequest(body) {
     const hasTools = Array.isArray(body.tools) && body.tools.length > 0;
     console.log(`[debug] model=${model} stream=${stream} messages=${msgCount} tools=${hasTools}`);
 }
-function errorMessage(error) {
-    return error instanceof Error ? error.message : String(error);
+function fetchUpstreamWithRetry(body, credentials, options, label = 'upstream') {
+    return fetchUpstreamWithRetryBase(postUpstreamJson, body, credentials, options, label);
 }
 function sendError(reply, statusCode, type, error) {
     reply.code(statusCode);
@@ -18,11 +42,14 @@ function sendError(reply, statusCode, type, error) {
 function sendOrStreamError(reply, statusCode, type, error, stream) {
     if (!stream)
         return sendError(reply, statusCode, type, error);
-    reply.raw.writeHead(200, {
-        'content-type': 'text/event-stream',
-        'cache-control': 'no-cache',
-        connection: 'keep-alive'
-    });
+    // Surface errors as a real status line. A 200 carrying only an error event
+    // is indistinguishable from an empty stream to most clients, which then
+    // report "empty stream with no finish_reason" instead of the real cause.
+    if (!reply.raw.headersSent) {
+        reply.raw.writeHead(statusCode, { 'content-type': 'application/json' });
+        reply.raw.end(JSON.stringify({ error: { message: errorMessage(error), type } }));
+        return reply;
+    }
     reply.raw.write(`data: ${JSON.stringify({ error: { message: errorMessage(error), type } })}\n\n`);
     reply.raw.write('data: [DONE]\n\n');
     reply.raw.end();
@@ -34,6 +61,335 @@ function requestBody(body) {
     }
     return body;
 }
+function requestMessages(body) {
+    return Array.isArray(body.messages) ? body.messages.filter((item) => Boolean(item) && typeof item === 'object' && !Array.isArray(item)) : [];
+}
+function extractTextContent(content) {
+    if (typeof content === 'string')
+        return content;
+    if (!Array.isArray(content))
+        return '';
+    return content
+        .map((part) => {
+        if (!part || typeof part !== 'object' || Array.isArray(part))
+            return '';
+        const record = part;
+        if (typeof record.text === 'string')
+            return record.text;
+        if (typeof record.input_text === 'string')
+            return record.input_text;
+        if (record.type === 'image_url')
+            return '[image]';
+        return '';
+    })
+        .filter(Boolean)
+        .join('\n');
+}
+function isCompactionRequest(body) {
+    return requestMessages(body).some((message) => message.role === 'system' && extractTextContent(message.content).includes(COMPACTION_PROMPT_MARKER));
+}
+function isCompactionLikeRequest(body) {
+    if (isCompactionRequest(body))
+        return true;
+    const messages = requestMessages(body);
+    const hasTools = Array.isArray(body.tools) && body.tools.length > 0;
+    return hasTools && messages.length >= COMPACTION_HISTORY_THRESHOLD;
+}
+function renderToolCall(toolCall) {
+    const fn = toolCall.function;
+    if (!fn || typeof fn !== 'object' || Array.isArray(fn))
+        return '';
+    const fnRecord = fn;
+    const name = typeof fnRecord.name === 'string' ? fnRecord.name : 'unknown';
+    const args = typeof fnRecord.arguments === 'string' ? fnRecord.arguments : '';
+    return `ASSISTANT TOOL_CALL ${name}${args ? ` ${args}` : ''}`;
+}
+function renderTranscriptLine(message) {
+    const role = typeof message.role === 'string' ? message.role.toUpperCase() : 'UNKNOWN';
+    const content = extractTextContent(message.content);
+    const lines = [];
+    if (role === 'SYSTEM' && content.includes(COMPACTION_PROMPT_MARKER)) {
+        return lines;
+    }
+    const toolCalls = Array.isArray(message.tool_calls) ? message.tool_calls : [];
+    for (const toolCall of toolCalls) {
+        const line = renderToolCall(toolCall);
+        if (line)
+            lines.push(line);
+    }
+    if (role === 'TOOL') {
+        const toolCallId = typeof message.tool_call_id === 'string' ? message.tool_call_id : 'unknown';
+        if (content)
+            lines.push(`TOOL RESULT ${toolCallId}: ${content}`);
+        return lines;
+    }
+    if (content)
+        lines.push(`${role}: ${content}`);
+    return lines;
+}
+function trimTranscript(text) {
+    if (text.length <= COMPACTION_TRANSCRIPT_LIMIT)
+        return text;
+    const suffix = text.slice(-COMPACTION_TRANSCRIPT_LIMIT);
+    return `[Earlier transcript truncated to fit upstream limits]\n${suffix}`;
+}
+function anthropicText(content) {
+    if (typeof content === 'string')
+        return content;
+    if (!Array.isArray(content))
+        return '';
+    return content
+        .filter((block) => block && typeof block === 'object' && !Array.isArray(block))
+        .map((block) => block.type === 'text' ? block.text ?? '' : '')
+        .filter(Boolean)
+        .join('\n');
+}
+function anthropicSystem(body) {
+    return anthropicText(body.system);
+}
+function anthropicImage(block) {
+    const source = block.source;
+    if (!source || typeof source !== 'object')
+        return null;
+    if (source.type === 'base64') {
+        return {
+            type: 'image_url',
+            image_url: { url: `data:${source.media_type ?? 'image/png'};base64,${source.data ?? ''}` }
+        };
+    }
+    if (source.type === 'url' && typeof source.url === 'string')
+        return { type: 'image_url', image_url: { url: source.url } };
+    return null;
+}
+function anthropicToOpenAI(body, mappedModel) {
+    const messages = [];
+    const system = anthropicSystem(body);
+    if (system)
+        messages.push({ role: 'system', content: system });
+    for (const message of Array.isArray(body.messages) ? body.messages : []) {
+        const role = message?.role === 'assistant' ? 'assistant' : 'user';
+        const content = message?.content ?? '';
+        if (typeof content === 'string') {
+            messages.push({ role, content });
+            continue;
+        }
+        if (!Array.isArray(content)) {
+            messages.push({ role, content: String(content) });
+            continue;
+        }
+        if (role === 'assistant') {
+            const text = [];
+            const toolCalls = [];
+            for (const block of content) {
+                if (!block || typeof block !== 'object')
+                    continue;
+                if (block.type === 'text' && typeof block.text === 'string')
+                    text.push(block.text);
+                else if (block.type === 'thinking' && typeof block.thinking === 'string')
+                    text.push(`<thinking>\n${block.thinking}\n</thinking>`);
+                else if (block.type === 'tool_use') {
+                    toolCalls.push({
+                        id: block.id ?? `toolu_${Date.now()}_${toolCalls.length}`,
+                        type: 'function',
+                        function: { name: block.name ?? '', arguments: JSON.stringify(block.input ?? {}) }
+                    });
+                }
+            }
+            const converted = { role: 'assistant', content: text.join('\n') };
+            if (toolCalls.length > 0)
+                converted.tool_calls = toolCalls;
+            messages.push(converted);
+            continue;
+        }
+        const text = [];
+        const images = [];
+        const toolResults = [];
+        for (const block of content) {
+            if (!block || typeof block !== 'object')
+                continue;
+            if (block.type === 'text' && typeof block.text === 'string')
+                text.push(block.text);
+            else if (block.type === 'image') {
+                const image = anthropicImage(block);
+                if (image)
+                    images.push(image);
+            }
+            else if (block.type === 'tool_result') {
+                toolResults.push({ role: 'tool', tool_call_id: block.tool_use_id ?? '', content: anthropicText(block.content) });
+            }
+        }
+        if (images.length > 0)
+            messages.push({ role: 'user', content: [...text.map((value) => ({ type: 'text', text: value })), ...images] });
+        else if (text.length > 0 || toolResults.length === 0)
+            messages.push({ role: 'user', content: text.join('\n') });
+        messages.push(...toolResults);
+    }
+    const tools = Array.isArray(body.tools) ? body.tools.map((tool) => ({
+        type: 'function',
+        function: { name: tool.name ?? '', description: tool.description ?? '', parameters: tool.input_schema ?? {} }
+    })).filter((tool) => tool.function.name) : [];
+    const result = { model: mappedModel, messages, stream: body.stream === true };
+    if (tools.length > 0)
+        result.tools = tools;
+    if (body.tool_choice === 'any')
+        result.tool_choice = 'required';
+    else if (body.tool_choice === 'auto' || body.tool_choice === 'none')
+        result.tool_choice = body.tool_choice;
+    else if (body.tool_choice?.type === 'tool')
+        result.tool_choice = { type: 'function', function: { name: body.tool_choice.name } };
+    for (const key of ['max_tokens', 'temperature', 'top_p']) {
+        if (body[key] !== undefined)
+            result[key] = body[key];
+    }
+    if (Array.isArray(body.stop_sequences) && body.stop_sequences.length > 0)
+        result.stop = body.stop_sequences;
+    return result;
+}
+function openAIToAnthropic(data, requestedModel) {
+    const choice = Array.isArray(data.choices) ? data.choices[0] ?? {} : {};
+    const message = choice.message ?? {};
+    const content = [];
+    if (typeof message.content === 'string' && message.content.length > 0)
+        content.push({ type: 'text', text: message.content });
+    for (const toolCall of Array.isArray(message.tool_calls) ? message.tool_calls : []) {
+        const fn = toolCall.function ?? {};
+        let input = {};
+        try {
+            input = JSON.parse(fn.arguments ?? '{}');
+        }
+        catch {
+            input = {};
+        }
+        content.push({ type: 'tool_use', id: toolCall.id ?? `toolu_${Date.now()}_${content.length}`, name: fn.name ?? '', input });
+    }
+    if (content.length === 0)
+        content.push({ type: 'text', text: '' });
+    const finishReason = choice.finish_reason;
+    const stopReason = finishReason === 'tool_calls' || message.tool_calls?.length > 0
+        ? 'tool_use' : finishReason === 'length' ? 'max_tokens' : 'end_turn';
+    return {
+        id: `msg_${Date.now()}_${Math.random().toString(16).slice(2)}`,
+        type: 'message',
+        role: 'assistant',
+        content,
+        model: requestedModel,
+        stop_reason: stopReason,
+        stop_sequence: null,
+        usage: { input_tokens: data.usage?.prompt_tokens ?? 0, output_tokens: data.usage?.completion_tokens ?? 0 }
+    };
+}
+function anthropicEvent(event, data) {
+    return `event: ${event}\ndata: ${JSON.stringify(data)}\n\n`;
+}
+function sendAnthropicStreamError(reply, statusCode, type, error) {
+    reply.raw.writeHead(200, {
+        'content-type': 'text/event-stream',
+        'cache-control': 'no-cache',
+        connection: 'keep-alive'
+    });
+    reply.raw.write(anthropicEvent('error', { type: 'error', error: { type, message: errorMessage(error) } }));
+    reply.raw.end();
+    return reply;
+}
+async function* openAIToAnthropicStream(response, requestedModel) {
+    const messageId = `msg_${Date.now()}_${Math.random().toString(16).slice(2)}`;
+    yield anthropicEvent('message_start', {
+        type: 'message_start',
+        message: {
+            id: messageId, type: 'message', role: 'assistant', content: [], model: requestedModel,
+            stop_reason: null, stop_sequence: null, usage: { input_tokens: 0, output_tokens: 0 }
+        }
+    });
+    let textOpen = false;
+    let textIndex = -1;
+    let nextIndex = 0;
+    const toolBlocks = new Map();
+    let stopReason = 'end_turn';
+    let inputTokens = 0;
+    let outputTokens = 0;
+    for await (const part of responseToChunks(response)) {
+        const dataLine = part.split(/\r?\n/).find((line) => line.startsWith('data:'));
+        if (!dataLine)
+            continue;
+        const dataText = dataLine.slice(5).trim();
+        if (!dataText || dataText === '[DONE]')
+            break;
+        let data;
+        try {
+            data = JSON.parse(dataText);
+        }
+        catch {
+            continue;
+        }
+        if (data.usage) {
+            inputTokens = data.usage.prompt_tokens ?? inputTokens;
+            outputTokens = data.usage.completion_tokens ?? outputTokens;
+        }
+        const choice = Array.isArray(data.choices) ? data.choices[0] : null;
+        if (!choice)
+            continue;
+        const delta = choice.delta ?? {};
+        const text = typeof delta.content === 'string' ? delta.content : '';
+        if (text) {
+            if (!textOpen) {
+                textIndex = nextIndex++;
+                textOpen = true;
+                yield anthropicEvent('content_block_start', { type: 'content_block_start', index: textIndex, content_block: { type: 'text', text: '' } });
+            }
+            yield anthropicEvent('content_block_delta', { type: 'content_block_delta', index: textIndex, delta: { type: 'text_delta', text } });
+        }
+        for (const toolCall of Array.isArray(delta.tool_calls) ? delta.tool_calls : []) {
+            const key = toolCall.index ?? 0;
+            const fn = toolCall.function ?? {};
+            let block = toolBlocks.get(key);
+            if (!block) {
+                block = { index: nextIndex++, id: toolCall.id ?? `toolu_${Date.now()}_${key}`, name: fn.name ?? '' };
+                toolBlocks.set(key, block);
+                yield anthropicEvent('content_block_start', { type: 'content_block_start', index: block.index, content_block: { type: 'tool_use', id: block.id, name: block.name, input: {} } });
+            }
+            if (typeof fn.arguments === 'string' && fn.arguments.length > 0) {
+                yield anthropicEvent('content_block_delta', { type: 'content_block_delta', index: block.index, delta: { type: 'input_json_delta', partial_json: fn.arguments } });
+            }
+        }
+        if (choice.finish_reason === 'tool_calls')
+            stopReason = 'tool_use';
+        else if (choice.finish_reason === 'length')
+            stopReason = 'max_tokens';
+    }
+    if (textOpen)
+        yield anthropicEvent('content_block_stop', { type: 'content_block_stop', index: textIndex });
+    for (const block of toolBlocks.values())
+        yield anthropicEvent('content_block_stop', { type: 'content_block_stop', index: block.index });
+    yield anthropicEvent('message_delta', { type: 'message_delta', delta: { stop_reason: stopReason, stop_sequence: null }, usage: { input_tokens: inputTokens, output_tokens: outputTokens } });
+    yield anthropicEvent('message_stop', { type: 'message_stop' });
+}
+function buildCompactionFallbackBody(body, mappedModel) {
+    const messages = requestMessages(body);
+    const systemPrompt = messages
+        .map((message) => extractTextContent(message.content))
+        .find((content) => content.includes(COMPACTION_PROMPT_MARKER)) ?? COMPACTION_PROMPT_MARKER;
+    const transcript = trimTranscript(messages.flatMap(renderTranscriptLine).join('\n'));
+    const userPrompt = [
+        'Compact the following conversation into a concise handoff for the next agent.',
+        'Preserve goals, constraints, decisions, unfinished work, and next steps.',
+        '',
+        transcript
+    ].join('\n');
+    return {
+        ...body,
+        model: mappedModel,
+        stream: false,
+        messages: [
+            { role: 'system', content: systemPrompt },
+            { role: 'user', content: userPrompt }
+        ],
+        tools: undefined,
+        tool_choice: undefined,
+        parallel_tool_calls: undefined,
+        response_format: undefined,
+        stream_options: undefined
+    };
+}
 async function* responseToChunks(response) {
     const reader = response.body?.getReader();
     if (!reader)
@@ -85,6 +441,87 @@ export function registerOpenAIRoutes(app, options) {
             return sendError(reply, 401, 'auth_error', error);
         }
     });
+    app.post('/v1/messages', async (request, reply) => {
+        let body;
+        try {
+            body = requestBody(request.body);
+        }
+        catch (error) {
+            return sendError(reply, 400, 'invalid_request_error', error);
+        }
+        logRequest(body);
+        const requestedModel = typeof body.model === 'string' ? body.model : '';
+        const canonicalModel = resolveModel(requestedModel);
+        if (!canonicalModel)
+            return sendError(reply, 400, 'invalid_request_error', new Error(unsupportedModelMessage(requestedModel)));
+        const mappedModel = toUpstreamModel(canonicalModel);
+        const stream = body.stream === true;
+        const upstreamBody = applyImageStrip(anthropicToOpenAI(body, mappedModel), 'anthropic');
+        let credentials;
+        try {
+            credentials = await options.auth.getCredentials();
+        }
+        catch (error) {
+            return stream ? sendAnthropicStreamError(reply, 401, 'authentication_error', error) : sendError(reply, 401, 'auth_error', error);
+        }
+        const fetchOpts = { fetchImpl: options.upstreamFetch, timeoutMs: options.timeoutMs };
+        let upstream;
+        let preReadErrorBody = null;
+        try {
+            ({ response: upstream, errorBody: preReadErrorBody } = await fetchUpstreamWithRetry(upstreamBody, credentials, fetchOpts, 'anthropic-upstream'));
+        }
+        catch (error) {
+            return stream ? sendAnthropicStreamError(reply, 502, 'api_error', error) : sendError(reply, 502, 'api_error', error);
+        }
+        if (upstream.status === 401 || upstream.status === 403) {
+            try {
+                credentials = await options.auth.refresh();
+            }
+            catch (error) {
+                return stream ? sendAnthropicStreamError(reply, 401, 'authentication_error', error) : sendError(reply, 401, 'auth_error', error);
+            }
+            try {
+                ({ response: upstream, errorBody: preReadErrorBody } = await fetchUpstreamWithRetry(upstreamBody, credentials, fetchOpts, 'anthropic-upstream-after-refresh'));
+            }
+            catch (error) {
+                return stream ? sendAnthropicStreamError(reply, 502, 'api_error', error) : sendError(reply, 502, 'api_error', error);
+            }
+        }
+        if (!upstream.ok) {
+            const message = preReadErrorBody ?? await upstream.text();
+            if (!preReadErrorBody)
+                console.log(`[debug] anthropic upstream non-ok: status=${upstream.status} body=${message.slice(0, 200)}`);
+            const friendly = formatUpstreamError(upstream.status, message);
+            if (stream)
+                return sendAnthropicStreamError(reply, upstream.status, 'api_error', new Error(friendly));
+            reply.code(upstream.status);
+            return { type: 'error', error: { type: 'api_error', message: friendly } };
+        }
+        if (stream) {
+            reply.raw.writeHead(200, {
+                'content-type': 'text/event-stream',
+                'cache-control': 'no-cache',
+                connection: 'keep-alive'
+            });
+            try {
+                for await (const event of openAIToAnthropicStream(upstream, requestedModel))
+                    reply.raw.write(event);
+            }
+            catch (error) {
+                reply.raw.write(anthropicEvent('error', { type: 'error', error: { type: 'api_error', message: errorMessage(error) } }));
+            }
+            reply.raw.end();
+            return reply;
+        }
+        try {
+            const data = JSON.parse(await upstream.text());
+            reply.header('content-type', 'application/json');
+            return openAIToAnthropic(data, requestedModel);
+        }
+        catch (error) {
+            return sendError(reply, 502, 'api_error', error);
+        }
+    });
     app.post('/v1/chat/completions', async (request, reply) => {
         let body;
         try {
@@ -94,8 +531,11 @@ export function registerOpenAIRoutes(app, options) {
             return sendError(reply, 400, 'invalid_request_error', error);
         }
         logRequest(body);
-        const mappedModel = mapModel(typeof body.model === 'string' ? body.model : undefined);
-        const upstreamBody = { ...body, model: mappedModel };
+        const canonicalModel = resolveModel(body.model);
+        if (!canonicalModel)
+            return sendError(reply, 400, 'invalid_request_error', new Error(unsupportedModelMessage(body.model)));
+        const mappedModel = toUpstreamModel(canonicalModel);
+        let upstreamBody = applyImageStrip({ ...body, model: mappedModel }, 'chat');
         const stream = body.stream === true;
         let credentials;
         try {
@@ -104,9 +544,11 @@ export function registerOpenAIRoutes(app, options) {
         catch (error) {
             return sendOrStreamError(reply, 401, 'auth_error', error, stream);
         }
+        const fetchOpts = { fetchImpl: options.upstreamFetch, timeoutMs: options.timeoutMs };
         let upstream;
+        let preReadErrorBody = null;
         try {
-            upstream = await postUpstreamJson(upstreamBody, credentials, { fetchImpl: options.upstreamFetch, timeoutMs: options.timeoutMs });
+            ({ response: upstream, errorBody: preReadErrorBody } = await fetchUpstreamWithRetry(upstreamBody, credentials, fetchOpts, 'upstream'));
         }
         catch (error) {
             return sendOrStreamError(reply, 502, 'api_error', error, stream);
@@ -119,20 +561,42 @@ export function registerOpenAIRoutes(app, options) {
                 return sendOrStreamError(reply, 401, 'auth_error', error, stream);
             }
             try {
-                upstream = await postUpstreamJson(upstreamBody, credentials, { fetchImpl: options.upstreamFetch, timeoutMs: options.timeoutMs });
+                ({ response: upstream, errorBody: preReadErrorBody } = await fetchUpstreamWithRetry(upstreamBody, credentials, fetchOpts, 'upstream-after-refresh'));
             }
             catch (error) {
                 return sendOrStreamError(reply, 502, 'api_error', error, stream);
             }
         }
         if (!upstream.ok) {
-            const message = await upstream.text();
-            console.log(`[debug] upstream non-ok: status=${upstream.status} body=${message.slice(0, 200)}`);
-            if (!stream) {
+            let message = preReadErrorBody ?? await upstream.text();
+            if (!preReadErrorBody)
+                console.log(`[debug] upstream non-ok: status=${upstream.status} body=${message.slice(0, 200)}`);
+            if (!stream && upstream.status === 400 && isCompactionLikeRequest(body)) {
+                upstreamBody = buildCompactionFallbackBody(body, mappedModel);
+                const fallbackMessages = requestMessages(upstreamBody);
+                const fallbackText = typeof fallbackMessages[1]?.content === 'string' ? fallbackMessages[1].content : '';
+                console.log(`[debug] compaction fallback retry: messages=${fallbackMessages.length} chars=${fallbackText.length}`);
+                try {
+                    ({ response: upstream, errorBody: preReadErrorBody } = await fetchUpstreamWithRetry(upstreamBody, credentials, fetchOpts, 'compaction-fallback'));
+                    message = preReadErrorBody ?? '';
+                }
+                catch (error) {
+                    return sendError(reply, 502, 'api_error', error);
+                }
+                if (!upstream.ok) {
+                    message = preReadErrorBody ?? await upstream.text();
+                    console.log(`[debug] compaction fallback non-ok: status=${upstream.status} body=${message.slice(0, 200)}`);
+                    reply.code(upstream.status);
+                    return { error: { message: formatUpstreamError(upstream.status, message), type: 'api_error' } };
+                }
+            }
+            else if (!stream) {
                 reply.code(upstream.status);
-                return { error: { message, type: 'api_error' } };
+                return { error: { message: formatUpstreamError(upstream.status, message), type: 'api_error' } };
+            }
+            if (!upstream.ok) {
+                return sendOrStreamError(reply, upstream.status, 'api_error', new Error(formatUpstreamError(upstream.status, message)), true);
             }
-            return sendOrStreamError(reply, upstream.status, 'api_error', new Error(message), true);
         }
         if (!stream) {
             reply.header('content-type', 'application/json');
@@ -155,23 +619,57 @@ export function registerOpenAIRoutes(app, options) {
                 return sendError(reply, 502, 'api_error', error);
             }
         }
-        reply.raw.writeHead(200, {
-            'content-type': 'text/event-stream',
-            'cache-control': 'no-cache',
-            connection: 'keep-alive'
-        });
+        // Hold the SSE status line until the first real chunk arrives, so an
+        // upstream that closes cleanly with zero chunks can still be reported as
+        // an error instead of an empty 200. Once content flows, stream it live.
+        const iterator = transformOpenAIStream(responseToChunks(upstream));
+        const lead = [];
+        let committed = false;
+        let emittedDone = false;
+        let streamError = null;
         try {
-            for await (const chunk of transformOpenAIStream(responseToChunks(upstream))) {
+            for await (const chunk of iterator) {
+                if (!committed) {
+                    if (/"choices"/.test(chunk)) {
+                        committed = true;
+                        reply.raw.writeHead(200, {
+                            'content-type': 'text/event-stream',
+                            'cache-control': 'no-cache',
+                            connection: 'keep-alive'
+                        });
+                        for (const buffered of lead)
+                            reply.raw.write(buffered);
+                        lead.length = 0;
+                        reply.raw.write(chunk);
+                        if (/\[DONE\]/.test(chunk))
+                            emittedDone = true;
+                    }
+                    else if (!/\[DONE\]/.test(chunk)) {
+                        lead.push(chunk);
+                    }
+                    continue;
+                }
                 reply.raw.write(chunk);
+                if (/\[DONE\]/.test(chunk))
+                    emittedDone = true;
             }
         }
         catch (error) {
+            streamError = error;
             console.log(`[debug] stream transform error: ${errorMessage(error)}`);
-            reply.raw.write(`data: ${JSON.stringify({ error: { message: errorMessage(error), type: 'api_error' } })}\n\n`);
         }
-        reply.raw.write('data: [DONE]\n\n');
+        if (!committed) {
+            const detail = streamError ? errorMessage(streamError) : 'upstream returned an empty stream';
+            console.log(`[debug] empty stream: ${detail}`);
+            return sendOrStreamError(reply, 502, 'api_error', new Error(`empty_stream: ${detail}`), true);
+        }
+        if (streamError) {
+            reply.raw.write(`data: ${JSON.stringify({ error: { message: errorMessage(streamError), type: 'api_error' } })}\n\n`);
+        }
+        if (!emittedDone)
+            reply.raw.write('data: [DONE]\n\n');
         reply.raw.end();
         return reply;
     });
 }
-//# sourceMappingURL=openai-routes.js.map
+//# sourceMappingURL=openai-routes.js.map