@myagentroam/agent 0.11.32 → 0.11.34

package/dist/sdk/execution-compact-extension.js

@@ -0,0 +1,46 @@
+import { compactExtensionMessages, compactExtensionResult, compactExtensionDiagnostic } from '../extensions/compaction.js';
+import { buildCompactionMessages } from '../runtime/compaction/history.js';
+/** Bounds Extension diagnostics and validates its candidate before native fallback. */
+export function createExecutionCompactExtension(ports) {
+    return async (history, reason, focus, compaction) => {
+        if (!ports.hasInterceptor())
+            return undefined;
+        const summaryTokenBudget = Math.min(10_000, ports.maxOutputTokens, Math.max(1, Math.floor(ports.contextWindowTokens / 4)));
+        let diagnosticReports = 0;
+        let acceptsDiagnostics = true;
+        try {
+            const result = await compaction.generate((signal) => ports.invoke(Object.freeze({
+                reason,
+                messages: compactExtensionMessages(history),
+                ...(focus === undefined ? {} : { focus }),
+                summaryTokenBudget,
+                getPrompt: () => buildCompactionMessages('')[1].content,
+                reportModelUsage: ports.reportUsage,
+                reportDiagnostic: async (value) => {
+                    if (!acceptsDiagnostics || ++diagnosticReports > 8)
+                        return;
+                    try {
+                        const diagnostic = compactExtensionDiagnostic(value);
+                        if (diagnostic)
+                            await compaction.observeExtension(diagnostic);
+                    }
+                    catch {
+                        /* Diagnostic failures must not change compaction or fallback. */
+                    }
+                }
+            }), signal));
+            compaction.signal.throwIfAborted();
+            const handled = compactExtensionResult(result, summaryTokenBudget);
+            await compaction.finishExtension(handled ? 'HANDLED' : result === undefined ? 'DECLINED' : 'INVALID_RESULT');
+            return handled;
+        }
+        catch {
+            await compaction.finishExtension('FAILED');
+            compaction.signal.throwIfAborted();
+            return undefined;
+        }
+        finally {
+            acceptsDiagnostics = false;
+        }
+    };
+}

package/dist/sdk/execution-compact-generation.d.ts

@@ -0,0 +1,17 @@
+import { generateCompactionCandidate } from '../runtime/compaction/generate.js';
+import type { CompactionOperation } from '../runtime/compaction/operation.js';
+import type { ModelTurnSession } from '../model/contracts.js';
+type Snapshot = Parameters<typeof generateCompactionCandidate>[0];
+type Generation = Parameters<typeof generateCompactionCandidate>[1];
+/** Borrows one independent Compact Turn and joins its operation before closing it. */
+export declare function generateExecutionCompaction(input: {
+    readonly snapshot: Snapshot;
+    createOperation(): CompactionOperation;
+    withTurn<T>(run: (turn: ModelTurnSession) => Promise<T>): Promise<T>;
+    readonly generateExtension: Generation['generateExtension'];
+    readonly transformRequest: Generation['transformRequest'];
+    readonly stream: Generation['stream'];
+    readonly observeUsage: Generation['observeUsage'];
+    readonly onAttemptDiagnostic: Generation['onAttemptDiagnostic'];
+}): Promise<import("../extensions.js").ExtensionCompactResult>;
+export {};

package/dist/sdk/execution-compact-generation.js

@@ -0,0 +1,30 @@
+import { generateCompactionCandidate } from '../runtime/compaction/generate.js';
+/** Borrows one independent Compact Turn and joins its operation before closing it. */
+export async function generateExecutionCompaction(input) {
+    const operation = input.createOperation();
+    let entered = false;
+    try {
+        return await input.withTurn(async (turn) => {
+            entered = true;
+            try {
+                return await generateCompactionCandidate(input.snapshot, {
+                    operation,
+                    turn,
+                    generateExtension: input.generateExtension,
+                    transformRequest: input.transformRequest,
+                    stream: input.stream,
+                    observeUsage: input.observeUsage,
+                    onAttemptDiagnostic: input.onAttemptDiagnostic
+                });
+            }
+            finally {
+                await operation.dispose();
+            }
+        });
+    }
+    catch (error) {
+        if (!entered)
+            await operation.dispose().catch(() => undefined);
+        throw error;
+    }
+}

