@borgee/agents-host 0.2.74 → 0.2.94

package/dist/providers/copilot/sdk-session.js

@@ -0,0 +1,981 @@
+import { accessSync, constants as fsConstants, existsSync, statSync } from 'node:fs';
+import { delimiter, extname, isAbsolute, resolve } from 'node:path';
+import { CopilotClient, RuntimeConnection, } from '@github/copilot-sdk';
+function isExecutableFile(path) {
+    if (!existsSync(path) || !statSync(path).isFile()) {
+        return false;
+    }
+    if (process.platform === 'win32') {
+        return true;
+    }
+    try {
+        accessSync(path, fsConstants.X_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function executableCandidates(command) {
+    if (process.platform !== 'win32' || extname(command)) {
+        return [command];
+    }
+    const pathExt = process.env.PATHEXT ?? '.COM;.EXE;.BAT;.CMD';
+    return pathExt
+        .split(';')
+        .filter(Boolean)
+        .map((extension) => `${command}${extension.toLowerCase()}`);
+}
+export function resolveCopilotCommandPath(command, cwd = process.cwd(), env = process.env) {
+    const trimmed = command.trim();
+    if (!trimmed) {
+        throw new Error('Copilot SDK command must not be empty');
+    }
+    if (isAbsolute(trimmed) || trimmed.includes('/') || trimmed.includes('\\')) {
+        const commandPath = isAbsolute(trimmed) ? trimmed : resolve(cwd, trimmed);
+        for (const candidate of executableCandidates(commandPath)) {
+            if (isExecutableFile(candidate)) {
+                return candidate;
+            }
+        }
+        throw new Error(`Copilot SDK command was not found: ${commandPath}`);
+    }
+    for (const rawDirectory of (env.PATH ?? '').split(delimiter)) {
+        const directory = rawDirectory.replace(/^"(.*)"$/u, '$1').trim();
+        if (!directory) {
+            continue;
+        }
+        for (const candidate of executableCandidates(resolve(directory, trimmed))) {
+            if (isExecutableFile(candidate)) {
+                return candidate;
+            }
+        }
+    }
+    throw new Error(`Copilot SDK command was not found on PATH: ${trimmed}`);
+}
+export function createCopilotSdkRuntimeConnection(commandPath) {
+    if (process.platform === 'win32' && /\.(?:cmd|bat)$/iu.test(commandPath)) {
+        const commandProcessor = process.env.ComSpec ?? process.env.COMSPEC;
+        if (!commandProcessor) {
+            throw new Error('Copilot SDK requires ComSpec to launch a Windows command shim');
+        }
+        return RuntimeConnection.forStdio({
+            path: commandProcessor,
+            args: ['/d', '/s', '/c', 'call', commandPath],
+        });
+    }
+    return RuntimeConnection.forStdio({ path: commandPath });
+}
+export const createCopilotSdkClient = (command, cwd, debug) => new CopilotClient({
+    connection: createCopilotSdkRuntimeConnection(resolveCopilotCommandPath(command, cwd)),
+    workingDirectory: cwd,
+    logLevel: debug ? 'debug' : 'none',
+});
+export function createCopilotSdkSessionConfig(cwd, onPermissionRequest) {
+    return {
+        workingDirectory: cwd,
+        streaming: true,
+        includeSubAgentStreamingEvents: false,
+        onPermissionRequest,
+    };
+}
+const BACKGROUND_COMPLETION_SIGNAL_TTL_MS = 30_000;
+const MAX_BACKGROUND_COMPLETION_SIGNALS = 32;
+function normalizeError(error) {
+    return error instanceof Error ? error : new Error(String(error));
+}
+function toolKindForName(toolName) {
+    const normalized = toolName.toLowerCase();
+    if (normalized.includes('read') || normalized.includes('view')) {
+        return 'read';
+    }
+    if (normalized.includes('edit') ||
+        normalized.includes('write') ||
+        normalized.includes('create') ||
+        normalized.includes('patch')) {
+        return 'edit';
+    }
+    if (normalized.includes('search') || normalized.includes('grep') || normalized.includes('glob')) {
+        return 'search';
+    }
+    if (normalized.includes('shell') ||
+        normalized.includes('bash') ||
+        normalized.includes('powershell') ||
+        normalized.includes('terminal') ||
+        normalized.includes('execute') ||
+        normalized.includes('run')) {
+        return 'execute';
+    }
+    if (normalized.includes('fetch') || normalized.includes('http') || normalized.includes('web')) {
+        return 'fetch';
+    }
+    return 'other';
+}
+function toMessageOptions(input) {
+    if (typeof input === 'string') {
+        return { prompt: input };
+    }
+    const text = input
+        .filter((block) => block.type === 'text')
+        .map((block) => block.text)
+        .join('\n');
+    const attachments = input.flatMap((block) => {
+        if (block.type !== 'image') {
+            return [];
+        }
+        return [
+            {
+                type: 'blob',
+                data: block.data,
+                mimeType: block.mimeType,
+            },
+        ];
+    });
+    return {
+        prompt: text,
+        ...(attachments.length > 0 ? { attachments } : {}),
+    };
+}
+function sessionUpdate(update) {
+    return {
+        kind: 'session_update',
+        update,
+    };
+}
+function stopUpdate(stopReason) {
+    return {
+        kind: 'stop',
+        stopReason,
+        response: { stopReason },
+    };
+}
+function parseTimestamp(value) {
+    if (!value) {
+        return undefined;
+    }
+    const timestamp = Date.parse(value);
+    return Number.isFinite(timestamp) ? timestamp : undefined;
+}
+function isCopilotExecutionTerminal(status, waiting) {
+    return (!waiting &&
+        (status === 'idle' || status === 'completed' || status === 'failed' || status === 'cancelled'));
+}
+export function toCopilotBackgroundRunProgress(task, explicitWait, executionStartedAt) {
+    if (task.type !== 'agent' || task.executionMode !== 'background') {
+        return undefined;
+    }
+    const waiting = explicitWait && (task.status === 'running' || task.status === 'idle');
+    const state = waiting ? 'waiting' : task.status === 'idle' ? 'completed' : task.status;
+    const startedAt = executionStartedAt ?? parseTimestamp(task.activeStartedAt) ?? parseTimestamp(task.startedAt);
+    const finishedAt = state === 'running' || state === 'waiting'
+        ? undefined
+        : state === 'completed' && task.status === 'idle'
+            ? parseTimestamp(task.idleSince)
+            : parseTimestamp(task.completedAt);
+    const reason = (waiting ? explicitWait.reason : undefined) ||
+        task.error?.trim() ||
+        (task.status === 'cancelled' ? 'Cancelled' : undefined);
+    return {
+        providerRunId: task.id,
+        label: task.description?.trim() || 'Background agent',
+        state,
+        ...(startedAt !== undefined ? { startedAt } : {}),
+        ...(finishedAt !== undefined ? { finishedAt } : {}),
+        ...(reason ? { reason } : {}),
+        stopSupported: true,
+    };
+}
+export class CopilotSdkSessionAdapter {
+    session;
+    onBackgroundRun;
+    onBackgroundAgentPresenceChanged;
+    onBackgroundRunError;
+    onAutonomousReply;
+    onAutonomousTurnPresenceChanged;
+    onBackgroundTaskExecutionsChanged;
+    transport = 'sdk';
+    pendingUpdates = [];
+    updateWaiters = [];
+    unsubscribe;
+    activeTurn;
+    currentRootTurnId;
+    lastRootTurnId;
+    backgroundAgentsActive = false;
+    backgroundTaskRefresh = Promise.resolve();
+    backgroundTaskRefreshFailures = 0;
+    backgroundTaskRefreshRetry;
+    reportedBackgroundTasks = new Map();
+    autonomousTurns = new Map();
+    autonomousTurnIdByRuntimeTurnId = new Map();
+    autonomousTurnIdByInteractionId = new Map();
+    backgroundCompletionSignals = [];
+    backgroundCompletionSignalExpiry;
+    autonomousTurnPending = false;
+    backgroundTaskExecutions;
+    backgroundTaskExecutionsDirty = false;
+    backgroundWaits = new Map();
+    lastSyntheticExecutionStartedAt = 0;
+    closePromise;
+    constructor(session, onBackgroundRun, onBackgroundAgentPresenceChanged, onBackgroundRunError, onAutonomousReply, onAutonomousTurnPresenceChanged, initialBackgroundTaskExecutions = {}, onBackgroundTaskExecutionsChanged = async () => { }) {
+        this.session = session;
+        this.onBackgroundRun = onBackgroundRun;
+        this.onBackgroundAgentPresenceChanged = onBackgroundAgentPresenceChanged;
+        this.onBackgroundRunError = onBackgroundRunError;
+        this.onAutonomousReply = onAutonomousReply;
+        this.onAutonomousTurnPresenceChanged = onAutonomousTurnPresenceChanged;
+        this.onBackgroundTaskExecutionsChanged = onBackgroundTaskExecutionsChanged;
+        this.backgroundTaskExecutions = new Map(Object.entries(initialBackgroundTaskExecutions).map(([taskId, execution]) => [
+            taskId,
+            { ...execution },
+        ]));
+        this.unsubscribe = session.on((event) => this.handleEvent(event));
+    }
+    get sessionId() {
+        return this.session.sessionId;
+    }
+    async prompt(input) {
+        if (this.closePromise) {
+            throw new Error('Copilot SDK session is closed');
+        }
+        if (this.activeTurn) {
+            throw new Error('Copilot SDK session already has an active foreground turn');
+        }
+        let resolveTurn;
+        let rejectTurn;
+        const completion = new Promise((resolvePromise, rejectPromise) => {
+            resolveTurn = resolvePromise;
+            rejectTurn = rejectPromise;
+        });
+        const turn = {
+            messageIdsWithDeltas: new Set(),
+            ownedTurnIds: new Set(),
+            userMessageObserved: false,
+            aborted: false,
+            cancelRequested: false,
+            resolve: resolveTurn,
+            reject: rejectTurn,
+        };
+        this.activeTurn = turn;
+        try {
+            await this.session.send(toMessageOptions(input));
+        }
+        catch (error) {
+            if (this.activeTurn === turn) {
+                this.activeTurn = undefined;
+            }
+            turn.reject(normalizeError(error));
+        }
+        return completion;
+    }
+    nextUpdate() {
+        const queued = this.pendingUpdates.shift();
+        if (queued) {
+            return Promise.resolve(queued);
+        }
+        if (this.closePromise) {
+            return Promise.reject(new Error('Copilot SDK session is closed'));
+        }
+        return new Promise((resolvePromise, rejectPromise) => {
+            this.updateWaiters.push({
+                resolve: resolvePromise,
+                reject: rejectPromise,
+            });
+        });
+    }
+    async interruptMainTurn() {
+        const turn = this.activeTurn;
+        if (turn) {
+            turn.cancelRequested = true;
+        }
+        const result = await this.session.rpc.interruptMainTurn({ flushQueued: false });
+        return result.interrupted || (turn !== undefined && this.activeTurn === turn);
+    }
+    async cancelAllBackgroundWork() {
+        await this.backgroundTaskRefresh;
+        const hadBackgroundSignal = this.backgroundAgentsActive;
+        const taskList = await this.session.rpc.tasks.list();
+        const activeShells = taskList.tasks.filter((task) => task.type === 'shell' && (task.status === 'running' || task.status === 'idle'));
+        const [cancelledAgents, ...cancelledShells] = await Promise.all([
+            this.session.rpc.cancelAllBackgroundAgents(),
+            ...activeShells.map((task) => this.session.rpc.tasks.cancel({ id: task.id })),
+        ]);
+        return (hadBackgroundSignal ||
+            cancelledAgents > 0 ||
+            activeShells.length > 0 ||
+            cancelledShells.some((result) => result.cancelled));
+    }
+    async cancelBackgroundRun(providerRunId) {
+        const result = await this.session.rpc.tasks.cancel({ id: providerRunId });
+        return result.cancelled;
+    }
+    async hasBackgroundAgents() {
+        await this.backgroundTaskRefresh;
+        return this.backgroundAgentsActive;
+    }
+    backgroundTaskExecutionState() {
+        return Object.fromEntries([...this.backgroundTaskExecutions].map(([taskId, execution]) => [
+            taskId,
+            { ...execution },
+        ]));
+    }
+    async reconcileBackgroundTasks() {
+        this.backgroundTaskExecutionsDirty = true;
+        this.queueBackgroundTaskRefresh();
+        await this.backgroundTaskRefresh;
+    }
+    close(reason) {
+        if (!this.closePromise) {
+            if (this.backgroundTaskRefreshRetry) {
+                clearTimeout(this.backgroundTaskRefreshRetry);
+                this.backgroundTaskRefreshRetry = undefined;
+            }
+            if (this.backgroundCompletionSignalExpiry) {
+                clearTimeout(this.backgroundCompletionSignalExpiry);
+                this.backgroundCompletionSignalExpiry = undefined;
+            }
+            this.backgroundCompletionSignals.length = 0;
+            this.autonomousTurns.clear();
+            this.autonomousTurnIdByRuntimeTurnId.clear();
+            this.autonomousTurnIdByInteractionId.clear();
+            this.refreshAutonomousTurnPresence();
+            this.closePromise = (async () => {
+                this.unsubscribe();
+                this.activeTurn?.reject(reason ?? new Error('Copilot SDK session closed'));
+                this.activeTurn = undefined;
+                for (const waiter of this.updateWaiters.splice(0)) {
+                    waiter.reject(reason ?? new Error('Copilot SDK session closed'));
+                }
+                try {
+                    await this.session.rpc.shutdown({
+                        type: reason ? 'error' : 'routine',
+                        ...(reason ? { reason: reason.message } : {}),
+                    });
+                }
+                finally {
+                    await this.session.disconnect();
+                }
+            })();
+        }
+        return this.closePromise;
+    }
+    emitUpdate(update) {
+        const waiter = this.updateWaiters.shift();
+        if (waiter) {
+            waiter.resolve(update);
+            return;
+        }
+        this.pendingUpdates.push(update);
+    }
+    queueBackgroundTaskRefresh() {
+        if (this.backgroundTaskRefreshRetry) {
+            clearTimeout(this.backgroundTaskRefreshRetry);
+            this.backgroundTaskRefreshRetry = undefined;
+        }
+        this.backgroundTaskRefresh = this.backgroundTaskRefresh
+            .then(async () => {
+            if (this.closePromise) {
+                return;
+            }
+            const taskList = await this.session.rpc.tasks.list();
+            if (this.closePromise) {
+                return;
+            }
+            this.backgroundTaskRefreshFailures = 0;
+            const reportedTaskIds = new Set();
+            let hasReusableBackgroundAgents = false;
+            for (const task of taskList.tasks) {
+                const explicitWait = this.backgroundWaitFor(task.id);
+                const executionStartedAt = task.type === 'agent' && task.executionMode === 'background'
+                    ? this.resolveBackgroundExecutionStartedAt(task, explicitWait !== undefined)
+                    : undefined;
+                const run = toCopilotBackgroundRunProgress(task, explicitWait, executionStartedAt);
+                if (!run) {
+                    continue;
+                }
+                reportedTaskIds.add(run.providerRunId);
+                if (task.status === 'running' || task.status === 'idle') {
+                    hasReusableBackgroundAgents = true;
+                }
+                const fingerprint = JSON.stringify(run);
+                const previous = this.reportedBackgroundTasks.get(run.providerRunId);
+                if (previous && JSON.stringify(previous) === fingerprint) {
+                    continue;
+                }
+                this.reportedBackgroundTasks.set(run.providerRunId, run);
+                this.onBackgroundRun(run);
+            }
+            for (const [providerRunId, previous] of this.reportedBackgroundTasks) {
+                if (!reportedTaskIds.has(providerRunId)) {
+                    this.reportedBackgroundTasks.delete(providerRunId);
+                    if (this.backgroundTaskExecutions.delete(providerRunId)) {
+                        this.backgroundTaskExecutionsDirty = true;
+                    }
+                    this.backgroundWaits.delete(providerRunId);
+                    if (previous.state === 'running' || previous.state === 'waiting') {
+                        this.onBackgroundRun({
+                            ...previous,
+                            state: 'unknown',
+                            finishedAt: Date.now(),
+                            reason: 'Provider registry stopped reporting this background task before its final state was observed',
+                            stopSupported: false,
+                        });
+                    }
+                }
+            }
+            if (this.backgroundTaskExecutionsDirty) {
+                await this.onBackgroundTaskExecutionsChanged(this.backgroundTaskExecutionState());
+                this.backgroundTaskExecutionsDirty = false;
+            }
+            if (this.backgroundAgentsActive !== hasReusableBackgroundAgents) {
+                this.backgroundAgentsActive = hasReusableBackgroundAgents;
+                this.onBackgroundAgentPresenceChanged(hasReusableBackgroundAgents);
+            }
+        })
+            .catch((error) => {
+            if (this.closePromise) {
+                return;
+            }
+            this.backgroundTaskRefreshFailures += 1;
+            if (!this.backgroundAgentsActive) {
+                this.backgroundAgentsActive = true;
+                this.onBackgroundAgentPresenceChanged(true);
+            }
+            this.onBackgroundRunError(normalizeError(error));
+            const retryDelayMs = Math.min(250 * 2 ** Math.min(this.backgroundTaskRefreshFailures - 1, 4), 5_000);
+            if (this.backgroundTaskRefreshRetry) {
+                clearTimeout(this.backgroundTaskRefreshRetry);
+            }
+            const retry = setTimeout(() => {
+                if (this.backgroundTaskRefreshRetry !== retry) {
+                    return;
+                }
+                this.backgroundTaskRefreshRetry = undefined;
+                this.queueBackgroundTaskRefresh();
+            }, retryDelayMs);
+            this.backgroundTaskRefreshRetry = retry;
+        });
+    }
+    /**
+     * Completion signals and their autonomous root turns are separate SDK event
+     * streams and may arrive in either order. A short-lived signal confirms an
+     * otherwise unowned root turn; only that root turn's assistant messages are
+     * eligible for delivery outside the foreground prompt.
+     */
+    noteBackgroundCompletion(event) {
+        const kind = event.data.kind;
+        if (kind.type !== 'agent_completed' && kind.type !== 'agent_idle') {
+            return;
+        }
+        this.pruneBackgroundCompletionSignals();
+        this.backgroundCompletionSignals.push({
+            eventId: event.id,
+            providerRunId: kind.agentId,
+            expiresAt: Date.now() + BACKGROUND_COMPLETION_SIGNAL_TTL_MS,
+        });
+        if (this.backgroundCompletionSignals.length > MAX_BACKGROUND_COMPLETION_SIGNALS) {
+            this.backgroundCompletionSignals.splice(0, this.backgroundCompletionSignals.length - MAX_BACKGROUND_COMPLETION_SIGNALS);
+        }
+        if (this.currentRootTurnId
+            && !this.activeTurn?.ownedTurnIds.has(this.currentRootTurnId)) {
+            const existing = this.findAutonomousTurn(this.currentRootTurnId);
+            if (existing) {
+                existing.confirmed = true;
+            }
+            else {
+                const turn = this.createAutonomousTurn(event.id, true, this.currentRootTurnId);
+                this.bindAutonomousTurn(turn, this.currentRootTurnId);
+            }
+            this.consumeBackgroundCompletionSignal(kind.agentId);
+        }
+        this.scheduleBackgroundCompletionSignalExpiry();
+        this.refreshAutonomousTurnPresence();
+    }
+    isAutonomousCompletionMessage(event) {
+        const source = event.data.source?.trim().toLowerCase();
+        const parentTaskId = event.data.parentAgentTaskId?.trim();
+        // Foreground SDK prompts can also carry external parent-task metadata.
+        const knownBackgroundParent = parentTaskId !== undefined &&
+            (this.reportedBackgroundTasks.has(parentTaskId) ||
+                this.backgroundTaskExecutions.has(parentTaskId));
+        if (source === 'background-task' || knownBackgroundParent) {
+            return true;
+        }
+        this.pruneBackgroundCompletionSignals();
+        return event.data.isAutopilotContinuation === true && this.backgroundCompletionSignals.length > 0;
+    }
+    beginAutonomousTurn(event) {
+        const turnId = this.readUserMessageTurnId(event);
+        const interactionId = event.data.interactionId?.trim() || undefined;
+        const existing = this.findAutonomousTurn(turnId, interactionId);
+        if (existing) {
+            return existing;
+        }
+        const turn = this.createAutonomousTurn(event.id, true, turnId, interactionId);
+        this.bindAutonomousTurn(turn, turnId, interactionId);
+        this.consumeBackgroundCompletionSignal(event.data.parentAgentTaskId);
+        this.refreshAutonomousTurnPresence();
+        return turn;
+    }
+    createAutonomousTurn(eventId, confirmed, turnId, interactionId) {
+        const turn = {
+            eventId,
+            confirmed,
+            turnId,
+            interactionId,
+            messageOrder: [],
+            messageTextById: new Map(),
+            seenEventIds: new Set(),
+        };
+        this.autonomousTurns.set(eventId, turn);
+        return turn;
+    }
+    bindAutonomousTurn(turn, turnId, interactionId) {
+        if (turnId) {
+            turn.turnId = turnId;
+            this.autonomousTurnIdByRuntimeTurnId.set(turnId, turn.eventId);
+        }
+        if (interactionId) {
+            turn.interactionId = interactionId;
+            this.autonomousTurnIdByInteractionId.set(interactionId, turn.eventId);
+        }
+    }
+    findAutonomousTurn(turnId, interactionId) {
+        const eventId = ((turnId ? this.autonomousTurnIdByRuntimeTurnId.get(turnId) : undefined)
+            ?? (interactionId ? this.autonomousTurnIdByInteractionId.get(interactionId) : undefined));
+        return eventId ? this.autonomousTurns.get(eventId) : undefined;
+    }
+    consumeBackgroundCompletionSignal(providerRunId) {
+        this.pruneBackgroundCompletionSignals();
+        const index = providerRunId
+            ? this.backgroundCompletionSignals.findIndex((signal) => signal.providerRunId === providerRunId)
+            : 0;
+        if (index < 0 || this.backgroundCompletionSignals.length === 0) {
+            return undefined;
+        }
+        const [signal] = this.backgroundCompletionSignals.splice(index, 1);
+        this.scheduleBackgroundCompletionSignalExpiry();
+        return signal;
+    }
+    pruneBackgroundCompletionSignals() {
+        const now = Date.now();
+        while (this.backgroundCompletionSignals.length > 0
+            && this.backgroundCompletionSignals[0].expiresAt <= now) {
+            this.backgroundCompletionSignals.shift();
+        }
+    }
+    scheduleBackgroundCompletionSignalExpiry() {
+        if (this.backgroundCompletionSignalExpiry) {
+            clearTimeout(this.backgroundCompletionSignalExpiry);
+            this.backgroundCompletionSignalExpiry = undefined;
+        }
+        this.pruneBackgroundCompletionSignals();
+        const next = this.backgroundCompletionSignals[0];
+        if (!next) {
+            this.refreshAutonomousTurnPresence();
+            return;
+        }
+        this.backgroundCompletionSignalExpiry = setTimeout(() => {
+            this.backgroundCompletionSignalExpiry = undefined;
+            this.pruneBackgroundCompletionSignals();
+            this.scheduleBackgroundCompletionSignalExpiry();
+        }, Math.max(0, next.expiresAt - Date.now()));
+        this.backgroundCompletionSignalExpiry.unref?.();
+    }
+    refreshAutonomousTurnPresence() {
+        const pending = this.autonomousTurns.size > 0 || this.backgroundCompletionSignals.length > 0;
+        if (pending === this.autonomousTurnPending) {
+            return;
+        }
+        this.autonomousTurnPending = pending;
+        this.onAutonomousTurnPresenceChanged(pending);
+    }
+    resolveBackgroundExecutionStartedAt(task, waiting) {
+        // task.startedAt belongs to the reusable task, so only per-execution fields or
+        // an adapter-owned generation may identify a later invocation.
+        const previous = this.backgroundTaskExecutions.get(task.id);
+        const activeStartedAt = parseTimestamp(task.activeStartedAt);
+        const previousTerminal = previous?.terminal ?? false;
+        const currentTerminal = isCopilotExecutionTerminal(task.status, waiting);
+        const terminalAt = currentTerminal
+            ? task.status === 'idle'
+                ? parseTimestamp(task.idleSince)
+                : parseTimestamp(task.completedAt)
+            : undefined;
+        const activePeriodChanged = previous?.activeStartedAt !== undefined &&
+            activeStartedAt !== undefined &&
+            previous.activeStartedAt !== activeStartedAt &&
+            !previous.waiting;
+        const terminalBoundaryChanged = previousTerminal &&
+            currentTerminal &&
+            terminalAt !== undefined &&
+            previous?.terminalAt !== undefined &&
+            previous.terminalAt !== terminalAt;
+        const startsNewExecution = !previous ||
+            (previousTerminal && !currentTerminal) ||
+            activePeriodChanged ||
+            terminalBoundaryChanged;
+        let startedAt = previous?.startedAt;
+        if (startsNewExecution) {
+            const observedStartedAt = currentTerminal && (!previous || terminalBoundaryChanged)
+                ? (terminalAt ?? activeStartedAt)
+                : (activeStartedAt ?? terminalAt);
+            if (observedStartedAt !== undefined && observedStartedAt !== previous?.startedAt) {
+                startedAt = observedStartedAt;
+            }
+            else {
+                const now = Date.now();
+                startedAt = Math.max(now, this.lastSyntheticExecutionStartedAt + 1, (previous?.startedAt ?? 0) + 1);
+                this.lastSyntheticExecutionStartedAt = startedAt;
+            }
+        }
+        if (startedAt === undefined) {
+            startedAt = Math.max(Date.now(), this.lastSyntheticExecutionStartedAt + 1);
+            this.lastSyntheticExecutionStartedAt = startedAt;
+        }
+        const execution = {
+            startedAt,
+            terminal: currentTerminal,
+            waiting,
+            ...(activeStartedAt !== undefined
+                ? { activeStartedAt }
+                : !startsNewExecution && previous?.activeStartedAt !== undefined
+                    ? { activeStartedAt: previous.activeStartedAt }
+                    : {}),
+            ...(terminalAt !== undefined
+                ? { terminalAt }
+                : !startsNewExecution && previous?.terminalAt !== undefined
+                    ? { terminalAt: previous.terminalAt }
+                    : {}),
+        };
+        if (!previous ||
+            previous.startedAt !== execution.startedAt ||
+            previous.terminal !== execution.terminal ||
+            previous.waiting !== execution.waiting ||
+            previous.activeStartedAt !== execution.activeStartedAt ||
+            previous.terminalAt !== execution.terminalAt) {
+            this.backgroundTaskExecutionsDirty = true;
+        }
+        this.backgroundTaskExecutions.set(task.id, execution);
+        return execution.startedAt;
+    }
+    handleEvent(event) {
+        if (event.type === 'session.background_tasks_changed') {
+            this.queueBackgroundTaskRefresh();
+        }
+        if (event.type === 'system.notification') {
+            this.noteBackgroundCompletion(event);
+            return;
+        }
+        if (event.agentId) {
+            this.handleBackgroundAgentEvent(event, event.agentId);
+            return;
+        }
+        if (event.type === 'user.message') {
+            if (this.isAutonomousCompletionMessage(event)) {
+                this.beginAutonomousTurn(event);
+                return;
+            }
+            if (this.activeTurn &&
+                !this.activeTurn.userMessageObserved &&
+                this.isPromptUserMessage(event)) {
+                this.activeTurn.userMessageObserved = true;
+                this.activeTurn.interactionId = event.data.interactionId;
+                const wireTurnId = this.readUserMessageTurnId(event);
+                if (wireTurnId) {
+                    this.activeTurn.ownedTurnIds.add(wireTurnId);
+                }
+            }
+            return;
+        }
+        if (event.type === 'assistant.turn_start') {
+            this.currentRootTurnId = event.data.turnId;
+            this.lastRootTurnId = event.data.turnId;
+            const activeTurn = this.activeTurn;
+            const foregroundOwnsTurn = (activeTurn &&
+                activeTurn.userMessageObserved &&
+                (activeTurn.ownedTurnIds.has(event.data.turnId) ||
+                    (activeTurn.ownedTurnIds.size === 0 &&
+                        (!activeTurn.interactionId || activeTurn.interactionId === event.data.interactionId)) ||
+                    (activeTurn.interactionId !== undefined &&
+                        activeTurn.interactionId === event.data.interactionId)));
+            if (foregroundOwnsTurn) {
+                activeTurn.ownedTurnIds.add(event.data.turnId);
+                if (activeTurn.cancelRequested) {
+                    void this.interruptAttachedTurn(activeTurn);
+                }
+                return;
+            }
+            let autonomousTurn = this.findAutonomousTurn(event.data.turnId, event.data.interactionId);
+            if (!autonomousTurn) {
+                const signal = this.consumeBackgroundCompletionSignal();
+                autonomousTurn = this.createAutonomousTurn(signal?.eventId ?? `${this.sessionId}:${event.data.turnId}`, signal !== undefined, event.data.turnId, event.data.interactionId);
+            }
+            if (autonomousTurn) {
+                this.bindAutonomousTurn(autonomousTurn, event.data.turnId, event.data.interactionId);
+                this.refreshAutonomousTurnPresence();
+            }
+            return;
+        }
+        const eventTurnId = this.resolveEventTurnId(event);
+        const autonomousTurn = eventTurnId
+            ? this.findAutonomousTurn(eventTurnId)
+            : undefined;
+        if (autonomousTurn) {
+            this.handleAutonomousTurnEvent(autonomousTurn, event);
+            this.noteTurnBoundary(event, eventTurnId);
+            return;
+        }
+        const activeTurn = this.activeTurn;
+        if (!activeTurn || !eventTurnId) {
+            this.noteTurnBoundary(event, eventTurnId);
+            return;
+        }
+        if (!activeTurn.ownedTurnIds.has(eventTurnId)) {
+            this.noteTurnBoundary(event, eventTurnId);
+            return;
+        }
+        this.handleOwnedTurnEvent(event);
+        this.noteTurnBoundary(event, eventTurnId);
+    }
+    handleAutonomousTurnEvent(turn, event) {
+        if (event.type === 'assistant.message_delta') {
+            if (turn.seenEventIds.has(event.id)) {
+                return;
+            }
+            turn.seenEventIds.add(event.id);
+            if (!turn.messageTextById.has(event.data.messageId)) {
+                turn.messageOrder.push(event.data.messageId);
+            }
+            const current = turn.messageTextById.get(event.data.messageId) ?? '';
+            turn.messageTextById.set(event.data.messageId, current + event.data.deltaContent);
+            return;
+        }
+        if (event.type === 'assistant.message') {
+            if (turn.seenEventIds.has(event.id)) {
+                return;
+            }
+            turn.seenEventIds.add(event.id);
+            if (!turn.messageTextById.has(event.data.messageId)) {
+                turn.messageOrder.push(event.data.messageId);
+            }
+            turn.messageTextById.set(event.data.messageId, event.data.content);
+            return;
+        }
+        if (event.type === 'session.error') {
+            this.discardAutonomousTurn(turn);
+            return;
+        }
+        if (event.type === 'assistant.idle') {
+            this.finishAutonomousTurn(turn);
+        }
+    }
+    finishAutonomousTurn(turn) {
+        const text = turn.messageOrder
+            .map((messageId) => turn.messageTextById.get(messageId) ?? '')
+            .join('\n\n')
+            .trim();
+        try {
+            if (turn.confirmed && text) {
+                this.onAutonomousReply({ eventId: turn.eventId, text });
+            }
+        }
+        finally {
+            this.discardAutonomousTurn(turn);
+        }
+    }
+    discardAutonomousTurn(turn) {
+        this.autonomousTurns.delete(turn.eventId);
+        if (turn.turnId) {
+            this.autonomousTurnIdByRuntimeTurnId.delete(turn.turnId);
+        }
+        if (turn.interactionId) {
+            this.autonomousTurnIdByInteractionId.delete(turn.interactionId);
+        }
+        this.refreshAutonomousTurnPresence();
+    }
+    handleBackgroundAgentEvent(event, agentId) {
+        switch (event.type) {
+            case 'permission.requested':
+                if (event.data.resolvedByHook !== true) {
+                    this.recordBackgroundWait(agentId, event.data.requestId, 'Waiting for permission approval');
+                }
+                return;
+            case 'user_input.requested':
+                this.recordBackgroundWait(agentId, event.data.requestId, event.data.question.trim() || 'Waiting for user input');
+                return;
+            case 'elicitation.requested':
+                this.recordBackgroundWait(agentId, event.data.requestId, event.data.message.trim() || 'Waiting for external input');
+                return;
+            case 'exit_plan_mode.requested':
+                this.recordBackgroundWait(agentId, event.data.requestId, event.data.summary.trim() || 'Waiting for plan approval');
+                return;
+            case 'permission.completed':
+            case 'user_input.completed':
+            case 'elicitation.completed':
+            case 'exit_plan_mode.completed':
+                this.resolveBackgroundWait(agentId, event.data.requestId);
+                return;
+            case 'assistant.turn_start':
+            case 'subagent.completed':
+            case 'subagent.failed':
+                if (this.backgroundWaits.delete(agentId)) {
+                    this.queueBackgroundTaskRefresh();
+                }
+                return;
+            default:
+                return;
+        }
+    }
+    recordBackgroundWait(agentId, requestId, reason) {
+        const waits = this.backgroundWaits.get(agentId) ?? new Map();
+        waits.set(requestId, reason);
+        this.backgroundWaits.set(agentId, waits);
+        this.queueBackgroundTaskRefresh();
+    }
+    resolveBackgroundWait(agentId, requestId) {
+        const waits = this.backgroundWaits.get(agentId);
+        if (!waits?.delete(requestId)) {
+            return;
+        }
+        if (waits.size === 0) {
+            this.backgroundWaits.delete(agentId);
+        }
+        this.queueBackgroundTaskRefresh();
+    }
+    backgroundWaitFor(agentId) {
+        const waits = this.backgroundWaits.get(agentId);
+        if (!waits || waits.size === 0) {
+            return undefined;
+        }
+        const reason = [...waits.values()].at(-1);
+        return reason ? { reason } : undefined;
+    }
+    handleOwnedTurnEvent(event) {
+        if (!this.activeTurn) {
+            return;
+        }
+        switch (event.type) {
+            case 'assistant.message_delta':
+                this.activeTurn.messageIdsWithDeltas.add(event.data.messageId);
+                this.emitUpdate(sessionUpdate({
+                    sessionUpdate: 'agent_message_chunk',
+                    content: { type: 'text', text: event.data.deltaContent },
+                    messageId: event.data.messageId,
+                }));
+                return;
+            case 'assistant.reasoning_delta':
+                this.emitUpdate(sessionUpdate({
+                    sessionUpdate: 'agent_thought_chunk',
+                    content: { type: 'text', text: event.data.deltaContent },
+                    messageId: event.data.reasoningId,
+                }));
+                return;
+            case 'assistant.message':
+                if (!this.activeTurn.messageIdsWithDeltas.has(event.data.messageId)) {
+                    this.emitUpdate(sessionUpdate({
+                        sessionUpdate: 'agent_message_chunk',
+                        content: { type: 'text', text: event.data.content },
+                        messageId: event.data.messageId,
+                    }));
+                }
+                return;
+            case 'tool.execution_start':
+                this.emitUpdate(sessionUpdate({
+                    sessionUpdate: 'tool_call',
+                    toolCallId: event.data.toolCallId,
+                    title: event.data.toolDescription?.name ?? event.data.toolName,
+                    kind: toolKindForName(event.data.toolName),
+                    status: 'in_progress',
+                    rawInput: event.data.arguments,
+                }));
+                return;
+            case 'tool.execution_progress':
+                this.emitUpdate(sessionUpdate({
+                    sessionUpdate: 'tool_call_update',
+                    toolCallId: event.data.toolCallId,
+                    status: 'in_progress',
+                    rawOutput: { content: event.data.progressMessage },
+                }));
+                return;
+            case 'tool.execution_complete':
+                this.emitUpdate(sessionUpdate({
+                    sessionUpdate: 'tool_call_update',
+                    toolCallId: event.data.toolCallId,
+                    title: event.data.toolDescription?.name,
+                    status: event.data.success ? 'completed' : 'failed',
+                    rawOutput: event.data.result ?? event.data.error,
+                }));
+                return;
+            case 'abort':
+                this.activeTurn.aborted = true;
+                return;
+            case 'session.error': {
+                const turn = this.activeTurn;
+                this.activeTurn = undefined;
+                turn.reject(new Error(event.data.message));
+                return;
+            }
+            case 'assistant.idle': {
+                this.finishActiveTurn(event.data.aborted === true);
+                return;
+            }
+            default:
+                return;
+        }
+    }
+    async interruptAttachedTurn(turn) {
+        try {
+            const result = await this.session.rpc.interruptMainTurn({ flushQueued: false });
+            if (!result.interrupted && this.activeTurn === turn) {
+                throw new Error('Copilot SDK did not accept the queued foreground interrupt');
+            }
+        }
+        catch (error) {
+            if (this.activeTurn !== turn) {
+                return;
+            }
+            this.activeTurn = undefined;
+            turn.reject(normalizeError(error));
+        }
+    }
+    finishActiveTurn(aborted) {
+        const turn = this.activeTurn;
+        if (!turn) {
+            return;
+        }
+        this.activeTurn = undefined;
+        const stopReason = aborted || turn.aborted ? 'cancelled' : 'end_turn';
+        this.emitUpdate(stopUpdate(stopReason));
+        turn.resolve({ stopReason });
+    }
+    resolveEventTurnId(event) {
+        switch (event.type) {
+            case 'assistant.turn_end':
+                return event.data.turnId;
+            case 'assistant.message':
+            case 'tool.execution_start':
+            case 'tool.execution_complete':
+                return event.data.turnId ?? this.currentRootTurnId;
+            case 'assistant.idle':
+                return this.currentRootTurnId ?? this.lastRootTurnId;
+            default:
+                return this.currentRootTurnId;
+        }
+    }
+    noteTurnBoundary(event, turnId) {
+        if (event.type !== 'assistant.turn_end' || !turnId) {
+            return;
+        }
+        this.lastRootTurnId = turnId;
+        if (this.currentRootTurnId === turnId) {
+            this.currentRootTurnId = undefined;
+        }
+    }
+    isPromptUserMessage(event) {
+        return event.data.isAutopilotContinuation !== true && event.data.source === undefined;
+    }
+    readUserMessageTurnId(event) {
+        const turnId = event.data.turnId;
+        return typeof turnId === 'string' ? turnId : undefined;
+    }
+}