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

package/dist/src/constants.d.ts

@@ -0,0 +1,7 @@
+export declare const AGY_PROVIDER_ID = "google-agy";
+export declare const AGY_CLIENT_ID = "1071006060591-tmhssin2h21lcre235vtolojh4g403ep.apps.googleusercontent.com";
+export declare const AGY_CLIENT_SECRET = "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";
+export declare const AGY_SCOPES: readonly string[];
+export declare const AGY_REDIRECT_URI = "https://antigravity.google/oauth-callback";
+export declare const AGY_CODE_ASSIST_ENDPOINT: string;
+export declare const AGY_GENERATIVE_LANGUAGE_ENDPOINT = "https://generativelanguage.googleapis.com/v1beta";

package/dist/src/fetch.d.ts

@@ -0,0 +1 @@
+export declare function agyFetch(input: RequestInfo | URL, init?: RequestInit): Promise<Response>;

package/dist/src/plugin/auth.d.ts

@@ -0,0 +1,14 @@
+import type { AuthDetails, OAuthAuthDetails, RefreshParts } from './types';
+export declare function isOAuthAuth(auth: AuthDetails): auth is OAuthAuthDetails;
+/**
+ * Splits the packed refresh string into the corresponding refresh token and project ID.
+ */
+export declare function parseRefreshParts(refresh: string): RefreshParts;
+/**
+ * Serializes the parts of a refresh token into the stored string format.
+ */
+export declare function formatRefreshParts(parts: RefreshParts): string;
+/**
+ * Determines whether the access token has expired or is missing, with a buffer for clock skew.
+ */
+export declare function accessTokenExpired(auth: OAuthAuthDetails): boolean;

package/dist/src/plugin/cache.d.ts

@@ -0,0 +1,28 @@
+import type { OAuthAuthDetails } from "./types";
+import { SignatureCache, type SignatureCacheConfig } from "../sdk/cache/signature-cache";
+/**
+ * Extracts valid OAuthAuthDetails from cache. Reuses an available and unexpired Token if present, otherwise prioritizes the latest provided value.
+ */
+export declare function resolveCachedAuth(auth: OAuthAuthDetails): OAuthAuthDetails;
+/**
+ * Explicitly updates or saves authorized token details to the cache.
+ */
+export declare function storeCachedAuth(auth: OAuthAuthDetails): void;
+/**
+ * Clears cached login authorization details. If no refresh token is provided, clears the global cache.
+ */
+export declare function clearCachedAuth(refresh?: string): void;
+/**
+ * Initializes the disk-level signature storage manager.
+ */
+export declare function initDiskSignatureCache(config: SignatureCacheConfig | undefined): SignatureCache | null;
+/**
+ * Caches a thought chain fragment and its corresponding service signature, synchronously saving it to disk.
+ */
+export declare function cacheSignature(sessionId: string, text: string, signature: string): void;
+/**
+ * Recovers and retrieves the most recently cached signature for a session (supports signature recovery).
+ */
+export declare function getLatestSignature(sessionId: string): string | undefined;
+export type { SignatureCache } from "../sdk/cache/signature-cache";
+export type { SignatureCacheConfig } from "../sdk/cache/signature-cache";

package/dist/src/plugin/notify.d.ts

@@ -0,0 +1,9 @@
+import type { PluginClient } from "./types";
+/**
+ * Shows a Toast notification to the user when the server-side Agy model capacity is exhausted.
+ */
+export declare function maybeShowAgyCapacityToast(client: PluginClient, response: Response, projectId: string, requestedModel?: string): Promise<void>;
+/**
+ * Temporary smoke test Toast, only enabled when OPENCODE_AGY_TEST_TOAST=1.
+ */
+export declare function maybeShowAgyTestToast(client: PluginClient, projectId: string): Promise<void>;

package/dist/src/plugin/oauth-authorize.d.ts

