@cortexkit/opencode-antigravity-auth 2.2.1 → 3.0.0

package/dist/src/plugin/request.js

@@ -1,11 +1,11 @@
 import crypto from 'node:crypto';
 import { ANTIGRAVITY_DEFAULT_PROJECT_ID, ANTIGRAVITY_ENDPOINT, CLAUDE_DESCRIPTION_PROMPT, CLAUDE_TOOL_SYSTEM_INSTRUCTION, EMPTY_SCHEMA_PLACEHOLDER_DESCRIPTION, EMPTY_SCHEMA_PLACEHOLDER_NAME, GEMINI_CLI_ENDPOINT, getRandomizedHeaders, SKIP_THOUGHT_SIGNATURE, } from '../constants';
 import { buildAgyAgentRequestMetadata, createAgyRequestSessionContext, orderAgyRequestPayloadInPlace, } from './agy-request-metadata';
-import { cacheSignature, getCachedSignature } from './cache';
+import { cacheSignature, getCachedSignature, } from './cache';
 import { getKeepThinking } from './config';
 import { createStreamingTransformer, transformSseLine, transformStreamingPayload, } from './core/streaming';
 import { DEBUG_MESSAGE_PREFIX, isDebugTuiEnabled, logAntigravityDebugResponse, logCacheStats, } from './debug';
-import { buildFingerprintHeaders, getSessionFingerprint, } from './fingerprint';
+import { buildFingerprintHeaders, generateFingerprint, getSessionFingerprint, } from './fingerprint';
 import { appendGeminiDumpResponseText, createGeminiDumpResponseTransform, noteGeminiDumpResponse, } from './gemini-dump';
 import { createLogger } from './logger';
 import { detectErrorType } from './recovery';
@@ -519,6 +519,58 @@ function configureAntigravityToolCalling(payload) {
     toolConfig.functionCallingConfig = functionCallingConfig;
     payload.toolConfig = toolConfig;
 }
