@myagentroam/agent 0.11.33 → 0.11.35

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

@@ -0,0 +1,163 @@
+import type { ExtensionInputSource } from '../extensions/session-input.js';
+import type { SubagentMailboxMessage } from '../subagent/session-controller.js';
+import { AsyncQueue } from '../runtime/async-queue.js';
+import { ExecutionLoop } from '../runtime/execution.js';
+import type { RoundToolScope } from '../tools/execution.js';
+import { CompactCoordinator } from '../runtime/compaction/coordinator.js';
+import { CompactRequests } from '../runtime/compaction/requests.js';
+import type { ExecutionMode, ExecutionResult, AgentEvent } from './types.js';
+import type { ModelAdapter, ModelTurnSession } from '../model/contracts.js';
+import type { SubagentMessageDelivery } from '../subagent/session-controller.js';
+import type { SessionModelMessage } from '../session/model-request.js';
+import type { ExecutionToolSources } from './extension-tools.js';
+import type { ExecutionHandle } from './types.js';
+import { createExecutionModelResources, type ResolvedModelConfiguration } from './model-runtime.js';
+export interface InternalExecutionOptions {
+    readonly publishHostEvents?: boolean;
+    readonly signal?: AbortSignal;
+    readonly inputSource?: 'parent_agent' | 'extension';
+    readonly extensionSource?: ExtensionInputSource;
+    readonly automaticInput?: boolean;
+    readonly inputCommitted?: (recordId: string) => void;
+    readonly promptAdmitted?: boolean;
+    readonly modelText?: string;
+    readonly inputContext?: readonly string[];
+    readonly modelContext?: readonly string[];
+    readonly initialMailbox?: readonly SubagentMailboxMessage[];
+    readonly turnId?: string;
+    readonly delivery?: SubagentMessageDelivery;
+    readonly mcpExecutionScopeId?: string;
+}
+export interface InternalExecutionHandle extends ExecutionHandle {
+    readonly persistedEvents: boolean;
+    readonly turnId: string;
+    enqueueMessage(message: string, delivery?: SubagentMessageDelivery): boolean;
+}
+export interface SessionExecutionContext {
+    readonly executionId: string;
+    readonly modelId: string;
+    readonly mode: ExecutionMode;
+    readonly models: ReadonlyMap<string, ResolvedModelConfiguration>;
+    readonly instruction: string | undefined;
+    readonly steer?: ((input: import('./types.js').SteerInput) => Promise<import('./types.js').SteerResult>) | undefined;
+    readonly compactRequests?: CompactRequests | undefined;
+    readonly requestMessages?: {
+        read(): readonly SessionModelMessage[];
+    } | undefined;
+    readonly appendedMessages?: {
+        append(recordId: string, message: SessionModelMessage): void;
+    } | undefined;
+    readonly toolSources?: ExecutionToolSources | undefined;
+}
+export type ExecutionEventPayload<T = AgentEvent> = T extends AgentEvent ? Omit<T, 'eventId' | 'sequence' | 'timestamp' | 'sessionId' | 'executionId' | 'turnId'> : never;
+export interface ExecutionEventPorts {
+    persist(event: AgentEvent, payload: AgentEvent): Promise<void>;
+    publish?(event: AgentEvent): void | Promise<void>;
+    hasRetainedLease?(): boolean;
+}
+interface ExecutionFinalization {
+    readonly failed: boolean;
+    readonly reason: unknown;
+    releaseImageBytes(): void;
+    revokeBindings(): void;
+    closeToolSources(): void;
+    detachAbort(): void;
+    endParent(): void;
+    deactivate(): void;
+}
+/** Resources and settlement of one Execution, independent of its Session identity. */
+export declare class SessionExecution {
+    #private;
+    readonly sessionId: string;
+    readonly executionId: string;
+    readonly turnId: string;
+    readonly kind: ExecutionMode | 'compact';
+    readonly source: 'user' | 'subagent';
+    readonly snapshot: {
+        readonly modelId: string;
+        readonly mode: ExecutionMode;
+        readonly models: ReadonlyMap<string, ResolvedModelConfiguration>;
+        readonly generation: number;
+        readonly instruction: string | undefined;
+    };
+    bindViews(views: Partial<Pick<SessionExecutionContext, 'requestMessages' | 'appendedMessages' | 'toolSources'>>): void;
+    acceptSteer(steer: NonNullable<SessionExecutionContext['steer']>): void;
+    stopSteer(): void;
+    retireCompactRequests(reason: unknown): void;
+    revokeViews(reason: unknown): void;
+    detachToolSources(): void;
+    invalidateContext(error: unknown): void;
+    assertContextValid(): void;
+    readonly controller: AbortController;
+    readonly events: AsyncQueue<AgentEvent>;
+    readonly compact: CompactCoordinator;
+    readonly compactRequests: CompactRequests;
+    readonly context: SessionExecutionContext;
+    private resultPromise;
+    private readonly modelResources;
+    private eventTail;
+    private terminalAdmitted;
+    private releaseLease;
+    private eventSequence;
+    private persistedTerminal;
+    private completionAdmitted;
+    private appendedMessages;
+    private messageTarget;
+    private mainLoop;
+    constructor(sessionId: string, executionId: string, turnId: string, kind: ExecutionMode | 'compact', source: 'user' | 'subagent', snapshot: {
+        readonly modelId: string;
+        readonly mode: ExecutionMode;
+        readonly models: ReadonlyMap<string, ResolvedModelConfiguration>;
+        readonly generation: number;
+        readonly instruction: string | undefined;
+    }, activeAdapters: Parameters<typeof createExecutionModelResources>[0]);
+    openMainTurn(adapter: ModelAdapter, ownsAdapter: boolean): ModelTurnSession;
+    runMainLoop(options: ConstructorParameters<typeof ExecutionLoop<RoundToolScope>>[0]): Promise<{
+        finalAnswer: string;
+        usage?: import("../model/usage.js").ModelUsage;
+    }>;
+    prepare(input: {
+        acquireLease(): Promise<Parameters<SessionExecution['adoptLease']>[0]>;
+        waitForInputs(): Promise<void>;
+        bindCommittedInputs(): void;
+        refreshAdapters(): Promise<void>;
+    }): Promise<void>;
+    get finalAnswer(): string | undefined;
+    withCompactTurn<T>(adapter: ModelAdapter, run: (turn: ModelTurnSession) => Promise<T>): Promise<T>;
+    closeModelTurns(reason: unknown): Promise<void>;
+    appendCommittedMessage(recordId: string, message: SessionModelMessage): void;
+    connectMessageProjection(messages: SessionModelMessage[], restoredIds: ReadonlySet<string>): void;
+    clearAppendedMessages(): void;
+    get appendBoundary(): number;
+    appendedAfter(boundary: number, restoredIds: ReadonlySet<string>): SessionModelMessage[];
+    orderEvent<T>(action: () => Promise<T>, advance?: boolean): Promise<T>;
+    emit(event: ExecutionEventPayload, ports: ExecutionEventPorts, assertLive?: () => void): Promise<void>;
+    adoptLease(release: () => Promise<void>): void;
+    get hasLease(): boolean;
+    releaseSessionLease(): Promise<void>;
+    finish(input: ExecutionFinalization): Promise<void>;
+    start(input: {
+        readonly scope: (run: () => Promise<ExecutionResult>) => Promise<ExecutionResult>;
+        readonly prepareProgram: () => Promise<{
+            readonly inputHandled: true;
+        } | {
+            run(focus?: string, signal?: AbortSignal): Promise<void>;
+            performManualCompact(run: (focus: string | undefined, signal: AbortSignal) => Promise<void>): Promise<unknown>;
+            finalAnswer(): string;
+            permissionStop(): ExecutionResult['permissionStop'];
+        }>;
+        readonly beforeFailure: (error: unknown) => Promise<void>;
+        readonly diagnostic: (error: unknown) => {
+            code: string;
+            message: string;
+        };
+        readonly emit: (event: ExecutionEventPayload) => Promise<void>;
+        readonly endParent: () => void;
+        readonly finalize: (failed: boolean) => Promise<void>;
+        readonly settle: (status: ExecutionResult['status']) => void;
+    }): void;
+    join(): Promise<ExecutionResult> | undefined;
+    handle(enqueueMessage: (message: string, delivery?: SubagentMessageDelivery) => boolean): InternalExecutionHandle;
+    cancel(reason?: unknown): void;
+}
+export {};

