@anthonyhaussman/opencode-agy-auth 1.1.1 → 1.1.2-beta.0

package/dist/src/sdk/request/openai.d.ts

@@ -0,0 +1,16 @@
+/**
+ * NOTE: Format/protocol conversion logic is typically in the app layer (Plugin), but is implemented here inside the SDK as a special case.
+ * Reason:
+ * Format conversion (OpenAI format to Gemini/Agy native and vice versa) is tightly coupled with Agy's unique streaming SSE data parsing,
+ * thought chain deduplication, and signature self-healing (Thinking Recovery / Signature Cache) in multi-turn dialogues.
+ * Encapsulating this conversion in the SDK completely shields the OpenCode plugin app layer from non-standard API interaction complexities,
+ * allowing the plugin to simply call and forward standard OpenAI formatted requests and response streams.
+ */
+/**
+ * Converts OpenAI's `tool_calls` into Gemini's `functionCall` sections.
+ */
+export declare function transformOpenAIToolCalls(requestPayload: Record<string, unknown>): void;
+/**
+ * Adds synthesized thoughtSignature to function calls in the flattened and wrapped payload.
+ */
+export declare function addThoughtSignaturesToFunctionCalls(requestPayload: Record<string, unknown>): void;

package/dist/src/sdk/request/prepare.d.ts

@@ -0,0 +1,14 @@
+export interface ThinkingConfigDefaults {
+    provider?: unknown;
+    models?: Record<string, unknown>;
+}
+/**
+ * Rewrites OpenAI-style requests into the format for Gemini Code Assist requests.
+ */
+export declare function prepareAgyRequest(input: RequestInfo, init: RequestInit | undefined, accessToken: string, projectId: string, thinkingConfigDefaults?: ThinkingConfigDefaults): {
+    request: RequestInfo;
+    init: RequestInit;
+    streaming: boolean;
+    requestedModel?: string;
+    sessionId?: string;
+};

package/dist/src/sdk/request/response.d.ts

@@ -0,0 +1,5 @@
+import type { ChatLogger } from "../chat-logger";
+/**
+ * Normalizes Gemini/Agy responses, preserving request metadata and usage counters.
+ */
+export declare function transformAgyResponse(response: Response, streaming: boolean, _ignoredDebugContext?: any, requestedModel?: string, sessionId?: string, chatLogger?: ChatLogger | null): Promise<Response>;

package/dist/src/sdk/request/shared.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Returns the URL string for supported RequestInfo inputs.
+ */
+export declare function toRequestUrlString(value: RequestInfo): string;
+/**
+ * Detects Gemini/Generative Language API requests via URL.
+ */
+export declare function isGenerativeLanguageRequest(input: RequestInfo): input is string;
+export declare function parseGenerativeLanguageRequest(input: RequestInfo): {
+    requestedModel: string;
+    effectiveModel: string;
+    action: string;
+} | undefined;
+export declare function isRecord(value: unknown): value is Record<string, unknown>;
+export declare function readString(value: unknown): string | undefined;
+export declare function pickString(...values: unknown[]): string | undefined;
+/**
+ * Preserves Cloud Code trace identity for downstream clients by mapping traceId to responseId.
+ */
+export declare function injectResponseIdFromTrace<T extends Record<string, unknown>>(body: T): T;

package/dist/src/sdk/request/thinking.d.ts

