@myagentroam/agent 0.11.32 → 0.11.34

package/dist/agent-core/subagent/scheduler.d.ts

@@ -1,135 +0,0 @@
-import type { SubagentManyOutput, SubagentManyOutputOptions } from './contracts.js';
-import type { SubagentController, SubagentOutputOptions, SubagentRunOptions, SubagentTaskInput, SubagentTaskResult, SubagentTaskSnapshot } from './contracts.js';
-export type { SubagentController, SubagentLatestActivity, SubagentLatestMessage, SubagentMessageOptions, SubagentManyOutput, SubagentManyOutputOptions, SubagentOutputOptions, SubagentRunOptions, SubagentTaskInput, SubagentTaskResult, SubagentTaskSnapshot, SubagentWaitFor, SubagentWaitOutcome } from './contracts.js';
-export declare class SubagentScheduler implements SubagentController {
-    #private;
-    readonly limits: {
-        maxTasks: number;
-        maxConcurrent: number;
-    };
-    constructor(runner: (task: SubagentTaskInput, signal: AbortSignal) => Promise<SubagentTaskResult>, limits?: {
-        maxTasks: number;
-        maxConcurrent: number;
-    });
-    beginExecution(runner: (task: SubagentTaskInput, signal: AbortSignal) => Promise<SubagentTaskResult>): void;
-    run(input: SubagentTaskInput, options?: SubagentRunOptions): Promise<SubagentTaskSnapshot>;
-    output(agentId: string, options?: SubagentOutputOptions): Promise<{
-        waitOutcome: "snapshot";
-        permissionStop?: import("../tools/permissions.js").PermissionStop;
-        agentId: string;
-        description: string;
-        role?: SubagentTaskInput["role"];
-        extensionId?: string;
-        status: "queued" | "running" | "completed" | "failed" | "cancelled" | "interrupted";
-        modelId?: string;
-        modelName?: string;
-        reasoningEffort?: import("../model/configuration.js").MarAgentReasoningEffort;
-        latestMessage?: import("./contracts.js").SubagentLatestMessage;
-        latestActivity?: import("./contracts.js").SubagentLatestActivity;
-        summary?: string;
-        changedFiles?: string[];
-        verification?: string[];
-        evidence?: Array<{
-            path: string;
-            startLine?: number;
-            endLine?: number;
-        }>;
-        errorCode?: string;
-        errorMessage?: string;
-        messageId?: string;
-        turnId?: string;
-        deliveryStatus?: "accepted" | "applied" | "cancelled" | "failed";
-        reason?: "steer";
-    } | {
-        waitOutcome: "completion" | "timeout";
-        permissionStop?: import("../tools/permissions.js").PermissionStop;
-        agentId: string;
-        description: string;
-        role?: SubagentTaskInput["role"];
-        extensionId?: string;
-        status: "queued" | "running" | "completed" | "failed" | "cancelled" | "interrupted";
-        modelId?: string;
-        modelName?: string;
-        reasoningEffort?: import("../model/configuration.js").MarAgentReasoningEffort;
-        latestMessage?: import("./contracts.js").SubagentLatestMessage;
-        latestActivity?: import("./contracts.js").SubagentLatestActivity;
-        summary?: string;
-        changedFiles?: string[];
-        verification?: string[];
-        evidence?: Array<{
-            path: string;
-            startLine?: number;
-            endLine?: number;
-        }>;
-        errorCode?: string;
-        errorMessage?: string;
-        messageId?: string;
-        turnId?: string;
-        deliveryStatus?: "accepted" | "applied" | "cancelled" | "failed";
-        reason?: "steer";
-    }>;
-    outputAny(options?: SubagentOutputOptions): Promise<{
-        waitOutcome: "snapshot";
-        permissionStop?: import("../tools/permissions.js").PermissionStop;
-        agentId: string;
-        description: string;
-        role?: SubagentTaskInput["role"];
-        extensionId?: string;
-        status: "queued" | "running" | "completed" | "failed" | "cancelled" | "interrupted";
-        modelId?: string;
-        modelName?: string;
-        reasoningEffort?: import("../model/configuration.js").MarAgentReasoningEffort;
-        latestMessage?: import("./contracts.js").SubagentLatestMessage;
-        latestActivity?: import("./contracts.js").SubagentLatestActivity;
-        summary?: string;
-        changedFiles?: string[];
-        verification?: string[];
-        evidence?: Array<{
-            path: string;
-            startLine?: number;
-            endLine?: number;
-        }>;
-        errorCode?: string;
-        errorMessage?: string;
-        messageId?: string;
-        turnId?: string;
-        deliveryStatus?: "accepted" | "applied" | "cancelled" | "failed";
-        reason?: "steer";
-    } | {
-        waitOutcome: "completion" | "timeout";
-        permissionStop?: import("../tools/permissions.js").PermissionStop;
-        agentId: string;
-        description: string;
-        role?: SubagentTaskInput["role"];
-        extensionId?: string;
-        status: "queued" | "running" | "completed" | "failed" | "cancelled" | "interrupted";
-        modelId?: string;
-        modelName?: string;
-        reasoningEffort?: import("../model/configuration.js").MarAgentReasoningEffort;
-        latestMessage?: import("./contracts.js").SubagentLatestMessage;
-        latestActivity?: import("./contracts.js").SubagentLatestActivity;
-        summary?: string;
-        changedFiles?: string[];
-        verification?: string[];
-        evidence?: Array<{
-            path: string;
-            startLine?: number;
-            endLine?: number;
-        }>;
-        errorCode?: string;
-        errorMessage?: string;
-        messageId?: string;
-        turnId?: string;
-        deliveryStatus?: "accepted" | "applied" | "cancelled" | "failed";
-        reason?: "steer";
-    }>;
-    outputMany(agentIds: readonly string[], options?: SubagentManyOutputOptions): Promise<SubagentManyOutput>;
-    cancel(agentId: string): Promise<SubagentTaskSnapshot>;
-    message(_agentId: string, _message: string): Promise<SubagentTaskSnapshot>;
-    listSessionResources(): {
-        agentId: string;
-        status: "completed" | "failed" | "cancelled" | "running" | "queued";
-        description: string;
-    }[];
-    dispose(): Promise<void>;
-}

