@felan-ai/felan 0.1.0-alpha.3 → 0.2.0

package/dist/subagents/host.js

@@ -0,0 +1,994 @@
+import { randomUUID } from 'node:crypto';
+import { mkdir, readFile } from 'node:fs/promises';
+import { HostAgentRuntime, SessionManager, createAgentCoreSession, } from '@felan-ai/agent-core';
+import { bindSubagentSession, } from '@felan-ai/ext-subagents';
+import { CURRENT_SESSION_VERSION } from '@earendil-works/pi-coding-agent';
+import { createLocalExtensionImporter } from '../extensions.js';
+import { loadLocalChildSystemPromptAppends } from '../system-prompt.js';
+import { discoverLocalSubagents } from './catalog.js';
+import { LocalSubagentStore } from './store.js';
+const EXT_SUBAGENTS = '@felan-ai/ext-subagents';
+const MAX_RESULT_BYTES = 256 * 1024;
+export class LocalSubagentHost {
+    descriptors;
+    policy;
+    #manager;
+    #sessionId;
+    constructor(manager, sessionId) {
+        this.#manager = manager;
+        this.#sessionId = sessionId;
+        this.descriptors = manager.descriptors;
+        this.policy = manager.policy;
+    }
+    static async create(options) {
+        const definitions = await discoverLocalSubagents(options.cwd, options.agentDir);
+        const manager = await LocalSubagentManager.create(options, definitions);
+        return new LocalSubagentHost(manager, options.sessionId);
+    }
+    attachParent(port) {
+        return this.#manager.attachParent(this.#sessionId, port);
+    }
+    spawn(request, signal) {
+        return this.#manager.spawn(this.#sessionId, request, signal);
+    }
+    list(options) {
+        return this.#manager.list(this.#sessionId, options);
+    }
+    getResult(agentId, options, signal) {
+        return this.#manager.getResult(this.#sessionId, agentId, options, signal);
+    }
+    steer(agentId, message) {
+        return this.#manager.steer(this.#sessionId, agentId, message);
+    }
+    cancel(agentId, reason) {
+        return this.#manager.cancel(this.#sessionId, agentId, reason);
+    }
+    subscribe(listener) {
+        return this.#manager.subscribe(listener);
+    }
+    async shutdown() {
+        await this.#manager.shutdown();
+    }
+}
+export class LocalSubagentManager {
+    definitions;
+    descriptors;
+    policy;
+    #options;
+    #store;
+    #children = new Map();
+    #ports = new Map();
+    #jobs = new Map();
+    #queue = [];
+    #listeners = new Set();
+    #deliveries = new Map();
+    #concurrency;
+    #maxDepth;
+    #active = 0;
+    #closed = false;
+    #save = Promise.resolve();
+    #control = Promise.resolve();
+    #shutdown;
+    constructor(options, definitions) {
+        this.#options = options;
+        this.definitions = new Map(definitions.map((definition) => [definition.descriptor.id, definition]));
+        this.descriptors = Object.freeze(definitions.map((definition) => definition.descriptor));
+        this.#concurrency = boundedInteger(options.settings?.concurrency, 4, 1, 32);
+        this.#maxDepth = boundedInteger(options.settings?.maxDepth, 3, 1, 10);
+        this.policy = Object.freeze({
+            maxPromptBytes: 128 * 1024,
+            maxDescriptionBytes: 512,
+            maxSteerBytes: 32 * 1024,
+        });
+        this.#store = new LocalSubagentStore(options.agentDir, options.sessionId);
+    }
+    static async create(options, definitions) {
+        const manager = new LocalSubagentManager(options, definitions);
+        const loaded = await manager.#store.load();
+        let reconciled = false;
+        for (const stored of loaded) {
+            const child = fromStored(stored);
+            if (child.record.status === 'queued' || child.record.status === 'running') {
+                child.record = terminalRecord(child.record, 'cancelled', {
+                    code: 'host_unavailable',
+                    message: 'Local subagent was interrupted when the previous Felan process exited',
+                });
+                child.completionPending = child.deliveryId !== undefined;
+                reconciled = true;
+            }
+            manager.#children.set(child.record.agentId, child);
+        }
+        if (reconciled)
+            await manager.#persist();
+        return manager;
+    }
+    attachParent(sessionId, port) {
+        this.#ports.set(sessionId, port);
+        const replay = setTimeout(() => {
+            this.#deliverPending(sessionId).catch(() => { });
+        }, 0);
+        replay.unref();
+        return () => {
+            clearTimeout(replay);
+            if (this.#ports.get(sessionId) === port)
+                this.#ports.delete(sessionId);
+        };
+    }
+    async spawn(parentSessionId, request, signal) {
+        if (this.#closed)
+            return failure('host_unavailable', 'Local subagent host is closed');
+        if (signal?.aborted)
+            return failure('invalid_request', 'Subagent startup was aborted');
+        if (byteLength(request.prompt) > this.policy.maxPromptBytes
+            || byteLength(request.description) > this.policy.maxDescriptionBytes) {
+            return failure('invalid_request', 'Subagent prompt or description exceeds local policy');
+        }
+        if (request.maxTurns !== undefined && (!Number.isInteger(request.maxTurns) || request.maxTurns < 1 || request.maxTurns > 100)) {
+            return failure('invalid_request', 'maxTurns must be an integer from 1 to 100');
+        }
+        if (request.timeoutSeconds !== undefined
+            && (!Number.isInteger(request.timeoutSeconds) || request.timeoutSeconds < 1 || request.timeoutSeconds > 86_400)) {
+            return failure('invalid_request', 'timeoutSeconds must be an integer from 1 to 86400');
+        }
+        const definition = this.definitions.get(request.type);
+        if (!definition)
+            return failure('unknown_agent_type', `Unknown subagent type: ${request.type}`);
+        const resolvedModel = this.#resolveModel(request.model, definition.descriptor.defaultModel);
+        if (!resolvedModel.ok)
+            return resolvedModel;
+        if (!this.#supportsThinking(resolvedModel.value, request.thinking)) {
+            return failure('unsupported_thinking', 'The resolved model does not support the requested thinking level');
+        }
+        const normalizedRequest = {
+            ...request,
+            ...(resolvedModel.value === undefined ? {} : { model: resolvedModel.value }),
+        };
+        const admitted = await this.#serializeControl(async () => {
+            if (this.#closed)
+                return failure('host_unavailable', 'Local subagent host is closed');
+            if (signal?.aborted)
+                return failure('invalid_request', 'Subagent startup was aborted');
+            const context = this.#sessionContext(parentSessionId);
+            if (!context)
+                return failure('parent_unavailable', 'Parent subagent is unavailable');
+            if (context.depth >= this.#maxDepth) {
+                return failure('depth_exceeded', 'Maximum local subagent depth reached');
+            }
+            if (request.inheritContext && !this.#ports.has(parentSessionId)) {
+                return failure('parent_unavailable', 'Parent context is unavailable');
+            }
+            const parent = context.child;
+            const parentJob = this.#jobs.get(parentSessionId);
+            if (parent
+                && (isTerminal(parent.record.status) || parentJob?.terminalStatus !== undefined)) {
+                return failure('parent_unavailable', 'Parent subagent is no longer active');
+            }
+            if (parent
+                && !this.definitions.get(parent.record.type)?.descriptor.allowNesting) {
+                return failure('depth_exceeded', `${parent.record.type} does not allow nested subagents`);
+            }
+            if (!request.runInBackground && this.#active >= this.#concurrency) {
+                return failure('capacity_unavailable', 'Foreground capacity is unavailable; retry in background');
+            }
+            let initialMessage;
+            try {
+                initialMessage = await this.#initialMessage(parentSessionId, normalizedRequest);
+            }
+            catch {
+                return failure('parent_unavailable', 'Parent context could not be captured');
+            }
+            if (this.#closed)
+                return failure('host_unavailable', 'Local subagent host is closed');
+            if (signal?.aborted)
+                return failure('invalid_request', 'Subagent startup was aborted');
+            const agentId = randomUUID();
+            const now = new Date().toISOString();
+            const record = {
+                agentId,
+                parentSessionId,
+                rootSessionId: context.rootSessionId,
+                type: request.type,
+                description: request.description,
+                status: 'queued',
+                createdAt: now,
+            };
+            const child = {
+                record,
+                request: normalizedRequest,
+                depth: context.depth + 1,
+                ...(request.runInBackground ? { deliveryId: randomUUID() } : {}),
+                completionPending: false,
+            };
+            const job = this.#job(child, initialMessage);
+            if (!request.runInBackground) {
+                job.slotHeld = true;
+                this.#active += 1;
+            }
+            this.#children.set(agentId, child);
+            this.#jobs.set(agentId, job);
+            try {
+                await this.#persist();
+            }
+            catch {
+                this.#children.delete(agentId);
+                this.#jobs.delete(agentId);
+                if (job.slotHeld) {
+                    job.slotHeld = false;
+                    this.#active -= 1;
+                }
+                return failure('host_unavailable', 'Local subagent startup could not be persisted');
+            }
+            if (signal?.aborted) {
+                this.#children.delete(agentId);
+                this.#jobs.delete(agentId);
+                if (job.slotHeld) {
+                    job.slotHeld = false;
+                    this.#active -= 1;
+                }
+                await this.#persist();
+                return failure('invalid_request', 'Subagent startup was aborted');
+            }
+            this.#emit();
+            return success({ child, job });
+        });
+        if (!admitted.ok)
+            return admitted;
+        const { child, job } = admitted.value;
+        if (request.runInBackground) {
+            const queued = cloneRecord(child.record);
+            this.#queue.push(job);
+            this.#drain();
+            return success(queued);
+        }
+        const abortForeground = () => {
+            this.#cancelTree(child.record.agentId, 'Subagent was cancelled').catch(() => { });
+        };
+        const running = this.#start(job);
+        signal?.addEventListener('abort', abortForeground, { once: true });
+        if (signal?.aborted)
+            abortForeground();
+        try {
+            await running;
+        }
+        finally {
+            signal?.removeEventListener('abort', abortForeground);
+        }
+        return success(await this.#resultRecord(child));
+    }
+    async list(parentSessionId, options) {
+        return this.#serializeControl(async () => {
+            if (!this.#sessionContext(parentSessionId))
+                return failure('parent_unavailable', 'Parent subagent is unavailable');
+            const direct = new Set([parentSessionId]);
+            if (options.includeDescendants) {
+                let changed = true;
+                while (changed) {
+                    changed = false;
+                    for (const child of this.#latestChildren()) {
+                        if (direct.has(child.record.parentSessionId) && !direct.has(child.record.agentId)) {
+                            direct.add(child.record.agentId);
+                            changed = true;
+                        }
+                    }
+                }
+            }
+            const records = this.#latestChildren()
+                .filter((child) => direct.has(child.record.parentSessionId))
+                .map((child) => cloneRecord(child.record))
+                .sort((left, right) => left.createdAt.localeCompare(right.createdAt));
+            return success(records);
+        });
+    }
+    async getResult(parentSessionId, agentId, options, signal) {
+        const authorized = await this.#serializeControl(async () => this.#directChild(parentSessionId, agentId));
+        if (!authorized.ok)
+            return authorized;
+        let child = authorized.value;
+        if (options.wait && !isTerminal(child.record.status)) {
+            await this.#wait(agentId, options.timeoutSeconds ?? 3_600, signal);
+            const refreshed = await this.#serializeControl(async () => this.#directChild(parentSessionId, agentId));
+            if (!refreshed.ok)
+                return refreshed;
+            child = refreshed.value;
+        }
+        return success(await this.#resultRecord(child));
+    }
+    async steer(parentSessionId, agentId, message) {
+        const prepared = await this.#serializeControl(async () => {
+            if (this.#closed)
+                return failure('host_unavailable', 'Local subagent host is closed');
+            const authorized = this.#directChild(parentSessionId, agentId);
+            if (!authorized.ok)
+                return authorized;
+            const child = authorized.value;
+            if (child.record.status === 'queued' || child.record.status === 'running') {
+                const steered = await this.#steerActive(child, message);
+                return steered.ok ? success({ kind: 'active', child: steered.value }) : steered;
+            }
+            if (child.record.status !== 'completed' || !child.sessionFile) {
+                return failure('not_steerable', 'Only retained completed subagents can be continued');
+            }
+            return success({
+                kind: 'completed',
+                child,
+                sessionFile: child.sessionFile,
+                deliveryId: child.completionPending ? child.deliveryId : undefined,
+            });
+        });
+        if (!prepared.ok)
+            return prepared;
+        if (prepared.value.kind === 'active')
+            return success(cloneRecord(prepared.value.child.record));
+        const completion = prepared.value;
+        try {
+            await preflightSessionFile(completion.sessionFile, agentId);
+        }
+        catch {
+            return failure('not_steerable', 'The retained subagent session is unavailable');
+        }
+        if (completion.deliveryId) {
+            await this.#deliver(completion.child, completion.deliveryId).catch(() => { });
+        }
+        const continued = await this.#serializeControl(async () => {
+            if (this.#closed)
+                return failure('host_unavailable', 'Local subagent host is closed');
+            const authorized = this.#directChild(parentSessionId, agentId);
+            if (!authorized.ok)
+                return authorized;
+            const child = authorized.value;
+            if (child.sessionFile !== completion.sessionFile) {
+                return failure('not_steerable', 'The retained subagent session changed before continuation');
+            }
+            if (child.record.status === 'queued' || child.record.status === 'running') {
+                const steered = await this.#steerActive(child, message);
+                return steered.ok ? success({ child: steered.value, job: undefined }) : steered;
+            }
+            if (child.record.status !== 'completed') {
+                return failure('not_steerable', 'The retained subagent session changed before continuation');
+            }
+            if (child.completionPending) {
+                return failure('not_steerable', 'The previous subagent completion is still pending delivery');
+            }
+            const previousRecord = child.record;
+            const previousDeliveryId = child.deliveryId;
+            const previousCompletionPending = child.completionPending;
+            child.record = {
+                agentId: child.record.agentId,
+                parentSessionId: child.record.parentSessionId,
+                rootSessionId: child.record.rootSessionId,
+                type: child.record.type,
+                description: child.record.description,
+                status: 'queued',
+                createdAt: child.record.createdAt,
+            };
+            child.deliveryId = randomUUID();
+            child.completionPending = false;
+            const job = this.#job(child, message);
+            this.#jobs.set(agentId, job);
+            try {
+                await this.#persist();
+            }
+            catch {
+                this.#jobs.delete(agentId);
+                child.record = previousRecord;
+                child.completionPending = previousCompletionPending;
+                if (previousDeliveryId === undefined)
+                    delete child.deliveryId;
+                else
+                    child.deliveryId = previousDeliveryId;
+                return failure('host_unavailable', 'Subagent continuation could not be persisted');
+            }
+            this.#queue.push(job);
+            this.#emit();
+            return success({ child, job });
+        });
+        if (!continued.ok)
+            return continued;
+        if (continued.value.job)
+            this.#drain();
+        return success(cloneRecord(continued.value.child.record));
+    }
+    async cancel(parentSessionId, agentId, reason = 'Cancelled by parent') {
+        const authorized = this.#directChild(parentSessionId, agentId);
+        if (!authorized.ok)
+            return authorized;
+        await this.#cancelTree(agentId, reason);
+        return success(cloneRecord(this.#latest(agentId).record));
+    }
+    subscribe(listener) {
+        this.#listeners.add(listener);
+        listener(this.#latestChildren().map(localView));
+        return () => this.#listeners.delete(listener);
+    }
+    async shutdown() {
+        this.#shutdown ??= this.#performShutdown();
+        await this.#shutdown;
+    }
+    async #performShutdown() {
+        this.#closed = true;
+        await this.#serializeControl(async () => { });
+        for (const child of this.#latestChildren()) {
+            if (!isTerminal(child.record.status))
+                await this.#cancelTree(child.record.agentId, 'Local host exited');
+        }
+        await Promise.allSettled(this.#deliveries.values());
+        await this.#save;
+    }
+    async #steerActive(child, message) {
+        const job = this.#jobs.get(child.record.agentId);
+        if (!job || job.terminalStatus) {
+            return failure('not_steerable', 'Subagent session is unavailable');
+        }
+        if (job.control)
+            await job.control.steer(message);
+        else
+            job.queuedMessages.push(message);
+        return success(child);
+    }
+    #job(child, initialMessage) {
+        return {
+            child,
+            controller: new AbortController(),
+            initialMessage,
+            waiters: [],
+            queuedMessages: [],
+            slotHeld: false,
+        };
+    }
+    #drain() {
+        this.#serializeControl(async () => {
+            while (!this.#closed && this.#active < this.#concurrency && this.#queue.length > 0) {
+                const job = this.#queue.shift();
+                if (job.child.record.status !== 'queued')
+                    continue;
+                await this.#beginRun(job);
+            }
+        }).catch(() => { });
+    }
+    async #start(job) {
+        await this.#serializeControl(() => this.#beginRun(job));
+        await job.runPromise;
+    }
+    async #beginRun(job) {
+        if (job.runPromise || job.child.record.status !== 'queued')
+            return;
+        if (!job.slotHeld) {
+            if (this.#active >= this.#concurrency) {
+                this.#queue.unshift(job);
+                return;
+            }
+            job.slotHeld = true;
+            this.#active += 1;
+        }
+        job.child.record = {
+            ...job.child.record,
+            status: 'running',
+            startedAt: new Date().toISOString(),
+        };
+        await this.#persist();
+        this.#emit();
+        job.runPromise = this.#run(job);
+    }
+    async #run(job) {
+        const child = job.child;
+        let timeout;
+        let outcome;
+        try {
+            if (child.request.timeoutSeconds) {
+                timeout = setTimeout(() => {
+                    this.#cancelTree(child.record.agentId, `Subagent timed out after ${child.request.timeoutSeconds} seconds`, 'timed_out').catch(() => { });
+                }, child.request.timeoutSeconds * 1_000);
+                timeout.unref();
+            }
+            const definition = this.definitions.get(child.record.type);
+            if (!job.controller.signal.aborted) {
+                const runner = this.#options.runChild ?? ((input) => this.#runAgentCore(input));
+                const queuedAtStart = job.queuedMessages.splice(0);
+                outcome = await runner({
+                    sessionId: child.record.agentId,
+                    depth: child.depth,
+                    subagents: new LocalSubagentHost(this, child.record.agentId),
+                    request: child.request,
+                    definition,
+                    cwd: this.#options.cwd,
+                    signal: job.controller.signal,
+                    initialMessage: [job.initialMessage, ...queuedAtStart].join('\n\n'),
+                    onReady: async (control) => {
+                        job.control = control;
+                        if (job.terminalStatus)
+                            this.#cancelControl(job);
+                        await job.cancelPromise;
+                        if (job.terminalStatus)
+                            return;
+                        const pending = job.queuedMessages.splice(0);
+                        for (const message of pending)
+                            await control.steer(message);
+                    },
+                    ...(child.sessionFile === undefined ? {} : { sessionFile: child.sessionFile }),
+                });
+            }
+            await job.cancelPromise;
+            outcome ??= {};
+        }
+        catch {
+            await job.cancelPromise;
+            outcome = { error: { code: 'internal_error', message: 'Local subagent failed unexpectedly' } };
+        }
+        finally {
+            if (timeout)
+                clearTimeout(timeout);
+            await this.#serializeControl(async () => {
+                if (outcome?.sessionFile)
+                    child.sessionFile = outcome.sessionFile;
+                if (job.terminalStatus) {
+                    child.record = terminalRecord(child.record, job.terminalStatus, job.terminalError);
+                }
+                else if (outcome?.turnLimitReached) {
+                    child.record = terminalRecord(child.record, 'cancelled', {
+                        code: 'turn_limit_reached',
+                        message: `Subagent reached its ${child.request.maxTurns} turn limit`,
+                    });
+                }
+                else if (outcome?.error) {
+                    child.record = terminalRecord(child.record, 'failed', outcome.error);
+                }
+                else {
+                    child.record = {
+                        ...terminalRecord(child.record, 'completed'),
+                        result: boundResult(outcome?.result ?? ''),
+                    };
+                }
+                if (job.slotHeld) {
+                    job.slotHeld = false;
+                    this.#active -= 1;
+                }
+                this.#jobs.delete(child.record.agentId);
+                if (child.deliveryId)
+                    child.completionPending = true;
+                await this.#persist();
+                this.#notify(job);
+                this.#emit();
+            });
+            if (child.deliveryId)
+                await this.#deliver(child, child.deliveryId);
+            this.#drain();
+        }
+    }
+    #requestCancellation(job, status, error) {
+        if (job.terminalStatus || isTerminal(job.child.record.status))
+            return;
+        job.terminalStatus = status;
+        job.terminalError = error;
+        job.controller.abort();
+        this.#cancelControl(job);
+    }
+    #cancelControl(job) {
+        if (!job.control || job.cancelPromise)
+            return;
+        job.cancelPromise = job.control.cancel().catch(() => { });
+    }
+    async #runAgentCore(input) {
+        await mkdir(this.#store.sessionDirectory(), { recursive: true });
+        if (input.signal.aborted)
+            return {};
+        const sessionManager = input.sessionFile
+            ? SessionManager.open(input.sessionFile, this.#store.sessionDirectory(), input.cwd)
+            : SessionManager.create(input.cwd, this.#store.sessionDirectory(), { id: input.sessionId });
+        const model = input.request.model ? this.#exactModel(input.request.model) : undefined;
+        if (input.request.model && !model) {
+            return { error: { code: 'unsupported_model', message: 'The requested model is unavailable' } };
+        }
+        const canNest = input.definition.descriptor.allowNesting && input.depth < this.#maxDepth;
+        const extensionPackages = canNest
+            ? this.#options.extensionPackages
+            : this.#options.extensionPackages.filter((packageName) => packageName !== EXT_SUBAGENTS);
+        if (input.signal.aborted)
+            return {};
+        const appendSystemPrompt = await loadLocalChildSystemPromptAppends(this.#options.agentDir, input.definition.prompt);
+        const created = await createAgentCoreSession({
+            runtime: this.#options.runtimeFactory?.(input.cwd) ?? new HostAgentRuntime(input.cwd),
+            extensionPackages,
+            importExtension: createLocalExtensionImporter(input.subagents, this.#options.importExtension),
+            modelRuntime: this.#options.modelRuntime,
+            settingsManager: this.#options.settingsManager,
+            sessionManager,
+            appendSystemPrompt,
+            ...(this.#options.skillPaths === undefined ? {} : { skillPaths: this.#options.skillPaths }),
+            ...(model === undefined ? {} : { model }),
+            ...(input.request.thinking === undefined ? {} : { thinkingLevel: input.request.thinking }),
+        });
+        bindSubagentSession({ host: input.subagents, session: created.session });
+        try {
+            if (input.signal.aborted)
+                return sessionFileOutcome(created.session.sessionFile);
+            if (input.definition.capability === 'read-only') {
+                created.session.setActiveToolsByName(created.session.getActiveToolNames().filter((name) => !['bash', 'edit', 'write'].includes(name)));
+            }
+            await created.session.bindExtensions({ mode: 'print' });
+            if (input.signal.aborted)
+                return sessionFileOutcome(created.session.sessionFile);
+            let turns = 0;
+            let turnLimitReached = false;
+            let cancellation;
+            const cancel = () => {
+                cancellation ??= created.session.abort();
+                return cancellation;
+            };
+            const unsubscribe = created.session.subscribe((event) => {
+                if (event.type !== 'turn_end')
+                    return;
+                turns += 1;
+                if (input.request.maxTurns
+                    && turns >= input.request.maxTurns
+                    && event.message.role === 'assistant'
+                    && event.message.stopReason !== 'stop') {
+                    turnLimitReached = true;
+                    cancel().catch(() => { });
+                }
+            });
+            const abort = () => {
+                cancel().catch(() => { });
+            };
+            input.signal.addEventListener('abort', abort, { once: true });
+            try {
+                if (input.signal.aborted) {
+                    await cancel();
+                    return sessionFileOutcome(created.session.sessionFile);
+                }
+                await input.onReady({
+                    steer: (message) => created.session.steer(message),
+                    cancel,
+                });
+                if (input.signal.aborted) {
+                    await cancel();
+                    return sessionFileOutcome(created.session.sessionFile);
+                }
+                await created.session.prompt(input.initialMessage);
+                await cancellation;
+                const assistant = [...created.session.messages].reverse().find((message) => message.role === 'assistant');
+                if (!assistant) {
+                    return {
+                        error: { code: 'internal_error', message: 'Subagent completed without an assistant response' },
+                        ...sessionFileOutcome(created.session.sessionFile),
+                    };
+                }
+                if (assistant.stopReason === 'error') {
+                    return {
+                        error: { code: 'internal_error', message: 'Subagent model request failed' },
+                        ...sessionFileOutcome(created.session.sessionFile),
+                    };
+                }
+                const result = assistant.content
+                    .filter((part) => part.type === 'text')
+                    .map((part) => part.text)
+                    .join('\n');
+                return {
+                    result,
+                    ...sessionFileOutcome(created.session.sessionFile),
+                    ...(turnLimitReached ? { turnLimitReached: true } : {}),
+                };
+            }
+            finally {
+                input.signal.removeEventListener('abort', abort);
+                await cancellation;
+                unsubscribe();
+            }
+        }
+        finally {
+            created.session.dispose();
+        }
+    }
+    #resolveModel(selector, defaultModel) {
+        const value = selector ?? defaultModel;
+        if (!value)
+            return success(undefined);
+        if (value === 'inherit') {
+            return failure('unsupported_model', 'Parent model is unavailable');
+        }
+        const model = this.#exactModel(value);
+        return model && this.#options.modelRuntime.hasConfiguredAuth(model.provider)
+            ? success(`${model.provider}/${model.id}`)
+            : failure('unsupported_model', 'The requested model is unavailable or unauthenticated');
+    }
+    #supportsThinking(modelReference, thinking) {
+        if (thinking === undefined || thinking === 'off')
+            return true;
+        if (!modelReference)
+            return false;
+        const model = this.#exactModel(modelReference);
+        if (!model?.reasoning)
+            return false;
+        const mapped = model.thinkingLevelMap?.[thinking];
+        return thinking === 'xhigh' || thinking === 'max'
+            ? mapped !== undefined && mapped !== null
+            : mapped !== null;
+    }
+    #exactModel(reference) {
+        const separator = reference.indexOf('/');
+        if (separator <= 0 || separator === reference.length - 1)
+            return undefined;
+        return this.#options.modelRuntime.getModel(reference.slice(0, separator), reference.slice(separator + 1));
+    }
+    async #initialMessage(parentSessionId, request) {
+        if (!request.inheritContext)
+            return request.prompt;
+        const snapshot = await this.#ports.get(parentSessionId)?.snapshotContext({ maxBytes: 64 * 1024 });
+        if (!snapshot || snapshot.length === 0)
+            return request.prompt;
+        return `${request.prompt}\n\nParent context:\n${snapshot.map((entry) => `${entry.role}: ${entry.text}`).join('\n\n')}`;
+    }
+    #directChild(parentSessionId, agentId) {
+        const child = this.#children.get(agentId);
+        if (!child)
+            return failure('not_found', `Subagent not found: ${agentId}`);
+        if (child.record.parentSessionId !== parentSessionId) {
+            return failure('not_child', 'The subagent is not a direct child of this session');
+        }
+        return success(child);
+    }
+    #sessionContext(sessionId) {
+        if (sessionId === this.#options.sessionId) {
+            return { rootSessionId: sessionId, depth: 0 };
+        }
+        const child = this.#children.get(sessionId);
+        if (!child)
+            return undefined;
+        return { rootSessionId: child.record.rootSessionId, depth: child.depth, child };
+    }
+    async #cancelTree(agentId, reason, status = 'cancelled') {
+        const cancellation = await this.#serializeControl(async () => {
+            const descendants = this.#latestChildren()
+                .filter((entry) => entry.record.parentSessionId === agentId && !isTerminal(entry.record.status))
+                .map((entry) => entry.record.agentId);
+            const child = this.#latest(agentId);
+            if (!child || isTerminal(child.record.status)) {
+                return { descendants, cleanup: Promise.resolve(), deliveryId: undefined };
+            }
+            const job = this.#jobs.get(agentId);
+            if (child.record.status === 'queued') {
+                const queueIndex = job ? this.#queue.indexOf(job) : -1;
+                if (queueIndex >= 0)
+                    this.#queue.splice(queueIndex, 1);
+                job?.controller.abort();
+                if (job?.slotHeld) {
+                    job.slotHeld = false;
+                    this.#active -= 1;
+                }
+                child.record = terminalRecord(child.record, status, {
+                    code: 'host_unavailable',
+                    message: reason,
+                });
+                if (child.deliveryId)
+                    child.completionPending = true;
+                this.#jobs.delete(agentId);
+                await this.#persist();
+                if (job)
+                    this.#notify(job);
+                this.#emit();
+                return { descendants, cleanup: Promise.resolve(), deliveryId: child.deliveryId };
+            }
+            if (!job)
+                return { descendants, cleanup: Promise.resolve(), deliveryId: undefined };
+            this.#requestCancellation(job, status, {
+                code: 'host_unavailable',
+                message: reason,
+            });
+            return { descendants, cleanup: job.runPromise ?? Promise.resolve(), deliveryId: undefined };
+        });
+        await Promise.all(cancellation.descendants.map((childId) => this.#cancelTree(childId, reason, status)));
+        await cancellation.cleanup;
+        if (cancellation.deliveryId) {
+            const child = this.#latest(agentId);
+            if (child)
+                await this.#deliver(child, cancellation.deliveryId);
+            this.#drain();
+        }
+    }
+    async #wait(agentId, timeoutSeconds, signal) {
+        const job = this.#jobs.get(agentId);
+        if (!job || isTerminal(job.child.record.status) || signal?.aborted)
+            return;
+        await new Promise((resolve) => {
+            let timeout;
+            const finish = () => {
+                if (timeout)
+                    clearTimeout(timeout);
+                signal?.removeEventListener('abort', finish);
+                resolve();
+            };
+            job.waiters.push(finish);
+            signal?.addEventListener('abort', finish, { once: true });
+            if (timeoutSeconds)
+                timeout = setTimeout(finish, timeoutSeconds * 1_000);
+        });
+    }
+    #notify(job) {
+        for (const waiter of job.waiters.splice(0))
+            waiter();
+    }
+    async #deliver(child, deliveryId) {
+        if (!child.completionPending || child.deliveryId !== deliveryId)
+            return;
+        const existing = this.#deliveries.get(deliveryId);
+        if (existing)
+            return existing;
+        const notice = completionNotice(child.record, deliveryId);
+        const delivery = (async () => {
+            const port = this.#ports.get(child.record.parentSessionId);
+            if (!port)
+                return;
+            const outcome = await port.deliverCompletion(notice);
+            if (outcome === 'delivered') {
+                await this.#serializeControl(async () => {
+                    if (child.deliveryId !== deliveryId)
+                        return;
+                    child.completionPending = false;
+                    await this.#persist();
+                });
+            }
+            else if (outcome === 'queued' && !this.#closed) {
+                const retry = setTimeout(() => {
+                    this.#deliver(child, deliveryId).catch(() => { });
+                }, 10);
+                retry.unref();
+            }
+        })();
+        this.#deliveries.set(deliveryId, delivery);
+        try {
+            await delivery;
+        }
+        finally {
+            if (this.#deliveries.get(deliveryId) === delivery)
+                this.#deliveries.delete(deliveryId);
+        }
+    }
+    async #deliverPending(parentSessionId) {
+        const children = [...this.#children.values()]
+            .filter((child) => child.record.parentSessionId === parentSessionId && child.completionPending);
+        for (const child of children) {
+            if (child.deliveryId)
+                await this.#deliver(child, child.deliveryId);
+        }
+    }
+    #latest(agentId) {
+        return this.#children.get(agentId);
+    }
+    #latestChildren() {
+        return [...this.#children.values()];
+    }
+    #emit() {
+        const records = this.#latestChildren().map(localView);
+        for (const listener of this.#listeners)
+            listener(records);
+    }
+    async #persist() {
+        const snapshot = [...this.#children.values()].map(toStored);
+        this.#save = this.#save.then(() => this.#store.save(snapshot));
+        await this.#save;
+    }
+    async #serializeControl(operation) {
+        const previous = this.#control;
+        let release;
+        this.#control = new Promise((resolve) => {
+            release = resolve;
+        });
+        await previous;
+        try {
+            return await operation();
+        }
+        finally {
+            release();
+        }
+    }
+    async #resultRecord(child) {
+        const record = cloneRecord(child.record);
+        if (record.status !== 'completed' || !child.sessionFile || !record.completedAt)
+            return record;
+        try {
+            const result = await finalAssistantText(child.sessionFile, record.completedAt);
+            return result === undefined ? record : { ...record, result };
+        }
+        catch {
+            return record;
+        }
+    }
+}
+function completionNotice(record, deliveryId) {
+    return {
+        deliveryId,
+        parentSessionId: record.parentSessionId,
+        agentId: record.agentId,
+        type: record.type,
+        status: record.status,
+        ...(record.result === undefined ? {} : { summary: record.result.slice(0, 4_000) }),
+        ...(record.error === undefined ? {} : { error: record.error }),
+    };
+}
+function terminalRecord(record, status, error) {
+    return {
+        ...record,
+        status,
+        completedAt: new Date().toISOString(),
+        ...(error === undefined ? {} : { error }),
+    };
+}
+function isTerminal(status) {
+    return status === 'completed' || status === 'failed' || status === 'timed_out' || status === 'cancelled';
+}
+function success(value) {
+    return { ok: true, value };
+}
+function failure(code, message) {
+    return { ok: false, error: { code, message } };
+}
+function cloneRecord(record) {
+    return structuredClone(record);
+}
+function localView(child) {
+    return cloneRecord(child.record);
+}
+function fromStored(stored) {
+    return structuredClone(stored);
+}
+function toStored(child) {
+    return structuredClone(child);
+}
+function boundedInteger(value, fallback, minimum, maximum) {
+    return value === undefined || !Number.isInteger(value)
+        ? fallback
+        : Math.max(minimum, Math.min(maximum, value));
+}
+function boundResult(result) {
+    const bytes = Buffer.from(result);
+    return bytes.byteLength <= MAX_RESULT_BYTES
+        ? result
+        : `${new TextDecoder().decode(bytes.subarray(0, MAX_RESULT_BYTES))}\n[truncated]`;
+}
+function byteLength(value) {
+    return Buffer.byteLength(value);
+}
+function sessionFileOutcome(sessionFile) {
+    return sessionFile === undefined ? {} : { sessionFile };
+}
+async function preflightSessionFile(sessionFile, expectedSessionId) {
+    const contents = await readFile(sessionFile, 'utf8');
+    let header;
+    for (const line of contents.split('\n')) {
+        if (!line.trim())
+            continue;
+        const entry = JSON.parse(line);
+        header ??= entry;
+    }
+    if (typeof header !== 'object'
+        || header === null
+        || Reflect.get(header, 'type') !== 'session'
+        || Reflect.get(header, 'version') !== CURRENT_SESSION_VERSION
+        || Reflect.get(header, 'id') !== expectedSessionId
+        || typeof Reflect.get(header, 'timestamp') !== 'string'
+        || typeof Reflect.get(header, 'cwd') !== 'string') {
+        throw new Error('Retained session file has an invalid header');
+    }
+}
+async function finalAssistantText(sessionFile, completedAt) {
+    let result;
+    for (const line of (await readFile(sessionFile, 'utf8')).split('\n')) {
+        if (!line)
+            continue;
+        const entry = JSON.parse(line);
+        if (entry.type !== 'message'
+            || entry.message?.role !== 'assistant'
+            || typeof entry.timestamp !== 'string'
+            || entry.timestamp > completedAt
+            || !Array.isArray(entry.message.content))
+            continue;
+        result = entry.message.content
+            .filter((part) => (typeof part === 'object'
+            && part !== null
+            && Reflect.get(part, 'type') === 'text'
+            && typeof Reflect.get(part, 'text') === 'string'))
+            .map((part) => part.text)
+            .join('\n');
+    }
+    return result;
+}
+//# sourceMappingURL=host.js.map