@myagentroam/agent 0.11.39 → 0.11.41

package/dist/runtime/context/gc-candidates-subagent.js

@@ -1,100 +0,0 @@
-import { contextGcTargetKey } from '../../session/context-gc-checkpoint.js';
-import { contextGcSubagentNeedsRetainedPriorFinal, contextGcSubagentOutputReplacement, contextGcSubagentPriorFinalIsRetained, contextGcSubagentSnapshotIsPreciselyCovered, contextGcSubagentSnapshotIsSuperseded, contextGcSubagentSnapshotTurnId, normalizeContextGcSubagentSnapshot } from '../../session/context-gc-subagent.js';
-import { CONTEXT_GC_POLICY } from './gc-economics.js';
-import { successfulRolloutsAfter, targetFor } from './gc-candidates.js';
-export function collectSubagentCandidates(input, groups, existingTargets, candidateSavings) {
-    const eligible = [];
-    let protectedTokens = 0;
-    let retryAfterRollouts = Infinity;
-    const invocations = [...groups.values()]
-        .flatMap((group) => {
-        if (!isContextGcSubagentToolName(group.toolName) ||
-            !group.call ||
-            !group.result ||
-            group.failed ||
-            !group.completed ||
-            group.call.message.role !== 'tool_call' ||
-            group.result.message.role !== 'tool')
-            return [];
-        const snapshot = normalizeContextGcSubagentSnapshot(group.result.message.content, group.completed.payload, group.toolName);
-        const turnId = snapshot && contextGcSubagentSnapshotTurnId(snapshot);
-        return snapshot && turnId ? [{ group, snapshot, turnId }] : [];
-    })
-        .sort((left, right) => left.group.completed.sequence - right.group.completed.sequence);
-    for (const [index, source] of invocations.entries()) {
-        if (source.group.evidenceOnly)
-            continue;
-        if (source.group.toolName !== 'agent_wait' &&
-            source.group.toolName !== 'agent_message' &&
-            source.group.toolName !== 'agent_cancel')
-            continue;
-        const sourceTarget = targetFor(source.group.result.record, source.group.result.message);
-        if (!sourceTarget || existingTargets.has(contextGcTargetKey(sourceTarget)))
-            continue;
-        const needsRetainedPriorFinal = contextGcSubagentNeedsRetainedPriorFinal(source.snapshot);
-        const retainedPriorFinal = needsRetainedPriorFinal
-            ? invocations
-                .slice(0, index)
-                .findLast((candidate) => contextGcSubagentPriorFinalIsRetained(source.snapshot, candidate.snapshot))
-            : undefined;
-        if (needsRetainedPriorFinal && retainedPriorFinal === undefined)
-            continue;
-        const terminal = invocations
-            .slice(index + 1)
-            .find((candidate) => candidate.snapshot.agentId === source.snapshot.agentId &&
-            candidate.turnId === source.turnId &&
-            (contextGcSubagentSnapshotIsSuperseded(source.snapshot, candidate.snapshot, retainedPriorFinal?.snapshot) ||
-                contextGcSubagentSnapshotIsPreciselyCovered(source.snapshot, candidate.snapshot)));
-        if (!terminal)
-            continue;
-        const sourceContent = source.group.result.message.content;
-        if (typeof sourceContent !== 'string')
-            continue;
-        const evidenceSequence = terminal.group.result.record.sequence;
-        const observedRollouts = successfulRolloutsAfter(input.records, evidenceSequence, input.modelId, input.contextWindowTokens);
-        const replacement = {
-            kind: 'SUBAGENT_OUTPUT',
-            toolName: source.group.toolName,
-            callId: source.group.callId,
-            target: sourceTarget,
-            replacementContent: contextGcSubagentOutputReplacement({
-                sourceContent,
-                source: source.snapshot,
-                terminal: terminal.snapshot
-            }),
-            terminalToolName: terminal.group.toolName,
-            terminalCallId: terminal.group.callId,
-            evidenceSequence,
-            ...(retainedPriorFinal === undefined
-                ? {}
-                : {
-                    retainedPriorFinal: {
-                        toolName: retainedPriorFinal.group.toolName,
-                        callId: retainedPriorFinal.group.callId,
-                        evidenceSequence: retainedPriorFinal.group.result.record.sequence
-                    }
-                })
-        };
-        const candidate = {
-            replacements: [replacement],
-            observedRollouts,
-            evidenceSequence
-        };
-        const reclaimedTokens = candidateSavings(candidate);
-        if (reclaimedTokens <= 0)
-            continue;
-        if (observedRollouts >= CONTEXT_GC_POLICY.stageAProtectionRollouts)
-            eligible.push(candidate);
-        else {
-            protectedTokens += reclaimedTokens;
-            retryAfterRollouts = Math.min(retryAfterRollouts, CONTEXT_GC_POLICY.stageAProtectionRollouts - observedRollouts);
-        }
-    }
-    return { eligible, protectedTokens, retryAfterRollouts };
-}
-function isContextGcSubagentToolName(value) {
-    return (value === 'agent_start' ||
-        value === 'agent_wait' ||
-        value === 'agent_message' ||
-        value === 'agent_cancel');
-}

