@ours.network/fleet 1.2.0-nightly.7 → 1.2.0-nightly.71

package/dist/session/acp.d.ts

@@ -1,8 +1,11 @@
+import type { FileDeliveryInput, CopyChatFile, DeliveredFile } from '../file-delivery/types.js';
+import { type TaskNoticeBinding, type TaskCreatedNotice } from './task-notice.js';
 import * as acp from '@agentclientprotocol/sdk';
 import type { CommonPermissions } from '../config.js';
 import type { AcpMcpServer } from '../harness/types.js';
 import { ConversationEventStore } from './conversation-store.js';
-import type { ConversationSnapshot, PromptOrigin, PromptReceipt, SubmitPromptCommand } from './conversation-types.js';
+import type { ConversationObservationState, ConversationSnapshot, PromptOrigin, PromptReceipt, SubmitPromptCommand } from './conversation-types.js';
+import { type PendingPrompt } from './prompt-batch.js';
 import type { ConversationHandlePage, ExitRecord, InterruptOutcome, QueuedPrompt, SessionEvent, AgentSession, RuntimeSelectorMetadata, SessionSnapshot, SubmitPromptOptions, TurnCancellationSource, TurnOutcome, TurnResult } from './types.js';
 /** Bound safe-boundary waiting without turning a hung tool into cancellation. */
 export declare const AFTER_TOOL_BOUNDARY_TIMEOUT_MS = 120000;
@@ -25,6 +28,17 @@ export declare const STEERING_OCCUPANCY_IDLE_MS = 150000;
 export declare const CODEX_DISABLE_INHERITED_MCP_ENV = "OURS_FLEET_CODEX_DISABLE_INHERITED_MCP";
 /** Server-generated typed provenance followed by the exact human-authored body. */
 export declare function promptContentBlocks(text: string, origin?: PromptOrigin): acp.ContentBlock[];
