@myagentroam/agent 0.11.38 → 0.11.40

package/dist/extensions/agents.d.ts

@@ -1,100 +0,0 @@
-import type { AgentReasoningEffort } from '../model/configuration.js';
-import type { SubagentTaskSnapshot, SubagentManyOutput, SubagentHandledResult } from '../subagent/contracts.js';
-import type { ExtensionOperationContext } from './operation.js';
-import type { ExtensionResourceScope } from './resources.js';
-import type { ExtensionHooks } from './hooks.js';
-import type { ExtensionCapabilitySnapshot } from './capabilities.js';
-export type ExtensionAgentSnapshot = Readonly<SubagentTaskSnapshot>;
-export type ExtensionAgentManySnapshot = Readonly<SubagentManyOutput>;
-export type ExtensionAgentWaitResult = ExtensionAgentSnapshot | ExtensionAgentManySnapshot;
-export type ExtensionAgentHandledResult = SubagentHandledResult;
-export type ExtensionAgentSpawnResult = ExtensionAgentSnapshot | ExtensionAgentHandledResult;
-export declare function isHandledAgentResult(value: ExtensionAgentSpawnResult | ExtensionAgentManySnapshot): value is ExtensionAgentHandledResult;
-export interface ExtensionAgentSpawnInput {
-    readonly turnSignal?: AbortSignal;
-    readonly waitFor?: 'start' | 'completion';
-    readonly background?: boolean;
-    readonly prompt: string;
-    readonly description?: string;
-    readonly modelId?: string;
-    readonly reasoningEffort?: AgentReasoningEffort;
-    readonly role?: 'general-purpose' | 'explore';
-    readonly signal?: AbortSignal;
-}
-export interface ExtensionAgentTarget {
-    readonly agentId: string;
-    readonly signal?: AbortSignal;
-}
-export interface ExtensionAgentWaitInput {
-    readonly untilSettled?: true;
-    readonly agentId?: string;
-    readonly agentIds?: readonly string[];
-    readonly mode?: 'any' | 'all';
-    readonly signal?: AbortSignal;
-    readonly waitMs?: number;
-    readonly waitFor?: 'completion' | 'message';
-}
-export interface ExtensionAgentMessageInput extends ExtensionAgentTarget {
-    readonly message: string;
-    readonly delivery?: 'append' | 'replace';
-}
-export interface ExtensionAgentsBackend {
-    own(ownerInstanceId: string): () => Promise<void>;
-    spawn(input: ExtensionAgentSpawnInput, call: ExtensionOperationContext): Promise<ExtensionAgentSnapshot>;
-    list(call: ExtensionOperationContext): Promise<readonly ExtensionAgentSnapshot[]>;
-    inspect(input: ExtensionAgentTarget, call: ExtensionOperationContext): Promise<ExtensionAgentSnapshot>;
-    wait(input: ExtensionAgentWaitInput, call: ExtensionOperationContext): Promise<ExtensionAgentWaitResult>;
-    message(input: ExtensionAgentMessageInput, call: ExtensionOperationContext): Promise<ExtensionAgentSnapshot>;
-    cancel(input: ExtensionAgentTarget, call: ExtensionOperationContext): Promise<ExtensionAgentSnapshot>;
-}
-export interface ExtensionAgentsApi {
-    spawn(input: ExtensionAgentSpawnInput): Promise<ExtensionAgentSpawnResult>;
-    list(input?: {
-        readonly signal?: AbortSignal;
-    }): Promise<readonly ExtensionAgentSnapshot[]>;
-    inspect(input: ExtensionAgentTarget): Promise<ExtensionAgentSnapshot>;
-    wait(input: ExtensionAgentWaitInput & {
-        readonly agentIds: readonly string[];
-    }): Promise<ExtensionAgentManySnapshot>;
-    wait(input: ExtensionAgentWaitInput & {
-        readonly agentIds?: undefined;
-    }): Promise<ExtensionAgentSnapshot>;
-    wait(input: ExtensionAgentWaitInput): Promise<ExtensionAgentWaitResult>;
-    message(input: ExtensionAgentMessageInput): Promise<ExtensionAgentSnapshot>;
-    cancel(input: ExtensionAgentTarget): Promise<ExtensionAgentSnapshot>;
-}
-export interface ExtensionAgentCompletion {
-    readonly operation: 'spawn' | 'wait' | 'message' | 'cancel';
-    readonly agentId: string;
-    readonly status: SubagentTaskSnapshot['status'];
-    readonly deliveryStatus?: SubagentTaskSnapshot['deliveryStatus'];
-}
-type AgentOperation = 'agent.spawn' | 'agent.wait' | 'agent.message' | 'agent.cancel';
-export type ExtensionAgentAction = <Key extends AgentOperation>(key: Key, input: DomainAgentOperations[Key]['input'], leaf: (input: DomainAgentOperations[Key]['input'], call: ExtensionOperationContext) => Promise<DomainAgentOperations[Key]['output']>) => Promise<DomainAgentOperations[Key]['output']>;
-/** All callers share one interception and authoritative leaf-completion boundary. */
-export declare function invokeCoreAgentOperation<Key extends AgentOperation>(hooks: Pick<ExtensionHooks<DomainAgentOperations, DomainAgentFacts>, 'invoke' | 'emit'>, key: Key, input: DomainAgentOperations[Key]['input'], call: ExtensionOperationContext, leaf: (input: DomainAgentOperations[Key]['input'], call: ExtensionOperationContext) => Promise<DomainAgentOperations[Key]['output']>): Promise<DomainAgentOperations[Key]['output']>;
-export declare function resolveAgentSpawn(input: ExtensionAgentSpawnInput): ExtensionAgentSpawnInput;
-export declare function agentCapabilities(capabilities: ExtensionCapabilitySnapshot, available: boolean): ExtensionCapabilitySnapshot;
-export declare function bindCoreAgents(backend: ExtensionAgentsBackend, scope: ExtensionResourceScope, run: <Value>(operation: (call: ExtensionOperationContext) => Promise<Value>, signal?: AbortSignal) => Promise<Value>, hooks: Pick<ExtensionHooks<DomainAgentOperations, DomainAgentFacts>, 'invoke' | 'emit'>): ExtensionAgentsApi;
-export interface DomainAgentOperations {
-    'agent.spawn': {
-        input: ExtensionAgentSpawnInput;
-        output: ExtensionAgentSpawnResult;
-    };
-    'agent.wait': {
-        input: ExtensionAgentWaitInput;
-        output: ExtensionAgentWaitResult;
-    };
-    'agent.message': {
-        input: ExtensionAgentMessageInput;
-        output: ExtensionAgentSnapshot;
-    };
-    'agent.cancel': {
-        input: ExtensionAgentTarget;
-        output: ExtensionAgentSnapshot;
-    };
-}
-export interface DomainAgentFacts {
-    'agent.completed': ExtensionAgentCompletion;
-}
-export {};