package/dist/sdk/execution-compaction-flight.d.ts

@@ -0,0 +1,31 @@
+import type { CompactCoordinator } from '../runtime/compaction/coordinator.js';
+import type { ExecutionEventPayload } from './session-execution.js';
+type CompactInput = {
+    readonly focus?: string;
+    readonly async?: boolean;
+};
+/** Owns Compact flight admission, joining, cancellation and failure publication. */
+export declare function createExecutionCompactionFlight(ports: {
+    readonly coordinator: CompactCoordinator;
+    readonly executionId: string;
+    readonly manualId: string | undefined;
+    readonly mode: 'run' | 'plan' | 'compact';
+    readonly executionSignal: AbortSignal;
+    readonly compactSignal: AbortSignal;
+    currentManual(): boolean;
+    markSmartRequested(): void;
+    compact(input: CompactInput, signal: AbortSignal, prepare: () => Promise<void>, id: string): Promise<boolean>;
+    perform(input: CompactInput, run: (effective: CompactInput, call: {
+        signal: AbortSignal;
+    }) => Promise<{
+        changed: boolean;
+        executionId: string;
+    }>): Promise<{
+        changed: boolean;
+    }>;
+    emit(event: ExecutionEventPayload): Promise<void>;
+}): {
+    start: (input?: CompactInput) => import("../runtime/compaction/coordinator.js").CompactFlight;
+    wait: (input?: CompactInput) => Promise<boolean>;
+};
+export {};

package/dist/sdk/execution-compaction-flight.js

@@ -0,0 +1,50 @@
+import { randomUUID } from 'node:crypto';
+import { describeAgentError } from '../error.js';
+/** Owns Compact flight admission, joining, cancellation and failure publication. */
+export function createExecutionCompactionFlight(ports) {
+    const start = (input = {}) => {
+        const id = ports.manualId ?? randomUUID();
+        const flight = ports.coordinator.start(id, input.focus, async (prepare, signal) => {
+            const linked = AbortSignal.any([signal, ports.executionSignal, ports.compactSignal]);
+            try {
+                if (ports.mode === 'compact' && ports.currentManual())
+                    return await ports.compact(input, linked, prepare, id);
+                return (await ports.perform(input, async (effective, call) => ({
+                    changed: await ports.compact({ ...effective, async: input.async === true }, AbortSignal.any([linked, call.signal]), prepare, id),
+                    executionId: ports.executionId
+                }))).changed;
+            }
+            catch (error) {
+                const diagnostic = describeAgentError(error, 'MAR_AGENT_COMPACT_FAILED');
+                try {
+                    await ports.emit({
+                        type: 'context.compact_failed',
+                        compactionId: id,
+                        code: diagnostic.code,
+                        async: input.async === true,
+                        cancelled: linked.aborted
+                    });
+                }
+                catch {
+                    // Failure notification cannot replace the authoritative Compact error.
+                }
+                throw error;
+            }
+        });
+        ports.markSmartRequested();
+        return flight;
+    };
+    const wait = async (input = {}) => {
+        const flight = start(input);
+        if (input.async)
+            return false;
+        await ports.emit({
+            type: 'context.compacting',
+            compactionId: flight.id,
+            stage: 'WAITING',
+            async: false
+        });
+        return (await ports.coordinator.checkpoint(true)) ?? false;
+    };
+    return { start, wait };
+}

package/dist/sdk/execution-compaction.d.ts

