mixdog 0.9.166 → 0.9.167

package/src/runtime/agent/orchestrator/providers/antigravity-oauth.mjs

@@ -37,10 +37,18 @@ import {
     DEFAULT_ANTIGRAVITY_MODEL,
     antigravityHeaders,
     ensureAccessToken,
+    ensureAntigravityVersion,
     hasAntigravityOAuthCredentials,
     loadTokens,
     _scrubTokens,
 } from './antigravity-oauth-tokens.mjs';
+import {
+    antigravityModelCache,
+    antigravityQuotaWindows,
+    fetchAvailableModels,
+    normalizeAntigravityCatalog,
+    resolveAntigravityWireModel,
+} from './antigravity-oauth-catalog.mjs';
 
 const CLAUDE_THINKING_BETA = 'interleaved-thinking-2025-05-14';
 
@@ -61,9 +69,16 @@ function antigravityError(res, text, endpoint) {
     }
     // Account verification is terminal and actionable: surface the URL Google
     // returns instead of a raw API body the user cannot act on.
-    const validationUrl = /https:\/\/\S*(?:accounts|console)\.google\.com\/\S+/.exec(message || '');
+    // Google puts the link in the error details, not the message text.
+    const validationDetail = Array.isArray(detail?.details)
+        ? detail.details.find((entry) => entry?.reason === 'VALIDATION_REQUIRED' && typeof entry.metadata?.validation_url === 'string')
+        : null;
+    const validationUrl = validationDetail?.metadata.validation_url
+        || /https:\/\/\S*(?:accounts|console)\.google\.com\/\S+/.exec(message || '')?.[0]
+        || '';
     if (res.status === 403 && /VALIDATION_REQUIRED/i.test(text || '')) {
-        err.message = `Antigravity requires account verification${validationUrl ? `: ${validationUrl[0]}` : ''}`;
+        err.message = `Antigravity requires account verification${validationUrl ? `: open ${validationUrl} , complete the check, then retry` : ''}`;
+        err.validationUrl = validationUrl || undefined;
         err.unsafeToRetry = true;
     }
     return err;
@@ -90,6 +105,28 @@ function antigravityFailoverEligible(err) {
     return status === 0;
 }
 