package/dist/sdk/extension-agent-controller.d.ts

@@ -1,3 +0,0 @@
-import type { SubagentController } from '../subagent/contracts.js';
-import { type ExtensionAgentAction } from '../extensions/agents.js';
-export declare function bindAgentController(controller: SubagentController, action: ExtensionAgentAction): SubagentController;

package/dist/sdk/extension-agent-controller.js

@@ -1,69 +0,0 @@
-import { parseAgentWaitTargets } from '../subagent/wait-targets.js';
-import { resolveAgentSpawn } from '../extensions/agents.js';
-export function bindAgentController(controller, action) {
-    const wait = (input, waitInterrupt) => action('agent.wait', input, (target, call) => {
-        const selection = parseAgentWaitTargets(target);
-        return selection.agentIds !== undefined
-            ? controller.outputMany(selection.agentIds, {
-                ...target,
-                waitInterrupt,
-                mode: selection.mode ?? 'any',
-                signal: call.signal
-            })
-            : target.agentId === undefined
-                ? controller.outputAny({ ...target, waitInterrupt, signal: call.signal })
-                : controller.output(target.agentId, { ...target, waitInterrupt, signal: call.signal });
-    });
-    return {
-        run: (input, options) => {
-            return action('agent.spawn', {
-                ...(options?.waitFor === undefined ? {} : { waitFor: options.waitFor }),
-                prompt: input.prompt,
-                description: input.description,
-                role: input.role,
-                background: input.background ?? false,
-                ...(input.modelId === undefined ? {} : { modelId: input.modelId }),
-                ...(input.reasoningEffort === undefined ? {} : { reasoningEffort: input.reasoningEffort })
-            }, async (target, call) => {
-                const task = resolveAgentSpawn(target);
-                return controller.run({
-                    prompt: task.prompt,
-                    description: task.description ?? input.description,
-                    role: task.role ?? input.role,
-                    background: task.background ?? false,
-                    ...(input.parentSubagentId === undefined
-                        ? {}
-                        : { parentSubagentId: input.parentSubagentId }),
-                    ...(task.modelId === undefined ? {} : { modelId: task.modelId }),
-                    ...(task.reasoningEffort === undefined
-                        ? {}
-                        : { reasoningEffort: task.reasoningEffort })
-                }, {
-                    ...options,
-                    ...(task.turnSignal === undefined ? {} : { turnSignal: task.turnSignal }),
-                    ...(task.waitFor === undefined ? {} : { waitFor: task.waitFor }),
-                    signal: call.signal
-                });
-            });
-        },
-        output: (id, options) => {
-            const { waitInterrupt, ...input } = options ?? {};
-            return wait({ ...input, agentId: id }, waitInterrupt);
-        },
-        outputAny: (options) => {
-            const { waitInterrupt, ...input } = options ?? {};
-            return wait(input, waitInterrupt);
-        },
-        outputMany: (ids, options) => {
-            const { waitInterrupt, ...input } = options ?? {};
-            return wait({ ...input, agentIds: ids }, waitInterrupt);
-        },
-        message: (id, message, options) => action('agent.message', { ...options, agentId: id, message }, (target, call) => controller.message(target.agentId, target.message, {
-            ...(target.delivery === undefined ? {} : { delivery: target.delivery }),
-            signal: call.signal
-        })),
-        cancel: (id) => action('agent.cancel', { agentId: id }, (target) => controller.cancel(target.agentId)),
-        listSessionResources: () => controller.listSessionResources(),
-        dispose: () => controller.dispose()
-    };
-}

