@crewx/sdk 0.9.0-rc.23 → 0.9.0-rc.231

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

@@ -1,40 +1,68 @@
 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 CliProviderInvocation {
+    args: string[];
+    stdinMessage?: string;
+    env?: Record<string, string>;
+    prepare?: () => void | Promise<void>;
+    dispose?: () => void | Promise<void>;
+}
 export interface CliProviderAdapter {
     readonly command: string;
+    readonly maxInitialInputBytes?: number;
+    createSessionId?(): string;
+    prepare?(options: ProviderQueryOptions): ProviderQueryOptions | Promise<ProviderQueryOptions>;
+    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): {
-        args: string[];
-        stdinMessage?: string;
-        env?: Record<string, string>;
-    };
+    buildArgs(message: string, options: ProviderQueryOptions, isExecute: boolean): CliProviderInvocation;
     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/claude-task-events.d.ts

@@ -0,0 +1,48 @@
+type ClaudeTaskType = 'local_bash' | 'local_agent' | 'unknown';
+interface ClaudeTaskUsageSnapshot {
+    totalTokens?: number;
+    toolUses?: number;
+    durationMs?: number;
+}
+interface ClaudeTaskStartedEvent {
+    subtype: 'task_started';
+    taskId: string;
+    parentToolUseId?: string;
+    taskType: ClaudeTaskType;
+    label?: string;
+    isBackgrounded?: boolean;
+}
+interface ClaudeTaskProgressEvent {
+    subtype: 'task_progress';
+    taskId: string;
+    parentToolUseId?: string;
+    lastToolName?: string;
+    usage?: ClaudeTaskUsageSnapshot;
+}
+interface ClaudeTaskUpdatedEvent {
+    subtype: 'task_updated';
+    taskId: string;
+    patch: {
+        isBackgrounded?: boolean;
+        status?: string;
+        endTime?: number;
+    };
+}
+interface ClaudeTaskNotificationEvent {
+    subtype: 'task_notification';
+    taskId: string;
+    parentToolUseId?: string;
+    status?: string;
+    exitCode?: number;
+}
+interface ClaudeBackgroundTaskChangedItem {
+    taskId: string;
+    taskType: ClaudeTaskType;
+}
+interface ClaudeBackgroundTasksChangedEvent {
+    subtype: 'background_tasks_changed';
+    tasks: ClaudeBackgroundTaskChangedItem[];
+}
+export type ClaudeTaskEvent = ClaudeTaskStartedEvent | ClaudeTaskProgressEvent | ClaudeTaskUpdatedEvent | ClaudeTaskNotificationEvent | ClaudeBackgroundTasksChangedEvent;
+export declare function parseClaudeTaskEvent(value: unknown): ClaudeTaskEvent | null;
+export {};

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/adapters/opencode-data-dir.d.ts

@@ -0,0 +1,17 @@
+import type BetterSqlite3 from 'better-sqlite3';
+import type { ProviderQueryOptions } from '../../bridge.js';
+type SqliteConstructor = typeof BetterSqlite3;
+export interface OpenCodeDataEnv extends Record<string, string> {
+    XDG_DATA_HOME: string;
+    XDG_STATE_HOME: string;
+}
+export interface OpenCodePrepareDependencies {
+    crewxHome?: string;
+    userDataHome?: string;
+    loadSqlite?: () => Promise<SqliteConstructor>;
+    initializeDatabase?: (env: OpenCodeDataEnv) => Promise<void>;
+}
+export declare function getOpenCodeDataEnv(crewxHome?: string): OpenCodeDataEnv;
+export declare function getOpenCodeDataDir(crewxHome?: string): string;
+export declare function prepareOpenCodeRunOptions(options: ProviderQueryOptions, dependencies?: OpenCodePrepareDependencies): Promise<ProviderQueryOptions>;
+export {};

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

@@ -1,2 +1,3 @@
 import type { CliProviderAdapter } from '../adapter.types.js';
+export declare function getCachedOpencodeModelEfforts(): Promise<Map<string, string[]>>;
 export declare const opencodeAdapter: CliProviderAdapter;

package/dist/provider/cli/builtin-allow.d.ts

