@undefineds.co/xpod 0.2.45 → 0.3.0

package/dist/api/chatkit/runtime/PtyThreadRuntime.js

@@ -1,791 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PtyThreadRuntime = void 0;
-const path = __importStar(require("node:path"));
-const crypto = __importStar(require("node:crypto"));
-const fs = __importStar(require("node:fs"));
-const os = __importStar(require("node:os"));
-const global_logger_factory_1 = require("global-logger-factory");
-const platform_ai_config_1 = require("../../service/platform-ai-config");
-const runtime_1 = require("../../../runtime");
-const GitWorktreeService_1 = require("./GitWorktreeService");
-const AcpRunner_1 = require("./AcpRunner");
-const provider_registry_1 = require("../../service/provider-registry");
-/**
- * In-memory PTY runtime manager keyed by threadId.
- *
- * Notes:
- * - Runtime state is not persisted; thread metadata can store repo/worktree hints,
- *   but PTY processes are always runtime-local.
- */
-class PtyThreadRuntime {
-    constructor(options = {}) {
-        this.options = options;
-        this.logger = (0, global_logger_factory_1.getLoggerFor)(this);
-        this.git = new GitWorktreeService_1.GitWorktreeService();
-        this.runtimes = new Map();
-    }
-    isRunning(threadId) {
-        return Boolean(this.runtimes.get(threadId)?.runner.isRunning());
-    }
-    async ensureStarted(threadId, cfg) {
-        const existing = this.runtimes.get(threadId);
-        if (existing?.runner.isRunning()) {
-            return existing.state;
-        }
-        const workdir = await this.resolveWorkdir(threadId, cfg.workspace);
-        if (cfg.workspace.type === 'git') {
-            this.git.ensurePathInsideRepo(cfg.workspace.rootPath, workdir);
-        }
-        const protocol = 'acp';
-        if (cfg.runner.protocol && cfg.runner.protocol !== 'acp') {
-            throw new Error(`Unsupported runner protocol: ${cfg.runner.protocol}. Only 'acp' is supported.`);
-        }
-        const argv = this.resolveRunnerArgv(cfg.runner.type, cfg.runner.argv);
-        const command = argv[0];
-        const args = argv.slice(1);
-        const env = this.buildRunnerEnv(cfg.runner.type, threadId, workdir, cfg.agentConfig);
-        const runner = new AcpRunner_1.AcpRunner();
-        runner.start({ command, args, cwd: workdir, env });
-        // ACP handshake + session creation (one session per thread).
-        // We intentionally keep capabilities minimal to avoid the agent calling back into the server.
-        await runner.request('initialize', {
-            protocolVersion: 1,
-            clientCapabilities: {},
-            clientInfo: { name: 'xpod', version: 'dev' },
-        });
-        // Build session/new params — inject MCP servers + system prompt from agent config when available.
-        const sessionParams = { cwd: workdir };
-        const ac = cfg.agentConfig;
-        if (ac) {
-            sessionParams.mcpServers = Object.keys(ac.mcpServers).length > 0
-                ? this.convertMcpServersForAcp(ac.mcpServers)
-                : [];
-            if (ac.systemPrompt)
-                sessionParams.systemPrompt = ac.systemPrompt;
-            if (ac.skillsContent)
-                sessionParams.appendSystemPrompt = ac.skillsContent;
-            if (ac.maxTurns)
-                sessionParams.maxTurns = ac.maxTurns;
-            if (ac.allowedTools)
-                sessionParams.allowedTools = ac.allowedTools;
-            if (ac.disallowedTools)
-                sessionParams.disallowedTools = ac.disallowedTools;
-            if (ac.permissionMode)
-                sessionParams.permissionMode = ac.permissionMode;
-        }
-        else {
-            sessionParams.mcpServers = [];
-        }
-        const newSession = await runner.request('session/new', sessionParams);
-        if (!newSession?.sessionId) {
-            throw new Error('ACP session/new did not return sessionId');
-        }
-        const state = { workdir, runnerType: cfg.runner.type, protocol, argv };
-        this.runtimes.set(threadId, {
-            runner,
-            state,
-            acp: { sessionId: newSession.sessionId, pendingRequests: new Map() },
-            jobs: [],
-            processing: false,
-        });
-        return state;
-    }
-    stop(threadId) {
-        const rt = this.runtimes.get(threadId);
-        if (!rt) {
-            return;
-        }
-        rt.runner.stop('SIGINT');
-    }
-    /**
-     * Write a message to stdin and stream back output deltas.
-     * We serialize jobs per thread to reduce interleaving outputs.
-     */
-    sendMessage(threadId, text, options) {
-        const rt = this.runtimes.get(threadId);
-        if (!rt) {
-            throw new Error('PTY runtime is not started');
-        }
-        const idleMs = options?.idleMs ?? 500;
-        const authWaitMs = Math.max(options?.authWaitMs ?? 300_000, idleMs);
-        const q = new AsyncPushQueue();
-        rt.jobs.push({ input: text, idleMs, authWaitMs, queue: q });
-        void this.processJobs(threadId);
-        return q.iterate();
-    }
-    respondToRequest(threadId, requestId, output, options) {
-        const rt = this.runtimes.get(threadId);
-        if (!rt || rt.state.protocol !== 'acp' || !rt.acp) {
-            throw new Error('ACP runtime is not started');
-        }
-        const pending = rt.acp.pendingRequests.get(requestId);
-        if (!pending) {
-            throw new Error(`ACP request not found: ${requestId}`);
-        }
-        const idleMs = options?.idleMs ?? 500;
-        const authWaitMs = Math.max(options?.authWaitMs ?? 300_000, idleMs);
-        const q = new AsyncPushQueue();
-        void this.continueAfterRequestResponse(rt, pending, requestId, output, idleMs, authWaitMs, q);
-        return q.iterate();
-    }
-    async processJobs(threadId) {
-        const rt = this.runtimes.get(threadId);
-        if (!rt || rt.processing) {
-            return;
-        }
-        rt.processing = true;
-        try {
-            while (rt.jobs.length > 0) {
-                const job = rt.jobs.shift();
-                await this.runJobAcp(rt, job);
-            }
-        }
-        finally {
-            rt.processing = false;
-        }
-    }
-    async runJobAcp(rt, job) {
-        const runner = rt.runner;
-        const sessionId = rt.acp?.sessionId;
-        if (!sessionId) {
-            throw new Error('ACP runtime missing sessionId');
-        }
-        let idleTimer;
-        let done = false;
-        const finish = () => {
-            if (done)
-                return;
-            done = true;
-            if (idleTimer) {
-                clearTimeout(idleTimer);
-                idleTimer = undefined;
-            }
-            runner.off('notification', onNotification);
-            runner.off('request', onRequest);
-            job.queue.close();
-        };
-        const bumpIdle = (ms = job.idleMs) => {
-            if (done)
-                return;
-            if (idleTimer)
-                clearTimeout(idleTimer);
-            idleTimer = setTimeout(() => finish(), ms);
-        };
-        // For MVP:
-        // - auto-ack common "permission"/"auth" style requests, so agents don't deadlock
-        // - surface auth-required as a structured event (so clients can click URL)
-        // - surface text chunks from session/update notifications
-        const onRequest = (req) => {
-            if (!req || typeof req.method !== 'string')
-                return;
-            if (req.method === 'session/request_permission' || req.method === 'auth/request' || req.method === 'auth/authorize') {
-                const hint = req.params?.message || req.params?.reason || req.method;
-                const url = this.extractAuthUrl(req.params);
-                const options = this.extractAuthOptions(req.params) ??
-                    (url ? [{ label: 'Continue in browser', url, method: req.method }] : undefined);
-                job.queue.push({
-                    type: 'auth_required',
-                    method: req.method,
-                    url,
-                    message: typeof hint === 'string' ? hint : undefined,
-                    options,
-                });
-                // Keep stream open longer so users can complete browser-based auth.
-                bumpIdle(job.authWaitMs);
-                // Ack so the runner doesn't deadlock.
-                // For "permission" style requests we grant by default; for auth requests we just acknowledge handling.
-                if (req.method === 'session/request_permission') {
-                    req.respond({ granted: true });
-                }
-                else {
-                    req.respond({ handled: true });
-                }
-                return;
-            }
-            // Map unknown requests to a "tool call" (client must respond via threads.add_client_tool_output).
-            // We end the current stream so the client can send the follow-up request.
-            const pendingId = `acp:${String(req.id)}`;
-            rt.acp.pendingRequests.set(pendingId, {
-                method: req.method,
-                params: req.params,
-                respond: req.respond,
-                fail: req.fail,
-            });
-            job.queue.push({
-                type: 'tool_call',
-                requestId: pendingId,
-                name: req.method,
-                arguments: JSON.stringify(req.params ?? {}),
-            });
-            finish();
-        };
-        const onNotification = (method, params) => {
-            if (method !== 'session/update')
-                return;
-            if (!params || params.sessionId !== sessionId)
-                return;
-            const update = params.update;
-            if (!update || typeof update !== 'object')
-                return;
-            const text = this.extractTextDeltaFromSessionUpdate(update);
-            if (typeof text === 'string' && text.length > 0) {
-                job.queue.push({ type: 'text', text });
-                bumpIdle();
-            }
-        };
-        runner.on('request', onRequest);
-        runner.on('notification', onNotification);
-        try {
-            // Don't await: some agents will block the response until tool-call requests are satisfied.
-            // However, some agents (notably codex-acp) may return the final text in the response,
-            // not via session/update streaming notifications. We therefore attach a best-effort
-            // handler to capture text from the response when available.
-            void runner.request('session/prompt', {
-                sessionId,
-                prompt: [{ type: 'text', text: job.input }],
-            }).then((result) => {
-                const text = this.extractTextFromPromptResult(result);
-                if (typeof text === 'string' && text.length > 0) {
-                    job.queue.push({ type: 'text', text });
-                    bumpIdle();
-                }
-            }).catch((error) => {
-                if (!done) {
-                    this.logger.warn(`ACP session/prompt failed: ${error}`);
-                    const anyErr = error;
-                    const dataMsg = anyErr?.data && typeof anyErr.data === 'object' && typeof anyErr.data.message === 'string'
-                        ? anyErr.data.message
-                        : undefined;
-                    const msg = dataMsg
-                        ? `${String(anyErr?.message ?? error)} | data.message=${dataMsg.slice(0, 800)}`
-                        : String(anyErr?.message ?? error);
-                    job.queue.push({ type: 'error', message: msg });
-                    finish();
-                }
-            });
-            // Some agents return the session/prompt response before streaming the final updates.
-            // We therefore keep listening until the stream goes idle.
-            bumpIdle();
-            await job.queue.waitClosed();
-        }
-        finally {
-            finish();
-        }
-    }
-    async continueAfterRequestResponse(rt, pending, requestId, output, idleMs, authWaitMs, queue) {
-        const runner = rt.runner;
-        const sessionId = rt.acp?.sessionId;
-        if (!sessionId || !rt.acp) {
-            throw new Error('ACP runtime missing session');
-        }
-        let idleTimer;
-        let done = false;
-        const finish = () => {
-            if (done)
-                return;
-            done = true;
-            if (idleTimer) {
-                clearTimeout(idleTimer);
-                idleTimer = undefined;
-            }
-            runner.off('notification', onNotification);
-            runner.off('request', onRequest);
-            queue.close();
-        };
-        const bumpIdle = (ms = idleMs) => {
-            if (done)
-                return;
-            if (idleTimer)
-                clearTimeout(idleTimer);
-            idleTimer = setTimeout(() => finish(), ms);
-        };
-        const onRequest = (req) => {
-            if (!req || typeof req.method !== 'string')
-                return;
-            if (req.method === 'session/request_permission' || req.method === 'auth/request' || req.method === 'auth/authorize') {
-                const hint = req.params?.message || req.params?.reason || req.method;
-                const url = this.extractAuthUrl(req.params);
-                const options = this.extractAuthOptions(req.params) ??
-                    (url ? [{ label: 'Continue in browser', url, method: req.method }] : undefined);
-                queue.push({
-                    type: 'auth_required',
-                    method: req.method,
-                    url,
-                    message: typeof hint === 'string' ? hint : undefined,
-                    options,
-                });
-                // Keep stream open longer so users can complete browser-based auth.
-                bumpIdle(authWaitMs);
-                if (req.method === 'session/request_permission') {
-                    req.respond({ granted: true });
-                }
-                else {
-                    req.respond({ handled: true });
-                }
-                return;
-            }
-            const nestedId = `acp:${String(req.id)}`;
-            rt.acp.pendingRequests.set(nestedId, {
-                method: req.method,
-                params: req.params,
-                respond: req.respond,
-                fail: req.fail,
-            });
-            queue.push({
-                type: 'tool_call',
-                requestId: nestedId,
-                name: req.method,
-                arguments: JSON.stringify(req.params ?? {}),
-            });
-            finish();
-        };
-        const onNotification = (method, params) => {
-            if (method !== 'session/update')
-                return;
-            if (!params || params.sessionId !== sessionId)
-                return;
-            const update = params.update;
-            if (!update || typeof update !== 'object')
-                return;
-            const text = this.extractTextDeltaFromSessionUpdate(update);
-            if (typeof text === 'string' && text.length > 0) {
-                queue.push({ type: 'text', text });
-                bumpIdle();
-            }
-        };
-        runner.on('request', onRequest);
-        runner.on('notification', onNotification);
-        try {
-            rt.acp.pendingRequests.delete(requestId);
-            let result = output;
-            try {
-                result = JSON.parse(output);
-            }
-            catch {
-                // keep raw string
-            }
-            pending.respond(result);
-            bumpIdle();
-            await queue.waitClosed();
-        }
-        finally {
-            finish();
-        }
-    }
-    async resolveWorkdir(threadId, workspace) {
-        if (workspace.type === 'path') {
-            if (!fs.existsSync(workspace.rootPath)) {
-                throw new Error(`workspace.rootPath not found: ${workspace.rootPath}`);
-            }
-            return workspace.rootPath;
-        }
-        // workspace.type === 'git'
-        const repoRoot = workspace.rootPath;
-        const worktree = workspace.worktree;
-        if (worktree.mode === 'existing') {
-            if (!fs.existsSync(worktree.path)) {
-                throw new Error(`worktree.path not found: ${worktree.path}`);
-            }
-            return worktree.path;
-        }
-        await this.git.assertGitRepo(repoRoot);
-        const rootDirName = this.options.worktreeRootDirName ?? '.xpod-worktrees';
-        const root = path.join(repoRoot, rootDirName);
-        const worktreePath = path.join(root, threadId);
-        if (fs.existsSync(worktreePath)) {
-            return worktreePath;
-        }
-        const baseRef = worktree.baseRef ?? 'main';
-        await this.git.createWorktree({
-            repoPath: repoRoot,
-            worktreePath,
-            baseRef,
-            branch: worktree.branch,
-        });
-        return worktreePath;
-    }
-    resolveRunnerArgv(type, argv) {
-        if (argv && argv.length > 0) {
-            return argv;
-        }
-        switch (type) {
-            case 'codebuddy':
-                return [this.resolveLocalBin('codebuddy'), '--acp'];
-            case 'claude':
-                return [this.resolveLocalBin('claude-code-acp')]; // from @zed-industries/claude-code-acp
-            case 'codex':
-                return [this.resolveLocalBin('codex-acp')]; // from @zed-industries/codex-acp
-            default:
-                return [type];
-        }
-    }
-    resolveLocalBin(binName) {
-        const localBin = path.join(runtime_1.PACKAGE_ROOT, 'node_modules', '.bin', binName);
-        if (fs.existsSync(localBin)) {
-            return localBin;
-        }
-        return binName;
-    }
-    buildRunnerEnv(type, threadId, workdir, agentConfig) {
-        // When agentConfig is provided, use its credentials; otherwise fall back to DEFAULT_* env vars.
-        const defaultApiKey = agentConfig?.apiKey || process.env.DEFAULT_API_KEY?.trim();
-        const rawApiBase = agentConfig?.baseUrl || (0, platform_ai_config_1.getPlatformApiBaseUrl)();
-        const defaultModel = agentConfig?.model || process.env.DEFAULT_MODEL?.trim();
-        // CodeBuddy ACP relies on its own local auth state, not OpenAI/Anthropic keys.
-        if (type === 'codebuddy') {
-            return undefined;
-        }
-        // Run external agents with an isolated HOME to avoid:
-        // - polluting the user's real ~/.codex / ~/.claude state
-        // - sandbox permission errors when tools try to write outside workspace roots
-        const home = this.getIsolatedHomeDir(type, threadId, workdir);
-        if (type === 'codex') {
-            // codex-acp speaks OpenAI Responses API by default. Only api.openai.com natively supports it.
-            // For all other providers, configure codex to use wire_api="chat" so it sends
-            // Chat Completions requests directly to the provider instead.
-            const defaultApiBase = rawApiBase || (0, provider_registry_1.getDefaultBaseUrl)();
-            const codexHome = path.join(home, '.codex');
-            this.ensureDir(codexHome);
-            this.ensureDir(path.join(codexHome, 'skills'));
-            this.ensureCodexConfigAndAuth(codexHome, {
-                baseUrl: defaultApiBase,
-                apiKey: defaultApiKey,
-                wireApi: (0, provider_registry_1.codexWireApi)(defaultApiBase),
-            });
-            const env = {
-                HOME: home,
-                XDG_CONFIG_HOME: path.join(home, '.config'),
-                XDG_STATE_HOME: path.join(home, '.local', 'state'),
-                XDG_DATA_HOME: path.join(home, '.local', 'share'),
-                XDG_CACHE_HOME: path.join(home, '.cache'),
-                CODEX_HOME: codexHome,
-            };
-            if (defaultApiKey) {
-                // codex-acp advertises CODEX_API_KEY / OPENAI_API_KEY.
-                env.CODEX_API_KEY = defaultApiKey;
-                env.OPENAI_API_KEY = defaultApiKey;
-            }
-            env.OPENAI_BASE_URL = defaultApiBase;
-            env.OPENAI_API_BASE = defaultApiBase;
-            if (defaultModel) {
-                // Best-effort: may be ignored by codex-acp depending on its config.
-                env.OPENAI_MODEL = defaultModel;
-                env.CODEX_MODEL = defaultModel;
-            }
-            return env;
-        }
-        // type === 'claude'
-        const defaultApiBase = rawApiBase || (0, provider_registry_1.getDefaultBaseUrl)();
-        const env = {
-            HOME: home,
-            XDG_CONFIG_HOME: path.join(home, '.config'),
-            XDG_STATE_HOME: path.join(home, '.local', 'state'),
-            XDG_DATA_HOME: path.join(home, '.local', 'share'),
-            XDG_CACHE_HOME: path.join(home, '.cache'),
-        };
-        const normalizedBase = defaultApiBase ? this.normalizeClaudeBaseUrl(defaultApiBase) : undefined;
-        const isOpenRouterLike = (typeof normalizedBase === 'string' && normalizedBase.includes('openrouter.ai'));
-        if (defaultApiKey) {
-            // claude-code-acp is built on the Claude Agent SDK.
-            // For OpenRouter, the Anthropic-compatible path is typically via AUTH_TOKEN.
-            if (isOpenRouterLike) {
-                env.ANTHROPIC_AUTH_TOKEN = defaultApiKey;
-                delete env.ANTHROPIC_API_KEY;
-            }
-            else {
-                env.ANTHROPIC_API_KEY = defaultApiKey;
-                delete env.ANTHROPIC_AUTH_TOKEN;
-            }
-        }
-        if (normalizedBase) {
-            env.ANTHROPIC_BASE_URL = normalizedBase;
-        }
-        if (defaultModel) {
-            // Use the same model for all families to keep behavior predictable.
-            env.ANTHROPIC_DEFAULT_SONNET_MODEL = defaultModel;
-            env.ANTHROPIC_DEFAULT_HAIKU_MODEL = defaultModel;
-            env.ANTHROPIC_DEFAULT_OPUS_MODEL = defaultModel;
-        }
-        return env;
-    }
-    getIsolatedHomeDir(type, threadId, workdir) {
-        // Keep it stable per thread/workdir so session state can be reused across requests,
-        // but still isolated from the user's actual home.
-        const hash = crypto.createHash('sha256').update(`${type}:${threadId}:${workdir}`).digest('hex').slice(0, 16);
-        const root = path.join(os.tmpdir(), 'xpod-acp-home', type, hash);
-        fs.mkdirSync(root, { recursive: true });
-        return root;
-    }
-    ensureDir(dir) {
-        try {
-            fs.mkdirSync(dir, { recursive: true });
-        }
-        catch {
-            // best-effort: agent binaries may create it themselves
-        }
-    }
-    normalizeClaudeBaseUrl(baseUrl) {
-        if (baseUrl.endsWith('/v1')) {
-            return baseUrl.slice(0, -3);
-        }
-        if (baseUrl.endsWith('/v1/')) {
-            return baseUrl.slice(0, -4);
-        }
-        return baseUrl;
-    }
-    ensureCodexConfigAndAuth(codexHome, options) {
-        // codex-acp wraps Codex CLI, which primarily reads config/auth from CODEX_HOME.
-        // We generate a minimal config + auth file for isolated runs so that:
-        // - it doesn't depend on the developer's ~/.codex
-        // - it can authenticate without interactive login
-        const configPath = path.join(codexHome, 'config.toml');
-        const authPath = path.join(codexHome, 'auth.json');
-        try {
-            const baseUrl = options.baseUrl?.trim();
-            if (baseUrl) {
-                const wireApi = options.wireApi ?? 'responses';
-                const contents = [
-                    'model_provider = "codex"',
-                    '',
-                    '[model_providers.codex]',
-                    'name = "codex"',
-                    `base_url = ${JSON.stringify(baseUrl)}`,
-                    `wire_api = ${JSON.stringify(wireApi)}`,
-                    'requires_openai_auth = true',
-                    '',
-                ].join('\n');
-                fs.writeFileSync(configPath, contents, { encoding: 'utf8' });
-            }
-        }
-        catch (e) {
-            this.logger.debug(`Failed to write Codex config.toml: ${String(e)}`);
-        }
-        try {
-            const apiKey = options.apiKey?.trim();
-            if (apiKey) {
-                // Match Codex's expected schema.
-                fs.writeFileSync(authPath, JSON.stringify({ OPENAI_API_KEY: apiKey }), { encoding: 'utf8' });
-            }
-        }
-        catch (e) {
-            this.logger.debug(`Failed to write Codex auth.json: ${String(e)}`);
-        }
-    }
-    /**
-     * Convert McpServerConfig map to ACP session/new format.
-     * ACP expects an array of { name, ...config } objects.
-     */
-    convertMcpServersForAcp(servers) {
-        return Object.entries(servers).map(([name, config]) => ({
-            name,
-            ...config,
-        }));
-    }
-    extractTextDeltaFromSessionUpdate(update) {
-        if (!update)
-            return undefined;
-        // Common shapes:
-        // - { sessionUpdate/type: 'agent_message_chunk', content: { type:'text', text:'...' } }
-        // - { ... , delta/text/content: '...' }
-        // - { ... , message: { content: [{ type:'text', text:'...' }, ...] } }
-        if (typeof update === 'string')
-            return update;
-        if (typeof update.delta === 'string')
-            return update.delta;
-        if (typeof update.text === 'string')
-            return update.text;
-        const content = update.content?.content ?? update.content;
-        if (typeof content === 'string')
-            return content;
-        if (content && typeof content === 'object') {
-            if (typeof content.text === 'string')
-                return content.text;
-            if (Array.isArray(content)) {
-                const parts = content
-                    .map((p) => (p && typeof p === 'object' ? p.text : undefined))
-                    .filter((t) => typeof t === 'string');
-                if (parts.length)
-                    return parts.join('');
-            }
-        }
-        const message = update.message ?? update.item ?? update.assistant_message;
-        if (message && typeof message === 'object') {
-            const msgContent = message.content?.content ?? message.content;
-            if (typeof msgContent === 'string')
-                return msgContent;
-            if (Array.isArray(msgContent)) {
-                const parts = msgContent
-                    .map((p) => {
-                    if (!p || typeof p !== 'object')
-                        return undefined;
-                    if (typeof p.text === 'string')
-                        return p.text;
-                    if (typeof p.delta === 'string')
-                        return p.delta;
-                    return undefined;
-                })
-                    .filter((t) => typeof t === 'string');
-                if (parts.length)
-                    return parts.join('');
-            }
-        }
-        return undefined;
-    }
-    extractTextFromPromptResult(result) {
-        if (!result)
-            return undefined;
-        if (typeof result === 'string')
-            return result;
-        // Common shapes observed in ACP implementations:
-        // - { message: { content: [{ type:'text', text:'...' }, ...] } }
-        // - { output_text: '...' } / { text: '...' }
-        // - { content: [{...}] }
-        if (typeof result.text === 'string')
-            return result.text;
-        if (typeof result.output_text === 'string')
-            return result.output_text;
-        const message = result.message ?? result.item ?? result.assistant_message;
-        if (message && typeof message === 'object') {
-            const msgContent = message.content?.content ?? message.content;
-            if (typeof msgContent === 'string')
-                return msgContent;
-            if (Array.isArray(msgContent)) {
-                const parts = msgContent
-                    .map((p) => (p && typeof p === 'object' ? (typeof p.text === 'string' ? p.text : undefined) : undefined))
-                    .filter((t) => typeof t === 'string');
-                if (parts.length)
-                    return parts.join('');
-            }
-        }
-        const content = result.content?.content ?? result.content;
-        if (typeof content === 'string')
-            return content;
-        if (Array.isArray(content)) {
-            const parts = content
-                .map((p) => (p && typeof p === 'object' ? (typeof p.text === 'string' ? p.text : undefined) : undefined))
-                .filter((t) => typeof t === 'string');
-            if (parts.length)
-                return parts.join('');
-        }
-        return undefined;
-    }
-    extractAuthUrl(params) {
-        if (!params || typeof params !== 'object')
-            return undefined;
-        const candidates = [
-            params.url,
-            params.authorizationUrl,
-            params.authorization_url,
-            params.authUrl,
-            params.auth_url,
-            params.browserUrl,
-            params.browser_url,
-            params.verification_uri,
-            params.verificationUri,
-            params.verificationUrl,
-        ];
-        const found = candidates.find((v) => typeof v === 'string' && v.startsWith('http'));
-        return found;
-    }
-    extractAuthOptions(params) {
-        if (!params || typeof params !== 'object')
-            return undefined;
-        const raw = Array.isArray(params.methods) ? params.methods
-            : Array.isArray(params.options) ? params.options
-                : Array.isArray(params.authMethods) ? params.authMethods
-                    : Array.isArray(params.auth_methods) ? params.auth_methods
-                        : undefined;
-        if (!raw)
-            return undefined;
-        const opts = raw
-            .map((m) => {
-            if (!m || typeof m !== 'object')
-                return undefined;
-            const url = this.extractAuthUrl(m);
-            const label = typeof m.label === 'string' ? m.label :
-                typeof m.name === 'string' ? m.name :
-                    typeof m.type === 'string' ? m.type :
-                        undefined;
-            const method = typeof m.method === 'string' ? m.method :
-                typeof m.type === 'string' ? m.type :
-                    undefined;
-            return { label, url, method };
-        })
-            .filter(Boolean);
-        return opts.length > 0 ? opts : undefined;
-    }
-}
-exports.PtyThreadRuntime = PtyThreadRuntime;
-class AsyncPushQueue {
-    constructor() {
-        this.items = [];
-        this.resolvers = [];
-        this._closed = false;
-        this.closeResolvers = [];
-    }
-    push(item) {
-        if (this._closed) {
-            return;
-        }
-        this.items.push(item);
-        const r = this.resolvers.shift();
-        r?.();
-    }
-    close() {
-        if (this._closed) {
-            return;
-        }
-        this._closed = true;
-        for (const r of this.resolvers) {
-            r();
-        }
-        this.resolvers = [];
-        for (const r of this.closeResolvers) {
-            r();
-        }
-        this.closeResolvers = [];
-    }
-    async waitClosed() {
-        if (this._closed) {
-            return;
-        }
-        await new Promise((resolve) => this.closeResolvers.push(resolve));
-    }
-    async *iterate() {
-        while (true) {
-            if (this.items.length > 0) {
-                yield this.items.shift();
-                continue;
-            }
-            if (this._closed) {
-                return;
-            }
-            await new Promise((resolve) => this.resolvers.push(resolve));
-        }
-    }
-}
-//# sourceMappingURL=PtyThreadRuntime.js.map