neoagent 3.2.1-beta.7 → 3.2.1-beta.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "neoagent",
-  "version": "3.2.1-beta.7",
+  "version": "3.2.1-beta.8",
   "description": "Self-hosted AI agent for long-running tasks, automation, messaging, device control, and local memory",
   "license": "AGPL-3.0-only",
   "main": "server/index.js",
@@ -68,7 +68,7 @@
   "dependencies": {
     "@anthropic-ai/sdk": "^0.39.0",
     "@bitwarden/cli": "^2026.6.0",
-    "@google/generative-ai": "^0.24.0",
+    "@google/genai": "^2.13.0",
     "@modelcontextprotocol/sdk": "^1.29.0",
     "@remotion/cli": "^4.0.459",
     "@slidev/cli": "^52.18.0",

package/server/http/routes.js

@@ -56,6 +56,13 @@ function registerApiRoutes(app) {
   if (isBillingEnabled()) {
     app.use('/api/billing/webhook', require('../routes/billing_webhook'));
     app.use('/api/billing', require('../routes/billing'));
+  } else {
+    // The Flutter client probes this public endpoint to decide whether to show
+    // billing. Return an explicit disabled state instead of generating a noisy
+    // 404 on every client startup.
+    app.get('/api/billing/plans', (_req, res) => {
+      res.json({ enabled: false, plans: null });
+    });
   }
 
   setupTelnyxWebhook(app);

package/server/public/.last_build_id

@@ -1 +1 @@
-4e3d49d31cbb561d89adf60e16759ebe
+38fc05bea2f5bf14dda4c0f58b31ff9a

package/server/public/flutter_bootstrap.js

@@ -33,10 +33,10 @@ addEventListener("message", eventListener);
 if (!window._flutter) {
   window._flutter = {};
 }
-_flutter.buildConfig = {"engineRevision":"69c8c61792f04cc809dfef0c910414fb9afc06cd","builds":[{"compileTarget":"dart2js","renderer":"canvaskit","mainJsPath":"main.dart.js"},{}]};
+_flutter.buildConfig = {"engineRevision":"0cd610717bde95fd88343c64f81c11ba4e5c0010","builds":[{"compileTarget":"dart2js","renderer":"canvaskit","mainJsPath":"main.dart.js"},{}]};
 
 _flutter.loader.load({
   serviceWorkerSettings: {
-    serviceWorkerVersion: "3827219452" /* Flutter's service worker is deprecated and will be removed in a future Flutter release. */
+    serviceWorkerVersion: "222530411" /* Flutter's service worker is deprecated and will be removed in a future Flutter release. */
   }
 });

package/server/public/main.dart.js

@@ -44367,7 +44367,7 @@ $S:4}
 A.bnI.prototype={
 $1(a){var s=A.fp().b
 s=s==null?null:s.canvasKitBaseUrl
-return(s==null?"https://www.gstatic.com/flutter-canvaskit/69c8c61792f04cc809dfef0c910414fb9afc06cd/":s)+a},
+return(s==null?"https://www.gstatic.com/flutter-canvaskit/0cd610717bde95fd88343c64f81c11ba4e5c0010/":s)+a},
 $S:42}
 A.a2F.prototype={
 gF(a){var s=this.a
@@ -144506,7 +144506,7 @@ if(r){r=s.d
 r===$&&A.b()
 p.push(A.ju(q,A.jx(!1,new A.Y(B.wP,A.cU(new A.cH(B.kE,new A.acU(r,q),q),q,q),q),!1,B.J,!0),q,q,0,0,0,q))}if(!s.ay){r=s.e
 r===$&&A.b()
-r=B.b.t("mry3rvmk-b952e5d").length!==0&&r.b}else r=!1
+r=B.b.t("mryrwx0x-27df61b").length!==0&&r.b}else r=!1
 if(r){r=s.d
 r===$&&A.b()
 r=r.aU&&!r.ag?84:0
@@ -150393,7 +150393,7 @@ $S:0}
 A.a3j.prototype={}
 A.WC.prototype={
 r9(a){var s=this
-if(B.b.t("mry3rvmk-b952e5d").length===0||s.a!=null)return
+if(B.b.t("mryrwx0x-27df61b").length===0||s.a!=null)return
 s.Co()
 s.a=A.mL(B.Yh,new A.bmK(s))},
 Co(){var s=0,r=A.l(t.H),q,p=2,o=[],n=this,m,l,k,j,i,h,g,f
@@ -150411,7 +150411,7 @@ if(!t.f.b(k)){s=1
 break}i=J.a0(k,"buildId")
 h=i==null?null:B.b.t(J.q(i))
 j=h==null?"":h
-if(J.bv(j)===0||J.e(j,"mry3rvmk-b952e5d")){s=1
+if(J.bv(j)===0||J.e(j,"mryrwx0x-27df61b")){s=1
 break}n.b=!0
 n.H()
 p=2
@@ -150428,7 +150428,7 @@ case 2:return A.i(o.at(-1),r)}})
 return A.k($async$Co,r)},
 wV(){var s=0,r=A.l(t.H),q,p=2,o=[],n=this,m,l,k,j,i,h,g,f,e,d,c,b,a,a0,a1
 var $async$wV=A.h(function(a2,a3){if(a2===1){o.push(a3)
-s=p}for(;;)switch(s){case 0:if(B.b.t("mry3rvmk-b952e5d").length===0||n.c){s=1
+s=p}for(;;)switch(s){case 0:if(B.b.t("mryrwx0x-27df61b").length===0||n.c){s=1
 break}n.c=!0
 n.H()
 p=4

package/server/services/ai/loop/completion_judge.js

@@ -2,7 +2,10 @@
 
 const { normalizeCompletionConfidence } = require('../completion');
 const { normalizeOutgoingMessage } = require('../messagingFallback');
-const { isDeferredWorkReply } = require('../terminal_reply');
+const {
+  isDeferredWorkReply,
+  isTerminalQuestionOrBlockerReply,
+} = require('../terminal_reply');
 const {
   summarizeAvailableTools,
   summarizeToolExecutions,
@@ -243,13 +246,19 @@ function normalizeCompletionDecision(raw, fallbackStatus = 'continue') {
 }
 
 function enforceTerminalReplyDecision(decision, lastReply) {
-  if (decision?.status === 'continue' || !isDeferredWorkReply(lastReply)) {
-    return decision;
+  if (isDeferredWorkReply(lastReply)) {
+    return {
+      status: 'continue',
+      reason: 'The latest reply only announces or promises unfinished work; the run must continue or return a concrete blocker.',
+    };
   }
-  return {
-    status: 'continue',
-    reason: 'The latest reply only announces or promises unfinished work; the run must continue or return a concrete blocker.',
-  };
+  if (decision?.status === 'continue' && isTerminalQuestionOrBlockerReply(lastReply)) {
+    return {
+      status: 'blocked',
+      reason: 'The latest reply asks for user input or states a concrete blocker, so the run must wait instead of repeating it.',
+    };
+  }
+  return decision;
 }
 
 // Intentionally lightweight (200-token cap, self-contained) so the model can

package/server/services/ai/loop/conversation_loop.js

@@ -422,13 +422,20 @@ async function getFailureFallbackModelId(
   preferredFallbackId = null,
   failureError = null,
   signal = null,
+  excludedModelIds = [],
 ) {
   const { getSupportedModels } = require('../models');
   const aiSettings = getAiSettings(userId, agentId);
   const models = await getSupportedModels(userId, agentId, { signal });
+  const excluded = new Set(
+    [...excludedModelIds]
+      .map((id) => String(id || '').trim())
+      .filter(Boolean),
+  );
   const availableModels = models.filter(
     (model) => model.available !== false
-      && !isModelCoolingDown(userId, agentId, model.id),
+      && !isModelCoolingDown(userId, agentId, model.id)
+      && !excluded.has(model.id),
   );
   const configuredEnabledIds = Array.isArray(aiSettings.enabled_models)
     ? aiSettings.enabled_models.map((id) => String(id).trim()).filter(Boolean)
@@ -438,15 +445,26 @@ async function getFailureFallbackModelId(
     ? availableModels.filter((model) => enabledIds.includes(model.id))
     : availableModels;
   const fallbackSearchPool = pool;
-  const currentModel = resolveModelSelection(pool, currentModelId)
-    || resolveModelSelection(availableModels, currentModelId);
-
-  // When the failure is a provider-level rate limit, the preferred fallback is
-  // likely on the same provider and will hit the same limit. Skip it and prefer
-  // a fallback from a different provider instead.
-  const isProviderRateLimit = /429|rate.?limit|free-models-per/i.test(String(failureError?.message || ''));
+  const currentModel = resolveModelSelection(models, currentModelId);
+
+  // Provider-wide failures (credentials, throttling, or service outages) are
+  // likely to affect another model on the same provider. Prefer a different
+  // provider before consulting the configured fallback.
+  const failureStatus = Number(
+    failureError?.status
+    ?? failureError?.statusCode
+    ?? failureError?.response?.status,
+  );
+  const isProviderScopedFailure = (
+    failureStatus === 401
+    || failureStatus === 403
+    || failureStatus === 429
+    || (failureStatus >= 500 && failureStatus < 600)
+    || /rate.?limit|free-models-per|service unavailable|provider unavailable|authentication|api key/i
+      .test(String(failureError?.message || ''))
+  );
 
-  if (preferredFallbackId && !isProviderRateLimit) {
+  if (preferredFallbackId && !isProviderScopedFailure) {
     const preferred = resolveModelSelection(fallbackSearchPool, preferredFallbackId)
       || resolveModelSelection(availableModels, preferredFallbackId);
     if (preferred && preferred.id !== currentModel?.id) return preferred.id;
@@ -458,8 +476,7 @@ async function getFailureFallbackModelId(
     if (differentProvider) return differentProvider.id;
   }
 
-  // If no different-provider model exists, still try the preferred fallback
-  // even on rate limits (it's better than nothing).
+  // If no different-provider model exists, still try the preferred fallback.
   if (preferredFallbackId) {
     const preferred = resolveModelSelection(fallbackSearchPool, preferredFallbackId)
       || resolveModelSelection(availableModels, preferredFallbackId);
@@ -491,6 +508,7 @@ async function runConversation(engine, userId, userMessage, options = {}, _model
   let model = null;
   let modelSelectionId = null;
   let providerName = null;
+  const modelTurnFailedModelSelectionIds = new Set();
   let messages = [];
   let iteration = 0;
   let totalTokens = 0;
@@ -606,8 +624,17 @@ async function runConversation(engine, userId, userMessage, options = {}, _model
   }
   db.prepare('UPDATE agent_runs SET model = ?, updated_at = datetime(\'now\') WHERE id = ?')
     .run(modelSelectionId, runId);
-  const switchToFallbackModel = async (failedSelectionId, error, phase) => {
+  const recordFailedModel = (failedSelectionId, error, excludedModels) => {
+    excludedModels.add(failedSelectionId);
     recordModelFailure(userId, agentId, failedSelectionId, error);
+  };
+  const switchToFallbackModel = async (
+    failedSelectionId,
+    error,
+    phase,
+    excludedModels,
+  ) => {
+    recordFailedModel(failedSelectionId, error, excludedModels);
     const fallbackModelId = await getFailureFallbackModelId(
       userId,
       agentId,
@@ -615,9 +642,21 @@ async function runConversation(engine, userId, userMessage, options = {}, _model
       aiSettings.fallback_model_id,
       error,
       engine.getRunMeta(runId)?.abortController?.signal,
+      excludedModels,
     );
     if (!fallbackModelId || fallbackModelId === failedSelectionId) return false;
-    console.log(`[Engine] ${phase} failed on ${failedSelectionId}; attempting fallback to: ${fallbackModelId}`);
+    const failureSummary = summarizeForLog(error?.message || error, 180);
+    console.log(
+      `[Engine] ${phase} failed on ${failedSelectionId}: ${failureSummary}; attempting fallback to: ${fallbackModelId}`
+    );
+    engine.recordRunEvent(userId, runId, 'model_fallback', {
+      phase,
+      failedModel: failedSelectionId,
+      fallbackModel: fallbackModelId,
+      errorCode: error?.code || null,
+      errorStatus: error?.status || error?.statusCode || error?.response?.status || null,
+      error: failureSummary,
+    }, { agentId });
     engine.emit(userId, 'run:interim', {
       runId,
       message: `Model service failed on ${failedSelectionId}; retrying with ${fallbackModelId}.`,
@@ -647,17 +686,28 @@ async function runConversation(engine, userId, userMessage, options = {}, _model
     return true;
   };
   const runWithModelFallback = async (phase, fn) => {
-    try {
-      const result = await fn();
-      recordModelSuccess(userId, agentId, modelSelectionId);
-      return result;
-    } catch (err) {
-      const failedSelectionId = modelSelectionId;
-      const switched = await switchToFallbackModel(failedSelectionId, err, phase);
-      if (!switched) throw err;
-      const result = await fn();
-      recordModelSuccess(userId, agentId, modelSelectionId);
-      return result;
+    let recoveries = 0;
+    const failedModels = new Set();
+    while (true) {
+      try {
+        const result = await fn();
+        recordModelSuccess(userId, agentId, modelSelectionId);
+        return result;
+      } catch (err) {
+        if (recoveries >= loopPolicy.maxModelFailureRecoveries) {
+          recordFailedModel(modelSelectionId, err, failedModels);
+          throw err;
+        }
+        const failedSelectionId = modelSelectionId;
+        const switched = await switchToFallbackModel(
+          failedSelectionId,
+          err,
+          phase,
+          failedModels,
+        );
+        if (!switched) throw err;
+        recoveries += 1;
+      }
     }
   };
 
@@ -1483,102 +1533,69 @@ async function runConversation(engine, userId, userMessage, options = {}, _model
       let responseModel = model;
       let streamContent = '';
 
-      const tryModelCall = async (retryForFallback = true) => {
-        try {
-          const modelCall = await engine.requestModelResponse({
-            provider,
-            providerName,
-            model,
-            messages,
-            tools,
-            options: {
-              ...options,
-              userId,
-              agentId,
-              runId,
-              phase: 'model_turn',
-              signal: engine.getRunMeta(runId)?.abortController?.signal,
-            },
-            runId,
-            iteration,
-          });
-          response = modelCall.response;
-          responseModel = modelCall.responseModel;
-          streamContent = modelCall.streamContent;
-          recordModelSuccess(userId, agentId, modelSelectionId);
-        } catch (err) {
-          console.error(`[Engine] Model call failed (${model}):`, err.message);
-          recordModelFailure(userId, agentId, modelSelectionId, err);
-          const fallbackModelId = retryForFallback
-            ? await getFailureFallbackModelId(
-              userId,
-              agentId,
-              modelSelectionId,
-              aiSettings.fallback_model_id,
-              err,
-              engine.getRunMeta(runId)?.abortController?.signal,
-            )
-            : null;
-          if (fallbackModelId) {
-            const failedModel = model;
-            console.log(`[Engine] Attempting fallback to: ${fallbackModelId}`);
-            const fallback = await getProviderForUser(
-              userId,
-              userMessage,
-              triggerType === 'subagent',
-              fallbackModelId,
-              {
-                ...providerStatusConfig,
-                signal: engine.getRunMeta(runId)?.abortController?.signal,
-              }
-            );
-            provider = fallback.provider;
-            model = fallback.model;
-            modelSelectionId = fallback.modelSelectionId;
-            providerName = fallback.providerName;
-            db.prepare('UPDATE agent_runs SET model = ?, updated_at = datetime(\'now\') WHERE id = ?')
-              .run(modelSelectionId, runId);
-            Object.assign(engine.getRunMeta(runId) || {}, {
-              model,
-              modelSelectionId,
-              providerName,
-            });
-
-            const retryMessages = sanitizeConversationMessages([
-              ...messages,
-              {
-                role: 'system',
-                content: buildModelFailureLoopPrompt({
-                  failedModel,
-                  nextModel: model,
-                  errorMessage: err.message
-                })
-              }
-            ]);
-
-            const fallbackCall = await engine.requestModelResponse({
+      const tryModelCall = async () => {
+        let requestMessages = messages;
+        let requestPhase = 'model_turn';
+        while (true) {
+          try {
+            const modelCall = await engine.requestModelResponse({
               provider,
               providerName,
               model,
-              messages: retryMessages,
+              messages: requestMessages,
               tools,
               options: {
                 ...options,
                 userId,
                 agentId,
                 runId,
-                phase: 'model_turn_fallback',
+                phase: requestPhase,
                 signal: engine.getRunMeta(runId)?.abortController?.signal,
               },
               runId,
               iteration,
             });
-            response = fallbackCall.response;
-            responseModel = fallbackCall.responseModel;
-            streamContent = fallbackCall.streamContent;
+            response = modelCall.response;
+            responseModel = modelCall.responseModel;
+            streamContent = modelCall.streamContent;
             recordModelSuccess(userId, agentId, modelSelectionId);
-          } else {
-            throw err;
+            return;
+          } catch (err) {
+            console.error(`[Engine] Model call failed (${model}):`, err.message);
+            const runSignal = engine.getRunMeta(runId)?.abortController?.signal;
+            if (isAbortError(err) || runSignal?.aborted) throw err;
+            if (modelFailureRecoveries >= loopPolicy.maxModelFailureRecoveries) {
+              recordFailedModel(
+                modelSelectionId,
+                err,
+                modelTurnFailedModelSelectionIds,
+              );
+              throw err;
+            }
+
+            const failedModel = model;
+            const switched = await switchToFallbackModel(
+              modelSelectionId,
+              err,
+              'model turn',
+              modelTurnFailedModelSelectionIds,
+            );
+            if (!switched) throw err;
+
+            modelFailureRecoveries += 1;
+            failedStepCount += 1;
+            requestPhase = 'model_turn_fallback';
+            requestMessages = sanitizeConversationMessages([
+              ...messages,
+              {
+                role: 'system',
+                content: buildModelFailureLoopPrompt({
+                  failedModel,
+                  nextModel: model,
+                  errorMessage: err.message
+                })
+              }
+            ]);
           }
         }
       };
@@ -1601,30 +1618,6 @@ async function runConversation(engine, userId, userMessage, options = {}, _model
           continue;
         }
         if (lifecycleControl?.action === 'stop' || lifecycleControl?.action === 'interrupt') break;
-        const modelError = String(err?.message || 'Model call failed');
-
-        if (modelFailureRecoveries < loopPolicy.maxModelFailureRecoveries) {
-          const failedModel = model;
-          const switched = await switchToFallbackModel(modelSelectionId, err, 'model turn');
-          if (!switched) throw err;
-          modelFailureRecoveries += 1;
-          failedStepCount += 1;
-          messages.push({
-            role: 'system',
-            content: buildModelFailureLoopPrompt({
-              failedModel,
-              nextModel: model,
-              errorMessage: modelError
-            })
-          });
-          engine.emit(userId, 'run:interim', {
-            runId,
-            message: 'Model call failed; adapting and retrying autonomously.',
-            phase: 'recovering'
-          });
-          continue;
-        }
-
         throw err;
       }
 

package/server/services/ai/model_failure_cache.js

@@ -1,6 +1,15 @@
 'use strict';
 
+const { isAbortError } = require('../../utils/abort');
+const {
+  getErrorCode,
+  getHttpStatus,
+  isTransientIoError,
+  retryAfterMilliseconds,
+} = require('../../utils/retry');
+
 const DEFAULT_COOLDOWN_MS = 15 * 60 * 1000;
+const DEFAULT_RECOVERY_COOLDOWN_MS = 60 * 1000;
 const failures = new Map();
 
 function cacheKey(userId, agentId, modelSelectionId) {
@@ -11,28 +20,57 @@ function cacheKey(userId, agentId, modelSelectionId) {
   ].join(':');
 }
 
-function readCooldownMs() {
+function readPermanentCooldownMs() {
   const configured = Number(process.env.NEOAGENT_MODEL_NOT_FOUND_COOLDOWN_MS);
   if (!Number.isFinite(configured)) return DEFAULT_COOLDOWN_MS;
   return Math.max(1_000, Math.min(configured, 24 * 60 * 60 * 1000));
 }
 
+function readRecoveryCooldownMs() {
+  const configured = Number(process.env.NEOAGENT_MODEL_RECOVERY_COOLDOWN_MS);
+  if (!Number.isFinite(configured)) return DEFAULT_RECOVERY_COOLDOWN_MS;
+  return Math.max(1_000, Math.min(configured, 15 * 60 * 1000));
+}
+
 function isPermanentModelFailure(error) {
-  const status = Number(
-    error?.status
-    ?? error?.statusCode
-    ?? error?.response?.status,
-  );
+  const status = getHttpStatus(error);
   if (status === 404) return true;
   return /\b404\b.*\b(model|nim|provider|request)\b|\b(model|nim)\b.*\b404\b/i
     .test(String(error?.message || ''));
 }
 
+function isRecoverableModelFailure(error) {
+  if (!error || isAbortError(error) || isPermanentModelFailure(error)) return false;
+  const status = getHttpStatus(error);
+  if (status === 401 || status === 403 || status === 429 || (status >= 500 && status < 600)) {
+    return true;
+  }
+  const code = String(getErrorCode(error) || '');
+  if (code === 'MODEL_EMPTY_RESPONSE' || code === 'MODEL_CALL_TIMEOUT') return true;
+  if (isTransientIoError(error)) return true;
+  return /\bempty response|temporarily unavailable|overloaded|rate.?limit|timed? ?out|network error\b/i
+    .test(String(error?.message || ''));
+}
+
+function resolveCooldownMs(error, now) {
+  if (isPermanentModelFailure(error)) return readPermanentCooldownMs();
+  if (!isRecoverableModelFailure(error)) return 0;
+
+  const configured = readRecoveryCooldownMs();
+  const retryAfter = retryAfterMilliseconds(
+    error?.headers || error?.response?.headers,
+    now,
+  );
+  if (!Number.isFinite(retryAfter)) return configured;
+  return Math.max(configured, Math.min(retryAfter, 15 * 60 * 1000));
+}
+
 function recordModelFailure(userId, agentId, modelSelectionId, error, now = Date.now()) {
   const modelId = String(modelSelectionId || '').trim();
-  if (!modelId || !isPermanentModelFailure(error)) return false;
+  const cooldownMs = resolveCooldownMs(error, now);
+  if (!modelId || cooldownMs <= 0) return false;
   failures.set(cacheKey(userId, agentId, modelId), {
-    expiresAt: now + readCooldownMs(),
+    expiresAt: now + cooldownMs,
   });
   return true;
 }
@@ -64,6 +102,7 @@ module.exports = {
   clearModelFailureCache,
   isModelCoolingDown,
   isPermanentModelFailure,
+  isRecoverableModelFailure,
   recordModelFailure,
   recordModelSuccess,
 };

package/server/services/ai/providers/google.js

@@ -1,7 +1,63 @@
-const { GoogleGenerativeAI } = require('@google/generative-ai');
+'use strict';
+
+const { GoogleGenAI } = require('@google/genai');
 const { BaseProvider } = require('./base');
 const { fetchResponseText } = require('../../network/http');
 
+function parseToolArguments(value) {
+  try {
+    const parsed = JSON.parse(value || '{}');
+    return parsed && typeof parsed === 'object' && !Array.isArray(parsed)
+      ? parsed
+      : {};
+  } catch {
+    return {};
+  }
+}
+
+function normalizeUsage(usage) {
+  if (!usage) return null;
+  return {
+    inputTokens: usage.promptTokenCount || 0,
+    outputTokens: usage.candidatesTokenCount || 0,
+    reasoningTokens: usage.thoughtsTokenCount || 0,
+    cachedReadTokens: usage.cachedContentTokenCount || 0,
+    cacheWriteTokens: 0,
+    promptTokens: usage.promptTokenCount || 0,
+    completionTokens: usage.candidatesTokenCount || 0,
+    totalTokens: usage.totalTokenCount || 0
+  };
+}
+
+function collectResponseParts(response, toolCalls, seenToolCalls = null) {
+  let content = '';
+  for (const candidate of response?.candidates || []) {
+    for (const part of candidate.content?.parts || []) {
+      if (part.text && part.thought !== true) content += part.text;
+      if (!part.functionCall?.name) continue;
+
+      const args = part.functionCall.args || {};
+      const providerCallId = String(part.functionCall.id || '').trim();
+      const signature = providerCallId
+        || `${part.functionCall.name}:${JSON.stringify(args)}`;
+      if (seenToolCalls?.has(signature)) continue;
+      seenToolCalls?.add(signature);
+
+      toolCalls.push({
+        id: providerCallId
+          || `call_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
+        type: 'function',
+        function: {
+          name: part.functionCall.name,
+          arguments: JSON.stringify(args),
+          thought_signature: part.thoughtSignature
+        }
+      });
+    }
+  }
+  return content;
+}
+
 class GoogleProvider extends BaseProvider {
   constructor(config = {}) {
     super(config);
@@ -29,7 +85,7 @@ class GoogleProvider extends BaseProvider {
       'gemini-1.5-flash': 1048576,
     };
     this.apiKey = config.apiKey || process.env.GOOGLE_AI_KEY;
-    this.genAI = new GoogleGenerativeAI(this.apiKey);
+    this.genAI = new GoogleGenAI({ apiKey: this.apiKey });
   }
 
   async listModels(signal = null) {
@@ -78,11 +134,23 @@ class GoogleProvider extends BaseProvider {
       functionDeclarations: tools.map(tool => ({
         name: tool.name,
         description: tool.description,
-        parameters: tool.parameters || { type: 'object', properties: {} }
+        parametersJsonSchema: tool.parameters || { type: 'object', properties: {} }
       }))
     }];
   }
 
+  buildGenerateConfig(systemInstruction, tools, options) {
+    const config = {};
+    if (systemInstruction) config.systemInstruction = systemInstruction;
+    if (tools.length > 0) config.tools = this.formatTools(tools);
+    if (options.signal) config.abortSignal = options.signal;
+    const maxOutputTokens = Number(options.maxTokens);
+    if (Number.isFinite(maxOutputTokens) && maxOutputTokens > 0) {
+      config.maxOutputTokens = Math.floor(maxOutputTokens);
+    }
+    return config;
+  }
+
   convertMessages(messages) {
     let systemInstruction = '';
     const history = [];
@@ -93,16 +161,16 @@ class GoogleProvider extends BaseProvider {
         continue;
       }
       if (msg.role === 'tool') {
+        const functionResponse = {
+          name: msg.name || 'tool',
+          response: { result: msg.content }
+        };
+        if (msg.tool_call_id) functionResponse.id = msg.tool_call_id;
         history.push({
-          // Gemini chat history only accepts user/model roles. Tool results are
-          // represented as functionResponse parts on a user turn.
+          // The current Gemini API represents tool results as functionResponse
+          // parts on a user turn.
           role: 'user',
-          parts: [{
-            functionResponse: {
-              name: msg.name || 'tool',
-              response: { result: msg.content }
-            }
-          }]
+          parts: [{ functionResponse }]
         });
         continue;
       }
@@ -113,9 +181,10 @@ class GoogleProvider extends BaseProvider {
           const functionCallPart = {
             functionCall: {
               name: tc.function.name,
-              args: JSON.parse(tc.function.arguments || '{}')
+              args: parseToolArguments(tc.function.arguments)
             }
           };
+          if (tc.id) functionCallPart.functionCall.id = tc.id;
           if (tc.function.thought_signature) {
             functionCallPart.thoughtSignature = tc.function.thought_signature;
           }
@@ -149,8 +218,8 @@ class GoogleProvider extends BaseProvider {
       normalizedHistory.push({ role: currentRole, parts: currentParts });
     }
 
-    // Structured helpers can consist entirely of system instructions. Gemini's
-    // chat API still requires a user turn to trigger generation.
+    // Structured helpers can consist entirely of system instructions. Gemini
+    // still requires a user turn to trigger generation.
     if (
       normalizedHistory.length === 0
       || normalizedHistory[normalizedHistory.length - 1].role === 'model'
@@ -174,53 +243,18 @@ class GoogleProvider extends BaseProvider {
   async chat(messages, tools = [], options = {}) {
     const model = options.model || this.config.model || this.getDefaultModel();
     const { systemInstruction, history } = this.convertMessages(messages);
-
-    const genModel = this.genAI.getGenerativeModel({
+    const response = await this.genAI.models.generateContent({
       model,
-      systemInstruction: systemInstruction || undefined,
-      tools: tools.length > 0 ? this.formatTools(tools) : undefined
+      contents: history,
+      config: this.buildGenerateConfig(systemInstruction, tools, options)
     });
-
-    const lastMessage = history.pop();
-    const chat = genModel.startChat({ history });
-    const result = await chat.sendMessage(lastMessage.parts, { signal: options.signal });
-    const response = result.response;
-
-    let content = '';
     const toolCalls = [];
-
-    for (const candidate of response.candidates || []) {
-      for (const part of candidate.content?.parts || []) {
-        if (part.text) content += part.text;
-        if (part.functionCall) {
-          toolCalls.push({
-            id: `call_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
-            type: 'function',
-            function: {
-              name: part.functionCall.name,
-              arguments: JSON.stringify(part.functionCall.args || {}),
-              thought_signature: part.thoughtSignature
-            }
-          });
-        }
-      }
-    }
-
-    const usage = response.usageMetadata;
+    const content = collectResponseParts(response, toolCalls);
     return {
       content,
       toolCalls,
       finishReason: toolCalls.length > 0 ? 'tool_calls' : 'stop',
-      usage: usage ? {
-        inputTokens: usage.promptTokenCount || 0,
-        outputTokens: usage.candidatesTokenCount || 0,
-        reasoningTokens: usage.thoughtsTokenCount || 0,
-        cachedReadTokens: usage.cachedContentTokenCount || 0,
-        cacheWriteTokens: 0,
-        promptTokens: usage.promptTokenCount || 0,
-        completionTokens: usage.candidatesTokenCount || 0,
-        totalTokens: usage.totalTokenCount || 0
-      } : null,
+      usage: normalizeUsage(response.usageMetadata),
       model
     };
   }
@@ -228,60 +262,32 @@ class GoogleProvider extends BaseProvider {
   async *stream(messages, tools = [], options = {}) {
     const model = options.model || this.config.model || this.getDefaultModel();
     const { systemInstruction, history } = this.convertMessages(messages);
-
-    const genModel = this.genAI.getGenerativeModel({
+    const responseStream = await this.genAI.models.generateContentStream({
       model,
-      systemInstruction: systemInstruction || undefined,
-      tools: tools.length > 0 ? this.formatTools(tools) : undefined
+      contents: history,
+      config: this.buildGenerateConfig(systemInstruction, tools, options)
     });
-
-    const lastMessage = history.pop();
-    const chat = genModel.startChat({ history });
-    const result = await chat.sendMessageStream(lastMessage.parts, { signal: options.signal });
-
     let content = '';
     const toolCalls = [];
+    const seenToolCalls = new Set();
+    let usage = null;
 
-    for await (const chunk of result.stream) {
-      for (const candidate of chunk.candidates || []) {
-        for (const part of candidate.content?.parts || []) {
-          if (part.text) {
-            content += part.text;
-            yield { type: 'content', content: part.text };
-          }
-          if (part.functionCall) {
-            toolCalls.push({
-              id: `call_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
-              type: 'function',
-              function: {
-                name: part.functionCall.name,
-                arguments: JSON.stringify(part.functionCall.args || {}),
-                thought_signature: part.thoughtSignature
-              }
-            });
-          }
-        }
+    for await (const chunk of responseStream) {
+      const chunkContent = collectResponseParts(chunk, toolCalls, seenToolCalls);
+      if (chunkContent) {
+        content += chunkContent;
+        yield { type: 'content', content: chunkContent };
       }
+      if (chunk.usageMetadata) usage = chunk.usageMetadata;
     }
 
-    const finalResponse = await result.response;
-    const usage = finalResponse.usageMetadata;
-
     yield {
       type: 'done',
       content,
       toolCalls,
       finishReason: toolCalls.length > 0 ? 'tool_calls' : 'stop',
-      usage: usage ? {
-        inputTokens: usage.promptTokenCount || 0,
-        outputTokens: usage.candidatesTokenCount || 0,
-        reasoningTokens: usage.thoughtsTokenCount || 0,
-        cachedReadTokens: usage.cachedContentTokenCount || 0,
-        cacheWriteTokens: 0,
-        promptTokens: usage.promptTokenCount || 0,
-        completionTokens: usage.candidatesTokenCount || 0,
-        totalTokens: usage.totalTokenCount || 0
-      } : null
+      usage: normalizeUsage(usage),
+      model
     };
   }
 }

package/server/services/ai/terminal_reply.js

@@ -10,7 +10,13 @@ function normalizeReply(content) {
 }
 
 function hasExternalBlocker(text) {
-  return /\b(?:blocked|cannot|can't|could not|couldn't|unable to|do not have access|don't have access|missing (?:access|credentials|permission|information)|need you to|requires? your|waiting for your|please (?:provide|send|choose|confirm|authorize|approve))\b/.test(text);
+  return /\b(?:blocked|cannot|can't|could not|couldn't|unable to|do not have access|don't have access|missing (?:access|credentials|permission|information)|need you to|requires? your|waiting for your|please (?:provide|send|choose|confirm|authorize|approve)|blockiert|kann nicht|konnte nicht|mir fehlt|ich brauche von dir|warte auf dein(?:e|en)?|bitte (?:gib|schick|sende|nenn|bestätige|waehle|wähle|genehmige))\b/.test(text);
+}
+
+function isTerminalQuestionOrBlockerReply(content) {
+  const text = normalizeReply(content);
+  if (!text) return false;
+  return /[?？]/.test(text) || hasExternalBlocker(text);
 }
 
 /**
@@ -36,10 +42,16 @@ function isDeferredWorkReply(content) {
     /^(?:working on it|checking now|on it)[.!…]*$/,
     /\bi(?:'ll| will)\s+(?:get back to you|update you|report back|let you know|keep you posted)\b/,
     /\b(?:i(?:'ll| will)\s+follow up|stay tuned)\b/,
+    /^(?:(?:klar|okay|ok|alles klar)[,.!]?\s+)?ich\s+(?:(?:arbeite|pruefe|prüfe|schaue|untersuche|teste|debugge|starte)\s+(?:(?:gerade|aktuell|jetzt|noch)\b|(?:das|dies|die logs?|den code|deine anfrage|deinen auftrag)\b)|(?:kuemmere|kümmere)\s+mich\s+(?:gerade|aktuell|jetzt|noch)\b)/,
+    /^(?:(?:klar|okay|ok|alles klar)[,.!]?\s+)?ich\s+(?:werde|wuerde|würde)\s+(?:jetzt\s+)?(?:pruefen|prüfen|nachsehen|untersuchen|testen|debuggen|starten|fixen|erledigen)\b/,
+    /^(?:(?:klar|okay|ok|alles klar)[,.!]?\s+)?(?:lass|lasst)\s+mich\s+(?:(?:das|dies|die logs?|den code)\s+)?(?:pruefen|prüfen|nachsehen|untersuchen|testen|debuggen)\b/,
+    /^(?:gib mir|gebt mir)\s+(?:einen\s+)?(?:moment|augenblick)|^(?:bin dran|mache ich)[.!…]*$/,
+    /\bich\s+(?:melde mich|gebe dir bescheid|halte dich auf dem laufenden)\b/,
   ];
   return patterns.some((pattern) => pattern.test(text));
 }
 
 module.exports = {
   isDeferredWorkReply,
+  isTerminalQuestionOrBlockerReply,
 };