@@ -0,0 +1,6 @@
+export declare const CORE_BUILTIN_ALLOW_COMMANDS: readonly ["crewx memory", "crewx search", "crewx doc", "crewx notify"];
+export declare const REST_BUILTIN_ALLOW_COMMANDS: readonly ["crewx q", "crewx query", "crewx x", "crewx execute", "crewx cron", "crewx wbs", "crewx wi", "crewx workflow", "crewx app", "crewx skill"];
+export type BuiltinAllowScope = 'core' | 'all';
+export declare function builtinAllowCommands(scope: BuiltinAllowScope | undefined): readonly string[];
+export declare function claudeBuiltinAllowRules(scope: BuiltinAllowScope | undefined): string[];
+export declare function antigravityBuiltinAllowRules(scope: BuiltinAllowScope | undefined): string[];

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,11 +1,28 @@
 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<{
+export type OpenCodeModelQueryErrorStage = 'prepare' | 'execute' | 'decode';
+export type OpenCodeModelQueryErrorReason = 'preparation_failed' | 'command_not_found' | 'timeout' | 'nonzero_exit' | 'execution_failed' | 'decode_failed';
+export type OpenCodeModelQueryErrorCode = 'OPENCODE_MODELS_PREPARATION_FAILED' | 'OPENCODE_MODELS_COMMAND_NOT_FOUND' | 'OPENCODE_MODELS_TIMEOUT' | 'OPENCODE_MODELS_EXECUTION_FAILED' | 'OPENCODE_MODELS_DECODE_FAILED';
+export declare class OpenCodeModelQueryError extends Error {
+    readonly code: OpenCodeModelQueryErrorCode;
+    readonly reason: OpenCodeModelQueryErrorReason;
+    readonly stage: OpenCodeModelQueryErrorStage;
+    constructor(reason: OpenCodeModelQueryErrorReason);
+}
+export declare function queryOpencodeModels(options?: {
+    throwOnError?: boolean;
+}): Promise<Array<{
     id: string;
 }>>;
+export declare function queryOpencodeModelEfforts(): Promise<Map<string, string[]>>;
 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,15 +1,22 @@
 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' | 'ACCOUNT_SETTING_REQUIRED' | 'MODEL_RETIRED' | 'SUBSCRIPTION_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;
     retryAfterMs?: number;
+    settingReason?: 'region' | 'training_consent' | 'access' | 'other';
+    replacementModel?: string;
+    providerReason?: string;
 }
 export declare class ProviderError extends Error {
     readonly providerStr: string;
     readonly code: ProviderErrorCode;
     readonly kind?: ProviderErrorKind;
     readonly retryAfterMs?: number;
+    readonly settingReason?: ProviderErrorOptions['settingReason'];
+    readonly replacementModel?: string;
+    readonly providerReason?: string;
+    stdout?: string;
     constructor(message: string, providerStr: string, options?: ProviderErrorOptions);
 }
 export declare class IdleTimeoutError extends ProviderError {
@@ -18,3 +25,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/model-ladder.d.ts

@@ -0,0 +1,8 @@
+export declare function suggestStrongerModel(options: {
+    provider: string;
+    model?: string;
+    effort?: string;
+}): {
+    model: string;
+    effort?: string;
+} | undefined;

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/safe-opencode-text.d.ts

@@ -0,0 +1,2 @@
+export declare function safeOpenCodeText(value: unknown, maxLength?: number): string | undefined;
+export declare function safeOpenCodeReason(value: unknown): string | undefined;

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

@@ -0,0 +1,20 @@
+export type TaskErrorCode = 'USAGE_LIMITED' | 'CONTEXT_WINDOW_EXCEEDED' | 'INPUT_TOO_LARGE' | 'MODEL_NOT_SUPPORTED' | 'MODEL_AT_CAPACITY' | 'AUTH_REQUIRED' | 'ACCOUNT_SETTING_REQUIRED' | 'MODEL_RETIRED' | 'SUBSCRIPTION_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;
+    settingReason?: 'region' | 'training_consent' | 'access' | 'other';
+    replacementModel?: string;
+    providerReason?: string;
+    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;