@@ -0,0 +1,47 @@
+import { splitContextualPrompt } from '../runtime/context/contextual-blocks.js';
+import type { SessionModelMessage } from '../session/model-request.js';
+import type { SessionRecord } from '../session/record-contract.js';
+import type { SessionStore } from '../session/store/contracts.js';
+import type { ClientToolDefinition } from '../tools/contracts.js';
+import type { EnvironmentContextState } from '../prompts/core.js';
+import type { CompactCoordinator } from '../runtime/compaction/coordinator.js';
+import type { ResolvedModelConfiguration } from './model-runtime.js';
+import type { ExecutionEventPayload } from './session-execution.js';
+import type { ResourceInputProjection } from './resource-input.js';
+import type { createExecutionModelContext } from './execution-model-context.js';
+import type { generateExecutionCompaction } from './execution-compact-generation.js';
+type Snapshot = Parameters<typeof generateExecutionCompaction>[0]['snapshot'];
+/** Snapshots one Compact prefix, generates a candidate and adopts only its committed checkpoint. */
+export declare function createExecutionCompaction(ports: {
+    readonly mode: 'run' | 'plan' | 'compact';
+    readonly sessionId: string;
+    readonly executionId: string;
+    readonly turnId: string;
+    readonly model: Pick<ResolvedModelConfiguration, 'id' | 'contextWindowTokens'>;
+    readonly messages: SessionModelMessage[];
+    readonly pendingInputs: Map<string, SessionRecord>;
+    readonly messageSources: WeakMap<SessionModelMessage, SessionRecord>;
+    readonly modelContext: Pick<ReturnType<typeof createExecutionModelContext>, 'worldState' | 'compactInputs' | 'replaceCompactMessages' | 'adoptCompactCheckpoint'>;
+    readonly resourceInput: Pick<ResourceInputProjection, 'checkpoint'>;
+    readonly store: Pick<SessionStore, 'compact'>;
+    readonly coordinator: Pick<CompactCoordinator, 'waiting'>;
+    readonly userTokenLimit: number;
+    boundary(): number;
+    updateBoundary(value: number): void;
+    snapshotTools(): readonly ClientToolDefinition[];
+    usage(): Snapshot['latestUsage'];
+    effort(): Snapshot['reasoningEffort'];
+    environment(): EnvironmentContextState;
+    compose(tools: readonly ClientToolDefinition[]): Promise<Parameters<typeof splitContextualPrompt>[0]>;
+    generate(snapshot: Snapshot, compactionId: string, signal: AbortSignal): ReturnType<typeof generateExecutionCompaction>;
+    retainedResources(): Promise<string | undefined>;
+    withProjection<T>(action: () => Promise<T>): Promise<T>;
+    recordCommit(recordId: string): void;
+    invalidateContext(error: unknown): void;
+    invalidateUsage(): void;
+    emit(event: ExecutionEventPayload): Promise<void>;
+}): (input: {
+    readonly focus?: string;
+    readonly async?: boolean;
+}, signal: AbortSignal, prepare: () => Promise<void>, compactionId: string) => Promise<boolean>;
+export {};

package/dist/sdk/execution-compaction.js

