fix responses stream failure logging

src/server/routes/proxy/chat.stream.test.ts

@@ -3193,6 +3193,8 @@ describe('chat proxy stream behavior', () => {
     expect(response.statusCode).toBe(200);
     expect(response.body).toContain('"finish_reason":"error"');
     expect(response.body).toContain('[DONE]');
+    expect(recordSuccessMock).not.toHaveBeenCalled();
+    expect(recordFailureMock).toHaveBeenCalledTimes(1);
   });
 
   it('preserves non-stream function_call output when /v1/chat/completions falls back to /v1/responses', async () => {

src/server/routes/proxy/chat.ts

@@ -366,6 +366,7 @@ async function handleChatProxyRequest(
         const streamSession = openAiChatTransformer.proxyStream.createSession({
           downstreamFormat,
           modelName,
+          successfulUpstreamPath,
           onParsedPayload: (payload) => {
             if (payload && typeof payload === 'object') {
               parsedUsage = mergeProxyUsage(parsedUsage, parseProxyUsage(payload));
@@ -389,9 +390,32 @@ async function handleChatProxyRequest(
           if (String(selected.site.platform || '').trim().toLowerCase() === 'gemini-cli') {
             fallbackData = unwrapGeminiCliPayload(fallbackData);
           }
-          streamSession.consumeUpstreamFinalPayload(fallbackData, fallbackText, reply.raw);
+          const streamResult = streamSession.consumeUpstreamFinalPayload(fallbackData, fallbackText, reply.raw);
 
           const latency = Date.now() - startTime;
+          if (streamResult.status === 'failed') {
+            tokenRouter.recordFailure(selected.channel.id);
+            logProxy(
+              selected,
+              requestedModel,
+              'failed',
+              200,
+              latency,
+              streamResult.errorMessage,
+              retryCount,
+              downstreamPath,
+              parsedUsage.promptTokens,
+              parsedUsage.completionTokens,
+              parsedUsage.totalTokens,
+              0,
+              null,
+              successfulUpstreamPath,
+              clientContext,
+              logDownstreamApiKeyId ? downstreamApiKeyId : null,
+            );
+            return;
+          }
+
           const resolvedUsage = await resolveProxyUsageWithSelfLogFallback({
             site: selected.site,
             account: selected.account,
@@ -443,9 +467,32 @@ async function handleChatProxyRequest(
         const reader = String(selected.site.platform || '').trim().toLowerCase() === 'gemini-cli' && upstreamReader
           ? createGeminiCliStreamReader(upstreamReader)
           : upstreamReader;
-        await streamSession.run(reader, reply.raw);
+        const streamResult = await streamSession.run(reader, reply.raw);
 
         const latency = Date.now() - startTime;
+        if (streamResult.status === 'failed') {
+          tokenRouter.recordFailure(selected.channel.id);
+          logProxy(
+            selected,
+            requestedModel,
+            'failed',
+            200,
+            latency,
+            streamResult.errorMessage,
+            retryCount,
+            downstreamPath,
+            parsedUsage.promptTokens,
+            parsedUsage.completionTokens,
+            parsedUsage.totalTokens,
+            0,
+            null,
+            successfulUpstreamPath,
+            clientContext,
+            logDownstreamApiKeyId ? downstreamApiKeyId : null,
+          );
+          return;
+        }
+
         const resolvedUsage = await resolveProxyUsageWithSelfLogFallback({
           site: selected.site,
           account: selected.account,

src/server/routes/proxy/endpointFlow.test.ts

@@ -185,6 +185,22 @@ describe('executeEndpointFlow', () => {
     expect(fetchMock).toHaveBeenCalledTimes(1);
   });
 
+  it('uses proxyUrl for the default fetch path when no dispatch hook is provided', async () => {
+    fetchMock.mockResolvedValueOnce(toUndiciResponse(new Response(JSON.stringify({ ok: true }), {
+      status: 200,
+      headers: { 'content-type': 'application/json' },
+    })));
+
+    await executeEndpointFlow({
+      siteUrl: 'https://example.com',
+      proxyUrl: 'https://proxy.internal/base',
+      endpointCandidates: ['responses'],
+      buildRequest: () => requestFor('/v1/responses'),
+    });
+
+    expect(fetchMock.mock.calls[0]?.[0]).toBe('https://proxy.internal/base/v1/responses');
+  });
+
   it('returns normalized final error when all endpoints fail', async () => {
     fetchMock.mockResolvedValueOnce(toUndiciResponse(new Response(JSON.stringify({
       error: { message: 'upstream_error', type: 'upstream_error' },

src/server/routes/proxy/endpointFlow.ts

@@ -63,6 +63,12 @@ type ExecuteEndpointFlowInput = {
   onDowngrade?: (ctx: EndpointAttemptContext & { errText: string }) => void | Promise<void>;
 };
 
+function buildAbsoluteUrl(base: string, path: string): string {
+  const normalizedBase = base.replace(/\/+$/, '');
+  const normalizedPath = path.replace(/^\/+/, '');
+  return normalizedPath ? `${normalizedBase}/${normalizedPath}` : normalizedBase;
+}
+
 export async function executeEndpointFlow(input: ExecuteEndpointFlowInput): Promise<EndpointFlowResult> {
   const endpointCount = input.endpointCandidates.length;
   if (endpointCount <= 0) {
@@ -80,7 +86,10 @@ export async function executeEndpointFlow(input: ExecuteEndpointFlowInput): Prom
   for (let endpointIndex = 0; endpointIndex < endpointCount; endpointIndex += 1) {
     const endpoint = input.endpointCandidates[endpointIndex] as UpstreamEndpoint;
     const request = input.buildRequest(endpoint, endpointIndex);
-    const targetUrl = buildUpstreamUrl(input.siteUrl, request.path);
+    const defaultTarget = buildUpstreamUrl(input.siteUrl, request.path);
+    const targetUrl = input.proxyUrl
+      ? buildAbsoluteUrl(input.proxyUrl, request.path)
+      : defaultTarget;
 
     let response = input.dispatchRequest
       ? await input.dispatchRequest(request, targetUrl)

src/server/routes/proxy/responses.codex-oauth.test.ts

@@ -16,10 +16,14 @@ const resolveProxyUsageWithSelfLogFallbackMock = vi.fn(async ({ usage }: any) =>
 }));
 const refreshOauthAccessTokenSingleflightMock = vi.fn();
 const recordOauthQuotaResetHintMock = vi.fn();
+const insertedProxyLogs: Record<string, unknown>[] = [];
 const dbInsertMock = vi.fn((_arg?: any) => ({
-  values: () => ({
-    run: () => undefined,
-  }),
+  values: (values: Record<string, unknown>) => {
+    insertedProxyLogs.push(values);
+    return {
+      run: () => undefined,
+    };
+  },
 }));
 
 vi.mock('undici', () => ({
@@ -117,6 +121,7 @@ describe('responses proxy codex oauth refresh', () => {
     refreshOauthAccessTokenSingleflightMock.mockReset();
     recordOauthQuotaResetHintMock.mockReset();
     dbInsertMock.mockClear();
+    insertedProxyLogs.length = 0;
 
     selectChannelMock.mockReturnValue({
       channel: { id: 11, routeId: 22 },
@@ -431,4 +436,35 @@ describe('responses proxy codex oauth refresh', () => {
     expect(secondBody.store).toBe(false);
     expect(secondBody.stream).toBe(true);
   });
+
+  it('does not record success when a streaming responses request ends with response.failed', async () => {
+    fetchMock.mockResolvedValue(createSseResponse([
+      'event: response.created\n',
+      'data: {"type":"response.created","response":{"id":"resp_codex_failed","model":"gpt-5.4","created_at":1706000000,"status":"in_progress","output":[]}}\n\n',
+      'event: response.failed\n',
+      'data: {"type":"response.failed","response":{"id":"resp_codex_failed","model":"gpt-5.4","status":"failed","error":{"message":"tool execution failed"}}}\n\n',
+      'data: [DONE]\n\n',
+    ]));
+
+    const response = await app.inject({
+      method: 'POST',
+      url: '/v1/responses',
+      payload: {
+        model: 'gpt-5.4',
+        input: 'hello codex',
+        stream: true,
+      },
+    });
+
+    expect(response.statusCode).toBe(200);
+    expect(response.body).toContain('response.failed');
+    expect(response.body).not.toContain('response.completed');
+    expect(recordSuccessMock).not.toHaveBeenCalled();
+    expect(recordFailureMock).toHaveBeenCalledTimes(1);
+    expect(insertedProxyLogs.at(-1)).toMatchObject({
+      status: 'failed',
+      httpStatus: 200,
+    });
+    expect(String(insertedProxyLogs.at(-1)?.errorMessage || '')).toContain('tool execution failed');
+  });
 });

src/server/routes/proxy/responses.ts

@@ -457,9 +457,32 @@ export async function responsesProxyRoute(app: FastifyInstance) {
               reply.raw.write(chunk);
             },
           });
-          await streamSession.run(reader, reply.raw);
+          const streamResult = await streamSession.run(reader, reply.raw);
 
           const latency = Date.now() - startTime;
+          if (streamResult.status === 'failed') {
+            tokenRouter.recordFailure(selected.channel.id);
+            logProxy(
+              selected,
+              requestedModel,
+              'failed',
+              200,
+              latency,
+              streamResult.errorMessage,
+              retryCount,
+              downstreamPath,
+              parsedUsage.promptTokens,
+              parsedUsage.completionTokens,
+              parsedUsage.totalTokens,
+              0,
+              null,
+              successfulUpstreamPath,
+              clientContext,
+              logDownstreamApiKeyId ? downstreamApiKeyId : null,
+            );
+            return;
+          }
+
           const resolvedUsage = await resolveProxyUsageWithSelfLogFallback({
             site: selected.site,
             account: selected.account,