psadk 1.4.7 → 1.5.0

package/build/module/lib/agent-core/src/harness/agent-harness.js

@@ -0,0 +1,1028 @@
+import { streamSimple, } from '@earendil-works/pi-ai';
+import { runAgentLoop } from "../agent-loop.js";
+import { collectEntriesForBranchSummary, generateBranchSummary, } from "./compaction/branch-summarization.js";
+import { compact, DEFAULT_COMPACTION_SETTINGS, prepareCompaction, } from "./compaction/compaction.js";
+import { convertToLlm } from "./messages.js";
+import { formatPromptTemplateInvocation } from "./prompt-templates.js";
+import { formatSkillInvocation } from "./skills.js";
+import { AgentHarnessError, BranchSummaryError, CompactionError, SessionError, toError, } from "./types.js";
+function createUserMessage(text, images) {
+    const content = [
+        { type: 'text', text },
+    ];
+    if (images)
+        content.push(...images);
+    return { role: 'user', content, timestamp: Date.now() };
+}
+function createFailureMessage(model, error, aborted) {
+    return {
+        role: 'assistant',
+        content: [{ type: 'text', text: '' }],
+        api: model.api,
+        provider: model.provider,
+        model: model.id,
+        stopReason: aborted ? 'aborted' : 'error',
+        errorMessage: error instanceof Error ? error.message : String(error),
+        timestamp: Date.now(),
+        usage: {
+            input: 0,
+            output: 0,
+            cacheRead: 0,
+            cacheWrite: 0,
+            totalTokens: 0,
+            cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+        },
+    };
+}
+function cloneStreamOptions(streamOptions) {
+    return {
+        ...streamOptions,
+        headers: streamOptions?.headers ? { ...streamOptions.headers } : undefined,
+        metadata: streamOptions?.metadata
+            ? { ...streamOptions.metadata }
+            : undefined,
+    };
+}
+function mergeHeaders(...headers) {
+    const merged = {};
+    let hasHeaders = false;
+    for (const entry of headers) {
+        if (!entry)
+            continue;
+        Object.assign(merged, entry);
+        hasHeaders = true;
+    }
+    return hasHeaders ? merged : undefined;
+}
+function findDuplicateNames(names) {
+    const seen = new Set();
+    const duplicates = new Set();
+    for (const name of names) {
+        if (seen.has(name))
+            duplicates.add(name);
+        seen.add(name);
+    }
+    return [...duplicates];
+}
+function applyStreamOptionsPatch(base, patch) {
+    const result = cloneStreamOptions(base);
+    if (!patch)
+        return result;
+    if (Object.hasOwn(patch, 'transport'))
+        result.transport = patch.transport;
+    if (Object.hasOwn(patch, 'timeoutMs'))
+        result.timeoutMs = patch.timeoutMs;
+    if (Object.hasOwn(patch, 'maxRetries'))
+        result.maxRetries = patch.maxRetries;
+    if (Object.hasOwn(patch, 'maxRetryDelayMs'))
+        result.maxRetryDelayMs = patch.maxRetryDelayMs;
+    if (Object.hasOwn(patch, 'cacheRetention'))
+        result.cacheRetention = patch.cacheRetention;
+    if (Object.hasOwn(patch, 'headers')) {
+        if (patch.headers === undefined) {
+            result.headers = undefined;
+        }
+        else {
+            const headers = { ...(result.headers ?? {}) };
+            for (const [key, value] of Object.entries(patch.headers)) {
+                if (value === undefined)
+                    delete headers[key];
+                else
+                    headers[key] = value;
+            }
+            result.headers = Object.keys(headers).length > 0 ? headers : undefined;
+        }
+    }
+    if (Object.hasOwn(patch, 'metadata')) {
+        if (patch.metadata === undefined) {
+            result.metadata = undefined;
+        }
+        else {
+            const metadata = { ...(result.metadata ?? {}) };
+            for (const [key, value] of Object.entries(patch.metadata)) {
+                if (value === undefined)
+                    delete metadata[key];
+                else
+                    metadata[key] = value;
+            }
+            result.metadata = Object.keys(metadata).length > 0 ? metadata : undefined;
+        }
+    }
+    return result;
+}
+const SUBSCRIBER_EVENT_TYPE = '*';
+function normalizeHarnessError(error, fallbackCode) {
+    if (error instanceof AgentHarnessError)
+        return error;
+    const cause = toError(error);
+    if (cause instanceof SessionError)
+        return new AgentHarnessError('session', cause.message, cause);
+    if (cause instanceof CompactionError)
+        return new AgentHarnessError('compaction', cause.message, cause);
+    if (cause instanceof BranchSummaryError)
+        return new AgentHarnessError('branch_summary', cause.message, cause);
+    return new AgentHarnessError(fallbackCode, cause.message, cause);
+}
+function normalizeHookError(error) {
+    return normalizeHarnessError(error, 'hook');
+}
+export class AgentHarness {
+    env;
+    session;
+    phase = 'idle';
+    runAbortController;
+    runPromise;
+    pendingSessionWrites = [];
+    model;
+    thinkingLevel;
+    systemPrompt;
+    streamOptions;
+    getApiKeyAndHeaders;
+    resources;
+    tools = new Map();
+    activeToolNames;
+    steerQueue = [];
+    steeringQueueMode;
+    followUpQueue = [];
+    followUpQueueMode;
+    nextTurnQueue = [];
+    handlers = new Map();
+    constructor(options) {
+        this.env = options.env;
+        this.session = options.session;
+        this.resources = options.resources ?? {};
+        this.streamOptions = cloneStreamOptions(options.streamOptions);
+        this.systemPrompt = options.systemPrompt;
+        this.getApiKeyAndHeaders = options.getApiKeyAndHeaders;
+        this.validateUniqueNames((options.tools ?? []).map((tool) => tool.name), 'Duplicate tool name(s)');
+        for (const tool of options.tools ?? []) {
+            this.tools.set(tool.name, tool);
+        }
+        this.model = options.model;
+        this.thinkingLevel = options.thinkingLevel ?? 'off';
+        this.activeToolNames = options.activeToolNames
+            ? [...options.activeToolNames]
+            : (options.tools ?? []).map((tool) => tool.name);
+        this.validateUniqueNames(this.activeToolNames, 'Duplicate active tool name(s)');
+        this.validateToolNames(this.activeToolNames);
+        this.steeringQueueMode = options.steeringMode ?? 'one-at-a-time';
+        this.followUpQueueMode = options.followUpMode ?? 'one-at-a-time';
+    }
+    getHandlers(type) {
+        return this.handlers.get(type);
+    }
+    async emitOwn(event, signal) {
+        for (const listener of this.getHandlers(SUBSCRIBER_EVENT_TYPE) ?? []) {
+            try {
+                await listener(event, signal);
+            }
+            catch (error) {
+                throw normalizeHookError(error);
+            }
+        }
+    }
+    async emitAny(event, signal) {
+        for (const listener of this.getHandlers(SUBSCRIBER_EVENT_TYPE) ?? []) {
+            try {
+                await listener(event, signal);
+            }
+            catch (error) {
+                throw normalizeHookError(error);
+            }
+        }
+    }
+    async emitHook(event) {
+        const handlers = this.getHandlers(event.type);
+        if (!handlers || handlers.size === 0)
+            return undefined;
+        let lastResult;
+        for (const handler of handlers) {
+            try {
+                const result = await handler(event);
+                if (result !== undefined) {
+                    lastResult = result;
+                }
+            }
+            catch (error) {
+                throw normalizeHookError(error);
+            }
+        }
+        return lastResult;
+    }
+    async emitBeforeProviderRequest(model, sessionId, streamOptions) {
+        const handlers = this.getHandlers('before_provider_request');
+        let current = cloneStreamOptions(streamOptions);
+        if (!handlers || handlers.size === 0)
+            return current;
+        for (const handler of handlers) {
+            try {
+                const result = await handler({
+                    type: 'before_provider_request',
+                    model,
+                    sessionId,
+                    streamOptions: cloneStreamOptions(current),
+                });
+                if (result?.streamOptions) {
+                    current = applyStreamOptionsPatch(current, result.streamOptions);
+                }
+            }
+            catch (error) {
+                throw normalizeHookError(error);
+            }
+        }
+        return current;
+    }
+    async emitBeforeProviderPayload(model, payload) {
+        const handlers = this.getHandlers('before_provider_payload');
+        let current = payload;
+        if (!handlers || handlers.size === 0)
+            return current;
+        for (const handler of handlers) {
+            try {
+                const result = await handler({
+                    type: 'before_provider_payload',
+                    model,
+                    payload: current,
+                });
+                if (result !== undefined) {
+                    current = result.payload;
+                }
+            }
+            catch (error) {
+                throw normalizeHookError(error);
+            }
+        }
+        return current;
+    }
+    async emitQueueUpdate() {
+        await this.emitOwn({
+            type: 'queue_update',
+            steer: [...this.steerQueue],
+            followUp: [...this.followUpQueue],
+            nextTurn: [...this.nextTurnQueue],
+        });
+    }
+    startRunPromise() {
+        let finish = () => { };
+        this.runPromise = new Promise((resolve) => {
+            finish = resolve;
+        });
+        return () => {
+            this.runPromise = undefined;
+            finish();
+        };
+    }
+    async createTurnState() {
+        const context = await this.session.buildContext();
+        const resources = this.getResources();
+        const sessionMetadata = await this.session.getMetadata();
+        const tools = [...this.tools.values()];
+        const activeTools = this.activeToolNames
+            .map((name) => this.tools.get(name))
+            .filter((tool) => tool !== undefined);
+        let systemPrompt = 'You are a helpful assistant.';
+        if (typeof this.systemPrompt === 'string') {
+            systemPrompt = this.systemPrompt;
+        }
+        else if (this.systemPrompt) {
+            systemPrompt = await this.systemPrompt({
+                env: this.env,
+                session: this.session,
+                model: this.model,
+                thinkingLevel: this.thinkingLevel,
+                activeTools,
+                resources,
+            });
+        }
+        return {
+            messages: context.messages,
+            resources,
+            streamOptions: cloneStreamOptions(this.streamOptions),
+            sessionId: sessionMetadata.id,
+            systemPrompt,
+            model: this.model,
+            thinkingLevel: this.thinkingLevel,
+            tools,
+            activeTools,
+        };
+    }
+    createContext(turnState, systemPrompt) {
+        return {
+            systemPrompt: systemPrompt ?? turnState.systemPrompt,
+            messages: turnState.messages.slice(),
+            tools: turnState.activeTools.slice(),
+        };
+    }
+    createStreamFn(getTurnState) {
+        return async (model, context, streamOptions) => {
+            const turnState = getTurnState();
+            const auth = await this.getApiKeyAndHeaders?.(model);
+            const snapshotOptions = {
+                ...turnState.streamOptions,
+                headers: mergeHeaders(turnState.streamOptions.headers, auth?.headers),
+            };
+            const requestOptions = await this.emitBeforeProviderRequest(model, turnState.sessionId, snapshotOptions);
+            return streamSimple(model, context, {
+                cacheRetention: requestOptions.cacheRetention,
+                headers: requestOptions.headers,
+                maxRetries: requestOptions.maxRetries,
+                maxRetryDelayMs: requestOptions.maxRetryDelayMs,
+                metadata: requestOptions.metadata,
+                onPayload: async (payload) => await this.emitBeforeProviderPayload(model, payload),
+                onResponse: async (response) => {
+                    const headers = { ...response.headers };
+                    await this.emitOwn({
+                        type: 'after_provider_response',
+                        status: response.status,
+                        headers,
+                    }, streamOptions?.signal);
+                },
+                reasoning: streamOptions?.reasoning,
+                signal: streamOptions?.signal,
+                sessionId: turnState.sessionId,
+                timeoutMs: requestOptions.timeoutMs,
+                transport: requestOptions.transport,
+                apiKey: auth?.apiKey,
+            });
+        };
+    }
+    async drainQueuedMessages(queue, mode) {
+        const messages = mode === 'all' ? queue.splice(0) : queue.splice(0, 1);
+        if (messages.length === 0)
+            return messages;
+        try {
+            await this.emitQueueUpdate();
+            return messages;
+        }
+        catch (error) {
+            queue.unshift(...messages);
+            throw normalizeHookError(error);
+        }
+    }
+    createLoopConfig(getTurnState, setTurnState) {
+        const turnState = getTurnState();
+        return {
+            model: turnState.model,
+            reasoning: turnState.thinkingLevel === 'off' ? undefined : turnState.thinkingLevel,
+            convertToLlm,
+            transformContext: async (messages) => {
+                const result = await this.emitHook({
+                    type: 'context',
+                    messages: [...messages],
+                });
+                return result?.messages ?? messages;
+            },
+            beforeToolCall: async ({ toolCall, args }) => {
+                const result = await this.emitHook({
+                    type: 'tool_call',
+                    toolCallId: toolCall.id,
+                    toolName: toolCall.name,
+                    input: args,
+                });
+                return result
+                    ? { block: result.block, reason: result.reason }
+                    : undefined;
+            },
+            afterToolCall: async ({ toolCall, args, result, isError }) => {
+                const patch = await this.emitHook({
+                    type: 'tool_result',
+                    toolCallId: toolCall.id,
+                    toolName: toolCall.name,
+                    input: args,
+                    content: result.content,
+                    details: result.details,
+                    isError,
+                });
+                return patch
+                    ? {
+                        content: patch.content,
+                        details: patch.details,
+                        isError: patch.isError,
+                        terminate: patch.terminate,
+                    }
+                    : undefined;
+            },
+            prepareNextTurn: async () => {
+                await this.flushPendingSessionWrites();
+                const nextTurnState = await this.createTurnState();
+                setTurnState(nextTurnState);
+                return {
+                    context: this.createContext(nextTurnState),
+                    model: nextTurnState.model,
+                    thinkingLevel: nextTurnState.thinkingLevel,
+                };
+            },
+            getSteeringMessages: async () => this.drainQueuedMessages(this.steerQueue, this.steeringQueueMode),
+            getFollowUpMessages: async () => this.drainQueuedMessages(this.followUpQueue, this.followUpQueueMode),
+        };
+    }
+    validateUniqueNames(names, message) {
+        const duplicates = findDuplicateNames(names);
+        if (duplicates.length > 0)
+            throw new AgentHarnessError('invalid_argument', `${message}: ${duplicates.join(', ')}`);
+    }
+    validateToolNames(toolNames, tools = this.tools) {
+        this.validateUniqueNames(toolNames, 'Duplicate active tool name(s)');
+        const missing = toolNames.filter((name) => !tools.has(name));
+        if (missing.length > 0)
+            throw new AgentHarnessError('invalid_argument', `Unknown tool(s): ${missing.join(', ')}`);
+    }
+    async flushPendingSessionWrites() {
+        while (this.pendingSessionWrites.length > 0) {
+            const write = this.pendingSessionWrites[0];
+            if (write.type === 'message') {
+                await this.session.appendMessage(write.message);
+            }
+            else if (write.type === 'model_change') {
+                await this.session.appendModelChange(write.provider, write.modelId);
+            }
+            else if (write.type === 'thinking_level_change') {
+                await this.session.appendThinkingLevelChange(write.thinkingLevel);
+            }
+            else if (write.type === 'active_tools_change') {
+                await this.session.appendActiveToolsChange(write.activeToolNames);
+            }
+            else if (write.type === 'custom') {
+                await this.session.appendCustomEntry(write.customType, write.data);
+            }
+            else if (write.type === 'custom_message') {
+                await this.session.appendCustomMessageEntry(write.customType, write.content, write.display, write.details);
+            }
+            else if (write.type === 'label') {
+                await this.session.appendLabel(write.targetId, write.label);
+            }
+            else if (write.type === 'session_info') {
+                await this.session.appendSessionName(write.name ?? '');
+            }
+            else if (write.type === 'leaf') {
+                await this.session.getStorage().setLeafId(write.targetId);
+            }
+            this.pendingSessionWrites.shift();
+        }
+    }
+    async handleAgentEvent(event, signal) {
+        if (event.type === 'message_end') {
+            await this.session.appendMessage(event.message);
+            await this.emitAny(event, signal);
+            return;
+        }
+        if (event.type === 'turn_end') {
+            let eventError;
+            try {
+                await this.emitAny(event, signal);
+            }
+            catch (error) {
+                eventError = error;
+            }
+            const hadPendingMutations = this.pendingSessionWrites.length > 0;
+            await this.flushPendingSessionWrites();
+            if (eventError)
+                throw eventError;
+            await this.emitOwn({ type: 'save_point', hadPendingMutations });
+            return;
+        }
+        if (event.type === 'agent_end') {
+            await this.flushPendingSessionWrites();
+            this.phase = 'idle';
+            await this.emitAny(event, signal);
+            await this.emitOwn({ type: 'settled', nextTurnCount: this.nextTurnQueue.length }, signal);
+            return;
+        }
+        await this.emitAny(event, signal);
+    }
+    async emitRunFailure(model, error, aborted, signal) {
+        const failureMessage = createFailureMessage(model, error, aborted);
+        await this.handleAgentEvent({ type: 'message_start', message: failureMessage }, signal);
+        await this.handleAgentEvent({ type: 'message_end', message: failureMessage }, signal);
+        await this.handleAgentEvent({ type: 'turn_end', message: failureMessage, toolResults: [] }, signal);
+        await this.handleAgentEvent({ type: 'agent_end', messages: [failureMessage] }, signal);
+        return [failureMessage];
+    }
+    async executeTurn(turnState, text, options) {
+        let activeTurnState = turnState;
+        let messages = [createUserMessage(text, options?.images)];
+        if (this.nextTurnQueue.length > 0) {
+            const queuedMessages = this.nextTurnQueue.splice(0);
+            try {
+                await this.emitQueueUpdate();
+            }
+            catch (error) {
+                this.nextTurnQueue.unshift(...queuedMessages);
+                throw normalizeHookError(error);
+            }
+            messages = [...queuedMessages, messages[0]];
+        }
+        const beforeResult = await this.emitHook({
+            type: 'before_agent_start',
+            prompt: text,
+            images: options?.images,
+            systemPrompt: turnState.systemPrompt,
+            resources: turnState.resources,
+        });
+        if (beforeResult?.messages)
+            messages = [...messages, ...beforeResult.messages];
+        const abortController = new AbortController();
+        const getTurnState = () => activeTurnState;
+        const setTurnState = (nextTurnState) => {
+            activeTurnState = nextTurnState;
+        };
+        this.runAbortController = abortController;
+        const runResultPromise = (async () => {
+            try {
+                return await runAgentLoop(messages, this.createContext(turnState, beforeResult?.systemPrompt), this.createLoopConfig(getTurnState, setTurnState), (event) => this.handleAgentEvent(event, abortController.signal), abortController.signal, this.createStreamFn(getTurnState));
+            }
+            catch (error) {
+                try {
+                    return await this.emitRunFailure(activeTurnState.model, error, abortController.signal.aborted, abortController.signal);
+                }
+                catch (failureError) {
+                    const cause = new AggregateError([toError(error), toError(failureError)], 'Agent run failed and failure reporting failed');
+                    throw new AgentHarnessError('unknown', cause.message, cause);
+                }
+            }
+        })();
+        try {
+            const newMessages = await runResultPromise;
+            for (let i = newMessages.length - 1; i >= 0; i--) {
+                const message = newMessages[i];
+                if (message.role === 'assistant') {
+                    return message;
+                }
+            }
+            throw new AgentHarnessError('invalid_state', 'AgentHarness prompt completed without an assistant message');
+        }
+        finally {
+            try {
+                await this.flushPendingSessionWrites();
+            }
+            finally {
+                this.runAbortController = undefined;
+            }
+        }
+    }
+    async prompt(text, options) {
+        if (this.phase !== 'idle')
+            throw new AgentHarnessError('busy', 'AgentHarness is busy');
+        this.phase = 'turn';
+        const finishRunPromise = this.startRunPromise();
+        try {
+            const turnState = await this.createTurnState();
+            return await this.executeTurn(turnState, text, options);
+        }
+        catch (error) {
+            this.phase = 'idle';
+            throw normalizeHarnessError(error, 'unknown');
+        }
+        finally {
+            finishRunPromise();
+        }
+    }
+    async skill(name, additionalInstructions) {
+        if (this.phase !== 'idle')
+            throw new AgentHarnessError('busy', 'AgentHarness is busy');
+        this.phase = 'turn';
+        const finishRunPromise = this.startRunPromise();
+        try {
+            const turnState = await this.createTurnState();
+            const skill = (turnState.resources.skills ?? []).find((candidate) => candidate.name === name);
+            if (!skill)
+                throw new AgentHarnessError('invalid_argument', `Unknown skill: ${name}`);
+            return await this.executeTurn(turnState, formatSkillInvocation(skill, additionalInstructions));
+        }
+        catch (error) {
+            this.phase = 'idle';
+            throw normalizeHarnessError(error, 'unknown');
+        }
+        finally {
+            finishRunPromise();
+        }
+    }
+    async promptFromTemplate(name, args = []) {
+        if (this.phase !== 'idle')
+            throw new AgentHarnessError('busy', 'AgentHarness is busy');
+        this.phase = 'turn';
+        const finishRunPromise = this.startRunPromise();
+        try {
+            const turnState = await this.createTurnState();
+            const template = (turnState.resources.promptTemplates ?? []).find((candidate) => candidate.name === name);
+            if (!template)
+                throw new AgentHarnessError('invalid_argument', `Unknown prompt template: ${name}`);
+            return await this.executeTurn(turnState, formatPromptTemplateInvocation(template, args));
+        }
+        catch (error) {
+            this.phase = 'idle';
+            throw normalizeHarnessError(error, 'unknown');
+        }
+        finally {
+            finishRunPromise();
+        }
+    }
+    async steer(text, options) {
+        if (this.phase === 'idle')
+            throw new AgentHarnessError('invalid_state', 'Cannot steer while idle');
+        this.steerQueue.push(createUserMessage(text, options?.images));
+        await this.emitQueueUpdate();
+    }
+    async followUp(text, options) {
+        if (this.phase === 'idle')
+            throw new AgentHarnessError('invalid_state', 'Cannot follow up while idle');
+        this.followUpQueue.push(createUserMessage(text, options?.images));
+        await this.emitQueueUpdate();
+    }
+    async nextTurn(text, options) {
+        this.nextTurnQueue.push(createUserMessage(text, options?.images));
+        await this.emitQueueUpdate();
+    }
+    async appendMessage(message) {
+        try {
+            if (this.phase === 'idle') {
+                await this.session.appendMessage(message);
+            }
+            else {
+                this.pendingSessionWrites.push({ type: 'message', message });
+            }
+        }
+        catch (error) {
+            throw normalizeHarnessError(error, 'session');
+        }
+    }
+    async compact(customInstructions) {
+        if (this.phase !== 'idle')
+            throw new AgentHarnessError('busy', 'compact() requires idle harness');
+        this.phase = 'compaction';
+        try {
+            const model = this.model;
+            if (!model)
+                throw new AgentHarnessError('invalid_state', 'No model set for compaction');
+            const auth = await this.getApiKeyAndHeaders?.(model);
+            if (!auth)
+                throw new AgentHarnessError('auth', 'No auth available for compaction');
+            const branchEntries = await this.session.getBranch();
+            const preparationResult = prepareCompaction(branchEntries, DEFAULT_COMPACTION_SETTINGS);
+            if (!preparationResult.ok)
+                throw preparationResult.error;
+            const preparation = preparationResult.value;
+            if (!preparation)
+                throw new AgentHarnessError('compaction', 'Nothing to compact');
+            const hookResult = await this.emitHook({
+                type: 'session_before_compact',
+                preparation,
+                branchEntries,
+                customInstructions,
+                signal: new AbortController().signal,
+            });
+            if (hookResult?.cancel)
+                throw new AgentHarnessError('compaction', 'Compaction cancelled');
+            const provided = hookResult?.compaction;
+            const compactResult = provided
+                ? { ok: true, value: provided }
+                : await compact(preparation, model, auth.apiKey, auth.headers, customInstructions, undefined, this.thinkingLevel);
+            if (!compactResult.ok)
+                throw compactResult.error;
+            const result = compactResult.value;
+            const entryId = await this.session.appendCompaction(result.summary, result.firstKeptEntryId, result.tokensBefore, result.details, provided !== undefined);
+            const entry = await this.session.getEntry(entryId);
+            if (entry?.type === 'compaction') {
+                await this.emitOwn({
+                    type: 'session_compact',
+                    compactionEntry: entry,
+                    fromHook: provided !== undefined,
+                });
+            }
+            return result;
+        }
+        catch (error) {
+            throw normalizeHarnessError(error, 'compaction');
+        }
+        finally {
+            this.phase = 'idle';
+        }
+    }
+    async navigateTree(targetId, options) {
+        if (this.phase !== 'idle')
+            throw new AgentHarnessError('busy', 'navigateTree() requires idle harness');
+        this.phase = 'branch_summary';
+        try {
+            const oldLeafId = await this.session.getLeafId();
+            if (oldLeafId === targetId)
+                return { cancelled: false };
+            const targetEntry = await this.session.getEntry(targetId);
+            if (!targetEntry)
+                throw new AgentHarnessError('invalid_argument', `Entry ${targetId} not found`);
+            const { entries, commonAncestorId } = await collectEntriesForBranchSummary(this.session, oldLeafId, targetId);
+            const preparation = {
+                targetId,
+                oldLeafId,
+                commonAncestorId,
+                entriesToSummarize: entries,
+                userWantsSummary: options?.summarize ?? false,
+                customInstructions: options?.customInstructions,
+                replaceInstructions: options?.replaceInstructions,
+                label: options?.label,
+            };
+            const signal = new AbortController().signal;
+            const hookResult = await this.emitHook({
+                type: 'session_before_tree',
+                preparation,
+                signal,
+            });
+            if (hookResult?.cancel)
+                return { cancelled: true };
+            let summaryEntry;
+            let summaryText = hookResult?.summary?.summary;
+            let summaryDetails = hookResult?.summary?.details;
+            if (!summaryText && options?.summarize && entries.length > 0) {
+                const model = this.model;
+                if (!model)
+                    throw new AgentHarnessError('invalid_state', 'No model set for branch summary');
+                const auth = await this.getApiKeyAndHeaders?.(model);
+                if (!auth)
+                    throw new AgentHarnessError('auth', 'No auth available for branch summary');
+                const branchSummary = await generateBranchSummary(entries, {
+                    model,
+                    apiKey: auth.apiKey,
+                    headers: auth.headers,
+                    signal: new AbortController().signal,
+                    customInstructions: hookResult?.customInstructions ?? options?.customInstructions,
+                    replaceInstructions: hookResult?.replaceInstructions ?? options?.replaceInstructions,
+                });
+                if (!branchSummary.ok) {
+                    if (branchSummary.error.code === 'aborted')
+                        return { cancelled: true };
+                    throw new AgentHarnessError('branch_summary', branchSummary.error.message, branchSummary.error);
+                }
+                summaryText = branchSummary.value.summary;
+                summaryDetails = {
+                    readFiles: branchSummary.value.readFiles,
+                    modifiedFiles: branchSummary.value.modifiedFiles,
+                };
+            }
+            let editorText;
+            let newLeafId;
+            if (targetEntry.type === 'message' &&
+                targetEntry.message.role === 'user') {
+                newLeafId = targetEntry.parentId;
+                const content = targetEntry.message.content;
+                editorText =
+                    typeof content === 'string'
+                        ? content
+                        : content
+                            .filter((c) => c.type === 'text')
+                            .map((c) => c.text)
+                            .join('');
+            }
+            else if (targetEntry.type === 'custom_message') {
+                newLeafId = targetEntry.parentId;
+                editorText =
+                    typeof targetEntry.content === 'string'
+                        ? targetEntry.content
+                        : targetEntry.content
+                            .filter((c) => c.type === 'text')
+                            .map((c) => c.text)
+                            .join('');
+            }
+            else {
+                newLeafId = targetId;
+            }
+            const summaryId = await this.session.moveTo(newLeafId, summaryText
+                ? {
+                    summary: summaryText,
+                    details: summaryDetails,
+                    fromHook: hookResult?.summary !== undefined,
+                }
+                : undefined);
+            if (summaryId) {
+                const entry = await this.session.getEntry(summaryId);
+                if (entry?.type === 'branch_summary')
+                    summaryEntry = entry;
+            }
+            await this.emitOwn({
+                type: 'session_tree',
+                newLeafId: await this.session.getLeafId(),
+                oldLeafId,
+                summaryEntry,
+                fromHook: hookResult?.summary !== undefined,
+            });
+            return { cancelled: false, editorText, summaryEntry };
+        }
+        catch (error) {
+            throw normalizeHarnessError(error, 'branch_summary');
+        }
+        finally {
+            this.phase = 'idle';
+        }
+    }
+    getModel() {
+        return this.model;
+    }
+    async setModel(model) {
+        try {
+            const previousModel = this.model;
+            if (this.phase === 'idle') {
+                await this.session.appendModelChange(model.provider, model.id);
+            }
+            else {
+                this.pendingSessionWrites.push({
+                    type: 'model_change',
+                    provider: model.provider,
+                    modelId: model.id,
+                });
+            }
+            this.model = model;
+            await this.emitOwn({
+                type: 'model_update',
+                model,
+                previousModel,
+                source: 'set',
+            });
+        }
+        catch (error) {
+            throw normalizeHarnessError(error, 'session');
+        }
+    }
+    getThinkingLevel() {
+        return this.thinkingLevel;
+    }
+    async setThinkingLevel(level) {
+        try {
+            const previousLevel = this.thinkingLevel;
+            if (this.phase === 'idle') {
+                await this.session.appendThinkingLevelChange(level);
+            }
+            else {
+                this.pendingSessionWrites.push({
+                    type: 'thinking_level_change',
+                    thinkingLevel: level,
+                });
+            }
+            this.thinkingLevel = level;
+            await this.emitOwn({
+                type: 'thinking_level_update',
+                level,
+                previousLevel,
+            });
+        }
+        catch (error) {
+            throw normalizeHarnessError(error, 'session');
+        }
+    }
+    getTools() {
+        return [...this.tools.values()];
+    }
+    async setTools(tools, activeToolNames) {
+        try {
+            this.validateUniqueNames(tools.map((tool) => tool.name), 'Duplicate tool name(s)');
+            const nextTools = new Map(tools.map((tool) => [tool.name, tool]));
+            const nextActiveToolNames = activeToolNames
+                ? [...activeToolNames]
+                : this.activeToolNames;
+            this.validateToolNames(nextActiveToolNames, nextTools);
+            const previousToolNames = [...this.tools.keys()];
+            const previousActiveToolNames = [...this.activeToolNames];
+            if (this.phase === 'idle') {
+                await this.session.appendActiveToolsChange(nextActiveToolNames);
+            }
+            else {
+                this.pendingSessionWrites.push({
+                    type: 'active_tools_change',
+                    activeToolNames: [...nextActiveToolNames],
+                });
+            }
+            this.tools = nextTools;
+            this.activeToolNames = [...nextActiveToolNames];
+            await this.emitOwn({
+                type: 'tools_update',
+                toolNames: [...this.tools.keys()],
+                previousToolNames,
+                activeToolNames: [...this.activeToolNames],
+                previousActiveToolNames,
+                source: 'set',
+            });
+        }
+        catch (error) {
+            throw normalizeHarnessError(error, 'invalid_argument');
+        }
+    }
+    getActiveTools() {
+        return this.activeToolNames.map((name) => this.tools.get(name));
+    }
+    async setActiveTools(toolNames) {
+        try {
+            this.validateToolNames(toolNames);
+            const previousToolNames = [...this.tools.keys()];
+            const previousActiveToolNames = [...this.activeToolNames];
+            if (this.phase === 'idle') {
+                await this.session.appendActiveToolsChange(toolNames);
+            }
+            else {
+                this.pendingSessionWrites.push({
+                    type: 'active_tools_change',
+                    activeToolNames: [...toolNames],
+                });
+            }
+            this.activeToolNames = [...toolNames];
+            await this.emitOwn({
+                type: 'tools_update',
+                toolNames: [...this.tools.keys()],
+                previousToolNames,
+                activeToolNames: [...this.activeToolNames],
+                previousActiveToolNames,
+                source: 'set',
+            });
+        }
+        catch (error) {
+            throw normalizeHarnessError(error, 'invalid_argument');
+        }
+    }
+    getSteeringMode() {
+        return this.steeringQueueMode;
+    }
+    async setSteeringMode(mode) {
+        this.steeringQueueMode = mode;
+    }
+    getFollowUpMode() {
+        return this.followUpQueueMode;
+    }
+    async setFollowUpMode(mode) {
+        this.followUpQueueMode = mode;
+    }
+    getResources() {
+        return {
+            skills: this.resources.skills?.slice(),
+            promptTemplates: this.resources.promptTemplates?.slice(),
+        };
+    }
+    async setResources(resources) {
+        const previousResources = this.getResources();
+        this.resources = {
+            skills: resources.skills?.slice(),
+            promptTemplates: resources.promptTemplates?.slice(),
+        };
+        await this.emitOwn({
+            type: 'resources_update',
+            resources: this.getResources(),
+            previousResources,
+        });
+    }
+    getStreamOptions() {
+        return cloneStreamOptions(this.streamOptions);
+    }
+    async setStreamOptions(streamOptions) {
+        this.streamOptions = cloneStreamOptions(streamOptions);
+    }
+    async abort() {
+        const clearedSteer = [...this.steerQueue];
+        const clearedFollowUp = [...this.followUpQueue];
+        this.steerQueue = [];
+        this.followUpQueue = [];
+        this.runAbortController?.abort();
+        const errors = [];
+        try {
+            await this.emitQueueUpdate();
+        }
+        catch (error) {
+            errors.push(toError(error));
+        }
+        try {
+            await this.waitForIdle();
+        }
+        catch (error) {
+            errors.push(toError(error));
+        }
+        try {
+            await this.emitOwn({ type: 'abort', clearedSteer, clearedFollowUp });
+        }
+        catch (error) {
+            errors.push(toError(error));
+        }
+        if (errors.length > 0) {
+            const cause = errors.length === 1
+                ? errors[0]
+                : new AggregateError(errors, 'Abort completed with errors');
+            throw normalizeHarnessError(cause, 'hook');
+        }
+        return { clearedSteer, clearedFollowUp };
+    }
+    async waitForIdle() {
+        await this.runPromise;
+    }
+    subscribe(listener) {
+        let handlers = this.handlers.get(SUBSCRIBER_EVENT_TYPE);
+        if (!handlers) {
+            handlers = new Set();
+            this.handlers.set(SUBSCRIBER_EVENT_TYPE, handlers);
+        }
+        handlers.add(listener);
+        return () => handlers.delete(listener);
+    }
+    on(type, handler) {
+        let handlers = this.handlers.get(type);
+        if (!handlers) {
+            handlers = new Set();
+            this.handlers.set(type, handlers);
+        }
+        handlers.add(handler);
+        return () => handlers.delete(handler);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"agent-harness.js","sourceRoot":"","sources":["../../../../../../src/lib/agent-core/src/harness/agent-harness.ts"],"names":[],"mappings":"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"}