@undefineds.co/xpod 0.2.45 → 0.3.0

package/dist/api/runs/PiAgentRuntimeDriver.d.ts

@@ -0,0 +1,66 @@
+import type { AgentRuntimeEvent } from './AgentRuntimeTypes';
+import type { RunExecutionBackend, RunExecutionInput } from './RunExecutionBackend';
+type PiSdk = typeof import('@mariozechner/pi-coding-agent');
+export interface PiAgentRuntimeDriverOptions {
+    /**
+     * local: run pi's full Agent Loop in the API process.
+     * cloud: run the entire pi Agent Loop in a sandboxed worker process.
+     */
+    agentLoopIsolation?: 'in-process' | 'sandboxed-process';
+    /**
+     * Cloud defaults to strict sandboxing: do not fall back to an unsandboxed
+     * process if sandbox-exec/bubblewrap is unavailable.
+     */
+    requireSandbox?: boolean;
+    workerPath?: string;
+    sandboxedLoopRunner?: (input: RunExecutionInput, workdir: string) => AsyncIterable<AgentRuntimeEvent>;
+    sessionRootDir?: string;
+    /**
+     * Off by default: pi sessions are request-scoped implementation detail. When
+     * enabled, the JSONL session is a diagnostic copy only; Xpod still restores
+     * authoritative state from Run/Thread/Message before each execution.
+     */
+    persistPiSessions?: boolean;
+    piSdk?: PiSdk;
+}
+/**
+ * Request-scoped adapter around pi's AgentSession primitives.
+ *
+ * Xpod restores durable conversation state into pi with replaceMessages() on
+ * every run. pi owns the atomic agent loop, tools and streaming events for the
+ * current invocation only; its SessionManager is not the Xpod state center.
+ */
+export declare class PiAgentRuntimeDriver implements RunExecutionBackend {
+    private readonly options;
+    private static sdkPromise?;
+    private readonly git;
+    private readonly warmRuntimes;
+    constructor(options?: PiAgentRuntimeDriverOptions);
+    start(input: RunExecutionInput): AsyncIterable<AgentRuntimeEvent>;
+    private startInProcess;
+    private startSandboxedAgentLoop;
+    private projectPiEvent;
+    private resolvePiConfig;
+    private resolveProviderId;
+    private resolveApiForBaseUrl;
+    private resolveThinkingLevel;
+    private resolveTools;
+    private getWarmRuntime;
+    private createWarmRuntime;
+    private warmRuntimeKey;
+    private hashSecret;
+    private toPiMessages;
+    private resolveWorkdir;
+    private canResolveFileWorkspace;
+    private mapPodUrlToLocalPath;
+    private createSessionManager;
+    private resolveSessionDir;
+    private resolveWorkerPath;
+    private workerEnv;
+    private extractText;
+    private formatError;
+    private startupErrorToEvent;
+    private loadPiSdk;
+}
+export declare const PI_AGENT_WORKER_EVENT_PREFIX = "XPOD_AGENT_EVENT ";
+export {};

package/dist/api/runs/PiAgentRuntimeDriver.js

