@crewx/sdk 0.9.0-rc.20 → 0.9.0-rc.200

package/dist/provider/cli/adapter.types.d.ts

@@ -1,24 +1,38 @@
 import type { ProviderQueryOptions, ProviderUsage } from '../bridge.js';
 import type { TaskLogEntry } from '../../types/task-log.types.js';
+import type { ModelTier } from '../../config/models.generated.js';
 import { ProviderError } from '../errors.js';
+export interface ParseEventContext {
+    readonly rowIndex: number;
+    readonly state: Map<string, unknown>;
+}
 export interface CliProviderAdapter {
     readonly command: string;
+    readonly maxInitialInputBytes?: number;
+    createSessionId?(): string;
+    extractSessionId?(line: string): string | null;
     readonly meta?: {
         displayName?: string;
         models?: Array<{
             id: string;
             name?: string;
+            description?: string;
+            contextWindowTokens?: number;
+            tier?: ModelTier;
         }>;
         defaultTimeoutMs?: {
             query?: number;
             execute?: number;
         };
+        defaultIdleMs?: number;
+        defaultResumeTimeoutMs?: number;
         capabilities?: {
             resume?: boolean;
             image?: boolean;
             audio?: boolean;
             mcp?: boolean;
             loadSession?: boolean;
+            usageCompleteness?: boolean;
         };
     };
     buildArgs(message: string, options: ProviderQueryOptions, isExecute: boolean): {
@@ -27,14 +41,24 @@ export interface CliProviderAdapter {
         env?: Record<string, string>;
     };
     extractText(stdout: string): string;
+    extractPartialText?(stdout: string): string | undefined;
     extractFailure?(line: string): Error | null;
-    interpretExit?(code: number, stderr: string): Error | null;
+    interpretExit?(code: number, stderr: string, stdout?: string): Error | null;
     parseResultMeta?(stdout: string): {
         usage?: ProviderUsage | null;
         model?: string | null;
     };
-    parseEvent?(line: string, timestamp?: string): TaskLogEntry[];
+    parseEvent?(line: string, timestamp?: string, context?: ParseEventContext): TaskLogEntry[];
     suppressOutputLine?(line: string): boolean;
+    observeRateLimit?(line: string): ProviderRateLimitWindows | undefined;
+}
+export interface ProviderRateLimitWindow {
+    utilization: number;
+    resetsAt: number;
+}
+export interface ProviderRateLimitWindows {
+    five_hour?: ProviderRateLimitWindow;
+    seven_day?: ProviderRateLimitWindow;
 }
 export declare class RateLimitError extends ProviderError {
     readonly name = "RateLimitError";

package/dist/provider/cli/adapters/agent-call.util.d.ts

@@ -1,3 +1,3 @@
 import type { TaskLogEntry } from '../../../types/task-log.types';
 export declare function isAgentCallCommand(command: string): boolean;
-export declare function parseAgentCall(timestamp: string, command: string): TaskLogEntry;
+export declare function parseAgentCall(timestamp: string, command: string, toolUseId?: string): TaskLogEntry;

package/dist/provider/cli/adapters/antigravity-stream.d.ts

@@ -0,0 +1,27 @@
+type JsonRecord = Record<string, unknown>;
+export type AntigravityStreamEvent = {
+    kind: 'init';
+    envelope: JsonRecord;
+    init: JsonRecord;
+} | {
+    kind: 'step_update';
+    envelope: JsonRecord;
+    step: JsonRecord;
+} | {
+    kind: 'result';
+    envelope: JsonRecord;
+    result: JsonRecord;
+} | {
+    kind: 'legacy_result';
+    envelope: JsonRecord;
+    result: JsonRecord;
+} | {
+    kind: 'agy_error';
+    envelope: JsonRecord;
+    error: unknown;
+};
+export declare function parseAntigravityLine(line: string): AntigravityStreamEvent | undefined;
+export declare function isAntigravityProtocolLine(line: string): boolean;
+export declare function isAntigravityMetadataOnlyLine(line: string): boolean;
+export declare function parseAntigravityStream(stdout: string): AntigravityStreamEvent[];
+export {};

package/dist/provider/cli/adapters/antigravity.d.ts

@@ -1,2 +1,3 @@
 import type { CliProviderAdapter } from '../adapter.types.js';
+export declare const ANTIGRAVITY_INITIAL_INPUT_BYTES = 180000;
 export declare const antigravityAdapter: CliProviderAdapter;

package/dist/provider/cli/adapters/cli-knob.util.d.ts

@@ -6,3 +6,10 @@ export declare function codexModeArgs(mode?: string): string[];
 export declare function codexResumeModeArgs(mode?: string): string[];
 export declare function codexEffortArgs(effort?: string): string[];
 export declare function claudeModeArgs(mode?: string): string[];
+export declare function claudeEffortArgs(effort?: string): string[];
+export declare function grokModeArgs(mode?: string): string[];
+export declare function grokAlwaysApproveArgs(alwaysApprove?: unknown): string[];
+export declare function grokSandboxArgs(sandbox?: unknown, onWarning?: (message: string) => void): string[];
+export declare function grokEffortArgs(effort?: string): string[];
+export declare function antigravityModeArgs(mode?: string): string[];
+export declare function antigravityEffortArgs(effort?: string): string[];

package/dist/provider/cli/adapters/codex-item.d.ts

@@ -0,0 +1 @@
+export declare function isCodexDisplaySkippedStart(value: unknown): boolean;

package/dist/provider/cli/adapters/event-timestamp.util.d.ts

@@ -0,0 +1 @@
+export declare function resolveEventTimestamp(parsed: unknown, fallbackTs: string): string;

package/dist/provider/cli/adapters/grok.d.ts

@@ -0,0 +1,2 @@
+import type { CliProviderAdapter } from '../adapter.types.js';
+export declare const grokAdapter: CliProviderAdapter;

package/dist/provider/cli/adapters/index.d.ts

@@ -5,6 +5,11 @@ export { copilotAdapter } from './copilot.js';
 export { codexAdapter } from './codex.js';
 export { opencodeAdapter } from './opencode.js';
 export { antigravityAdapter } from './antigravity.js';
+export { grokAdapter } from './grok.js';
 export { isAgentCallCommand, parseAgentCall } from './agent-call.util.js';
 export declare const BUILTIN_ADAPTERS: Record<string, CliProviderAdapter>;
 export declare function parseStdoutEvent(timestamp: string, message: string, providerId?: string): TaskLogEntry[];
+export interface LogParseSession {
+    parse(timestamp: string, message: string, rowIndex: number): TaskLogEntry[];
+}
+export declare function createLogParseSession(providerId?: string): LogParseSession;

package/dist/provider/cli/index.d.ts

@@ -1,3 +1,4 @@
-export { BUILTIN_ADAPTERS, parseStdoutEvent, claudeAdapter, copilotAdapter, codexAdapter, opencodeAdapter, antigravityAdapter, isAgentCallCommand, parseAgentCall, } from './adapters/index.js';
-export type { CliProviderAdapter } from './adapter.types.js';
+export { BUILTIN_ADAPTERS, parseStdoutEvent, createLogParseSession, claudeAdapter, copilotAdapter, codexAdapter, opencodeAdapter, antigravityAdapter, grokAdapter, isAgentCallCommand, parseAgentCall, } from './adapters/index.js';
+export type { CliProviderAdapter, ParseEventContext } from './adapter.types.js';
 export { RateLimitError } from './adapter.types.js';
+export type { LogParseSession } from './adapters/index.js';

package/dist/provider/cli/meta.d.ts

@@ -1,4 +1,5 @@
 import type { AcpProviderMetaResult } from '../acp/meta.js';
+import type { ModelTier } from '../../config/models.generated.js';
 import type { CliProviderAdapter } from './adapter.types.js';
 export declare function queryOpencodeModels(): Promise<Array<{
     id: string;
@@ -6,6 +7,10 @@ export declare function queryOpencodeModels(): Promise<Array<{
 export declare function cliAdapterMetaToProviderMeta(key: string, adapter: CliProviderAdapter, overrideModels?: Array<{
     id: string;
     name?: string;
+    description?: string;
+    contextWindowTokens?: number;
+    tier?: ModelTier;
+    recommended?: boolean;
 }>): AcpProviderMetaResult | null;
 export declare function queryAllCliProviderMetas(options?: {
     includeOpencodeRuntimeModels?: boolean;

package/dist/provider/cli/protocol-envelope.d.ts

@@ -0,0 +1,3 @@
+export declare function shouldSkipRawStdoutJsonFallback(message: string, providerId?: string): boolean;
+export declare function isProtocolOnlyText(text: string, providerId?: string): boolean;
+export declare function isMetadataOnlyProtocolLine(message: string, providerId: string): boolean;

package/dist/provider/errors.d.ts

@@ -1,5 +1,5 @@
 export type ProviderErrorKind = 'transient' | 'permanent' | 'config';
-export type ProviderErrorCode = 'QUOTA_EXHAUSTED' | 'RATE_LIMITED' | 'EMPTY_OUTPUT' | 'AUTH_REQUIRED' | 'MODEL_UNAVAILABLE' | 'TIMEOUT_IDLE' | 'TIMEOUT_TOTAL' | 'PROVIDER_NOT_FOUND' | 'INVALID_PROVIDER_FORMAT' | 'PROVIDER_CRASHED' | 'UNKNOWN';
+export type ProviderErrorCode = 'QUOTA_EXHAUSTED' | 'RATE_LIMITED' | 'EMPTY_OUTPUT' | 'AUTH_REQUIRED' | 'MODEL_UNAVAILABLE' | 'TIMEOUT_IDLE' | 'TIMEOUT_TOTAL' | 'TIMEOUT_RESUME' | 'PROVIDER_NOT_FOUND' | 'INVALID_PROVIDER_FORMAT' | 'PROVIDER_CRASHED' | 'UNKNOWN';
 export interface ProviderErrorOptions {
     code?: ProviderErrorCode;
     kind?: ProviderErrorKind;
@@ -10,6 +10,7 @@ export declare class ProviderError extends Error {
     readonly code: ProviderErrorCode;
     readonly kind?: ProviderErrorKind;
     readonly retryAfterMs?: number;
+    stdout?: string;
     constructor(message: string, providerStr: string, options?: ProviderErrorOptions);
 }
 export declare class IdleTimeoutError extends ProviderError {
@@ -18,3 +19,6 @@ export declare class IdleTimeoutError extends ProviderError {
 export declare class TotalTimeoutError extends ProviderError {
     constructor(message: string, providerStr: string);
 }
+export declare class ResumeTimeoutError extends ProviderError {
+    constructor(message: string, providerStr: string);
+}

package/dist/provider/idle-watchdog.d.ts

@@ -0,0 +1,19 @@
+export interface IdleWatchdogOptions {
+    timeoutMs: number;
+    onIdle: () => void;
+    now?: () => number;
+}
+export declare class IdleWatchdog {
+    private readonly timeoutMs;
+    private readonly onIdleCb;
+    private readonly now;
+    private timer;
+    private lastActivity;
+    private settled;
+    constructor(options: IdleWatchdogOptions);
+    start(): void;
+    refresh(): void;
+    stop(): void;
+    private scheduleCheck;
+    private fireIdle;
+}

package/dist/provider/models.d.ts

@@ -1,9 +1,22 @@
-import { type ModelCatalogEntry, type ProviderCatalogEntry, type ProviderModeEntry, type ProviderModelOverride } from '../config/models.generated.js';
-export type { ModelCatalogEntry, ProviderCatalogEntry, ProviderModeEntry, ProviderModelOverride, } from '../config/models.generated.js';
+import { type ModelCatalogEntry, type ModelTier, type ProviderCatalogEntry, type ProviderDefaultProfile, type ProviderModeEntry, type ProviderModelOverride } from '../config/models.generated.js';
+import type { ModelApiPricing } from '../config/pricing.types.js';
+export type { ModelTier, ModelCatalogEntry, ProviderCatalogEntry, ProviderDefaultProfile, ProviderDefaults, ProviderModeEntry, ProviderOptionSpec, ProviderModelOverride, } from '../config/models.generated.js';
+export type ModelMergeEntry = {
+    id: string;
+    name?: string;
+    description?: string;
+    contextWindowTokens?: number;
+    tier?: ModelTier;
+    recommended?: boolean;
+    apiPricing?: ModelApiPricing;
+};
 export declare function setModelsOverride(providers: Record<string, ProviderCatalogEntry | ModelCatalogEntry[]>): void;
 export declare function clearModelsOverride(): void;
+export declare function setModelsDefaultsOverride(providers: Record<string, ProviderDefaultProfile>): void;
+export declare function clearModelsDefaultsOverride(): void;
 export declare function getProviderModels(provider: string): ModelCatalogEntry[];
 export declare function getProviderCatalog(provider: string): ProviderCatalogEntry;
+export declare function getProviderDefaultProfile(provider: string): ProviderDefaultProfile | undefined;
 export declare function getProviderModes(provider: string): ProviderModeEntry[];
 export declare function getProviderEffort(provider: string, model?: string): string[];
 export declare function getProviderModelOverrides(provider: string): Record<string, ProviderModelOverride>;
@@ -11,13 +24,5 @@ export declare function getClaudeModels(): ModelCatalogEntry[];
 export declare function getCodexModels(): ModelCatalogEntry[];
 export declare function getCopilotModels(): ModelCatalogEntry[];
 export declare function getAntigravityModels(): ModelCatalogEntry[];
-export declare function mergeModels(a: Array<{
-    id: string;
-    name?: string;
-}>, b: Array<{
-    id: string;
-    name?: string;
-}>): Array<{
-    id: string;
-    name?: string;
-}>;
+export declare function mergeModels(a: ModelMergeEntry[], b: ModelMergeEntry[]): ModelMergeEntry[];
+export declare function withApiPricing(models: ModelMergeEntry[]): ModelMergeEntry[];

package/dist/provider/order.d.ts

@@ -1,4 +1,4 @@
-export declare const PROVIDER_ORDER: readonly ["codex", "claude", "opencode", "antigravity", "copilot"];
+export declare const PROVIDER_ORDER: readonly ["codex", "claude", "grok", "opencode", "antigravity", "copilot"];
 export declare function providerRank(id: string): number;
 export declare function compareProviders(a: string, b: string): number;
 export declare function normalizeProviderId(provider?: string): string;

package/dist/provider/parse-usage.d.ts

@@ -3,4 +3,10 @@ export interface ParsedUsage {
     outputTokens: number;
     cachedInputTokens: number;
 }
+export interface ClaudePartialUsage {
+    inputTokens: number;
+    cachedInputTokens: number;
+    model?: string;
+}
+export declare function parseClaudePartialUsage(stdout: string): ClaudePartialUsage | undefined;
 export declare function parseUsage(stdout: string): ParsedUsage | undefined;

package/dist/provider/provider-selection.d.ts

@@ -0,0 +1,8 @@
+import type { CliProviderAdapter } from './cli/adapter.types.js';
+export declare function lookupCliAdapter(providerStr: string): CliProviderAdapter | undefined;
+export type ProviderAvailabilityDeps = {
+    lookupAdapter?: (providerStr: string) => CliProviderAdapter | undefined;
+    env?: NodeJS.ProcessEnv;
+};
+export declare function isProviderAvailable(providerStr: string, deps?: ProviderAvailabilityDeps): boolean;
+export declare function selectAvailableProvider(providers: string | string[], deps?: ProviderAvailabilityDeps): string;

package/dist/provider/redact-technical-message.d.ts

@@ -0,0 +1 @@
+export declare function redactTechnicalMessage(value: unknown): string | undefined;

package/dist/provider/task-error.types.d.ts

@@ -0,0 +1,17 @@
+export type TaskErrorCode = 'USAGE_LIMITED' | 'CONTEXT_WINDOW_EXCEEDED' | 'INPUT_TOO_LARGE' | 'MODEL_NOT_SUPPORTED' | 'MODEL_AT_CAPACITY' | 'AUTH_REQUIRED' | 'CLI_NOT_AVAILABLE' | 'CLI_UPDATE_REQUIRED' | 'AGENT_NOT_FOUND' | 'PERMISSION_OR_TRUST' | 'TIMEOUT_OR_STUCK' | 'NETWORK_OR_PROVIDER_TRANSIENT' | 'PROVIDER_CONFIGURATION' | 'AGENT_MODE_RESTRICTED' | 'PROCESS_FAILED';
+export interface TaskErrorMeta {
+    resetAt?: string | number;
+    model?: string;
+    cliName?: string;
+    envKey?: string;
+    upstreamType?: string;
+    upstreamCode?: string | number;
+    mode?: string;
+    referenceId?: string;
+    technicalMessage?: string;
+}
+export interface TaskErrorProjection {
+    errorCode: TaskErrorCode | null;
+    errorProvider: string | null;
+    errorMeta?: TaskErrorMeta;
+}

package/dist/provider-account/accounts.d.ts

@@ -0,0 +1,15 @@
+import { type AddedAiAccount, type AiAccountEnvPlan, type AiAccountInvocation, type AiAccountProvider, type AiAccountSummary, type ResolvedAiAccount, type ResolveAiAccountInput } from './types';
+export declare function aiAccountEnvPlan(provider: AiAccountProvider, namedDir?: string): AiAccountEnvPlan;
+export declare function applyAiAccountEnv(base: NodeJS.ProcessEnv, plan: AiAccountEnvPlan): NodeJS.ProcessEnv;
+export declare function listAiAccounts(provider: string): AiAccountSummary[];
+export declare function addAiAccount(provider: string, label: string): AddedAiAccount;
+export declare function removeAiAccount(id: string): {
+    id: string;
+    label: string;
+    provider: AiAccountProvider;
+    removedAt: string;
+};
+export declare function setActiveAiAccount(provider: string, id: string): void;
+export declare function getLoginInvocation(id: string, provider?: string): AiAccountInvocation;
+export declare function getStatusInvocation(id: string, provider?: string): AiAccountInvocation;
+export declare function resolveAiAccountForRun(input: ResolveAiAccountInput): ResolvedAiAccount | undefined;

package/dist/provider-account/antigravity-acp/auth.d.ts

@@ -0,0 +1,29 @@
+import type { AcpConnection } from '../../provider/acp/connection.js';
+import type { AcpLineInterceptor } from '../../provider/acp/adapter.js';
+import type { InitializeResponse } from '../../provider/acp/types.js';
+import { AiAccountError } from '../types.js';
+import type { AiAccountErrorCode } from '../types.js';
+export type AntigravityAuthPromptMode = 'interactive' | 'noninteractive';
+export interface AntigravityAuthPromptObserver {
+    readonly mode: AntigravityAuthPromptMode;
+    readonly interceptLine: AcpLineInterceptor;
+    readonly authorizationUrl: string | null;
+    readonly failureCode: 'ACCOUNT_NOT_SIGNED_IN' | 'ACCOUNT_LOGIN_FAILED' | 'ACCOUNT_LOGIN_UNSUPPORTED_POLICY' | null;
+    readonly browserSuppressionObserved: boolean;
+}
+export interface CreateAntigravityAuthPromptObserverOptions {
+    mode: AntigravityAuthPromptMode;
+    controller: AbortController;
+    onAuthorizationUrl?: (url: string) => void;
+    onBrowserSuppression?: () => void;
+}
+export declare function parseAntigravityAuthorizationUrl(value: string): string;
+export declare function redactOAuthText(value: string): string;
+export declare function createAntigravityAuthPromptObserver(options: CreateAntigravityAuthPromptObserverOptions): AntigravityAuthPromptObserver;
+export declare function validateAntigravityInitialize(result: InitializeResponse | null | undefined, options?: {
+    requireLogout?: boolean;
+}): asserts result is InitializeResponse;
+export declare function authenticateAntigravityAcpConnection(connection: AcpConnection, observer: AntigravityAuthPromptObserver, options?: {
+    signal?: AbortSignal;
+}): Promise<void>;
+export declare function accountError(code: AiAccountErrorCode): AiAccountError;

package/dist/provider-account/antigravity-acp/browser.d.ts

@@ -0,0 +1,4 @@
+export declare const ANTIGRAVITY_BROWSER_SUPPRESSION_MARKER = "__CREWX_AGY_BROWSER_SUPPRESSED__";
+export declare const ANTIGRAVITY_BROWSER_SUPPRESSION_SCRIPT = "#!/bin/sh\nprintf '%s\\n' '__CREWX_AGY_BROWSER_SUPPRESSED__' >&2\nexit 0\n";
+export declare function createBrowserSuppressionHelper(directory: string): string;
+export declare function isSupportedBrowserHelperPath(helperPath: string): boolean;

package/dist/provider-account/antigravity-acp/install.d.ts

@@ -0,0 +1,42 @@
+import { type AiAccountProvider } from '../types';
+import { type AntigravityAcpDistribution } from './manifest';
+export type AiAccountRuntimeStatusReason = 'unsupported_platform' | 'not_installed' | 'digest_mismatch' | 'helper_path_unsupported';
+export interface AiAccountRuntimeStatus {
+    installed: boolean;
+    version?: string;
+    platformSupported: boolean;
+    reason?: AiAccountRuntimeStatusReason;
+}
+export type AiAccountRuntimeInstallPhase = 'download' | 'verify' | 'extract' | 'finalize';
+export interface AiAccountRuntimeInstallProgress {
+    phase: AiAccountRuntimeInstallPhase;
+    receivedBytes?: number;
+    totalBytes?: number;
+}
+export interface InstallAiAccountRuntimeOptions {
+    signal?: AbortSignal;
+    onProgress?: (progress: AiAccountRuntimeInstallProgress) => void;
+}
+export interface TrustedAiAccountRuntimePaths {
+    command: string;
+    args: string[];
+    harnessPath: string;
+    browserHelper: string;
+    browserSetting: string;
+    version: string;
+}
+export interface RuntimeInstallDependencies {
+    homeDir: string;
+    distribution: AntigravityAcpDistribution;
+    fetcher: typeof fetch;
+}
+export declare function getAiAccountRuntimeStatus(provider: AiAccountProvider): AiAccountRuntimeStatus;
+export declare function installAiAccountRuntime(provider: AiAccountProvider, options?: InstallAiAccountRuntimeOptions): Promise<AiAccountRuntimeStatus & {
+    installed: true;
+}>;
+export declare function resolveInstalledAiAccountRuntime(provider: AiAccountProvider): TrustedAiAccountRuntimePaths;
+export declare function getAiAccountRuntimeStatusAt(provider: AiAccountProvider, homeDir: string, platform: string, architecture: string, distributionOverride?: AntigravityAcpDistribution): AiAccountRuntimeStatus;
+export declare function resolveInstalledAiAccountRuntimeAt(provider: AiAccountProvider, homeDir: string, distribution: AntigravityAcpDistribution): TrustedAiAccountRuntimePaths;
+export declare function installAiAccountRuntimeWithDependencies(provider: AiAccountProvider, options: InstallAiAccountRuntimeOptions, dependencies: RuntimeInstallDependencies): Promise<AiAccountRuntimeStatus & {
+    installed: true;
+}>;

package/dist/provider-account/antigravity-acp/lease.d.ts

@@ -0,0 +1,23 @@
+export type AntigravityAuthRecord = Readonly<{
+    epoch: string;
+    state: 'stable' | 'login';
+}>;
+export type AntigravityProfileLeaseErrorCode = 'INVALID_PROFILE_DIR' | 'INVALID_TASK_ID' | 'AUTH_REQUIRED' | 'AUTH_INCOMPLETE' | 'AUTH_RECORD_INVALID' | 'AUTH_EPOCH_CHANGED' | 'AUTH_EPOCH_MISMATCH' | 'AUTHENTICATION_NOT_BEGUN' | 'PROFILE_BUSY' | 'LOCK_INVALID' | 'LOCK_UNVERIFIABLE' | 'OWNERSHIP_MISMATCH' | 'LEASE_RELEASED' | 'IO_ERROR';
+export declare class AntigravityProfileLeaseError extends Error {
+    readonly code: AntigravityProfileLeaseErrorCode;
+    constructor(code: AntigravityProfileLeaseErrorCode, message: string, cause?: unknown);
+}
+export type AntigravityRunLease = Readonly<{
+    epoch: string;
+    release: () => Promise<void>;
+}>;
+export type AntigravityExclusiveProfileLease = Readonly<{
+    beginAuthentication: () => Promise<string>;
+    commitAuthentication: (epoch: string) => Promise<void>;
+    commitLogout: (epoch: string) => Promise<void>;
+    release: () => Promise<void>;
+}>;
+export declare function readAuthRecord(accountDir: string): Promise<AntigravityAuthRecord | null>;
+export declare function acquireRunLease(accountDir: string, taskId: string): Promise<AntigravityRunLease>;
+export declare function acquireExclusiveProfileLease(accountDir: string): Promise<AntigravityExclusiveProfileLease>;
+export declare function assertProfileIdle(accountDir: string): Promise<void>;

package/dist/provider-account/antigravity-acp/lifecycle.d.ts

@@ -0,0 +1,76 @@
+import { AcpConnection } from '../../provider/acp/connection.js';
+import type { AcpConnectionOptions } from '../../provider/acp/connection.js';
+import type { AcpSpawnConfig } from '../../provider/acp/adapter.js';
+import { removeAiAccount } from '../accounts.js';
+import { type TrustedAiAccountRuntimePaths } from './install.js';
+import { type AiAccountErrorCode, type ResolvedAiAccount } from '../types.js';
+export type AiAccountRuntimeKind = 'native' | 'acp';
+export type AiAccountState = 'signed-in' | 'signed-out' | 'runtime-missing' | 'login-in-progress' | 'login-incomplete' | 'error';
+export type AntigravityAccountErrorCode = AiAccountErrorCode;
+export interface AiAccountStatus {
+    accountId: string;
+    state: AiAccountState;
+    authEpoch?: string;
+    runtimeVersion?: string;
+    code?: AntigravityAccountErrorCode;
+}
+export interface AiAccountLoginResult {
+    state: 'signed-in';
+    authEpoch: string;
+    browserSuppressionObserved: boolean;
+}
+export interface AiAccountLoginHandle {
+    readonly accountId: string;
+    readonly authorizationUrl: Promise<string | null>;
+    readonly done: Promise<AiAccountLoginResult>;
+    cancel(): Promise<void>;
+}
+export interface AiAccountRunBinding {
+    readonly accountId: string;
+    readonly runtime: 'acp';
+    readonly runtimeVersion: string;
+    readonly authEpoch: string;
+    readonly spawn: AcpSpawnConfig;
+    readonly env: Record<string, string>;
+    readonly unsetEnv: string[];
+    readonly unsetEnvPrefixes: string[];
+    release(): Promise<void>;
+}
+export interface AiAccountResumeMetadata {
+    authEpoch?: string;
+    runtime?: string;
+    runtimeVersion?: string;
+}
+export interface AntigravityAccountServiceDependencies {
+    resolveRuntime?: () => TrustedAiAccountRuntimePaths;
+    createConnection?: (options: AcpConnectionOptions) => AcpConnection;
+}
+export interface AiAccountLifecycleOptions {
+    signal?: AbortSignal;
+    timeoutMs?: number;
+}
+export declare function createAntigravityAccountService(dependencies?: AntigravityAccountServiceDependencies): {
+    getAiAccountStatus: (accountId: string, options?: AiAccountLifecycleOptions) => Promise<AiAccountStatus>;
+    startAiAccountLogin: (accountId: string, options?: AiAccountLifecycleOptions) => Promise<AiAccountLoginHandle>;
+    logoutAiAccount: (accountId: string) => Promise<void>;
+    assertAiAccountIdle: (accountId: string) => Promise<void>;
+    withAiAccountExclusive: <T>(accountId: string, operation: () => T | Promise<T>) => Promise<T>;
+    removeAiAccountGuarded: (accountId: string) => Promise<ReturnType<typeof removeAiAccount>>;
+    bindAiAccountRun: (input: {
+        account: ResolvedAiAccount;
+        taskId: string;
+        resume?: AiAccountResumeMetadata;
+    }) => Promise<AiAccountRunBinding>;
+};
+export declare const getAiAccountStatus: (accountId: string, options?: AiAccountLifecycleOptions) => Promise<AiAccountStatus>;
+export declare const startAiAccountLogin: (accountId: string, options?: AiAccountLifecycleOptions) => Promise<AiAccountLoginHandle>;
+export declare const logoutAiAccount: (accountId: string) => Promise<void>;
+export declare const assertAiAccountIdle: (accountId: string) => Promise<void>;
+export declare const withAiAccountExclusive: <T>(accountId: string, operation: () => T | Promise<T>) => Promise<T>;
+export declare const removeAiAccountGuarded: (accountId: string) => Promise<ReturnType<typeof removeAiAccount>>;
+export declare const bindAiAccountRun: (input: {
+    account: ResolvedAiAccount;
+    taskId: string;
+    resume?: AiAccountResumeMetadata;
+}) => Promise<AiAccountRunBinding>;
+export declare function requireActiveAiAccountRunBinding(value: unknown): AiAccountRunBinding;

package/dist/provider-account/antigravity-acp/manifest.d.ts

@@ -0,0 +1,76 @@
+export declare const ANTIGRAVITY_ACP_VERSION: "1.4.3";
+export interface AntigravityAcpDistribution {
+    platform: 'darwin' | 'linux' | 'win32';
+    architecture: 'arm64' | 'x64';
+    archiveUrl: string;
+    command: string;
+    args: readonly string[];
+    sha256: string;
+    archiveBytes?: number;
+    expectedMembers: readonly string[];
+    supported: boolean;
+}
+export declare const ANTIGRAVITY_ACP_DISTRIBUTIONS: {
+    readonly 'darwin-arm64': {
+        readonly platform: "darwin";
+        readonly architecture: "arm64";
+        readonly archiveUrl: "https://dl.google.com/agy-extensions/releases/macos/agy-acp-server-1.4.3-darwin-arm64.zip";
+        readonly command: "./agy_acp_server.par";
+        readonly args: readonly [];
+        readonly sha256: "c57db0a9b8b712daa9c3c17cdb990a61842ea569f279e8bd79d7aa85a303b20b";
+        readonly archiveBytes: 114147623;
+        readonly expectedMembers: readonly ["agy_acp_server.par", "localharness_external"];
+        readonly supported: true;
+    };
+    readonly 'darwin-x64': {
+        readonly platform: "darwin";
+        readonly architecture: "x64";
+        readonly archiveUrl: "https://dl.google.com/agy-extensions/releases/macos/agy-acp-server-1.4.3-darwin-x86_64.zip";
+        readonly command: "./agy_acp_server.par";
+        readonly args: readonly [];
+        readonly sha256: "9392dbbdad7f0663dbfb5a0bf641297b0cf80d2ee9cd2d49a616bbbc7378731d";
+        readonly expectedMembers: readonly ["agy_acp_server.par", "localharness_external"];
+        readonly supported: true;
+    };
+    readonly 'linux-x64': {
+        readonly platform: "linux";
+        readonly architecture: "x64";
+        readonly archiveUrl: "https://dl.google.com/agy-extensions/releases/linux/agy-acp-server-1.4.3-linux-x86_64.zip";
+        readonly command: "./agy_acp_server.par";
+        readonly args: readonly ["--uid="];
+        readonly sha256: "0634ce5306ba92c932945455e7a83fda78e2d99c33fa8aa6ee0566206a382714";
+        readonly expectedMembers: readonly ["agy_acp_server.par", "localharness_external"];
+        readonly supported: true;
+    };
+    readonly 'linux-arm64': {
+        readonly platform: "linux";
+        readonly architecture: "arm64";
+        readonly archiveUrl: "https://dl.google.com/agy-extensions/releases/linux/agy-acp-server-1.4.3-linux-arm64.zip";
+        readonly command: "./agy_acp_server.par";
+        readonly args: readonly ["--uid="];
+        readonly sha256: "05c153443b0b1175151c760eeddea538950bc9843e317d54786a1f03670182bc";
+        readonly expectedMembers: readonly ["agy_acp_server.par", "localharness_external"];
+        readonly supported: true;
+    };
+    readonly 'win32-x64': {
+        readonly platform: "win32";
+        readonly architecture: "x64";
+        readonly archiveUrl: "https://dl.google.com/agy-extensions/releases/windows/agy-acp-server-1.4.3-windows-x86_64.zip";
+        readonly command: "./agy_acp_server.exe";
+        readonly args: readonly [];
+        readonly sha256: "54c2e16378d9a4952e1da70e355f3c33c4f284308d6de48ab3e6e34a127bd325";
+        readonly expectedMembers: readonly [];
+        readonly supported: false;
+    };
+    readonly 'win32-arm64': {
+        readonly platform: "win32";
+        readonly architecture: "arm64";
+        readonly archiveUrl: "https://dl.google.com/agy-extensions/releases/windows/agy-acp-server-1.4.3-windows-arm64.zip";
+        readonly command: "./agy_acp_server.exe";
+        readonly args: readonly [];
+        readonly sha256: "fcd46431ad33d3b510ce0b98fe7b43d095bd8b3f1c363ee2d57faa7ee981c7bb";
+        readonly expectedMembers: readonly [];
+        readonly supported: false;
+    };
+};
+export declare function getAntigravityAcpDistribution(platform: string, architecture: string): AntigravityAcpDistribution | undefined;

package/dist/provider-account/antigravity-acp/profile.d.ts

@@ -0,0 +1,4 @@
+import type { AiAccountEnvPlan } from '../types';
+export declare const ANTIGRAVITY_ACCOUNT_STRIPPED_ENV: readonly ["GEMINI_API_KEY", "GOOGLE_API_KEY", "GOOGLE_APPLICATION_CREDENTIALS", "GOOGLE_CLOUD_PROJECT", "GOOGLE_CLOUD_LOCATION", "GOOGLE_CLOUD_QUOTA_PROJECT", "GOOGLE_GENAI_USE_VERTEXAI", "GCLOUD_PROJECT", "CLOUDSDK_CORE_PROJECT", "AGY_ADC_AUTH", "GEMINI_BASE_URL", "JETSKI_OAUTH_TOKEN"];
+export declare const ANTIGRAVITY_ACCOUNT_STRIPPED_ENV_PREFIXES: readonly ["AGY_ACP_"];
+export declare function antigravityAccountEnvPlan(accountDir: string): AiAccountEnvPlan;

package/dist/provider-account/capabilities.d.ts

@@ -0,0 +1,6 @@
+export declare function getAiAccountCapabilities(): Readonly<{
+    schemaVersion: 1;
+    supportedProviders: readonly ['cli/claude', 'cli/codex', 'cli/antigravity'];
+    registryVersions: readonly [1, 2];
+    features: readonly ['antigravity-acp-accounts-v1'];
+}>;

package/dist/provider-account/index.d.ts

@@ -0,0 +1,13 @@
+export { addAiAccount, applyAiAccountEnv, aiAccountEnvPlan, getLoginInvocation, getStatusInvocation, listAiAccounts, removeAiAccount, resolveAiAccountForRun, setActiveAiAccount, } from './accounts';
+export { getAiAccountCapabilities } from './capabilities';
+export { ANTIGRAVITY_ACCOUNT_STRIPPED_ENV, ANTIGRAVITY_ACCOUNT_STRIPPED_ENV_PREFIXES, antigravityAccountEnvPlan, } from './antigravity-acp/profile';
+export { ANTIGRAVITY_ACP_DISTRIBUTIONS, ANTIGRAVITY_ACP_VERSION, } from './antigravity-acp/manifest';
+export { getAiAccountRuntimeStatus, installAiAccountRuntime, } from './antigravity-acp/install';
+export type { AiAccountRuntimeInstallPhase, AiAccountRuntimeInstallProgress, AiAccountRuntimeStatus, AiAccountRuntimeStatusReason, InstallAiAccountRuntimeOptions, } from './antigravity-acp/install';
+export type { AntigravityAcpDistribution } from './antigravity-acp/manifest';
+export { assertAiAccountIdle, bindAiAccountRun, getAiAccountStatus, logoutAiAccount, removeAiAccountGuarded, startAiAccountLogin, withAiAccountExclusive, } from './antigravity-acp/lifecycle';
+export type { AiAccountLifecycleOptions, AiAccountLoginHandle, AiAccountLoginResult, AiAccountResumeMetadata, AiAccountRunBinding, AiAccountRuntimeKind, AiAccountState, AiAccountStatus, AntigravityAccountErrorCode, } from './antigravity-acp/lifecycle';
+export { defaultAiAccountDir, loadProviderAccountsRegistry, providerAccountsRegistryPath, providerAccountsRoot, } from './registry';
+export type { ProviderAccountsRegistry, RemovedAiAccount, StoredAiAccount, } from './registry';
+export { AI_ACCOUNT_PROVIDERS, AiAccountError, CLAUDE_ACCOUNT_STRIPPED_ENV, DEFAULT_AI_ACCOUNT_ID, } from './types';
+export type { AddedAiAccount, AiAccountEnvPlan, AiAccountErrorCode, AiAccountInvocation, AiAccountLoginKind, AiAccountProvider, AiAccountRuntime, AiAccountSummary, ResolveAiAccountInput, ResolvedAiAccount, } from './types';