From fbcaad6c23995e97675d91b7a70a83baf98bd8e9 Mon Sep 17 00:00:00 2001 From: "elliot.fouchy" Date: Fri, 30 Oct 2026 23:51:33 +0100 Subject: [PATCH 1/2] fix: preserve Gemini refusals and zero-output usage --- src/handlers/streamHandler.test.ts | 164 +++++++++++++++++- .../google-vertex-ai/chatComplete.ts | 32 ++-- src/providers/google-vertex-ai/types.ts | 4 +- src/providers/google/chatComplete.ts | 52 ++++-- 4 files changed, 220 insertions(+), 32 deletions(-) diff --git a/src/handlers/streamHandler.test.ts b/src/handlers/streamHandler.test.ts index 70f99e6a9..b09fa9ad4 100644 --- a/src/handlers/streamHandler.test.ts +++ b/src/handlers/streamHandler.test.ts @@ -1,9 +1,171 @@ -import { BEDROCK, OPEN_AI, PERPLEXITY_AI } from '../globals'; +import { + BEDROCK, + GOOGLE, + GOOGLE_VERTEX_AI, + OPEN_AI, + PERPLEXITY_AI, +} from '../globals'; +import { + GoogleChatCompleteResponseTransform, + GoogleChatCompleteStreamChunkTransform, +} from '../providers/google/chatComplete'; +import { + GoogleChatCompleteResponseTransform as vertexResponse, + GoogleChatCompleteStreamChunkTransform as vertexStream, +} from '../providers/google-vertex-ai/chatComplete'; import { PerplexityAIChatCompleteStreamChunkTransform } from '../providers/perplexity-ai/chatComplete'; import { BedrockChatCompleteStreamChunkTransform } from '../providers/bedrock/chatComplete'; import { getStreamModeSplitPattern } from '../utils'; import { handleStreamingMode, readStream } from './streamHandler'; +describe.each([ + [ + GOOGLE, + GoogleChatCompleteResponseTransform, + GoogleChatCompleteStreamChunkTransform, + ], + [GOOGLE_VERTEX_AI, vertexResponse, vertexStream], +] as const)( + '%s Gemini response metadata', + (provider, responseTransform, streamTransform) => { + const transform = (payload: object) => + JSON.parse( + streamTransform(JSON.stringify(payload), 'test', {}, false).slice(6) + ); + const blocked = { + modelVersion: 'gemini-3-flash-preview', + promptFeedback: { + blockReason: 'SAFETY', + blockReasonMessage: 'Test prompt blocked', + }, + }; + + it('preserves prompt blocks in JSON and SSE instead of returning an empty completion', () => { + for (const result of [ + responseTransform(blocked as any, 200, new Headers(), false), + transform(blocked), + ]) { + expect(result).toMatchObject({ + provider, + error: { code: 'content_policy_violation', type: 'SAFETY' }, + }); + expect((result as any).error.message).toContain('Test prompt blocked'); + expect((result as any).usage).toBeUndefined(); + } + }); + + it.each([0, undefined])( + 'preserves usage when candidatesTokenCount is %s', + (candidatesTokenCount) => { + expect( + transform({ + usageMetadata: { + promptTokenCount: 10, + candidatesTokenCount, + totalTokenCount: 15, + thoughtsTokenCount: 5, + }, + }).usage + ).toMatchObject({ + prompt_tokens: 10, + completion_tokens: 5, + total_tokens: 15, + }); + } + ); + + it('preserves prompt-only usage and never invents a missing usage block', () => { + expect( + transform({ + usageMetadata: { promptTokenCount: 10, totalTokenCount: 10 }, + }).usage + ).toMatchObject({ + prompt_tokens: 10, + completion_tokens: 0, + total_tokens: 10, + }); + expect(transform({ candidates: [] }).usage).toBeUndefined(); + expect( + transform({ + promptFeedback: { blockReason: 'BLOCKED_REASON_UNSPECIFIED' }, + }).error + ).toBeUndefined(); + }); + + it('keeps upstream errors carried inside a successful HTTP stream', () => { + expect( + transform({ + error: { + code: 429, + status: 'RESOURCE_EXHAUSTED', + message: 'Quota exhausted', + }, + }) + ).toMatchObject({ + provider, + error: { + type: 'RESOURCE_EXHAUSTED', + message: expect.stringContaining('Quota exhausted'), + }, + }); + }); + + it('preserves filtered candidates without content parts and their reported usage', () => { + // Live Vertex safety-filter response to our synthetic test prompt. + const result = transform({ + candidates: [{ content: { role: 'model' }, finishReason: 'SAFETY' }], + usageMetadata: { + promptTokenCount: 12, + candidatesTokenCount: 3, + thoughtsTokenCount: 121, + totalTokenCount: 136, + }, + }); + expect(result.error).toBeUndefined(); + expect(result.choices[0].finish_reason).toBe('content_filter'); + expect(result.usage).toMatchObject({ + prompt_tokens: 12, + completion_tokens: 124, + total_tokens: 136, + }); + }); + } +); + +it('preserves Vertex prompt-block errors across fragmented SSE transport', async () => { + const bytes = new TextEncoder().encode( + 'data: ' + + JSON.stringify({ + promptFeedback: { blockReason: 'PROHIBITED_CONTENT' }, + modelVersion: 'gemini-3-flash-preview', + }) + + '\r\n\r\n' + ); + const response = handleStreamingMode( + new Response( + new ReadableStream({ + start(controller) { + for (const byte of bytes) controller.enqueue(Uint8Array.of(byte)); + controller.close(); + }, + }), + { headers: { 'content-type': 'text/event-stream' } } + ), + GOOGLE_VERTEX_AI, + vertexStream, + '/publishers/google/models/gemini-3-flash-preview:streamGenerateContent', + false, + { model: 'gemini-3-flash-preview' }, + 'chatComplete', + { beforeRequestHooksResult: [], afterRequestHooksResult: [] } + ); + const events = (await response.text()).trim().split('\n\n'); + expect(events).toHaveLength(1); + expect(JSON.parse(events[0].slice(6))).toMatchObject({ + error: { code: 'content_policy_violation', type: 'PROHIBITED_CONTENT' }, + }); +}); + describe('Bedrock Converse stream errors', () => { // AWS EventStream frame: prelude, headers, JSON payload, message CRC. // The reader ignores headers and CRCs; exercise its actual binary framing. diff --git a/src/providers/google-vertex-ai/chatComplete.ts b/src/providers/google-vertex-ai/chatComplete.ts index 7d5739b1e..30fe576c8 100644 --- a/src/providers/google-vertex-ai/chatComplete.ts +++ b/src/providers/google-vertex-ai/chatComplete.ts @@ -28,6 +28,7 @@ import { SYSTEM_INSTRUCTION_DISABLED_MODELS, transformOpenAIRoleToGoogleRole, transformToolChoiceForGemini, + GoogleErrorResponseTransform, } from '../google/chatComplete'; import { GOOGLE_GENERATE_CONTENT_FINISH_REASON } from '../google/types'; import { @@ -482,17 +483,12 @@ export const GoogleChatCompleteResponseTransform: ( ); } - if (responseStatus !== 200 && 'error' in response) { - const { error } = response; - return generateErrorResponse( - { - message: error.message, - type: error.status, - param: null, - code: String(error.code), - }, + if (!Array.isArray(response)) { + const errorResponse = GoogleErrorResponseTransform( + response, GOOGLE_VERTEX_AI ); + if (errorResponse) return errorResponse; } // sometimes vertex gemini returns usageMetadata without candidates @@ -723,14 +719,20 @@ export const GoogleChatCompleteStreamChunkTransform: ( return `data: ${chunk}\n\n`; } - let parsedChunk: GoogleGenerateContentResponse = JSON.parse(chunk); + const parsedChunk: GoogleGenerateContentResponse = JSON.parse(chunk); + + const errorResponse = GoogleErrorResponseTransform( + parsedChunk, + GOOGLE_VERTEX_AI + ); + if (errorResponse) return `data: ${JSON.stringify(errorResponse)}\n\n`; let usageMetadata; if (parsedChunk.usageMetadata) { usageMetadata = { prompt_tokens: parsedChunk.usageMetadata.promptTokenCount, completion_tokens: - parsedChunk.usageMetadata.candidatesTokenCount + + (parsedChunk.usageMetadata.candidatesTokenCount ?? 0) + (parsedChunk.usageMetadata.thoughtsTokenCount ?? 0), total_tokens: parsedChunk.usageMetadata.totalTokenCount, completion_tokens_details: { @@ -790,7 +792,7 @@ export const GoogleChatCompleteStreamChunkTransform: ( ) : null; let message: any = { role: 'assistant', content: '' }; - if (generation.content?.parts[0]?.text) { + if (generation.content?.parts?.[0]?.text) { const contentBlocks = []; let content = ''; for (const part of generation.content.parts) { @@ -816,7 +818,7 @@ export const GoogleChatCompleteStreamChunkTransform: ( content_blocks: contentBlocks, }), }; - } else if (generation.content?.parts[0]?.functionCall) { + } else if (generation.content?.parts?.[0]?.functionCall) { message = { role: 'assistant', tool_calls: generation.content.parts.map((part, idx) => { @@ -837,7 +839,7 @@ export const GoogleChatCompleteStreamChunkTransform: ( } }), }; - } else if (generation.content?.parts[0]?.inlineData) { + } else if (generation.content?.parts?.[0]?.inlineData) { const part = generation.content.parts[0]; const contentBlocks = [ { @@ -867,7 +869,7 @@ export const GoogleChatCompleteStreamChunkTransform: ( : {}), }; }) ?? [], - ...(parsedChunk.usageMetadata?.candidatesTokenCount && { + ...(usageMetadata && { usage: usageMetadata, }), }; diff --git a/src/providers/google-vertex-ai/types.ts b/src/providers/google-vertex-ai/types.ts index 5cebbcbc8..06cabe50e 100644 --- a/src/providers/google-vertex-ai/types.ts +++ b/src/providers/google-vertex-ai/types.ts @@ -58,7 +58,9 @@ export interface GoogleResponseCandidate { export interface GoogleGenerateContentResponse { modelVersion: string; candidates: GoogleResponseCandidate[]; - promptFeedback: { + promptFeedback?: { + blockReason?: string; + blockReasonMessage?: string; safetyRatings: { category: string; probability: string; diff --git a/src/providers/google/chatComplete.ts b/src/providers/google/chatComplete.ts index 9d8bc5c14..2a91e3feb 100644 --- a/src/providers/google/chatComplete.ts +++ b/src/providers/google/chatComplete.ts @@ -508,7 +508,7 @@ export const GoogleChatCompleteConfig: ProviderConfig = { export interface GoogleErrorResponse { error: { - code: string; + code: string | number; message: string; status: string; details: Array>; @@ -563,7 +563,9 @@ export interface GoogleResponseCandidate { interface GoogleGenerateContentResponse { modelVersion: string; candidates: GoogleResponseCandidate[]; - promptFeedback: { + promptFeedback?: { + blockReason?: string; + blockReasonMessage?: string; safetyRatings: { category: string; probability: string; @@ -587,7 +589,9 @@ interface GoogleGenerateContentResponse { } export const GoogleErrorResponseTransform: ( - response: GoogleErrorResponse, + response: + | GoogleErrorResponse + | Pick, provider?: string ) => ErrorResponse | undefined = (response, provider = GOOGLE) => { if ('error' in response) { @@ -596,7 +600,26 @@ export const GoogleErrorResponseTransform: ( message: response.error.message ?? '', type: response.error.status ?? null, param: null, - code: response.error.code ?? null, + code: response.error.code == null ? null : String(response.error.code), + }, + provider + ); + } + + const feedback = + 'promptFeedback' in response ? response.promptFeedback : undefined; + if ( + feedback?.blockReason && + feedback.blockReason !== 'BLOCKED_REASON_UNSPECIFIED' + ) { + return generateErrorResponse( + { + message: + feedback.blockReasonMessage || + `Prompt blocked: ${feedback.blockReason}`, + type: feedback.blockReason, + param: null, + code: 'content_policy_violation', }, provider ); @@ -616,12 +639,8 @@ export const GoogleChatCompleteResponseTransform: ( _responseHeaders, strictOpenAiCompliance ) => { - if (responseStatus !== 200) { - const errorResponse = GoogleErrorResponseTransform( - response as GoogleErrorResponse - ); - if (errorResponse) return errorResponse; - } + const errorResponse = GoogleErrorResponseTransform(response); + if (errorResponse) return errorResponse; if ('candidates' in response) { const { @@ -764,12 +783,15 @@ export const GoogleChatCompleteStreamChunkTransform: ( const parsedChunk: GoogleGenerateContentResponse = JSON.parse(chunk); + const errorResponse = GoogleErrorResponseTransform(parsedChunk); + if (errorResponse) return `data: ${JSON.stringify(errorResponse)}\n\n`; + let usageMetadata; if (parsedChunk.usageMetadata) { usageMetadata = { prompt_tokens: parsedChunk.usageMetadata.promptTokenCount, completion_tokens: - parsedChunk.usageMetadata.candidatesTokenCount + + (parsedChunk.usageMetadata.candidatesTokenCount ?? 0) + (parsedChunk.usageMetadata.thoughtsTokenCount ?? 0), total_tokens: parsedChunk.usageMetadata.totalTokenCount, completion_tokens_details: { @@ -814,7 +836,7 @@ export const GoogleChatCompleteStreamChunkTransform: ( strictOpenAiCompliance ) : null; - if (generation.content?.parts[0]?.text) { + if (generation.content?.parts?.[0]?.text) { const contentBlocks = []; let content = ''; for (const part of generation.content.parts) { @@ -838,7 +860,7 @@ export const GoogleChatCompleteStreamChunkTransform: ( ...(!strictOpenAiCompliance && contentBlocks.length && { content_blocks: contentBlocks }), }; - } else if (generation.content?.parts[0]?.functionCall) { + } else if (generation.content?.parts?.[0]?.functionCall) { message = { role: 'assistant', tool_calls: generation.content.parts.map((part, idx) => { @@ -859,7 +881,7 @@ export const GoogleChatCompleteStreamChunkTransform: ( } }), }; - } else if (generation.content?.parts[0]?.inlineData) { + } else if (generation.content?.parts?.[0]?.inlineData) { const part = generation.content.parts[0]; const contentBlocks = [ { @@ -886,7 +908,7 @@ export const GoogleChatCompleteStreamChunkTransform: ( : {}), }; }) ?? [], - ...(parsedChunk.usageMetadata?.candidatesTokenCount && { + ...(usageMetadata && { usage: usageMetadata, }), })}` + '\n\n' From 1efffefa3149a030934cfde75fc4f606767ad5b6 Mon Sep 17 00:00:00 2001 From: "elliot.fouchy" Date: Sat, 31 Oct 2026 00:08:25 +0100 Subject: [PATCH 2/2] fix: reject unspecified Gemini blocks and retain SSE error usage --- src/handlers/streamHandler.test.ts | 35 ++++++++++++++++--- .../google-vertex-ai/chatComplete.ts | 9 ++++- src/providers/google/chatComplete.ts | 14 +++++--- 3 files changed, 47 insertions(+), 11 deletions(-) diff --git a/src/handlers/streamHandler.test.ts b/src/handlers/streamHandler.test.ts index b09fa9ad4..91348e0d1 100644 --- a/src/handlers/streamHandler.test.ts +++ b/src/handlers/streamHandler.test.ts @@ -85,11 +85,30 @@ describe.each([ total_tokens: 10, }); expect(transform({ candidates: [] }).usage).toBeUndefined(); - expect( - transform({ - promptFeedback: { blockReason: 'BLOCKED_REASON_UNSPECIFIED' }, - }).error - ).toBeUndefined(); + }); + + it('rejects Google’s documented unspecified prompt block and retains its SSE usage', () => { + const payload = { + promptFeedback: { blockReason: 'BLOCKED_REASON_UNSPECIFIED' }, + usageMetadata: { promptTokenCount: 7, totalTokenCount: 7 }, + }; + for (const result of [ + responseTransform(payload as any, 200, new Headers(), false), + transform(payload), + ]) { + expect(result).toMatchObject({ + provider, + error: { + code: 'content_policy_violation', + type: 'BLOCKED_REASON_UNSPECIFIED', + }, + }); + } + expect(transform(payload).usage).toMatchObject({ + prompt_tokens: 7, + completion_tokens: 0, + total_tokens: 7, + }); }); it('keeps upstream errors carried inside a successful HTTP stream', () => { @@ -100,6 +119,11 @@ describe.each([ status: 'RESOURCE_EXHAUSTED', message: 'Quota exhausted', }, + usageMetadata: { + promptTokenCount: 7, + candidatesTokenCount: 2, + totalTokenCount: 9, + }, }) ).toMatchObject({ provider, @@ -107,6 +131,7 @@ describe.each([ type: 'RESOURCE_EXHAUSTED', message: expect.stringContaining('Quota exhausted'), }, + usage: { prompt_tokens: 7, completion_tokens: 2, total_tokens: 9 }, }); }); diff --git a/src/providers/google-vertex-ai/chatComplete.ts b/src/providers/google-vertex-ai/chatComplete.ts index 30fe576c8..807cbef43 100644 --- a/src/providers/google-vertex-ai/chatComplete.ts +++ b/src/providers/google-vertex-ai/chatComplete.ts @@ -725,7 +725,6 @@ export const GoogleChatCompleteStreamChunkTransform: ( parsedChunk, GOOGLE_VERTEX_AI ); - if (errorResponse) return `data: ${JSON.stringify(errorResponse)}\n\n`; let usageMetadata; if (parsedChunk.usageMetadata) { @@ -776,6 +775,14 @@ export const GoogleChatCompleteStreamChunkTransform: ( }; } + if (errorResponse) { + return `data: ${JSON.stringify({ + ...errorResponse, + model: parsedChunk.modelVersion, + usage: usageMetadata, + })}\n\n`; + } + const dataChunk = { id: fallbackId, object: 'chat.completion.chunk', diff --git a/src/providers/google/chatComplete.ts b/src/providers/google/chatComplete.ts index 2a91e3feb..4c42a05d9 100644 --- a/src/providers/google/chatComplete.ts +++ b/src/providers/google/chatComplete.ts @@ -608,10 +608,7 @@ export const GoogleErrorResponseTransform: ( const feedback = 'promptFeedback' in response ? response.promptFeedback : undefined; - if ( - feedback?.blockReason && - feedback.blockReason !== 'BLOCKED_REASON_UNSPECIFIED' - ) { + if (feedback?.blockReason) { return generateErrorResponse( { message: @@ -784,7 +781,6 @@ export const GoogleChatCompleteStreamChunkTransform: ( const parsedChunk: GoogleGenerateContentResponse = JSON.parse(chunk); const errorResponse = GoogleErrorResponseTransform(parsedChunk); - if (errorResponse) return `data: ${JSON.stringify(errorResponse)}\n\n`; let usageMetadata; if (parsedChunk.usageMetadata) { @@ -820,6 +816,14 @@ export const GoogleChatCompleteStreamChunkTransform: ( }; } + if (errorResponse) { + return `data: ${JSON.stringify({ + ...errorResponse, + model: parsedChunk.modelVersion, + usage: usageMetadata, + })}\n\n`; + } + return ( `data: ${JSON.stringify({ id: fallbackId,