@@ -0,0 +1,15 @@
+import type { AgyTokenExchangeResult } from '../sdk/oauth';
+import type { PluginClient } from './types';
+/**
+ * Builds the OAuth authorization callback for the plugin authentication method.
+ */
+export declare function createOAuthAuthorizeMethod(options?: {
+    client?: PluginClient;
+    getConfiguredProjectId?: () => Promise<string | undefined> | string | undefined;
+    getUserAgentModel?: () => Promise<string | undefined> | string | undefined;
+}): () => Promise<{
+    url: string;
+    instructions: string;
+    method: 'code';
+    callback: (callbackUrl: string) => Promise<AgyTokenExchangeResult>;
+}>;

package/dist/src/plugin/project/context.d.ts

@@ -0,0 +1,13 @@
+import type { OAuthAuthDetails, PluginClient, ProjectContextResult } from '../types';
+/**
+ * Clears cached project context results and pending Promises.
+ */
+export declare function invalidateProjectContextCache(refresh?: string): void;
+/**
+ * Resolves the project context corresponding to the access token, optionally persisting updated auth details.
+ */
+export declare function resolveProjectContextFromAccessToken(auth: OAuthAuthDetails, accessToken: string, configuredProjectId?: string, persistAuth?: (auth: OAuthAuthDetails) => Promise<void>, userAgentModel?: string): Promise<ProjectContextResult>;
+/**
+ * Resolves the effective project ID for the current auth state and caches the result by refresh token.
+ */
+export declare function ensureProjectContext(auth: OAuthAuthDetails, client: PluginClient, configuredProjectId?: string, userAgentModel?: string): Promise<ProjectContextResult>;

package/dist/src/plugin/project/index.d.ts

@@ -0,0 +1,2 @@
+export { retrieveUserQuota, retrieveUserQuotaSummary } from "../../sdk/fetch_quota";
+export { ensureProjectContext, invalidateProjectContextCache, resolveProjectContextFromAccessToken, } from "./context";

package/dist/src/plugin/project/types.d.ts

@@ -0,0 +1,84 @@
+export declare const FREE_TIER_ID = "free-tier";
+export declare const LEGACY_TIER_ID = "legacy-tier";
+export declare const CODE_ASSIST_METADATA: {
+    readonly ideType: "ANTIGRAVITY";
+};
+export interface AgyUserTier {
+    id?: string;
+    isDefault?: boolean;
+    userDefinedCloudaicompanionProject?: boolean;
+    name?: string;
+    description?: string;
+}
+export interface CloudAiCompanionProject {
+    id?: string;
+}
+export interface AgyIneligibleTier {
+    reasonCode?: string;
+    reasonMessage?: string;
+    validationUrl?: string;
+    validationLearnMoreUrl?: string;
+}
+export interface LoadCodeAssistPayload {
+    cloudaicompanionProject?: string | CloudAiCompanionProject;
+    currentTier?: {
+        id?: string;
+        name?: string;
+    };
+    allowedTiers?: AgyUserTier[];
+    ineligibleTiers?: AgyIneligibleTier[];
+}
+export interface OnboardUserPayload {
+    name?: string;
+    done?: boolean;
+    response?: {
+        cloudaicompanionProject?: {
+            id?: string;
+        };
+    };
+}
+export interface RetrieveUserQuotaBucket {
+    remainingAmount?: string;
+    remainingFraction?: number;
+    resetTime?: string;
+    tokenType?: string;
+    modelId?: string;
+}
+export interface RetrieveUserQuotaResponse {
+    buckets?: RetrieveUserQuotaBucket[];
+}
+export interface QuotaSummaryBucket {
+    bucketId?: string;
+    displayName?: string;
+    description?: string;
+    window?: string;
+    remaining?: string;
+    remainingFraction?: number;
+    remainingAmount?: string;
+    disabled?: boolean;
+    resetTime?: string;
+}
+export interface QuotaSummaryGroup {
+    displayName?: string;
+    description?: string;
+    buckets?: QuotaSummaryBucket[];
+}
+export interface RetrieveUserQuotaSummaryResponse {
+    groups?: QuotaSummaryGroup[];
+    buckets?: QuotaSummaryBucket[];
+    description?: string;
+}
+/**
+ * Thrown during Gemini enablement if the required Google Cloud project is missing.
+ */
+export declare class ProjectIdRequiredError extends Error {
+    constructor();
+}
+export declare class ProjectAccessDeniedError extends Error {
+    constructor(projectId: string | undefined, backendMessage: string | undefined);
+}
+export declare class AccountValidationRequiredError extends Error {
+    validationUrl?: string;
+    validationLearnMoreUrl?: string;
+    constructor(message: string, validationUrl?: string, validationLearnMoreUrl?: string);
+}