@@ -0,0 +1,129 @@
+/**
+ * NOTE: Special Design - Streaming deduplication and signature state self-healing
+ * Agy/Gemini official API has the following non-standard behaviors and strict constraints that must be specially handled here:
+ * 1. [Streaming Deduplication]: In the data packets returned by the official API during streaming, thought chain (Thinking) content is output cumulatively.
+ *    We must perform hash comparison and truncation on each returned delta to prevent the IDE from receiving duplicate text.
+ * 2. [Signature State Self-healing]: In multi-turn dialogues, if the thoughtSignature is lost due to tool calls or client state breakage,
+ *    the official API throws a signature mismatch error. An auto-detection mechanism (e.g., needsThinkingRecovery) is designed here to, upon signature breakage,
+ *    automatically backfill/align fallback thought chain fragments and signatures in context messages, allowing the dialogue chain to self-heal and continue.
+ */
+/**
+ * Cached signed thought chain data structure
+ */
+export interface SignedThinking {
+    /** Full thought chain text content */
+    text: string;
+    /** Corresponding server signature */
+    signature: string;
+}
+/**
+ * External contract interface for signature storage manager
+ */
+export interface SignatureStore {
+    get(sessionKey: string): SignedThinking | undefined;
+    set(sessionKey: string, value: SignedThinking): void;
+    has(sessionKey: string): boolean;
+    delete(sessionKey: string): void;
+}
+/**
+ * Custom callback functions for the streaming phase
+ */
+export interface StreamingCallbacks {
+    onCacheSignature?: (sessionKey: string, text: string, signature: string) => void;
+    onInjectDebug?: (response: unknown, debugText: string) => unknown;
+    transformThinkingParts?: (parts: unknown) => unknown;
+    onTurnStateUpdate?: (sessionKey: string, state: {
+        turnHasThinking: boolean;
+        lastModelHasToolCalls: boolean;
+    }) => void;
+}
+/**
+ * Configuration parameters for the streaming phase
+ */
+export interface StreamingOptions {
+    /** Unique identifier for the signature session, used for cross-turn signature recovery */
+    signatureSessionKey?: string;
+    /** Debugging text to inject into the stream (optional) */
+    debugText?: string;
+    /** Whether to cache the latest generated signature in this stream */
+    cacheSignatures?: boolean;
+    /** Set of already rendered thought chain hashes, used to avoid duplicate output in tool call loops */
+    displayedThinkingHashes?: Set<string>;
+}
+/**
+ * Text buffer for caching thought chains of a specific index or type (handles streaming chunk cumulative output)
+ */
+export interface ThoughtBuffer {
+    get(index: number): string | undefined;
+    set(index: number, text: string): void;
+    clear(): void;
+}
+/**
+ * Agent and tool interaction state record during multi-turn dialogue runtime
+ */
+export interface ConversationState {
+    /** Whether inside an incomplete tool call loop (i.e., last turn ended with functionResponse, continuing this turn) */
+    inToolLoop: boolean;
+    /** Array index of the first model reply message in the current dialogue turn */
+    turnStartIdx: number;
+    /** Whether the start of the current dialogue turn contains a thought chain (thought) */
+    turnHasThinking: boolean;
+    /** Array index of the last model reply message */
+    lastModelIdx: number;
+    /** Whether the last model message contains a thought chain */
+    lastModelHasThinking: boolean;
+    /** Whether the last model message contains a tool call (tool_use) */
+    lastModelHasToolCalls: boolean;
+}
+/**
+ * Creates a memory Map-based signature storage manager
+ */
+export declare function createSignatureStore(): SignatureStore;
+/**
+ * Creates a thought chain text accumulation buffer for temporarily storing streaming chunks
+ */
+export declare function createThoughtBuffer(): ThoughtBuffer;
+/**
+ * Default global memory signature storage
+ */
+export declare const defaultSignatureStore: SignatureStore;
+/**
+ * Analyzes multi-turn historical dialogue arrays to extract context metrics like agent interaction loop state, model message positions, whether the turn has thoughts, etc.
+ */
+export declare function analyzeConversationState(contents: any[]): ConversationState;
+/**
+ * Closes the tool execution loop and injects transition content to smoothly recover the dialogue without providing the old thought chain
+ */
+export declare function closeToolLoopForThinking(contents: any[]): any[];
+/**
+ * Checks if the current state meets conditions to trigger historical self-healing
+ */
+export declare function needsThinkingRecovery(state: ConversationState): boolean;
+/**
+ * Determines if the current model reply message had its thought chain pruned (has only tool calls but lost its preceding thought chain description)
+ */
+export declare function looksLikeCompactedThinkingTurn(msg: any): boolean;
+/**
+ * Deeply determines if the start of this Turn contains historical rounds whose thought chains might have been pruned/compressed by the system
+ */
+export declare function hasPossibleCompactedThinking(contents: any[], turnStartIdx: number): boolean;
+/**
+ * For streaming SSE data packets, calculates and locally strips duplicated thought chain text
+ * Simultaneously supports Gemini's exclusive candidates.content structure and Claude's exclusive content[type=thinking] structure
+ */
+export declare function deduplicateThinkingText(response: unknown, sentBuffer: ThoughtBuffer, displayedThinkingHashes?: Set<string>): unknown;
+/**
+ * Caches thought chain content and its validation signature from the returned message body for signature alignment in the next interaction round
+ * Also supports Gemini signature mechanism (candidates[].thoughtSignature) and Claude signature mechanism (content[].signature)
+ */
+export declare function cacheThinkingSignaturesFromResponse(response: unknown, signatureSessionKey: string, signatureStore: SignatureStore, thoughtBuffer: ThoughtBuffer, onCacheSignature?: (sessionKey: string, text: string, signature: string) => void): void;
+/**
+ * Transforms a single complete SSE event, triggering thought chain caching and incremental deduplication here
+ */
+export declare function transformSseEvent(eventText: string, signatureStore: SignatureStore, thoughtBuffer: ThoughtBuffer, sentThinkingBuffer: ThoughtBuffer, callbacks: StreamingCallbacks, options: StreamingOptions, debugState: {
+    injected: boolean;
+}): string;
+/**
+ * Creates a TransformStream processor to split, deduplicate, and recombine the output stream
+ */
+export declare function createStreamingTransformer(signatureStore: SignatureStore, callbacks: StreamingCallbacks, options?: StreamingOptions): TransformStream<Uint8Array, Uint8Array>;