package/dist/extensions/agents.js

@@ -1,121 +0,0 @@
-import { AgentError } from '../error.js';
-import { parseAgentWaitTargets } from '../subagent/wait-targets.js';
-export function isHandledAgentResult(value) {
-    return 'outcome' in value && value.outcome === 'handled' && !Object.hasOwn(value, 'agentId');
-}
-/** All callers share one interception and authoritative leaf-completion boundary. */
-export function invokeCoreAgentOperation(hooks, key, input, call, leaf) {
-    return hooks.invoke(key, input, call, async (input, effective) => {
-        const result = structuredClone(await leaf(input, effective));
-        if (isHandledAgentResult(result))
-            return result;
-        const agents = Array.isArray(result.agents)
-            ? result.agents
-            : [result];
-        for (const agent of agents)
-            await hooks.emit('agent.completed', {
-                operation: key.slice('agent.'.length),
-                agentId: agent.agentId,
-                status: agent.status,
-                ...(agent.deliveryStatus === undefined ? {} : { deliveryStatus: agent.deliveryStatus })
-            }, effective);
-        return result;
-    });
-}
-export function resolveAgentSpawn(input) {
-    if (!input ||
-        typeof input !== 'object' ||
-        Array.isArray(input) ||
-        typeof input.prompt !== 'string' ||
-        !input.prompt.trim() ||
-        (input.turnSignal !== undefined && !(input.turnSignal instanceof AbortSignal)) ||
-        (input.description !== undefined &&
-            (typeof input.description !== 'string' || !input.description.trim())) ||
-        (input.modelId !== undefined && (typeof input.modelId !== 'string' || !input.modelId)) ||
-        (input.role !== undefined && input.role !== 'general-purpose' && input.role !== 'explore') ||
-        (input.background !== undefined && typeof input.background !== 'boolean') ||
-        (input.waitFor !== undefined && input.waitFor !== 'start' && input.waitFor !== 'completion') ||
-        (input.reasoningEffort !== undefined &&
-            !['low', 'medium', 'high', 'xhigh', 'max', 'ultra'].includes(input.reasoningEffort)))
-        throw invalid('Agent spawn input is invalid.');
-    return {
-        prompt: input.prompt,
-        ...(input.turnSignal === undefined ? {} : { turnSignal: input.turnSignal }),
-        ...(input.waitFor === undefined ? {} : { waitFor: input.waitFor }),
-        ...(input.background === undefined ? {} : { background: input.background }),
-        description: input.description ?? 'Extension agent',
-        ...(input.signal === undefined ? {} : { signal: input.signal }),
-        ...(input.modelId === undefined ? {} : { modelId: input.modelId }),
-        ...(input.reasoningEffort === undefined ? {} : { reasoningEffort: input.reasoningEffort }),
-        role: input.role ?? 'general-purpose'
-    };
-}
-export function agentCapabilities(capabilities, available) {
-    const values = Object.freeze(capabilities.list().filter((id) => id !== 'agents' || available));
-    return Object.freeze({ has: (id) => values.includes(id), list: () => values });
-}
-export function bindCoreAgents(backend, scope, run, hooks) {
-    scope.effect(() => backend.own(scope.instanceId));
-    const invoke = (key, input) => run((call) => invokeCoreAgentOperation(hooks, key, input, call, async (effectiveInput, effective) => {
-        let result;
-        switch (key) {
-            case 'agent.spawn':
-                result = await backend.spawn({
-                    ...resolveAgentSpawn(effectiveInput),
-                    ...(effectiveInput.turnSignal === undefined
-                        ? {}
-                        : {
-                            turnSignal: AbortSignal.any([
-                                scope.signal,
-                                effectiveInput.turnSignal
-                            ])
-                        })
-                }, effective);
-                break;
-            case 'agent.wait':
-                result = await backend.wait(effectiveInput, effective);
-                break;
-            case 'agent.message':
-                result = await backend.message(effectiveInput, effective);
-                break;
-            case 'agent.cancel':
-                result = await backend.cancel(effectiveInput, effective);
-                break;
-        }
-        return result;
-    }), input.signal);
-    const target = (input) => {
-        if (!input ||
-            typeof input !== 'object' ||
-            Array.isArray(input) ||
-            typeof input.agentId !== 'string' ||
-            !input.agentId)
-            throw invalid('Agent target is invalid.');
-        return { ...input };
-    };
-    return {
-        spawn: (input) => invoke('agent.spawn', { ...input }),
-        list: async (input = {}) => {
-            if (!input || typeof input !== 'object' || Array.isArray(input))
-                throw invalid('Agent list input is invalid.');
-            return run(async (call) => structuredClone(await backend.list(call)), input.signal);
-        },
-        inspect: async (input) => {
-            const copied = target(input);
-            return run(async (call) => structuredClone(await backend.inspect(copied, call)), copied.signal);
-        },
-        wait: (async (input) => {
-            if (!input || typeof input !== 'object' || Array.isArray(input))
-                throw invalid('Agent wait input is invalid.');
-            const selection = parseAgentWaitTargets(input);
-            return invoke('agent.wait', input.agentId === undefined
-                ? { ...input, ...selection }
-                : target(input));
-        }),
-        message: async (input) => invoke('agent.message', target(input)),
-        cancel: async (input) => invoke('agent.cancel', target(input))
-    };
-}
-function invalid(message) {
-    return new AgentError('MAR_AGENT_EXTENSION_AGENT_INPUT_INVALID', message);
-}

package/dist/runtime/context/gc-candidates-subagent.d.ts

@@ -1,6 +0,0 @@
-import { type ContextGcPlannerInput, type ContextCandidate, type CandidateSavings, type ToolGroup } from './gc-contracts.js';
-export declare function collectSubagentCandidates(input: ContextGcPlannerInput, groups: ReadonlyMap<string, ToolGroup>, existingTargets: ReadonlySet<string>, candidateSavings: CandidateSavings): {
-    eligible: ContextCandidate[];
-    protectedTokens: number;
-    retryAfterRollouts: number;
-};

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;
-}>;