@@ -0,0 +1,121 @@
+import { splitContextualPrompt } from '../runtime/context/contextual-blocks.js';
+import { compactSnapshotAnchor } from '../runtime/compaction/retained-context.js';
+import { buildCompactedHistory } from '../runtime/compaction/history.js';
+import { commitExecutionCompaction } from './execution-compact-commit.js';
+/** Snapshots one Compact prefix, generates a candidate and adopts only its committed checkpoint. */
+export function createExecutionCompaction(ports) {
+    return async (input, signal, prepare, compactionId) => {
+        const { messages, modelContext } = ports;
+        if (messages.length < 2)
+            return false;
+        const cutoff = Math.min(ports.boundary(), messages.length);
+        const current = messages[cutoff - 1];
+        const retainCurrent = ports.mode !== 'compact' && current.role === 'user' && current.contextKind === undefined;
+        const prefix = messages.slice(0, cutoff - (retainCurrent ? 1 : 0));
+        if (!prefix.some((message) => message.role !== 'user' ||
+            message.contextKind === undefined ||
+            message.contextKind === 'summary'))
+            return false;
+        const history = structuredClone(prefix).map(({ images: _images, ...message }) => message);
+        const prefixInputs = modelContext.compactInputs(prefix);
+        const tools = structuredClone(ports.snapshotTools());
+        const generation = modelContext.worldState.generation;
+        const usage = ports.usage();
+        const effort = ports.effort();
+        const anchorRecordId = prefix
+            .map((message) => ports.messageSources.get(message)?.recordId ?? message.metadata?.recordId)
+            .findLast((id) => id !== undefined);
+        const visibleAnchor = compactSnapshotAnchor(prefix, ports.messageSources);
+        const anchor = {
+            ...(anchorRecordId ? { anchorRecordId } : {}),
+            ...(visibleAnchor ? { anchor: visibleAnchor } : {})
+        };
+        const composition = splitContextualPrompt(await ports.compose(tools));
+        await ports.emit({
+            type: 'context.compacting',
+            compactionId,
+            async: input.async === true,
+            stage: 'GENERATING',
+            ...anchor
+        });
+        const candidate = await ports.generate({
+            history,
+            system: composition.system,
+            ...(composition.systemBlocks === undefined
+                ? {}
+                : { systemBlocks: composition.systemBlocks }),
+            tools,
+            contextWindowTokens: ports.model.contextWindowTokens,
+            latestUsage: usage,
+            reasoningEffort: effort,
+            ...(input.focus === undefined ? {} : { focus: input.focus }),
+            reason: ports.mode === 'compact' ? 'manual' : 'automatic',
+            promptCacheKey: ports.sessionId
+        }, compactionId, signal);
+        await ports.emit({
+            type: 'context.compacting',
+            compactionId,
+            async: !ports.coordinator.waiting && input.async === true,
+            stage: ports.coordinator.waiting ? 'WAITING' : 'READY',
+            ...anchor
+        });
+        await prepare();
+        signal.throwIfAborted();
+        const resources = await ports.retainedResources();
+        const replacementHistory = buildCompactedHistory(candidate.summary, prefixInputs, ports.userTokenLimit);
+        let committed = false;
+        let retained;
+        try {
+            const result = await commitExecutionCompaction({
+                store: ports.store,
+                sessionId: ports.sessionId,
+                signal,
+                prefix,
+                messages,
+                generation,
+                messageSources: ports.messageSources,
+                checkpoint: (value) => ports.resourceInput.checkpoint(value),
+                withProjection: ports.withProjection,
+                currentGeneration: () => modelContext.worldState.generation,
+                recordCommit: (recordId) => {
+                    committed = true;
+                    ports.recordCommit(recordId);
+                },
+                replace: (value) => {
+                    modelContext.replaceCompactMessages(replacementHistory, value);
+                    ports.updateBoundary(messages.length - value.length);
+                },
+                draft: () => ({
+                    summary: candidate.summary,
+                    replacementHistory,
+                    pendingInputs: [...ports.pendingInputs.values()],
+                    snapshotMessageCount: prefix.length,
+                    ...(anchorRecordId ? { snapshotRecordId: anchorRecordId } : {}),
+                    automatic: ports.mode !== 'compact',
+                    environment: ports.environment(),
+                    modelId: ports.model.id,
+                    contextWindowTokens: ports.model.contextWindowTokens,
+                    ...(candidate.usage === undefined ? {} : { usage: candidate.usage }),
+                    executionId: ports.executionId,
+                    turnId: ports.turnId
+                })
+            });
+            retained = result.retained;
+            await modelContext.adoptCompactCheckpoint(result.record.recordId, replacementHistory, retained, resources);
+            ports.invalidateUsage();
+        }
+        catch (error) {
+            if (committed)
+                ports.invalidateContext(error);
+            throw error;
+        }
+        await ports.emit({
+            type: 'context.compacted',
+            compactionId,
+            async: input.async === true,
+            retainedContext: retained.length > 0,
+            ...anchor
+        });
+        return true;
+    };
+}

