linkshell-cli 0.10.36 → 0.10.38

package/dist/host/src/drivers/acp/antigravity.d.ts

@@ -1,5 +1,6 @@
-import { type AgentAuth, type ContentBlock, type GoalChange, type SessionGoal } from "@linkshell/wire";
-import type { AttachContext, DiscoveredSession, HistoryItem } from "../types.js";
+import { type AgentAuth, type ContentBlock, type GoalChange, type QuestionAnswer, type SessionGoal } from "@linkshell/wire";
+import type { DriverBehavior } from "../behavior.js";
+import type { AttachContext, DiscoveredSession, ForkOptions, HistoryItem } from "../types.js";
 import { AcpDriver, type AcpAgentSpec } from "./driver.js";
 /**
  * Official Google Antigravity ACP distribution metadata (from the ACP Registry:
@@ -39,66 +40,232 @@ export declare function resolveAntigravityDesktop(env?: NodeJS.ProcessEnv): Reso
 export declare function extractAntigravityAuthUrl(line: string): string | undefined;
 export declare function antigravityAuthStatus(env: NodeJS.ProcessEnv): Promise<AgentAuth>;
 export declare function antigravitySpec(): AcpAgentSpec;
+interface TranscriptToolCall {
+    id?: string;
+    name?: string;
+    args?: Record<string, unknown>;
+}
+interface TranscriptMedia {
+    mime_type?: string;
+    mimeType?: string;
+    uri?: string;
+    inline_data?: string;
+    inlineData?: string;
+}
+interface TranscriptStep {
+    step_index?: number;
+    source?: string;
+    type?: string;
+    status?: string;
+    created_at?: string;
+    content?: string;
+    error?: string;
+    thinking?: string;
+    tool_calls?: TranscriptToolCall[];
+    media?: TranscriptMedia[];
+    input_tokens?: number;
+    cache_read_tokens?: number;
+    output_tokens?: number;
+}
 export declare function cleanAntigravityUserInput(content: string): string;
 export declare function cleanAntigravityAgentContent(content: string): {
     text: string;
     goalComplete: boolean;
     goalCancelled: boolean;
 };
+export interface AskQuestionItem {
+    question: string;
+    isMultiSelect?: boolean;
+    options?: {
+        id: string;
+        text: string;
+    }[];
+}
+export interface PendingDesktopAskQuestion {
+    stepIndex: number;
+    toolCallId: string;
+    title: string;
+    questions: AskQuestionItem[];
+}
+/** What has to be remembered between reads of a transcript so the next lines are understood the same way. */
+export interface TranscriptParseState {
+    goal: SessionGoal | null;
+    lastModelLabel?: string;
+    lastStepIndex?: number;
+    /** A reply whose tool calls are still waiting for their outputs (the GENERIC steps that follow). */
+    openCalls?: {
+        stepIndex: number;
+        calls: TranscriptToolCall[];
+        consumed: number;
+    };
+}
+export declare function newTranscriptParseState(): TranscriptParseState;
+/**
+ * Turns transcript steps into history items, carrying `state` across calls so
+ * the transcript can be read a few lines at a time. Tool calls whose outputs
+ * haven't been written yet are `in_progress`; their outputs arrive later as
+ * `tool_call_update`s.
+ */
+export declare function parseTranscriptSteps(parsed: {
+    index: number;
+    step: TranscriptStep;
+}[], state: TranscriptParseState): {
+    items: HistoryItem[];
+    pendingAskQuestion?: PendingDesktopAskQuestion;
+};
 /**
  * Converts an Antigravity Desktop `transcript_full.jsonl` (or `transcript.jsonl`)
  * file into LinkShell's `HistoryItem[]` list, tracking Goal Mode (`ls_goal`),
- * model changes (`<USER_SETTINGS_CHANGE>`), and uploaded media.
+ * model changes (`<USER_SETTINGS_CHANGE>`), and uploaded media. Lines before
+ * `fromLine` only rebuild state.
  */
 export declare function parseAntigravityTranscript(transcriptPath: string, fromLine?: number): {
     items: HistoryItem[];
     nextLine: number;
+    lastStepIndex?: number;
     lastModelLabel?: string;
     goal?: SessionGoal | null;
+    pendingAskQuestion?: PendingDesktopAskQuestion;
+    state: TranscriptParseState;
+    /** Byte offset just past the last complete line: where a TranscriptTail picks up. */
+    endOffset: number;
 };