package/dist/src/sdk/request/turn-state-tracker.d.ts

@@ -0,0 +1,21 @@
+import { type ConversationState } from "./thinking";
+export type TurnState = Pick<ConversationState, "inToolLoop" | "turnHasThinking" | "lastModelHasThinking" | "lastModelHasToolCalls">;
+export declare class TurnStateTracker {
+    private entries;
+    private dirty;
+    private lastWriteTime;
+    private writeTimer;
+    private readonly diskEnabled;
+    constructor(diskEnabled?: boolean);
+    getState(sessionId: string): TurnState | undefined;
+    needsThinkingRecovery(sessionId: string): boolean;
+    updateAfterResponse(sessionId: string, newState: TurnState): void;
+    recoverFromContents(sessionId: string, contents: any[]): TurnState;
+    clear(sessionId: string): void;
+    shutdown(): void;
+    private scheduleThrottledWrite;
+    private clearWriteTimer;
+}
+export declare function initTurnStateTracker(): TurnStateTracker;
+export declare function getTurnStateTracker(): TurnStateTracker | null;
+export declare function shutdownTurnStateTracker(): void;

package/dist/src/sdk/request-helpers/errors.d.ts

@@ -0,0 +1,9 @@
+import { type GeminiApiBody, type GeminiErrorEnhancement } from "./types";
+/**
+ * Enhances 404 errors for Gemini 3 models with direct preview access information.
+ */
+export declare function rewriteGeminiPreviewAccessError(body: GeminiApiBody, status: number, requestedModel?: string): GeminiApiBody | null;
+/**
+ * Enhances Gemini errors with validation/quota messages and retry hints.
+ */
+export declare function enhanceGeminiErrorResponse(body: GeminiApiBody, status: number): GeminiErrorEnhancement | null;

package/dist/src/sdk/request-helpers/index.d.ts

@@ -0,0 +1,4 @@
+export { CLOUDCODE_DOMAINS, GEMINI_PREVIEW_LINK, type GeminiApiBody, type GeminiApiError, type GeminiErrorEnhancement, type GeminiUsageMetadata, type ThinkingConfig, } from "./types";
+export { normalizeThinkingConfig } from "./thinking";
+export { parseGeminiApiBody, extractUsageMetadata } from "./parsing";
+export { rewriteGeminiPreviewAccessError, enhanceGeminiErrorResponse } from "./errors";

package/dist/src/sdk/request-helpers/parsing.d.ts