package/dist/src/plugin/project/utils.d.ts

@@ -0,0 +1,35 @@
+import type { OAuthAuthDetails } from "../types";
+import { type CloudAiCompanionProject, type AgyIneligibleTier, type AgyUserTier } from "./types";
+/**
+ * Builds the metadata headers required for the Code Assist API.
+ */
+export declare function buildMetadata(projectId?: string, includeDuetProject?: boolean): Record<string, string>;
+/**
+ * Normalizes project identifiers from API payloads or configuration.
+ */
+export declare function normalizeProjectId(value?: string | CloudAiCompanionProject): string | undefined;
+/**
+ * Selects the default hierarchy ID from the allowed hierarchy list.
+ */
+export declare function pickOnboardTier(allowedTiers?: AgyUserTier[]): AgyUserTier;
+/**
+ * Builds a concise error message for non-compliant hierarchy payloads.
+ */
+export declare function buildIneligibleTierMessage(tiers?: AgyIneligibleTier[]): string | undefined;
+export declare function throwIfValidationRequired(tiers?: AgyIneligibleTier[]): void;
+/**
+ * Detects VPC-SC errors from Cloud Code responses.
+ */
+export declare function isVpcScError(payload: unknown): boolean;
+/**
+ * Safely parses JSON, returning null on failure.
+ */
+export declare function parseJsonSafe(text: string): unknown;
+/**
+ * Promise-based delay utility.
+ */
+export declare function wait(ms: number): Promise<void>;
+/**
+ * Generates a cache key for the project context based on the refresh token.
+ */
+export declare function getCacheKey(auth: OAuthAuthDetails): string | undefined;

package/dist/src/plugin/provider.d.ts

@@ -0,0 +1,12 @@
+import type { Config } from "./types";
+import type { PluginClient, Provider } from "./types";
+interface ResolveConfiguredProjectIdInput {
+    provider?: Provider | null;
+    config?: Config | null;
+    configProjectId?: string;
+    env?: NodeJS.ProcessEnv;
+}
+export declare function resolveConfiguredProjectId(input?: ResolveConfiguredProjectIdInput): string | undefined;
+export declare function resolveConfiguredProjectIdFromConfig(config: Config | null | undefined): string | undefined;
+export declare function resolveConfiguredProjectIdFromClient(client: PluginClient | null | undefined): Promise<string | undefined>;
+export {};

package/dist/src/plugin/quota-summary.d.ts

@@ -0,0 +1,14 @@
+import type { GetAuth, PluginClient } from "./types";
+export declare const AGY_QUOTA_SUMMARY_TOOL_NAME = "agy_quota_summary";
+interface AgyQuotaSummaryToolDependencies {
+    client: PluginClient;
+    getAuthResolver: () => GetAuth | undefined;
+    getConfiguredProjectId: () => string | undefined;
+    getUserAgentModel: () => string | undefined;
+}
+export declare function createAgyQuotaSummaryTool({ client, getAuthResolver, getConfiguredProjectId, getUserAgentModel, }: AgyQuotaSummaryToolDependencies): {
+    description: string;
+    args: {};
+    execute(args: Record<string, never>, context: import("@opencode-ai/plugin").ToolContext): Promise<import("@opencode-ai/plugin").ToolResult>;
+};
+export {};

package/dist/src/plugin/quota-utils.d.ts

@@ -0,0 +1,5 @@
+export declare function clamp(value: number, min: number, max: number): number;
+export declare function pad(value: string, width: number): string;
+export declare function buildProgressBar(fraction: number, width?: number): string;
+export declare function formatRemainingAmount(value: string | undefined): string | undefined;
+export declare function formatRelativeResetTime(resetTime: string | undefined): string | undefined;