package/dist/sdk/extension-agents.d.ts

@@ -1,9 +0,0 @@
-import type { ExtensionAgentsBackend } from '../extensions/agents.js';
-import type { ExtensionOperationContext } from '../extensions/operation.js';
-import type { SubagentParentOperation, SubagentSessionController } from '../subagent/session-controller.js';
-/** Uses the Session's sole task controller, including its durable children and queue. */
-export declare function createExtensionAgentsBackend(input: {
-    readonly controller: () => Promise<SubagentSessionController>;
-    readonly existingController: () => SubagentSessionController | undefined;
-    readonly parent: (controller: SubagentSessionController, call: ExtensionOperationContext) => SubagentParentOperation;
-}): ExtensionAgentsBackend;

package/dist/sdk/extension-agents.js

@@ -1,58 +0,0 @@
-import { AgentError } from '../error.js';
-import { parseAgentWaitTargets } from '../subagent/wait-targets.js';
-/** Uses the Session's sole task controller, including its durable children and queue. */
-export function createExtensionAgentsBackend(input) {
-    const withController = async (call, run) => {
-        call.signal.throwIfAborted();
-        const controller = await input.controller();
-        call.signal.throwIfAborted();
-        return controller.withOperation(input.parent(controller, call), () => run(controller));
-    };
-    return {
-        own: (owner) => async () => {
-            await input.existingController()?.cancelOwned(owner);
-        },
-        spawn: (task, call) => withController(call, (controller) => controller.run({
-            description: task.description ?? 'Extension agent',
-            prompt: task.prompt,
-            role: task.role ?? 'general-purpose',
-            background: task.background ?? true,
-            ...(task.modelId === undefined ? {} : { modelId: task.modelId }),
-            ...(task.reasoningEffort === undefined ? {} : { reasoningEffort: task.reasoningEffort })
-        }, {
-            signal: call.signal,
-            ...(task.turnSignal === undefined ? {} : { turnSignal: task.turnSignal }),
-            ...(task.waitFor === undefined ? {} : { waitFor: task.waitFor }),
-            onCreated: (created) => {
-                if (created.status === 'failed')
-                    throw new AgentError(created.errorCode ?? 'MAR_AGENT_SUBAGENT_FAILED', created.errorMessage ?? 'Agent could not start.');
-            }
-        })),
-        list: (call) => withController(call, (controller) => controller.list(call.signal)),
-        inspect: (target, call) => withController(call, (controller) => controller.inspect(target.agentId)),
-        wait: (target, call) => withController(call, (controller) => {
-            const selection = parseAgentWaitTargets(target);
-            const options = {
-                waitMs: target.waitMs ?? 30_000,
-                ...(target.untilSettled === undefined ? {} : { untilSettled: target.untilSettled }),
-                ...(target.waitFor === undefined ? {} : { waitFor: target.waitFor }),
-                signal: call.signal
-            };
-            if (selection.agentIds !== undefined)
-                return controller.outputMany(selection.agentIds, {
-                    ...options,
-                    mode: selection.mode ?? 'any'
-                });
-            if (target.untilSettled && target.agentId === undefined)
-                throw new AgentError('MAR_AGENT_TOOL_INPUT_INVALID', 'An unbounded wait requires an agent id.');
-            return target.agentId === undefined
-                ? controller.outputAny(options)
-                : controller.output(target.agentId, options);
-        }),
-        message: (target, call) => withController(call, (controller) => controller.message(target.agentId, target.message, {
-            ...(target.delivery === undefined ? {} : { delivery: target.delivery }),
-            signal: call.signal
-        })),
-        cancel: (target, call) => withController(call, (controller) => controller.cancel(target.agentId))
-    };
-}

package/dist/sdk/subagent-backend.d.ts

