@action-llama/action-llama 0.27.5 → 0.29.0

package/dist/agents/transport-runner.js

@@ -0,0 +1,791 @@
+/**
+ * TransportAgentRunner — runs Pi sessions in the scheduler process,
+ * driving a remote runtime via a Transport.
+ *
+ * Replaces ContainerAgentRunner for the centralized architecture where:
+ *  - The scheduler is the "brain" (LLM session, tool orchestration)
+ *  - The runtime is the "body" (filesystem, shell, credentials)
+ *  - The transport connects them (DockerExecTransport, SshTransport, etc.)
+ *
+ * Key differences from ContainerAgentRunner:
+ *  - Pi session runs in-process (not inside the container)
+ *  - Events are captured directly (no JSON log parsing)
+ *  - Credentials staged via transport (no volume mounts needed)
+ *  - No gateway registration (direct access to scheduler services)
+ *  - No signal files (scheduler tools handle reruns, returns, etc.)
+ */
+import { randomBytes } from "crypto";
+import { execFileSync } from "child_process";
+import { getModel } from "@mariozechner/pi-ai";
+import { AuthStorage, createAgentSession, SessionManager, SettingsManager, DefaultResourceLoader, ModelRegistry, } from "@mariozechner/pi-coding-agent";
+import { sessionStatsToUsage } from "../shared/usage.js";
+import { DEFAULT_AGENT_TIMEOUT } from "../shared/constants.js";
+import { selectAvailableModels, isRateLimitError } from "./model-fallback.js";
+import { DockerExecTransport } from "../transport/docker-exec.js";
+import { SshTransport } from "../transport/ssh.js";
+import { HostUserTransport } from "../transport/host-user.js";
+import { createTransportTools } from "../transport/operations.js";
+import { parseCredentialRef, getDefaultBackend } from "../shared/credentials.js";
+import { parseFrontmatter } from "../shared/frontmatter.js";
+import { withSpan } from "../telemetry/index.js";
+import { SpanKind } from "@opentelemetry/api";
+import { createSchedulerTools } from "./scheduler-tools.js";
+const MAX_MODEL_PASSES = 3;
+const DEFAULT_BACKOFF_MS = 30_000;
+const MAX_BACKOFF_MS = 300_000;
+const CONTAINER_CWD = "/tmp";
+export class TransportAgentRunner {
+    _running = false;
+    _suspended = false;
+    _aborting = false;
+    _transport = null;
+    _containerName = null;
+    _session = null;
+    _turnTextBuffer = "";
+    _turnThinkingBuffer = "";
+    instanceId;
+    /** Trigger depth for subagent call tracking. Set by the scheduler before run(). */
+    depth = 0;
+    globalConfig;
+    agentConfig;
+    baseLogger;
+    logger;
+    circuitBreaker;
+    statusTracker;
+    baseImage;
+    projectPath;
+    providerKeys;
+    schedulerToolsDeps;
+    waitingRegistry;
+    onWaitStateChange;
+    constructor(opts) {
+        this.globalConfig = opts.globalConfig;
+        this.agentConfig = opts.agentConfig;
+        this.baseLogger = opts.logger;
+        this.logger = opts.logger;
+        this.circuitBreaker = opts.circuitBreaker;
+        this.statusTracker = opts.statusTracker;
+        this.baseImage = opts.baseImage;
+        this.projectPath = opts.projectPath;
+        this.providerKeys = opts.providerKeys ?? new Map();
+        this.schedulerToolsDeps = opts.schedulerToolsDeps;
+        this.waitingRegistry = opts.waitingRegistry;
+        this.onWaitStateChange = opts.onWaitStateChange;
+        this.instanceId = opts.agentConfig.name;
+    }
+    get isRunning() {
+        return this._running;
+    }
+    setAgentConfig(config) {
+        this.agentConfig = config;
+    }
+    get isSuspended() {
+        return this._suspended;
+    }
+    abort() {
+        this._aborting = true;
+        this.logger.info("Transport agent runner abort requested");
+        // Dispose the Pi session to stop the LLM loop
+        if (this._session) {
+            try {
+                this._session.dispose();
+            }
+            catch { /* best effort */ }
+        }
+        // Unpause container first if suspended, then kill
+        if (this._containerName) {
+            if (this._suspended) {
+                try {
+                    execFileSync("docker", ["unpause", this._containerName], {
+                        timeout: 10_000,
+                        stdio: ["pipe", "pipe", "pipe"],
+                    });
+                }
+                catch { /* container may not be paused */ }
+            }
+            try {
+                execFileSync("docker", ["kill", this._containerName], {
+                    timeout: 10_000,
+                    stdio: ["pipe", "pipe", "pipe"],
+                });
+            }
+            catch { /* container may already be dead */ }
+        }
+        // Close the transport
+        if (this._transport) {
+            this._transport.close().catch(() => { });
+        }
+    }
+    async run(prompt, triggerInfo, instanceId) {
+        if (this._running) {
+            this.logger.warn(`${this.agentConfig.name} is already running, skipping`);
+            return { result: "error", triggers: [] };
+        }
+        this._running = true;
+        this._aborting = false;
+        this.instanceId = instanceId ?? `${this.agentConfig.name}-${randomBytes(4).toString("hex")}`;
+        this.logger = this.baseLogger.child({ instance: this.instanceId });
+        try {
+            return await withSpan("transport_agent.run", async (span) => {
+                span.setAttributes({
+                    "agent.name": this.agentConfig.name,
+                    "agent.run_id": this.instanceId,
+                    "agent.trigger_type": triggerInfo?.type || "manual",
+                    "agent.trigger_source": triggerInfo?.source || "",
+                    "agent.model_provider": this.agentConfig.models[0]?.provider,
+                    "agent.model_name": this.agentConfig.models[0]?.model,
+                    "execution.environment": "transport",
+                });
+                return this.runInternal(prompt, triggerInfo, span);
+            }, {}, SpanKind.INTERNAL);
+        }
+        catch (err) {
+            this._running = false;
+            this.logger.error({ err }, "transport run setup failed");
+            return { result: "error", triggers: [] };
+        }
+    }
+    async runInternal(prompt, triggerInfo, parentSpan) {
+        const runStartTime = Date.now();
+        let runResult = "error";
+        let runError;
+        let returnValue;
+        let tokenUsage;
+        // Surface run start in TUI
+        const runReason = triggerInfo
+            ? (triggerInfo.source
+                ? (triggerInfo.type === 'agent' ? `triggered by ${triggerInfo.source}` : `${triggerInfo.type} (${triggerInfo.source})`)
+                : triggerInfo.type)
+            : undefined;
+        this.statusTracker?.startRun(this.agentConfig.name, runReason);
+        this.statusTracker?.registerInstance({
+            id: this.instanceId,
+            agentName: this.agentConfig.name,
+            status: "running",
+            startedAt: new Date(),
+            trigger: triggerInfo?.source ? `${triggerInfo.type}:${triggerInfo.source}` : (triggerInfo?.type ?? "manual"),
+        });
+        this.logger.info(`Starting ${this.agentConfig.name} transport run`);
+        this.statusTracker?.addLogLine(this.agentConfig.name, `${this.instanceId} started (${runReason ?? "manual"})`);
+        // ── Timeout — kill the entire run if it exceeds the configured limit ──
+        const timeoutSeconds = this.agentConfig.timeout ?? this.globalConfig.local?.timeout ?? DEFAULT_AGENT_TIMEOUT;
+        const timeoutTimer = setTimeout(() => {
+            this.logger.error({ timeoutSeconds }, "agent timeout reached, aborting");
+            this.abort();
+        }, timeoutSeconds * 1000);
+        timeoutTimer.unref();
+        try {
+            // ── 1–2. Provision runtime & connect transport ──────────
+            const transport = await this.createTransport();
+            this._transport = transport;
+            // ── 3. Stage credentials ─────────────────────────────────
+            const providerKeys = await this.stageCredentials(transport);
+            // Merge with pre-configured provider keys
+            for (const [k, v] of this.providerKeys) {
+                if (!providerKeys.has(k))
+                    providerKeys.set(k, v);
+            }
+            // ── 4. Run hooks.pre ─────────────────────────────────────
+            if (this.agentConfig.hooks?.pre && this.agentConfig.hooks.pre.length > 0) {
+                for (const hook of this.agentConfig.hooks.pre) {
+                    this.logger.info({ hook }, "running pre hook via transport");
+                    await transport.exec(hook);
+                }
+            }
+            // ── 5. Build SKILL.md and prompt ─────────────────────────
+            // Read SKILL.md from the project directory on the host
+            const { readFileSync, existsSync } = await import("fs");
+            const { join } = await import("path");
+            const skillPath = join(this.projectPath, "agents", this.agentConfig.name, "SKILL.md");
+            let skillBody = "";
+            if (existsSync(skillPath)) {
+                const { body } = parseFrontmatter(readFileSync(skillPath, "utf-8"));
+                skillBody = body;
+            }
+            // Process context injection (runs commands on the transport)
+            // TODO: In the future, context injection should execute on the transport
+            // For now, we skip it since the commands won't have access to the runtime
+            // ── 6. Create Pi session with transport tools ────────────
+            const result = await this.runPiSession(prompt, skillBody, transport, providerKeys);
+            runResult = result.result;
+            returnValue = result.returnValue;
+            tokenUsage = result.usage;
+            runError = result.error;
+            // ── 7. Run hooks.post ────────────────────────────────────
+            if (this.agentConfig.hooks?.post && this.agentConfig.hooks.post.length > 0) {
+                for (const hook of this.agentConfig.hooks.post) {
+                    this.logger.info({ hook }, "running post hook via transport");
+                    try {
+                        await transport.exec(hook);
+                    }
+                    catch (err) {
+                        this.logger.error({ err }, "post hook failed");
+                    }
+                }
+            }
+        }
+        catch (err) {
+            this.logger.error({ err }, `${this.agentConfig.name} transport run failed`);
+            runError = String(err?.message || err).slice(0, 200);
+        }
+        finally {
+            clearTimeout(timeoutTimer);
+            // ── 8. Cleanup ───────────────────────────────────────────
+            if (this._transport) {
+                try {
+                    await this._transport.close();
+                }
+                catch { /* best effort */ }
+                this._transport = null;
+            }
+            if (this._containerName) {
+                try {
+                    execFileSync("docker", ["rm", "-f", this._containerName], {
+                        timeout: 10_000,
+                        stdio: ["pipe", "pipe", "pipe"],
+                    });
+                }
+                catch { /* best effort */ }
+                this._containerName = null;
+            }
+            const elapsed = Date.now() - runStartTime;
+            const instanceStatus = this._aborting ? "killed" : runError ? "error" : "completed";
+            this.statusTracker?.completeInstance(this.instanceId, instanceStatus);
+            this.statusTracker?.endRun(this.agentConfig.name, elapsed, runError, tokenUsage);
+            const elapsedStr = (elapsed / 1000).toFixed(1);
+            const turnInfo = tokenUsage?.turnCount != null ? `, ${tokenUsage.turnCount} turns` : "";
+            const costInfo = tokenUsage?.cost != null ? `, $${tokenUsage.cost.toFixed(4)}` : "";
+            const errInfo = runError ? ` — ${runError.slice(0, 100)}` : "";
+            this.statusTracker?.addLogLine(this.agentConfig.name, `${this.instanceId} ${runResult} (${elapsedStr}s${turnInfo}${costInfo})${errInfo}`);
+            this.logger.info({
+                result: runResult,
+                elapsed: `${elapsedStr}s`,
+                hasReturnValue: !!returnValue,
+                turnCount: tokenUsage?.turnCount,
+                inputTokens: tokenUsage?.inputTokens,
+                outputTokens: tokenUsage?.outputTokens,
+                totalTokens: tokenUsage?.totalTokens,
+                cost: tokenUsage?.cost,
+                error: runError,
+            }, "run outcome");
+            if (parentSpan) {
+                parentSpan.setAttributes({
+                    "execution.result": runResult,
+                    "execution.has_return_value": !!returnValue,
+                });
+                if (tokenUsage) {
+                    parentSpan.setAttributes({
+                        "llm.token.input": tokenUsage.inputTokens,
+                        "llm.token.output": tokenUsage.outputTokens,
+                        "llm.token.total": tokenUsage.totalTokens,
+                        "llm.cost.total": tokenUsage.cost,
+                        "llm.turns": tokenUsage.turnCount,
+                    });
+                }
+                if (runResult === "error") {
+                    parentSpan.recordException(new Error(`Transport execution failed: ${runError || "Unknown error"}`));
+                }
+            }
+            this._running = false;
+        }
+        return {
+            result: runResult,
+            triggers: [],
+            returnValue,
+            usage: tokenUsage,
+            exitReason: runError,
+        };
+    }
+    /**
+     * Handle a wait_for_trigger call from the agent.
+     * Suspends the container, registers in the waiting registry, and returns
+     * a promise that resolves when a matching trigger arrives.
+     */
+    async _handleWait(filter, timeoutMs, transport) {
+        if (!this.waitingRegistry) {
+            throw new Error("Waiting registry not available");
+        }
+        const runtimeType = this.agentConfig.runtime?.type ?? "container";
+        const deadline = Date.now() + timeoutMs;
+        // Disconnect transport and pause container
+        await transport.close();
+        this._suspended = true;
+        if (runtimeType === "container" && this._containerName) {
+            try {
+                execFileSync("docker", ["pause", this._containerName], {
+                    timeout: 10_000,
+                    stdio: ["pipe", "pipe", "pipe"],
+                });
+                this.logger.info({ container: this._containerName }, "container paused for wait");
+            }
+            catch (err) {
+                this.logger.warn({ err: err.message }, "failed to pause container");
+            }
+        }
+        // Notify status tracker
+        this.statusTracker?.setInstanceWaiting(this.instanceId);
+        this.onWaitStateChange?.(this.instanceId, "waiting");
+        return new Promise((resolve, reject) => {
+            const entry = {
+                instanceId: this.instanceId,
+                agentName: this.agentConfig.name,
+                filter,
+                deadline,
+                registeredAt: Date.now(),
+                runId: this._containerName ?? this.instanceId,
+                runtimeType,
+                cwd: CONTAINER_CWD,
+                resolve: async (payload) => {
+                    // Resume: unpause container, reconnect transport
+                    try {
+                        await this._resumeFromWait(transport);
+                        resolve(payload);
+                    }
+                    catch (err) {
+                        reject(err);
+                    }
+                },
+                reject: (err) => {
+                    // Timeout or kill — still need to clean up
+                    this._suspended = false;
+                    this.onWaitStateChange?.(this.instanceId, "resumed");
+                    reject(err);
+                },
+            };
+            this.waitingRegistry.register(entry);
+            this.logger.info({ filter, deadline: new Date(deadline).toISOString() }, "instance registered for wait");
+        });
+    }
+    /**
+     * Resume from a suspended wait state: unpause container and reconnect transport.
+     */
+    async _resumeFromWait(transport) {
+        const runtimeType = this.agentConfig.runtime?.type ?? "container";
+        if (runtimeType === "container" && this._containerName) {
+            try {
+                execFileSync("docker", ["unpause", this._containerName], {
+                    timeout: 10_000,
+                    stdio: ["pipe", "pipe", "pipe"],
+                });
+                this.logger.info({ container: this._containerName }, "container unpaused after wait");
+            }
+            catch (err) {
+                this.logger.warn({ err: err.message }, "failed to unpause container");
+            }
+        }
+        // Reconnect the transport
+        await transport.connect();
+        this._suspended = false;
+        this.statusTracker?.resumeInstance(this.instanceId);
+        this.onWaitStateChange?.(this.instanceId, "resumed");
+        this.logger.info("transport reconnected after wait resume");
+    }
+    /**
+     * Create and connect the appropriate transport based on the agent's runtime config.
+     */
+    async createTransport() {
+        const runtimeType = this.agentConfig.runtime?.type ?? "container";
+        switch (runtimeType) {
+            case "ssh": {
+                const rt = this.agentConfig.runtime;
+                if (!rt.host)
+                    throw new Error("SSH runtime requires 'host' in [runtime] config");
+                const transport = new SshTransport({
+                    host: rt.host,
+                    port: rt.port,
+                    user: rt.user,
+                    keyPath: rt.key_path,
+                    cwd: rt.cwd,
+                    sshOptions: rt.ssh_options,
+                });
+                await transport.connect();
+                this.logger.debug({ host: rt.host, user: rt.user }, "SSH transport connected");
+                return transport;
+            }
+            case "host-user": {
+                const rt = this.agentConfig.runtime ?? {};
+                const user = rt.run_as ?? "al-agent";
+                const transport = new HostUserTransport({
+                    user,
+                    groups: rt.groups,
+                    cwd: rt.cwd,
+                });
+                await transport.connect();
+                this.logger.debug({ user }, "Host-user transport connected");
+                return transport;
+            }
+            case "container":
+            default: {
+                const containerName = await this.provisionContainer();
+                this._containerName = containerName;
+                const transport = new DockerExecTransport({
+                    container: containerName,
+                    cwd: CONTAINER_CWD,
+                });
+                await transport.connect();
+                this.logger.debug({ container: containerName }, "Docker transport connected");
+                return transport;
+            }
+        }
+    }
+    /**
+     * Provision a Docker container that stays alive for the transport to connect to.
+     * Returns the container name.
+     */
+    async provisionContainer() {
+        const runId = randomBytes(4).toString("hex");
+        const containerName = `al-${this.agentConfig.name}-${runId}`;
+        const memory = this.globalConfig.local?.memory || "4g";
+        // Build agent-specific image if a Dockerfile exists, otherwise use base
+        const { ensureAgentImage } = await import("../docker/image.js");
+        const image = await ensureAgentImage(this.agentConfig.name, this.projectPath, this.baseImage, (msg) => {
+            this.logger.debug(msg);
+            this.statusTracker?.addLogLine(this.agentConfig.name, msg);
+        });
+        // Ensure the image is available locally
+        this.ensureImageAvailable(image);
+        const args = [
+            "run", "-d",
+            "--name", containerName,
+            "--tmpfs", "/tmp:rw,exec,nosuid",
+            "--tmpfs", "/credentials:rw,nosuid,nodev,noexec",
+            "--cap-drop", "ALL",
+            "--security-opt", "no-new-privileges:true",
+            "--memory", memory,
+        ];
+        if (this.globalConfig.local?.cpus) {
+            args.push("--cpus", String(this.globalConfig.local.cpus));
+        }
+        // Keep the container alive with tail -f /dev/null
+        args.push(image, "tail", "-f", "/dev/null");
+        execFileSync("docker", args, {
+            timeout: 30_000,
+            encoding: "utf-8",
+        });
+        this.logger.debug({ container: containerName }, "container provisioned");
+        return containerName;
+    }
+    /**
+     * Ensure a Docker image is available locally. If not, attempt to pull it.
+     */
+    ensureImageAvailable(image) {
+        try {
+            execFileSync("docker", ["image", "inspect", image], {
+                timeout: 10_000,
+                stdio: ["pipe", "pipe", "pipe"],
+            });
+        }
+        catch {
+            // Image not found locally — try to pull
+            this.logger.debug({ image }, "image not found locally, pulling...");
+            try {
+                execFileSync("docker", ["pull", image], {
+                    timeout: 120_000,
+                    stdio: ["pipe", "pipe", "pipe"],
+                });
+            }
+            catch (pullErr) {
+                throw new Error(`Base image "${image}" not found and pull failed: ${pullErr.message}`);
+            }
+        }
+    }
+    /**
+     * Stage credentials onto the runtime via the transport.
+     * Returns a map of provider → API key for Pi session auth.
+     */
+    async stageCredentials(transport) {
+        const providerKeys = new Map();
+        const credRefs = [...new Set(this.agentConfig.credentials ?? [])];
+        // Add provider keys for all configured models
+        for (const mc of this.agentConfig.models) {
+            if (mc.authType === "pi_auth")
+                continue;
+            const providerKey = `${mc.provider}_key`;
+            if (!credRefs.some((r) => r === providerKey || r.startsWith(`${providerKey}:`))) {
+                credRefs.push(providerKey);
+            }
+        }
+        if (credRefs.length === 0)
+            return providerKeys;
+        // For host-user runtime, stage credentials to a temp dir (not /credentials which is root-only).
+        // For container runtimes, /credentials is inside the container filesystem.
+        const runtimeType = this.agentConfig.runtime?.type ?? "container";
+        const isHostUser = runtimeType === "host-user";
+        const credBase = isHostUser
+            ? `/tmp/al-creds-${randomBytes(4).toString("hex")}`
+            : "/credentials";
+        const backend = getDefaultBackend();
+        const credFiles = new Map();
+        for (const credRef of credRefs) {
+            const { type, instance } = parseCredentialRef(credRef);
+            const fields = await backend.readAll(type, instance);
+            if (!fields)
+                continue;
+            for (const [field, value] of Object.entries(fields)) {
+                // Stage credential file on the runtime
+                const remotePath = `${credBase}/${type}/${instance}/${field}`;
+                credFiles.set(remotePath, Buffer.from(value + "\n", "utf-8"));
+                // Extract provider API keys for Pi session auth
+                if (field === "api_key" || field === "token") {
+                    if (type.endsWith("_key")) {
+                        const provider = type.replace(/_key$/, "");
+                        providerKeys.set(provider, value);
+                    }
+                }
+            }
+        }
+        // Batch write all credential files
+        if (credFiles.size > 0) {
+            // Clean and recreate credential directory for a fresh state
+            await transport.exec(`rm -rf ${credBase} 2>/dev/null; mkdir -p ${credBase}`);
+            await transport.writeFiles(credFiles);
+            await transport.exec(`find ${credBase} -type f -exec chmod 400 {} +`);
+            this.logger.debug({ count: credFiles.size, credBase }, "credentials staged via transport");
+        }
+        return providerKeys;
+    }
+    /**
+     * Run the Pi session in-process with transport-backed tools.
+     */
+    async runPiSession(prompt, skillBody, transport, providerKeys) {
+        const models = this.agentConfig.models;
+        // Create resource loader with the skill body
+        const agentsContent = skillBody || `# ${this.agentConfig.name} Agent\n\nCustom agent.\n`;
+        const resourceLoader = new DefaultResourceLoader({
+            noExtensions: true,
+            agentsFilesOverride: () => ({
+                agentsFiles: [
+                    { path: "/tmp/SKILL.md", content: agentsContent },
+                ],
+            }),
+        });
+        await resourceLoader.reload();
+        const settingsManager = SettingsManager.inMemory({
+            compaction: { enabled: true },
+            retry: { enabled: true, maxRetries: 2 },
+        });
+        // Create transport-backed tools
+        const tools = createTransportTools(transport, CONTAINER_CWD);
+        // Create scheduler tools (locks, calls, status, return, wait) if deps provided
+        let capturedReturnValue;
+        const customTools = this.schedulerToolsDeps
+            ? createSchedulerTools({
+                ...this.schedulerToolsDeps,
+                agentName: this.agentConfig.name,
+                instanceId: this.instanceId,
+                depth: this.depth,
+                onReturnValue: (value) => { capturedReturnValue = value; },
+                onWait: this.waitingRegistry ? (filter, timeoutMs) => this._handleWait(filter, timeoutMs, transport) : undefined,
+                defaultWaitTimeout: this.agentConfig.waitTimeout ?? this.globalConfig.defaultWaitTimeout,
+            })
+            : undefined;
+        let anyModelSucceeded = false;
+        for (let pass = 0; pass <= MAX_MODEL_PASSES; pass++) {
+            const availableModels = selectAvailableModels(models, this.circuitBreaker);
+            let modelSucceeded = false;
+            for (const modelConfig of availableModels) {
+                if (this._aborting) {
+                    return { result: "error", error: "Aborted" };
+                }
+                const authStorage = AuthStorage.create();
+                const providerKey = providerKeys.get(modelConfig.provider);
+                if (providerKey) {
+                    authStorage.setRuntimeApiKey(modelConfig.provider, providerKey);
+                }
+                // Resolve model — either from built-in registry or custom provider with baseUrl
+                let llmModel;
+                let customModelRegistry;
+                if (modelConfig.baseUrl) {
+                    // Create a model registry with the custom provider registered
+                    customModelRegistry = ModelRegistry.inMemory(authStorage);
+                    const providerName = `custom_${modelConfig.provider}`;
+                    // Register API key under custom provider name too
+                    if (providerKey) {
+                        authStorage.setRuntimeApiKey(providerName, providerKey);
+                    }
+                    customModelRegistry.registerProvider(providerName, {
+                        baseUrl: modelConfig.baseUrl,
+                        apiKey: providerKey || "dummy-key",
+                        models: [{
+                                id: modelConfig.model,
+                                name: modelConfig.model,
+                                api: "openai-completions",
+                                reasoning: false,
+                                input: ["text"],
+                                cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+                                contextWindow: 128000,
+                                maxTokens: 16384,
+                            }],
+                    });
+                    llmModel = customModelRegistry.find(providerName, modelConfig.model);
+                    if (!llmModel) {
+                        throw new Error(`Failed to register custom model ${modelConfig.provider}/${modelConfig.model} at ${modelConfig.baseUrl}`);
+                    }
+                }
+                else {
+                    llmModel = getModel(modelConfig.provider, modelConfig.model);
+                }
+                this.logger.debug({
+                    model: modelConfig.model,
+                    thinking: modelConfig.thinkingLevel,
+                    baseUrl: modelConfig.baseUrl,
+                }, "creating Pi session with transport tools");
+                const { session } = await createAgentSession({
+                    cwd: CONTAINER_CWD,
+                    model: llmModel,
+                    modelRegistry: customModelRegistry,
+                    thinkingLevel: modelConfig.thinkingLevel,
+                    authStorage,
+                    resourceLoader,
+                    tools,
+                    customTools,
+                    sessionManager: SessionManager.inMemory(),
+                    settingsManager,
+                });
+                this._session = session;
+                // Subscribe to events for logging and status tracking
+                this.subscribeToEvents(session);
+                try {
+                    const state = session.state;
+                    this.logger.debug({
+                        promptLength: prompt.length,
+                        model: state?.model ? { id: state.model.id, provider: state.model.provider, api: state.model.api, baseUrl: state.model.baseUrl } : "NO MODEL",
+                        toolCount: state?.tools?.length ?? 0,
+                    }, "about to call session.prompt()");
+                    await session.prompt(prompt);
+                    this.flushTurnBuffers();
+                    const allMessages = session.state?.messages ?? [];
+                    const lastMsg = allMessages[allMessages.length - 1];
+                    if (lastMsg?.stopReason === "error") {
+                        this.logger.error({
+                            errorMessage: lastMsg?.errorMessage ?? session.state?.errorMessage,
+                        }, "session.prompt() completed with error");
+                    }
+                    this.circuitBreaker.recordSuccess(modelConfig.provider, modelConfig.model);
+                    // Get usage stats (logged later in "run outcome")
+                    const sessionStats = session.getSessionStats();
+                    const usage = sessionStatsToUsage(sessionStats);
+                    session.dispose();
+                    this._session = null;
+                    modelSucceeded = true;
+                    anyModelSucceeded = true;
+                    return { result: "completed", usage, returnValue: capturedReturnValue };
+                }
+                catch (promptErr) {
+                    const msg = String(promptErr?.message || promptErr || "");
+                    if (isRateLimitError(msg)) {
+                        this.circuitBreaker.recordFailure(modelConfig.provider, modelConfig.model);
+                        this.logger.warn({
+                            provider: modelConfig.provider,
+                            model: modelConfig.model,
+                        }, "rate limited, trying next model");
+                        session.dispose();
+                        this._session = null;
+                        continue;
+                    }
+                    session.dispose();
+                    this._session = null;
+                    return { result: "error", error: msg };
+                }
+            }
+            if (modelSucceeded)
+                break;
+            if (pass < MAX_MODEL_PASSES) {
+                const delayMs = Math.min(DEFAULT_BACKOFF_MS * Math.pow(2, pass), MAX_BACKOFF_MS);
+                this.logger.warn({ pass: pass + 1, delayMs }, "all models exhausted, backing off");
+                await new Promise((r) => setTimeout(r, delayMs));
+            }
+        }
+        if (!anyModelSucceeded) {
+            this.logger.error("all models exhausted across all retry passes");
+            return { result: "error", error: "All models exhausted — rate limited across all retries" };
+        }
+        return { result: "completed" };
+    }
+    /**
+     * Subscribe to Pi session events and forward them to the logger and status tracker.
+     * Since the session runs in-process, we get direct access to events.
+     */
+    subscribeToEvents(session) {
+        session.subscribe((event) => {
+            this.logger.debug({ eventType: event.type }, "session event");
+            if (event.type === "tool_execution_start") {
+                const toolName = String(event.toolName || "unknown");
+                const summary = toolName === "bash"
+                    ? String(event.args?.command || "").slice(0, 200)
+                    : JSON.stringify(event.args ?? {}).slice(0, 200);
+                this.logger.info({ toolName, summary }, "[tool]");
+            }
+            if (event.type === "tool_execution_end") {
+                const toolName = String(event.toolName || "unknown");
+                const resultText = this.extractToolResultText(event.result);
+                if (event.isError) {
+                    const errorSummary = resultText.slice(0, 200);
+                    this.statusTracker?.setAgentError(this.agentConfig.name, errorSummary);
+                    this.logger.warn({ toolName, error: errorSummary }, "[error]");
+                }
+                else if (resultText) {
+                    this.logger.info({ toolName, summary: resultText.slice(0, 200) }, "[result]");
+                }
+            }
+            // Pi SDK emits thinking/text as message_update events with assistantMessageEvent
+            if (event.type === "message_update" && event.assistantMessageEvent) {
+                const ame = event.assistantMessageEvent;
+                if (ame.type === "thinking_delta") {
+                    const delta = String(ame.delta ?? "");
+                    if (delta)
+                        this._turnThinkingBuffer += delta;
+                }
+                if (ame.type === "text_delta") {
+                    const delta = String(ame.delta ?? ame.content ?? "");
+                    if (delta)
+                        this._turnTextBuffer += delta;
+                }
+            }
+            if (event.type === "turn_end") {
+                this.flushTurnBuffers();
+            }
+            if (event.type === "error") {
+                const err = event.error;
+                const errorMsg = err?.errorMessage
+                    || (typeof err === "string" ? err : null)
+                    || JSON.stringify(event);
+                this.logger.error({ error: String(errorMsg).slice(0, 300) }, "[error]");
+                this.statusTracker?.setAgentError(this.agentConfig.name, String(errorMsg).slice(0, 200));
+            }
+        });
+    }
+    /**
+     * Extract human-readable text from a tool result, unwrapping the Pi SDK content array format.
+     * Returns empty string for empty/trivial results.
+     */
+    extractToolResultText(result) {
+        if (result == null)
+            return "";
+        if (typeof result === "string")
+            return result.trim();
+        // Pi SDK wraps results as { content: [{ type: "text", text: "..." }] }
+        const obj = result;
+        if (obj.content && Array.isArray(obj.content)) {
+            const texts = obj.content
+                .filter((c) => c.type === "text" && c.text)
+                .map((c) => String(c.text).trim())
+                .filter(Boolean);
+            return texts.join("\n");
+        }
+        const str = JSON.stringify(result);
+        return str === "{}" || str === "[]" ? "" : str;
+    }
+    /** Flush accumulated text/thinking buffers to the logger. */
+    flushTurnBuffers() {
+        if (this._turnThinkingBuffer) {
+            this.logger.info({ text: this._turnThinkingBuffer.slice(0, 2000) }, "[thinking]");
+            this._turnThinkingBuffer = "";
+        }
+        if (this._turnTextBuffer) {
+            this.logger.info({ text: this._turnTextBuffer.slice(0, 2000) }, "[text]");
+            this._turnTextBuffer = "";
+        }
+    }
+}
+//# sourceMappingURL=transport-runner.js.map