package/dist/src/plugin/quota.d.ts

@@ -0,0 +1,14 @@
+import type { GetAuth, PluginClient } from "./types";
+export declare const AGY_QUOTA_TOOL_NAME = "agy_quota";
+interface AgyQuotaToolDependencies {
+    client: PluginClient;
+    getAuthResolver: () => GetAuth | undefined;
+    getConfiguredProjectId: () => string | undefined;
+    getUserAgentModel: () => string | undefined;
+}
+export declare function createAgyQuotaTool({ client, getAuthResolver, getConfiguredProjectId, getUserAgentModel, }: AgyQuotaToolDependencies): {
+    description: string;
+    args: {};
+    execute(args: Record<string, never>, context: import("@opencode-ai/plugin").ToolContext): Promise<import("@opencode-ai/plugin").ToolResult>;
+};
+export {};

package/dist/src/plugin/token.d.ts

@@ -0,0 +1,2 @@
+import type { OAuthAuthDetails, PluginClient } from './types';
+export declare function refreshAccessToken(auth: OAuthAuthDetails, client: PluginClient): Promise<OAuthAuthDetails | undefined>;

package/dist/src/plugin/traffic.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Simulates the experimental fetch and metric telemetry traffic sent periodically by the official Agy client in the background to prevent API bans or anomaly detection.
+ */
+export declare function simulateClientBackgroundTraffic(accessToken: string, projectId: string, userAgentModel?: string): void;
+export declare function buildTrajectoryAnalyticsBody(cascadeId?: `${string}-${string}-${string}-${string}-${string}`, platform?: string): {
+    trajectory: {
+        cascadeId: `${string}-${string}-${string}-${string}-${string}`;
+        executorMetadatas: {
+            cascadeConfig: {
+                agentApiConfig: {
+                    enabled: boolean;
+                };
+                checkpointConfig: {
+                    checkpointModel: string;
+                    strategy: string;
+                    maxTokenLimit: string;
+                    tokenThreshold: string;
+                    maxOverheadRatio: string;
+                    movingWindowSize: string;
+                    enabled: boolean;
+                    maxOutputTokens: string;
+                    useLastPlannerModel: boolean;
+                    isSync: boolean;
+                    maxUserRequests: number;
+                    includeLastUserMessage: boolean;
+                    includeConversationLog: boolean;
+                    includeRunningTaskSnapshots: boolean;
+                    includeSubagentSnapshots: boolean;
+                    includeArtifactSnapshots: boolean;
+                    retryConfig: {
+                        maxRetries: number;
+                        initialSleepDurationMs: number;
+                        exponentialMultiplier: number;
+                        includeErrorFeedback: boolean;
+                    };
+                };
+            };
+        }[];
+    };
+    mendelExperimentIds: never[];
+    metadata: {
+        ideType: string;
+        ideVersion: string;
+        platform: string;
+    };
+    startStepIndex: string;
+};

package/dist/src/plugin/types.d.ts

@@ -0,0 +1,31 @@
+import type { OpencodeClient, Auth } from '@opencode-ai/sdk';
+import type { Provider as ProviderV1 } from '@opencode-ai/sdk';
+import type { Model as ModelV2 } from '@opencode-ai/sdk/v2';
+import type { Hooks, Config as PluginConfig } from '@opencode-ai/plugin';
+export type OAuthAuthDetails = Extract<Auth, {
+    type: 'oauth';
+}>;
+export type AuthDetails = Auth;
+export type GetAuth = () => Promise<AuthDetails>;
+export type Provider = ProviderV1;
+export type ProviderModel = ModelV2;
+export type Config = PluginConfig;
+export interface LoaderResult {
+    apiKey: string;
+    fetch(input: RequestInfo, init?: RequestInit): Promise<Response>;
+}
+export type PluginClient = OpencodeClient;
+export interface PluginContext {
+    client: PluginClient;
+}
+export type PluginResult = Hooks;
+export interface RefreshParts {
+    refreshToken: string;
+    projectId?: string;
+    managedProjectId?: string;
+}
+export interface ProjectContextResult {
+    auth: OAuthAuthDetails;
+    effectiveProjectId: string;
+}
+export type { Provider as ProviderV2, Model as ModelV2 } from '@opencode-ai/sdk/v2';