@@ -0,0 +1,9 @@
+import type { GeminiApiBody, GeminiUsageMetadata } from "./types";
+/**
+ * Parses the Gemini API response body; handles array-wrapped responses sometimes returned by the API.
+ */
+export declare function parseGeminiApiBody(rawText: string): GeminiApiBody | null;
+/**
+ * Extracts usageMetadata from the response object with type-safe guards.
+ */
+export declare function extractUsageMetadata(body: GeminiApiBody): GeminiUsageMetadata | null;

package/dist/src/sdk/request-helpers/thinking.d.ts

@@ -0,0 +1,5 @@
+import type { ThinkingConfig } from "./types";
+/**
+ * Normalizes thinkingConfig aliases to standard Gemini field names.
+ */
+export declare function normalizeThinkingConfig(config: unknown): ThinkingConfig | undefined;

package/dist/src/sdk/request-helpers/types.d.ts

@@ -0,0 +1,65 @@
+export declare const GEMINI_PREVIEW_LINK = "https://goo.gle/enable-preview-features";
+export interface GeminiApiError {
+    code?: number;
+    message?: string;
+    status?: string;
+    details?: unknown[];
+    [key: string]: unknown;
+}
+/**
+ * The minimal representation of the Gemini API response we touch.
+ */
+export interface GeminiApiBody {
+    response?: unknown;
+    error?: GeminiApiError;
+    [key: string]: unknown;
+}
+export interface GeminiErrorEnhancement {
+    body?: GeminiApiBody;
+    retryAfterMs?: number;
+}
+/**
+ * Usage metadata exposed by Gemini responses. Fields are optional to reflect partial payloads.
+ */
+export interface GeminiUsageMetadata {
+    totalTokenCount?: number;
+    promptTokenCount?: number;
+    candidatesTokenCount?: number;
+    cachedContentTokenCount?: number;
+}
+/**
+ * Thinking configuration accepted by Gemini.
+ */
+export interface ThinkingConfig {
+    thinkingBudget?: number;
+    thinkingLevel?: string;
+    includeThoughts?: boolean;
+}
+export interface GoogleRpcErrorInfo {
+    "@type"?: string;
+    reason?: string;
+    domain?: string;
+    metadata?: Record<string, string>;
+}
+export interface GoogleRpcHelp {
+    "@type"?: string;
+    links?: Array<{
+        description?: string;
+        url?: string;
+    }>;
+}
+export interface GoogleRpcQuotaFailure {
+    "@type"?: string;
+    violations?: Array<{
+        subject?: string;
+        description?: string;
+    }>;
+}
+export interface GoogleRpcRetryInfo {
+    "@type"?: string;
+    retryDelay?: string | {
+        seconds?: number;
+        nanos?: number;
+    };
+}
+export declare const CLOUDCODE_DOMAINS: string[];

package/dist/src/sdk/retry/cooldown-store.d.ts

@@ -0,0 +1,14 @@
+export declare function loadCooldowns(): Map<string, number>;
+export declare function saveCooldowns(entries: Map<string, number>): boolean;
+export declare class CooldownStore {
+    private dirty;
+    private lastWriteTime;
+    private writeTimer;
+    private entries;
+    bind(entries: Map<string, number>): void;
+    markDirty(): void;
+    flush(): boolean;
+    shutdown(): void;
+    private scheduleThrottledWrite;
+    private clearWriteTimer;
+}

package/dist/src/sdk/retry/helpers.d.ts

@@ -0,0 +1,19 @@
+export declare const DEFAULT_MAX_ATTEMPTS = 3;
+/**
+ * Ensures the request body is replayable before attempting a retry.
+ */
+export declare function canRetryRequest(init: RequestInit | undefined): boolean;
+/**
+ * Status code-based retry strategy, consistent with Gemini/Agy CLI.
+ */
+export declare function isRetryableStatus(status: number): boolean;
+/**
+ * Handles transient network failures (including error codes nested in `cause.code`).
+ */
+export declare function isRetryableNetworkError(error: unknown): boolean;
+/**
+ * Prioritizes parsing retry delay milliseconds via Retry-After header, quota info in response body, or fallback exponential backoff.
+ */
+export declare function resolveRetryDelayMs(response: Response, attempt: number, quotaDelayMs?: number): Promise<number>;
+export declare function getExponentialDelayWithJitter(attempt: number): number;
+export declare function wait(ms: number): Promise<void>;