package/dist/agent-core/subagent/scheduler.js

@@ -1,369 +0,0 @@
-import { randomUUID } from 'node:crypto';
-import { describeMarAgentError, MarAgentError } from '../error.js';
-import { marAgentReasoningEffortSchema } from '../model/configuration.js';
-import { TOOL_EXECUTION_LIMITS } from '../tools/execution-limits.js';
-import { parseAgentWaitTargets, waitForAgentCondition } from './wait.js';
-export class SubagentScheduler {
-    limits;
-    #tasks = new Map();
-    #queue = [];
-    #completionWaiters = new Set();
-    #running = 0;
-    #disposed = false;
-    #createdInExecution = 0;
-    #runner;
-    constructor(runner, limits = { maxTasks: 16, maxConcurrent: 16 }) {
-        this.limits = limits;
-        this.#runner = runner;
-    }
-    beginExecution(runner) {
-        if (this.#disposed)
-            throw new MarAgentError('MAR_AGENT_SUBAGENT_LIMIT', 'Subagent scheduler is disposed.');
-        this.#runner = runner;
-        this.#createdInExecution = 0;
-    }
-    async run(input, options = {}) {
-        options.signal?.throwIfAborted();
-        const reasoningEffort = input.reasoningEffort;
-        const parsedReasoningEffort = typeof reasoningEffort === 'string'
-            ? marAgentReasoningEffortSchema.safeParse(reasoningEffort.trim())
-            : undefined;
-        if (input.parentSubagentId)
-            throw new MarAgentError('MAR_AGENT_SUBAGENT_RECURSION_DISABLED', 'Subagents cannot create subagents.');
-        if (this.#disposed || this.#createdInExecution >= this.limits.maxTasks)
-            throw new MarAgentError('MAR_AGENT_SUBAGENT_LIMIT', 'Subagent task limit was reached.');
-        if (!input.description.trim() ||
-            input.description.length > TOOL_EXECUTION_LIMITS.subagentDescriptionMaxCharacters ||
-            !input.prompt.trim() ||
-            Buffer.byteLength(input.prompt) > TOOL_EXECUTION_LIMITS.subagentPromptMaxBytes ||
-            (reasoningEffort !== undefined &&
-                (parsedReasoningEffort === undefined || !parsedReasoningEffort.success)))
-            throw new MarAgentError('MAR_AGENT_TOOL_INPUT_INVALID', 'Subagent task is invalid.');
-        const agentId = randomUUID();
-        let resolve;
-        const completion = new Promise((done) => (resolve = done));
-        const task = {
-            agentId,
-            input: {
-                ...input,
-                description: input.description.trim(),
-                ...(parsedReasoningEffort?.success ? { reasoningEffort: parsedReasoningEffort.data } : {})
-            },
-            status: 'queued',
-            controller: new AbortController(),
-            completion,
-            resolve,
-            runner: this.#runner
-        };
-        this.#createdInExecution++;
-        this.#tasks.set(agentId, task);
-        this.#queue.push(task);
-        this.#drain();
-        try {
-            await options.onCreated?.(this.#public(task));
-        }
-        catch (error) {
-            this.#cancelTask(task, error);
-            if (task.status === 'running')
-                await task.completion;
-            throw error;
-        }
-        if (!input.background)
-            await waitForPromise(completion, options.signal);
-        return this.#public(task);
-    }
-    async output(agentId, options = {}) {
-        options.signal?.throwIfAborted();
-        rejectUnsupportedMessageWait(options);
-        const task = this.#tasks.get(agentId);
-        if (!task)
-            throw new MarAgentError('MAR_AGENT_SUBAGENT_NOT_FOUND', 'Subagent task was not found.');
-        validateOutputOptions(options);
-        const terminal = ['completed', 'failed', 'cancelled'].includes(task.status);
-        if (options.waitMs === undefined || options.waitMs === 0)
-            return { ...this.#public(task), waitOutcome: 'snapshot' };
-        if (terminal)
-            return { ...this.#public(task), waitOutcome: 'completion' };
-        const waitMs = Math.max(options.waitMs, TOOL_EXECUTION_LIMITS.agentWaitWaitFloorMs);
-        const completed = await this.#waitForCompletion(task, waitMs, options.signal);
-        options.signal?.throwIfAborted();
-        return {
-            ...this.#public(task),
-            waitOutcome: completed ? 'completion' : 'timeout'
-        };
-    }
-    async outputAny(options = {}) {
-        options.signal?.throwIfAborted();
-        validateOutputOptions(options);
-        rejectUnsupportedMessageWait(options);
-        const tasks = [...this.#tasks.values()];
-        if (tasks.length === 0)
-            throw new MarAgentError('MAR_AGENT_SUBAGENT_NOT_FOUND', 'Subagent task was not found.');
-        const live = tasks.filter((task) => task.status === 'queued' || task.status === 'running');
-        if (options.waitMs === undefined || options.waitMs === 0)
-            return { ...this.#public(live.at(-1) ?? tasks.at(-1)), waitOutcome: 'snapshot' };
-        if (live.length === 0)
-            return { ...this.#public(tasks.at(-1)), waitOutcome: 'completion' };
-        const waitMs = Math.max(options.waitMs, TOOL_EXECUTION_LIMITS.agentWaitWaitFloorMs);
-        const completed = await this.#waitForAnyCompletion(live, waitMs, options.signal);
-        options.signal?.throwIfAborted();
-        return {
-            ...this.#public(completed ?? live.at(-1)),
-            waitOutcome: completed ? 'completion' : 'timeout'
-        };
-    }
-    async outputMany(agentIds, options = {}) {
-        options.signal?.throwIfAborted();
-        const { agentIds: ids, mode = 'any' } = parseAgentWaitTargets({ agentIds, mode: options.mode });
-        validateOutputOptions(options);
-        rejectUnsupportedMessageWait(options);
-        if (!ids || 'untilSettled' in options)
-            throw new MarAgentError('MAR_AGENT_TOOL_INPUT_INVALID', 'Group waits require explicit targets and a bounded deadline.');
-        const tasks = ids.map((id) => {
-            const task = this.#tasks.get(id);
-            if (!task)
-                throw new MarAgentError('MAR_AGENT_SUBAGENT_NOT_FOUND', 'Subagent task was not found.');
-            return task;
-        });
-        const terminal = (task) => task.status !== 'queued' && task.status !== 'running';
-        const snapshot = options.waitMs === undefined || options.waitMs === 0;
-        const satisfied = !snapshot &&
-            (await waitForAgentCondition({
-                ready: () => (mode === 'all' ? tasks.every(terminal) : tasks.some(terminal)),
-                subscribe: (notify) => {
-                    this.#completionWaiters.add(notify);
-                    return () => this.#completionWaiters.delete(notify);
-                },
-                waitMs: Math.max(options.waitMs, TOOL_EXECUTION_LIMITS.agentWaitWaitFloorMs),
-                signal: options.signal
-            }));
-        options.signal?.throwIfAborted();
-        return {
-            mode,
-            waitFor: 'completion',
-            waitOutcome: snapshot ? 'snapshot' : satisfied ? 'completion' : 'timeout',
-            pendingAgentIds: tasks.filter((task) => !terminal(task)).map((task) => task.agentId),
-            agents: tasks.map((task) => ({
-                ...this.#public(task),
-                waitOutcome: snapshot
-                    ? 'snapshot'
-                    : terminal(task)
-                        ? 'completion'
-                        : satisfied
-                            ? 'snapshot'
-                            : 'timeout'
-            }))
-        };
-    }
-    async cancel(agentId) {
-        const task = this.#tasks.get(agentId);
-        if (!task)
-            throw new MarAgentError('MAR_AGENT_SUBAGENT_NOT_FOUND', 'Subagent task was not found.');
-        this.#cancelTask(task, new MarAgentError('MAR_AGENT_CANCELLED', 'Subagent task was cancelled.'));
-        if (task.status === 'running')
-            await task.completion;
-        return this.#public(task);
-    }
-    async message(_agentId, _message) {
-        throw new MarAgentError('MAR_AGENT_SUBAGENT_FAILED', 'The in-memory compatibility scheduler does not support follow-up messages.');
-    }
-    #cancelTask(task, reason) {
-        if (task.status === 'queued') {
-            task.status = 'cancelled';
-            const index = this.#queue.indexOf(task);
-            if (index >= 0)
-                this.#queue.splice(index, 1);
-            task.controller.abort(reason);
-            task.resolve();
-            this.#notifyCompletion(task);
-            this.#drain();
-        }
-        else if (task.status === 'running')
-            task.controller.abort(reason);
-    }
-    #drain() {
-        while (!this.#disposed && this.#running < this.limits.maxConcurrent && this.#queue.length) {
-            const task = this.#queue.shift();
-            if (task.status !== 'queued')
-                continue;
-            task.status = 'running';
-            this.#running++;
-            void task
-                .runner(task.input, task.controller.signal)
-                .then((result) => {
-                if (task.controller.signal.aborted)
-                    task.status = 'cancelled';
-                else {
-                    task.result = normalizeResult(result);
-                    task.status = 'completed';
-                }
-            }, (error) => {
-                task.status = task.controller.signal.aborted ? 'cancelled' : 'failed';
-                const diagnostic = describeMarAgentError(error, 'MAR_AGENT_SUBAGENT_FAILED');
-                task.errorCode = diagnostic.code;
-                task.errorMessage = diagnostic.message;
-            })
-                .finally(() => {
-                this.#running--;
-                task.resolve();
-                this.#notifyCompletion(task);
-                this.#drain();
-            });
-        }
-    }
-    #public(task) {
-        return {
-            agentId: task.agentId,
-            description: task.input.description,
-            status: task.status,
-            ...(task.result
-                ? { summary: task.result.summary, changedFiles: [...task.result.changedFiles] }
-                : {}),
-            ...(task.errorCode ? { errorCode: task.errorCode } : {}),
-            ...(task.errorMessage ? { errorMessage: task.errorMessage } : {})
-        };
-    }
-    listSessionResources() {
-        return [...this.#tasks.values()].map((task) => ({
-            agentId: task.agentId,
-            status: task.status,
-            description: task.input.description
-        }));
-    }
-    async dispose() {
-        if (this.#disposed)
-            return;
-        this.#disposed = true;
-        for (const task of this.#tasks.values()) {
-            if (task.status === 'queued') {
-                task.status = 'cancelled';
-                task.controller.abort();
-                task.resolve();
-                this.#notifyCompletion(task);
-            }
-            else if (task.status === 'running')
-                task.controller.abort();
-        }
-        await Promise.all([...this.#tasks.values()].map((task) => task.completion));
-        this.#queue.length = 0;
-        this.#tasks.clear();
-    }
-    #waitForAnyCompletion(candidates, waitMs, signal) {
-        return waitForCompletionNotification(this.#completionWaiters, (task) => candidates.includes(task), waitMs, signal);
-    }
-    #waitForCompletion(task, waitMs, signal) {
-        return waitForCompletionNotification(this.#completionWaiters, (completed) => completed === task, waitMs, signal);
-    }
-    #notifyCompletion(task) {
-        for (const waiter of this.#completionWaiters)
-            waiter(task);
-    }
-}
-function normalizeResult(result) {
-    return {
-        summary: truncateUtf8(result.summary, TOOL_EXECUTION_LIMITS.subagentSummaryMaxBytes),
-        changedFiles: [...new Set(result.changedFiles)]
-            .filter((path) => typeof path === 'string' && path.length > 0 && path.length <= 4096)
-            .slice(0, TOOL_EXECUTION_LIMITS.subagentChangedFilesMaxItems),
-        verification: result.verification
-            .filter((item) => typeof item === 'string')
-            .slice(0, TOOL_EXECUTION_LIMITS.subagentVerificationMaxItems)
-            .map((item) => truncateUtf8(item, 2_000)),
-        evidence: (result.evidence ?? [])
-            .filter((item) => item && typeof item.path === 'string' && item.path.length > 0 && item.path.length <= 4096)
-            .slice(0, TOOL_EXECUTION_LIMITS.subagentEvidenceMaxItems)
-            .map((item) => ({
-            path: item.path,
-            ...(Number.isInteger(item.startLine) && item.startLine >= 1
-                ? { startLine: item.startLine }
-                : {}),
-            ...(Number.isInteger(item.endLine) && item.endLine >= 1 ? { endLine: item.endLine } : {})
-        }))
-    };
-}
-function truncateUtf8(value, maximumBytes) {
-    if (typeof value !== 'string')
-        return '';
-    const bytes = Buffer.from(value);
-    if (bytes.length <= maximumBytes)
-        return value;
-    let end = maximumBytes;
-    while (end > 0 && (bytes[end] & 0xc0) === 0x80)
-        end--;
-    return bytes.subarray(0, end).toString('utf8');
-}
-function waitForCompletionNotification(waiters, accepts, waitMs, signal) {
-    return new Promise((resolve, reject) => {
-        let settled = false;
-        const finish = (error) => {
-            if (settled)
-                return;
-            settled = true;
-            clearTimeout(timer);
-            signal?.removeEventListener('abort', abort);
-            waiters.delete(notify);
-            if (error === undefined)
-                resolve(undefined);
-            else
-                reject(error);
-        };
-        const notify = (value) => {
-            if (accepts(value)) {
-                if (settled)
-                    return;
-                settled = true;
-                clearTimeout(timer);
-                signal?.removeEventListener('abort', abort);
-                waiters.delete(notify);
-                resolve(value);
-            }
-        };
-        const abort = () => finish(signal?.reason ?? new MarAgentError('MAR_AGENT_EXECUTION_CANCELLED', 'Execution cancelled.'));
-        const timer = setTimeout(finish, waitMs);
-        timer.unref();
-        waiters.add(notify);
-        signal?.addEventListener('abort', abort, { once: true });
-        if (signal?.aborted)
-            abort();
-    });
-}
-function validateOutputOptions(options) {
-    if ((options.waitFor !== undefined &&
-        options.waitFor !== 'completion' &&
-        options.waitFor !== 'message') ||
-        (options.waitMs !== undefined &&
-            (!Number.isInteger(options.waitMs) ||
-                options.waitMs < TOOL_EXECUTION_LIMITS.agentWaitMinWaitMs ||
-                options.waitMs > TOOL_EXECUTION_LIMITS.agentWaitMaxWaitMs)))
-        throw new MarAgentError('MAR_AGENT_TOOL_INPUT_INVALID', 'Task wait is invalid.');
-}
-function rejectUnsupportedMessageWait(options) {
-    if (options.waitFor === 'message')
-        throw new MarAgentError('MAR_AGENT_TOOL_NOT_AVAILABLE', 'Message waits require a session-backed subagent controller.');
-}
-function waitForPromise(promise, signal) {
-    signal?.throwIfAborted();
-    if (signal === undefined)
-        return promise;
-    return new Promise((resolve, reject) => {
-        let settled = false;
-        const finish = (result) => {
-            if (settled)
-                return;
-            settled = true;
-            signal.removeEventListener('abort', abort);
-            if ('error' in result)
-                reject(result.error);
-            else
-                resolve(result.value);
-        };
-        const abort = () => finish({
-            error: signal.reason ??
-                new MarAgentError('MAR_AGENT_EXECUTION_CANCELLED', 'Execution cancelled.')
-        });
-        signal.addEventListener('abort', abort, { once: true });
-        promise.then((value) => finish({ value }), (error) => finish({ error }));
-        if (signal.aborted)
-            abort();
-    });
-}

package/dist/agent-core/subagent/session-controller.d.ts

@@ -1,138 +0,0 @@
-import { type ToolWaitInterrupt } from '../tools/wait.js';
-import type { CoreOperationContext } from '../extensions/operation.js';
-import type { MarAgentReasoningEffort } from '../model/configuration.js';
-import type { ExecutionResult } from '../runtime/contracts.js';
-import type { MarAgentEvent } from '../runtime/events.js';
-import type { SessionRecord, SessionSource } from '../session/store/index.js';
-import type { SubagentManyOutput, SubagentManyOutputOptions } from './contracts.js';
-import type { SubagentController, SubagentMessageOptions, SubagentOutputOptions, SubagentRunOptions, SubagentTaskInput, SubagentTaskSnapshot } from './scheduler.js';
-export interface SubagentModelOption {
-    readonly id: string;
-    readonly name: string;
-    readonly conversationModel?: boolean;
-    readonly reasoningEfforts: readonly MarAgentReasoningEffort[];
-    readonly defaultReasoningEffort: MarAgentReasoningEffort;
-}
-export interface SubagentTurnHandle extends AsyncIterable<MarAgentEvent> {
-    readonly executionId: string;
-    readonly turnId: string;
-    /** True only after the child terminal event was durably appended. */
-    readonly persistedEvents?: boolean;
-    result(): Promise<ExecutionResult>;
-    cancel(): void;
-    enqueueMessage(message: string, delivery?: SubagentMessageDelivery): boolean;
-}
-export interface SubagentMessageDelivery {
-    readonly messageId: string;
-    readonly origin?: CoreOperationContext;
-    readonly signal?: AbortSignal;
-    applied(): void;
-    settled?(status: 'cancelled' | 'failed'): void;
-}
-export interface SubagentMailboxMessage {
-    readonly text: string;
-    readonly delivery?: SubagentMessageDelivery;
-}
-export interface SubagentParentExecution {
-    readonly executionId: string;
-    readonly modelId: string;
-    readonly reasoningEffort: MarAgentReasoningEffort;
-    readonly models: ReadonlyMap<string, SubagentModelOption>;
-    emitTerminal(snapshot: SubagentTaskSnapshot): Promise<void>;
-    startTurn(input: {
-        readonly sessionId: string;
-        readonly prompt: string;
-        readonly modelId: string;
-        readonly reasoningEffort: MarAgentReasoningEffort;
-        readonly role: SubagentTaskInput['role'];
-        readonly initialMailbox: readonly SubagentMailboxMessage[];
-        readonly turnId: string;
-        readonly delivery?: SubagentMessageDelivery;
-        readonly origin?: CoreOperationContext;
-    }): Promise<SubagentTurnHandle>;
-}
-/** A native operation has its own provenance even when no parent Execution is active. */
-export interface SubagentParentOperation extends Omit<SubagentParentExecution, 'executionId'> {
-    readonly operationId: string;
-    readonly executionId?: string;
-    readonly ownerInstanceId?: string;
-    readonly extensionId?: string;
-    readonly signal: AbortSignal;
-    readonly origin?: CoreOperationContext;
-}
-export interface PersistedSubagentSession {
-    readonly id: string;
-    readonly createdAt: string;
-    readonly lastActivityAt: string;
-    readonly source: Extract<SessionSource, {
-        type: 'subagent';
-    }>;
-    readonly records: readonly SessionRecord[];
-}
-export interface SubagentSessionControllerBackend {
-    createSession(input: {
-        readonly title: string;
-        readonly source: Extract<SessionSource, {
-            type: 'subagent';
-        }>;
-    }): Promise<{
-        readonly id: string;
-    }>;
-    deleteSession(sessionId: string): Promise<void>;
-    /** Returns children in durable creation order. */
-    listChildren(parentSessionId: string): Promise<readonly Omit<PersistedSubagentSession, 'records'>[]>;
-    loadChild(parentSessionId: string, sessionId: string): Promise<PersistedSubagentSession | undefined>;
-}
-export declare class SubagentSessionController implements SubagentController {
-    #private;
-    private readonly parentSessionId;
-    private readonly rootSessionId;
-    private readonly backend;
-    readonly limits: {
-        maxTasks: number;
-        maxConcurrent: number;
-    };
-    readonly modelMessages: ToolWaitInterrupt;
-    private constructor();
-    static open(input: {
-        readonly parentSessionId: string;
-        readonly rootSessionId: string;
-        readonly backend: SubagentSessionControllerBackend;
-        readonly limits?: {
-            readonly maxTasks: number;
-            readonly maxConcurrent: number;
-        };
-    }): Promise<SubagentSessionController>;
-    beginParentExecution(execution: SubagentParentExecution): Promise<void>;
-    /** A retained cell must not borrow a later model Execution's identity or task budget. */
-    captureExecution(executionId?: string): SubagentController;
-    /** SDK physical tool ingress shares the same captured parent as its model controls. */
-    captureParentFrame(executionId?: string): <Value>(run: () => Value) => Value;
-    withOperation<T>(operation: SubagentParentOperation, run: () => T): T;
-    inspect(agentId: string): Promise<SubagentTaskSnapshot>;
-    inspectAll(): readonly SubagentTaskSnapshot[];
-    list(signal?: AbortSignal): Promise<readonly SubagentTaskSnapshot[]>;
-    /** Full listing is explicit; ordinary opens and executions never require it. */
-    prepareAll(signal?: AbortSignal): Promise<void>;
-    prepareSessionResources(signal?: AbortSignal): Promise<void>;
-    collectModelUpdates(): readonly {
-        snapshot: SubagentTaskSnapshot;
-        truncated: boolean;
-        acknowledge(): void;
-    }[];
-    cancelOwned(ownerInstanceId: string): Promise<void>;
-    endParentExecution(executionId: string): void;
-    parentExecution(executionId: string): SubagentParentExecution | undefined;
-    run(input: SubagentTaskInput, options?: SubagentRunOptions): Promise<SubagentTaskSnapshot>;
-    output(agentId: string, options?: SubagentOutputOptions): Promise<SubagentTaskSnapshot>;
-    outputAny(options?: SubagentOutputOptions): Promise<SubagentTaskSnapshot>;
-    outputMany(agentIds: readonly string[], options?: SubagentManyOutputOptions): Promise<SubagentManyOutput>;
-    message(agentId: string, message: string, options?: SubagentMessageOptions): Promise<SubagentTaskSnapshot>;
-    cancel(agentId: string): Promise<SubagentTaskSnapshot>;
-    listSessionResources(): {
-        agentId: string;
-        status: "completed" | "failed" | "cancelled" | "interrupted" | "running" | "queued";
-        description: string;
-    }[];
-    dispose(): Promise<void>;
-}