@@ -0,0 +1,614 @@
+"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.PI_AGENT_WORKER_EVENT_PREFIX = exports.PiAgentRuntimeDriver = void 0;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const os = __importStar(require("node:os"));
+const crypto = __importStar(require("node:crypto"));
+const node_readline_1 = require("node:readline");
+const provider_registry_1 = require("../service/provider-registry");
+const platform_ai_config_1 = require("../service/platform-ai-config");
+const GitWorktreeService_1 = require("../chatkit/runtime/GitWorktreeService");
+const sandbox_1 = require("../../terminal/sandbox");
+/**
+ * Request-scoped adapter around pi's AgentSession primitives.
+ *
+ * Xpod restores durable conversation state into pi with replaceMessages() on
+ * every run. pi owns the atomic agent loop, tools and streaming events for the
+ * current invocation only; its SessionManager is not the Xpod state center.
+ */
+class PiAgentRuntimeDriver {
+    constructor(options = {}) {
+        this.options = options;
+        this.git = new GitWorktreeService_1.GitWorktreeService();
+        this.warmRuntimes = new Map();
+    }
+    async *start(input) {
+        if (this.options.agentLoopIsolation === 'sandboxed-process') {
+            try {
+                const workdir = await this.resolveWorkdir(input.threadId, input.config.workspace, input.config);
+                const runner = this.options.sandboxedLoopRunner
+                    ?? ((runInput, runWorkdir) => this.startSandboxedAgentLoop(runInput, runWorkdir));
+                for await (const event of runner(input, workdir)) {
+                    yield event;
+                }
+            }
+            catch (error) {
+                yield this.startupErrorToEvent(error);
+            }
+            return;
+        }
+        yield* this.startInProcess(input);
+    }
+    async *startInProcess(input) {
+        const queue = new AsyncPushQueue();
+        let session;
+        try {
+            const runtime = await this.getWarmRuntime(input);
+            const sessionManager = this.createSessionManager(runtime.pi, input.runId, runtime.workdir);
+            const result = await runtime.pi.createAgentSession({
+                cwd: runtime.workdir,
+                authStorage: runtime.authStorage,
+                modelRegistry: runtime.modelRegistry,
+                settingsManager: runtime.settingsManager,
+                sessionManager,
+                resourceLoader: runtime.resourceLoader,
+                model: runtime.piConfig.model,
+                thinkingLevel: runtime.thinkingLevel,
+                tools: runtime.tools,
+            });
+            session = result.session;
+            session.agent.replaceMessages(this.toPiMessages(input.conversation, runtime.piConfig));
+            const streamState = {
+                lastAssistantText: '',
+                assistantTextStreamed: false,
+            };
+            const unsubscribe = session.subscribe((event) => {
+                this.projectPiEvent(event, queue, streamState);
+            });
+            void session.prompt(input.prompt, { expandPromptTemplates: false, source: 'rpc' }).then(() => {
+                if (!streamState.assistantTextStreamed && streamState.lastAssistantText.length > 0) {
+                    queue.push({ type: 'text', text: streamState.lastAssistantText });
+                }
+                queue.close();
+            }).catch((error) => {
+                queue.push({ type: 'error', message: this.formatError(error) });
+                queue.close();
+            }).finally(() => {
+                unsubscribe();
+                session?.dispose();
+            });
+            for await (const event of queue.iterate()) {
+                yield event;
+            }
+        }
+        catch (error) {
+            session?.dispose();
+            yield this.startupErrorToEvent(error);
+        }
+    }
+    startSandboxedAgentLoop(input, workdir) {
+        const queue = new AsyncPushQueue();
+        const requireSandbox = this.options.requireSandbox ?? true;
+        if (requireSandbox && !sandbox_1.SandboxFactory.isAvailable()) {
+            queue.push({ type: 'error', message: 'Cloud Agent Runtime requires an OS sandbox, but none is available on this host' });
+            queue.close();
+            return queue.iterate();
+        }
+        const child = sandbox_1.SandboxFactory.launch({
+            workdir,
+            command: process.execPath,
+            args: [this.resolveWorkerPath()],
+            env: this.workerEnv(),
+            isolateNetwork: false,
+        });
+        if (requireSandbox && !child.sandboxed) {
+            child.process.kill();
+            queue.push({ type: 'error', message: 'Cloud Agent Runtime refused to run without a sandbox' });
+            queue.close();
+            return queue.iterate();
+        }
+        const stderrChunks = [];
+        const stderrMaxBytes = 16 * 1024;
+        let closed = false;
+        const closeOnce = () => {
+            if (closed) {
+                return;
+            }
+            closed = true;
+            queue.close();
+        };
+        child.process.stdin?.end(JSON.stringify({
+            input,
+            options: {
+                persistPiSessions: this.options.persistPiSessions === true,
+                sessionRootDir: this.options.sessionRootDir,
+            },
+        }));
+        const rl = (0, node_readline_1.createInterface)({ input: child.process.stdout });
+        rl.on('line', (line) => {
+            if (!line.startsWith(exports.PI_AGENT_WORKER_EVENT_PREFIX)) {
+                return;
+            }
+            const payload = line.slice(exports.PI_AGENT_WORKER_EVENT_PREFIX.length);
+            try {
+                queue.push(JSON.parse(payload));
+            }
+            catch (error) {
+                queue.push({ type: 'error', message: `Invalid Agent Runtime worker event: ${this.formatError(error)}` });
+            }
+        });
+        child.process.stderr?.on('data', (chunk) => {
+            if (Buffer.concat(stderrChunks).length < stderrMaxBytes) {
+                stderrChunks.push(chunk);
+            }
+        });
+        child.process.on('error', (error) => {
+            queue.push({ type: 'error', message: `Agent Runtime worker failed to start: ${this.formatError(error)}` });
+            closeOnce();
+        });
+        child.process.on('close', (code, signal) => {
+            rl.close();
+            if (code !== 0) {
+                const stderr = Buffer.concat(stderrChunks).toString('utf-8').trim();
+                const suffix = stderr ? `: ${stderr}` : signal ? ` (signal ${signal})` : '';
+                queue.push({ type: 'error', message: `Agent Runtime worker exited with code ${code ?? 'null'}${suffix}` });
+            }
+            closeOnce();
+        });
+        return queue.iterate();
+    }
+    projectPiEvent(event, queue, state) {
+        if (event.type === 'message_update' && event.assistantMessageEvent?.type === 'text_delta') {
+            queue.push({ type: 'text', text: event.assistantMessageEvent.delta });
+            state.assistantTextStreamed = true;
+            return;
+        }
+        if (event.type === 'message_update' && event.message.role === 'assistant') {
+            state.lastAssistantText = this.extractText(event.message.content);
+            return;
+        }
+        if (event.type === 'message_end' && event.message.role === 'assistant') {
+            const finalText = this.extractText(event.message.content);
+            const alreadyStreamed = state.assistantTextStreamed;
+            state.lastAssistantText = '';
+            state.assistantTextStreamed = false;
+            if (!alreadyStreamed && finalText.length > 0) {
+                queue.push({ type: 'text', text: finalText });
+            }
+            return;
+        }
+        // pi emits tool_execution_start for its own read/bash/edit/write tools.
+        // Those are internal runtime activity, not client-side tool requests.
+    }
+    resolvePiConfig(config) {
+        const baseUrl = config.agentConfig?.baseUrl || (0, platform_ai_config_1.getPlatformApiBaseUrl)();
+        const provider = this.resolveProviderId(baseUrl);
+        const apiKey = config.agentConfig?.apiKey || (0, platform_ai_config_1.getPlatformApiKey)();
+        if (!apiKey) {
+            throw new Error('No API key configured for pi Agent Runtime. Store the agent credential in the Pod or set DEFAULT_API_KEY for local development.');
+        }
+        const resolvedBaseUrl = baseUrl || (0, provider_registry_1.getDefaultBaseUrl)(provider);
+        const modelId = config.agentConfig?.model || (0, platform_ai_config_1.getPlatformDefaultModel)();
+        const api = this.resolveApiForBaseUrl(resolvedBaseUrl);
+        return {
+            provider,
+            apiKey,
+            api,
+            baseUrl: resolvedBaseUrl,
+            model: {
+                id: modelId,
+                name: modelId,
+                api,
+                provider,
+                baseUrl: resolvedBaseUrl,
+                reasoning: false,
+                input: ['text'],
+                cost: {
+                    input: 0,
+                    output: 0,
+                    cacheRead: 0,
+                    cacheWrite: 0,
+                },
+                contextWindow: 128_000,
+                maxTokens: 8192,
+                compat: api === 'openai-completions'
+                    ? {
+                        supportsStore: false,
+                        supportsDeveloperRole: false,
+                        supportsReasoningEffort: false,
+                    }
+                    : undefined,
+            },
+        };
+    }
+    resolveProviderId(baseUrl) {
+        const configured = (0, platform_ai_config_1.getPlatformProviderId)();
+        if (configured && configured !== 'undefineds') {
+            return configured;
+        }
+        if (!baseUrl) {
+            return 'xpod';
+        }
+        try {
+            const host = new URL(baseUrl).hostname;
+            if (host.includes('openai.com'))
+                return 'openai';
+            if (host.includes('anthropic.com'))
+                return 'anthropic';
+            if (host.includes('openrouter.ai'))
+                return 'openrouter';
+            if (host.includes('deepseek.com'))
+                return 'deepseek';
+            if (host.includes('mistral.ai'))
+                return 'mistral';
+            if (host === 'localhost' || host === '127.0.0.1')
+                return 'ollama';
+        }
+        catch {
+            // fall through to xpod
+        }
+        return 'xpod';
+    }
+    resolveApiForBaseUrl(baseUrl) {
+        try {
+            const host = new URL(baseUrl).hostname;
+            return host === 'api.openai.com' ? 'openai-responses' : 'openai-completions';
+        }
+        catch {
+            return 'openai-completions';
+        }
+    }
+    resolveThinkingLevel(config) {
+        const level = config.agentConfig?.thinkingLevel;
+        return level === 'minimal' || level === 'low' || level === 'medium' || level === 'high' || level === 'xhigh'
+            ? level
+            : 'off';
+    }
+    resolveTools(pi, workdir, config) {
+        const permissionMode = config.agentConfig?.permissionMode;
+        const allowed = new Set(config.agentConfig?.allowedTools?.map((tool) => tool.toLowerCase()) ?? []);
+        const disallowed = new Set(config.agentConfig?.disallowedTools?.map((tool) => tool.toLowerCase()) ?? []);
+        const baseTools = permissionMode === 'plan' || allowed.size > 0
+            ? pi.createReadOnlyTools(workdir)
+            : pi.createCodingTools(workdir);
+        return baseTools.filter((tool) => {
+            const name = tool.name.toLowerCase();
+            if (disallowed.has(name)) {
+                return false;
+            }
+            return allowed.size === 0 || allowed.has(name);
+        });
+    }
+    async getWarmRuntime(input) {
+        const pi = await this.loadPiSdk();
+        const workdir = await this.resolveWorkdir(input.threadId, input.config.workspace, input.config);
+        const key = this.warmRuntimeKey(workdir, input.config);
+        const existing = this.warmRuntimes.get(key);
+        if (existing) {
+            return existing;
+        }
+        const created = this.createWarmRuntime(pi, workdir, input.config).catch((error) => {
+            this.warmRuntimes.delete(key);
+            throw error;
+        });
+        this.warmRuntimes.set(key, created);
+        return created;
+    }
+    async createWarmRuntime(pi, workdir, config) {
+        const piConfig = this.resolvePiConfig(config);
+        const authStorage = pi.AuthStorage.inMemory();
+        authStorage.setRuntimeApiKey(piConfig.provider, piConfig.apiKey);
+        const modelRegistry = new pi.ModelRegistry(authStorage, undefined);
+        modelRegistry.registerProvider(piConfig.provider, {
+            baseUrl: piConfig.baseUrl,
+            apiKey: piConfig.apiKey,
+            api: piConfig.api,
+            models: [piConfig.model],
+        });
+        const thinkingLevel = this.resolveThinkingLevel(config);
+        const settingsManager = pi.SettingsManager.inMemory({
+            defaultProvider: piConfig.provider,
+            defaultModel: piConfig.model.id,
+            defaultThinkingLevel: thinkingLevel,
+        });
+        const resourceLoader = new pi.DefaultResourceLoader({
+            cwd: workdir,
+            settingsManager,
+            systemPrompt: config.agentConfig?.systemPrompt,
+            appendSystemPrompt: config.agentConfig?.skillsContent,
+            noExtensions: true,
+            noSkills: true,
+            noPromptTemplates: true,
+            noThemes: true,
+        });
+        await resourceLoader.reload();
+        return {
+            pi,
+            workdir,
+            piConfig,
+            thinkingLevel,
+            authStorage,
+            modelRegistry,
+            settingsManager,
+            resourceLoader,
+            tools: this.resolveTools(pi, workdir, config),
+        };
+    }
+    warmRuntimeKey(workdir, config) {
+        const agent = config.agentConfig;
+        return JSON.stringify({
+            workdir,
+            baseUrl: agent?.baseUrl ?? (0, platform_ai_config_1.getPlatformApiBaseUrl)(),
+            model: agent?.model ?? (0, platform_ai_config_1.getPlatformDefaultModel)(),
+            apiKeyHash: this.hashSecret(agent?.apiKey ?? (0, platform_ai_config_1.getPlatformApiKey)()),
+            systemPrompt: agent?.systemPrompt ?? '',
+            skillsContent: agent?.skillsContent ?? '',
+            permissionMode: agent?.permissionMode ?? '',
+            allowedTools: agent?.allowedTools ?? [],
+            disallowedTools: agent?.disallowedTools ?? [],
+            persistPiSessions: this.options.persistPiSessions === true,
+            agentLoopIsolation: this.options.agentLoopIsolation ?? 'in-process',
+            thinkingLevel: this.resolveThinkingLevel(config),
+        });
+    }
+    hashSecret(value) {
+        return value
+            ? crypto.createHash('sha256').update(value).digest('hex').slice(0, 16)
+            : '';
+    }
+    toPiMessages(conversation, config) {
+        return conversation.map((message) => {
+            if (message.role === 'user') {
+                return {
+                    role: 'user',
+                    content: [{ type: 'text', text: message.text }],
+                    timestamp: message.createdAt * 1000,
+                };
+            }
+            return {
+                role: 'assistant',
+                content: [{ type: 'text', text: message.text }],
+                api: config.api,
+                provider: config.provider,
+                model: config.model.id,
+                usage: {
+                    input: 0,
+                    output: 0,
+                    cacheRead: 0,
+                    cacheWrite: 0,
+                    totalTokens: 0,
+                    cost: {
+                        input: 0,
+                        output: 0,
+                        cacheRead: 0,
+                        cacheWrite: 0,
+                        total: 0,
+                    },
+                },
+                stopReason: 'stop',
+                timestamp: message.createdAt * 1000,
+            };
+        });
+    }
+    async resolveWorkdir(threadId, workspace, config) {
+        const url = new URL(workspace);
+        let workdir;
+        if (url.protocol === 'http:' || url.protocol === 'https:') {
+            const mapped = this.mapPodUrlToLocalPath(workspace);
+            if (!mapped || !fs.existsSync(mapped)) {
+                throw new WaitingRunnerError(workspace, `Workspace is not mounted on this runner: ${workspace}`);
+            }
+            workdir = mapped;
+        }
+        else if (url.protocol === 'file:') {
+            if (!this.canResolveFileWorkspace(url)) {
+                throw new WaitingRunnerError(workspace, `Waiting for a runner that can resolve workspace ${workspace}`);
+            }
+            workdir = decodeURIComponent(url.pathname);
+            if (!fs.existsSync(workdir)) {
+                throw new Error(`workspace URI does not exist on this runner: ${workspace}`);
+            }
+        }
+        else {
+            throw new Error(`Unsupported workspace URI protocol: ${url.protocol}`);
+        }
+        const worktree = config?.worktree;
+        if (!worktree) {
+            return workdir;
+        }
+        const repoRoot = workdir;
+        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 root = path.join(repoRoot, '.xpod-worktrees');
+        const worktreePath = path.join(root, threadId);
+        if (fs.existsSync(worktreePath)) {
+            return worktreePath;
+        }
+        await this.git.createWorktree({
+            repoPath: repoRoot,
+            worktreePath,
+            baseRef: worktree.baseRef ?? 'main',
+            branch: worktree.branch,
+        });
+        return worktreePath;
+    }
+    canResolveFileWorkspace(url) {
+        const authority = url.hostname;
+        if (!authority || authority === 'localhost') {
+            return true;
+        }
+        const configured = process.env.XPOD_RUNNER_AUTHORITY?.trim();
+        return authority === configured || authority === os.hostname();
+    }
+    mapPodUrlToLocalPath(rootUrl) {
+        const rootFilePath = process.env.CSS_ROOT_FILE_PATH;
+        const baseUrl = process.env.CSS_BASE_URL;
+        if (!rootFilePath || !baseUrl) {
+            return undefined;
+        }
+        try {
+            const base = new URL(baseUrl.endsWith('/') ? baseUrl : `${baseUrl}/`);
+            const pod = new URL(rootUrl.endsWith('/') ? rootUrl : `${rootUrl}/`);
+            if (base.origin !== pod.origin) {
+                return undefined;
+            }
+            if (!pod.pathname.startsWith(base.pathname)) {
+                return undefined;
+            }
+            const relativePath = decodeURIComponent(pod.pathname.slice(base.pathname.length)).replace(/\/+$/, '');
+            const resolvedRoot = path.resolve(rootFilePath);
+            const resolved = path.resolve(resolvedRoot, relativePath);
+            if (resolved !== resolvedRoot && !resolved.startsWith(`${resolvedRoot}${path.sep}`)) {
+                return undefined;
+            }
+            return resolved;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    createSessionManager(pi, runId, workdir) {
+        if (this.options.persistPiSessions) {
+            return pi.SessionManager.create(workdir, this.resolveSessionDir(runId, workdir));
+        }
+        return pi.SessionManager.inMemory(workdir);
+    }
+    resolveSessionDir(runId, workdir) {
+        const root = this.options.sessionRootDir ?? path.join(os.tmpdir(), 'xpod-pi-sessions');
+        const hash = crypto.createHash('sha256').update(`${workdir}:${runId}`).digest('hex').slice(0, 20);
+        return path.join(root, hash);
+    }
+    resolveWorkerPath() {
+        if (this.options.workerPath) {
+            return this.options.workerPath;
+        }
+        return path.join(__dirname, `PiAgentRuntimeWorker${path.extname(__filename)}`);
+    }
+    workerEnv() {
+        const env = {};
+        for (const [key, value] of Object.entries(process.env)) {
+            if (typeof value === 'string') {
+                env[key] = value;
+            }
+        }
+        env.XPOD_AGENT_LOOP_WORKER = '1';
+        return env;
+    }
+    extractText(content) {
+        if (typeof content === 'string') {
+            return content;
+        }
+        if (!Array.isArray(content)) {
+            return '';
+        }
+        return content
+            .map((part) => {
+            if (part && typeof part === 'object' && part.type === 'text') {
+                return typeof part.text === 'string' ? part.text : '';
+            }
+            return '';
+        })
+            .join('');
+    }
+    formatError(error) {
+        return error instanceof Error ? error.message : String(error);
+    }
+    startupErrorToEvent(error) {
+        if (error instanceof WaitingRunnerError) {
+            return {
+                type: 'waiting_runner',
+                workspace: error.workspace,
+                message: error.message,
+            };
+        }
+        return { type: 'error', message: this.formatError(error) };
+    }
+    async loadPiSdk() {
+        if (this.options.piSdk) {
+            return this.options.piSdk;
+        }
+        if (PiAgentRuntimeDriver.sdkPromise) {
+            return PiAgentRuntimeDriver.sdkPromise;
+        }
+        // Keep a native dynamic import so the CommonJS build can lazily load pi's
+        // ESM-only package instead of requiring it during CSS component discovery.
+        const nativeImport = new Function('specifier', 'return import(specifier)');
+        PiAgentRuntimeDriver.sdkPromise = nativeImport('@mariozechner/pi-coding-agent');
+        return PiAgentRuntimeDriver.sdkPromise;
+    }
+}
+exports.PiAgentRuntimeDriver = PiAgentRuntimeDriver;
+exports.PI_AGENT_WORKER_EVENT_PREFIX = 'XPOD_AGENT_EVENT ';
+class WaitingRunnerError extends Error {
+    constructor(workspace, message) {
+        super(message);
+        this.workspace = workspace;
+    }
+}
+class AsyncPushQueue {
+    constructor() {
+        this.items = [];
+        this.resolvers = [];
+        this.closed = false;
+    }
+    push(item) {
+        if (this.closed) {
+            return;
+        }
+        this.items.push(item);
+        const resolver = this.resolvers.shift();
+        resolver?.();
+    }
+    close() {
+        if (this.closed) {
+            return;
+        }
+        this.closed = true;
+        for (const resolver of this.resolvers) {
+            resolver();
+        }
+        this.resolvers = [];
+    }
+    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=PiAgentRuntimeDriver.js.map