@@ -1,3 +0,0 @@
-import type { SessionStore } from '../session/store/contracts.js';
-import type { SubagentSessionControllerBackend } from '../subagent/session-controller.js';
-export declare function createSubagentBackend(store: Pick<SessionStore, 'createSession' | 'delete' | 'listSubagentChildren' | 'getSession' | 'read'>, workspace: string): SubagentSessionControllerBackend;

package/dist/sdk/subagent-backend.js

@@ -1,49 +0,0 @@
-import { AgentError } from '../error.js';
-export function createSubagentBackend(store, workspace) {
-    return {
-        createSession: async (input) => {
-            const session = await store.createSession({
-                workspace,
-                title: input.title,
-                source: input.source
-            });
-            return { id: session.id };
-        },
-        deleteSession: async (sessionId) => {
-            await store.delete(sessionId);
-        },
-        listChildren: async (parentSessionId) => {
-            const sessions = await store.listSubagentChildren(parentSessionId);
-            return sessions.map((session) => ({
-                id: session.id,
-                createdAt: session.createdAt,
-                lastActivityAt: session.lastActivityAt,
-                source: session.source
-            }));
-        },
-        loadChild: async (parentSessionId, childSessionId) => {
-            try {
-                const session = await store.getSession(childSessionId);
-                if (session.source.type !== 'subagent' ||
-                    session.source.parentSessionId !== parentSessionId)
-                    return undefined;
-                return {
-                    id: session.id,
-                    createdAt: session.createdAt,
-                    lastActivityAt: session.lastActivityAt,
-                    source: session.source,
-                    records: await store.read(session.id)
-                };
-            }
-            catch (error) {
-                if (error instanceof AgentError && error.code === 'MAR_AGENT_SESSION_NOT_FOUND') {
-                    // A history read failure is not proof that the child was deleted.
-                    const children = await store.listSubagentChildren(parentSessionId);
-                    if (!children.some((child) => child.id === childSessionId))
-                        return undefined;
-                }
-                throw error;
-            }
-        }
-    };
-}

package/dist/subagent/contracts.d.ts

@@ -1,107 +0,0 @@
-import type { AgentReasoningEffort } from '../model/configuration.js';
-import type { ExecutionResult } from '../runtime/contracts.js';
-export interface SubagentTaskInput {
-    description: string;
-    prompt: string;
-    role: 'general-purpose' | 'explore';
-    modelId?: string;
-    reasoningEffort?: AgentReasoningEffort;
-    background?: boolean;
-    parentSubagentId?: string;
-}
-export interface SubagentLatestMessage {
-    itemId: string;
-    turnId: string;
-    phase: 'commentary' | 'final_answer';
-    text: string;
-    timestamp: string;
-    truncated: boolean;
-}
-export type SubagentLatestActivity = {
-    kind: 'message';
-    timestamp: string;
-    phase: 'commentary' | 'final_answer';
-} | {
-    kind: 'tool';
-    timestamp: string;
-    toolName: string;
-    status: 'started' | 'completed' | 'failed';
-};
-export interface SubagentTaskSnapshot extends Record<string, unknown> {
-    permissionStop?: ExecutionResult['permissionStop'];
-    agentId: string;
-    description: string;
-    role?: SubagentTaskInput['role'];
-    extensionId?: string;
-    status: 'queued' | 'running' | 'completed' | 'failed' | 'cancelled' | 'interrupted';
-    modelId?: string;
-    modelName?: string;
-    reasoningEffort?: AgentReasoningEffort;
-    latestMessage?: SubagentLatestMessage;
-    latestActivity?: 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';
-    waitOutcome?: SubagentWaitOutcome;
-    reason?: 'steer';
-}
-export type SubagentWaitFor = 'completion' | 'message';
-export type SubagentWaitOutcome = Exclude<import('../runtime/wait.js').ToolWaitOutcome, 'yield'>;
-export interface SubagentMessageOptions {
-    delivery?: 'append' | 'replace';
-    signal?: AbortSignal;
-}
-export interface SubagentRunOptions {
-    turnSignal?: AbortSignal;
-    waitFor?: 'start' | 'completion';
-    signal?: AbortSignal;
-    onCreated?: (task: SubagentTaskSnapshot) => Promise<void> | void;
-}
-export interface SubagentOutputOptions {
-    waitInterrupt?: import('../runtime/wait.js').ToolWaitInterrupt | undefined;
-    untilSettled?: true;
-    waitMs?: number;
-    waitFor?: SubagentWaitFor;
-    signal?: AbortSignal;
-}
-export type SubagentWaitMode = 'any' | 'all';
-export interface SubagentManyOutputOptions extends Omit<SubagentOutputOptions, 'untilSettled'> {
-    mode?: SubagentWaitMode;
-}
-export interface SubagentManyOutput {
-    mode: SubagentWaitMode;
-    waitFor: SubagentWaitFor;
-    waitOutcome: SubagentWaitOutcome;
-    reason?: 'steer';
-    agents: SubagentTaskSnapshot[];
-    pendingAgentIds: string[];
-}
-export interface SubagentHandledResult {
-    readonly outcome: 'handled';
-    readonly value?: unknown;
-}
-export type SubagentRunResult = SubagentTaskSnapshot | SubagentHandledResult;
-export interface SubagentController {
-    run(input: SubagentTaskInput, options?: SubagentRunOptions): Promise<SubagentRunResult>;
-    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(): readonly {
-        agentId: string;
-        status: SubagentTaskSnapshot['status'];
-        description: string;
-    }[];
-    dispose(): Promise<void>;
-}