package/dist/sdk/session-execution.js

@@ -0,0 +1,388 @@
+import { AsyncQueue } from '../runtime/async-queue.js';
+import { randomUUID } from 'node:crypto';
+import { eventForPersistence } from '../runtime/event-projection.js';
+import { ExecutionLoop } from '../runtime/execution.js';
+import { CompactCoordinator } from '../runtime/compaction/coordinator.js';
+import { CompactRequests } from '../runtime/compaction/requests.js';
+import { DEFAULT_COMPACTION_FOCUS } from '../runtime/compaction/history.js';
+import { AgentError } from '../error.js';
+import { createExecutionModelResources, createModelTurnSession } from './model-runtime.js';
+/** Resources and settlement of one Execution, independent of its Session identity. */
+export class SessionExecution {
+    sessionId;
+    executionId;
+    turnId;
+    kind;
+    source;
+    snapshot;
+    #contextInvalid = false;
+    #contextFailure;
+    #bindings;
+    bindViews(views) {
+        Object.assign(this.#bindings, views);
+    }
+    acceptSteer(steer) {
+        this.#bindings = { ...this.#bindings, steer };
+    }
+    stopSteer() {
+        delete this.#bindings.steer;
+    }
+    retireCompactRequests(reason) {
+        this.compactRequests.close(reason);
+        delete this.#bindings.compactRequests;
+    }
+    revokeViews(reason) {
+        delete this.#bindings.requestMessages;
+        this.retireCompactRequests(reason);
+        delete this.#bindings.appendedMessages;
+        delete this.#bindings.steer;
+    }
+    detachToolSources() {
+        delete this.#bindings.toolSources;
+    }
+    invalidateContext(error) {
+        if (this.#contextInvalid)
+            return;
+        this.#contextInvalid = true;
+        this.#contextFailure = error;
+    }
+    assertContextValid() {
+        if (this.#contextInvalid)
+            throw this.#contextFailure;
+    }
+    controller = new AbortController();
+    events = new AsyncQueue();
+    compact = new CompactCoordinator();
+    compactRequests;
+    context;
+    resultPromise;
+    modelResources;
+    eventTail = Promise.resolve();
+    terminalAdmitted = false;
+    releaseLease;
+    eventSequence = 0;
+    persistedTerminal = false;
+    completionAdmitted = false;
+    appendedMessages = [];
+    messageTarget;
+    mainLoop;
+    constructor(sessionId, executionId, turnId, kind, source, snapshot, activeAdapters) {
+        this.sessionId = sessionId;
+        this.executionId = executionId;
+        this.turnId = turnId;
+        this.kind = kind;
+        this.source = source;
+        this.snapshot = snapshot;
+        this.compactRequests = new CompactRequests(executionId, () => this.compact.assertNotReentrant());
+        this.#bindings = { compactRequests: this.compactRequests };
+        const owner = this;
+        this.context = Object.freeze({
+            executionId,
+            modelId: snapshot.modelId,
+            mode: snapshot.mode,
+            models: snapshot.models,
+            instruction: snapshot.instruction,
+            get compactRequests() {
+                return owner.#bindings.compactRequests;
+            },
+            get steer() {
+                return owner.#bindings.steer;
+            },
+            get requestMessages() {
+                return owner.#bindings.requestMessages;
+            },
+            get appendedMessages() {
+                return owner.#bindings.appendedMessages;
+            },
+            get toolSources() {
+                return owner.#bindings.toolSources;
+            }
+        });
+        this.modelResources = createExecutionModelResources(activeAdapters);
+    }
+    openMainTurn(adapter, ownsAdapter) {
+        return this.modelResources.openTurn(adapter, ownsAdapter);
+    }
+    async runMainLoop(options) {
+        const loop = new ExecutionLoop(options);
+        this.mainLoop = loop;
+        return loop.run();
+    }
+    async prepare(input) {
+        this.controller.signal.throwIfAborted();
+        this.adoptLease(await input.acquireLease());
+        await input.waitForInputs();
+        input.bindCommittedInputs();
+        await input.refreshAdapters();
+    }
+    get finalAnswer() {
+        return this.mainLoop?.finalAnswer;
+    }
+    async withCompactTurn(adapter, run) {
+        const turn = createModelTurnSession(adapter);
+        let failed = false;
+        try {
+            return await run(turn);
+        }
+        catch (error) {
+            failed = true;
+            throw error;
+        }
+        finally {
+            try {
+                await turn.close();
+            }
+            catch (error) {
+                // A cleanup failure cannot replace the generation failure.
+                if (!failed)
+                    throw error;
+            }
+        }
+    }
+    async closeModelTurns(reason) {
+        let failed = false;
+        let failure;
+        try {
+            await this.compact.close(reason);
+        }
+        catch (error) {
+            failed = true;
+            failure = error;
+        }
+        try {
+            await this.modelResources.close();
+        }
+        catch (error) {
+            if (!failed)
+                failure = error;
+            failed = true;
+        }
+        if (failed)
+            throw failure;
+    }
+    appendCommittedMessage(recordId, message) {
+        this.appendedMessages.push({ recordId, message });
+        this.messageTarget?.push(message);
+    }
+    connectMessageProjection(messages, restoredIds) {
+        for (const pending of this.appendedMessages)
+            if (!restoredIds.has(pending.recordId))
+                messages.push(pending.message);
+        this.appendedMessages.length = 0;
+        this.messageTarget = messages;
+    }
+    clearAppendedMessages() {
+        this.appendedMessages.length = 0;
+    }
+    get appendBoundary() {
+        return this.appendedMessages.length;
+    }
+    appendedAfter(boundary, restoredIds) {
+        return this.appendedMessages
+            .slice(boundary)
+            .filter((entry) => !restoredIds.has(entry.recordId))
+            .map((entry) => entry.message);
+    }
+    orderEvent(action, advance = true) {
+        const operation = this.eventTail.then(action);
+        if (advance)
+            this.eventTail = operation.then(() => undefined, () => undefined);
+        return operation;
+    }
+    emit(event, ports, assertLive) {
+        assertLive?.();
+        const full = {
+            ...event,
+            eventId: randomUUID(),
+            sequence: ++this.eventSequence,
+            timestamp: new Date().toISOString(),
+            sessionId: this.sessionId,
+            executionId: this.executionId,
+            turnId: this.turnId
+        };
+        return this.orderEvent(async () => {
+            assertLive?.();
+            if (full.type === 'tool.output' && this.terminalAdmitted)
+                return;
+            if (full.type === 'execution.completed') {
+                this.controller.signal.throwIfAborted();
+                this.completionAdmitted = true;
+            }
+            if (full.type === 'execution.completed' ||
+                full.type === 'execution.failed' ||
+                full.type === 'execution.cancelled')
+                this.terminalAdmitted = true;
+            const persistent = eventForPersistence(full);
+            let committedTerminal = false;
+            const retainedToolEvent = this.terminalAdmitted &&
+                (full.type === 'tool.started' ||
+                    full.type === 'tool.completed' ||
+                    full.type === 'tool.failed') &&
+                full.parentCallId !== undefined &&
+                ports.hasRetainedLease?.() === true;
+            if (persistent !== undefined && (this.hasLease || retainedToolEvent)) {
+                await ports.persist(full, persistent);
+                if (full.type === 'execution.completed' ||
+                    full.type === 'execution.failed' ||
+                    full.type === 'execution.cancelled')
+                    committedTerminal = this.persistedTerminal = true;
+            }
+            if (full.type === 'tool.output')
+                this.events.pushIfWaiting(full);
+            else
+                this.events.push(full);
+            this.compactRequests.publish(full);
+            try {
+                await ports.publish?.(full);
+            }
+            catch (error) {
+                if (!committedTerminal)
+                    throw error;
+                try {
+                    process.emitWarning(new AgentError('MAR_AGENT_HOST_EVENT_PUBLICATION_FAILED', `Host publication of ${full.type} failed for Execution ${this.executionId}.`, {
+                        details: {
+                            sessionId: this.sessionId,
+                            executionId: this.executionId,
+                            eventId: full.eventId,
+                            eventType: full.type
+                        }
+                    }));
+                }
+                catch {
+                    // A diagnostic sink must not change a committed outcome.
+                }
+            }
+        }, full.type !== 'tool.output');
+    }
+    adoptLease(release) {
+        this.releaseLease = release;
+    }
+    get hasLease() {
+        return this.releaseLease !== undefined;
+    }
+    async releaseSessionLease() {
+        const release = this.releaseLease;
+        this.releaseLease = undefined;
+        await release?.();
+    }
+    async finish(input) {
+        let failed = false;
+        let failure;
+        const attemptSync = (action) => {
+            try {
+                action();
+            }
+            catch (error) {
+                if (!failed)
+                    failure = error;
+                failed = true;
+            }
+        };
+        const attempt = async (action) => {
+            try {
+                await action();
+            }
+            catch (error) {
+                if (!failed)
+                    failure = error;
+                failed = true;
+            }
+        };
+        attemptSync(input.releaseImageBytes);
+        attemptSync(input.revokeBindings);
+        this.messageTarget = undefined;
+        this.appendedMessages.length = 0;
+        attemptSync(input.closeToolSources);
+        attemptSync(input.detachAbort);
+        await attempt(() => this.closeModelTurns(input.reason));
+        await attempt(input.endParent);
+        await attempt(() => this.releaseSessionLease());
+        attemptSync(input.deactivate);
+        this.events.close();
+        if (failed && !input.failed)
+            throw failure;
+    }
+    start(input) {
+        const result = input.scope(async () => {
+            let failed = false;
+            try {
+                const program = await input.prepareProgram();
+                if ('inputHandled' in program) {
+                    this.controller.signal.throwIfAborted();
+                    await input.emit({ type: 'execution.completed' });
+                    return {
+                        executionId: this.executionId,
+                        status: 'completed',
+                        finalAnswer: '',
+                        inputHandled: true
+                    };
+                }
+                if (this.kind === 'compact')
+                    await program.performManualCompact((focus, signal) => program.run(focus ?? DEFAULT_COMPACTION_FOCUS, signal));
+                else
+                    await program.run();
+                this.controller.signal.throwIfAborted();
+                const permissionStop = program.permissionStop();
+                const result = {
+                    finalAnswer: this.kind === 'compact' || permissionStop ? '' : program.finalAnswer(),
+                    ...(permissionStop ? { permissionStop } : {})
+                };
+                input.endParent();
+                await input.emit({
+                    type: 'execution.completed',
+                    ...(result.permissionStop ? { permissionStop: result.permissionStop } : {})
+                });
+                return { executionId: this.executionId, status: 'completed', ...result };
+            }
+            catch (error) {
+                failed = true;
+                await input.beforeFailure(error);
+                input.endParent();
+                const finalAnswer = this.kind === 'compact' ? '' : (this.finalAnswer ?? '');
+                if (this.controller.signal.aborted) {
+                    await input.emit({ type: 'execution.cancelled' }).catch(() => undefined);
+                    return { executionId: this.executionId, status: 'cancelled', finalAnswer };
+                }
+                const diagnostic = input.diagnostic(error);
+                await input.emit({ type: 'execution.failed', ...diagnostic }).catch(() => undefined);
+                return {
+                    executionId: this.executionId,
+                    status: 'failed',
+                    finalAnswer,
+                    errorCode: diagnostic.code,
+                    errorMessage: diagnostic.message
+                };
+            }
+            finally {
+                await input.finalize(failed);
+            }
+        });
+        this.resultPromise = result;
+        void result.then((outcome) => input.settle(outcome.status), () => input.settle('failed'));
+    }
+    join() {
+        return this.resultPromise;
+    }
+    handle(enqueueMessage) {
+        const owner = this;
+        return {
+            get persistedEvents() {
+                return owner.persistedTerminal;
+            },
+            executionId: this.executionId,
+            turnId: this.turnId,
+            [Symbol.asyncIterator]: () => this.events[Symbol.asyncIterator](),
+            result: () => {
+                this.events.discardIfUnobserved();
+                return this.resultPromise;
+            },
+            cancel: () => owner.cancel(new AgentError('MAR_AGENT_CANCELLED', 'Execution was cancelled.')),
+            enqueueMessage
+        };
+    }
+    cancel(reason) {
+        if (this.completionAdmitted)
+            return;
+        this.controller.abort(reason);
+    }
+}

package/dist/sdk/session-extension-messages.d.ts

@@ -0,0 +1,16 @@
+import type { ExtensionSessionBackend } from '../extensions/session-input.js';
+import type { ExtensionAgentsBackend } from '../extensions/agents.js';
+import type { SessionStore } from '../session/store/contracts.js';
+import type { SessionRuntime } from './session-runtime.js';
+import type { ResolvedModelConfiguration } from './model-runtime.js';
+/** Reads either a live request snapshot or the authoritative Session history. */
+export declare function createSessionExtensionMessages(ports: {
+    sessionId: string;
+    store: Pick<SessionStore, 'readResource' | 'readInputImages' | 'readExecutionState' | 'readContextualWorldState'>;
+    agents(): Pick<ExtensionAgentsBackend, 'inspect'> | undefined;
+    runtime(id: string): Pick<SessionRuntime, 'execution' | 'contextualWorldState'> | undefined;
+    models(): {
+        models: ReadonlyMap<string, ResolvedModelConfiguration>;
+        defaultModelId: string;
+    };
+}): ExtensionSessionBackend['messages'];

package/dist/sdk/session-extension-messages.js

@@ -0,0 +1,64 @@
+import { AgentError } from '../error.js';
+import { normalizeSessionMessagesInput, sessionMessagesPage } from '../extensions/session-messages.js';
+import { readResourceImages, restoreMessages } from '../runtime/context/restore.js';
+import { latestContextualWorldStateGeneration, parsePersistedContextualWorldState } from '../runtime/context/world-state.js';
+import { projectSessionRequestMessages } from './request-preparation.js';
+/** Reads either a live request snapshot or the authoritative Session history. */
+export function createSessionExtensionMessages(ports) {
+    const { sessionId, store, agents, runtime, models } = ports;
+    return async (input, call) => {
+        const selection = normalizeSessionMessagesInput(input);
+        call.signal.throwIfAborted();
+        let target = sessionId;
+        let targetModelId;
+        if (selection.agentId !== undefined) {
+            const backend = agents();
+            if (!backend)
+                throw new AgentError('MAR_AGENT_SESSION_INPUT_UNAVAILABLE', 'Session child message access is unavailable.');
+            const child = await backend.inspect({ agentId: selection.agentId }, call);
+            target = child.agentId;
+            targetModelId = child.modelId;
+        }
+        call.signal.throwIfAborted();
+        const targetRuntime = runtime(target);
+        const requestMessages = targetRuntime?.execution?.requestMessages;
+        if (selection.view === 'request' && requestMessages) {
+            const messages = requestMessages.read();
+            const restored = selection.includeImages
+                ? await Promise.all(messages.map(async (message) => message.images?.length
+                    ? {
+                        ...message,
+                        images: await readResourceImages(store, target, message.images)
+                    }
+                    : message))
+                : messages;
+            call.signal.throwIfAborted();
+            return sessionMessagesPage(restored, selection);
+        }
+        const modelState = models();
+        const requestModel = selection.view === 'request'
+            ? modelState.models.get(targetModelId ?? modelState.defaultModelId)
+            : undefined;
+        if (selection.view === 'request' && !requestModel)
+            throw new AgentError('MAR_AGENT_MODEL_DISABLED', 'Selected model is unavailable.');
+        const includeImages = selection.includeImages &&
+            (requestModel === undefined || requestModel.inputCapabilities.includes('IMAGE'));
+        const state = await store.readExecutionState(target);
+        call.signal.throwIfAborted();
+        const restored = await restoreMessages(store, target, state.contextRecords, {
+            includeImages,
+            strictImages: includeImages
+        });
+        call.signal.throwIfAborted();
+        if (requestModel) {
+            const generation = latestContextualWorldStateGeneration(state.contextRecords);
+            const cachedWorld = targetRuntime?.contextualWorldState;
+            const world = cachedWorld?.generation === generation
+                ? cachedWorld
+                : parsePersistedContextualWorldState(await store.readContextualWorldState(target));
+            call.signal.throwIfAborted();
+            return sessionMessagesPage(projectSessionRequestMessages(restored.messages, world?.generation === generation ? (world?.entries ?? []) : [], requestModel.inputCapabilities.includes('IMAGE'), requestModel.codeMode), selection);
+        }
+        return sessionMessagesPage(restored.messages, selection, restored.toolOutcomes);
+    };
+}

package/dist/sdk/session-extension-prompt.d.ts

@@ -0,0 +1,35 @@
+import type { AgentHost } from '../host/contracts.js';
+import type { ExtensionOperationContext } from '../extensions/operation.js';
+import type { ExtensionPromptFacts } from '../extensions/prompt-composition.js';
+import type { ExtensionSession } from '../extensions/session.js';
+import type { ClientToolDefinition } from '../tools/contracts.js';
+import type { ExecutionMode } from './types.js';
+import type { SessionExecutionContext } from './session-execution.js';
+import type { ResolvedModelConfiguration } from './model-runtime.js';
+import type { PromptPart } from '../prompts/prompt-sections.js';
+/** Builds the Session prompt preview using the same capability and Skill boundaries as execution. */
+export declare function createSessionExtensionPrompt(ports: {
+    readonly sessionId: string;
+    readonly source: 'user' | 'subagent';
+    readonly home: string;
+    readonly workspace: string;
+    readonly displayWorkspace: string;
+    readonly codeExecute: boolean;
+    readonly host: Pick<AgentHost, 'listExecutionExtensions' | 'listSessionSkills'>;
+    execution(): SessionExecutionContext | undefined;
+    models(): {
+        models: ReadonlyMap<string, ResolvedModelConfiguration>;
+        defaultModelId: string;
+    };
+    instruction(): string | undefined;
+    workspaceMapped(): boolean;
+    capture(call: ExtensionOperationContext): ReturnType<ExtensionSession['capture']> | undefined;
+    sections(tools: readonly ClientToolDefinition[], mode: ExecutionMode, model: ResolvedModelConfiguration, instruction: string | undefined, skills: string | undefined): readonly PromptPart[];
+}): (facts: ExtensionPromptFacts, call: ExtensionOperationContext) => Promise<{
+    sections: readonly PromptPart[];
+    facts: {
+        modelId: string;
+        mode: ExecutionMode;
+        tools: string[];
+    };
+}>;