scalix 1.0.0 → 1.2.0

package/dist/agent.js

@@ -1,4 +1,4 @@
-import OpenAI from 'openai';
+import { ScalixClient } from './api-client.js';
 import { EventEmitter } from 'eventemitter3';
 import { randomUUID } from 'node:crypto';
 import { getToolPermission } from './sandbox.js';
@@ -11,8 +11,12 @@ import { ToolSelector } from './tool-selector.js';
 import { AgentReplay } from './agent-replay.js';
 import { loadHooks, runHooks } from './hooks.js';
 import { setAgentToolConfig } from './tools-advanced.js';
+import { AgentRegistry, generateAgentId } from './agent-registry.js';
 import { runVerification, VERIFY_DEFAULTS } from './auto-verify.js';
 import { ChangeTracker } from './change-tracker.js';
+import { detectPromptInjection, formatInjectionWarning } from './injection-detector.js';
+import { extractCodeClaims, checkGrounding, formatGroundingNudge, GROUNDING_DEFAULTS } from './grounding-checker.js';
+import { RETRIEVAL_DEFAULTS } from './context-retriever.js';
 import fs from 'node:fs/promises';
 import path from 'node:path';
 function transformToolsForApi(tools) {
@@ -140,12 +144,24 @@ export class Agent extends EventEmitter {
     verifyConfig = null;
     verifyFailCounts = new Map();
     compressAttempts = 0;
+    agentId;
+    parentAgentId;
+    agentDescription;
+    registeredInRegistry = false;
+    injectionDetectionEnabled;
+    injectionSensitivity;
+    injectionCustomPatterns;
+    outputFormat;
+    outputSchema;
+    groundingConfig = null;
+    groundingNudgeCount = 0;
+    retrievalConfig = null;
     constructor(config) {
         super();
-        this.client = new OpenAI({
-            apiKey: config.apiKey,
-            baseURL: config.baseUrl,
-        });
+        this.agentId = config.agentId ?? generateAgentId();
+        this.parentAgentId = config.parentAgentId ?? null;
+        this.agentDescription = config.agentDescription ?? 'main';
+        this.client = new ScalixClient(config.baseUrl || 'https://api.scalix.world/v1', config.apiKey);
         this.log = logger.child();
         const resolvedModels = Array.isArray(config.model)
             ? (config.model.length > 0 ? config.model : FALLBACK_MODELS)
@@ -191,6 +207,33 @@ export class Agent extends EventEmitter {
             permissionMode: this.config.permissionMode,
             confirmToolCall: this.config.confirmToolCall,
         });
+        if (config.injectionDetection === false) {
+            this.injectionDetectionEnabled = false;
+            this.injectionSensitivity = 'medium';
+        }
+        else if (typeof config.injectionDetection === 'object') {
+            this.injectionDetectionEnabled = true;
+            this.injectionSensitivity = config.injectionDetection.sensitivity ?? 'medium';
+            this.injectionCustomPatterns = config.injectionDetection.customPatterns;
+        }
+        else {
+            this.injectionDetectionEnabled = true;
+            this.injectionSensitivity = 'medium';
+        }
+        this.outputFormat = config.outputFormat ?? 'text';
+        this.outputSchema = config.outputSchema;
+        if (config.groundingCheck === true) {
+            this.groundingConfig = { ...GROUNDING_DEFAULTS };
+        }
+        else if (config.groundingCheck && typeof config.groundingCheck === 'object') {
+            this.groundingConfig = { ...GROUNDING_DEFAULTS, ...config.groundingCheck };
+        }
+        if (config.contextRetrieval === true) {
+            this.retrievalConfig = { ...RETRIEVAL_DEFAULTS };
+        }
+        else if (config.contextRetrieval && typeof config.contextRetrieval === 'object') {
+            this.retrievalConfig = { ...RETRIEVAL_DEFAULTS, ...config.contextRetrieval };
+        }
     }
     pickModel() {
         const startIdx = this.modelIndex;
@@ -284,7 +327,7 @@ export class Agent extends EventEmitter {
                 ...this.messages.map((m) => ({ role: (m.role === 'tool' ? 'user' : m.role), content: messageContentToString(m.content) })),
                 { role: 'user', content: summaryPrompt },
             ];
-            const result = await this.client.chat.completions.create({
+            const result = await this.client.chatComplete({
                 model,
                 messages: apiMessages,
                 stream: false,
@@ -336,7 +379,7 @@ export class Agent extends EventEmitter {
         try {
             const prompt = this.contextManager.buildCompressionPrompt(toCompress);
             const model = this.config.models[0];
-            const result = await this.client.chat.completions.create({
+            const result = await this.client.chatComplete({
                 model,
                 messages: [
                     { role: 'system', content: 'You compress conversation history. Preserve every file path, function name, error message, code change, command, config value, and user instruction verbatim. Omit greetings and filler only. This output replaces the original — anything omitted is permanently lost.' },
@@ -388,6 +431,48 @@ export class Agent extends EventEmitter {
     getHooks() { return this.hooks; }
     getApiKey() { return this.config.apiKey; }
     getBaseUrl() { return this.client.baseURL; }
+    getAgentId() { return this.agentId; }
+    registerInRegistry() {
+        if (this.registeredInRegistry)
+            return;
+        this.registeredInRegistry = true;
+        const registry = AgentRegistry.getInstance();
+        registry.register(this.agentId, this, this.parentAgentId, {
+            description: this.agentDescription,
+            model: this.config.models[0],
+        });
+        this.on('usage', (data) => {
+            registry.recordTokens(this.agentId, data.total_tokens ?? 0);
+        });
+        this.on('tool:call', () => {
+            registry.recordStep(this.agentId);
+        });
+    }
+    deregisterFromRegistry(status) {
+        if (!this.registeredInRegistry)
+            return;
+        AgentRegistry.getInstance().deregister(this.agentId, status);
+    }
+    checkInbox() {
+        const registry = AgentRegistry.getInstance();
+        const msgs = registry.getUnread(this.agentId);
+        for (const msg of msgs) {
+            this.messages.push({
+                role: 'system',
+                content: `[Message from agent ${msg.from.slice(0, 8)}]: ${msg.content}`,
+            });
+        }
+        registry.markRead(this.agentId);
+    }
+    getAgentConfig() {
+        return {
+            apiKey: this.config.apiKey,
+            baseUrl: this.client.baseURL,
+            models: this.config.models,
+            permissionMode: this.config.permissionMode,
+            confirmToolCall: this.config.confirmToolCall,
+        };
+    }
     abort() {
         this._aborted = true;
         if (this._abortController) {
@@ -447,8 +532,64 @@ export class Agent extends EventEmitter {
             return content;
         return contextBlocks.join('\n\n') + '\n\n' + content;
     }
+    addOutputFormatInstructions() {
+        let instruction;
+        if (this.outputFormat === 'json-schema' && this.outputSchema) {
+            instruction = `IMPORTANT: Your final response MUST be valid JSON matching this schema:\n${JSON.stringify(this.outputSchema, null, 2)}\n\nDo not include any text outside the JSON object. No markdown code fences, no explanation — only the raw JSON.`;
+        }
+        else {
+            instruction = 'IMPORTANT: Your final response MUST be valid JSON. Do not include any text outside the JSON object. No markdown code fences, no explanation — only the raw JSON.';
+        }
+        this.messages.push({ role: 'system', content: instruction });
+    }
+    extractJsonFromResponse(response) {
+        const trimmed = response.trim();
+        // Try direct parse
+        try {
+            JSON.parse(trimmed);
+            return trimmed;
+        }
+        catch { }
+        // Try extracting from markdown code fence
+        const fenceMatch = trimmed.match(/```(?:json)?\s*\n?([\s\S]*?)\n?```/);
+        if (fenceMatch) {
+            try {
+                JSON.parse(fenceMatch[1].trim());
+                return fenceMatch[1].trim();
+            }
+            catch { }
+        }
+        // Try finding first { to last }
+        const firstBrace = trimmed.indexOf('{');
+        const lastBrace = trimmed.lastIndexOf('}');
+        if (firstBrace !== -1 && lastBrace > firstBrace) {
+            const candidate = trimmed.slice(firstBrace, lastBrace + 1);
+            try {
+                JSON.parse(candidate);
+                return candidate;
+            }
+            catch { }
+        }
+        // Try finding first [ to last ]
+        const firstBracket = trimmed.indexOf('[');
+        const lastBracket = trimmed.lastIndexOf(']');
+        if (firstBracket !== -1 && lastBracket > firstBracket) {
+            const candidate = trimmed.slice(firstBracket, lastBracket + 1);
+            try {
+                JSON.parse(candidate);
+                return candidate;
+            }
+            catch { }
+        }
+        // Return as-is if no valid JSON found
+        return response;
+    }
+    getOutputFormat() {
+        return this.outputFormat;
+    }
     async send(content, images) {
         this._aborted = false;
+        this.groundingNudgeCount = 0;
         const hasFileRefs = /@(?:[\w./-]+\/)?[\w.-]+\.\w+/.test(content);
         const expandedContent = hasFileRefs ? await this.expandFileReferences(content) : content;
         let finalContent = expandedContent;
@@ -461,6 +602,9 @@ export class Agent extends EventEmitter {
             const newImages = images.map(dataUrl => ({ type: 'image_url', image_url: { url: dataUrl, detail: 'auto' } }));
             finalContent = [textPart, ...existingImages, ...newImages];
         }
+        if (this.outputFormat !== 'text') {
+            this.addOutputFormatInstructions();
+        }
         const userMessage = { role: 'user', content: finalContent };
         this.messages.push(userMessage);
         this.emit('message:user', userMessage);
@@ -471,12 +615,19 @@ export class Agent extends EventEmitter {
         const requestId = randomUUID().slice(0, 8);
         const reqLog = logger.child(requestId);
         reqLog.info('User message received', { length: content.length });
+        this.registerInRegistry();
         try {
             const initialModel = this.pickModel();
-            reqLog.info('Starting agent loop', { model: initialModel });
-            return await this.loopStreamingTurns(initialModel, reqLog);
+            reqLog.info('Starting agent loop', { model: initialModel, agentId: this.agentId });
+            let result = await this.loopStreamingTurns(initialModel, reqLog);
+            if (this.outputFormat !== 'text') {
+                result = this.extractJsonFromResponse(result);
+            }
+            this.deregisterFromRegistry('completed');
+            return result;
         }
         catch (err) {
+            this.deregisterFromRegistry('failed');
             const error = err instanceof Error ? err : new Error(String(err));
             error.metadata = {
                 model: this.config.models[this.modelIndex % this.config.models.length],
@@ -497,11 +648,15 @@ export class Agent extends EventEmitter {
         let turnCount = 0;
         let retryAttempt = 0;
         let emptyTurnCount = 0;
+        let disableTools = false;
+        let forceNonStreaming = false;
         while (turnCount < this.config.maxSteps) {
             if (this._aborted) {
                 reqLog.info('Agent aborted by user');
+                this.deregisterFromRegistry('aborted');
                 return '[interrupted]';
             }
+            this.checkInbox();
             turnCount++;
             let fullText = '';
             const toolCalls = new Map();
@@ -525,29 +680,44 @@ export class Agent extends EventEmitter {
                         toolsForRequest = this.toolSelector.select(messageContentToString(lastUserMsg.content), recentTools);
                     }
                 }
-                const apiTools = toolsForRequest.length > 0 ? transformToolsForApi(toolsForRequest) : undefined;
+                const apiTools = !disableTools && toolsForRequest.length > 0 ? transformToolsForApi(toolsForRequest) : undefined;
                 const estimatedTokens = estimateMessageTokens(this.messages);
                 this.emit('cost:estimate', { estimatedTokens, model: currentModel });
                 this._abortController = new AbortController();
+                let effectiveInstructions = this.config.instructions;
+                if (this.retrievalConfig?.enabled && turnCount === 1) {
+                    const lastUserMsg = [...this.messages].reverse().find((m) => m.role === 'user');
+                    if (lastUserMsg?.content) {
+                        const queryText = messageContentToString(lastUserMsg.content);
+                        try {
+                            const { buildQueryContext } = await import('./context-builder.js');
+                            const contextSnippets = await buildQueryContext(queryText, process.cwd(), this.retrievalConfig);
+                            if (contextSnippets) {
+                                effectiveInstructions += '\n\n' + contextSnippets;
+                            }
+                        }
+                        catch (err) {
+                            reqLog.warn('Context retrieval failed', { error: err.message });
+                        }
+                    }
+                }
                 const vision = modelSupportsVision(currentModel);
-                const apiMessages = messagesToApi(this.messages, this.config.instructions, vision);
+                const apiMessages = messagesToApi(this.messages, effectiveInstructions, vision);
                 const thinkingLevel = this.config.thinkingMode !== 'off' ? this.config.thinkingMode : undefined;
-                const stream = await this.client.chat.completions.create({
-                    model: currentModel,
-                    messages: apiMessages,
-                    tools: apiTools && apiTools.length > 0 ? apiTools : undefined,
-                    max_tokens: modelSpec.maxOutputTokens,
-                    temperature: 0.7,
-                    stream: true,
-                    stream_options: { include_usage: true },
-                    ...(thinkingLevel && { thinking_level: thinkingLevel }),
-                }, {
-                    signal: this._abortController.signal,
-                });
-                this.emit('stream:start');
-                retryAttempt = 0;
-                this.recordModelSuccess(currentModel);
-                try {
+                const hasToolMessages = this.messages.some(m => m.role === 'tool' || (m.role === 'assistant' && m.tool_calls && m.tool_calls.length > 0));
+                const useStreaming = !hasToolMessages && !forceNonStreaming;
+                if (useStreaming) {
+                    const stream = await this.client.chatComplete({
+                        model: currentModel,
+                        messages: apiMessages,
+                        tools: apiTools && apiTools.length > 0 ? apiTools : undefined,
+                        temperature: 0.7,
+                        stream: true,
+                        ...(thinkingLevel && { thinking_level: thinkingLevel }),
+                    }, this._abortController.signal);
+                    this.emit('stream:start');
+                    retryAttempt = 0;
+                    this.recordModelSuccess(currentModel);
                     for await (const chunk of stream) {
                         if (this._aborted)
                             break;
@@ -590,8 +760,48 @@ export class Agent extends EventEmitter {
                         }
                     }
                 }
-                finally {
-                    stream.controller?.abort();
+                else {
+                    this.emit('stream:start');
+                    const result = await this.client.chatComplete({
+                        model: currentModel,
+                        messages: apiMessages,
+                        tools: apiTools && apiTools.length > 0 ? apiTools : undefined,
+                        temperature: 0.7,
+                        stream: false,
+                        ...(thinkingLevel && { thinking_level: thinkingLevel }),
+                    }, this._abortController.signal);
+                    retryAttempt = 0;
+                    this.recordModelSuccess(currentModel);
+                    const choice = result.choices?.[0];
+                    if (choice?.message) {
+                        if (choice.message.content) {
+                            fullText = choice.message.content;
+                            this.emit('stream:delta', fullText, fullText);
+                        }
+                        if (choice.message.tool_calls) {
+                            for (const tc of choice.message.tool_calls) {
+                                toolCalls.set(toolCalls.size, {
+                                    id: tc.id,
+                                    name: tc.function.name,
+                                    arguments: tc.function.arguments,
+                                });
+                            }
+                        }
+                    }
+                    if (result.usage) {
+                        const inTok = result.usage.prompt_tokens ?? 0;
+                        const outTok = result.usage.completion_tokens ?? 0;
+                        const totalTok = result.usage.total_tokens ?? (inTok + outTok);
+                        const cost = result.usage.cost ?? 0;
+                        this.emit('usage', {
+                            prompt_tokens: inTok,
+                            completion_tokens: outTok,
+                            total_tokens: totalTok,
+                            cost,
+                            model: currentModel,
+                        });
+                        this.replay.recordUsage(totalTok, cost);
+                    }
                 }
                 for (const [, call] of toolCalls) {
                     this.emit('tool:call', call.name, call.arguments);
@@ -600,11 +810,23 @@ export class Agent extends EventEmitter {
                 this.emit('stream:end', fullText);
                 this.replay.record('stream_end', { text: fullText.slice(0, 200) });
                 const resolvedToolCalls = Array.from(toolCalls.values());
+                // Normalize hallucinated tool name prefixes (e.g. "default_api.write_file" → "write_file")
+                for (const tc of resolvedToolCalls) {
+                    if (tc.name.includes('.')) {
+                        const normalized = tc.name.split('.').pop();
+                        reqLog.warn('Normalized tool name', { original: tc.name, normalized });
+                        tc.name = normalized;
+                    }
+                }
                 const hasToolCalls = resolvedToolCalls.length > 0;
                 if (!fullText && !hasToolCalls) {
                     emptyTurnCount++;
                     reqLog.warn('Empty assistant turn (no text, no tool calls) — skipping', { emptyTurns: emptyTurnCount });
-                    if (emptyTurnCount >= 3) {
+                    if (emptyTurnCount >= 2 && !disableTools) {
+                        disableTools = true;
+                        reqLog.warn('Disabling tools due to repeated empty turns — model may not support function calling');
+                    }
+                    if (emptyTurnCount >= 5) {
                         reqLog.error('Too many empty turns, aborting');
                         return '[no response]';
                     }
@@ -662,50 +884,57 @@ export class Agent extends EventEmitter {
                         }
                         if (permission === 'ask') {
                             if (!this.config.confirmToolCall) {
-                                result = { denied: true, message: `Tool ${call.name} requires confirmation but no confirmation handler is available` };
-                                reqLog.warn('Tool requires confirmation but no confirmToolCall provided', { tool: call.name });
-                                this.emit('tool:blocked', call.name, 'No confirmation handler');
-                                this.messages.push({
-                                    role: 'tool',
-                                    content: JSON.stringify(result),
-                                    tool_call_id: call.id,
-                                    name: call.name,
-                                });
-                                this.emit('tool:result', call.name, result);
-                                continue;
-                            }
-                            let args;
-                            try {
-                                args = JSON.parse(call.arguments);
-                            }
-                            catch {
-                                args = call.arguments;
+                                if (this.config.permissionMode === 'auto') {
+                                    reqLog.info('Auto-approving tool (no confirmation handler in auto mode)', { tool: call.name });
+                                }
+                                else {
+                                    result = { denied: true, message: `Tool ${call.name} requires confirmation but no confirmation handler is available` };
+                                    reqLog.warn('Tool requires confirmation but no confirmToolCall provided', { tool: call.name });
+                                    this.emit('tool:blocked', call.name, 'No confirmation handler');
+                                    this.messages.push({
+                                        role: 'tool',
+                                        content: JSON.stringify(result),
+                                        tool_call_id: call.id,
+                                        name: call.name,
+                                    });
+                                    this.emit('tool:result', call.name, result);
+                                    continue;
+                                }
                             }
-                            const CONFIRM_TIMEOUT_MS = 300_000;
-                            const confirmed = await new Promise((resolve) => {
-                                const timer = setTimeout(() => resolve(false), CONFIRM_TIMEOUT_MS);
-                                this.config.confirmToolCall(call.name, args).then((v) => {
-                                    clearTimeout(timer);
-                                    resolve(v);
-                                }).catch(() => {
-                                    clearTimeout(timer);
-                                    resolve(false);
-                                });
-                            });
-                            if (this._aborted)
-                                break;
-                            if (!confirmed) {
-                                result = { denied: true, message: `User denied execution of ${call.name}` };
-                                reqLog.info('Tool call denied by user', { tool: call.name });
-                                this.emit('tool:blocked', call.name, 'User denied');
-                                this.messages.push({
-                                    role: 'tool',
-                                    content: JSON.stringify(result),
-                                    tool_call_id: call.id,
-                                    name: call.name,
+                            else {
+                                let args;
+                                try {
+                                    args = JSON.parse(call.arguments);
+                                }
+                                catch {
+                                    args = call.arguments;
+                                }
+                                const CONFIRM_TIMEOUT_MS = 300_000;
+                                const confirmed = await new Promise((resolve) => {
+                                    const timer = setTimeout(() => resolve(false), CONFIRM_TIMEOUT_MS);
+                                    this.config.confirmToolCall(call.name, args).then((v) => {
+                                        clearTimeout(timer);
+                                        resolve(v);
+                                    }).catch(() => {
+                                        clearTimeout(timer);
+                                        resolve(false);
+                                    });
                                 });
-                                this.emit('tool:result', call.name, result);
-                                continue;
+                                if (this._aborted)
+                                    break;
+                                if (!confirmed) {
+                                    result = { denied: true, message: `User denied execution of ${call.name}` };
+                                    reqLog.info('Tool call denied by user', { tool: call.name });
+                                    this.emit('tool:blocked', call.name, 'User denied');
+                                    this.messages.push({
+                                        role: 'tool',
+                                        content: JSON.stringify(result),
+                                        tool_call_id: call.id,
+                                        name: call.name,
+                                    });
+                                    this.emit('tool:result', call.name, result);
+                                    continue;
+                                }
                             }
                         }
                         const execFn = tool?.function?.execute ?? tool?.execute;
@@ -722,7 +951,19 @@ export class Agent extends EventEmitter {
                                 const toolTimeout = (typeof args?.timeout === 'number' && args.timeout > 0)
                                     ? Math.min(args.timeout, TOOL_DEFAULTS.maxCommandTimeoutMs)
                                     : this.config.toolTimeoutMs;
-                                result = await withTimeout(execFn(args, { context: {}, workspaceRoot: process.cwd(), permissionMode: this.config.permissionMode }), toolTimeout, call.name);
+                                result = await withTimeout(execFn(args, {
+                                    context: {},
+                                    workspaceRoot: process.cwd(),
+                                    permissionMode: this.config.permissionMode,
+                                    agentId: this.agentId,
+                                    agentConfig: {
+                                        apiKey: this.config.apiKey,
+                                        baseUrl: this.client.baseURL,
+                                        models: this.config.models,
+                                        permissionMode: this.config.permissionMode,
+                                        confirmToolCall: this.config.confirmToolCall,
+                                    },
+                                }), toolTimeout, call.name);
                                 if (call.name === 'add_mcp_server' && result?.success) {
                                     this.addTool({ type: 'mcp', serverLabel: args.label, serverUrl: args.url });
                                 }
@@ -733,7 +974,11 @@ export class Agent extends EventEmitter {
                             }
                         }
                         else {
-                            result = { error: `Tool ${call.name} not found or not locally executable.` };
+                            const availableNames = this.config.tools
+                                .map((t) => t.function?.name || t.name)
+                                .filter(Boolean)
+                                .slice(0, 20);
+                            result = { error: `Tool "${call.name}" does not exist. Available tools: ${availableNames.join(', ')}. Do not invent tool names — only use tools from the list above, or respond with text directly.` };
                         }
                         let resultStr;
                         try {
@@ -759,6 +1004,23 @@ export class Agent extends EventEmitter {
                         if (resultStr.length > MAX_TOOL_RESULT_CHARS) {
                             resultStr = resultStr.slice(0, MAX_TOOL_RESULT_CHARS) + `\n...[truncated — ${(resultStr.length - MAX_TOOL_RESULT_CHARS).toLocaleString()} chars removed]`;
                         }
+                        if (this.injectionDetectionEnabled) {
+                            const injectionCheck = detectPromptInjection(resultStr, call.name, this.injectionSensitivity, this.injectionCustomPatterns);
+                            if (injectionCheck.detected) {
+                                this.emit('injection:detected', injectionCheck);
+                                if (injectionCheck.confidence === 'high') {
+                                    resultStr = formatInjectionWarning(injectionCheck) + '\n\n' + resultStr;
+                                }
+                                else if (injectionCheck.confidence === 'medium') {
+                                    resultStr = `[Note: content may contain injection patterns (${injectionCheck.patterns.join(', ')})]\n\n` + resultStr;
+                                }
+                                reqLog.warn('Prompt injection detected in tool result', {
+                                    tool: call.name,
+                                    confidence: injectionCheck.confidence,
+                                    patterns: injectionCheck.patterns,
+                                });
+                            }
+                        }
                         this.messages.push({
                             role: 'tool',
                             content: resultStr,
@@ -824,13 +1086,40 @@ export class Agent extends EventEmitter {
                         return '[interrupted]';
                     continue;
                 }
+                if (this.groundingConfig?.enabled && this.groundingNudgeCount < this.groundingConfig.maxNudges) {
+                    const claims = extractCodeClaims(fullText);
+                    if (claims.length >= this.groundingConfig.minClaimsToCheck) {
+                        const groundingResult = checkGrounding(claims, this.messages, this.groundingConfig.ungroundedThreshold, this.groundingConfig.minClaimsToCheck);
+                        if (groundingResult.needsVerification) {
+                            this.groundingNudgeCount++;
+                            this.emit('grounding:unverified', groundingResult);
+                            this.messages.push({ role: 'system', content: formatGroundingNudge(groundingResult) });
+                            reqLog.info('Grounding check: nudging agent to verify claims', {
+                                total: claims.length,
+                                ungrounded: groundingResult.ungroundedClaims.length,
+                                ratio: groundingResult.groundingRatio,
+                            });
+                            continue;
+                        }
+                    }
+                }
                 return fullText;
             }
             catch (err) {
                 this._abortController = null;
                 this.recordModelFailure(currentModel);
+                const errMsg = (err?.message || '').toLowerCase();
+                const isStreamError = errMsg.includes('stream') || errMsg.includes('sse') || errMsg.includes('no response body');
+                // On stream failure, retry once with non-streaming before giving up
+                if (isStreamError && !forceNonStreaming) {
+                    forceNonStreaming = true;
+                    reqLog.warn('Streaming failed, retrying with non-streaming mode', { error: err.message });
+                    await sleep(500);
+                    continue;
+                }
                 if (this.shouldFallbackToNext(err) && retryAttempt < this.config.maxRetries && turnCount < this.config.maxSteps) {
                     retryAttempt++;
+                    forceNonStreaming = false;
                     const delay = backoffDelay(retryAttempt);
                     reqLog.warn(`Retrying after ${Math.round(delay)}ms (attempt ${retryAttempt}/${this.config.maxRetries})`, {
                         model: currentModel,