+/**
+ * One adapter turn that carries several admitted prompts.
+ *
+ * A single prompt's provenance block describes "the accompanying text", which
+ * is only unambiguous when there is one text. Here every member is one text
+ * block, unchanged, immediately preceded by its own server-generated block
+ * that names its route and binds its exact bytes — so a monitor wake next to
+ * an owner prompt is never read under the owner's authority, and text that
+ * imitates a marker stays text: it cannot produce a typed block.
+ */
+export declare function batchContentBlocks(members: ReadonlyArray<Pick<PendingPrompt, 'text' | 'origin'>>): acp.ContentBlock[];
 export declare function runtimeSelector(options: acp.SessionConfigOption[] | null | undefined, category: string): RuntimeSelectorMetadata | undefined;
 /** Fresh ACP response including the legacy model report still used by some adapters. */
 export type AcpStartupSessionResponse = acp.NewSessionResponse & {
@@ -49,6 +63,12 @@ export interface AcpSessionOptions {
     inheritEnvironment?: boolean;
     stateDir: string;
     mode: 'fresh' | 'resume';
+    requireResume?: boolean;
+    /**
+     * Hold never-started prompts recovered from a prior generation until the
+     * caller's control plane is listening; see activateRecoveredPrompts().
+     */
+    deferRecoveredPrompts?: boolean;
     permissions: CommonPermissions;
     /** Native permission-mode id to request via session/set_mode; undefined keeps the agent default. */
     modeId?: string;
@@ -136,7 +156,16 @@ export declare class AcpSession implements AgentSession {
     private lastUpdateAt?;
     private lastError?;
     private promptTail;
+    /** Admitted prompts not yet handed to the adapter, in admission order. */
+    private readonly pendingPrompts;
+    /** Admitted prompt → the adapter turn that carries it, while that turn is open. */
+    private readonly sharedTurns;
+    /** Commands the adapter currently advertises; only these are control operations. */
+    private advertisedCommands;
+    private presentedCommands;
     private queueDepth;
+    private readonly deferredRecovered;
+    private readonly observation;
     private exit;
     private steeringSupported;
     private agentCapabilities?;
@@ -175,6 +204,7 @@ export declare class AcpSession implements AgentSession {
     private stallTimer?;
     private stallAttempt?;
     private readonly toolBoundaryWaiters;
+    private fileExportBusy;
     private activeTurn?;
     private constructor();
     static start(options: AcpSessionOptions): Promise<AcpSession>;
@@ -185,6 +215,14 @@ export declare class AcpSession implements AgentSession {
      * never silently replayed.
      */
     private recoverOpenPrompts;
+    /**
+     * Dispatch recovered prompts held by deferRecoveredPrompts. A recovered turn
+     * can run tools at once, including the managed Fleet CLI, so it must not
+     * start before the supervisor's control socket accepts connections. Prompts
+     * never activated stay admitted-unstarted and recover again on next start.
+     */
+    activateRecoveredPrompts(): void;
+    private dispatchRecovered;
     isAlive(): boolean;
     /**
      * Take the occupancy lease for a turn the adapter started on its own behalf.
@@ -232,6 +270,22 @@ export declare class AcpSession implements AgentSession {
      * for it is what turned a busy agent into a timeout and then into "dead".
      */
     queuePrompt(text: string, options?: SubmitPromptOptions): Promise<QueuedPrompt>;
+    /** The turn whose events and result answer this admitted prompt; itself unless a release shared it. */
+    sharedTurnId(promptId: string): string | undefined;
+    /**
+     * Queue an admitted prompt behind the current work. Each prompt keeps its
+     * own step in the chain, so its place in line is unchanged; what the step
+     * does when it is reached is release a whole snapshot, not one prompt.
+     */
+    private enqueue;
+    /**
+     * The turn boundary. The first waiting prompt to get here takes every
+     * pending prompt delivered with it, synchronously, and they share one adapter
+     * turn. A prompt admitted after that — while the turn runs, or while a
+     * cancellation settles — stays pending for the next boundary. A step whose
+     * prompt an earlier boundary already took just reports that turn's result.
+     */
+    private release;
     /**
      * Prepare the session for a prompt that asked to pre-empt current work.
      *
@@ -271,6 +325,8 @@ export declare class AcpSession implements AgentSession {
      * (`queuePrompt({ interrupt: true })`) needs the typed error, because only it
      * still owes an undelivered message a replay.
      */
+    readonly liveVoiceSupported = true;
+    interruptPrompt(generation: string, promptId: string): Promise<InterruptOutcome>;
     interrupt(source?: TurnCancellationSource): Promise<InterruptOutcome>;
     private cancelActive;
     /**
@@ -300,6 +356,8 @@ export declare class AcpSession implements AgentSession {
      */
     private settlePendingAutomatically;
     exitResult(): ExitRecord | null;
+    /** One attempt, tied to the managed live turn captured before any approval/read. */
+    sendFileToChat(input: FileDeliveryInput, signal: AbortSignal, copy: CopyChatFile, policy: CommonPermissions): Promise<DeliveredFile>;
     close(): Promise<void>;
     /** ACP requires the field. Bundled agents treat [] as no client-added servers. */
     private declaredMcpServers;
@@ -311,6 +369,11 @@ export declare class AcpSession implements AgentSession {
     private recoverStall;
     /** Keep the original queue slot (including startup) until recovery finishes. */
     private runPrompt;
+    /**
+     * One adapter turn. `members` are the admitted prompts it carries, the first
+     * being the turn's own id; each keeps its own started and completed records
+     * so none is left open and none is reported delivered that was not sent.
+     */
     private runSinglePrompt;
     private steerPrompt;
     private requestPermission;
@@ -338,12 +401,22 @@ export declare class AcpSession implements AgentSession {
      * signal. Never infer commentary from text, message order, or unknown meta.
      */
     private codexMessagePhase;
-    /** Normalize every ACP update losslessly into the durable ledger. */
+    /**
+     * Normalize every ACP update losslessly into the durable ledger. The ledger is the conversation the
+     * owner reads, so the agent's commentary between its tools is kept as written, like its final answer.
+     */
     private recordConversationUpdate;
+    taskNoticeBinding(): TaskNoticeBinding | undefined;
+    recordTaskCreated(binding: TaskNoticeBinding, notice: TaskCreatedNotice): void;
     conversationPage(request?: {
         after?: string;
         limit?: number;
     }): ConversationHandlePage;
+    subscribeConversationFailure(listener: (generation: string) => void): () => void;
+    conversationReplayAvailable(expectedGeneration: string): boolean;
+    replayConversation(request: import('./conversation-replay.js').ConversationReplayRequest): AsyncGenerator<import("./conversation-replay.js").ConversationReplayPage, any, any>;
+    observeConversation(listener: (state: ConversationObservationState) => void): import("./conversation-types.js").ConversationObservation;
+    private captureObservation;
     conversationSnapshot(): ConversationSnapshot;
     subscribeConversation(listener: Parameters<ConversationEventStore['subscribe']>[0]): () => void;
     private isCurrentConversationEvent;