@action-llama/action-llama 0.27.5 → 0.28.0

package/dist/agents/transport-runner.js

@@ -0,0 +1,653 @@
+/**
+ * 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 = "/workspace";
+export class TransportAgentRunner {
+    _running = false;
+    _aborting = false;
+    _transport = null;
+    _containerName = null;
+    _session = null;
+    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;
+    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.instanceId = opts.agentConfig.name;
+    }
+    get isRunning() {
+        return this._running;
+    }
+    setAgentConfig(config) {
+        this.agentConfig = config;
+    }
+    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 */ }
+        }
+        // Kill the container (only applies to container runtime)
+        if (this._containerName) {
+            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,
+                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,
+        };
+    }
+    /**
+     * 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.info({ 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.info({ 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.info({ 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";
+        // Ensure the base image is available locally
+        this.ensureImageAvailable(this.baseImage);
+        const args = [
+            "run", "-d",
+            "--name", containerName,
+            "--tmpfs", "/workspace:rw,exec,nosuid",
+            "--tmpfs", "/tmp:rw,exec,nosuid",
+            "--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(this.baseImage, "tail", "-f", "/dev/null");
+        execFileSync("docker", args, {
+            timeout: 30_000,
+            encoding: "utf-8",
+        });
+        this.logger.info({ 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.info({ 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.info({ 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) 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; },
+            })
+            : 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.info({
+                    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);
+                    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
+                    const sessionStats = session.getSessionStats();
+                    const usage = sessionStatsToUsage(sessionStats);
+                    this.logger.info({
+                        inputTokens: usage.inputTokens,
+                        outputTokens: usage.outputTokens,
+                        turnCount: usage.turnCount,
+                        cost: usage.cost,
+                    }, "session completed");
+                    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) => {
+            // Log all event types at debug level
+            this.logger.debug({ eventType: event.type }, "session event");
+            if (event.type === "tool_execution_start") {
+                const cmd = String(event.args?.command || "");
+                this.logger.debug({
+                    toolName: event.toolName,
+                    toolCallId: event.toolCallId,
+                    command: cmd || undefined,
+                }, "tool started");
+            }
+            if (event.type === "tool_execution_end") {
+                const resultStr = typeof event.result === "string"
+                    ? event.result
+                    : JSON.stringify(event.result);
+                if (event.isError) {
+                    const cmdPrefix = event.args?.command ? `$ ${String(event.args.command).slice(0, 80)} — ` : "";
+                    this.statusTracker?.setAgentError(this.agentConfig.name, `${cmdPrefix}${resultStr.slice(0, 200)}`);
+                }
+                this.logger.debug({
+                    toolName: event.toolName,
+                    toolCallId: event.toolCallId,
+                    isError: !!event.isError,
+                    resultLength: resultStr.length,
+                }, "tool ended");
+            }
+            if (event.type === "error") {
+                const err = event.error;
+                const errorMsg = err?.errorMessage
+                    || (typeof err === "string" ? err : null)
+                    || JSON.stringify(event);
+                this.logger.error({ error: errorMsg }, "session error");
+                this.statusTracker?.setAgentError(this.agentConfig.name, String(errorMsg).slice(0, 200));
+            }
+            // Context usage tracking
+            if (event.type === "turn_end") {
+                try {
+                    const ctx = session.getContextUsage?.();
+                    if (ctx && ctx.percent != null) {
+                        this.logger.info({
+                            contextPercent: Math.round(ctx.percent * 10) / 10,
+                            contextWindow: ctx.contextWindow,
+                            contextTokens: ctx.tokens,
+                        }, "context-usage");
+                    }
+                }
+                catch { /* context usage not available */ }
+            }
+        });
+    }
+}
+//# sourceMappingURL=transport-runner.js.map