package/dist/sdk/execution-context-coordinator.d.ts

@@ -0,0 +1,56 @@
+import type { ContextGcRuntime, ContextGcRuntimeInput } from '../runtime/context/gc-runtime.js';
+import type { SessionModelMessage } from '../session/model-request.js';
+import type { PreparedExecutionRound } from '../runtime/execution.js';
+import type { RoundToolScope } from '../tools/execution.js';
+import type { CompactCoordinator, CompactFlight } from '../runtime/compaction/coordinator.js';
+import type { CompactRequests } from '../runtime/compaction/requests.js';
+import type { SessionExecution } from './session-execution.js';
+import type { ExecutionModelLifecycle } from './execution-model-lifecycle.js';
+import type { createExecutionModelContext } from './execution-model-context.js';
+import type { ResourceInputProjection } from './resource-input.js';
+/** Coordinates safe-point adoption of Compact and GC without owning Session state. */
+export declare class ExecutionContextCoordinator {
+    #private;
+    private readonly ports;
+    constructor(ports: {
+        readonly initialBoundary: number;
+        readonly messages: SessionModelMessage[];
+        readonly resources: Pick<ResourceInputProjection, 'hasPendingImages' | 'gcCandidate' | 'historyView'>;
+        readonly execution: Pick<SessionExecution, 'appendBoundary' | 'assertContextValid'>;
+        readonly model: Pick<ExecutionModelLifecycle, 'tokens'>;
+        readonly context: Pick<ReturnType<typeof createExecutionModelContext>, 'syncMcpWorldState' | 'recordEnvironment' | 'adoptGcCheckpoint'>;
+        readonly compact: Pick<CompactCoordinator, 'pending' | 'checkpoint'>;
+        readonly requests: Pick<CompactRequests, 'drain'>;
+        readonly signal: AbortSignal;
+        readonly window: number;
+        readonly gc: Pick<ContextGcRuntime, 'run'>;
+        readonly gcBase: Omit<ContextGcRuntimeInput, 'system' | 'tools' | 'usage' | 'inlineMedia' | 'mediaView' | 'getActiveProcessIds'>;
+        readonly child: boolean;
+        start(input?: {
+            focus?: string;
+            async?: boolean;
+        }): CompactFlight;
+        wait(input?: {
+            focus?: string;
+            async?: boolean;
+        }): Promise<boolean>;
+        activeProcesses(): Promise<ReadonlySet<string>>;
+    });
+    get boundary(): number;
+    setBoundary(value: number): void;
+    advanceBoundary(): void;
+    drainRequests(): boolean;
+    prepareInputs(ports: {
+        includeSubagentUpdates: boolean;
+        appendMailbox(): Promise<unknown>;
+        appendSubagentUpdates(): Promise<void>;
+        refreshTools(): void;
+        updateEnvironment(): void;
+    }): Promise<void>;
+    ensureBudget(): Promise<void>;
+    checkpoint(round: PreparedExecutionRound<RoundToolScope>, usage: ContextGcRuntimeInput['usage'] | undefined): Promise<void>;
+    gc(round: {
+        readonly request: Pick<PreparedExecutionRound<RoundToolScope>['request'], 'system'>;
+        readonly toolScope: Pick<RoundToolScope, 'tools'>;
+    }, usage: ContextGcRuntimeInput['usage'] | undefined, media: ContextGcRuntimeInput['inlineMedia'], includeProcesses?: boolean): Promise<boolean>;
+}

package/dist/sdk/execution-context-coordinator.js

