@crewx/sdk 0.9.0-rc.190 → 0.9.0-rc.191

package/dist/provider/acp/adapter.d.ts

@@ -1,6 +1,7 @@
-import type { NewSessionRequest, SessionNotification, PromptResponse } from './types.js';
-import type { ProviderUsage } from '../bridge.js';
+import type { RequestPermissionRequest, RequestPermissionResponse, NewSessionRequest, NewSessionResponse, ResumeSessionResponse, SessionNotification, PromptResponse, InitializeResponse, ClientCapabilities } from './types.js';
+import type { ProviderQueryOptions, ProviderUsage } from '../bridge.js';
 import type { AcpSessionOptions, AcpOptionAction } from './types.js';
+import type { AcpConnection } from './connection.js';
 import type { TaskLogEntry } from '../../types/task-log.types.js';
 export type { AcpSessionOptions, AcpOptionAction };
 export interface AcpToolCallParsed {
@@ -27,9 +28,42 @@ export interface AcpProviderMeta {
     displayName: string;
     defaultMode?: string;
 }
+export type AcpPermissionPolicy = (request: RequestPermissionRequest) => RequestPermissionResponse | Promise<RequestPermissionResponse>;
+export interface AcpSessionSelectionContext {
+    readonly connection: AcpConnection;
+    readonly sessionId: string;
+    readonly resumed: boolean;
+    readonly sessionState?: NewSessionResponse | ResumeSessionResponse;
+    readonly options: ProviderQueryOptions;
+}
+export interface AcpAppliedSelection {
+    readonly model?: {
+        readonly requested?: string;
+        readonly applied?: string;
+    };
+    readonly effort?: {
+        readonly requested?: string;
+        readonly applied?: string;
+    };
+}
+export type AcpLineInterceptor = (stream: 'stdout' | 'stderr', line: string) => boolean;
 export interface AcpProviderAdapter {
     readonly spawn: AcpSpawnConfig;
+    readonly completionProof?: boolean;
+    readonly completionEligible?: () => boolean;
     readonly meta?: AcpProviderMeta;
+    readonly strictOptions?: boolean;
+    readonly connectTimeoutMs?: number;
+    readonly sessionTimeoutMs?: number;
+    readonly permissionPolicy?: AcpPermissionPolicy;
+    readonly autoAuthenticate?: boolean;
+    readonly allowIdOnlyAuth?: boolean;
+    readonly sessionResume?: boolean;
+    readonly clientCapabilities?: ClientCapabilities;
+    readonly validateInitialize?: (initializeResult: InitializeResponse) => void;
+    readonly beforeSession?: (connection: AcpConnection, initializeResult: InitializeResponse, options: ProviderQueryOptions) => void | Promise<void>;
+    readonly applySessionSelection?: (context: AcpSessionSelectionContext) => Promise<AcpAppliedSelection | void>;
+    readonly interceptLine?: AcpLineInterceptor;
     readonly npmPackage?: string;
     readonly clientInfo?: {
         name: string;
@@ -40,6 +74,7 @@ export interface AcpProviderAdapter {
     extractUsage?(result: PromptResponse): ProviderUsage | null;
     buildEffortAction?(effort: string, model?: string): AcpOptionAction | null;
     buildSpawnEnv?(model: string): Record<string, string> | undefined;
+    buildTrustedSpawnEnv?(options: ProviderQueryOptions): Record<string, string> | undefined;
     resolveMode?(mode: string): string | null;
     readonly yoloModeId?: string;
     parseToolCall?(event: AcpToolCallEvent): AcpToolCallParsed | null;

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

@@ -0,0 +1,4 @@
+import type { AiAccountRunBinding } from '../../../provider-account/antigravity-acp/lifecycle.js';
+import type { AcpProviderAdapter } from '../adapter.js';
+export declare function createAntigravityAccountAdapter(input: AiAccountRunBinding): AcpProviderAdapter;
+export declare function resolveAntigravityAccountMode(mode: string): string | null;

package/dist/provider/acp/completion-observer.d.ts

@@ -0,0 +1,24 @@
+export declare class AcpCompletionObserver {
+    private valid;
+    private eofObserved;
+    private sessionId;
+    private readonly pendingSessionUpdates;
+    private readonly tools;
+    private readonly pendingAgentRequests;
+    private readonly pendingClientRequests;
+    private readonly seenAgentRequestIds;
+    private readonly seenClientRequestIds;
+    observeLine(line: string): void;
+    observeOutgoingLine(line: string): void;
+    setSessionId(sessionId: string): void;
+    observeEndOfStream(): void;
+    invalidate(): void;
+    isCompleteFor(sessionId: string): boolean;
+    private observeAgentRequest;
+    private observeAgentNotification;
+    private observeAgentResponse;
+    private observeClientRequest;
+    private observeClientNotification;
+    private observeClientResponse;
+    private applySessionUpdate;
+}

package/dist/provider/acp/connection.d.ts

@@ -1,21 +1,39 @@
-import type { NewSessionRequest, NewSessionResponse, InitializeResponse, SessionNotification, PromptResponse, ContentBlock } from './types.js';
+import type { SetSessionConfigOptionResponse } from '@agentclientprotocol/sdk';
+import type { NewSessionRequest, NewSessionResponse, InitializeResponse, SessionNotification, PromptResponse, ContentBlock, ResumeSessionRequest, ResumeSessionResponse, ClientCapabilities } from './types.js';
 import { AcpProtocolError } from './types.js';
-import type { AcpSpawnConfig } from './adapter.js';
+import type { AcpLineInterceptor, AcpPermissionPolicy, AcpSpawnConfig } from './adapter.js';
 export interface AcpConnectionOptions {
     spawn: AcpSpawnConfig;
     env?: Record<string, string>;
+    trustedEnv?: Record<string, string>;
+    unsetEnv?: readonly string[];
+    unsetEnvPrefixes?: readonly string[];
     cwd?: string;
     timeoutMs?: number;
+    connectTimeoutMs?: number;
+    sessionTimeoutMs?: number;
+    strictOptions?: boolean;
+    autoAuthenticate?: boolean;
+    allowIdOnlyAuth?: boolean;
+    sessionResume?: boolean;
+    clientCapabilities?: ClientCapabilities;
+    interceptLine?: AcpLineInterceptor;
+    onProtocolLine?: (line: string) => void;
+    onOutgoingProtocolLine?: (line: string) => void;
+    verifyOwnedProcessGroup?: boolean;
+    signal?: AbortSignal;
     idleMs?: number;
     onStderr?: (line: string) => void;
     onPid?: (pid: number) => void;
     configOptions?: Record<string, string>;
+    permissionPolicy?: AcpPermissionPolicy;
 }
 export declare class AcpConnection {
     private readonly options;
     private proc;
     private sdkConnection;
     private disposed;
+    private disposePromise;
     private stderrBuffer;
     private collectedStderr;
     private stderrDecoder;
@@ -25,9 +43,23 @@ export declare class AcpConnection {
     private idleReject;
     private idlePromise;
     private authMethods;
+    private effectiveEnv;
     private _initResponse;
+    private stdoutDecoder;
+    private stdoutLineBuffer;
+    private outgoingDecoder;
+    private outgoingLineBuffer;
+    private _stdoutTailObserved;
+    private stdoutTailDone;
+    private readonly stdoutTailPromise;
+    private resolveStdoutTail;
+    private processClosePromise;
+    private ownedProcessGroupId;
+    private _ownedProcessGroupDisposed;
     get initResponse(): InitializeResponse | null;
     constructor(options: AcpConnectionOptions);
+    get ownedProcessGroupDisposed(): boolean;
+    get stdoutTailObserved(): boolean;
     connect(clientInfo?: {
         name: string;
         version: string;
@@ -37,14 +69,42 @@ export declare class AcpConnection {
     private newSessionWithTimeout;
     newSessionRaw(params: NewSessionRequest): Promise<NewSessionResponse>;
     private newSessionRawTimeout;
+    resumeSession(params: ResumeSessionRequest): Promise<string>;
+    resumeSessionRaw(params: ResumeSessionRequest): Promise<ResumeSessionResponse>;
+    private resumeSessionRawTimeout;
+    getAuthMethods(): Array<{
+        id: string;
+        name?: string;
+        type?: string;
+    }>;
+    authenticate(methodId: string, options?: {
+        signal?: AbortSignal;
+    }): Promise<void>;
+    logout(options?: {
+        signal?: AbortSignal;
+    }): Promise<void>;
+    private withProcessReply;
     private isAuthError;
     private tryAuthenticate;
     private hasEnvVarsFor;
+    private hasResumeCapability;
+    private createAuthRequiredError;
+    private assertCanOperate;
+    private withSignal;
+    private withTimeoutAndSignal;
+    private shouldConsumeLine;
+    private consumeStdoutText;
+    private finishStdoutTail;
+    private consumeOutgoingText;
+    private consumeStderrText;
+    private emitStderrLine;
     setModel(sessionId: string, modelId: string): Promise<void>;
     setMode(sessionId: string, modeId: string): Promise<void>;
-    setConfigOption(sessionId: string, configId: string, value: string): Promise<void>;
+    setConfigOption(sessionId: string, configId: string, value: string): Promise<SetSessionConfigOptionResponse>;
     prompt(sessionId: string, promptBlocks: ContentBlock[], onUpdate?: (notification: SessionNotification) => void, timeoutMs?: number): Promise<PromptResponse>;
     dispose(): Promise<void>;
+    private disposeResources;
+    private disposeOwnedProcessGroup;
     get isConnected(): boolean;
 }
 export { AcpProtocolError };

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

@@ -1,6 +1,6 @@
-export { AcpProtocolError } from './types.js';
-export type { AcpSessionOptions, InitializeRequest, InitializeResponse, NewSessionRequest, NewSessionResponse, PromptRequest, PromptResponse, SessionNotification, SessionUpdate, ContentBlock, McpServer, } from './types.js';
-export type { AcpProviderAdapter, AcpProviderMeta, AcpSpawnConfig } from './adapter.js';
+export { AcpAbortError, AcpAuthMethodError, AcpAuthRequiredError, AcpCapabilityError, AcpOptionError, AcpProtocolError, } from './types.js';
+export type { AcpSessionOptions, AcpProtocolErrorReason, ClientCapabilities, InitializeRequest, InitializeResponse, NewSessionRequest, NewSessionResponse, PromptRequest, PromptResponse, ResumeSessionRequest, ResumeSessionResponse, RequestPermissionRequest, RequestPermissionResponse, SessionNotification, SessionUpdate, ContentBlock, McpServer, } from './types.js';
+export type { AcpAppliedSelection, AcpLineInterceptor, AcpPermissionPolicy, AcpProviderAdapter, AcpProviderMeta, AcpSessionSelectionContext, AcpSpawnConfig, } from './adapter.js';
 export { defaultExtractText, defaultParseEvent } from './adapter.js';
 export type { AcpProviderMetaResult } from './meta.js';
 export { queryAcpProviderMeta, queryAllAcpProviderMetas } from './meta.js';

package/dist/provider/acp/register.d.ts

@@ -1,2 +1,3 @@
 import type { ProviderFactory } from '../bridge.js';
 export declare function registerAcpProviders(factory?: ProviderFactory): void;
+export declare function registerAntigravityAccountProvider(): void;

package/dist/provider/acp/runtime.d.ts

@@ -7,6 +7,7 @@ export declare class AcpProviderRuntime implements ProviderRuntime {
     execute(message: string, options?: ProviderQueryOptions): Promise<string>;
     dispose(): Promise<void>;
     private runPrompt;
+    private awaitWithSignal;
     private applySessionOptions;
     private composePrompt;
     private handleUpdate;

package/dist/provider/acp/types.d.ts

@@ -1,5 +1,5 @@
-import type { InitializeRequest, InitializeResponse, NewSessionRequest, NewSessionResponse, PromptRequest, PromptResponse, SessionNotification, SessionUpdate, ContentBlock, McpServer, ClientCapabilities } from '@agentclientprotocol/sdk';
-export type { InitializeRequest, InitializeResponse, NewSessionRequest, NewSessionResponse, PromptRequest, PromptResponse, SessionNotification, SessionUpdate, ContentBlock, McpServer, ClientCapabilities, };
+import type { InitializeRequest, InitializeResponse, NewSessionRequest, NewSessionResponse, PromptRequest, PromptResponse, ResumeSessionRequest, ResumeSessionResponse, RequestPermissionRequest, RequestPermissionResponse, SessionNotification, SessionUpdate, ContentBlock, McpServer, ClientCapabilities } from '@agentclientprotocol/sdk';
+export type { InitializeRequest, InitializeResponse, NewSessionRequest, NewSessionResponse, PromptRequest, PromptResponse, ResumeSessionRequest, ResumeSessionResponse, RequestPermissionRequest, RequestPermissionResponse, SessionNotification, SessionUpdate, ContentBlock, McpServer, ClientCapabilities, };
 export interface AcpSessionOptions {
     cwd?: string;
     env?: Record<string, string>;
@@ -16,9 +16,36 @@ export type AcpOptionAction = {
     type: 'set_model';
     modelId: string;
 };
+export type AcpProtocolErrorReason = 'connect_timeout' | 'session_timeout' | 'resume_unsupported' | 'auth_required' | 'auth_method_unsupported' | 'aborted';
 export declare class AcpProtocolError extends Error {
     readonly code?: number | undefined;
     readonly data?: unknown | undefined;
-    readonly name = "AcpProtocolError";
-    constructor(message: string, code?: number | undefined, data?: unknown | undefined);
+    readonly reason?: AcpProtocolErrorReason | undefined;
+    readonly name: string;
+    constructor(message: string, code?: number | undefined, data?: unknown | undefined, reason?: AcpProtocolErrorReason | undefined);
+}
+export declare class AcpAuthRequiredError extends AcpProtocolError {
+    readonly name = "AcpAuthRequiredError";
+    readonly methodIds: readonly string[];
+    constructor(methodIds: readonly string[]);
+}
+export declare class AcpAuthMethodError extends AcpProtocolError {
+    readonly name = "AcpAuthMethodError";
+    constructor();
+}
+export declare class AcpCapabilityError extends AcpProtocolError {
+    readonly capability: 'session.resume' | 'auth.logout';
+    readonly name = "AcpCapabilityError";
+    constructor(capability: 'session.resume' | 'auth.logout');
+}
+export declare class AcpAbortError extends AcpProtocolError {
+    readonly name = "AcpAbortError";
+    constructor();
+}
+export declare class AcpOptionError extends AcpProtocolError {
+    readonly name: string;
+    readonly option: 'model' | 'mode' | 'config';
+    readonly requestedValue: string;
+    readonly supportedValues?: readonly string[];
+    constructor(option: 'model' | 'mode' | 'config', requestedValue: string, supportedValues?: readonly string[], reason?: string);
 }

package/dist/provider/bridge.browser.d.ts

@@ -8,6 +8,7 @@ export interface ProviderUsage {
     complete?: boolean;
 }
 export interface ProviderQueryOptions {
+    signal?: AbortSignal;
     model?: string;
     context?: string;
     systemPrompt?: string;

package/dist/provider/bridge.d.ts

@@ -43,7 +43,7 @@ export declare class ClientToolCallRequiredError extends Error {
     readonly name = "ClientToolCallRequiredError";
     constructor(toolCall: ClientToolCall, continuationState: ContinuationState);
 }
-export type ProviderFactory = (id: string, providerStr: string) => ProviderRuntime;
+export type ProviderFactory = (id: string, providerStr: string, context?: unknown) => ProviderRuntime;
 export type AdditionalArgsProvider = (ctx: {
     providerStr: string;
     providerId: string;
@@ -58,6 +58,7 @@ export interface ProviderUsage {
     complete?: boolean;
 }
 export interface ProviderQueryOptions {
+    signal?: AbortSignal;
     model?: string;
     effort?: string;
     mode?: string;
@@ -68,6 +69,11 @@ export interface ProviderQueryOptions {
     resumeSessionId?: string;
     providerSessionId?: string;
     onProviderSessionId?: (id: string) => void;
+    onAcpCompletionProof?: (proof: {
+        sessionId: string;
+        stopReason: 'end_turn';
+        lifecycleComplete: true;
+    }) => void;
     onSpawn?: () => void;
     onOutput?: (line: string, level: 'stdout' | 'stderr') => void;
     onPid?: (pid: number) => void;
@@ -78,6 +84,7 @@ export interface ProviderQueryOptions {
     onTaskLog?: (entries: import('../types/task-log.types').TaskLogEntry[]) => void;
     env?: Record<string, string>;
     unsetEnv?: readonly string[];
+    unsetEnvPrefixes?: readonly string[];
     onRateLimitObserved?: (windows: ProviderRateLimitWindows) => void;
     cwd?: string;
     timeoutMs?: number;
@@ -97,6 +104,7 @@ export interface ProviderRuntime {
     dispose?(): Promise<void>;
 }
 export declare function createProvider(providerStr: string, additionalArgsProvider?: AdditionalArgsProvider): ProviderRuntime;
+export declare function createProviderWithContext(providerStr: string, additionalArgsProvider?: AdditionalArgsProvider, context?: unknown): ProviderRuntime;
 export declare function mergeAdditionalArgs(options: ProviderQueryOptions | undefined, provider: AdditionalArgsProvider | undefined, ctx: {
     providerStr: string;
     providerId: string;

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

@@ -1,5 +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, AiAccountProvider, AiAccountSummary, ResolveAiAccountInput, ResolvedAiAccount, } from './types';
+export type { AddedAiAccount, AiAccountEnvPlan, AiAccountErrorCode, AiAccountInvocation, AiAccountLoginKind, AiAccountProvider, AiAccountRuntime, AiAccountSummary, ResolveAiAccountInput, ResolvedAiAccount, } from './types';

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

@@ -16,7 +16,7 @@ export interface ProviderAccountSlot {
     accounts: StoredAiAccount[];
 }
 export interface ProviderAccountsRegistry {
-    version: 1;
+    version: 1 | 2;
     providers: Record<AiAccountProvider, ProviderAccountSlot>;
     removed: RemovedAiAccount[];
 }