package/dist/subagent/contracts.js

@@ -1 +0,0 @@
-export {};

package/dist/subagent/limits.d.ts

@@ -1,17 +0,0 @@
-export declare const SUBAGENT_LIMITS: Readonly<{
-    agentWaitMinWaitMs: 0;
-    agentWaitWaitFloorMs: 10000;
-    agentWaitDefaultWaitMs: 30000;
-    agentWaitMaxWaitMs: 300000;
-    agentWaitMaxAgents: 8;
-    subagentDescriptionMaxCharacters: 80;
-    subagentPromptMaxBytes: 131072;
-    subagentMessageMaxBytes: 131072;
-    subagentReasoningEffortMaxCharacters: 64;
-    subagentSummaryMaxBytes: 16384;
-    subagentUpdateMaxBytes: 32768;
-    subagentRunningLatestMessageMaxCharacters: 2000;
-    subagentEvidenceMaxItems: 64;
-    subagentVerificationMaxItems: 16;
-    subagentChangedFilesMaxItems: 200;
-}>;

package/dist/subagent/limits.js

@@ -1,17 +0,0 @@
-export const SUBAGENT_LIMITS = Object.freeze({
-    agentWaitMinWaitMs: 0,
-    agentWaitWaitFloorMs: 10_000,
-    agentWaitDefaultWaitMs: 30_000,
-    agentWaitMaxWaitMs: 300_000,
-    agentWaitMaxAgents: 8,
-    subagentDescriptionMaxCharacters: 80,
-    subagentPromptMaxBytes: 131_072,
-    subagentMessageMaxBytes: 131_072,
-    subagentReasoningEffortMaxCharacters: 64,
-    subagentSummaryMaxBytes: 16_384,
-    subagentUpdateMaxBytes: 32_768,
-    subagentRunningLatestMessageMaxCharacters: 2_000,
-    subagentEvidenceMaxItems: 64,
-    subagentVerificationMaxItems: 16,
-    subagentChangedFilesMaxItems: 200
-});

package/dist/subagent/model-update.d.ts

@@ -1,2 +0,0 @@
-import type { SubagentTaskSnapshot } from './contracts.js';
-export declare function renderSubagentUpdate(snapshot: SubagentTaskSnapshot, truncated?: boolean): string;

package/dist/subagent/model-update.js

