@fabric-harness/sdk 0.1.0

package/dist/session.js

@@ -0,0 +1,762 @@
+import { createHash } from 'node:crypto';
+import { FabricError } from './error.js';
+import { buildModelMessagesFromHistory } from './history.js';
+import { defaultLoopRuntime } from './loop.js';
+import { defaultModelProvider, generateWithRuntime } from './model.js';
+import { clampCommandTimeout, evaluateCommandPolicy, evaluateToolCallPolicy } from './policy.js';
+import { buildResultRetryPrompt, validateResult } from './result.js';
+import { evaluateContextBudget, isContextOverflowError } from './context-budget.js';
+import { createSandboxEnv } from './sandbox.js';
+import { defaultSessionStore } from './store.js';
+import { createBuiltinTools, createCommandTools, shellQuote } from './tools.js';
+let nextTaskId = 0;
+export class StubFabricSession {
+    id;
+    agent;
+    sandbox;
+    checkpoint = {
+        create: (options) => this.createCheckpoint(options),
+        restore: (options) => this.restoreCheckpoint(options),
+    };
+    options;
+    store;
+    eventSubscribers = new Set();
+    constructor(agent, id, options = {}) {
+        this.agent = agent;
+        this.id = id;
+        this.options = options;
+        this.store = options.store ?? defaultSessionStore;
+        this.sandbox = this.createSandbox();
+    }
+    async prompt(text, options = {}) {
+        const role = this.resolveRole(options.role ?? this.options.role ?? this.agent.role);
+        const promptSubscriber = options.onEvent;
+        if (promptSubscriber)
+            this.eventSubscribers.add(promptSubscriber);
+        try {
+            await this.emit('prompt_start', { text, ...(role ? { role: role.name } : {}) });
+            const sandbox = await this.sandbox;
+            const tools = this.resolveTools(sandbox, options.tools, options.commands);
+            await this.recordEntry('user_prompt', { text, ...(role ? { role: role.name } : {}) });
+            let messages = buildModelMessagesFromHistory(await this.history(), role);
+            messages = await this.autoCompactIfNeeded(messages, role, options);
+            if (options.toolCalls?.length) {
+                const results = await this.executeToolCalls(options.toolCalls, tools, sandbox, options.policy, options.approvalTimeoutMs ?? this.options.approvalTimeoutMs, options.onApproval);
+                await this.recordEntry('result', { result: results });
+                await this.emit('prompt_end', { text, result: results });
+                return validateResult(results, options.result, options.resultExtraction);
+            }
+            const runtime = options.loopRuntime ?? this.options.loopRuntime ?? defaultLoopRuntime;
+            const runRuntime = () => runtime.runPrompt({
+                sessionId: this.id,
+                text,
+                messages,
+                tools,
+                sandbox,
+                ...(typeof (options.model ?? this.options.model ?? this.agent.model) === 'string' ? { model: (options.model ?? this.options.model ?? this.agent.model) } : {}),
+                ...((options.modelProvider ?? this.options.modelProvider) !== undefined ? { modelProvider: options.modelProvider ?? this.options.modelProvider } : {}),
+                ...(options.maxIterations !== undefined ? { maxIterations: options.maxIterations } : {}),
+                ...(options.modelTimeoutMs !== undefined ? { modelTimeoutMs: options.modelTimeoutMs } : {}),
+                ...(options.modelRetries !== undefined ? { modelRetries: options.modelRetries } : {}),
+                ...(options.modelRetryDelayMs !== undefined ? { modelRetryDelayMs: options.modelRetryDelayMs } : {}),
+                ...(options.signal !== undefined ? { signal: options.signal } : {}),
+                ...(options.policy !== undefined ? { policy: options.policy } : {}),
+                ...((options.approvalTimeoutMs ?? this.options.approvalTimeoutMs) !== undefined ? { approvalTimeoutMs: options.approvalTimeoutMs ?? this.options.approvalTimeoutMs } : {}),
+                executeToolCalls: (calls, policy, approvalTimeoutMs) => this.executeToolCalls(calls, tools, sandbox, policy, approvalTimeoutMs, options.onApproval),
+                recordEntry: (type, data) => this.recordEntry(type, data),
+                emit: (type, data) => this.emit(type, data),
+            });
+            let result;
+            try {
+                result = await runRuntime();
+            }
+            catch (error) {
+                if (!isContextOverflowError(error) || options.recoverContextOverflow === false)
+                    throw error;
+                await this.emit('error', { error: 'Context overflow detected; compacting and retrying once.' });
+                await this.compact({ keepRecentEntries: options.compactionKeepRecentEntries ?? 20, generateSummary: true });
+                messages = buildModelMessagesFromHistory(await this.history(), role);
+                result = await runRuntime();
+            }
+            const resultRetries = options.resultRetries ?? (options.result ? 1 : 0);
+            for (let attempt = 0; attempt <= resultRetries; attempt += 1) {
+                try {
+                    return await validateResult(result.raw, options.result, options.resultExtraction);
+                }
+                catch (error) {
+                    if (attempt >= resultRetries)
+                        throw error;
+                    const message = error instanceof Error ? error.message : String(error);
+                    await this.recordEntry('result_retry', { error: message, retryAttempt: attempt + 1, maxRetries: resultRetries });
+                    await this.emit('result_retry', { error: message, retryAttempt: attempt + 1, maxRetries: resultRetries });
+                    messages.push({ role: 'user', content: buildResultRetryPrompt(error, options.resultExtraction) });
+                    result = await runRuntime();
+                }
+            }
+            throw new FabricError({ code: 'RESULT_VALIDATION_FAILED', message: 'Typed result validation failed.', retryable: true });
+        }
+        finally {
+            if (promptSubscriber)
+                this.eventSubscribers.delete(promptSubscriber);
+        }
+    }
+    async *stream(text, options = {}) {
+        const events = [];
+        let notify;
+        let settled = false;
+        const wake = () => {
+            notify?.();
+            notify = undefined;
+        };
+        const subscriber = (event) => {
+            events.push(event);
+            wake();
+        };
+        this.eventSubscribers.add(subscriber);
+        let result;
+        let failure;
+        const resultPromise = this.prompt(text, options)
+            .then((value) => {
+            result = value;
+        })
+            .catch((error) => {
+            failure = error;
+        })
+            .finally(() => {
+            settled = true;
+            this.eventSubscribers.delete(subscriber);
+            wake();
+        });
+        while (!settled || events.length > 0) {
+            const event = events.shift();
+            if (event) {
+                yield event;
+                continue;
+            }
+            await new Promise((resolve) => {
+                notify = resolve;
+            });
+        }
+        await resultPromise;
+        if (failure)
+            throw failure;
+        return result;
+    }
+    async skill(name, options = {}) {
+        const skill = this.resolveSkill(name);
+        await this.recordEntry('skill_start', { skill: name });
+        await this.emit('skill_start', { skill: name });
+        if (!skill)
+            throw new FabricError({ code: 'SKILL_NOT_FOUND', message: `Skill not found: ${name}`, details: { skill: name } });
+        const argsText = options.args ? `\n\nArguments:\n${JSON.stringify(options.args, null, 2)}` : '';
+        const result = await this.prompt(`${skill.content ?? ''}${argsText}`, options);
+        await this.recordEntry('skill_end', { skill: name });
+        await this.emit('skill_end', { skill: name });
+        return result;
+    }
+    async task(text, options = {}) {
+        const taskId = options.id ?? `${this.id}:task-${++nextTaskId}`;
+        const startedAt = new Date().toISOString();
+        await this.recordEntry('task_start', { taskId, text, status: 'running', startedAt, ...(options.agent ? { agent: options.agent } : {}), ...(options.metadata ? { metadata: options.metadata } : {}) });
+        await this.emit('task_start', { taskId, text, status: 'running', startedAt });
+        const checkpointLabel = typeof options.checkpoint === 'string' ? options.checkpoint : `task:${taskId}`;
+        try {
+            if (options.signal?.aborted)
+                throw abortError();
+            if (options.checkpoint) {
+                const checkpoint = await this.createCheckpoint({ label: `${checkpointLabel}:before`, metadata: { taskId, phase: 'before' } });
+                await this.recordEntry('task_checkpoint', { taskId, phase: 'before', checkpoint: checkpoint, ...(checkpoint.snapshotId ? { checkpointId: checkpoint.snapshotId } : {}) });
+                await this.emit('task_checkpoint', { taskId, phase: 'before', ...(checkpoint.snapshotId ? { checkpointId: checkpoint.snapshotId } : {}) });
+            }
+            const taskAbort = new AbortController();
+            const stopCancellationWatcher = this.watchTaskCancellation(taskId, taskAbort);
+            const forwardAbort = () => taskAbort.abort(options.signal?.reason);
+            if (options.signal)
+                options.signal.addEventListener('abort', forwardAbort, { once: true });
+            try {
+                const child = new StubFabricSession(this.agent, taskId, {
+                    ...this.options,
+                    ...options,
+                    store: this.store,
+                    sandbox: await this.sandbox,
+                });
+                const result = await child.prompt(text, { ...options, signal: taskAbort.signal });
+                if (taskAbort.signal.aborted)
+                    throw abortError();
+                if (options.checkpoint) {
+                    const checkpoint = await this.createCheckpoint({ label: `${checkpointLabel}:after`, metadata: { taskId, phase: 'after' } });
+                    await this.recordEntry('task_checkpoint', { taskId, phase: 'after', checkpoint: checkpoint, ...(checkpoint.snapshotId ? { checkpointId: checkpoint.snapshotId } : {}) });
+                    await this.emit('task_checkpoint', { taskId, phase: 'after', ...(checkpoint.snapshotId ? { checkpointId: checkpoint.snapshotId } : {}) });
+                }
+                const completedAt = new Date().toISOString();
+                await this.recordEntry('task_end', { taskId, status: 'completed', completedAt });
+                await this.emit('task_end', { taskId, status: 'completed', completedAt });
+                return result;
+            }
+            finally {
+                stopCancellationWatcher();
+                if (options.signal)
+                    options.signal.removeEventListener('abort', forwardAbort);
+            }
+        }
+        catch (error) {
+            if (isAbortError(error) || options.signal?.aborted) {
+                const cancelledAt = new Date().toISOString();
+                const message = error instanceof Error ? error.message : 'Task cancelled';
+                await this.recordEntry('task_cancelled', { taskId, status: 'cancelled', cancelledAt, reason: message });
+                await this.emit('task_cancelled', { taskId, status: 'cancelled', cancelledAt, reason: message });
+                throw error;
+            }
+            const failedAt = new Date().toISOString();
+            const message = error instanceof Error ? error.message : String(error);
+            await this.recordEntry('task_failed', { taskId, status: 'failed', failedAt, error: message });
+            await this.emit('task_failed', { taskId, status: 'failed', failedAt, error: message });
+            throw error;
+        }
+    }
+    watchTaskCancellation(taskId, controller) {
+        const interval = setInterval(() => {
+            void (async () => {
+                if (controller.signal.aborted)
+                    return;
+                const entries = (await this.store.load(this.id))?.entries ?? [];
+                if (entries.some((entry) => entry.type === 'task_cancelled' && entry.data?.taskId === taskId))
+                    controller.abort(abortError());
+            })().catch(() => undefined);
+        }, 500);
+        return () => clearInterval(interval);
+    }
+    async shell(command, options = {}) {
+        const sandbox = await this.sandbox;
+        const execOptions = {};
+        const policy = options.policy ?? this.options.policy;
+        const decision = evaluateCommandPolicy(command, policy);
+        if (!decision.allowed) {
+            if (decision.approvalRequired) {
+                const approved = await this.requestApproval({
+                    kind: 'command',
+                    command,
+                    input: { command, ...(options.cwd ? { cwd: options.cwd } : {}) },
+                    reason: decision.reason ?? `Approval required for command: ${command}`,
+                    ...(decision.risk ? { risk: decision.risk } : {}),
+                    ...(decision.matchedPattern ? { matchedPattern: decision.matchedPattern } : {}),
+                }, policy, options.approvalTimeoutMs ?? this.options.approvalTimeoutMs, options.onApproval);
+                if (!approved) {
+                    const message = decision.reason ?? 'Command approval denied or unavailable';
+                    await this.emit('error', { reason: message, command, approvalRequired: true });
+                    throw new FabricError({ code: 'COMMAND_DENIED', message, details: { command, approvalRequired: true } });
+                }
+            }
+            else {
+                const message = decision.reason ?? 'Command denied by policy';
+                await this.emit('error', { reason: message, command });
+                throw new FabricError({ code: 'COMMAND_DENIED', message, details: { command } });
+            }
+        }
+        if (options.cwd !== undefined)
+            execOptions.cwd = options.cwd;
+        if (options.env !== undefined)
+            execOptions.env = options.env;
+        if (options.signal !== undefined)
+            execOptions.signal = options.signal;
+        const timeout = clampCommandTimeout(options.timeout, policy);
+        if (timeout !== undefined)
+            execOptions.timeout = timeout;
+        await this.recordEntry('shell_command', { command });
+        await this.emit('command_start', { command });
+        const result = await sandbox.exec(command, execOptions);
+        await this.recordEntry('shell_result', { command, exitCode: result.exitCode, stdout: result.stdout, stderr: result.stderr, ...(result.durationMs !== undefined ? { durationMs: result.durationMs } : {}) });
+        await this.emit('command_end', { command, exitCode: result.exitCode, ...(result.durationMs !== undefined ? { durationMs: result.durationMs } : {}) });
+        return result;
+    }
+    async history() {
+        return this.ensureData();
+    }
+    async artifact(name, content, options = {}) {
+        const bytes = typeof content === 'string' ? new TextEncoder().encode(content) : content;
+        const fallback = {
+            id: `${Date.now()}-${name.replace(/[^a-zA-Z0-9._-]/g, '_')}`,
+            sessionId: this.id,
+            name,
+            path: name,
+            size: bytes.byteLength,
+            sha256: createHash('sha256').update(bytes).digest('hex'),
+            createdAt: new Date().toISOString(),
+            ...(options.contentType ? { contentType: options.contentType } : {}),
+            ...(options.metadata ? { metadata: options.metadata } : {}),
+        };
+        const ref = this.store.putArtifact ? await this.store.putArtifact(this.id, name, bytes, options) : fallback;
+        await this.recordEntry('artifact_created', { artifact: ref });
+        await this.emit('artifact_created', { artifact: ref });
+        return ref;
+    }
+    async compact(options = {}) {
+        const history = await this.history();
+        const entries = history.entries ?? [];
+        const keepRecentEntries = options.keepRecentEntries ?? 20;
+        const compactedEntries = Math.max(0, entries.length - keepRecentEntries);
+        const firstKeptEntry = compactedEntries > 0 ? entries[compactedEntries] : undefined;
+        const compacted = compactedEntries > 0 ? entries.slice(0, compactedEntries) : [];
+        const fileRefs = collectFileReferences(compacted);
+        const baseSummary = options.summary ?? (options.generateSummary ? await this.generateCompactionSummary(compacted) : summarizeEntries(compacted));
+        const summary = appendFileReferenceTags(baseSummary, fileRefs);
+        const entry = await this.recordEntry('compaction', {
+            summary,
+            compactedEntries,
+            ...(fileRefs.readFiles.length > 0 ? { readFiles: fileRefs.readFiles } : {}),
+            ...(fileRefs.modifiedFiles.length > 0 ? { modifiedFiles: fileRefs.modifiedFiles } : {}),
+            ...(firstKeptEntry ? { firstKeptEntryId: firstKeptEntry.id } : {}),
+        });
+        await this.emit('compaction', { summary, compactedEntries });
+        return {
+            entryId: entry.id,
+            summary,
+            compactedEntries,
+            ...(firstKeptEntry ? { firstKeptEntryId: firstKeptEntry.id } : {}),
+        };
+    }
+    async autoCompactIfNeeded(messages, role, options) {
+        if (options.autoCompact === false)
+            return messages;
+        const budget = evaluateContextBudget(messages, {
+            ...(options.contextWindowTokens !== undefined ? { contextWindowTokens: options.contextWindowTokens } : {}),
+            ...(options.compactAtTokens !== undefined ? { compactAtTokens: options.compactAtTokens } : {}),
+            ...(options.reserveTokens !== undefined ? { reserveTokens: options.reserveTokens } : {}),
+        });
+        if (!budget.shouldCompact)
+            return messages;
+        await this.emit('compaction', {
+            phase: 'auto_start',
+            estimatedTokens: budget.estimatedTokens,
+            compactAtTokens: budget.compactAtTokens ?? 0,
+        });
+        await this.compact({ keepRecentEntries: options.compactionKeepRecentEntries ?? 20, generateSummary: true });
+        const compacted = buildModelMessagesFromHistory(await this.history(), role);
+        const compactedBudget = evaluateContextBudget(compacted, {
+            ...(options.contextWindowTokens !== undefined ? { contextWindowTokens: options.contextWindowTokens } : {}),
+            ...(options.compactAtTokens !== undefined ? { compactAtTokens: options.compactAtTokens } : {}),
+            ...(options.reserveTokens !== undefined ? { reserveTokens: options.reserveTokens } : {}),
+        });
+        await this.emit('compaction', {
+            phase: 'auto_end',
+            estimatedTokens: compactedBudget.estimatedTokens,
+            compactAtTokens: compactedBudget.compactAtTokens ?? 0,
+        });
+        return compacted;
+    }
+    async generateCompactionSummary(entries) {
+        if (entries.length === 0)
+            return summarizeEntries(entries);
+        const deterministic = summarizeEntries(entries);
+        const provider = this.options.modelProvider ?? defaultModelProvider;
+        try {
+            const response = await generateWithRuntime(provider, {
+                ...(this.agent.model !== undefined ? { model: this.agent.model } : {}),
+                messages: [
+                    {
+                        role: 'system',
+                        content: 'Summarize durable agent session history for future context. Preserve user goals, decisions, tool/command effects, files touched, errors, policy/approval events, and pending work. Do not include secrets.',
+                    },
+                    {
+                        role: 'user',
+                        content: JSON.stringify(entries.map((entry) => ({ type: entry.type, timestamp: entry.timestamp, data: entry.data ?? {} })).slice(0, 200)),
+                    },
+                ],
+            }, { retries: 1, retryDelayMs: 250 });
+            return response.message?.content?.trim() || deterministic;
+        }
+        catch {
+            return deterministic;
+        }
+    }
+    async createCheckpoint(options) {
+        const input = typeof options === 'string' ? { label: options } : options;
+        const sandbox = await this.sandbox;
+        const snapshot = sandbox.snapshot ? await sandbox.snapshot() : undefined;
+        const entry = await this.recordEntry('checkpoint_created', {
+            label: input.label,
+            ...(input.metadata ? { metadata: input.metadata } : {}),
+            ...(snapshot ? { snapshotId: snapshot.id, snapshot: snapshot } : {}),
+        });
+        await this.emit('checkpoint_created', { label: input.label, ...(snapshot ? { snapshotId: snapshot.id } : {}) });
+        return { label: input.label, entryId: entry.id, ...(snapshot ? { snapshotId: snapshot.id } : {}) };
+    }
+    async restoreCheckpoint(options) {
+        const input = typeof options === 'string' ? { label: options } : options;
+        const history = await this.history();
+        const checkpoint = [...(history.entries ?? [])]
+            .reverse()
+            .find((entry) => entry.type === 'checkpoint_created' && entry.data?.label === input.label);
+        if (!checkpoint)
+            throw new FabricError({ code: 'CHECKPOINT_NOT_FOUND', message: `Checkpoint not found: ${input.label}`, details: { label: input.label } });
+        const sandbox = await this.sandbox;
+        const snapshot = checkpoint.data?.snapshot;
+        if (sandbox.restore && isSnapshot(snapshot))
+            await sandbox.restore(snapshot);
+        const entry = await this.recordEntry('checkpoint_restored', {
+            label: input.label,
+            checkpointEntryId: checkpoint.id,
+            ...(isSnapshot(snapshot) ? { snapshotId: snapshot.id } : {}),
+        });
+        await this.emit('checkpoint_restored', { label: input.label, checkpointEntryId: checkpoint.id });
+        return {
+            label: input.label,
+            entryId: entry.id,
+            ...(isSnapshot(snapshot) ? { snapshotId: snapshot.id } : {}),
+        };
+    }
+    async createSandbox() {
+        const sandbox = this.options.sandbox;
+        if (typeof sandbox === 'object' && sandbox !== null && 'exec' in sandbox)
+            return sandbox;
+        if (typeof sandbox === 'function')
+            return sandbox({ sessionId: this.id });
+        return createSandboxEnv({ backend: sandbox ?? 'empty', sessionId: this.id });
+    }
+    async executeToolCalls(calls, tools, sandbox, callPolicy, approvalTimeoutMs, approvalHandler) {
+        const results = [];
+        const policy = callPolicy ?? this.options.policy;
+        for (const call of calls) {
+            const tool = tools.get(call.tool);
+            const decision = evaluateToolCallPolicy(call, policy);
+            if (!decision.allowed) {
+                if (decision.approvalRequired) {
+                    const approved = await this.requestApproval({
+                        kind: 'tool',
+                        tool: call.tool,
+                        input: call.input,
+                        reason: decision.reason ?? `Approval required for tool: ${call.tool}`,
+                        ...(decision.risk ? { risk: decision.risk } : {}),
+                        ...(decision.matchedPattern ? { matchedPattern: decision.matchedPattern } : {}),
+                        affectedPaths: affectedPathsFromInput(call.input),
+                    }, policy, approvalTimeoutMs, approvalHandler);
+                    if (approved) {
+                        // Approved by caller/operator; continue to normal execution path.
+                    }
+                    else {
+                        const error = decision.reason ?? `Approval required for tool call: ${call.tool}`;
+                        results.push({ tool: call.tool, input: call.input, error, ...(call.id ? { id: call.id } : {}) });
+                        await this.recordEntry('error', { tool: call.tool, error, approvalRequired: true });
+                        await this.emit('error', { tool: call.tool, error, approvalRequired: true });
+                        continue;
+                    }
+                }
+                else {
+                    const error = decision.reason ?? `Tool call denied by policy: ${call.tool}`;
+                    results.push({ tool: call.tool, input: call.input, error, ...(call.id ? { id: call.id } : {}) });
+                    await this.recordEntry('error', { tool: call.tool, error, approvalRequired: false });
+                    await this.emit('error', { tool: call.tool, error, approvalRequired: false });
+                    continue;
+                }
+            }
+            const commandDecision = this.evaluateScopedCommandToolCall(tool, call.input, policy);
+            if (!commandDecision.allowed) {
+                if (commandDecision.approvalRequired) {
+                    const command = this.commandTextForApproval(tool, call.input);
+                    const approved = await this.requestApproval({
+                        kind: 'command',
+                        tool: call.tool,
+                        ...(command ? { command } : {}),
+                        input: call.input,
+                        reason: commandDecision.reason ?? `Approval required for command: ${call.tool}`,
+                        ...(commandDecision.risk ? { risk: commandDecision.risk } : {}),
+                        ...(commandDecision.matchedPattern ? { matchedPattern: commandDecision.matchedPattern } : {}),
+                        envKeys: commandEnvKeys(tool),
+                        affectedPaths: affectedPathsFromInput(call.input),
+                    }, policy, approvalTimeoutMs, approvalHandler);
+                    if (!approved) {
+                        const error = commandDecision.reason ?? `Approval required for command: ${call.tool}`;
+                        results.push({ tool: call.tool, input: call.input, error, ...(call.id ? { id: call.id } : {}) });
+                        await this.recordEntry('error', { tool: call.tool, error, approvalRequired: true });
+                        await this.emit('error', { tool: call.tool, error, approvalRequired: true });
+                        continue;
+                    }
+                }
+                else {
+                    const error = commandDecision.reason ?? `Command denied by policy: ${call.tool}`;
+                    results.push({ tool: call.tool, input: call.input, error, ...(call.id ? { id: call.id } : {}) });
+                    await this.recordEntry('error', { tool: call.tool, error, approvalRequired: false });
+                    await this.emit('error', { tool: call.tool, error, approvalRequired: false });
+                    continue;
+                }
+            }
+            await this.recordEntry('tool_call', { tool: call.tool, input: call.input, ...(tool?.metadata?.effect ? { effect: tool.metadata.effect } : {}), ...(call.id ? { toolCallId: call.id } : {}) });
+            await this.emit('tool_start', { tool: call.tool });
+            if (!tool?.execute) {
+                const error = `Tool is not available: ${call.tool}`;
+                results.push({ tool: call.tool, input: call.input, error, ...(call.id ? { id: call.id } : {}) });
+                await this.recordEntry('error', { tool: call.tool, error, approvalRequired: false });
+                await this.emit('tool_end', { tool: call.tool, error });
+                continue;
+            }
+            try {
+                const input = call.tool === 'bash' ? this.clampBashToolInput(call.input, policy) : call.input;
+                const startedAt = Date.now();
+                const output = await tool.execute(input, { sandbox });
+                const durationMs = Date.now() - startedAt;
+                results.push({ tool: call.tool, input, output, ...(call.id ? { id: call.id } : {}) });
+                await this.recordEntry('tool_result', { tool: call.tool, output: output, durationMs, ...(call.id ? { toolCallId: call.id } : {}) });
+                await this.emit('tool_end', { tool: call.tool, durationMs });
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                results.push({ tool: call.tool, input: call.input, error: message, ...(call.id ? { id: call.id } : {}) });
+                await this.recordEntry('error', { tool: call.tool, error: message });
+                await this.emit('tool_end', { tool: call.tool, error: message });
+            }
+        }
+        return results;
+    }
+    async requestApproval(input, callPolicy, approvalTimeoutMs, approvalHandler) {
+        const id = `${this.id}-approval-${Date.now()}-${Math.random().toString(16).slice(2)}`;
+        const request = {
+            id,
+            sessionId: this.id,
+            reason: input.reason,
+            subject: input.command ?? input.tool ?? input.kind,
+            kind: input.kind,
+            createdAt: new Date().toISOString(),
+            ...(input.risk ? { risk: input.risk } : {}),
+            ...(callPolicy?.approvals?.requiredApprovals ? { requiredApprovals: callPolicy.approvals.requiredApprovals } : {}),
+            ...(callPolicy?.approvals?.escalation ? { escalation: callPolicy.approvals.escalation } : {}),
+            ...(input.matchedPattern ? { matchedPattern: input.matchedPattern } : {}),
+            ...(input.envKeys && input.envKeys.length > 0 ? { envKeys: input.envKeys } : {}),
+            ...(input.affectedPaths && input.affectedPaths.length > 0 ? { affectedPaths: input.affectedPaths } : {}),
+            ...(input.tool ? { tool: input.tool } : {}),
+            ...(input.command ? { command: input.command } : {}),
+            ...(isJsonValue(input.input) ? { input: input.input } : {}),
+            ...(this.options.actor ? { actor: this.options.actor } : {}),
+        };
+        await this.recordEntry('approval_requested', request);
+        await this.emit('approval_requested', request);
+        const handler = approvalHandler ?? this.options.onApproval;
+        const autonomy = this.effectiveAutonomy();
+        const waitTimeout = approvalTimeoutMs ?? callPolicy?.approvals?.defaultTimeoutMs;
+        const hasStoredApprovalBackend = typeof this.store.waitForApproval === 'function';
+        const response = handler
+            ? normalizeApprovalResponse(await handler(request))
+            : hasStoredApprovalBackend
+                ? await this.waitForStoredApproval(request, waitTimeout)
+                : undefined;
+        if (!response) {
+            const unavailableReason = !handler && !hasStoredApprovalBackend
+                ? `Approval unavailable in ${autonomy.mode} mode: no approval handler or store waiter is configured (${autonomy.onApprovalUnavailable}).`
+                : waitTimeout !== undefined
+                    ? `Approval timed out after ${waitTimeout}ms`
+                    : 'No approval response was received';
+            if (!handler && !hasStoredApprovalBackend && autonomy.onApprovalUnavailable === 'deny') {
+                await this.recordEntry('approval_denied', { approvalId: id, reason: unavailableReason });
+                await this.emit('approval_denied', { approvalId: id, reason: unavailableReason });
+            }
+            else {
+                await this.recordEntry('approval_expired', { approvalId: id, reason: unavailableReason });
+                await this.emit('approval_expired', { approvalId: id, reason: unavailableReason });
+            }
+            return false;
+        }
+        if (response.decision === 'approved') {
+            await this.recordEntry('approval_granted', { approvalId: id, reason: response.reason ?? 'Approved by handler' });
+            await this.emit('approval_granted', { approvalId: id, reason: response.reason ?? 'Approved by handler' });
+            return true;
+        }
+        await this.recordEntry('approval_denied', { approvalId: id, reason: response.reason ?? 'Denied by handler' });
+        await this.emit('approval_denied', { approvalId: id, reason: response.reason ?? 'Denied by handler' });
+        return false;
+    }
+    async waitForStoredApproval(request, timeoutMs) {
+        if (!this.store.waitForApproval)
+            return undefined;
+        return this.store.waitForApproval(this.id, request.id, timeoutMs);
+    }
+    effectiveAutonomy() {
+        return {
+            mode: this.options.autonomy?.mode ?? 'background',
+            onMissingInput: this.options.autonomy?.onMissingInput ?? 'assume',
+            onApprovalUnavailable: this.options.autonomy?.onApprovalUnavailable ?? 'fail',
+            onCredentialMissing: this.options.autonomy?.onCredentialMissing ?? 'fail',
+        };
+    }
+    evaluateScopedCommandToolCall(tool, input, policy) {
+        if (tool?.metadata?.kind !== 'command' || typeof tool.metadata.command !== 'string')
+            return { allowed: true };
+        const args = typeof input === 'object' && input !== null && Array.isArray(input.args)
+            ? input.args.filter((value) => typeof value === 'string')
+            : [];
+        const command = [tool.metadata.command, ...args.map(shellQuote)].join(' ');
+        return evaluateCommandPolicy(command, policy);
+    }
+    commandTextForApproval(tool, input) {
+        if (tool?.metadata?.kind !== 'command' || typeof tool.metadata.command !== 'string')
+            return undefined;
+        const args = typeof input === 'object' && input !== null && Array.isArray(input.args)
+            ? input.args.filter((value) => typeof value === 'string')
+            : [];
+        return [tool.metadata.command, ...args].join(' ');
+    }
+    clampBashToolInput(input, policy) {
+        if (!policy?.maxCommandTimeoutMs || typeof input !== 'object' || input === null)
+            return input;
+        const record = input;
+        const timeout = typeof record.timeout === 'number' ? record.timeout : undefined;
+        return { ...record, timeout: clampCommandTimeout(timeout, policy) };
+    }
+    resolveTools(sandbox, promptTools = [], promptCommands = []) {
+        const tools = new Map();
+        const commandToolOptions = this.options.resolveSecret ? { resolveSecret: this.options.resolveSecret } : {};
+        for (const tool of createBuiltinTools(sandbox))
+            tools.set(tool.name, tool);
+        for (const tool of createCommandTools(this.options.commands ?? [], commandToolOptions))
+            tools.set(tool.name, tool);
+        for (const tool of this.options.tools ?? [])
+            tools.set(tool.name, tool);
+        for (const tool of createCommandTools(promptCommands ?? [], commandToolOptions))
+            tools.set(tool.name, tool);
+        for (const tool of promptTools)
+            tools.set(tool.name, tool);
+        return tools;
+    }
+    resolveSkill(name) {
+        return this.options.skills?.find((skill) => skill.name === name);
+    }
+    resolveRole(role) {
+        if (!role)
+            return undefined;
+        if (typeof role !== 'string')
+            return role;
+        return this.options.roles?.find((candidate) => candidate.name === role);
+    }
+    async ensureData() {
+        const existing = await this.store.load(this.id);
+        if (existing)
+            return existing;
+        const now = new Date().toISOString();
+        const data = { id: this.id, agentId: this.agent.id, createdAt: now, updatedAt: now, events: [], entries: [] };
+        if (this.options.metadata !== undefined)
+            data.metadata = this.options.metadata;
+        await this.store.save(data);
+        return data;
+    }
+    async recordEntry(type, data) {
+        await this.ensureData();
+        const current = await this.store.load(this.id);
+        const entry = {
+            id: `${this.id}-entry-${Date.now()}-${Math.random().toString(16).slice(2)}`,
+            type,
+            timestamp: new Date().toISOString(),
+            ...(current?.leafId ? { parentId: current.leafId } : {}),
+            ...(this.options.actor ? { actor: this.options.actor } : {}),
+            ...(data ? { data } : {}),
+        };
+        await this.store.appendEntry?.(this.id, entry);
+        return entry;
+    }
+    async emit(type, data) {
+        await this.ensureData();
+        const event = {
+            id: `${this.id}-${Date.now()}-${Math.random().toString(16).slice(2)}`,
+            type,
+            timestamp: new Date().toISOString(),
+            sessionId: this.id,
+            ...(data ? { data } : {}),
+        };
+        await this.store.appendEvent?.(this.id, event);
+        await this.options.onEvent?.(event);
+        for (const subscriber of this.eventSubscribers)
+            await subscriber(event);
+    }
+}
+function affectedPathsFromInput(input) {
+    if (typeof input !== 'object' || input === null)
+        return [];
+    const record = input;
+    const paths = [record.path, record.cwd].filter((value) => typeof value === 'string');
+    return [...new Set(paths)];
+}
+function commandEnvKeys(tool) {
+    const value = tool?.metadata?.envKeys;
+    return Array.isArray(value) ? value.filter((entry) => typeof entry === 'string') : [];
+}
+function normalizeApprovalResponse(value) {
+    if (typeof value === 'boolean')
+        return { decision: value ? 'approved' : 'denied' };
+    if (typeof value === 'string')
+        return { decision: value };
+    return value;
+}
+function isJsonValue(value) {
+    if (value === null)
+        return true;
+    if (['string', 'number', 'boolean'].includes(typeof value))
+        return true;
+    if (Array.isArray(value))
+        return value.every(isJsonValue);
+    if (typeof value !== 'object')
+        return false;
+    return Object.values(value).every(isJsonValue);
+}
+function summarizeEntries(entries) {
+    if (entries.length === 0)
+        return 'No entries to compact.';
+    const counts = new Map();
+    for (const entry of entries)
+        counts.set(entry.type, (counts.get(entry.type) ?? 0) + 1);
+    const summary = [...counts.entries()].map(([type, count]) => `${type}: ${count}`).join(', ');
+    const first = entries[0];
+    const last = entries.at(-1);
+    return `Compacted ${entries.length} entries (${summary}). Range: ${first?.timestamp ?? 'unknown'} to ${last?.timestamp ?? 'unknown'}.`;
+}
+function collectFileReferences(entries) {
+    const readFiles = new Set();
+    const modifiedFiles = new Set();
+    for (const entry of entries) {
+        if (entry.type === 'tool_call') {
+            const tool = typeof entry.data?.tool === 'string' ? entry.data.tool : undefined;
+            const effect = typeof entry.data?.effect === 'string' ? entry.data.effect : undefined;
+            const input = entry.data?.input;
+            for (const path of filePathsFromToolInput(input)) {
+                if (effect === 'read' || (!effect && isReadOnlyFileTool(tool)))
+                    readFiles.add(path);
+                if (effect === 'write' || (!effect && isMutatingFileTool(tool)))
+                    modifiedFiles.add(path);
+            }
+        }
+        if (entry.type === 'shell_command' && typeof entry.data?.cwd === 'string')
+            readFiles.add(entry.data.cwd);
+    }
+    return { readFiles: [...readFiles].sort(), modifiedFiles: [...modifiedFiles].sort() };
+}
+function appendFileReferenceTags(summary, refs) {
+    const sections = [summary];
+    if (refs.readFiles.length > 0)
+        sections.push(`<read-files>\n${refs.readFiles.join('\n')}\n</read-files>`);
+    if (refs.modifiedFiles.length > 0)
+        sections.push(`<modified-files>\n${refs.modifiedFiles.join('\n')}\n</modified-files>`);
+    return sections.join('\n\n');
+}
+function isReadOnlyFileTool(tool) {
+    return tool !== undefined && ['read', 'read_buffer', 'stat', 'readdir', 'exists', 'grep', 'glob'].includes(tool);
+}
+function isMutatingFileTool(tool) {
+    return tool !== undefined && ['write', 'edit', 'mkdir', 'rm'].includes(tool);
+}
+function filePathsFromToolInput(input) {
+    if (typeof input !== 'object' || input === null)
+        return [];
+    const record = input;
+    const values = [record.path, record.cwd, record.pattern];
+    if (Array.isArray(record.paths))
+        values.push(...record.paths);
+    return [...new Set(values.filter((value) => typeof value === 'string' && value.length > 0))];
+}
+function isSnapshot(value) {
+    return typeof value === 'object' && value !== null && 'id' in value && typeof value.id === 'string';
+}
+function abortError() {
+    const error = new Error('Task cancelled');
+    error.name = 'AbortError';
+    return error;
+}
+function isAbortError(error) {
+    return error instanceof Error && (error.name === 'AbortError' || /aborted|cancelled|canceled/i.test(error.message));
+}
+//# sourceMappingURL=session.js.map