+async function storedAuth(options) {
+    const tokens = await ensureAccessToken(options);
+    return { accessToken: tokens.access_token, projectId: tokens.project_id, email: tokens.email || '' };
+}
+
+// A retired wire id answers with one plain-text notice and no finishReason.
+// That is a terminal answer about the model, not a truncated stream.
+const RETIRED_MODEL_NOTICE = /\bno longer (?:available|supported)\b/i;
+
+function retiredModelError(err, streamedText, model) {
+    if (!(err?.code === 'TRUNCATED_STREAM' && /no finishReason/.test(String(err?.message || '')))) return null;
+    const text = String(streamedText || '').trim();
+    if (!RETIRED_MODEL_NOTICE.test(text)) return null;
+    return Object.assign(new Error(`Antigravity retired ${model}: ${text}`), {
+        code: 'MODEL_RETIRED',
+        status: 404,
+        httpStatus: 404,
+        unsafeToRetry: true,
+        modelRetired: true,
+    });
+}
+
 export class AntigravityOAuthProvider {
     // usageMetadata.promptTokenCount is the total, cached tokens included.
     static inputExcludesCache = false;
@@ -101,7 +138,12 @@ export class AntigravityOAuthProvider {
         this._preconnect = typeof config.preconnectFn === 'function' ? config.preconnectFn : preconnect;
         // AuthStorage equivalent: refreshes the token and resolves the project.
         // Injectable so wire-shape tests do not need a real credential store.
-        this._ensureAuth = typeof config.ensureAuthFn === 'function' ? config.ensureAuthFn : ensureAccessToken;
+        // The store keeps snake_case fields; requests read the camelCase view.
+        this._ensureAuth = typeof config.ensureAuthFn === 'function' ? config.ensureAuthFn : storedAuth;
+        // Client version for the hub identity header, discovered once per process.
+        this._ensureVersion = typeof config.ensureVersionFn === 'function'
+            ? config.ensureVersionFn
+            : () => ensureAntigravityVersion({ fetchFn: this._fetch });
         // Remember the endpoint that last answered so a session stops paying the
         // failover cost on every turn.
         this._lastGoodEndpoint = null;
@@ -123,20 +165,37 @@ export class AntigravityOAuthProvider {
     }
 
     async send(messages, model, tools, sendOpts = {}) {
-        const opts = sendOpts || {};
-        const signal = opts.signal || null;
-        const useModel = model || DEFAULT_ANTIGRAVITY_MODEL;
+        const signal = sendOpts?.signal || null;
+        // Picker ids name a tier family; the wire id carries the chosen effort.
+        const route = resolveAntigravityWireModel(model || DEFAULT_ANTIGRAVITY_MODEL, sendOpts?.effort);
+        const useModel = route.model;
+        const opts = route.effort === sendOpts?.effort
+            ? (sendOpts || {})
+            : { ...sendOpts, effort: route.effort, thinkingLevel: route.effort == null ? null : sendOpts?.thinkingLevel };
         const onToolCall = typeof opts.onToolCall === 'function' ? opts.onToolCall : null;
-        const onTextDelta = typeof opts.onTextDelta === 'function' ? opts.onTextDelta : null;
+        // Streamed text is kept so a retirement notice can be told apart from
+        // a truncated stream when the gateway omits the finishReason.
+        let streamedText = '';
+        const onTextDelta = typeof opts.onTextDelta === 'function'
+            ? (text) => { if (typeof text === 'string') streamedText += text; opts.onTextDelta(text); }
+            : null;
         const onStreamDelta = typeof opts.onStreamDelta === 'function' ? opts.onStreamDelta : null;
         if (signal?.aborted) {
             const reason = signal.reason;
             throw reason instanceof Error ? reason : new Error('Antigravity request aborted');
         }
 
-        const auth = await this._ensureAuth({ fetchFn: this._fetch });
+        this._preconnect(this._endpointOrder()[0]);
+        // Normalize history while version discovery and token refresh run.
+        // The authenticated project is bound only after those tasks finish.
+        const [, auth, request] = await Promise.all([
+            this._ensureVersion(),
+            this._ensureAuth({ fetchFn: this._fetch }),
+            Promise.resolve().then(() => this._buildBody(messages, useModel, tools, opts)),
+        ]);
         this._projectId = auth.projectId;
-        const body = JSON.stringify(this._buildBody(messages, useModel, tools, opts));
+        request.project = auth.projectId;
+        const body = JSON.stringify(request);
         const headers = {
             Authorization: `Bearer ${auth.accessToken}`,
             'Content-Type': 'application/json',
@@ -146,6 +205,42 @@ export class AntigravityOAuthProvider {
         };
 
         let textLeakGuard = null;
+        let terminalFailure = null;
+        let streamedParts = [];
+        let streamedNativeToolCalls = [];
+        const seenNativeToolIds = new Set();
+        const emittedToolIds = new Set();
+        const dispatchToolCall = onToolCall ? (call) => {
+            // A failure already observed in this chunk must win over both
+            // native calls and calls recovered from its text.
+            if (terminalFailure || emittedToolIds.has(call.id)) return;
+            emittedToolIds.add(call.id);
+            onToolCall(call);
+        } : null;
+        const onChunk = (chunk) => {
+            const candidate = chunk?.candidates?.[0];
+            const finishReason = candidate?.finishReason
+                || (chunk?.promptFeedback?.blockReason ? `PROMPT_${chunk.promptFeedback.blockReason}` : null);
+            if (finishReason && String(finishReason).replace(/^FINISH_REASON_/, '') !== 'STOP') {
+                terminalFailure ||= finishReason;
+            }
+            if (!onToolCall) return;
+            const parts = candidate?.content?.parts ?? [];
+            streamedParts.push(...parts);
+            if (terminalFailure || !parts.some((part) => part?.functionCall)) return;
+            // Parse against the turn's parts so anonymous call IDs keep the
+            // same ordinal as final parsing, even across separate SSE chunks.
+            const fresh = (parseToolCalls(streamedParts) || []).filter((call) => {
+                if (seenNativeToolIds.has(call.id)) return false;
+                seenNativeToolIds.add(call.id);
+                return true;
+            });
+            const calls = textLeakGuard?.enabled
+                ? textLeakGuard.filterNativeToolCalls(fresh)
+                : fresh;
+            if (calls?.length) streamedNativeToolCalls.push(...calls);
+            emitGeminiToolCalls(calls, dispatchToolCall);
+        };
         const passthrough = createPassthroughSignal(signal);
         const endpoints = this._endpointOrder();
         let lastErr = null;
@@ -185,21 +280,45 @@ export class AntigravityOAuthProvider {
                             textLeakGuard = createGeminiTextLeakGuard({
                                 knownToolNames: tools?.map((t) => t.name).filter(Boolean) ?? [],
                                 onTextDelta,
-                                onToolCall,
+                                onToolCall: dispatchToolCall,
                                 onStreamDelta,
                             });
-                            return await consumeGeminiRestStreamResponse(res, {
-                                signal: attemptSignal,
-                                onStreamDelta,
-                                onTextDelta,
-                                textLeakGuard,
-                                label: 'Antigravity streamGenerateContent',
-                                // Cloud Code Assist nests the Gemini payload under
-                                // `response`; in-band error events stay top level.
-                                unwrapChunk: (chunk) => (chunk && typeof chunk === 'object' && chunk.response
-                                    ? chunk.response
-                                    : chunk),
-                            });
+                            streamedText = '';
+                            terminalFailure = null;
+                            streamedParts = [];
+                            streamedNativeToolCalls = [];
+                            seenNativeToolIds.clear();
+                            emittedToolIds.clear();
+                            try {
+                                return await consumeGeminiRestStreamResponse(res, {
+                                    signal: attemptSignal,
+                                    onStreamDelta,
+                                    onTextDelta,
+                                    onChunk,
+                                    textLeakGuard,
+                                    label: 'Antigravity streamGenerateContent',
+                                    // Cloud Code Assist nests the Gemini payload under
+                                    // `response`; in-band error events stay top level.
+                                    unwrapChunk: (chunk) => (chunk && typeof chunk === 'object' && chunk.response
+                                        ? chunk.response
+                                        : chunk),
+                                });
+                            } catch (streamErr) {
+                                const error = retiredModelError(streamErr, streamedText, useModel) || streamErr;
+                                // Native calls now run before EOF. Preserve
+                                // their history and prohibit resampling after
+                                // a tool callback, including on another host.
+                                if (emittedToolIds.size) {
+                                    error.emittedToolCall = true;
+                                    error.unsafeToRetry = true;
+                                    const leaked = textLeakGuard.getLeakedToolCalls();
+                                    error.partialToolCalls = [...streamedNativeToolCalls, ...leaked];
+                                    const replay = createProviderReplay('antigravity', leaked.length ? [] : streamedParts);
+                                    if (replay) replay.requestContext = { model: useModel };
+                                    if (replay) error.partialProviderReplay = replay;
+                                }
+                                throw error;
+                            }
                         },
                         {
                             signal: passthrough.signal,
@@ -273,19 +392,23 @@ export class AntigravityOAuthProvider {
         const leakedToolCalls = textLeakGuard?.getLeakedToolCalls() ?? [];
         const providerReplay = createProviderReplay(
             'antigravity',
-            leakedToolCalls.length ? [] : responseParts,
+            leakedToolCalls.length || rawContent !== content ? [] : responseParts,
         );
-        let nativeToolCalls = parseToolCalls(responseParts);
-        if (textLeakGuard?.enabled) nativeToolCalls = textLeakGuard.filterNativeToolCalls(nativeToolCalls);
+        // Thought signatures are only valid for the model family that minted
+        // them; the request builder consults this when the route changes.
+        if (providerReplay) providerReplay.requestContext = { model: useModel };
+        let nativeToolCalls = onToolCall
+            ? (streamedNativeToolCalls.length ? streamedNativeToolCalls : undefined)
+            : parseToolCalls(responseParts);
+        if (!onToolCall && textLeakGuard?.enabled) nativeToolCalls = textLeakGuard.filterNativeToolCalls(nativeToolCalls);
         let toolCalls = nativeToolCalls;
         if (leakedToolCalls.length) {
             toolCalls = toolCalls?.length ? [...toolCalls, ...leakedToolCalls] : leakedToolCalls;
         }
         const citations = collectGeminiGroundingSources(candidate);
-        emitGeminiToolCalls(nativeToolCalls, onToolCall);
 
         const promptBlockReason = response.promptFeedback?.blockReason || null;
-        const finishReason = candidate?.finishReason || (promptBlockReason ? `PROMPT_${promptBlockReason}` : null);
+        const finishReason = terminalFailure || candidate?.finishReason || (promptBlockReason ? `PROMPT_${promptBlockReason}` : null);
         const normalizedFinish = String(finishReason || '').replace(/^FINISH_REASON_/, '');
         if (finishReason && normalizedFinish !== 'STOP') {
             throw Object.assign(new Error(`Antigravity response incomplete: finishReason=${finishReason}`), {
@@ -299,6 +422,7 @@ export class AntigravityOAuthProvider {
                 providerMetadata,
                 model: useModel,
                 rawUsage: response.usageMetadata || null,
+                ...(emittedToolIds.size ? { emittedToolCall: true, unsafeToRetry: true } : {}),
             });
         }
 
@@ -337,12 +461,50 @@ export class AntigravityOAuthProvider {
         };
     }
 
-    // The gateway publishes no public catalog endpoint, so the curated list in
-    // the tokens module is the source of truth.
+    async _fetchRawModels(signal = null) {
+        await this._ensureVersion();
+        const auth = await this._ensureAuth({ fetchFn: this._fetch });
+        return fetchAvailableModels({
+            accessToken: auth.accessToken,
+            projectId: auth.projectId,
+            fetchFn: this._fetch,
+            signal,
+        });
+    }
+
+    // Live catalog with a disk cache; the curated list covers an offline or
+    // signed-out daemon so the picker never goes empty.
     async listModels() {
+        const cached = antigravityModelCache.loadSync();
+        if (cached) return cached;
+        try {
+            const models = normalizeAntigravityCatalog(await this._fetchRawModels());
+            if (models.length) {
+                antigravityModelCache.save(models);
+                return models;
+            }
+        } catch (err) {
+            console.warn(`[antigravity-oauth] catalog refresh failed, using the curated list: ${err?.message || err}`);
+        }
         return ANTIGRAVITY_MODELS;
     }
 
+    async _refreshModelCache() {
+        const models = normalizeAntigravityCatalog(await this._fetchRawModels());
+        if (!models.length) throw new Error('[antigravity-oauth] fetchAvailableModels listed no chat models');
+        antigravityModelCache.save(models);
+        return models;
+    }
+
+    async getUsageSnapshot() {
+        return {
+            provider: this.name,
+            model: null,
+            source: 'antigravity-models',
+            quotaWindows: antigravityQuotaWindows(await this._fetchRawModels()),
+        };
+    }
+
     async isAvailable() {
         try {
             if (!hasAntigravityOAuthCredentials()) return false;

package/src/runtime/agent/orchestrator/providers/antigravity-request.mjs

@@ -10,10 +10,19 @@ export function isAntigravityClaude(model) {
     return /^claude-/i.test(String(model || ''));
 }
 
+// A replay recorded by the other model family (Claude vs Gemini) carries
+// signatures the target model rejects; rebuild it from the plain history
+// with the recovery sentinel instead.
+function replayFamilyMatches(message, model) {
+    const recorded = message?.providerReplay?.requestContext?.model;
+    if (typeof recorded !== 'string' || !recorded) return true;
+    return isAntigravityClaude(recorded) === isAntigravityClaude(model);
+}
+
 function signatureSafeMessages(messages, model) {
     return messages.map(message => {
         if (message?.role !== 'assistant') return message;
-        const ownParts = providerReplayItems(message, 'antigravity');
+        const ownParts = replayFamilyMatches(message, model) ? providerReplayItems(message, 'antigravity') : undefined;
         // Repair tool signatures only after the complete history establishes
         // the active turn, not while normalizing an isolated older message.
         const parts = ownParts || toGeminiContents([message], model, { repairToolSignatures: false })[0]?.parts;
@@ -60,20 +69,12 @@ export function buildAntigravityRequest(messages, model, tools, opts = {}, proje
             thinkingConfig.thinkingBudget = value;
         }
     } else {
+        // Tiered wire ids (gemini-3.8-flash-high) already encode the thinking
+        // level; the provider resolves them from the catalog and clears the
+        // effort, so only bare ids reach this field.
         thinkingConfig = geminiThinkingConfig(model, opts, {
             includeThoughts: /^gemini-3/i.test(model) ? true : undefined,
         });
-        // This gateway selects Gemini Pro thinking tiers by model ID; Flash
-        // uses the bare model ID plus the ordinary thinkingLevel field.
-        if (thinkingConfig?.thinkingLevel && /^gemini-3(?:\.\d+)?-pro(?:-|$)/i.test(model)) {
-            const level = thinkingConfig.thinkingLevel;
-            if (!['low', 'high'].includes(level)) {
-                throw new TypeError('Antigravity Gemini Pro supports low/high model tiers.');
-            }
-            model = `${model.replace(/-(?:low|medium|high)$/i, '')}-${level}`;
-        } else if (thinkingConfig?.thinkingLevel && /^gemini-3(?:\.\d+)?-flash(?:-|$)/i.test(model)) {
-            model = model.replace(/-(?:minimal|low|medium|high)$/i, '');
-        }
     }
     const generationConfig = {
         ...(claude ? { maxOutputTokens: CLAUDE_MAX_OUTPUT_TOKENS } : {}),

package/src/runtime/agent/orchestrator/providers/cursor-wire-guards.mjs

@@ -4,7 +4,6 @@ const SCHEMA_ANNOTATIONS = new Set([
     '$schema',
     'default',
     'deprecated',
-    'description',
     'examples',
     'readOnly',
     'title',
@@ -105,13 +104,6 @@ function flattenCursorTopLevelCompoundSchema(schema) {
     };
 }
 
-function conciseDescription(value) {
-    const normalized = String(value || '').replace(/\s+/g, ' ').trim();
-    if (normalized.length <= 120) return normalized;
-    const sentence = normalized.match(/^.{24,117}?[.!?](?:\s|$)/)?.[0]?.trim();
-    return sentence || `${normalized.slice(0, 117)}...`;
-}
-
 export function prepareCursorToolDefinition(tool) {
     const fn = tool?.function || tool || {};
     const inputSchema = fn.parameters && typeof fn.parameters === 'object'
@@ -119,7 +111,7 @@ export function prepareCursorToolDefinition(tool) {
         : { type: 'object', properties: {} };
     return {
         name: fn.name,
-        description: conciseDescription(fn.description),
+        description: String(fn.description || ''),
         inputSchema,
     };
 }

package/src/runtime/agent/orchestrator/providers/cursor-wire-protobuf.mjs

@@ -30,8 +30,11 @@ const SCHEMAS = {
         ['mimeType', 7, 'string'],
         ['data', 8, 'bytes'],
     ]),
-    UserMessageAction: fields([['userMessage', 1, 'UserMessage']]),
-    ResumeAction: fields([]),
+    UserMessageAction: fields([
+        ['userMessage', 1, 'UserMessage'],
+        ['requestContext', 2, 'RequestContext'],
+    ]),
+    ResumeAction: fields([['requestContext', 2, 'RequestContext']]),
     ConversationAction: fields([
         ['userMessageAction', 1, 'UserMessageAction'],
         ['resumeAction', 2, 'ResumeAction'],

package/src/runtime/agent/orchestrator/providers/cursor-wire.mjs

@@ -1,5 +1,6 @@
 import crypto, { createHash } from 'node:crypto';
 import http2 from 'node:http2';
+import { isDeepStrictEqual } from 'node:util';
 import {
     AUTO_MODEL,
     FALLBACK_MODELS,
@@ -380,6 +381,7 @@ function buildToolDefinitions(tools = []) {
             description: prepared.description,
             inputSchema: encodeJsonValue(prepared.inputSchema),
             inputSchemaJson: JSON.stringify(prepared.inputSchema),
+            inputSchemaObject: prepared.inputSchema,
             providerIdentifier: 'mixdog',
             toolName: prepared.name,
         };
@@ -405,6 +407,33 @@ function requestModelParameters(body) {
         .filter((entry) => entry.id);
 }
 
+function buildRequestContext(tools, cloudRule) {
+    return {
+        tools,
+        mcpInstructions: tools.length ? [{
+            serverName: 'mixdog',
+            instructions: 'Use the tools provided by the mixdog MCP server for this task. '
+                + 'Follow their descriptions and input schemas. Prefer them over Cursor native tools; '
+                + 'native tools do not directly access the Mixdog environment. '
+                + 'If a needed tool is not available, use the provided tool discovery mechanism rather than inventing a tool.',
+        }] : [],
+        ...(cloudRule ? { cloudRule } : {}),
+        fileContents: {},
+    };
+}
+
+function canReuseRun(active, { tools, cloudRule, modelParameters, maxMode }) {
+    const toolContract = (definitions) => new Map(definitions.map((tool) => [
+        tool.name,
+        { description: tool.description, inputSchema: tool.inputSchemaObject },
+    ]));
+    const parameters = (values) => new Map(values.map(({ id, value }) => [id, value]));
+    return (active.cloudRule || '') === (cloudRule || '')
+        && isDeepStrictEqual(toolContract(active.tools), toolContract(tools))
+        && isDeepStrictEqual(parameters(active.modelParameters || []), parameters(modelParameters))
+        && (active.maxMode === true) === maxMode;
+}
+
 const conversations = new Map();
 const activeRuns = new Map();
 const MEMORY_TTL_MS = 30 * 60_000;
@@ -522,11 +551,8 @@ function storeBlob(conversation, bytes) {
 
 function buildRunRequest({ model, modelParameters = [], maxMode = false, systems, history, userText, userImages = [], tools, conversation }) {
     assertCursorUserImages(userImages);
-    const prompts = systems.length ? systems : ['You are a helpful assistant.'];
+    const requestContext = buildRequestContext(tools, systems.join('\n\n') || undefined);
     const rootPromptMessagesJson = [];
-    for (const content of prompts) {
-        rootPromptMessagesJson.push(storeBlob(conversation, textEncoder.encode(JSON.stringify({ role: 'system', content }))));
-    }
     for (const entry of history) {
         rootPromptMessagesJson.push(storeBlob(conversation, textEncoder.encode(JSON.stringify(entry))));
     }
@@ -535,6 +561,7 @@ function buildRunRequest({ model, modelParameters = [], maxMode = false, systems
     const action = userText || userImages.length
         ? {
             userMessageAction: {
+                requestContext,
                 userMessage: {
                     text: userText,
                     messageId: crypto.randomUUID(),
@@ -550,7 +577,7 @@ function buildRunRequest({ model, modelParameters = [], maxMode = false, systems
                 },
             },
         }
-        : { resumeAction: {} };
+        : { resumeAction: { requestContext } };
     return encodeMessage('AgentClientMessage', {
         runRequest: {
             conversationState: stateBytes,
@@ -560,13 +587,12 @@ function buildRunRequest({ model, modelParameters = [], maxMode = false, systems
                 maxMode: maxMode === true,
                 parameters: modelParameters,
             },
-            mcpTools: { mcpTools: tools },
             conversationId: conversation.id,
             // NOTE: AgentRunRequest.customSystemPrompt (field 8) is a dead
             // channel on the current cloud endpoint: the server maps it to an
             // internal `--system-prompt` agent flag its binary rejects with
-            // invalid_argument (400). Harness parity is carried by the
-            // requestContext cloudRule instead (see handleExecMessage).
+            // invalid_argument (400). Send the harness once through the
+            // action's requestContext.cloudRule, not through root history too.
         },
     });
 }
@@ -671,15 +697,7 @@ function handleExecMessage(bridge, exec, tools, cloudRule, onToolCall) {
     if (exec.requestContextArgs) {
         sendExecResult(bridge, exec, 'requestContextResult', {
             success: {
-                requestContext: {
-                    tools,
-                    mcpInstructions: [],
-                    // Cursor's rules channel: without it the server-side agent
-                    // treats the client as ruleless and applies only its own
-                    // harness policy (user report: policies ignored vs direct).
-                    ...(cloudRule ? { cloudRule } : {}),
-                    fileContents: {},
-                },
+                requestContext: buildRequestContext(tools, cloudRule),
             },
         });
         return;
@@ -989,6 +1007,8 @@ function createStreamResponse({
     tools,
     cloudRule,
     model,
+    modelParameters = [],
+    maxMode = false,
     key,
     // Owning session, carried into the stored run so a session close can find
     // and tear down the pending batch's bridge/heartbeat.
@@ -1072,6 +1092,8 @@ function createStreamResponse({
                     conversation,
                     tools,
                     cloudRule,
+                    modelParameters,
+                    maxMode,
                     sessionId,
                     pending: state.pending,
                     sawTurnEnded: state.sawTurnEnded,
@@ -1361,8 +1383,12 @@ export async function handleChatCompletion(body, accessToken) {
     const maxMode = body.mixdog_max_mode === true;
     const sessionId = String(body.mixdog_session_id || '');
     const key = runKey(model, body.messages, sessionId);
+    const selectedTools = selectToolsForChoice(body.tools, body.tool_choice);
+    const toolDefinitions = buildToolDefinitions(selectedTools);
+    const cloudRule = parsed.systems.join('\n\n') || undefined;
     const active = activeRuns.get(key);
-    if (active && parsed.toolResults.length && active.bridge.alive) {
+    if (active && parsed.toolResults.length && active.bridge.alive
+        && canReuseRun(active, { tools: toolDefinitions, cloudRule, modelParameters, maxMode })) {
         forgetActiveRun(key, active);
         return resumeRun(active, parsed.toolResults, parsed.userText, model, key);
     }
@@ -1373,8 +1399,6 @@ export async function handleChatCompletion(body, accessToken) {
     }
     const convKey = conversationKey(body.messages, sessionId);
     const conversation = getConversation(convKey);
-    const selectedTools = selectToolsForChoice(body.tools, body.tool_choice);
-    const toolDefinitions = buildToolDefinitions(selectedTools);
     const runInput = {
         model,
         modelParameters,
@@ -1392,12 +1416,11 @@ export async function handleChatCompletion(body, accessToken) {
         bridge,
         heartbeat,
         conversation,
-        tools: toolDefinitions.map((definition, index) => ({
-            ...definition,
-            inputSchemaObject: selectedTools[index]?.function?.parameters || {},
-        })),
-        cloudRule: parsed.systems.join('\n\n') || undefined,
+        tools: toolDefinitions,
+        cloudRule,
         model,
+        modelParameters,
+        maxMode,
         key,
         sessionId,
         restart: ({ fromCheckpoint }) => startRun(

package/src/runtime/agent/orchestrator/providers/gemini-schema.mjs

@@ -526,12 +526,36 @@ function convertSchema(schema) {
     return result;
 }
 
+// Gemini's legacy Schema requires typed values. An unconstrained JSON value
+// (Office operation values, for example) cannot be replaced with a string or
+// an untyped Schema node. FunctionDeclaration.parametersJsonSchema is the
+// documented, mutually exclusive representation for the original JSON Schema.
+function needsJsonParameters(schema) {
+    if (typeof schema === 'boolean') return true;
+    if (!schema || typeof schema !== 'object') return false;
+    // The legacy dialect has no reference vocabulary; preserve both pointers
+    // and their definitions together, including recursive MCP contracts.
+    if (['$ref', '$defs', 'definitions'].some((key) => Object.hasOwn(schema, key))) return true;
+    const constraints = Object.keys(schema)
+        .filter((key) => !['description', 'title', 'default', 'examples', '$comment'].includes(key));
+    if (!constraints.length || (schema.type === 'array' && !schema.items)) return true;
+    const children = [
+        ...Object.values(schema.properties || {}),
+        ...(schema.items ? [schema.items] : []),
+        ...(typeof schema.additionalProperties === 'object' ? [schema.additionalProperties] : []),
+        ...(schema.anyOf || []), ...(schema.oneOf || []), ...(schema.allOf || []),
+    ];
+    return children.some(needsJsonParameters);
+}
+
 export function toGeminiTools(tools) {
     return {
         functionDeclarations: tools.map((t) => ({
             name: t.name,
             description: t.description,
-            parameters: convertSchema(t.inputSchema),
+            ...(needsJsonParameters(t.inputSchema)
+                ? { parametersJsonSchema: structuredClone(t.inputSchema) }
+                : { parameters: convertSchema(t.inputSchema) }),
         })),
     };
 }
@@ -832,7 +856,9 @@ export function parseToolCalls(parts) {
             // deterministic id only for older responses that omit it.
             id: typeof fc.id === 'string' && fc.id ? fc.id : `gemini_${idHash}`,
             name: fc.name,
-            arguments: (fc.args ?? {}),
+            // Execution may normalize nested arguments in place. Keep native
+            // replay and anonymous ID inputs independent of that working copy.
+            arguments: structuredClone(fc.args ?? {}),
         };
         if (typeof sig === 'string' && sig && sig.length <= 16_384) {
             call.thoughtSignature = sig;

package/src/runtime/agent/orchestrator/providers/gemini-stream.mjs

@@ -352,7 +352,7 @@ export function createGeminiTextLeakGuard({ knownToolNames, onTextDelta, onToolC
 // deeper. Cloud Code Assist (Antigravity) streams `{ response: { candidates … } }`
 // while the public API streams the candidates directly; everything downstream —
 // aggregation, leak guard, watchdogs — stays shared.
-export async function consumeGeminiRestStreamResponse(response, { signal, onStreamDelta, onTextDelta, textLeakGuard, label, unwrapChunk = null }) {
+export async function consumeGeminiRestStreamResponse(response, { signal, onStreamDelta, onTextDelta, textLeakGuard, label, unwrapChunk = null, onChunk = null }) {
     const unwrap = typeof unwrapChunk === 'function'
         ? (chunk) => { try { return unwrapChunk(chunk); } catch { return chunk; } }
         : (chunk) => chunk;
@@ -467,6 +467,7 @@ export async function consumeGeminiRestStreamResponse(response, { signal, onStre
                     clearFirstByteTimer();
                 }
                 allChunks.push(parsed);
+                onChunk?.(parsed);
                 try { onStreamDelta?.(geminiChunkProgressKind(parsed)); } catch {}
                 if (!sawFunctionCall && geminiChunkHasFunctionCall(parsed)) sawFunctionCall = true;
                 if (onTextDelta || textLeakGuard) {
@@ -494,6 +495,7 @@ export async function consumeGeminiRestStreamResponse(response, { signal, onStre
                             clearFirstByteTimer();
                         }
                         allChunks.push(parsed);
+                        onChunk?.(parsed);
                         try { onStreamDelta?.(geminiChunkProgressKind(parsed)); } catch {}
                         if (!sawFunctionCall && geminiChunkHasFunctionCall(parsed)) sawFunctionCall = true;
                         if (onTextDelta || textLeakGuard) {