bloby-bot 0.47.3 → 0.47.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bloby-bot",
-  "version": "0.47.3",
+  "version": "0.47.5",
   "releaseNotes": [
     "1. # voice note (PTT bubble)",
     "2. # audio file + caption",

package/supervisor/harnesses/pi/providers/stream-google.ts

@@ -8,6 +8,7 @@
  * Endpoint: POST {baseUrl}/models/{modelId}:streamGenerateContent?alt=sse&key={apiKey}
  * Stream:   SSE — each `data: {...}` is one candidate update.
  */
+import { log } from '../../../../shared/logger.js';
 import type {
   PiStreamRequest,
   PiStreamEvent,
@@ -17,37 +18,72 @@ import type {
 } from './types.js';
 
 /** Walk an SSE byte stream and yield each parsed JSON event. */
-async function* parseSse(res: Response): AsyncIterable<any> {
+async function* parseSse(res: Response, dbg: { firstBytes: string }): AsyncIterable<any> {
   if (!res.body) return;
   const reader = res.body.getReader();
   const decoder = new TextDecoder();
   let buffer = '';
+  let totalBytes = 0;
   try {
     while (true) {
       const { value, done } = await reader.read();
       if (done) break;
+      if (value) totalBytes += value.byteLength;
       buffer += decoder.decode(value, { stream: true });
-      // SSE event boundary is a blank line. Process every complete event in buffer.
+      if (!dbg.firstBytes && buffer.length > 0) {
+        dbg.firstBytes = buffer.slice(0, 800);
+      }
+      // SSE event boundary is a blank line. Accept both LF and CRLF separators.
       let idx;
-      while ((idx = buffer.indexOf('\n\n')) !== -1) {
+      while (
+        (idx = (() => {
+          const a = buffer.indexOf('\n\n');
+          const b = buffer.indexOf('\r\n\r\n');
+          if (a < 0) return b;
+          if (b < 0) return a;
+          return Math.min(a, b);
+        })()) !== -1
+      ) {
+        const isCrlf = buffer.slice(idx, idx + 4) === '\r\n\r\n';
         const raw = buffer.slice(0, idx);
-        buffer = buffer.slice(idx + 2);
-        const dataLines = raw.split('\n').filter((l) => l.startsWith('data:'));
-        if (!dataLines.length) continue;
-        const data = dataLines.map((l) => l.slice(5).trimStart()).join('\n');
-        if (!data || data === '[DONE]') continue;
-        try {
-          yield JSON.parse(data);
-        } catch {
-          // Skip malformed chunks rather than killing the whole turn.
-        }
+        buffer = buffer.slice(idx + (isCrlf ? 4 : 2));
+        const parsed = parseSseEvent(raw);
+        if (parsed !== undefined) yield parsed;
       }
     }
+    // Flush whatever remains — Gemini's final event may not have a trailing blank line.
+    buffer += decoder.decode();
+    if (buffer.trim()) {
+      const parsed = parseSseEvent(buffer);
+      if (parsed !== undefined) yield parsed;
+    }
   } finally {
     try { reader.releaseLock(); } catch {}
+    dbg.firstBytes = dbg.firstBytes || `(zero bytes — total=${totalBytes})`;
   }
 }
 
+function parseSseEvent(raw: string): any | undefined {
+  // Standard SSE: one or more `data:` lines per event. Concatenate their payloads.
+  const lines = raw.split(/\r?\n/);
+  const dataLines = lines
+    .filter((l) => l.startsWith('data:'))
+    .map((l) => l.slice(5).trimStart());
+  if (!dataLines.length) {
+    // Fallback: some servers omit the `data:` prefix and send pure JSON per event.
+    const trimmed = raw.trim();
+    if (!trimmed || trimmed === '[DONE]') return undefined;
+    // Strip a leading JSON-array delimiter if Gemini is returning array-stream
+    // instead of SSE (alt=sse not honored).
+    const candidate = trimmed.replace(/^[\[,]/, '').replace(/[\],]$/, '').trim();
+    if (!candidate) return undefined;
+    try { return JSON.parse(candidate); } catch { return undefined; }
+  }
+  const data = dataLines.join('\n');
+  if (!data || data === '[DONE]') return undefined;
+  try { return JSON.parse(data); } catch { return undefined; }
+}
+
 function toGeminiRole(role: PiMessage['role']): 'user' | 'model' {
   return role === 'assistant' ? 'model' : 'user';
 }
@@ -149,9 +185,19 @@ export async function* streamGoogle(req: PiStreamRequest): AsyncIterable<PiStrea
   let lastFinish: string | undefined;
   let promptBlockReason: string | undefined;
   let usage: { inputTokens?: number; outputTokens?: number } | undefined;
+  // Debug counters — drop once this stabilises.
+  let chunkCount = 0;
+  let thoughtPartCount = 0;
+  let emptyTextPartCount = 0;
+  let firstChunkSummary = '';
+  const dbg = { firstBytes: '' };
 
   try {
-    for await (const chunk of parseSse(res)) {
+    for await (const chunk of parseSse(res, dbg)) {
+      chunkCount++;
+      if (chunkCount === 1) {
+        try { firstChunkSummary = JSON.stringify(chunk).slice(0, 600); } catch {}
+      }
       // The whole prompt can be rejected before we even get a candidate.
       if (chunk?.promptFeedback?.blockReason) {
         promptBlockReason = chunk.promptFeedback.blockReason;
@@ -161,10 +207,12 @@ export async function* streamGoogle(req: PiStreamRequest): AsyncIterable<PiStrea
       for (const part of parts) {
         // Thinking models emit reasoning parts with `thought: true`. They
         // shouldn't be shown to the user as part of the visible answer.
-        if (part?.thought) continue;
+        if (part?.thought) { thoughtPartCount++; continue; }
         if (typeof part?.text === 'string' && part.text.length > 0) {
           accumulated += part.text;
           yield { type: 'text_delta', delta: part.text };
+        } else {
+          emptyTextPartCount++;
         }
       }
       if (candidate?.finishReason) lastFinish = candidate.finishReason;
@@ -185,6 +233,19 @@ export async function* streamGoogle(req: PiStreamRequest): AsyncIterable<PiStrea
     return;
   }
 
+  log.info(
+    `[pi/google] stream done — chunks=${chunkCount} text=${accumulated.length} ` +
+    `thoughtParts=${thoughtPartCount} emptyTextParts=${emptyTextPartCount} ` +
+    `finishReason=${lastFinish || 'none'} ` +
+    `promptTok=${usage?.inputTokens ?? '?'} outTok=${usage?.outputTokens ?? '?'}`,
+  );
+  if (chunkCount > 0 && !accumulated) {
+    log.info(`[pi/google] first chunk (truncated): ${firstChunkSummary}`);
+  } else if (chunkCount === 0) {
+    log.warn(`[pi/google] SSE stream parsed zero chunks — content-type=${res.headers.get('content-type') || '?'}`);
+    log.warn(`[pi/google] first raw bytes: ${JSON.stringify(dbg.firstBytes)}`);
+  }
+
   // Prompt-level block: nothing came back at all.
   if (promptBlockReason) {
     yield { type: 'error', error: `Gemini blocked the prompt (${promptBlockReason}).` };
@@ -199,7 +260,10 @@ export async function* streamGoogle(req: PiStreamRequest): AsyncIterable<PiStrea
     const reason = lastFinish && lastFinish !== 'STOP' && lastFinish !== 'FINISH_REASON_STOP'
       ? lastFinish
       : undefined;
-    yield { type: 'error', error: finishReasonMessage(reason) };
+    const hint = thoughtPartCount > 0 && !lastFinish
+      ? ' (model emitted thinking but never the final answer — try a non-thinking model like gemini-2.5-flash, or raise maxOutputTokens)'
+      : '';
+    yield { type: 'error', error: finishReasonMessage(reason) + hint };
     yield { type: 'done', stopReason: mapStopReason(lastFinish), usage };
     return;
   }