@fitchmultz/pi-subagents 0.0.0-stage → 0.44.5

package/dist/shared/temp-root.js

@@ -0,0 +1,114 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { isSafeNestedPathId } from "../runs/shared/nested-path.js";
+import { ASYNC_DIR, RESULTS_DIR, TEMP_ROOT_DIR } from "./types.js";
+import { listRunQuestions, LEGACY_QUESTIONS_DIR, QUESTIONS_DIR } from "../runs/shared/supervisor-questions.js";
+const MAX_RUN_AGE_MS = 7 * 24 * 60 * 60 * 1000;
+export function ensureTempRoot() {
+    fs.mkdirSync(TEMP_ROOT_DIR, { recursive: true, mode: 0o700 });
+    const stat = fs.lstatSync(TEMP_ROOT_DIR);
+    if (!stat.isDirectory() || stat.isSymbolicLink())
+        throw new Error(`Unsafe pi-subagents temp root: ${TEMP_ROOT_DIR}`);
+    const uid = process.getuid?.();
+    if (uid !== undefined && stat.uid !== uid)
+        throw new Error(`pi-subagents temp root is owned by another user: ${TEMP_ROOT_DIR}`);
+    fs.chmodSync(TEMP_ROOT_DIR, 0o700);
+}
+export function ensureSafeTempPath(candidate) {
+    const root = path.resolve(TEMP_ROOT_DIR);
+    const resolved = path.resolve(candidate);
+    const relative = path.relative(root, resolved);
+    if (relative === ".." || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative))
+        return;
+    ensureTempRoot();
+    let current = root;
+    for (const segment of relative.split(path.sep).filter(Boolean)) {
+        current = path.join(current, segment);
+        try {
+            const stat = fs.lstatSync(current);
+            if (stat.isSymbolicLink())
+                throw new Error(`Unsafe symlink in pi-subagents temp path: ${current}`);
+        }
+        catch (error) {
+            if (error.code === "ENOENT")
+                return;
+            throw error;
+        }
+    }
+}
+// Missing, malformed, or non-object JSON means the entry is incomplete garbage and safe
+// to remove. Operational read failures throw so callers fail closed instead of deleting.
+async function readJsonObject(file) {
+    try {
+        const parsed = JSON.parse(await fs.promises.readFile(file, "utf-8"));
+        return parsed !== null && typeof parsed === "object" ? parsed : undefined;
+    }
+    catch (error) {
+        if (error.code === "ENOENT" || error instanceof SyntaxError)
+            return undefined;
+        throw error;
+    }
+}
+async function activeStatus(statusFile) {
+    const status = await readJsonObject(statusFile);
+    return status?.state === "running" || status?.state === "queued";
+}
+async function removeOldEntries(root, now, keepActive) {
+    let entries;
+    try {
+        entries = await fs.promises.readdir(root, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    for (const entry of entries) {
+        const entryPath = path.join(root, entry.name);
+        try {
+            const stat = await fs.promises.lstat(entryPath);
+            if (now - stat.mtimeMs <= MAX_RUN_AGE_MS)
+                continue;
+            if (keepActive && entry.isDirectory() && await keepActive(entryPath))
+                continue;
+            await fs.promises.rm(entryPath, { recursive: entry.isDirectory(), force: true });
+        }
+        catch {
+            // Startup retention cleanup is best effort; entries that fail closed are skipped.
+        }
+    }
+}
+// A route is live while anything still writes into it (nested descendants can outlive a
+// terminal root, and foreground roots have no async status at all) or while its root run
+// reports an active state. Child writes land in the events/ and controls/ subdirs without
+// bumping the route-root mtime; registry projection renames into routeRoot, which the
+// caller's mtime gate already covers.
+async function nestedRouteActive(routeRoot, now) {
+    for (const name of ["events", "controls"]) {
+        try {
+            if (now - (await fs.promises.stat(path.join(routeRoot, name))).mtimeMs <= MAX_RUN_AGE_MS)
+                return true;
+        }
+        catch (error) {
+            if (error.code !== "ENOENT")
+                throw error;
+        }
+    }
+    const metadata = await readJsonObject(path.join(routeRoot, "route.json"));
+    if (!metadata || !isSafeNestedPathId(metadata.rootRunId))
+        return false;
+    return activeStatus(path.join(ASYNC_DIR, metadata.rootRunId, "status.json"));
+}
+function pendingQuestion(runDir) {
+    return listRunQuestions(runDir).some((question) => question.state === "awaiting_input" || question.state === "answer_pending");
+}
+export async function cleanupOldRunStorage(now = Date.now()) {
+    for (const [dir, keepActive] of [
+        [ASYNC_DIR, async (entryPath) => await activeStatus(path.join(entryPath, "status.json")) || pendingQuestion(path.join(QUESTIONS_DIR, path.basename(entryPath)))],
+        [LEGACY_QUESTIONS_DIR, pendingQuestion],
+        [RESULTS_DIR, undefined],
+        [path.join(TEMP_ROOT_DIR, "nested-subagent-runs"), undefined],
+        [path.join(TEMP_ROOT_DIR, "nested-subagent-events"), (entryPath) => nestedRouteActive(entryPath, now)],
+    ]) {
+        ensureSafeTempPath(dir);
+        await removeOldEntries(dir, now, keepActive);
+    }
+}

package/dist/shared/types.js

@@ -0,0 +1,207 @@
+/**
+ * Type definitions for the subagent extension
+ */
+import * as os from "node:os";
+import * as path from "node:path";
+export const INTERCOM_DETACH_REQUEST_EVENT = "pi-intercom:detach-request";
+export const INTERCOM_DETACH_RESPONSE_EVENT = "pi-intercom:detach-response";
+export const SUBAGENT_ASYNC_STARTED_EVENT = "subagent:async-started";
+export const SUBAGENT_ASYNC_COMPLETE_EVENT = "subagent:async-complete";
+export const SUBAGENT_CONTROL_EVENT = "subagent:control-event";
+export const SUBAGENT_CONTROL_INTERCOM_EVENT = "subagent:control-intercom";
+export const SUBAGENT_RESULT_INTERCOM_EVENT = "subagent:result-intercom";
+export const SUBAGENT_RESULT_INTERCOM_DELIVERY_EVENT = "subagent:result-intercom-delivery";
+export const SUBAGENT_LIVE_INTERCOM_EVENT = "subagent:live-intercom";
+export const SUBAGENT_LIVE_INTERCOM_DELIVERY_EVENT = "subagent:live-intercom-delivery";
+export const SUBAGENT_INTERCOM_HEALTH_REQUEST_EVENT = "subagent:intercom-health-request";
+export const SUBAGENT_INTERCOM_HEALTH_RESPONSE_EVENT = "subagent:intercom-health-response";
+export const SUBAGENT_INTERCOM_IDENTITY_REQUEST_EVENT = "subagent:intercom-identity-request";
+export const SUBAGENT_INTERCOM_IDENTITY_RESPONSE_EVENT = "subagent:intercom-identity-response";
+// ============================================================================
+// Constants
+// ============================================================================
+export const DEFAULT_MAX_OUTPUT = {
+    bytes: 200 * 1024,
+    lines: 5000,
+};
+function sanitizeTempScopeSegment(value) {
+    const sanitized = value
+        .trim()
+        .replace(/[^A-Za-z0-9._-]+/g, "-")
+        .replace(/^-+|-+$/g, "");
+    return sanitized || "unknown";
+}
+export function resolveTempScopeId() {
+    if (typeof process.getuid === "function")
+        return `uid-${process.getuid()}`;
+    for (const key of ["USERNAME", "USER", "LOGNAME"]) {
+        const value = process.env[key];
+        if (value)
+            return `user-${sanitizeTempScopeSegment(value)}`;
+    }
+    try {
+        const username = os.userInfo().username;
+        if (username)
+            return `user-${sanitizeTempScopeSegment(username)}`;
+    }
+    catch {
+        // Fall through to home-directory-based scoping.
+    }
+    const homedir = process.env.HOME;
+    if (homedir)
+        return `home-${sanitizeTempScopeSegment(homedir)}`;
+    try {
+        const fallbackHomedir = os.homedir();
+        if (fallbackHomedir)
+            return `home-${sanitizeTempScopeSegment(fallbackHomedir)}`;
+    }
+    catch {
+        // Fall through to the last-resort shared scope.
+    }
+    return "shared";
+}
+const MAX_PARALLEL = 8;
+export const MAX_CONCURRENCY = 4;
+export function resolveTempRootDir(configured = process.env.PI_SUBAGENT_TEMP_ROOT) {
+    const fallback = path.join(os.tmpdir(), `pi-subagents-${resolveTempScopeId()}`);
+    if (!configured?.trim())
+        return fallback;
+    const resolved = path.resolve(configured);
+    if (!path.basename(resolved).startsWith("pi-subagents-")) {
+        throw new Error("PI_SUBAGENT_TEMP_ROOT must name a dedicated 'pi-subagents-*' directory.");
+    }
+    return resolved;
+}
+export const TEMP_ROOT_DIR = resolveTempRootDir();
+export const RESULTS_DIR = path.join(TEMP_ROOT_DIR, "async-subagent-results");
+export const ASYNC_DIR = path.join(TEMP_ROOT_DIR, "async-subagent-runs");
+export const RUNNER_ERROR_LOG_FILE = "runner-error.log";
+export const CHAIN_RUNS_DIR = path.join(TEMP_ROOT_DIR, "chain-runs");
+export const TEMP_ARTIFACTS_DIR = path.join(TEMP_ROOT_DIR, "artifacts");
+export const WIDGET_KEY = "subagent-async";
+export const SLASH_RESULT_TYPE = "subagent-slash-result";
+export const SLASH_SUBAGENT_REQUEST_EVENT = "subagent:slash:request";
+export const SLASH_SUBAGENT_STARTED_EVENT = "subagent:slash:started";
+export const SLASH_SUBAGENT_RESPONSE_EVENT = "subagent:slash:response";
+export const SLASH_SUBAGENT_UPDATE_EVENT = "subagent:slash:update";
+export const SLASH_SUBAGENT_CANCEL_EVENT = "subagent:slash:cancel";
+export const POLL_INTERVAL_MS = 1000;
+export const MAX_WIDGET_JOBS = 4;
+export const DEFAULT_SUBAGENT_MAX_DEPTH = 1;
+export const SUBAGENT_ACTIONS = ["list", "get", "create", "update", "delete", "status", "history", "search", "interrupt", "extend", "resume", "nudge", "questions", "answer", "review", "doctor"];
+export const DEFAULT_FORK_PREAMBLE = "You are a delegated subagent running from a fork of the parent session. " +
+    "Treat the inherited conversation as reference-only context, not a live thread to continue. " +
+    "Do not continue or answer prior messages as if they are waiting for a reply. " +
+    "Your sole job is to execute the task below and return a focused result for that task using your tools.";
+function normalizeTopLevelParallelValue(value) {
+    const parsed = typeof value === "number" ? value : typeof value === "string" ? Number(value) : NaN;
+    if (!Number.isInteger(parsed) || parsed < 1)
+        return undefined;
+    return parsed;
+}
+export function resolveTopLevelParallelMaxTasks(value) {
+    return normalizeTopLevelParallelValue(value) ?? MAX_PARALLEL;
+}
+export function resolveTopLevelParallelConcurrency(override, configValue) {
+    return normalizeTopLevelParallelValue(override)
+        ?? normalizeTopLevelParallelValue(configValue)
+        ?? MAX_CONCURRENCY;
+}
+export function getAsyncConfigPath(suffix) {
+    return path.join(TEMP_ROOT_DIR, `async-cfg-${suffix}.json`);
+}
+export function wrapForkTask(task, preamble) {
+    if (preamble === false)
+        return task;
+    const effectivePreamble = preamble ?? DEFAULT_FORK_PREAMBLE;
+    const wrappedPrefix = `${effectivePreamble}\n\nTask:\n`;
+    if (task.startsWith(wrappedPrefix))
+        return task;
+    return `${wrappedPrefix}${task}`;
+}
+// ============================================================================
+// Recursion Depth Guard
+// ============================================================================
+export function normalizeMaxSubagentDepth(value) {
+    const parsed = typeof value === "number" ? value : typeof value === "string" ? Number(value) : NaN;
+    if (!Number.isInteger(parsed) || parsed < 0)
+        return undefined;
+    return parsed;
+}
+export function resolveCurrentMaxSubagentDepth(configMaxDepth) {
+    return normalizeMaxSubagentDepth(process.env.PI_SUBAGENT_MAX_DEPTH)
+        ?? normalizeMaxSubagentDepth(configMaxDepth)
+        ?? DEFAULT_SUBAGENT_MAX_DEPTH;
+}
+export function resolveChildMaxSubagentDepth(parentMaxDepth, agentMaxDepth) {
+    const normalizedParent = normalizeMaxSubagentDepth(parentMaxDepth) ?? DEFAULT_SUBAGENT_MAX_DEPTH;
+    const normalizedAgent = normalizeMaxSubagentDepth(agentMaxDepth);
+    return normalizedAgent === undefined ? normalizedParent : Math.min(normalizedParent, normalizedAgent);
+}
+function parseSubagentDepth(value) {
+    if (value === undefined || value === null || value === "")
+        return 0;
+    const depth = Number(value);
+    return Number.isInteger(depth) && depth >= 0 ? depth : undefined;
+}
+export function checkSubagentDepth(configMaxDepth) {
+    const maxDepth = resolveCurrentMaxSubagentDepth(configMaxDepth);
+    const depth = parseSubagentDepth(process.env.PI_SUBAGENT_DEPTH);
+    if (depth === undefined)
+        return { blocked: true, depth: maxDepth, maxDepth };
+    return { blocked: depth >= maxDepth, depth, maxDepth };
+}
+export function getSubagentDepthEnv(maxDepth) {
+    const childMaxDepth = normalizeMaxSubagentDepth(maxDepth) ?? resolveCurrentMaxSubagentDepth();
+    const parentDepth = parseSubagentDepth(process.env.PI_SUBAGENT_DEPTH);
+    const nextDepth = parentDepth === undefined ? childMaxDepth : parentDepth + 1;
+    return {
+        PI_SUBAGENT_DEPTH: String(nextDepth),
+        PI_SUBAGENT_MAX_DEPTH: String(childMaxDepth),
+    };
+}
+// ============================================================================
+// Utility Functions
+// ============================================================================
+function formatBytes(bytes) {
+    if (bytes < 1024)
+        return `${bytes}B`;
+    if (bytes < 1024 * 1024)
+        return `${(bytes / 1024).toFixed(1)}KB`;
+    return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
+}
+export function truncateOutput(output, config, artifactPath) {
+    const lines = output.split("\n");
+    const bytes = Buffer.byteLength(output, "utf-8");
+    if (bytes <= config.bytes && lines.length <= config.lines) {
+        return { text: output, truncated: false };
+    }
+    let truncatedLines = lines;
+    if (lines.length > config.lines) {
+        truncatedLines = lines.slice(0, config.lines);
+    }
+    let result = truncatedLines.join("\n");
+    if (Buffer.byteLength(result, "utf-8") > config.bytes) {
+        let low = 0;
+        let high = result.length;
+        while (low < high) {
+            const mid = Math.floor((low + high + 1) / 2);
+            if (Buffer.byteLength(result.slice(0, mid), "utf-8") <= config.bytes) {
+                low = mid;
+            }
+            else {
+                high = mid - 1;
+            }
+        }
+        result = result.slice(0, low);
+    }
+    const keptLines = result.split("\n").length;
+    const marker = `[TRUNCATED: showing first ${keptLines} of ${lines.length} lines, ${formatBytes(Buffer.byteLength(result))} of ${formatBytes(bytes)}${artifactPath ? ` - full output at ${artifactPath}` : ""}]\n`;
+    return {
+        text: marker + result,
+        truncated: true,
+        originalBytes: bytes,
+        originalLines: lines.length,
+        artifactPath,
+    };
+}

package/dist/shared/ui-mode.js

@@ -0,0 +1,3 @@
+export function isTuiContext(ctx) {
+    return ctx.mode === "tui";
+}

package/dist/shared/utils.js

@@ -0,0 +1,334 @@
+/**
+ * General utility functions for the subagent extension
+ */
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { formatToolCall } from "./formatters.js";
+// ============================================================================
+// File System Utilities
+// ============================================================================
+export function getAgentDir() {
+    const configured = process.env.PI_CODING_AGENT_DIR;
+    if (configured === "~")
+        return os.homedir();
+    if (configured?.startsWith("~/"))
+        return path.join(os.homedir(), configured.slice(2));
+    return configured || path.join(os.homedir(), ".pi", "agent");
+}
+const statusCache = new Map();
+function getErrorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+export function resolveChildCwd(baseCwd, childCwd) {
+    if (!childCwd)
+        return baseCwd;
+    return path.isAbsolute(childCwd) ? childCwd : path.resolve(baseCwd, childCwd);
+}
+function isNotFoundError(error) {
+    return typeof error === "object"
+        && error !== null
+        && "code" in error
+        && error.code === "ENOENT";
+}
+/**
+ * Read async job status from disk, invalidating on replacement and in-place updates.
+ */
+export function readStatus(asyncDir) {
+    const statusPath = path.join(asyncDir, "status.json");
+    let stat;
+    try {
+        stat = fs.statSync(statusPath, { bigint: true });
+    }
+    catch (error) {
+        if (isNotFoundError(error)) {
+            statusCache.delete(statusPath);
+            return null;
+        }
+        throw new Error(`Failed to inspect async status file '${statusPath}': ${getErrorMessage(error)}`, {
+            cause: error instanceof Error ? error : undefined,
+        });
+    }
+    const cached = statusCache.get(statusPath);
+    const version = `${stat.dev}:${stat.ino}:${stat.size}:${stat.mtimeNs}:${stat.ctimeNs}`;
+    if (cached && cached.version === version) {
+        return cached.status;
+    }
+    let content;
+    try {
+        content = fs.readFileSync(statusPath, "utf-8");
+    }
+    catch (error) {
+        if (isNotFoundError(error))
+            return null;
+        throw new Error(`Failed to read async status file '${statusPath}': ${getErrorMessage(error)}`, {
+            cause: error instanceof Error ? error : undefined,
+        });
+    }
+    let status;
+    try {
+        status = JSON.parse(content);
+    }
+    catch (error) {
+        throw new Error(`Failed to parse async status file '${statusPath}': ${getErrorMessage(error)}`, {
+            cause: error instanceof Error ? error : undefined,
+        });
+    }
+    statusCache.set(statusPath, { version, status });
+    if (statusCache.size > 50) {
+        const firstKey = statusCache.keys().next().value;
+        if (firstKey)
+            statusCache.delete(firstKey);
+    }
+    return status;
+}
+/**
+ * Find the latest session file in a directory
+ */
+export function findLatestSessionFile(sessionDir) {
+    try {
+        let latest;
+        for (const file of fs.readdirSync(sessionDir)) {
+            if (!file.endsWith(".jsonl"))
+                continue;
+            const filePath = path.join(sessionDir, file);
+            const mtime = fs.statSync(filePath).mtimeMs;
+            if (!latest || mtime > latest.mtime)
+                latest = { path: filePath, mtime };
+        }
+        return latest?.path ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+// ============================================================================
+// Message Parsing Utilities
+// ============================================================================
+/**
+ * Get the final text output from a list of messages
+ */
+export function getFinalOutput(messages) {
+    for (let i = messages.length - 1; i >= 0; i--) {
+        const msg = messages[i];
+        if (msg.role === "assistant") {
+            const hasAssistantError = ("errorMessage" in msg && typeof msg.errorMessage === "string" && msg.errorMessage.length > 0)
+                || ("stopReason" in msg && msg.stopReason === "error");
+            if (hasAssistantError)
+                continue;
+            for (let j = msg.content.length - 1; j >= 0; j--) {
+                const part = msg.content[j];
+                if (part.type === "text" && part.text.trim().length > 0)
+                    return part.text;
+            }
+        }
+    }
+    return "";
+}
+export function getSingleResultOutput(result) {
+    return result.finalOutput ?? getFinalOutput(result.messages ?? []);
+}
+export function formatResourceLimitExceeded(input) {
+    if (input.kind === "maxExecutionTimeMs") {
+        return `Resource limit exceeded for ${input.agent}: maxExecutionTimeMs ${input.limit}ms.`;
+    }
+    return `Resource limit exceeded for ${input.agent}: maxTokens ${input.limit}${input.observed !== undefined ? ` (observed ${input.observed})` : ""}.`;
+}
+/**
+ * Extract display items (text and tool calls) from messages
+ */
+export function getDisplayItems(messages) {
+    if (!messages || messages.length === 0)
+        return [];
+    const items = [];
+    for (const msg of messages) {
+        if (msg.role === "assistant") {
+            for (const part of msg.content) {
+                if (part.type === "text")
+                    items.push({ type: "text", text: part.text });
+                else if (part.type === "toolCall")
+                    items.push({ type: "tool", name: part.name, args: part.arguments });
+            }
+        }
+    }
+    return items;
+}
+function extractToolCallSummaries(messages) {
+    if (!messages?.length)
+        return [];
+    const summaries = [];
+    for (const msg of messages) {
+        if (msg.role !== "assistant")
+            continue;
+        for (const part of msg.content) {
+            if (part.type !== "toolCall")
+                continue;
+            const args = typeof part.arguments === "object" && part.arguments !== null && !Array.isArray(part.arguments)
+                ? part.arguments
+                : {};
+            summaries.push({
+                text: formatToolCall(part.name, args),
+                expandedText: formatToolCall(part.name, args, true),
+            });
+        }
+    }
+    return summaries;
+}
+export function compactForegroundResult(result) {
+    if (result.progress?.status === "running")
+        return result;
+    const toolCalls = result.toolCalls?.length ? result.toolCalls : extractToolCallSummaries(result.messages);
+    return {
+        ...result,
+        messages: undefined,
+        progress: undefined,
+        toolCalls: toolCalls.length ? toolCalls : undefined,
+    };
+}
+/**
+ * Detect errors in subagent execution from messages (only errors with no subsequent success)
+ */
+export function detectSubagentError(messages) {
+    let lastAssistantTextIndex = -1;
+    for (let i = messages.length - 1; i >= 0; i--) {
+        const msg = messages[i];
+        if (msg.role === "assistant") {
+            const hasText = Array.isArray(msg.content) && msg.content.some((c) => c.type === "text" && "text" in c && typeof c.text === "string" && c.text.trim().length > 0);
+            if (hasText) {
+                lastAssistantTextIndex = i;
+                break;
+            }
+        }
+    }
+    const scanStart = lastAssistantTextIndex >= 0 ? lastAssistantTextIndex + 1 : 0;
+    for (let i = messages.length - 1; i >= scanStart; i--) {
+        const msg = messages[i];
+        if (msg.role !== "toolResult")
+            continue;
+        const toolName = "toolName" in msg && typeof msg.toolName === "string" ? msg.toolName : undefined;
+        const isError = "isError" in msg && msg.isError === true;
+        const observedExit = msg.observedExitCode;
+        if (isError) {
+            const text = msg.content.find((c) => c.type === "text");
+            const details = text && "text" in text ? text.text : undefined;
+            const exitMatch = details?.match(/exit(?:ed)?\s*(?:with\s*)?(?:code|status)?\s*[:\s]?\s*(\d+)/i);
+            return {
+                hasError: true,
+                exitCode: observedExit ?? (exitMatch ? parseInt(exitMatch[1], 10) : 1),
+                errorType: toolName || "tool",
+                details: details?.slice(0, 200),
+            };
+        }
+        if (toolName !== "bash")
+            continue;
+        const text = msg.content.find((c) => c.type === "text");
+        if (!text || !("text" in text))
+            continue;
+        const output = text.text;
+        const exitMatch = output.match(/exit(?:ed)?\s*(?:with\s*)?(?:code|status)?\s*[:\s]?\s*(\d+)/i);
+        if (exitMatch || observedExit !== undefined) {
+            const code = observedExit ?? parseInt(exitMatch[1], 10);
+            if (code !== 0) {
+                return { hasError: true, exitCode: code, errorType: "bash", details: output.slice(0, 200) };
+            }
+        }
+    }
+    return { hasError: false };
+}
+/**
+ * Extract a preview of tool arguments for display
+ */
+export function extractToolArgsPreview(args) {
+    const truncatePreview = (value, maxLength) => value.length > maxLength ? `${value.slice(0, maxLength - 3)}...` : value;
+    const stringifyPreviewValue = (value) => {
+        if (typeof value === "string" && value.trim().length > 0)
+            return value;
+        if (typeof value === "number" || typeof value === "boolean")
+            return String(value);
+        return undefined;
+    };
+    const previewArray = (value) => {
+        if (!Array.isArray(value) || value.length === 0)
+            return undefined;
+        const first = stringifyPreviewValue(value[0]);
+        if (!first)
+            return undefined;
+        const suffix = value.length > 1 ? ` (+${value.length - 1} more)` : "";
+        return `${first}${suffix}`;
+    };
+    // Handle MCP tool calls - show server/tool info
+    if (args.tool && typeof args.tool === "string") {
+        const server = args.server && typeof args.server === "string" ? `${args.server}/` : "";
+        const toolArgs = args.args && typeof args.args === "string" ? ` ${args.args.slice(0, 40)}` : "";
+        return `${server}${args.tool}${toolArgs}`;
+    }
+    const queriesPreview = previewArray(args.queries);
+    if (queriesPreview)
+        return truncatePreview(queriesPreview, 60);
+    if (typeof args.query === "string" && args.query.trim().length > 0)
+        return truncatePreview(args.query, 60);
+    if (typeof args.workflow === "string" && args.workflow.trim().length > 0)
+        return `workflow=${truncatePreview(args.workflow, 48)}`;
+    if (typeof args.url === "string" && args.url.trim().length > 0)
+        return truncatePreview(args.url, 60);
+    const urlsPreview = previewArray(args.urls);
+    if (urlsPreview)
+        return truncatePreview(urlsPreview, 60);
+    if (typeof args.prompt === "string" && args.prompt.trim().length > 0)
+        return truncatePreview(args.prompt, 60);
+    const previewKeys = ["command", "path", "file_path", "pattern", "query", "url", "task", "describe", "search"];
+    for (const key of previewKeys) {
+        if (args[key] && typeof args[key] === "string") {
+            const value = args[key];
+            return truncatePreview(value, 60);
+        }
+    }
+    // Fallback: show first string value found
+    for (const [key, value] of Object.entries(args)) {
+        const arrayPreview = previewArray(value);
+        if (arrayPreview)
+            return `${key}=${truncatePreview(arrayPreview, 50)}`;
+        if (typeof value === "string" && value.length > 0) {
+            const preview = truncatePreview(value, 50);
+            return `${key}=${preview}`;
+        }
+    }
+    return "";
+}
+/**
+ * Extract text content from various message content formats
+ */
+export function extractTextFromContent(content) {
+    if (!content)
+        return "";
+    // Handle string content directly
+    if (typeof content === "string")
+        return content;
+    // Handle array content
+    if (!Array.isArray(content))
+        return "";
+    const texts = [];
+    for (const part of content) {
+        if (part && typeof part === "object") {
+            // Handle { type: "text", text: "..." }
+            if ("type" in part && part.type === "text" && "text" in part) {
+                texts.push(String(part.text));
+            }
+            // Handle { type: "tool_result", content: "..." }
+            else if ("type" in part && part.type === "tool_result" && "content" in part) {
+                const inner = extractTextFromContent(part.content);
+                if (inner)
+                    texts.push(inner);
+            }
+            // Handle { text: "..." } without type
+            else if ("text" in part) {
+                texts.push(String(part.text));
+            }
+        }
+    }
+    return texts.join("\n");
+}
+// ============================================================================
+// Concurrency Utilities
+// ============================================================================
+export { mapConcurrent } from "../runs/shared/parallel-utils.js";