+/**
+ * Follows a transcript by byte offset so a long conversation (tens of MB) is
+ * never re-read: each poll parses only the lines appended since the last.
+ */
+export declare class TranscriptTail {
+    private path;
+    readonly state: TranscriptParseState;
+    private offset;
+    private remainder;
+    constructor(path: string, state: TranscriptParseState, offset: number);
+    read(currentPath: string): {
+        items: HistoryItem[];
+        pendingAskQuestion?: PendingDesktopAskQuestion;
+        changed: boolean;
+    };
+}
 /**
  * Specialized driver for Google Antigravity:
  * - Drives `agy_acp_server.par` / `agy-acp` over ACP when installed.
  * - Also discovers and interacts with Antigravity Desktop (`/Applications/Antigravity.app`,
  *   `~/.gemini/antigravity/conversation_summaries.db`, `brain/<id>/.system_generated/logs/transcript_full.jsonl`,
  *   and its local `language_server` Connect-RPC service) so users with only the Desktop app
- *   get full session visibility, history, Goal Mode, image messaging, and model selection.
+ *   get full session visibility, history, Goal Mode, slash commands and skills, image messaging,
+ *   user questions/permissions, model selection, steering, fork, rename, archive and delete.
  */
 export declare class AntigravityDriver extends AcpDriver {
     private desktopMode;
     private desktopSummaryTimer?;
+    /** The state last reported to the host for each desktop conversation. */
     private readonly desktopSessionStates;
     private readonly desktopWatchers;
+    /** Conversations a device has open: their watchers outlive the turn. */
+    private readonly watchedSessions;
     private desktopModelsCache?;
     private desktopDefaultModel?;
+    private desktopRowsCache?;
+    private readonly slashCache;
+    private readonly generatorCache;
+    private archivedCache?;
+    private readonly untitledCache;
     constructor(options: {
         env?: NodeJS.ProcessEnv;
         hostVersion: string;
     });
     protected get env(): NodeJS.ProcessEnv;
+    /**
+     * The desktop app takes messages mid-turn (its message_delivery hook hands them
+     * to the running turn), forks at any reply, and its transcript is the history.
+     */
+    get behavior(): DriverBehavior;
+    private desktop;
+    private languageServer;
+    private requireConnection;
+    private isDesktopSession;
+    /** Every conversation row, read at most every two seconds however many watchers ask. */
+    private desktopRows;
+    sessionExists(nativeId: string, _cwd: string): boolean;
     authStatus(): Promise<AgentAuth>;
     protected detectVersion(): Promise<string | undefined>;
+    /**
+     * Reports conversations that started or stopped on the desktop. A running one
+     * is followed (attached), and from then on its watcher reports its turns.
+     */
+    private syncDesktopSummaries;
     protected boot(): Promise<void>;
     stop(): Promise<void>;
+    watched(nativeId: string, open: boolean): void;
     private transcriptPathFor;
     private desktopAliasesFor;
     private saveDesktopAliases;
     private isConversationRunningInDesktop;
+    private untitledTitle;
     private listDesktopSessions;
     listSessions(limit: number): Promise<DiscoveredSession[]>;
+    archivedSessions(): Promise<string[]>;
     private loadDesktopModels;
+    /**
+     * The model and command auto-run policy the desktop app last used for a
+     * conversation (or, for a new one, for the latest conversation): sending from
+     * the phone must not quietly change either.
+     */
+    private generatorInfo;
+    private fetchGeneratorInfo;
+    /** A conversation the desktop hasn't generated in yet takes the settings the user last used anywhere. */
+    private inheritedSettings;
+    private latestConversationId;
     private resolveSessionModel;
     private resolvePlanModelEnum;
+    /** The system commands and skills the desktop offers for this conversation (its workspace adds skills). */
+    private slashCommands;
     private emitDesktopConfig;
+    private emitDesktopPendingAction;
+    private clearDesktopPendingAction;
+    private pollDesktopInteractions;
+    private emitTranscriptItems;
+    /** A sub-agent's items as the parent session carries them: nested under the spawning call, with ids of their own. */
+    private nestChildItems;
+    private childTurn;
+    /**
+     * Starts following the sub-agents `items` spawned. With `collect`, what each
+     * has done so far is added there (history, or a sub-agent just seen live);
+     * without, only what it does from now on is shown.
+     */
+    private followChildren;
+    /** New work from every followed sub-agent, and when each starts or stops. */
+    private tickChildren;
+    private stopWatching;
     private startWatchingDesktopTranscript;
+    private tickWatcher;
     attach(nativeId: string, context: AttachContext): Promise<HistoryItem[]>;
     detach(nativeId: string): Promise<void>;
+    private resolveDesktopTrajectory;
+    answerQuestion(nativeId: string, requestId: string, answers: QuestionAnswer[]): Promise<void>;
+    respondPermission(nativeId: string, requestId: string, optionId: string): Promise<void>;
     createSession(options: {
         cwd: string;
         model?: string;
     }): Promise<DiscoveredSession>;
+    /** The transcript step an item of ours came from (the phone's own messages are aliased to theirs). */
+    private stepOfItem;
+    /**
+     * The step a fork ends at: the end of the turn holding `upTo` (or of the
+     * whole conversation). Antigravity forks only at a turn's last step, right
+     * before the next user message; the trajectory (not the transcript, which
+     * skips some steps) says which that is.
+     */
+    private forkStepFor;
+    fork(nativeId: string, options: ForkOptions): Promise<DiscoveredSession>;
+    rename(nativeId: string, title: string): Promise<void>;
+    archive(nativeId: string, archived: boolean): Promise<void>;
+    delete(nativeId: string): Promise<void>;
     goal(nativeId: string, change: GoalChange): Promise<SessionGoal | null>;
+    private echoDesktopMessage;
     prompt(nativeId: string, content: ContentBlock[], clientMessageId: string, context?: string): Promise<"started" | "steered" | "queued">;
+    cancelSubagent(nativeId: string, childId: string): Promise<void>;
     cancel(nativeId: string): Promise<void>;
     setConfig(nativeId: string, optionId: string, value: string): Promise<void>;
 }
+export {};