@agent-harness-experimental/adapter-pi 0.0.0 → 0.0.1

package/dist/split-runtime.js

@@ -0,0 +1,894 @@
+import { attachSplitSandboxContext, detachSplitSandbox, getSandboxRuntimeLayout, startSplitSandbox, stopSplitSandbox, } from 'agent-harness-experimental';
+import { withVercelSandboxBackend } from '@agent-harness-experimental/sandbox-vercel';
+import { Type } from '@sinclair/typebox';
+import { z } from 'zod';
+import { existsSync } from 'node:fs';
+import { mkdir } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { createPiModelResolver } from './model-resolver.mjs';
+import { createPrepareStepBridge, createPrepareStepExtension } from './prepare-step-extension.js';
+import { createRemoteOperations, createSplitPathMapper } from './remote-ops.js';
+import { createDelegateToolDescription, createSubagentPrompt, filterAgentToolNames } from './shared.js';
+import { PI_SPLIT_BUILTIN_NAMES, PI_VFS_ROOT, REQUEST_HOST_ACCESS_TOOL_NAME, buildRemotePiMetadata, configureAuth, createReplayProxies, extractAssistantText, getErrorText, getPiTerminalError, loadPiCodingAgent, resolveReplayProxyTargets, serializeToolOutput, parseSplitPiAdapterState, } from './split-runtime-support.js';
+import { syncLocalWorkspaceFromSandbox, writeLocalWorkspaceFile } from './workspace-mirror.js';
+import { PiWorkspaceVfs } from './workspace-vfs.js';
+import { msg as protocolMessage } from '@agent-harness-experimental/protocol';
+export { __setPiCodingAgentModuleLoaderForTests, configureAuth, resolveReplayProxyTargets } from './split-runtime-support.js';
+const piSessionEventSchema = z
+    .object({
+    type: z.string(),
+    assistantMessageEvent: z.object({ type: z.string().optional(), delta: z.string().optional() }).passthrough().optional(),
+    toolCallId: z.string().optional(),
+    toolName: z.string().optional(),
+    input: z.unknown().optional(),
+    content: z.unknown().optional(),
+    isError: z.boolean().optional(),
+    error: z.union([z.string(), z.object({ errorMessage: z.string().optional(), stopReason: z.string().optional() }).passthrough()]).optional(),
+    message: z
+        .object({
+        role: z.string().optional(),
+        content: z.unknown().optional(),
+        stopReason: z.string().optional(),
+        errorMessage: z.string().optional(),
+    })
+        .passthrough()
+        .optional(),
+})
+    .passthrough();
+function parseNativeEvent(raw) {
+    return piSessionEventSchema.parse(raw);
+}
+export class SplitPiRuntime {
+    options;
+    splitSandboxImageName;
+    ctx = null;
+    splitSandbox = null;
+    workspaceVfs = new PiWorkspaceVfs();
+    session = null;
+    resourceLoader = null;
+    authStorage = null;
+    modelRegistry = null;
+    settingsManager = null;
+    resolverEnv = process.env;
+    localRoot = null;
+    localWorkDir = null;
+    localAgentDir = null;
+    localSessionDir = null;
+    logicalRoot = null;
+    logicalWorkDir = null;
+    logicalAgentDir = null;
+    logicalSessionDir = null;
+    sessionFile;
+    importedState;
+    unsubscribeSession = null;
+    pendingToolResults = new Map();
+    pendingToolDecisions = new Map();
+    observedToolNames = new Map();
+    currentInstructions;
+    turnTerminalError;
+    resolveTurnTerminalError;
+    resolvePromptPause;
+    resolvePromptCompletion;
+    promptStarted = false;
+    streamedAssistantText = '';
+    replayProxies = [];
+    prepareStepBridge = createPrepareStepBridge();
+    constructor(options, splitSandboxImageName) {
+        this.options = options;
+        this.splitSandboxImageName = splitSandboxImageName;
+    }
+    importState(state) {
+        this.importedState = parseSplitPiAdapterState(state);
+    }
+    exportState() {
+        if (!this.localRoot && !this.sessionFile) {
+            return undefined;
+        }
+        return {
+            ...(this.localRoot ? { localRoot: this.localRoot } : {}),
+            ...(this.sessionFile ? { sessionFile: this.sessionFile } : {}),
+        };
+    }
+    resolveLocalPaths(sessionId) {
+        const root = this.importedState?.localRoot ?? path.join(os.tmpdir(), 'ai-sdk-agent', 'pi', sessionId);
+        const safeSessionId = sessionId.replaceAll(/[\\/:\0]/g, '-');
+        const logicalRoot = path.join(PI_VFS_ROOT, safeSessionId);
+        return {
+            localRoot: root,
+            localWorkDir: path.join(root, 'workspace'),
+            localAgentDir: path.join(root, 'agent'),
+            localSessionDir: path.join(root, 'sessions'),
+            logicalRoot,
+            logicalWorkDir: path.join(logicalRoot, 'workspace'),
+            logicalAgentDir: path.join(logicalRoot, 'agent'),
+            logicalSessionDir: path.join(logicalRoot, 'sessions'),
+        };
+    }
+    async ensureLocalMirror(ctx) {
+        const paths = this.resolveLocalPaths(ctx.sessionId);
+        this.localRoot = paths.localRoot;
+        this.localWorkDir = paths.localWorkDir;
+        this.localAgentDir = paths.localAgentDir;
+        this.localSessionDir = paths.localSessionDir;
+        this.logicalRoot = paths.logicalRoot;
+        this.logicalWorkDir = paths.logicalWorkDir;
+        this.logicalAgentDir = paths.logicalAgentDir;
+        this.logicalSessionDir = paths.logicalSessionDir;
+        await mkdir(this.localWorkDir, { recursive: true });
+        await mkdir(this.localAgentDir, { recursive: true });
+        await mkdir(this.localSessionDir, { recursive: true });
+    }
+    mountWorkspaceVfs() {
+        if (!this.localRoot || !this.logicalRoot) {
+            throw new Error('Split Pi local workspace was not initialized');
+        }
+        this.workspaceVfs.mount(this.localRoot, this.logicalRoot);
+    }
+    async syncLocalWorkspace() {
+        if (!this.splitSandbox || !this.localWorkDir) {
+            return;
+        }
+        await syncLocalWorkspaceFromSandbox({
+            sandbox: this.splitSandbox.session,
+            remoteWorkDir: this.splitSandbox.workDir,
+            localWorkDir: this.localWorkDir,
+        });
+    }
+    async waitForToolDecision(requestId, event) {
+        return await new Promise((resolve) => {
+            this.pendingToolDecisions.set(requestId, resolve);
+            this.resolvePromptPause?.();
+            this.resolvePromptPause = undefined;
+            this.ctx?.emit(protocolMessage.toolCall({ requestId, toolName: event.toolName, toolCallId: event.toolCallId, input: event.input }));
+        });
+    }
+    async waitForToolResult(requestId, event) {
+        return await new Promise((resolve) => {
+            this.pendingToolResults.set(requestId, resolve);
+            this.resolvePromptPause?.();
+            this.resolvePromptPause = undefined;
+            this.ctx?.emit(protocolMessage.toolCall({ requestId, toolName: event.toolName, toolCallId: event.toolCallId, input: event.input }));
+        });
+    }
+    async buildToolDefinitions(ctx, modelRegistry, authStorage, input) {
+        if (!this.splitSandbox || !this.localWorkDir || !this.logicalWorkDir) {
+            throw new Error('Split Pi runtime is not started');
+        }
+        const { DefaultResourceLoader, SessionManager, SettingsManager, createAgentSession, defineTool } = await loadPiCodingAgent();
+        const runtime = this;
+        const includedTools = new Set(input.toolNames ?? [
+            ...PI_SPLIT_BUILTIN_NAMES,
+            ...(ctx.requestHostAccess ? [REQUEST_HOST_ACCESS_TOOL_NAME] : []),
+            ...ctx.registeredTools.map((tool) => tool.name),
+        ]);
+        const paths = createSplitPathMapper(this.logicalWorkDir, this.splitSandbox.workDir);
+        const remote = createRemoteOperations({
+            sandbox: this.splitSandbox.session,
+            paths,
+            env: this.splitSandbox.commandEnv,
+            onFileChange: (event, relativePath, content) => {
+                if (runtime.localWorkDir) {
+                    void writeLocalWorkspaceFile(runtime.localWorkDir, relativePath, content);
+                }
+                runtime.ctx?.emit(protocolMessage.fileChange({ event, path: relativePath, content: content.toString('base64') }));
+            },
+        });
+        const definitions = [];
+        const addBuiltin = (schema, args) => {
+            if (!includedTools.has(args.name)) {
+                return;
+            }
+            definitions.push(defineTool({
+                name: args.name,
+                label: args.name,
+                description: args.description,
+                parameters: Type.Unsafe(schema),
+                async execute(toolCallId, params, signal) {
+                    const inputParams = params;
+                    const requestId = toolCallId;
+                    const decision = await runtime.waitForToolDecision(requestId, {
+                        toolName: args.name,
+                        toolCallId,
+                        input: inputParams,
+                    });
+                    runtime.pendingToolDecisions.delete(requestId);
+                    if (!decision.approved) {
+                        return {
+                            content: [
+                                {
+                                    type: 'text',
+                                    text: serializeToolOutput({
+                                        type: 'execution-denied',
+                                        reason: decision.reason ?? 'Tool execution denied',
+                                    }),
+                                },
+                            ],
+                            details: {},
+                        };
+                    }
+                    try {
+                        const output = await args.execute(inputParams, signal);
+                        runtime.ctx?.emit(protocolMessage.toolResult({ toolName: args.name, toolCallId, output }));
+                        return {
+                            content: [{ type: 'text', text: serializeToolOutput(output) }],
+                            details: {},
+                        };
+                    }
+                    catch (error) {
+                        const output = { error: getErrorText(error) };
+                        runtime.ctx?.emit(protocolMessage.toolResult({ toolName: args.name, toolCallId, output }));
+                        return {
+                            content: [{ type: 'text', text: serializeToolOutput(output) }],
+                            details: {},
+                        };
+                    }
+                },
+            }));
+        };
+        addBuiltin({
+            type: 'object',
+            properties: {
+                file_path: { type: 'string' },
+            },
+            required: ['file_path'],
+        }, {
+            name: 'read',
+            description: 'Read file contents',
+            async execute(params) {
+                return (await remote.readBuffer(String(params.file_path ?? ''))).toString('utf8');
+            },
+        });
+        addBuiltin({
+            type: 'object',
+            properties: {
+                file_path: { type: 'string' },
+                content: { type: 'string' },
+            },
+            required: ['file_path', 'content'],
+        }, {
+            name: 'write',
+            description: 'Write content to a file',
+            async execute(params) {
+                await remote.writeFile(String(params.file_path ?? ''), String(params.content ?? ''));
+                return `Wrote ${paths.toRelativePath(paths.toRemotePath(String(params.file_path ?? '')))}`;
+            },
+        });
+        addBuiltin({
+            type: 'object',
+            properties: {
+                file_path: { type: 'string' },
+                old_string: { type: 'string' },
+                new_string: { type: 'string' },
+            },
+            required: ['file_path', 'old_string', 'new_string'],
+        }, {
+            name: 'edit',
+            description: 'Edit a file by replacing text',
+            async execute(params) {
+                await remote.editFile(String(params.file_path ?? ''), String(params.old_string ?? ''), String(params.new_string ?? ''));
+                return `Edited ${paths.toRelativePath(paths.toRemotePath(String(params.file_path ?? '')))}`;
+            },
+        });
+        addBuiltin({
+            type: 'object',
+            properties: {
+                command: { type: 'string' },
+                timeout: { type: 'number' },
+            },
+            required: ['command'],
+        }, {
+            name: 'bash',
+            description: 'Execute a shell command',
+            async execute(params, signal) {
+                const chunks = [];
+                const result = await remote.exec(String(params.command ?? ''), '.', {
+                    signal,
+                    timeout: typeof params.timeout === 'number' ? params.timeout : undefined,
+                    onData(data) {
+                        chunks.push(data);
+                    },
+                });
+                await runtime.syncLocalWorkspace();
+                return `${Buffer.concat(chunks).toString('utf8')}${result.exitCode != null ? `\n\n(exit ${result.exitCode})` : ''}`.trim();
+            },
+        });
+        addBuiltin({
+            type: 'object',
+            properties: {
+                pattern: { type: 'string' },
+                path: { type: 'string' },
+                glob: { type: 'string' },
+                ignoreCase: { type: 'boolean' },
+                literal: { type: 'boolean' },
+                context: { type: 'number' },
+                limit: { type: 'number' },
+            },
+            required: ['pattern'],
+        }, {
+            name: 'grep',
+            description: 'Search file contents',
+            async execute(params) {
+                return await remote.grepFiles(String(params.pattern ?? ''), {
+                    ...(params.path ? { path: String(params.path) } : {}),
+                    ...(params.glob ? { glob: String(params.glob) } : {}),
+                    ...(typeof params.ignoreCase === 'boolean' ? { ignoreCase: params.ignoreCase } : {}),
+                    ...(typeof params.literal === 'boolean' ? { literal: params.literal } : {}),
+                    ...(typeof params.context === 'number' ? { context: params.context } : {}),
+                    ...(typeof params.limit === 'number' ? { limit: params.limit } : {}),
+                });
+            },
+        });
+        addBuiltin({
+            type: 'object',
+            properties: {
+                pattern: { type: 'string' },
+                path: { type: 'string' },
+                limit: { type: 'number' },
+            },
+            required: ['pattern'],
+        }, {
+            name: 'find',
+            description: 'Find files matching a glob pattern',
+            async execute(params) {
+                return (await remote.findFiles(String(params.pattern ?? ''), params.path ? String(params.path) : '.', typeof params.limit === 'number' ? params.limit : 1_000)).join('\n');
+            },
+        });
+        addBuiltin({
+            type: 'object',
+            properties: {
+                path: { type: 'string' },
+                limit: { type: 'number' },
+            },
+        }, {
+            name: 'ls',
+            description: 'List directory contents',
+            async execute(params) {
+                return (await remote.listDirectory(params.path ? String(params.path) : '.', typeof params.limit === 'number' ? params.limit : 500)).join('\n');
+            },
+        });
+        for (const schema of ctx.registeredTools) {
+            if (!includedTools.has(schema.name)) {
+                continue;
+            }
+            definitions.push(defineTool({
+                name: schema.name,
+                label: schema.name,
+                description: schema.description || '',
+                parameters: Type.Unsafe(schema.inputSchema),
+                async execute(toolCallId, params) {
+                    const inputParams = params;
+                    const requestId = toolCallId;
+                    const output = await runtime.waitForToolResult(requestId, {
+                        toolName: schema.name,
+                        toolCallId,
+                        input: inputParams,
+                    });
+                    runtime.pendingToolResults.delete(requestId);
+                    return {
+                        content: [{ type: 'text', text: serializeToolOutput(runtime.buildVisibleToolOutputForAgent(output)) }],
+                        details: {},
+                    };
+                },
+            }));
+        }
+        if (ctx.requestHostAccess && includedTools.has(REQUEST_HOST_ACCESS_TOOL_NAME)) {
+            definitions.push(defineTool({
+                name: REQUEST_HOST_ACCESS_TOOL_NAME,
+                label: REQUEST_HOST_ACCESS_TOOL_NAME,
+                description: 'Request access to an external host when sandbox network access is restricted.',
+                parameters: Type.Unsafe({
+                    type: 'object',
+                    properties: {
+                        host: { type: 'string' },
+                        access: { type: 'string', enum: ['proxy', 'direct'] },
+                        reason: { type: 'string' },
+                    },
+                    required: ['host'],
+                }),
+                async execute(_toolCallId, params) {
+                    const inputParams = params;
+                    const result = await ctx.requestHostAccess?.({
+                        host: String(inputParams.host),
+                        access: inputParams.access === 'proxy' || inputParams.access === 'direct' ? inputParams.access : undefined,
+                        ...(typeof inputParams.reason === 'string' ? { reason: inputParams.reason } : {}),
+                    });
+                    return {
+                        content: [{ type: 'text', text: serializeToolOutput(result) }],
+                        details: {},
+                    };
+                },
+            }));
+        }
+        if (input.allowDelegation && ctx.agents && Object.keys(ctx.agents).length > 0) {
+            definitions.push(defineTool({
+                name: 'delegate_task',
+                label: 'delegate_task',
+                description: createDelegateToolDescription(ctx.agents),
+                parameters: Type.Unsafe({
+                    type: 'object',
+                    properties: {
+                        agent: { type: 'string', enum: Object.keys(ctx.agents) },
+                        task: { type: 'string' },
+                    },
+                    required: ['agent', 'task'],
+                    additionalProperties: false,
+                }),
+                async execute(toolCallId, params) {
+                    const inputParams = params;
+                    const agentName = String(inputParams.agent ?? '');
+                    const task = String(inputParams.task ?? '');
+                    const definition = ctx.agents?.[agentName];
+                    if (!definition || !task || !runtime.logicalWorkDir || !runtime.logicalAgentDir) {
+                        throw new Error('delegate_task requires a valid agent and task');
+                    }
+                    runtime.ctx?.emit(protocolMessage.subagentStart({ agentName, parentToolCallId: toolCallId }));
+                    let usage;
+                    let text = '';
+                    let resolveCompletion;
+                    const completionPromise = new Promise((resolve) => {
+                        resolveCompletion = resolve;
+                    });
+                    const emitMissingAssistantText = (event) => {
+                        const fullText = extractAssistantText(event.message);
+                        if (!fullText) {
+                            return;
+                        }
+                        text = fullText;
+                    };
+                    try {
+                        const childSettingsManager = SettingsManager.inMemory();
+                        const childResourceLoader = new DefaultResourceLoader({
+                            cwd: runtime.logicalWorkDir,
+                            agentDir: runtime.logicalAgentDir,
+                            settingsManager: childSettingsManager,
+                            systemPromptOverride: (base) => [base, createSubagentPrompt(agentName, definition, definition.tools)].filter(Boolean).join('\n\n') || undefined,
+                            appendSystemPromptOverride: () => [],
+                        });
+                        await childResourceLoader.reload();
+                        const childTools = await runtime.buildToolDefinitions(ctx, modelRegistry, authStorage, {
+                            allowDelegation: false,
+                            toolNames: filterAgentToolNames(['read', 'write', 'edit', 'bash', 'grep', 'find', 'ls', REQUEST_HOST_ACCESS_TOOL_NAME, ...ctx.registeredTools.map((tool) => tool.name)], definition.tools),
+                        });
+                        const resolveModel = createPiModelResolver(modelRegistry);
+                        const resolvedModel = resolveModel({ model: runtime.options?.model }, definition.model);
+                        const { session } = await createAgentSession({
+                            cwd: runtime.logicalWorkDir,
+                            agentDir: runtime.logicalAgentDir,
+                            authStorage,
+                            modelRegistry,
+                            sessionManager: SessionManager.inMemory(runtime.logicalWorkDir),
+                            settingsManager: childSettingsManager,
+                            resourceLoader: childResourceLoader,
+                            customTools: childTools,
+                            tools: childTools.map((tool) => tool.name),
+                            ...(runtime.options?.thinkingLevel ? { thinkingLevel: runtime.options.thinkingLevel } : {}),
+                            ...(resolvedModel ? { model: resolvedModel } : {}),
+                        });
+                        const unsubscribe = session.subscribe((rawEvent) => {
+                            const event = parseNativeEvent(rawEvent);
+                            if (event.type === 'message_update' &&
+                                event.assistantMessageEvent?.type === 'text_delta' &&
+                                typeof event.assistantMessageEvent.delta === 'string') {
+                                text += event.assistantMessageEvent.delta;
+                                return;
+                            }
+                            if (event.type === 'message_end' || event.type === 'turn_end') {
+                                emitMissingAssistantText(event);
+                            }
+                            if (event.type === 'agent_end' || event.type === 'turn_end') {
+                                resolveCompletion?.();
+                                resolveCompletion = undefined;
+                            }
+                        });
+                        try {
+                            await session.prompt(task);
+                            await session.agent.waitForIdle();
+                            await completionPromise;
+                        }
+                        finally {
+                            unsubscribe();
+                            session.dispose();
+                        }
+                        const stats = session.getSessionStats?.();
+                        usage = {
+                            inputTokens: stats?.promptTokens ?? stats?.inputTokens ?? 0,
+                            outputTokens: stats?.completionTokens ?? stats?.outputTokens ?? 0,
+                            ...(typeof stats?.cost === 'number' ? { costUsd: stats.cost } : {}),
+                        };
+                    }
+                    finally {
+                        runtime.ctx?.emit(protocolMessage.subagentFinish({ agentName, parentToolCallId: toolCallId, output: { agent: agentName, text }, ...(usage ? { usage } : {}) }));
+                    }
+                    return {
+                        content: [{ type: 'text', text: serializeToolOutput({ agent: agentName, text }) }],
+                        details: {},
+                    };
+                },
+            }));
+        }
+        return definitions;
+    }
+    async start(ctx) {
+        this.ctx = ctx;
+        this.currentInstructions = ctx.instructions;
+        await this.ensureLocalMirror(ctx);
+        if (!this.localWorkDir || !this.localAgentDir || !this.localSessionDir || !this.logicalWorkDir || !this.logicalAgentDir || !this.logicalSessionDir) {
+            throw new Error('Split Pi local mirror was not initialized');
+        }
+        try {
+            const sandboxConfig = withVercelSandboxBackend(ctx.sandboxConfig);
+            if (sandboxConfig?.httpHandler) {
+                this.replayProxies = await createReplayProxies(sandboxConfig.httpHandler, resolveReplayProxyTargets(this.options, process.env));
+            }
+            const { workDir } = getSandboxRuntimeLayout('pi', ctx.sessionId, sandboxConfig);
+            this.splitSandbox = await startSplitSandbox(ctx, {
+                adapterName: 'pi',
+                sessionId: ctx.sessionId,
+                imageName: this.splitSandboxImageName,
+                sandboxConfig,
+                sandboxFiles: buildRemotePiMetadata(ctx, workDir),
+            });
+            this.splitSandbox.networkBroker.notifyPause = () => {
+                this.resolvePromptPause?.();
+                this.resolvePromptPause = undefined;
+            };
+            this.sessionFile = this.importedState?.sessionFile;
+            await this.syncLocalWorkspace();
+            this.mountWorkspaceVfs();
+            await this.initializeHostSession(ctx);
+        }
+        catch (error) {
+            this.unsubscribeSession?.();
+            this.unsubscribeSession = null;
+            this.session?.dispose();
+            this.session = null;
+            this.resourceLoader = null;
+            this.authStorage = null;
+            this.modelRegistry = null;
+            this.settingsManager = null;
+            if (this.splitSandbox) {
+                await stopSplitSandbox(this.splitSandbox);
+            }
+            this.splitSandbox = null;
+            this.workspaceVfs.unmount();
+            await this.closeReplayProxies();
+            throw error;
+        }
+    }
+    async prompt(message, ctx) {
+        if (!this.session || !this.resourceLoader) {
+            throw new Error('Split Pi runtime has not started');
+        }
+        this.attachContext(ctx);
+        this.currentInstructions = ctx.instructions;
+        await this.syncLocalWorkspace();
+        await this.resourceLoader.reload();
+        // Seed the prepare-step bridge with the host's initial step config so
+        // Pi's `before_agent_start` handler can append per-step instructions to
+        // the system prompt for turn 0. Subsequent turns are resolved by the
+        // extension via `ctx.resolvePrepareStep(turnIndex)` on `turn_start`.
+        this.prepareStepBridge.reset();
+        if (ctx.resolvePrepareStep) {
+            try {
+                this.prepareStepBridge.setInitialConfig(await ctx.resolvePrepareStep(0));
+            }
+            catch {
+                // Host failed to resolve an initial step — fall back to no overrides.
+            }
+        }
+        this.turnTerminalError = undefined;
+        this.promptStarted = false;
+        this.streamedAssistantText = '';
+        try {
+            const session = this.session;
+            const completionPromise = new Promise((resolve) => {
+                this.resolvePromptCompletion = resolve;
+            });
+            const promptPromise = (async () => {
+                await session.prompt(message);
+                await session.agent.waitForIdle();
+                await completionPromise;
+            })();
+            let backgroundMode = false;
+            const emitTurnOutcome = () => {
+                const stats = this.session?.getSessionStats?.();
+                if (this.turnTerminalError) {
+                    ctx.emit(protocolMessage.error({ message: this.turnTerminalError }));
+                    return;
+                }
+                ctx.emit(protocolMessage.finish({
+                    finishReason: 'stop',
+                    usage: {
+                        inputTokens: stats?.promptTokens ?? stats?.inputTokens ?? 0,
+                        outputTokens: stats?.completionTokens ?? stats?.outputTokens ?? 0,
+                        ...(typeof stats?.cost === 'number' ? { costUsd: stats.cost } : {}),
+                    },
+                }));
+            };
+            void promptPromise
+                .then(() => {
+                if (backgroundMode) {
+                    emitTurnOutcome();
+                }
+            }, (error) => {
+                if (backgroundMode) {
+                    ctx.emit(protocolMessage.error({ message: this.turnTerminalError ?? getErrorText(error) }));
+                }
+            })
+                .finally(() => {
+                this.resolvePromptPause = undefined;
+                this.resolveTurnTerminalError = undefined;
+                this.resolvePromptCompletion = undefined;
+                this.promptStarted = false;
+                this.streamedAssistantText = '';
+            });
+            const promptResult = await Promise.race([
+                promptPromise.then(() => ({ type: 'complete' })),
+                new Promise((resolve) => {
+                    this.resolveTurnTerminalError = (error) => {
+                        this.resolveTurnTerminalError = undefined;
+                        resolve({ type: 'terminal-error', message: error });
+                    };
+                }),
+                new Promise((resolve) => {
+                    this.resolvePromptPause = () => {
+                        this.resolvePromptPause = undefined;
+                        resolve({ type: 'paused' });
+                    };
+                }),
+            ]);
+            if (promptResult.type === 'paused') {
+                backgroundMode = true;
+                return;
+            }
+            if (promptResult.type === 'terminal-error' || this.turnTerminalError) {
+                ctx.emit(protocolMessage.error({ message: promptResult.type === 'terminal-error' ? promptResult.message : (this.turnTerminalError ?? 'Unknown error') }));
+                return;
+            }
+            emitTurnOutcome();
+        }
+        catch (error) {
+            ctx.emit(protocolMessage.error({ message: this.turnTerminalError ?? getErrorText(error) }));
+        }
+        finally {
+            this.resolvePromptPause = undefined;
+            this.resolveTurnTerminalError = undefined;
+        }
+    }
+    settlePending(reason) {
+        for (const resolve of this.pendingToolResults.values()) {
+            resolve({ error: reason });
+        }
+        this.pendingToolResults.clear();
+        for (const resolve of this.pendingToolDecisions.values()) {
+            resolve({ approved: false, reason });
+        }
+        this.pendingToolDecisions.clear();
+    }
+    async closeReplayProxies() {
+        if (this.replayProxies.length === 0) {
+            return;
+        }
+        const proxies = this.replayProxies;
+        this.replayProxies = [];
+        await Promise.all(proxies.map((proxy) => proxy.close()));
+    }
+    attachContext(ctx) {
+        this.ctx = ctx;
+        this.prepareStepBridge.setCtx(ctx);
+        if (this.splitSandbox) {
+            attachSplitSandboxContext(this.splitSandbox, ctx);
+        }
+        ctx.sendToolResult = (requestId, output) => {
+            this.prepareStepBridge.setResolved(this.buildCurrentPrepareStepConfig(ctx));
+            this.pendingToolResults.get(requestId)?.(output);
+            this.pendingToolResults.delete(requestId);
+        };
+        ctx.sendToolDecision = (requestId, approved, reason) => {
+            this.pendingToolDecisions.get(requestId)?.({ approved, reason });
+            this.pendingToolDecisions.delete(requestId);
+        };
+        ctx.sendUserMessage = (text) => {
+            void this.session?.steer?.(text);
+        };
+        ctx.sendCompact = () => {
+            void this.session?.compact?.();
+        };
+        ctx.abort = () => {
+            void this.session?.abort?.();
+        };
+    }
+    buildCurrentPrepareStepConfig(ctx) {
+        return {
+            ...(ctx.activeTools !== undefined ? { activeTools: [...ctx.activeTools] } : {}),
+            activeSkillNames: (ctx.activeSkills ?? ctx.skills ?? []).map((skill) => skill.name),
+            forcedSkillNames: (ctx.forcedSkills ?? []).map((skill) => skill.name),
+            ...(ctx.instructions !== undefined ? { instructions: ctx.instructions } : {}),
+            ...(ctx.responseFormat !== undefined ? { responseFormat: ctx.responseFormat } : {}),
+        };
+    }
+    buildVisibleToolOutputForAgent(output) {
+        const config = this.prepareStepBridge.getResolved();
+        const nextStep = {
+            note: 'Use this nextStep guidance for your next action.',
+        };
+        if (config?.instructions) {
+            nextStep.instructions = config.instructions;
+        }
+        if (config?.activeTools?.length) {
+            nextStep.activeTools = [...config.activeTools];
+        }
+        if (config?.activeSkillNames?.length) {
+            nextStep.activeSkills = [...config.activeSkillNames];
+        }
+        if (config?.forcedSkillNames?.length) {
+            nextStep.forcedSkills = [...config.forcedSkillNames];
+        }
+        return Object.keys(nextStep).length === 1 ? output : { result: output, nextStep };
+    }
+    bindSession(ctx, session) {
+        this.session = session;
+        this.unsubscribeSession = session.subscribe((rawEvent) => {
+            const event = parseNativeEvent(rawEvent);
+            const terminalError = getPiTerminalError(event);
+            if (terminalError) {
+                this.turnTerminalError = terminalError;
+                this.resolveTurnTerminalError?.(terminalError);
+                this.resolveTurnTerminalError = undefined;
+            }
+            if (event.type === 'message_update') {
+                if (!this.promptStarted) {
+                    return;
+                }
+                const update = event.assistantMessageEvent;
+                if (update?.type === 'text_delta' && typeof update.delta === 'string') {
+                    this.streamedAssistantText += update.delta;
+                    this.ctx?.emit(protocolMessage.textDelta({ delta: update.delta }));
+                }
+                if (update?.type === 'thinking_delta' && typeof update.delta === 'string') {
+                    this.ctx?.emit(protocolMessage.reasoningDelta({ delta: update.delta }));
+                }
+                return;
+            }
+            if (event.type === 'turn_start' || (event.type === 'message_start' && event.message?.role === 'assistant')) {
+                this.promptStarted = true;
+                this.streamedAssistantText = '';
+                return;
+            }
+            if ((event.type === 'message_end' || event.type === 'turn_end') && this.promptStarted) {
+                const fullText = extractAssistantText(event.message);
+                if (fullText.startsWith(this.streamedAssistantText) && fullText.length > this.streamedAssistantText.length) {
+                    const missingText = fullText.slice(this.streamedAssistantText.length);
+                    this.streamedAssistantText = fullText;
+                    this.ctx?.emit(protocolMessage.textDelta({ delta: missingText }));
+                }
+            }
+            if ((event.type === 'agent_end' || event.type === 'turn_end') && this.promptStarted) {
+                this.resolvePromptCompletion?.();
+                this.resolvePromptCompletion = undefined;
+                return;
+            }
+            if (event.type === 'tool_call' && event.toolCallId && event.toolName) {
+                this.observedToolNames.set(event.toolCallId, event.toolName);
+                this.ctx?.emit(protocolMessage.toolCall({
+                    requestId: event.toolCallId,
+                    toolName: event.toolName,
+                    toolCallId: event.toolCallId,
+                    input: event.input,
+                    observeOnly: true,
+                }));
+                return;
+            }
+            if (event.type === 'tool_result' && event.toolCallId) {
+                const toolName = event.toolName ?? this.observedToolNames.get(event.toolCallId);
+                if (!toolName) {
+                    return;
+                }
+                this.ctx?.emit(protocolMessage.toolResult({ toolName, toolCallId: event.toolCallId, output: event.content }));
+            }
+        });
+        this.attachContext(ctx);
+    }
+    async rebuildSession(ctx) {
+        if (!this.logicalWorkDir ||
+            !this.logicalAgentDir ||
+            !this.logicalSessionDir ||
+            !this.resourceLoader ||
+            !this.authStorage ||
+            !this.modelRegistry ||
+            !this.settingsManager) {
+            throw new Error('Split Pi runtime session dependencies are not initialized');
+        }
+        this.unsubscribeSession?.();
+        this.unsubscribeSession = null;
+        this.session?.dispose();
+        this.session = null;
+        await new Promise((resolve) => setTimeout(resolve, 25));
+        const { SessionManager, createAgentSession } = await loadPiCodingAgent();
+        const sessionManager = this.sessionFile && existsSync(this.sessionFile)
+            ? SessionManager.open(this.sessionFile, this.logicalSessionDir, this.logicalWorkDir)
+            : SessionManager.create(this.logicalWorkDir, this.logicalSessionDir);
+        this.sessionFile = sessionManager.getSessionFile?.();
+        const tools = await this.buildToolDefinitions(ctx, this.modelRegistry, this.authStorage, {
+            allowDelegation: true,
+        });
+        const resolveModel = createPiModelResolver(this.modelRegistry, this.resolverEnv);
+        const resolvedModel = resolveModel({ model: this.options?.model });
+        const { session } = await createAgentSession({
+            cwd: this.logicalWorkDir,
+            agentDir: this.logicalAgentDir,
+            authStorage: this.authStorage,
+            modelRegistry: this.modelRegistry,
+            sessionManager,
+            settingsManager: this.settingsManager,
+            resourceLoader: this.resourceLoader,
+            customTools: tools,
+            tools: tools.map((tool) => tool.name),
+            ...(this.options?.thinkingLevel ? { thinkingLevel: this.options.thinkingLevel } : {}),
+            ...(resolvedModel ? { model: resolvedModel } : {}),
+        });
+        this.bindSession(ctx, session);
+    }
+    async initializeHostSession(ctx) {
+        if (!this.logicalWorkDir || !this.logicalAgentDir) {
+            throw new Error('Split Pi local mirror was not initialized');
+        }
+        const { AuthStorage, DefaultResourceLoader, ModelRegistry, SettingsManager } = await loadPiCodingAgent();
+        this.settingsManager = SettingsManager.inMemory();
+        const authPath = path.join(this.logicalAgentDir, 'auth.json');
+        const modelsPath = path.join(this.logicalAgentDir, 'models.json');
+        this.authStorage = AuthStorage.create(authPath);
+        this.modelRegistry = ModelRegistry.create(this.authStorage, modelsPath);
+        this.resolverEnv = configureAuth(this.options, this.authStorage, this.modelRegistry, process.env, Object.fromEntries(this.replayProxies.map((proxy) => [proxy.provider, proxy.baseURL])));
+        this.resourceLoader = new DefaultResourceLoader({
+            cwd: this.logicalWorkDir,
+            agentDir: this.logicalAgentDir,
+            settingsManager: this.settingsManager,
+            systemPromptOverride: (base) => [base, this.currentInstructions].filter(Boolean).join('\n\n') || undefined,
+            appendSystemPromptOverride: () => [],
+            extensionFactories: [createPrepareStepExtension(this.prepareStepBridge)],
+        });
+        await this.resourceLoader.reload();
+        await this.rebuildSession(ctx);
+    }
+    async stop() {
+        this.settlePending('Session stopped');
+        this.unsubscribeSession?.();
+        this.unsubscribeSession = null;
+        this.session?.dispose();
+        this.session = null;
+        this.resourceLoader = null;
+        this.authStorage = null;
+        this.modelRegistry = null;
+        this.settingsManager = null;
+        if (this.splitSandbox) {
+            await stopSplitSandbox(this.splitSandbox);
+        }
+        this.splitSandbox = null;
+        this.workspaceVfs.unmount();
+        await this.closeReplayProxies();
+        this.prepareStepBridge.setCtx(null);
+        this.prepareStepBridge.reset();
+    }
+    async detach() {
+        this.settlePending('Session detached');
+        this.unsubscribeSession?.();
+        this.unsubscribeSession = null;
+        this.session?.dispose();
+        this.session = null;
+        this.resourceLoader = null;
+        this.authStorage = null;
+        this.modelRegistry = null;
+        this.settingsManager = null;
+        if (this.splitSandbox) {
+            detachSplitSandbox(this.splitSandbox);
+        }
+        this.splitSandbox = null;
+        this.workspaceVfs.unmount();
+        await this.closeReplayProxies();
+        this.prepareStepBridge.setCtx(null);
+        this.prepareStepBridge.reset();
+    }
+}
+//# sourceMappingURL=split-runtime.js.map