@@ -1,81 +0,0 @@
-import { escapeMarkupText, markupAttributes } from '../prompts/markup.js';
-import { SUBAGENT_LIMITS } from './limits.js';
-export function renderSubagentUpdate(snapshot, truncated = false) {
-    const attributes = (values) => markupAttributes(Object.fromEntries(Object.entries(values).map(([key, value]) => {
-        if (value === undefined)
-            return [key, undefined];
-        let bounded = '';
-        let count = 0;
-        for (const point of String(value)) {
-            if (count++ === 256) {
-                truncated = true;
-                break;
-            }
-            bounded += point;
-        }
-        return [key, bounded];
-    })));
-    const root = '<mar_subagent_update' +
-        attributes({
-            agentId: snapshot.agentId,
-            status: snapshot.status,
-            modelId: snapshot.modelId,
-            modelName: snapshot.modelName,
-            reasoningEffort: snapshot.reasoningEffort,
-            messageId: snapshot.messageId,
-            turnId: snapshot.turnId,
-            deliveryStatus: snapshot.deliveryStatus
-        });
-    const close = '</mar_subagent_update>';
-    let remaining = SUBAGENT_LIMITS.subagentUpdateMaxBytes -
-        Buffer.byteLength(root + ' truncated="false">\n' + close);
-    const lines = [];
-    const field = (name, value, metadata = {}, limit = remaining) => {
-        let attrs = attributes(metadata);
-        const overhead = Buffer.byteLength('  <' + name + attrs + '></' + name + '>\n');
-        if (overhead > remaining) {
-            truncated = true;
-            return;
-        }
-        let budget = Math.min(limit, remaining - overhead);
-        let text = '';
-        let clipped = false;
-        for (const point of value) {
-            const encoded = escapeMarkupText(point);
-            const bytes = Buffer.byteLength(encoded);
-            if (bytes > budget) {
-                clipped = true;
-                break;
-            }
-            text += encoded;
-            budget -= bytes;
-        }
-        if (clipped) {
-            truncated = true;
-            if ('truncated' in metadata)
-                attrs = attributes({ ...metadata, truncated: true });
-        }
-        const opening = '  <' + name + attrs;
-        const line = text === '' ? opening + ' />\n' : opening + '>' + text + '</' + name + '>\n';
-        remaining -= Buffer.byteLength(line);
-        lines.push(line);
-    };
-    // Preserve failure/permission facts before spending the remaining budget on result text.
-    if (snapshot.errorCode !== undefined || snapshot.errorMessage !== undefined)
-        field('error', snapshot.errorMessage ?? '', { code: snapshot.errorCode }, 1024);
-    if (snapshot.permissionStop)
-        field('permission_stop', snapshot.permissionStop.reason, { action: snapshot.permissionStop.action, ...snapshot.permissionStop.source }, 1024);
-    field('description', snapshot.description, {}, 1024);
-    if (snapshot.latestMessage) {
-        const { text, ...metadata } = snapshot.latestMessage;
-        truncated ||= metadata.truncated;
-        field('message', text, metadata, SUBAGENT_LIMITS.subagentSummaryMaxBytes);
-    }
-    if (snapshot.summary !== undefined)
-        field('summary', snapshot.summary);
-    for (const path of snapshot.changedFiles ?? [])
-        field('changed_file', path);
-    if (snapshot.latestActivity)
-        field('activity', '', snapshot.latestActivity);
-    return root + ' truncated="' + String(truncated) + '">\n' + lines.join('') + close;
-}

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

@@ -1,87 +0,0 @@
-import { type ToolWaitInterrupt } from '../runtime/wait.js';
-import type { SessionSource } from '../session/types.js';
-import type { SubagentManyOutput, SubagentManyOutputOptions } from './contracts.js';
-import type { SubagentController, SubagentMessageOptions, SubagentOutputOptions, SubagentRunOptions, SubagentTaskInput, SubagentTaskSnapshot } from './contracts.js';
-import type { SubagentParentExecution, SubagentParentOperation } from './turn-contracts.js';
-export type { SubagentModelOption, SubagentTurnHandle, SubagentOrigin, SubagentMessageDelivery, SubagentMailboxMessage, SubagentParentExecution, SubagentParentOperation } from './turn-contracts.js';
-interface SubagentHistoryRecord {
-    readonly type: string;
-    readonly payload: unknown;
-    readonly turnId?: string;
-}
-export interface PersistedSubagentSession {
-    readonly id: string;
-    readonly createdAt: string;
-    readonly lastActivityAt: string;
-    readonly source: Extract<SessionSource, {
-        type: 'subagent';
-    }>;
-    readonly records: readonly SubagentHistoryRecord[];
-}
-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" | "queued" | "running";
-        description: string;
-    }[];
-    dispose(): Promise<void>;
-}