package/dist/src/plugin.d.ts

@@ -0,0 +1,6 @@
+import type { PluginContext, PluginResult } from './plugin/types';
+/**
+ * Registers the Agy OAuth provider for Opencode.
+ */
+export declare const AgyCLIOAuthPlugin: ({ client }: PluginContext) => Promise<PluginResult>;
+export declare const GoogleOAuthPlugin: typeof AgyCLIOAuthPlugin;

package/dist/src/sdk/activity-request-id.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Agy/Gemini CLI attaches a short activity ID to each request via its network logger.
+ * We mirror the same format so backend/debug traces look like CLI traffic.
+ */
+export declare function createAgyActivityRequestId(): string;

package/dist/src/sdk/agy-cli-version.d.ts

@@ -0,0 +1 @@
+export declare const AGY_CLI_VERSION = "1.1.2";

package/dist/src/sdk/cache/signature-cache.d.ts

@@ -0,0 +1,130 @@
+/**
+ * NOTE: Special Design - Cross-turn signature disk-level persistent cache
+ * Google Agy / Gemini 2.5/3 thinking models introduce strict "Thought Signature Validation" restrictions:
+ * In multi-turn dialogues (especially with Tool calls), the next request must carry a context signature (thoughtSignature) exactly matching the previous API response.
+ * To avoid conversation crashes caused by the following:
+ * 1. IDE-side session lifecycle rebuilds, causing loss of in-memory signature states.
+ * 2. Concurrent packets from multi-turn Tool interactions disrupting the memory cache of signatures.
+ * We implement a disk cache layer here with a background thread that periodically flushes to disk. Using a combination of session ID (sessionId) and historical thought chain hash digest as the Key,
+ * it persists the signatures and thought chains. Even if the IDE restarts or turns split, it can pull back the latest matching signature to fulfill official validation constraints.
+ */
+/**
+ * Signature cache configuration options
+ */
+export interface SignatureCacheConfig {
+    /** Whether to enable caching */
+    enabled: boolean;
+    /** In-memory cache time-to-live (seconds) */
+    memory_ttl_seconds: number;
+    /** Disk cache time-to-live (seconds) */
+    disk_ttl_seconds: number;
+    /** Auto-save interval to disk (seconds) */
+    write_interval_seconds: number;
+}
+/**
+ * Cache runtime state and statistics
+ */
+interface CacheStats {
+    /** Memory hit count */
+    memoryHits: number;
+    /** Disk hit count */
+    diskHits: number;
+    /** Miss count */
+    misses: number;
+    /** Disk write count */
+    writes: number;
+    /** Total number of entries currently in memory */
+    memoryEntries: number;
+    /** Whether the cache is dirty (has unsaved data) */
+    dirty: boolean;
+    /** Whether disk storage is enabled */
+    diskEnabled: boolean;
+}
+/**
+ * Retrieve full thought chain cache data structure
+ */
+export interface ThinkingCacheData {
+    /** Thought chain text */
+    text: string;
+    /** Signature */
+    signature: string;
+    /** Associated tool ID list */
+    toolIds?: string[];
+}
+export declare class SignatureCache {
+    private cache;
+    private memoryTtlMs;
+    private diskTtlMs;
+    private writeIntervalMs;
+    private cacheFilePath;
+    private enabled;
+    private dirty;
+    private writeTimer;
+    private cleanupTimer;
+    private stats;
+    constructor(config: SignatureCacheConfig);
+    /**
+     * Generates a unique cache key based on session ID and model ID
+     */
+    static makeKey(sessionId: string, modelId: string): string;
+    /**
+     * Stores a signature in cache (marks as dirty, awaits background disk write)
+     */
+    store(key: string, signature: string): void;
+    /**
+     * Retrieves a signature from cache and updates hit stats
+     * Returns null if expired or missing
+     */
+    retrieve(key: string): string | null;
+    /**
+     * Checks if a key is valid and unexpired in cache (without affecting stats)
+     */
+    has(key: string): boolean;
+    /**
+     * Caches the full thought chain text content and signature
+     * Allows self-healing and recovery of historical thought blocks even if the context is subsequently compressed.
+     */
+    storeThinking(key: string, thinkingText: string, signature: string, toolIds?: string[]): void;
+    /**
+     * Extracts full thought chain info from cache
+     */
+    retrieveThinking(key: string): ThinkingCacheData | null;
+    /**
+     * Checks if full thought chain content exists for a key
+     */
+    hasThinking(key: string): boolean;
+    /**
+     * Gets current cache stats and memory footprint
+     */
+    getStats(): CacheStats;
+    /**
+     * Manually triggers immediate save to disk
+     */
+    flush(): Promise<boolean>;
+    /**
+     * Graceful shutdown: stops all timers and flushes unsaved data to disk
+     */
+    shutdown(): void;
+    /**
+     * Loads signature cache from disk and validates TTL state
+     */
+    private loadFromDisk;
+    /**
+     * Synchronously saves memory cache to disk (using atomic write: temp file then rename)
+     * Merges with existing unexpired entries on disk during write
+     */
+    private saveToDisk;
+    /**
+     * Starts timers for auto-saving and auto-cleaning expired memory entries
+     */
+    private startBackgroundTasks;
+    /**
+     * Removes memory cache entries exceeding their TTL
+     */
+    private cleanupExpired;
+}
+/**
+ * Instantiates signature cache object based on config. Returns null if disabled.
+ */
+export declare function createSignatureCache(config: SignatureCacheConfig | undefined): SignatureCache | null;
+export {};