+/**
+ * The native CLI sends a function response to a same-target call in a model
+ * turn (a request then ends with a model turn and gets the trailing user
+ * `[Continue]` turn). A call is same-target when it carries its own replay
+ * signature; a call whose signature was missing or stripped carries the
+ * validator sentinel and keeps its responses in a user turn.
+ */
+function normalizeNativeFunctionResponseRoles(payload) {
+    const contents = payload.contents;
+    if (!Array.isArray(contents))
+        return;
+    const signedCalls = new Set();
+    for (const content of contents) {
+        const parts = content?.parts;
+        if (!Array.isArray(parts))
+            continue;
+        let signedTurn = false;
+        for (const part of parts) {
+            const call = part
+                ?.functionCall;
+            if (!call)
+                continue;
+            const signature = part
+                .thoughtSignature;
+            // Only the first call of a turn carries the turn's signature.
+            if (typeof signature === 'string') {
+                signedTurn =
+                    signature.length >= MIN_SIGNATURE_LENGTH &&
+                        signature !== SKIP_THOUGHT_SIGNATURE;
+            }
+            if (signedTurn) {
+                signedCalls.add(String(call.id ?? call.name));
+            }
+        }
+    }
+    for (const content of contents) {
+        if (!content || typeof content !== 'object')
+            continue;
+        const record = content;
+        if (record.role !== 'user' || !Array.isArray(record.parts))
+            continue;
+        if (record.parts.length === 0)
+            continue;
+        const sameTarget = record.parts.every((part) => {
+            const response = part?.functionResponse;
+            return (response !== undefined &&
+                signedCalls.has(String(response.id ?? response.name)));
+        });
+        if (sameTarget)
+            record.role = 'model';
+    }
+}
 function sanitizeRequestPayloadForAntigravity(payload) {
     const anyPayload = payload;
     if (Array.isArray(anyPayload.contents)) {
@@ -557,8 +609,12 @@ function sanitizeRequestPayloadForAntigravity(payload) {
                         // Parallel function calls MUST NOT have a signature
                         sig = undefined;
                     }
+                    // The native CLI sends only the camel-case key; a snake-case
+                    // duplicate from host history is dropped.
                     if (sig) {
-                        return { ...part, thought_signature: sig, thoughtSignature: sig };
+                        const signed = { ...part, thoughtSignature: sig };
+                        delete signed.thought_signature;
+                        return signed;
                     }
                     // If not the first part, just return the part without adding any signature keys
                     const newPart = { ...part };
@@ -677,7 +733,7 @@ function getThinkingPartText(part) {
     }
     return '';
 }
-function hasCachedMatchingSignature(part, sessionId) {
+function hasCachedMatchingSignature(part, sessionId, wire) {
     if (!part || typeof part !== 'object') {
         return false;
     }
@@ -685,7 +741,7 @@ function hasCachedMatchingSignature(part, sessionId) {
     if (!text) {
         return false;
     }
-    const expectedSignature = getCachedSignature(sessionId, text);
+    const expectedSignature = wire.signatures.getCachedSignature(sessionId, text);
     if (!expectedSignature) {
         return false;
     }
@@ -715,7 +771,7 @@ function ensureThoughtSignature(part, sessionId) {
     }
     return part;
 }
-function hasSignedThinkingPart(part, sessionId) {
+function hasSignedThinkingPart(part, sessionId, wire) {
     if (!part || typeof part !== 'object') {
         return false;
     }
@@ -731,7 +787,7 @@ function hasSignedThinkingPart(part, sessionId) {
         if (!sessionId) {
             return true;
         }
-        return hasCachedMatchingSignature(part, sessionId);
+        return hasCachedMatchingSignature(part, sessionId, wire);
     }
     if (part.type === 'thinking' ||
         part.type === 'reasoning' ||
@@ -747,11 +803,11 @@ function hasSignedThinkingPart(part, sessionId) {
         if (!sessionId) {
             return true;
         }
-        return hasCachedMatchingSignature(part, sessionId);
+        return hasCachedMatchingSignature(part, sessionId, wire);
     }
     return false;
 }
-function ensureThinkingBeforeToolUseInContents(contents, signatureSessionKey) {
+function ensureThinkingBeforeToolUseInContents(contents, signatureSessionKey, wire) {
     return contents.map((content) => {
         if (!content ||
             typeof content !== 'object' ||
@@ -769,7 +825,7 @@ function ensureThinkingBeforeToolUseInContents(contents, signatureSessionKey) {
         }
         // Check if any thinking part has a valid signed signature
         const hasSignedThinking = parts.some((p) => isGeminiThinkingPart(p) &&
-            hasSignedThinkingPart(ensureThoughtSignature(p, signatureSessionKey), signatureSessionKey));
+            hasSignedThinkingPart(ensureThoughtSignature(p, signatureSessionKey), signatureSessionKey, wire));
         if (hasSignedThinking) {
             // Ensure signatures on thinking parts in-place — NO reordering to preserve array indices (cache-friendly)
             return {
@@ -781,8 +837,8 @@ function ensureThinkingBeforeToolUseInContents(contents, signatureSessionKey) {
         }
         // Replace thinking parts with sentinels in-place to preserve array indices (cache-friendly).
         // Deleting parts via .filter() shifts array indices → changes hash → busts prompt cache.
-        const lastThinking = defaultSignatureStore.get(signatureSessionKey);
-        log.debug('Replacing thinking with sentinels in-place', {
+        const lastThinking = wire.signatures.signatureStore.get(signatureSessionKey);
+        wire.logger.debug('Replacing thinking with sentinels in-place', {
             signatureSessionKey,
             hasCachedSig: !!lastThinking,
         });
@@ -826,14 +882,14 @@ function hasToolUseInContents(contents) {
         return content.parts.some(isGeminiToolUsePart);
     });
 }
-function hasSignedThinkingInContents(contents, sessionId) {
+function hasSignedThinkingInContents(contents, sessionId, wire) {
     return contents.some((content) => {
         if (!content ||
             typeof content !== 'object' ||
             !Array.isArray(content.parts)) {
             return false;
         }
-        return content.parts.some((part) => hasSignedThinkingPart(part, sessionId));
+        return content.parts.some((part) => hasSignedThinkingPart(part, sessionId, wire));
     });
 }
 function hasToolUseInMessages(messages) {
@@ -848,17 +904,17 @@ function hasToolUseInMessages(messages) {
             (block.type === 'tool_use' || block.type === 'tool_result'));
     });
 }
-function hasSignedThinkingInMessages(messages, sessionId) {
+function hasSignedThinkingInMessages(messages, sessionId, wire) {
     return messages.some((message) => {
         if (!message ||
             typeof message !== 'object' ||
             !Array.isArray(message.content)) {
             return false;
         }
-        return message.content.some((block) => hasSignedThinkingPart(block, sessionId));
+        return message.content.some((block) => hasSignedThinkingPart(block, sessionId, wire));
     });
 }
-function ensureThinkingBeforeToolUseInMessages(messages, signatureSessionKey) {
+function ensureThinkingBeforeToolUseInMessages(messages, signatureSessionKey, wire) {
     return messages.map((message) => {
         if (!message ||
             typeof message !== 'object' ||
@@ -880,7 +936,7 @@ function ensureThinkingBeforeToolUseInMessages(messages, signatureSessionKey) {
             (b.type === 'thinking' || b.type === 'redacted_thinking');
         // Check if any thinking block has a valid signed signature
         const hasSignedThinking = blocks.some((b) => isThinkingBlock(b) &&
-            hasSignedThinkingPart(ensureMessageThinkingSignature(b, signatureSessionKey), signatureSessionKey));
+            hasSignedThinkingPart(ensureMessageThinkingSignature(b, signatureSessionKey), signatureSessionKey, wire));
         if (hasSignedThinking) {
             // Ensure signatures on thinking blocks in-place — NO reordering to preserve array indices (cache-friendly)
             return {
@@ -892,8 +948,8 @@ function ensureThinkingBeforeToolUseInMessages(messages, signatureSessionKey) {
         }
         // Replace thinking blocks with sentinels in-place to preserve array indices (cache-friendly).
         // Deleting/reordering via .filter() shifts indices → changes hash → busts prompt cache.
-        const lastThinking = defaultSignatureStore.get(signatureSessionKey);
-        log.debug('Replacing thinking with sentinels in-place (Messages format)', {
+        const lastThinking = wire.signatures.signatureStore.get(signatureSessionKey);
+        wire.logger.debug('Replacing thinking with sentinels in-place (Messages format)', {
             signatureSessionKey,
             hasCachedSig: !!lastThinking,
         });
@@ -926,9 +982,41 @@ function ensureThinkingBeforeToolUseInMessages(messages, signatureSessionKey) {
 export function getPluginSessionId() {
     return PLUGIN_SESSION_ID;
 }
-let _lastCacheStats = null;
+/** Builds one location's wire state from its own collaborators. */
+export function createRequestWireLocation(input) {
+    const fingerprint = input.sessionFingerprint ?? generateFingerprint();
+    return {
+        signatures: input.signatures,
+        debug: input.debug,
+        logger: input.logger,
+        sessionFingerprint: () => fingerprint,
+        displayedThinkingHashes: new Set(),
+        cacheStats: { last: null },
+    };
+}
+// OpenCode 1's single-location binding: every read goes to the module-level
+// config, signature cache, debug log and fingerprint at call time.
+const openCode1WireLocation = {
+    signatures: {
+        get keepThinking() {
+            return getKeepThinking();
+        },
+        signatureStore: defaultSignatureStore,
+        cacheSignature: (sessionId, text, signature) => cacheSignature(sessionId, text, signature),
+        getCachedSignature: (sessionId, text) => getCachedSignature(sessionId, text),
+    },
+    debug: {
+        isDebugTuiEnabled: () => isDebugTuiEnabled(),
+        logAntigravityDebugResponse: (context, response, meta) => logAntigravityDebugResponse(context, response, meta),
+        logCacheStats: (model, cacheRead, cacheWrite, totalInput) => logCacheStats(model, cacheRead, cacheWrite, totalInput),
+    },
+    logger: log,
+    sessionFingerprint: () => getSessionFingerprint(),
+    displayedThinkingHashes: sessionDisplayedThinkingHashes,
+    cacheStats: { last: null },
+};
 export function getLastCacheStats() {
-    return _lastCacheStats;
+    return openCode1WireLocation.cacheStats.last;
 }
 const STREAM_ACTION = 'streamGenerateContent';
 /**
@@ -952,7 +1040,7 @@ export function fetchInputToUrl(input) {
 export function isGenerativeLanguageRequest(input) {
     return fetchInputToUrl(input).includes('generativelanguage.googleapis.com');
 }
-export function prepareAntigravityRequest(input, init, accessToken, projectId, endpointOverride, headerStyle = 'antigravity', forceThinkingRecovery = false, options) {
+function prepareAntigravityRequestIn(wire, input, init, accessToken, projectId, endpointOverride, headerStyle = 'antigravity', forceThinkingRecovery = false, options) {
     const baseInit = { ...init };
     const headers = new Headers(init?.headers ?? {});
     let resolvedProjectId = projectId?.trim() || '';
@@ -976,6 +1064,8 @@ export function prepareAntigravityRequest(input, init, accessToken, projectId, e
     headers.delete('x-session-affinity');
     headers.delete('x-session-id');
     headers.delete('x-parent-session-id');
+    headers.delete('x-opencode-session-id');
+    headers.delete('x-opencode-parent-session-id');
     // Strip x-goog-user-project header to prevent 403 auth/license conflicts.
     // This header is added by OpenCode/AI SDK and can force project-level checks
     // that are not required for Antigravity/Gemini CLI OAuth requests.
@@ -1000,7 +1090,7 @@ export function prepareAntigravityRequest(input, init, accessToken, projectId, e
     const transformedUrl = `${baseEndpoint}/v1internal:${rawAction}${streaming ? '?alt=sse' : ''}`;
     const isClaude = isClaudeModel(resolved.actualModel);
     const isClaudeThinking = isClaudeThinkingModel(resolved.actualModel);
-    const keepThinkingEnabled = getKeepThinking();
+    const keepThinkingEnabled = wire.signatures.keepThinking;
     // Tier-based thinking configuration from model resolver (can be overridden by variant config)
     let tierThinkingBudget = resolved.thinkingBudget;
     let tierThinkingLevel = resolved.thinkingLevel;
@@ -1053,19 +1143,19 @@ export function prepareAntigravityRequest(input, init, accessToken, projectId, e
                             targetModel: effectiveModel,
                         });
                         // Step 1: Strip corrupted/unsigned thinking blocks FIRST
-                        deepFilterThinkingBlocks(req, signatureSessionKey, getCachedSignature, true);
+                        deepFilterThinkingBlocks(req, signatureSessionKey, wire.signatures.getCachedSignature, true, keepThinkingEnabled);
                         // Step 2: THEN inject signed thinking from cache (after stripping)
                         if (isClaudeThinking &&
                             keepThinkingEnabled &&
                             Array.isArray(req.contents)) {
                             ;
-                            req.contents = ensureThinkingBeforeToolUseInContents(req.contents, signatureSessionKey);
+                            req.contents = ensureThinkingBeforeToolUseInContents(req.contents, signatureSessionKey, wire);
                         }
                         if (isClaudeThinking &&
                             keepThinkingEnabled &&
                             Array.isArray(req.messages)) {
                             ;
-                            req.messages = ensureThinkingBeforeToolUseInMessages(req.messages, signatureSessionKey);
+                            req.messages = ensureThinkingBeforeToolUseInMessages(req.messages, signatureSessionKey, wire);
                         }
                         // Step 3: Apply tool pairing fixes (ID assignment, response matching, orphan recovery)
                         applyToolPairingFixes(req, true);
@@ -1074,6 +1164,7 @@ export function prepareAntigravityRequest(input, init, accessToken, projectId, e
                         sanitizeRequestPayloadForAntigravity(req);
                         stripUnsupportedAntigravityFields(req);
                         configureAntigravityToolCalling(req);
+                        normalizeNativeFunctionResponseRoles(req);
                     }
                 }
                 // AGY rejects every request that ends with a model turn. Enforce this at
@@ -1106,10 +1197,10 @@ export function prepareAntigravityRequest(input, init, accessToken, projectId, e
                         (Array.isArray(req.messages) &&
                             hasToolUseInMessages(req.messages)));
                     const hasSignedThinking = requestObjects.some((req) => (Array.isArray(req.contents) &&
-                        hasSignedThinkingInContents(req.contents, signatureSessionKey)) ||
+                        hasSignedThinkingInContents(req.contents, signatureSessionKey, wire)) ||
                         (Array.isArray(req.messages) &&
-                            hasSignedThinkingInMessages(req.messages, signatureSessionKey)));
-                    const hasCachedThinking = defaultSignatureStore.has(signatureSessionKey);
+                            hasSignedThinkingInMessages(req.messages, signatureSessionKey, wire)));
+                    const hasCachedThinking = wire.signatures.signatureStore.has(signatureSessionKey);
                     needsSignedThinkingWarmup =
                         hasToolUse && !hasSignedThinking && !hasCachedThinking;
                 }
@@ -1146,7 +1237,7 @@ export function prepareAntigravityRequest(input, init, accessToken, projectId, e
                 const extraBody = requestPayload.extra_body;
                 const variantConfig = extractVariantThinkingConfig(requestPayload.providerOptions, rawGenerationConfig);
                 const isGemini3 = effectiveModel.toLowerCase().includes('gemini-3');
-                log.debug(`[ThinkingResolution] rawModel=${rawModel} resolvedModel=${effectiveModel} resolvedTier=${tierThinkingLevel ?? 'none'} variantLevel=${variantConfig?.thinkingLevel ?? 'none'} variantBudget=${variantConfig?.thinkingBudget ?? 'none'} providerOptions.google=${JSON.stringify(requestPayload.providerOptions?.google ?? null)} generationConfig.thinkingConfig=${JSON.stringify(rawGenerationConfig?.thinkingConfig ?? null)}`);
+                wire.logger.debug(`[ThinkingResolution] rawModel=${rawModel} resolvedModel=${effectiveModel} resolvedTier=${tierThinkingLevel ?? 'none'} variantLevel=${variantConfig?.thinkingLevel ?? 'none'} variantBudget=${variantConfig?.thinkingBudget ?? 'none'} providerOptions.google=${JSON.stringify(requestPayload.providerOptions?.google ?? null)} generationConfig.thinkingConfig=${JSON.stringify(rawGenerationConfig?.thinkingConfig ?? null)}`);
                 // providerOptions belongs to the host AI SDK and is only used above to
                 // resolve the requested variant. It is never part of the Google wire schema.
                 delete requestPayload.providerOptions;
@@ -1168,7 +1259,7 @@ export function prepareAntigravityRequest(input, init, accessToken, projectId, e
                 else if (variantConfig?.thinkingBudget) {
                     if (isGemini3) {
                         // Legacy format for Gemini 3 - convert with deprecation warning
-                        log.warn('[Deprecated] Using thinkingBudget for Gemini 3 model. Use thinkingLevel instead.');
+                        wire.logger.warn('[Deprecated] Using thinkingBudget for Gemini 3 model. Use thinkingLevel instead.');
                         tierThinkingLevel =
                             variantConfig.thinkingBudget <= 8192
                                 ? 'low'
@@ -1532,17 +1623,17 @@ export function prepareAntigravityRequest(input, init, accessToken, projectId, e
                         targetModel: effectiveModel,
                     });
                     // Step 1: Strip corrupted/unsigned thinking blocks FIRST
-                    deepFilterThinkingBlocks(requestPayload, signatureSessionKey, getCachedSignature, true);
+                    deepFilterThinkingBlocks(requestPayload, signatureSessionKey, wire.signatures.getCachedSignature, true, keepThinkingEnabled);
                     // Step 2: THEN inject signed thinking from cache (after stripping)
                     if (isClaudeThinking &&
                         keepThinkingEnabled &&
                         Array.isArray(requestPayload.contents)) {
-                        requestPayload.contents = ensureThinkingBeforeToolUseInContents(requestPayload.contents, signatureSessionKey);
+                        requestPayload.contents = ensureThinkingBeforeToolUseInContents(requestPayload.contents, signatureSessionKey, wire);
                     }
                     if (isClaudeThinking &&
                         keepThinkingEnabled &&
                         Array.isArray(requestPayload.messages)) {
-                        requestPayload.messages = ensureThinkingBeforeToolUseInMessages(requestPayload.messages, signatureSessionKey);
+                        requestPayload.messages = ensureThinkingBeforeToolUseInMessages(requestPayload.messages, signatureSessionKey, wire);
                     }
                     // Step 3: Check if warmup needed (AFTER injection attempt)
                     if (isClaudeThinking && keepThinkingEnabled) {
@@ -1551,10 +1642,10 @@ export function prepareAntigravityRequest(input, init, accessToken, projectId, e
                             (Array.isArray(requestPayload.messages) &&
                                 hasToolUseInMessages(requestPayload.messages));
                         const hasSignedThinking = (Array.isArray(requestPayload.contents) &&
-                            hasSignedThinkingInContents(requestPayload.contents, signatureSessionKey)) ||
+                            hasSignedThinkingInContents(requestPayload.contents, signatureSessionKey, wire)) ||
                             (Array.isArray(requestPayload.messages) &&
-                                hasSignedThinkingInMessages(requestPayload.messages, signatureSessionKey));
-                        const hasCachedThinking = defaultSignatureStore.has(signatureSessionKey);
+                                hasSignedThinkingInMessages(requestPayload.messages, signatureSessionKey, wire));
+                        const hasCachedThinking = wire.signatures.signatureStore.has(signatureSessionKey);
                         needsSignedThinkingWarmup =
                             hasToolUse && !hasSignedThinking && !hasCachedThinking;
                     }
@@ -1649,7 +1740,7 @@ export function prepareAntigravityRequest(input, init, accessToken, projectId, e
                             ? 'Thinking recovery: retrying with fresh turn (API error)'
                             : 'Thinking recovery: restarting turn (corrupted context)';
                         requestPayload.contents = closeToolLoopForThinking(requestPayload.contents);
-                        defaultSignatureStore.delete(signatureSessionKey);
+                        wire.signatures.signatureStore.delete(signatureSessionKey);
                     }
                 }
                 // AGY rejects every request that ends with a model turn. Enforce this at
@@ -1687,6 +1778,19 @@ export function prepareAntigravityRequest(input, init, accessToken, projectId, e
                 if (headerStyle === 'antigravity') {
                     stripUnsupportedAntigravityFields(requestPayload);
                     configureAntigravityToolCalling(requestPayload);
+                    // Function-response roles depend on the signatures settled by the
+                    // sanitizer above; a response turn that becomes a model turn at the
+                    // end of the request then needs the trailing user turn.
+                    normalizeNativeFunctionResponseRoles(requestPayload);
+                    if (Array.isArray(requestPayload.contents)) {
+                        const lastContent = requestPayload.contents[requestPayload.contents.length - 1];
+                        if (lastContent?.role === 'model') {
+                            requestPayload.contents.push({
+                                role: 'user',
+                                parts: [{ text: '[Continue]' }],
+                            });
+                        }
+                    }
                 }
                 // Use the stable default project ID (never a per-request random one):
                 // a fresh random project each request busts the prompt cache and
@@ -1750,7 +1854,7 @@ export function prepareAntigravityRequest(input, init, accessToken, projectId, e
         // Antigravity mode: Match Antigravity Manager behavior
         // AM only sends User-Agent on content requests — no X-Goog-Api-Client, no Client-Metadata header
         // (ideType=ANTIGRAVITY goes in request body metadata via project.ts, not as a header)
-        const fingerprint = options?.fingerprint ?? getSessionFingerprint();
+        const fingerprint = options?.fingerprint ?? wire.sessionFingerprint();
         const fingerprintHeaders = buildFingerprintHeaders(fingerprint);
         headers.set('User-Agent', fingerprintHeaders['User-Agent'] || selectedHeaders['User-Agent']);
         headers.set('Accept-Encoding', 'gzip');
@@ -1785,6 +1889,10 @@ export function prepareAntigravityRequest(input, init, accessToken, projectId, e
         thinkingRecoveryMessage,
     };
 }
+/** OpenCode 1's request preparation over its module-level state. */
+export function prepareAntigravityRequest(...args) {
+    return prepareAntigravityRequestIn(openCode1WireLocation, ...args);
+}
 export function buildThinkingWarmupBody(bodyText, isClaudeThinking) {
     if (!bodyText || !isClaudeThinking) {
         return null;
@@ -1849,7 +1957,7 @@ export function buildThinkingWarmupBody(bodyText, isClaudeThinking) {
  * For streaming SSE responses, uses TransformStream for true real-time incremental streaming.
  * Thinking/reasoning tokens are transformed and forwarded immediately as they arrive.
  */
-export async function transformAntigravityResponse(response, streaming, debugContext, requestedModel, projectId, endpoint, effectiveModel, sessionId, toolDebugMissing, toolDebugSummary, toolDebugPayload, debugLines, dumpContext) {
+async function transformAntigravityResponseIn(wire, response, streaming, debugContext, requestedModel, projectId, endpoint, effectiveModel, sessionId, toolDebugMissing, toolDebugSummary, toolDebugPayload, debugLines, dumpContext) {
     const contentType = response.headers.get('content-type') ?? '';
     const isJsonResponse = contentType.includes('application/json');
     const isEventStreamResponse = contentType.includes('text/event-stream');
@@ -1857,14 +1965,16 @@ export async function transformAntigravityResponse(response, streaming, debugCon
     // - If debug=true: inject full debug logs
     // - If keep_thinking=true (but no debug): inject placeholder to trigger signature caching
     // Both use the same injection path (injectDebugThinking) for consistent behavior
-    const debugText = isDebugTuiEnabled() && Array.isArray(debugLines) && debugLines.length > 0
+    const debugText = wire.debug.isDebugTuiEnabled() &&
+        Array.isArray(debugLines) &&
+        debugLines.length > 0
         ? formatDebugLinesForThinking(debugLines)
-        : getKeepThinking()
+        : wire.signatures.keepThinking
             ? SYNTHETIC_THINKING_PLACEHOLDER
             : undefined;
     const cacheSignatures = shouldCacheThinkingSignatures(effectiveModel);
     if (!isJsonResponse && !isEventStreamResponse) {
-        logAntigravityDebugResponse(debugContext, response, {
+        wire.debug.logAntigravityDebugResponse(debugContext, response, {
             note: 'Non-JSON response (body omitted)',
         });
         return response;
@@ -1874,7 +1984,7 @@ export async function transformAntigravityResponse(response, streaming, debugCon
     // This enables thinking tokens to be displayed as they arrive, like the Codex plugin.
     if (streaming && response.ok && isEventStreamResponse && response.body) {
         const headers = new Headers(response.headers);
-        logAntigravityDebugResponse(debugContext, response, {
+        wire.debug.logAntigravityDebugResponse(debugContext, response, {
             note: 'Streaming SSE response (real-time transform)',
         });
         noteGeminiDumpResponse(dumpContext, response);
@@ -1882,8 +1992,8 @@ export async function transformAntigravityResponse(response, streaming, debugCon
         const sourceBody = rawDumpTransformer
             ? response.body.pipeThrough(rawDumpTransformer)
             : response.body;
-        const streamingTransformer = createStreamingTransformer(defaultSignatureStore, {
-            onCacheSignature: cacheSignature,
+        const streamingTransformer = createStreamingTransformer(wire.signatures.signatureStore, {
+            onCacheSignature: wire.signatures.cacheSignature,
             onInjectDebug: injectDebugThinking,
             onUsageMetadata: (usage) => {
                 if (effectiveModel) {
@@ -1891,9 +2001,9 @@ export async function transformAntigravityResponse(response, streaming, debugCon
                     const totalInput = usage.promptTokenCount ?? usage.totalTokenCount;
                     const hitRate = totalInput > 0 ? Math.round((cacheRead / totalInput) * 100) : 0;
                     const status = cacheRead > 0 ? 'HIT' : 'MISS';
-                    logCacheStats(effectiveModel, cacheRead, 0, totalInput);
-                    log.debug(`[Cache] ${status} model=${effectiveModel} read=${cacheRead} total=${totalInput} hitRate=${hitRate}%`);
-                    _lastCacheStats = {
+                    wire.debug.logCacheStats(effectiveModel, cacheRead, 0, totalInput);
+                    wire.logger.debug(`[Cache] ${status} model=${effectiveModel} read=${cacheRead} total=${totalInput} hitRate=${hitRate}%`);
+                    wire.cacheStats.last = {
                         model: effectiveModel,
                         read: cacheRead,
                         total: totalInput,
@@ -1907,7 +2017,7 @@ export async function transformAntigravityResponse(response, streaming, debugCon
             debugText,
             cacheSignatures,
             displayedThinkingHashes: effectiveModel && isGemini3Model(effectiveModel)
-                ? sessionDisplayedThinkingHashes
+                ? wire.displayedThinkingHashes
                 : undefined,
             // injectSyntheticThinking removed - keep_thinking now unified with debug via debugText
         });
@@ -2009,8 +2119,8 @@ export async function transformAntigravityResponse(response, streaming, debugCon
             const totalInput = usage.promptTokenCount ?? usage.totalTokenCount ?? 0;
             const hitRate = totalInput > 0 ? Math.round((cacheRead / totalInput) * 100) : 0;
             const status = cacheRead > 0 ? 'HIT' : 'MISS';
-            logCacheStats(effectiveModel, cacheRead, 0, totalInput);
-            log.debug(`[Cache] ${status} model=${effectiveModel} read=${cacheRead} total=${totalInput} hitRate=${hitRate}%`);
+            wire.debug.logCacheStats(effectiveModel, cacheRead, 0, totalInput);
+            wire.logger.debug(`[Cache] ${status} model=${effectiveModel} read=${cacheRead} total=${totalInput} hitRate=${hitRate}%`);
         }
         if (usage?.cachedContentTokenCount !== undefined) {
             headers.set('x-antigravity-cached-content-token-count', String(usage.cachedContentTokenCount));
@@ -2024,7 +2134,7 @@ export async function transformAntigravityResponse(response, streaming, debugCon
                 headers.set('x-antigravity-candidates-token-count', String(usage.candidatesTokenCount));
             }
         }
-        logAntigravityDebugResponse(debugContext, response, {
+        wire.debug.logAntigravityDebugResponse(debugContext, response, {
             body: text,
             note: streaming ? 'Streaming SSE payload (buffered fallback)' : undefined,
             headersOverride: headers,
@@ -2054,13 +2164,32 @@ export async function transformAntigravityResponse(response, streaming, debugCon
             error.message === 'THINKING_RECOVERY_NEEDED') {
             throw error;
         }
-        logAntigravityDebugResponse(debugContext, response, {
+        wire.debug.logAntigravityDebugResponse(debugContext, response, {
             error,
             note: 'Failed to transform Antigravity response',
         });
         return responseFallback;
     }
 }
+/** OpenCode 1's response transformation over its module-level state. */
+export function transformAntigravityResponse(...args) {
+    return transformAntigravityResponseIn(openCode1WireLocation, ...args);
+}
+/**
+ * The wire functions bound to one location's state. Preparation and
+ * response handling follow exactly the OpenCode 1 rules; only the signature
+ * cache, keep_thinking policy, debug log, logger, fallback fingerprint,
+ * displayed-thinking set and cache statistics are the location's own.
+ */
+export function createRequestWire(location) {
+    return {
+        prepare: (...args) => prepareAntigravityRequestIn(location, ...args),
+        transformResponse: (...args) => transformAntigravityResponseIn(location, ...args),
+        buildThinkingWarmupBody,
+        getImageModelLocalTitle,
+        getLastCacheStats: () => location.cacheStats.last,
+    };
+}
 export const __testExports = {
     buildSignatureSessionKey,
     hashConversationSeed,
@@ -2072,13 +2201,14 @@ export const __testExports = {
     isGeminiToolUsePart,
     isGeminiThinkingPart,
     ensureThoughtSignature,
-    hasSignedThinkingPart,
-    hasSignedThinkingInContents,
-    hasSignedThinkingInMessages,
+    // The helpers below are exposed over OpenCode 1's module-level state.
+    hasSignedThinkingPart: (part, sessionId) => hasSignedThinkingPart(part, sessionId, openCode1WireLocation),
+    hasSignedThinkingInContents: (contents, sessionId) => hasSignedThinkingInContents(contents, sessionId, openCode1WireLocation),
+    hasSignedThinkingInMessages: (messages, sessionId) => hasSignedThinkingInMessages(messages, sessionId, openCode1WireLocation),
     hasToolUseInContents,
     hasToolUseInMessages,
-    ensureThinkingBeforeToolUseInContents,
-    ensureThinkingBeforeToolUseInMessages,
+    ensureThinkingBeforeToolUseInContents: (contents, key) => ensureThinkingBeforeToolUseInContents(contents, key, openCode1WireLocation),
+    ensureThinkingBeforeToolUseInMessages: (messages, key) => ensureThinkingBeforeToolUseInMessages(messages, key, openCode1WireLocation),
     MIN_SIGNATURE_LENGTH,
     transformSseLine,
     transformStreamingPayload,