mixdog 0.7.8 → 0.7.12

package/src/agent/orchestrator/providers/gemini.mjs

@@ -8,10 +8,14 @@ import { withRetry } from './retry-classifier.mjs';
 import { traceBridgeUsage, appendBridgeTrace } from '../bridge-trace.mjs';
 import {
     PROVIDER_FIRST_BYTE_TIMEOUT_MS,
+    PROVIDER_NONSTREAM_TOTAL_TIMEOUT_MS,
     PROVIDER_GENERATE_TOTAL_TIMEOUT_MS,
     PROVIDER_MAX_BEFORE_WARN_MS,
+    PROVIDER_SSE_IDLE_TIMEOUT_MS,
+    PROVIDER_SSE_IDLE_WATCHDOG_ENABLED,
     providerTimeoutError,
     resolveTimeoutMs,
+    createTimeoutSignal,
 } from '../stall-policy.mjs';
 import { getLlmDispatcher, preconnect } from '../../../shared/llm/http-agent.mjs';
 
@@ -357,6 +361,323 @@ function runGeminiOperationWithTimeout({ label, timeoutMs, signal, run }) {
     });
 }
 
+function geminiTruncatedStreamError(message) {
+    return Object.assign(
+        new Error(message),
+        { name: 'TruncatedStreamError', code: 'TRUNCATED_STREAM', truncatedStream: true },
+    );
+}
+
+/**
+ * Aggregate streamed GenerateContentResponse chunks into one response object
+ * (same shape as a non-streaming generateContent JSON body).
+ * Mirrors @google/generative-ai aggregateResponses().
+ */
+function aggregateGeminiStreamChunks(responses) {
+    const lastResponse = responses[responses.length - 1];
+    const aggregatedResponse = {
+        promptFeedback: lastResponse?.promptFeedback,
+    };
+    for (const response of responses) {
+        if (response?.candidates) {
+            let candidateIndex = 0;
+            for (const candidate of response.candidates) {
+                if (!aggregatedResponse.candidates) aggregatedResponse.candidates = [];
+                if (!aggregatedResponse.candidates[candidateIndex]) {
+                    aggregatedResponse.candidates[candidateIndex] = { index: candidateIndex };
+                }
+                const aggCand = aggregatedResponse.candidates[candidateIndex];
+                aggCand.citationMetadata = candidate.citationMetadata;
+                aggCand.groundingMetadata = candidate.groundingMetadata;
+                aggCand.finishReason = candidate.finishReason;
+                aggCand.finishMessage = candidate.finishMessage;
+                aggCand.safetyRatings = candidate.safetyRatings;
+                if (candidate.content?.parts) {
+                    if (!aggCand.content) {
+                        aggCand.content = {
+                            role: candidate.content.role || 'user',
+                            parts: [],
+                        };
+                    }
+                    for (const part of candidate.content.parts) {
+                        const newPart = {};
+                        if (part.text) newPart.text = part.text;
+                        if (part.functionCall) newPart.functionCall = part.functionCall;
+                        if (part.thoughtSignature) newPart.thoughtSignature = part.thoughtSignature;
+                        if (part.thought_signature) newPart.thought_signature = part.thought_signature;
+                        if (part.executableCode) newPart.executableCode = part.executableCode;
+                        if (part.codeExecutionResult) newPart.codeExecutionResult = part.codeExecutionResult;
+                        if (Object.keys(newPart).length === 0) newPart.text = '';
+                        aggCand.content.parts.push(newPart);
+                    }
+                }
+                candidateIndex++;
+            }
+        }
+        if (response?.usageMetadata) aggregatedResponse.usageMetadata = response.usageMetadata;
+    }
+    return aggregatedResponse;
+}
+
+function assertGeminiStreamCompleted({ sawStreamChunk, finishReason, label }) {
+    if (!sawStreamChunk) {
+        throw geminiTruncatedStreamError(`${label} truncated: empty stream`);
+    }
+    if (!finishReason) {
+        throw geminiTruncatedStreamError(`${label} truncated: no finishReason`);
+    }
+}
+
+async function consumeGeminiRestStreamResponse(response, { signal, onStreamDelta, label }) {
+    if (!response?.body) throw new Error(`${label}: missing response body`);
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = '';
+    const allChunks = [];
+    let sawStreamChunk = false;
+    let idleTimedOut = false;
+    let idleTimer = null;
+    let idleReject = null;
+
+    let firstByteTimer = setTimeout(() => {
+        try { reader.cancel('first byte timeout'); } catch {}
+        if (idleReject) {
+            const e = geminiTimeoutError(`${label} first byte`, GEMINI_FIRST_BYTE_TIMEOUT_MS);
+            const r = idleReject; idleReject = null; r(e);
+        }
+    }, GEMINI_FIRST_BYTE_TIMEOUT_MS);
+    if (firstByteTimer.unref) firstByteTimer.unref();
+
+    const clearFirstByteTimer = () => {
+        if (firstByteTimer) {
+            clearTimeout(firstByteTimer);
+            firstByteTimer = null;
+        }
+    };
+
+    const resetIdleTimer = () => {
+        if (!PROVIDER_SSE_IDLE_WATCHDOG_ENABLED) return;
+        if (idleTimer) clearTimeout(idleTimer);
+        idleTimer = setTimeout(() => {
+            idleTimedOut = true;
+            try { reader.cancel('SSE idle timeout'); } catch {}
+            if (idleReject) {
+                const e = geminiTimeoutError(`${label} SSE idle`, PROVIDER_SSE_IDLE_TIMEOUT_MS);
+                const r = idleReject; idleReject = null; r(e);
+            }
+        }, PROVIDER_SSE_IDLE_TIMEOUT_MS);
+        if (idleTimer.unref) idleTimer.unref();
+    };
+
+    const onAbort = () => {
+        try {
+            const c = reader.cancel('aborted');
+            if (c && typeof c.catch === 'function') c.catch(() => {});
+        } catch {}
+    };
+
+    if (signal) {
+        if (signal.aborted) {
+            const reason = signal.reason;
+            throw reason instanceof Error ? reason : new Error(`${label} aborted`);
+        }
+        signal.addEventListener('abort', onAbort, { once: true });
+    }
+
+    try {
+        resetIdleTimer();
+        while (true) {
+            let chunk;
+            try {
+                chunk = await new Promise((resolve, reject) => {
+                    idleReject = reject;
+                    reader.read().then(resolve, reject);
+                });
+            } catch (err) {
+                if (idleTimedOut) {
+                    throw geminiTimeoutError(`${label} SSE idle`, PROVIDER_SSE_IDLE_TIMEOUT_MS);
+                }
+                if (signal?.aborted) {
+                    const reason = signal.reason;
+                    throw reason instanceof Error ? reason : new Error(`${label} aborted`);
+                }
+                throw err;
+            } finally {
+                idleReject = null;
+            }
+            const { done, value } = chunk;
+            if (done) break;
+            resetIdleTimer();
+            buffer += decoder.decode(value, { stream: true });
+            let lineEnd;
+            while ((lineEnd = buffer.indexOf('\n')) >= 0) {
+                let line = buffer.slice(0, lineEnd);
+                buffer = buffer.slice(lineEnd + 1);
+                line = line.replace(/\r$/, '');
+                if (!line.startsWith('data: ')) continue;
+                const data = line.slice(6).trim();
+                if (!data || data === '[DONE]') continue;
+                let parsed;
+                try { parsed = JSON.parse(data); } catch { continue; }
+                if (!sawStreamChunk) {
+                    sawStreamChunk = true;
+                    clearFirstByteTimer();
+                }
+                allChunks.push(parsed);
+                try { onStreamDelta?.(); } catch {}
+            }
+        }
+        if (buffer.trim()) {
+            const line = buffer.trim().replace(/\r$/, '');
+            if (line.startsWith('data: ')) {
+                const data = line.slice(6).trim();
+                if (data && data !== '[DONE]') {
+                    try {
+                        const parsed = JSON.parse(data);
+                        if (!sawStreamChunk) {
+                            sawStreamChunk = true;
+                            clearFirstByteTimer();
+                        }
+                        allChunks.push(parsed);
+                        try { onStreamDelta?.(); } catch {}
+                    } catch { /* skip malformed tail */ }
+                }
+            }
+        }
+    } finally {
+        clearFirstByteTimer();
+        if (idleTimer) clearTimeout(idleTimer);
+        if (signal) signal.removeEventListener('abort', onAbort);
+        try { reader.releaseLock(); } catch {}
+    }
+
+    const aggregated = aggregateGeminiStreamChunks(allChunks);
+    const finishReason = aggregated.candidates?.[0]?.finishReason || null;
+    assertGeminiStreamCompleted({ sawStreamChunk, finishReason, label });
+    return aggregated;
+}
+
+async function consumeGeminiSdkStream(streamResult, { signal, onStreamDelta, label }) {
+    let sawStreamChunk = false;
+    let idleTimedOut = false;
+    let idleTimer = null;
+    let firstByteReject = null;
+    let firstByteTimer = null;
+    let inFlightReject = null;
+
+    const armFirstByteTimer = () => {
+        if (firstByteTimer) clearTimeout(firstByteTimer);
+        firstByteTimer = setTimeout(() => {
+            if (firstByteReject) {
+                const e = geminiTimeoutError(`${label} first byte`, GEMINI_FIRST_BYTE_TIMEOUT_MS);
+                const r = firstByteReject; firstByteReject = null; r(e);
+            }
+        }, GEMINI_FIRST_BYTE_TIMEOUT_MS);
+        if (firstByteTimer.unref) firstByteTimer.unref();
+    };
+
+    const clearFirstByteTimer = () => {
+        if (firstByteTimer) {
+            clearTimeout(firstByteTimer);
+            firstByteTimer = null;
+        }
+        firstByteReject = null;
+    };
+
+    const resetIdleTimer = () => {
+        if (!PROVIDER_SSE_IDLE_WATCHDOG_ENABLED) return;
+        if (idleTimer) clearTimeout(idleTimer);
+        idleTimer = setTimeout(() => {
+            idleTimedOut = true;
+            if (inFlightReject) {
+                const e = geminiTimeoutError(`${label} SSE idle`, PROVIDER_SSE_IDLE_TIMEOUT_MS);
+                const r = inFlightReject; inFlightReject = null; r(e);
+            }
+        }, PROVIDER_SSE_IDLE_TIMEOUT_MS);
+        if (idleTimer.unref) idleTimer.unref();
+    };
+
+    if (signal?.aborted) {
+        const reason = signal.reason;
+        throw reason instanceof Error ? reason : new Error(`${label} aborted`);
+    }
+
+    const iterator = streamResult.stream[Symbol.asyncIterator]();
+
+    try {
+        armFirstByteTimer();
+        resetIdleTimer();
+        while (true) {
+            if (idleTimedOut) {
+                throw geminiTimeoutError(`${label} SSE idle`, PROVIDER_SSE_IDLE_TIMEOUT_MS);
+            }
+            let step;
+            try {
+                step = await new Promise((resolve, reject) => {
+                    inFlightReject = reject;
+                    if (!sawStreamChunk) firstByteReject = reject;
+                    iterator.next().then(
+                        (value) => {
+                            inFlightReject = null;
+                            firstByteReject = null;
+                            resolve(value);
+                        },
+                        (err) => {
+                            inFlightReject = null;
+                            firstByteReject = null;
+                            reject(err);
+                        },
+                    );
+                });
+            } catch (err) {
+                if (idleTimedOut) {
+                    throw geminiTimeoutError(`${label} SSE idle`, PROVIDER_SSE_IDLE_TIMEOUT_MS);
+                }
+                if (signal?.aborted) {
+                    const reason = signal.reason;
+                    throw reason instanceof Error ? reason : new Error(`${label} aborted`);
+                }
+                throw err;
+            }
+            if (step.done) break;
+            if (!sawStreamChunk) {
+                sawStreamChunk = true;
+                clearFirstByteTimer();
+            }
+            resetIdleTimer();
+            try { onStreamDelta?.(); } catch {}
+        }
+        if (idleTimedOut) {
+            throw geminiTimeoutError(`${label} SSE idle`, PROVIDER_SSE_IDLE_TIMEOUT_MS);
+        }
+    } catch (err) {
+        clearFirstByteTimer();
+        if (signal?.aborted) {
+            const reason = signal.reason;
+            throw reason instanceof Error ? reason : new Error(`${label} aborted`);
+        }
+        throw err;
+    } finally {
+        clearFirstByteTimer();
+        if (idleTimer) clearTimeout(idleTimer);
+    }
+
+    let response;
+    try {
+        response = await streamResult.response;
+    } catch (err) {
+        if (signal?.aborted) {
+            const reason = signal.reason;
+            throw reason instanceof Error ? reason : new Error(`${label} aborted`);
+        }
+        throw err;
+    }
+    const raw = response?.candidates ? response : (response?.response || response);
+    const finishReason = raw?.candidates?.[0]?.finishReason || null;
+    assertGeminiStreamCompleted({ sawStreamChunk, finishReason, label });
+    return raw;
+}
+
 /**
  * Convert JSON Schema type string to Gemini SchemaType.
  * Gemini SDK uses its own enum instead of plain strings.
@@ -836,6 +1157,7 @@ export class GeminiProvider {
     async _doSend(messages, model, tools, sendOpts) {
         const opts = sendOpts || {};
         const signal = opts.signal || null;
+        const onStreamDelta = typeof opts.onStreamDelta === 'function' ? opts.onStreamDelta : null;
         if (signal?.aborted) {
             const reason = signal.reason;
             throw reason instanceof Error ? reason : new Error('Gemini request aborted by session close');
@@ -884,7 +1206,7 @@ export class GeminiProvider {
         let response;
         if (cachedContent) {
             const apiKey = this._getApiKey();
-            const genUrl = `https://generativelanguage.googleapis.com/v1beta/models/${encodeURIComponent(useModel)}:generateContent?key=${encodeURIComponent(apiKey)}`;
+            const genUrl = `https://generativelanguage.googleapis.com/v1beta/models/${encodeURIComponent(useModel)}:streamGenerateContent?alt=sse&key=${encodeURIComponent(apiKey)}`;
             const cachedPrefixContentCount = Number.isFinite(Number(opts.providerState?.gemini?.cachePrefixContentCount))
                 ? Math.max(0, Math.min(contents.length, Math.trunc(Number(opts.providerState.gemini.cachePrefixContentCount))))
                 : 0;
@@ -897,32 +1219,42 @@ export class GeminiProvider {
                 cachedContent,
             };
             if (toolConfig) body.toolConfig = toolConfig;
-            const fetchResult = await runGeminiOperationWithTimeout({
-                label: 'Gemini REST generateContent total',
-                timeoutMs: GEMINI_GENERATE_TOTAL_TIMEOUT_MS,
+            response = await runGeminiOperationWithTimeout({
+                label: 'Gemini REST streamGenerateContent total',
+                timeoutMs: PROVIDER_NONSTREAM_TOTAL_TIMEOUT_MS,
                 signal,
                 run: (totalSignal) => withRetry(
-                    () => runGeminiOperationWithTimeout({
-                        label: 'Gemini REST generateContent first byte',
-                        timeoutMs: GEMINI_FIRST_BYTE_TIMEOUT_MS,
-                        signal: totalSignal,
-                        run: async (opSignal) => {
-                            const res = await fetch(genUrl, {
+                    async ({ signal: attemptSignal }) => {
+                        try { opts.onStageChange?.('requesting'); } catch {}
+                        const openFirstByte = createTimeoutSignal(
+                            attemptSignal,
+                            GEMINI_FIRST_BYTE_TIMEOUT_MS,
+                            'Gemini REST first byte',
+                        );
+                        let res;
+                        try {
+                            res = await fetch(genUrl, {
                                 method: 'POST',
                                 headers: { 'Content-Type': 'application/json' },
                                 body: JSON.stringify(body),
-                                signal: opSignal,
+                                signal: openFirstByte.signal,
                                 dispatcher: getLlmDispatcher(),
                             });
-                            if (!res.ok) {
-                                const text = await res.text().catch(() => '');
-                                const err = new Error(`Gemini REST generateContent ${res.status}: ${text.slice(0, 300)}`);
-                                err.status = res.status;
-                                throw err;
-                            }
-                            return await res.json();
-                        },
-                    }),
+                        } finally {
+                            openFirstByte.cleanup();
+                        }
+                        if (!res.ok) {
+                            const text = await res.text().catch(() => '');
+                            const err = new Error(`Gemini REST streamGenerateContent ${res.status}: ${text.slice(0, 300)}`);
+                            err.status = res.status;
+                            throw err;
+                        }
+                        return await consumeGeminiRestStreamResponse(res, {
+                            signal: attemptSignal,
+                            onStreamDelta,
+                            label: 'Gemini REST streamGenerateContent',
+                        });
+                    },
                     {
                         signal: totalSignal,
                         onRetry: ({ attempt, lastErr }) => {
@@ -932,7 +1264,6 @@ export class GeminiProvider {
                     },
                 ),
             });
-            response = fetchResult;
         } else {
             const genModel = this.genAI.getGenerativeModel({
                 model: useModel,
@@ -940,17 +1271,42 @@ export class GeminiProvider {
                 tools: geminiTools,
                 ...(toolConfig ? { toolConfig } : {}),
             });
-            const result = await runGeminiOperationWithTimeout({
-                label: 'Gemini generateContent total',
-                timeoutMs: GEMINI_GENERATE_TOTAL_TIMEOUT_MS,
+            response = await runGeminiOperationWithTimeout({
+                label: 'Gemini streamGenerateContent total',
+                timeoutMs: PROVIDER_NONSTREAM_TOTAL_TIMEOUT_MS,
                 signal,
                 run: (totalSignal) => withRetry(
-                    () => runGeminiOperationWithTimeout({
-                        label: 'Gemini generateContent first byte',
-                        timeoutMs: GEMINI_FIRST_BYTE_TIMEOUT_MS,
-                        signal: totalSignal,
-                        run: (opSignal) => genModel.generateContent({ contents }, { signal: opSignal }),
-                    }),
+                    async ({ signal: attemptSignal }) => {
+                        try { opts.onStageChange?.('requesting'); } catch {}
+                        const openFirstByte = createTimeoutSignal(
+                            attemptSignal,
+                            GEMINI_FIRST_BYTE_TIMEOUT_MS,
+                            'Gemini SDK first byte',
+                        );
+                        let streamResult;
+                        try {
+                            try {
+                                streamResult = await genModel.generateContentStream(
+                                    { contents },
+                                    { signal: openFirstByte.signal },
+                                );
+                            } catch (err) {
+                                if (openFirstByte.signal.aborted) {
+                                    throw openFirstByte.signal.reason instanceof Error
+                                        ? openFirstByte.signal.reason
+                                        : err;
+                                }
+                                throw err;
+                            }
+                        } finally {
+                            openFirstByte.cleanup();
+                        }
+                        return await consumeGeminiSdkStream(streamResult, {
+                            signal: attemptSignal,
+                            onStreamDelta,
+                            label: 'Gemini SDK streamGenerateContent',
+                        });
+                    },
                     {
                         signal: totalSignal,
                         onRetry: ({ attempt, lastErr }) => {
@@ -960,7 +1316,6 @@ export class GeminiProvider {
                     },
                 ),
             });
-            response = result.response;
         }
         writeGeminiCacheTrace({
             opts,

package/src/agent/orchestrator/providers/grok-oauth.mjs

@@ -710,11 +710,8 @@ export async function loginOAuth() {
     url.searchParams.set('plan', 'generic');
     url.searchParams.set('referrer', 'mixdog');
     process.stderr.write(`\n[grok-oauth] Open this URL to log in (consent shows as "Grok Build"):\n${url.toString()}\n\n`);
-    try {
-        const { exec } = await import('child_process');
-        const opener = process.platform === 'win32' ? 'start' : process.platform === 'darwin' ? 'open' : 'xdg-open';
-        exec(`${opener} "${url.toString()}"`, { windowsHide: true });
-    } catch { /* user opens manually */ }
+        const { openInBrowser } = await import('../../../shared/open-url.mjs');
+        openInBrowser(url.toString());
 
     return new Promise((resolve) => {
         const timeout = setTimeout(() => { server.close(); resolve(null); }, LOGIN_TIMEOUT_MS);