package/dist/src/sdk/chat-logger.d.ts

@@ -0,0 +1,8 @@
+export interface ChatLogger {
+    logRequest(url: string, method: string, headers: HeadersInit | undefined, body: BodyInit | null | undefined): void;
+    logResponseHeaders(status: number, statusText: string, headers: Headers): void;
+    logResponseBody(body: string): void;
+    createLoggingTransformStream(): TransformStream<Uint8Array, Uint8Array>;
+    close(): void;
+}
+export declare function createChatLogger(): ChatLogger | null;

package/dist/src/sdk/fetch_models.d.ts

@@ -0,0 +1,47 @@
+export interface AvailableModelDetails {
+    displayName: string;
+    supportsImages?: boolean;
+    supportsThinking?: boolean;
+    thinkingBudget?: number;
+    minThinkingBudget?: number;
+    recommended?: boolean;
+    maxTokens?: number;
+    maxOutputTokens?: number;
+    tokenizerType?: string;
+    quotaInfo?: {
+        remainingFraction?: number;
+        resetTime?: string;
+    };
+    model?: string;
+    apiProvider?: string;
+    modelProvider?: string;
+    supportsVideo?: boolean;
+    supportedMimeTypes?: Record<string, boolean>;
+    modelExperiments?: Record<string, unknown>;
+    [key: string]: unknown;
+}
+export interface FetchAvailableModelsResponse {
+    models?: Record<string, AvailableModelDetails>;
+    defaultAgentModelId?: string;
+    agentModelSorts?: Array<{
+        displayName: string;
+        groups: Array<{
+            modelIds: string[];
+        }>;
+    }>;
+    commandModelIds?: string[];
+    tabModelIds?: string[];
+    imageGenerationModelIds?: string[];
+    mqueryModelIds?: string[];
+    webSearchModelIds?: string[];
+    deprecatedModelIds?: Record<string, unknown>;
+    commitMessageModelIds?: string[];
+    audioTranscriptionModelIds?: string[];
+    experimentIds?: number[];
+    tieredModelIds?: Record<string, string[]>;
+    [key: string]: unknown;
+}
+/**
+ * Fetches the list of available models for the current account under the specified project from the Agy server.
+ */
+export declare function fetchAvailableModels(accessToken: string, projectId: string, userAgentModel?: string): Promise<FetchAvailableModelsResponse>;