package/dist/src/sdk/retry/index.d.ts

@@ -0,0 +1,9 @@
+import { retryInternals } from "./quota";
+declare function initCooldownPersistence(): void;
+export { initCooldownPersistence };
+/**
+ * Sends a request with retry/exponential backoff semantics, consistent with Gemini/Agy CLI.
+ */
+export declare function fetchWithRetry(input: RequestInfo, init: RequestInit | undefined): Promise<Response>;
+export declare function shutdownRetryCooldowns(): void;
+export { retryInternals };

package/dist/src/sdk/retry/quota.d.ts

@@ -0,0 +1,28 @@
+export interface QuotaContext {
+    terminal: boolean;
+    retryDelayMs?: number;
+    reason?: string;
+}
+/**
+ * NOTE: Special Design - Granular 429 Error Classification and Retry Strategy
+ * Traditional network retry modules usually treat 429 errors uniformly as rate-limiting for retries or throwing errors.
+ * Here we parse it granularly:
+ * 1. Differentiate between "Account physical quota exhausted" and "Model instantaneous capacity overloaded (MODEL_CAPACITY_EXHAUSTED)".
+ * 2. If it's physical quota exhaustion, it's considered an unretriable terminal state to avoid meaningless network requests;
+ *    If it's a momentary overload of Google's backend model capacity, it's considered retriable, parses RetryInfo delay from response, and notifies the upper layer (showing a Toast in TUI, backing off, and retrying).
+ */
+export declare function classifyQuotaResponse(response: Response): Promise<QuotaContext | null>;
+/**
+ * Extracts the RetryInfo delay hint directly from the error payload.
+ */
+export declare function parseRetryDelayFromBody(response: Response): Promise<number | null>;
+declare function parseRetryDelayValue(value: string | {
+    seconds?: number;
+    nanos?: number;
+}): number | null;
+declare function parseRetryDelayFromMessage(message: string): number | null;
+export declare const retryInternals: {
+    parseRetryDelayValue: typeof parseRetryDelayValue;
+    parseRetryDelayFromMessage: typeof parseRetryDelayFromMessage;
+};
+export {};

package/dist/src/sdk/terminal-hyperlink.d.ts

@@ -0,0 +1,3 @@
+export declare function supportsOsc8Hyperlinks(): boolean;
+export declare function formatHyperlink(url: string, text?: string): string;
+export declare function stripOsc8(text: string): string;

package/dist/src/sdk/user-agent.d.ts

@@ -0,0 +1,5 @@
+export declare function getAgyCliVersion(): string;
+export declare function buildAgyCliUserAgent(model?: string): string;
+export declare const userAgentInternals: {
+    resetCache(): void;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@anthonyhaussman/opencode-agy-auth",
-  "version": "1.1.1",
+  "version": "1.1.2-beta.0",
   "author": "antigravity",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
@@ -19,19 +19,19 @@
   "license": "MIT",
   "type": "module",
   "scripts": {
-    "build": "tsup",
+    "build": "tsup && tsc -p tsconfig.build.json",
     "typecheck": "tsc",
     "smoke:node-import": "node -e \"import('./dist/index.js').then(() => console.log('ok')).catch((error) => { console.error(error); process.exit(1); })\"",
     "prepack": "npm run build"
   },
   "devDependencies": {
-    "@opencode-ai/sdk": "^1.17.18",
+    "@opencode-ai/sdk": "^1.17.20",
     "@types/node": "^26.1.1",
     "tsup": "^8.5.1",
-    "typescript": "^6.0.3"
+    "typescript": "^7.0.2"
   },
   "dependencies": {
     "@openauthjs/openauth": "^0.4.3",
-    "@opencode-ai/plugin": "^1.17.18"
+    "@opencode-ai/plugin": "^1.17.20"
   }
 }