@@ -0,0 +1,102 @@
+import { AgentError } from '../error.js';
+import { AGENT_EXECUTION_POLICY } from '../runtime/execution-policy.js';
+/** Coordinates safe-point adoption of Compact and GC without owning Session state. */
+export class ExecutionContextCoordinator {
+    ports;
+    #boundary;
+    constructor(ports) {
+        this.ports = ports;
+        this.#boundary = ports.initialBoundary;
+    }
+    get boundary() {
+        return this.#boundary;
+    }
+    setBoundary(value) {
+        this.#boundary = value;
+    }
+    advanceBoundary() {
+        if (!this.ports.resources.hasPendingImages(this.ports.messages.slice(this.#boundary)))
+            this.#boundary = this.ports.messages.length;
+    }
+    drainRequests() {
+        return this.ports.requests.drain((input) => this.ports.start({
+            ...(input.prompt === undefined ? {} : { focus: input.prompt }),
+            async: input.async === true
+        }));
+    }
+    async prepareInputs(ports) {
+        await ports.appendMailbox();
+        if (ports.includeSubagentUpdates)
+            await ports.appendSubagentUpdates();
+        ports.refreshTools();
+        await this.ports.context.syncMcpWorldState(this.ports.messages.length);
+        this.advanceBoundary();
+        if (this.drainRequests())
+            await this.ports.compact.checkpoint(true);
+        await this.ensureBudget();
+        await this.ports.context.syncMcpWorldState(this.ports.messages.length);
+        ports.updateEnvironment();
+        await this.ports.context.recordEnvironment();
+    }
+    async ensureBudget() {
+        const { model, compact, window, signal, execution } = this.ports;
+        const percent = model.tokens === undefined ? undefined : (model.tokens * 100) / window;
+        if (percent !== undefined && percent >= AGENT_EXECUTION_POLICY.automaticCompactionPercent) {
+            const hadPending = compact.pending;
+            let compacted;
+            try {
+                compacted = await this.ports.wait();
+            }
+            catch (error) {
+                signal.throwIfAborted();
+                execution.assertContextValid();
+                if (!hadPending)
+                    throw error;
+                this.advanceBoundary();
+                compacted = await this.ports.wait();
+            }
+            if (!compacted)
+                throw new AgentError('MAR_AGENT_CONTEXT_LIMIT', 'Provider usage reached the compaction threshold but no history can be compacted.');
+        }
+        else {
+            const adopted = await compact.checkpoint(false).catch(() => {
+                signal.throwIfAborted();
+                execution.assertContextValid();
+            });
+            if (!adopted &&
+                percent !== undefined &&
+                percent >= AGENT_EXECUTION_POLICY.backgroundCompactionPercent &&
+                !compact.pending)
+                this.ports.start({ async: true });
+        }
+    }
+    async checkpoint(round, usage) {
+        this.advanceBoundary();
+        const blocking = this.drainRequests();
+        if (blocking)
+            await this.ports.compact.checkpoint(true);
+        else
+            await this.ports.compact.checkpoint(false).catch(() => {
+                this.ports.signal.throwIfAborted();
+                this.ports.execution.assertContextValid();
+            });
+        if (!this.ports.compact.pending && !this.ports.child)
+            await this.gc(round, usage, await this.ports.resources.gcCandidate(), true);
+    }
+    async gc(round, usage, media, includeProcesses = false) {
+        const appendBoundary = this.ports.execution.appendBoundary;
+        const committed = await this.ports.gc.run({
+            ...this.ports.gcBase,
+            inlineMedia: media,
+            mediaView: (messages) => this.ports.resources.historyView(messages),
+            system: round.request.system,
+            tools: round.toolScope.tools,
+            usage: usage ?? {},
+            ...(includeProcesses ? { getActiveProcessIds: () => this.ports.activeProcesses() } : {})
+        });
+        if (!committed)
+            return false;
+        await this.ports.context.adoptGcCheckpoint(committed, appendBoundary);
+        return true;
+    }
+}

package/dist/sdk/execution-input.d.ts

@@ -0,0 +1,58 @@
+import type { SessionStore } from '../session/store/contracts.js';
+import type { SessionRecord } from '../session/record-contract.js';
+import type { SessionModelMessage as ModelMessage } from '../session/model-request.js';
+import { SessionInputCoordinator, type SessionInputEntry, type ExtensionSessionRequest, type ExtensionSessionActionResult } from '../extensions/session-input.js';
+import type { ExtensionPromptInput, ExtensionPromptResult } from '../extensions/prompt-input.js';
+import type { ExtensionOperationContext } from '../extensions/operation.js';
+import type { ResolvedModelConfiguration } from './model-runtime.js';
+import type { SmartCompactionInput } from '../runtime/compaction/smart.js';
+import type { CompactFlight } from '../runtime/compaction/coordinator.js';
+import { type ResourcePublisher } from '../runtime/resource-publication.js';
+import type { createExecutionModelContext } from './execution-model-context.js';
+import type { InternalExecutionOptions } from './session-execution.js';
+import type { RunInput } from './types.js';
+import type { SubagentSessionController } from '../subagent/session-controller.js';
+/** Owns committed input, mailbox admission and live projection for one Execution. */
+export declare function createExecutionInput(input: {
+    host: ResourcePublisher;
+    store: Pick<SessionStore, 'append' | 'persistInputImages' | 'readInputImages' | 'persistResource' | 'setResourceUrl'>;
+    sessionId: string;
+    executionId: string;
+    turnId: string;
+    mode: 'run' | 'plan' | 'compact';
+    source: 'user' | 'subagent';
+    controller: AbortController;
+    inputs: Pick<SessionInputCoordinator, 'drain' | 'boundarySize'>;
+    messages: ModelMessage[];
+    pendingInputs: Map<string, SessionRecord>;
+    messageSources: WeakMap<ModelMessage, SessionRecord>;
+    modelContext: Pick<ReturnType<typeof createExecutionModelContext>, 'recordEnvironment' | 'rememberInput'>;
+    model(): Pick<ResolvedModelConfiguration, 'inputCapabilities' | 'contextWindowTokens'>;
+    tokens(): number | undefined;
+    setSmartInput(value: SmartCompactionInput): void;
+    withRecordProjection<T>(action: () => Promise<T>): Promise<T>;
+    appendExtensionMessage(entry: SessionInputEntry, request: Extract<ExtensionSessionRequest, {
+        kind: 'append';
+    }>, call: ExtensionOperationContext): Promise<ExtensionSessionActionResult>;
+    startCompact(): (input?: {
+        focus?: string;
+        async?: boolean;
+    }) => CompactFlight;
+    compactContext(): (input?: {
+        focus?: string;
+        async?: boolean;
+    }) => Promise<boolean>;
+}): {
+    startInitialInput: (ports: {
+        input: RunInput;
+        internal: InternalExecutionOptions;
+        restoredImages: boolean;
+        operation<T>(action: (call: ExtensionOperationContext) => T): T;
+        admit(content: ExtensionPromptInput, call: ExtensionOperationContext, write: (content: ExtensionPromptInput, call: ExtensionOperationContext) => Promise<ExtensionPromptResult>): Promise<unknown>;
+        enqueue(content: ExtensionPromptInput, call: ExtensionOperationContext): Promise<unknown>;
+        project(actual: ExtensionPromptInput, metadata: NonNullable<ModelMessage["metadata"]>): void;
+    }) => Promise<boolean>;
+    receiveSteer: (content: ExtensionPromptInput, clientMessageId: string, call: ExtensionOperationContext) => Promise<SessionRecord>;
+    appendSubagentUpdates: (subagents: Pick<SubagentSessionController, "collectModelUpdates"> | undefined) => Promise<void>;
+    appendMailboxMessages: (restoring?: boolean) => Promise<boolean>;
+};