package/dist/src/sdk/fetch_project.d.ts

@@ -0,0 +1,9 @@
+import { type LoadCodeAssistPayload } from '../plugin/project/types';
+/**
+ * Loads hosted project information for a given access token and optional project.
+ */
+export declare function loadManagedProject(accessToken: string, projectId?: string, userAgentModel?: string): Promise<LoadCodeAssistPayload | null>;
+/**
+ * Enables a hosted project for the user, optionally retrying until complete.
+ */
+export declare function onboardManagedProject(accessToken: string, tierId: string, projectId?: string, userAgentModel?: string, attempts?: number, delayMs?: number): Promise<string | undefined>;

package/dist/src/sdk/fetch_quota.d.ts

@@ -0,0 +1,9 @@
+import type { RetrieveUserQuotaResponse, RetrieveUserQuotaSummaryResponse } from '../plugin/project/types';
+/**
+ * Fetches the Code Assist quota bucket information, which contains the model IDs visible to the current account/project.
+ */
+export declare function retrieveUserQuota(accessToken: string, projectId: string, userAgentModel?: string): Promise<RetrieveUserQuotaResponse | null>;
+/**
+ * Fetches the Code Assist quota summary, grouped by model family with window-based buckets.
+ */
+export declare function retrieveUserQuotaSummary(accessToken: string, projectId: string, userAgentModel?: string): Promise<RetrieveUserQuotaSummaryResponse | null>;

package/dist/src/sdk/oauth.d.ts

@@ -0,0 +1,26 @@
+export interface AgyAuthorization {
+    url: string;
+    verifier: string;
+    state: string;
+}
+interface AgyTokenExchangeSuccess {
+    type: 'success';
+    refresh: string;
+    access: string;
+    expires: number;
+    email?: string;
+}
+interface AgyTokenExchangeFailure {
+    type: 'failed';
+    error: string;
+}
+export type AgyTokenExchangeResult = AgyTokenExchangeSuccess | AgyTokenExchangeFailure;
+/**
+ * Builds the Agy OAuth authorization URL with PKCE.
+ */
+export declare function authorizeAgy(): Promise<AgyAuthorization>;
+/**
+ * Exchanges the authorization code for Agy using a known PKCE verifier.
+ */
+export declare function exchangeAgyWithVerifier(code: string, verifier: string): Promise<AgyTokenExchangeResult>;
+export {};

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

@@ -0,0 +1,16 @@
+/**
+ * Applies canonical identifiers for wrapped Code Assist payloads.
+ */
+export declare function normalizeWrappedIdentifiers(wrapped: Record<string, unknown>): {
+    userPromptId: string;
+    sessionId: string;
+    requestId: string;
+};
+/**
+ * Applies canonical identifiers for unwrapped request payloads prior to wrapping.
+ */
+export declare function normalizeRequestPayloadIdentifiers(payload: Record<string, unknown>): {
+    userPromptId: string;
+    sessionId: string;
+    requestId: string;
+};

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

@@ -0,0 +1,11 @@
+/**
+ * NOTE: The request module here handles serialization, deserialization, and streaming data conversion between the standard OpenAI protocol and Agy's native Gemini protocol.
+ * Though normally an app/adapter layer responsibility, it's highly coupled with Agy's exclusive SSE streaming deduplication and multi-turn signature caching,
+ * so to ensure a simple and clean external interface, we package it as a built-in SDK capability, shielding the upper layer from all protocol conversion internal complexities.
+ */
+export { prepareAgyRequest } from "./prepare";
+export type { ThinkingConfigDefaults } from "./prepare";
+export { transformAgyResponse } from "./response";
+export { isGenerativeLanguageRequest, parseGenerativeLanguageRequest } from "./shared";
+export { initTurnStateTracker, getTurnStateTracker, shutdownTurnStateTracker, TurnStateTracker } from "./turn-state-tracker";
+export type { TurnState } from "./turn-state-tracker";