@camerontaylor/paseo-server 0.8.0-fork.1

package/dist/server/server/agent/providers/omp/session-descriptor.js

@@ -0,0 +1,389 @@
+import { open, readdir, readFile, stat } from "node:fs/promises";
+import { homedir } from "node:os";
+import path from "node:path";
+import { createRealpathAwarePathMatcher } from "../../../../utils/path.js";
+const OMP_CONFIG_DIR_NAME = ".omp";
+const OMP_AGENT_DIR_ENV = "OMP_AGENT_DIR";
+const OMP_SESSION_DIR_ENV = "OMP_SESSION_DIR";
+// Import listing intentionally bounds header parsing to this window. Sessions
+// with unusually large preambles may omit their first-prompt preview.
+const HEAD_BYTES = 64 * 1024;
+const TAIL_BYTES = 256 * 1024;
+const FULL_SCAN_LINE_LIMIT = 2000;
+// Rank all discovered files cheaply, then parse only a bounded recent window.
+// OMP keeps nested completed-subagent transcripts importable, so discovery
+// remains recursive rather than applying Pi's historical parent-only depth cap.
+const IMPORT_CANDIDATE_OVERSCAN = 40;
+const IMPORT_CANDIDATE_MIN = 400;
+export async function listOmpImportableSessions(options = {}) {
+    const sessionsDir = await resolveOmpSessionsDir(options);
+    const files = await walkJsonlFiles(sessionsDir);
+    const matchesCwd = options.cwd ? createRealpathAwarePathMatcher(options.cwd) : null;
+    const limit = options.limit ?? 20;
+    const ranked = await rankSessionFilesByMtime(files);
+    const candidateLimit = Math.min(options.scanLimit ?? Math.max(limit * IMPORT_CANDIDATE_OVERSCAN, IMPORT_CANDIDATE_MIN), 500);
+    const candidates = options.scanLimit === undefined && matchesCwd ? ranked : ranked.slice(0, candidateLimit);
+    const sessions = [];
+    for (const entry of candidates) {
+        const session = await readOmpImportableSession(entry.file);
+        if (!session)
+            continue;
+        if (matchesCwd && !matchesCwd(session.cwd))
+            continue;
+        sessions.push(session);
+        if (sessions.length >= limit) {
+            break;
+        }
+    }
+    return sessions.sort((left, right) => right.lastActivityAt.getTime() - left.lastActivityAt.getTime());
+}
+export async function readOmpImportSessionConfig(filePath) {
+    const descriptor = await readOmpSessionDescriptor(filePath);
+    if (!descriptor)
+        return {};
+    return toOmpImportSessionConfig(descriptor);
+}
+async function resolveOmpSessionsDir(options) {
+    const env = options.env ?? process.env;
+    const homeDir = options.homeDir ?? homedir();
+    const baseDir = options.cwd ?? process.cwd();
+    if (options.sessionDir?.trim()) {
+        return resolveConfigPath(options.sessionDir, { baseDir, homeDir });
+    }
+    const agentDir = resolveOmpAgentDir({ runtimeSettings: options.runtimeSettings, env, homeDir });
+    const envSessionDir = options.runtimeSettings?.env?.[OMP_SESSION_DIR_ENV] ?? env[OMP_SESSION_DIR_ENV];
+    if (envSessionDir?.trim()) {
+        return resolveConfigPath(envSessionDir, { baseDir, homeDir });
+    }
+    const settingsSessionDir = await readConfiguredSessionDir({
+        agentDir,
+        cwd: options.cwd,
+    });
+    if (settingsSessionDir?.trim()) {
+        return resolveConfigPath(settingsSessionDir, { baseDir, homeDir });
+    }
+    return path.join(agentDir, "sessions");
+}
+function resolveOmpAgentDir(input) {
+    const configured = input.runtimeSettings?.env?.[OMP_AGENT_DIR_ENV] ?? input.env[OMP_AGENT_DIR_ENV];
+    if (configured?.trim()) {
+        return resolveConfigPath(configured, { baseDir: process.cwd(), homeDir: input.homeDir });
+    }
+    return path.join(input.homeDir, OMP_CONFIG_DIR_NAME, "agent");
+}
+async function readConfiguredSessionDir(input) {
+    const values = await Promise.all([
+        readSessionDirFromSettings(path.join(input.agentDir, "settings.json")),
+        input.cwd
+            ? readSessionDirFromSettings(path.join(input.cwd, OMP_CONFIG_DIR_NAME, "settings.json"))
+            : null,
+    ]);
+    return values[1] ?? values[0] ?? null;
+}
+async function readSessionDirFromSettings(settingsPath) {
+    try {
+        const parsed = JSON.parse(await readFile(settingsPath, "utf8"));
+        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+            return null;
+        }
+        const sessionDir = Reflect.get(parsed, "sessionDir");
+        return typeof sessionDir === "string" && sessionDir.trim() ? sessionDir : null;
+    }
+    catch {
+        return null;
+    }
+}
+function resolveConfigPath(value, options) {
+    if (value === "~") {
+        return options.homeDir;
+    }
+    if (value.startsWith("~/")) {
+        return path.join(options.homeDir, value.slice(2));
+    }
+    return path.isAbsolute(value) ? value : path.resolve(options.baseDir, value);
+}
+async function walkJsonlFiles(root) {
+    let entries;
+    try {
+        entries = await readdir(root, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+    const files = await Promise.all(entries.map(async (entry) => {
+        const entryPath = path.join(root, entry.name);
+        if (entry.isDirectory()) {
+            return await walkJsonlFiles(entryPath);
+        }
+        return entry.isFile() && entry.name.endsWith(".jsonl") ? [entryPath] : [];
+    }));
+    return files.flat();
+}
+async function rankSessionFilesByMtime(files) {
+    const ranked = await Promise.all(files.map(async (file) => {
+        const mtime = await readFileMtime(file);
+        return mtime ? { file, mtime } : null;
+    }));
+    return ranked
+        .filter((entry) => entry !== null)
+        .sort((left, right) => right.mtime.getTime() - left.mtime.getTime());
+}
+async function readOmpImportableSession(filePath) {
+    const descriptor = await readOmpSessionDescriptor(filePath);
+    if (!descriptor)
+        return null;
+    return {
+        providerHandleId: filePath,
+        cwd: descriptor.cwd,
+        title: descriptor.title,
+        firstPromptPreview: normalizePromptPreview(descriptor.firstUserMessage),
+        lastPromptPreview: normalizePromptPreview(descriptor.lastUserMessage ?? descriptor.firstUserMessage),
+        lastActivityAt: descriptor.lastActivityAt,
+    };
+}
+async function readOmpSessionDescriptor(filePath) {
+    // OMP may emit title/session_info lines before the session header.
+    const headChunk = await readHeadChunk(filePath);
+    if (!headChunk)
+        return null;
+    const header = parseSessionHeaderFromChunk(headChunk);
+    if (!header)
+        return null;
+    const tail = await readTail(filePath).catch(() => "");
+    const tailInfo = parseSessionTail(tail);
+    const headInfo = parseSessionHeadFromChunk(headChunk);
+    const title = tailInfo.title ??
+        headInfo.title ??
+        readReadableSessionTitleFromPath(filePath) ??
+        headInfo.firstUserMessage;
+    const model = tailInfo.model ?? headInfo.model;
+    const thinkingOptionId = tailInfo.thinkingOptionId ?? headInfo.thinkingOptionId;
+    const lastActivityAt = tailInfo.lastActivityAt ?? (await readFileMtime(filePath)) ?? header.createdAt ?? new Date(0);
+    return {
+        cwd: header.cwd,
+        title,
+        firstUserMessage: headInfo.firstUserMessage,
+        lastUserMessage: tailInfo.lastUserMessage,
+        lastActivityAt,
+        model,
+        thinkingOptionId,
+    };
+}
+function toOmpImportSessionConfig(descriptor) {
+    return {
+        ...(descriptor.model ? { model: descriptor.model } : {}),
+        ...(descriptor.thinkingOptionId ? { thinkingOptionId: descriptor.thinkingOptionId } : {}),
+    };
+}
+async function readHeadChunk(filePath) {
+    const handle = await open(filePath, "r").catch(() => null);
+    if (!handle)
+        return null;
+    try {
+        const buffer = Buffer.alloc(HEAD_BYTES);
+        const { bytesRead } = await handle.read(buffer, 0, buffer.length, 0);
+        if (bytesRead <= 0)
+            return null;
+        return buffer.subarray(0, bytesRead).toString("utf8");
+    }
+    finally {
+        await handle.close().catch(() => undefined);
+    }
+}
+function parseSessionHeaderFromChunk(chunk) {
+    for (const line of chunk.split(/\r?\n/u)) {
+        const header = parseSessionHeader(line.trim());
+        if (header)
+            return header;
+    }
+    return null;
+}
+function parseSessionHeadFromChunk(chunk) {
+    let title = null;
+    let firstUserMessage = null;
+    let model = null;
+    let thinkingOptionId = null;
+    let lineCount = 0;
+    for (const rawLine of chunk.split(/\r?\n/u)) {
+        lineCount += 1;
+        const entry = parseJsonRecord(rawLine.trim());
+        if (!entry)
+            continue;
+        if (entry.type === "session_info") {
+            title = readNonEmptyString(entry.name) ?? title;
+        }
+        if (entry.type === "title") {
+            title = readNonEmptyString(entry.title) ?? title;
+        }
+        model = extractModel(entry) ?? model;
+        thinkingOptionId = extractThinkingOptionId(entry) ?? thinkingOptionId;
+        if (!firstUserMessage && entry.type === "message" && isRecord(entry.message)) {
+            if (entry.message.role === "user") {
+                firstUserMessage = extractMessageText(entry.message.content);
+            }
+        }
+        if (title && firstUserMessage && model && thinkingOptionId) {
+            break;
+        }
+        if (lineCount >= FULL_SCAN_LINE_LIMIT && firstUserMessage) {
+            break;
+        }
+    }
+    return { title, firstUserMessage, model, thinkingOptionId };
+}
+async function readTail(filePath) {
+    const fileStats = await stat(filePath);
+    const start = Math.max(0, fileStats.size - TAIL_BYTES);
+    const length = fileStats.size - start;
+    const handle = await open(filePath, "r");
+    try {
+        const buffer = Buffer.alloc(length);
+        const { bytesRead } = await handle.read(buffer, 0, buffer.length, start);
+        return buffer.subarray(0, bytesRead).toString("utf8");
+    }
+    finally {
+        await handle.close().catch(() => undefined);
+    }
+}
+async function readFileMtime(filePath) {
+    try {
+        return (await stat(filePath)).mtime;
+    }
+    catch {
+        return null;
+    }
+}
+function parseSessionHeader(firstLine) {
+    const entry = parseJsonRecord(firstLine);
+    if (!entry || entry.type !== "session")
+        return null;
+    const sessionId = typeof entry.id === "string" ? entry.id : null;
+    const cwd = typeof entry.cwd === "string" ? entry.cwd : null;
+    if (!sessionId || !cwd)
+        return null;
+    const createdAt = parseDate(entry.timestamp);
+    return { sessionId, cwd, createdAt };
+}
+function parseSessionTail(tail) {
+    const lines = tail.split(/\r?\n/u);
+    let title = null;
+    let lastActivityAt = null;
+    let fallbackTimestamp = null;
+    let lastUserMessage = null;
+    let model = null;
+    let thinkingOptionId = null;
+    for (let index = lines.length - 1; index >= 0; index -= 1) {
+        const entry = parseJsonRecord(lines[index].trim());
+        if (!entry)
+            continue;
+        if (!title && entry.type === "session_info") {
+            title = readNonEmptyString(entry.name);
+        }
+        if (!title && entry.type === "title") {
+            title = readNonEmptyString(entry.title);
+        }
+        if (!model) {
+            model = extractModel(entry);
+        }
+        if (!thinkingOptionId) {
+            thinkingOptionId = extractThinkingOptionId(entry);
+        }
+        const entryTimestamp = parseDate(entry.timestamp);
+        if (!fallbackTimestamp && entryTimestamp) {
+            fallbackTimestamp = entryTimestamp;
+        }
+        if (entry.type !== "message")
+            continue;
+        if (!lastActivityAt && entryTimestamp) {
+            lastActivityAt = entryTimestamp;
+        }
+        if (!lastUserMessage && isRecord(entry.message) && entry.message.role === "user") {
+            lastUserMessage = extractMessageText(entry.message.content);
+        }
+    }
+    return {
+        title,
+        lastActivityAt: lastActivityAt ?? fallbackTimestamp,
+        lastUserMessage,
+        model,
+        thinkingOptionId,
+    };
+}
+function extractModel(entry) {
+    if (entry.type === "model_change") {
+        // Pi records provider + modelId; OMP records a combined model string.
+        return buildModelId(entry.provider, entry.modelId) ?? readNonEmptyString(entry.model);
+    }
+    if (entry.type === "message" && isRecord(entry.message)) {
+        return buildModelId(entry.message.provider, entry.message.model);
+    }
+    return null;
+}
+function extractThinkingOptionId(entry) {
+    return entry.type === "thinking_level_change" ? readNonEmptyString(entry.thinkingLevel) : null;
+}
+function buildModelId(provider, modelId) {
+    const providerName = readNonEmptyString(provider);
+    const modelName = readNonEmptyString(modelId);
+    if (!providerName || !modelName) {
+        return null;
+    }
+    return `${providerName}/${modelName}`;
+}
+function parseJsonRecord(line) {
+    if (!line)
+        return null;
+    try {
+        const parsed = JSON.parse(line);
+        return isRecord(parsed) ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readNonEmptyString(value) {
+    return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+function normalizePromptPreview(text) {
+    const normalized = text?.trim().replace(/\s+/g, " ") ?? "";
+    if (!normalized)
+        return null;
+    return normalized.length > 160 ? normalized.slice(0, 160) : normalized;
+}
+function readReadableSessionTitleFromPath(filePath) {
+    const stem = path.basename(filePath, ".jsonl").trim();
+    if (!stem) {
+        return null;
+    }
+    if (/^\d{4}-\d{2}-\d{2}T\d{2}[-:]\d{2}[-:]\d{2}/u.test(stem)) {
+        return null;
+    }
+    if (/^[0-9a-f]{8,}$/iu.test(stem)) {
+        return null;
+    }
+    return stem;
+}
+function parseDate(value) {
+    if (typeof value !== "string" && typeof value !== "number") {
+        return null;
+    }
+    const date = new Date(value);
+    return Number.isNaN(date.getTime()) ? null : date;
+}
+function extractMessageText(content) {
+    if (typeof content === "string") {
+        return content.trim() || null;
+    }
+    if (!Array.isArray(content)) {
+        return null;
+    }
+    const text = content
+        .flatMap((part) => isRecord(part) && part.type === "text" && typeof part.text === "string" ? [part.text] : [])
+        .join("\n\n")
+        .trim();
+    return text || null;
+}
+//# sourceMappingURL=session-descriptor.js.map

package/dist/server/server/agent/providers/omp/subagent-card-tracker.d.ts

@@ -0,0 +1,33 @@
+import type { ToolCallDetail } from "../../agent-sdk-types.js";
+import type { OmpSubagentLifecyclePayload, OmpSubagentProgressPayload } from "./rpc-types.js";
+export interface OmpSubagentCardTimer {
+    readonly token: unknown;
+}
+export interface OmpSubagentCardScheduler {
+    now(): number;
+    setTimeout(callback: () => void, delayMs: number): OmpSubagentCardTimer;
+    clearTimeout(timer: OmpSubagentCardTimer): void;
+}
+export interface OmpSubagentCardTrackerOptions {
+    scheduler?: OmpSubagentCardScheduler;
+    emitToolCall?: (toolCallId: string) => boolean;
+}
+export declare function createOmpSubagentCardScheduler(): OmpSubagentCardScheduler;
+export declare class OmpSubagentCardTracker {
+    private readonly scheduler;
+    private readonly emitToolCall;
+    private readonly states;
+    constructor(options: OmpSubagentCardTrackerOptions);
+    handleLifecycle(payload: OmpSubagentLifecyclePayload, emitToolCall?: (toolCallId: string) => boolean): void;
+    handleProgress(payload: OmpSubagentProgressPayload, emitToolCall?: (toolCallId: string) => boolean): void;
+    detailFor(toolCallId: string, baseDetail: ToolCallDetail): ToolCallDetail;
+    flush(toolCallId: string): void;
+    delete(toolCallId: string): void;
+    clear(): void;
+    private upsertItem;
+    private stateFor;
+    private appendLine;
+    private requestEmit;
+    private emitNow;
+}
+//# sourceMappingURL=subagent-card-tracker.d.ts.map

package/dist/server/server/agent/providers/omp/subagent-card-tracker.js

@@ -0,0 +1,264 @@
+const MAX_LOG_LINES_PER_ITEM = 200;
+const MAX_LOG_LINE_CHARS = 240;
+const THROTTLE_INTERVAL_MS = 500;
+export function createOmpSubagentCardScheduler() {
+    return {
+        now: () => Date.now(),
+        setTimeout: (callback, delayMs) => ({ token: setTimeout(callback, delayMs) }),
+        clearTimeout: (timer) => {
+            clearTimeout(timer.token);
+        },
+    };
+}
+export class OmpSubagentCardTracker {
+    constructor(options) {
+        this.states = new Map();
+        this.scheduler = options.scheduler ?? createOmpSubagentCardScheduler();
+        this.emitToolCall = options.emitToolCall ?? (() => false);
+    }
+    handleLifecycle(payload, emitToolCall = this.emitToolCall) {
+        const parentToolCallId = readTrimmedString(payload.parentToolCallId);
+        if (!parentToolCallId) {
+            return;
+        }
+        this.stateFor(parentToolCallId).emitToolCall = emitToolCall;
+        const item = this.upsertItem(parentToolCallId, {
+            index: payload.index,
+            agent: payload.agent,
+            description: payload.description,
+            status: payload.status === "started" ? "running" : payload.status,
+            childSessionId: payload.sessionFile,
+        });
+        this.appendLine(item, `lifecycle:${payload.status}:${payload.id}`, `${payload.id} ${payload.status}`);
+        this.requestEmit(parentToolCallId);
+    }
+    handleProgress(payload, emitToolCall = this.emitToolCall) {
+        const parentToolCallId = readTrimmedString(payload.parentToolCallId);
+        if (!parentToolCallId) {
+            return;
+        }
+        this.stateFor(parentToolCallId).emitToolCall = emitToolCall;
+        const item = this.upsertItem(parentToolCallId, {
+            index: payload.index,
+            agent: payload.agent,
+            description: payload.progress.description,
+            status: payload.progress.status,
+            childSessionId: payload.sessionFile,
+        });
+        const currentToolLine = summarizeTool(readRecord(payload.progress.currentTool));
+        if (currentToolLine) {
+            this.appendLine(item, `current:${currentToolLine.key}`, currentToolLine.text);
+        }
+        for (const tool of readRecordArray(payload.progress.recentTools)) {
+            const line = summarizeTool(tool);
+            if (line) {
+                this.appendLine(item, `tool:${line.key}`, line.text);
+            }
+        }
+        for (const output of readOutputLines(payload.progress.recentOutput)) {
+            this.appendLine(item, `output:${output}`, output);
+        }
+        if (payload.progress.status !== "running") {
+            this.appendLine(item, `status:${payload.progress.status}:${payload.progress.id}`, `${payload.progress.id} ${payload.progress.status}`);
+        }
+        this.requestEmit(parentToolCallId);
+    }
+    detailFor(toolCallId, baseDetail) {
+        if (baseDetail.type !== "sub_agent") {
+            return baseDetail;
+        }
+        const state = this.states.get(toolCallId);
+        if (!state) {
+            return baseDetail;
+        }
+        const items = [...state.items.values()].sort((left, right) => left.index - right.index);
+        const firstItem = items[0];
+        if (!firstItem) {
+            return baseDetail;
+        }
+        const detail = {
+            type: "sub_agent",
+            ...(baseDetail.subAgentType ? { subAgentType: baseDetail.subAgentType } : {}),
+            ...((baseDetail.description ?? firstItem.description)
+                ? { description: baseDetail.description ?? firstItem.description }
+                : {}),
+            ...((firstItem.childSessionId ?? baseDetail.childSessionId)
+                ? { childSessionId: firstItem.childSessionId ?? baseDetail.childSessionId }
+                : {}),
+            log: buildLog(items, baseDetail.log),
+        };
+        return baseDetail.actions ? { ...detail, actions: baseDetail.actions } : detail;
+    }
+    flush(toolCallId) {
+        const state = this.states.get(toolCallId);
+        if (!state || !state.dirty) {
+            return;
+        }
+        this.emitNow(toolCallId, state);
+    }
+    delete(toolCallId) {
+        const state = this.states.get(toolCallId);
+        if (state?.trailingTimer) {
+            this.scheduler.clearTimeout(state.trailingTimer);
+        }
+        this.states.delete(toolCallId);
+    }
+    clear() {
+        for (const toolCallId of this.states.keys()) {
+            this.delete(toolCallId);
+        }
+    }
+    upsertItem(parentToolCallId, input) {
+        const state = this.stateFor(parentToolCallId);
+        const existing = state.items.get(input.index);
+        if (existing) {
+            existing.agent = readTrimmedString(input.agent) ?? existing.agent;
+            existing.status = input.status ?? existing.status;
+            existing.description = readTrimmedString(input.description) ?? existing.description;
+            existing.childSessionId = readTrimmedString(input.childSessionId) ?? existing.childSessionId;
+            return existing;
+        }
+        const item = {
+            index: input.index,
+            lines: [],
+            lineKeys: new Set(),
+            ...(readTrimmedString(input.agent) ? { agent: readTrimmedString(input.agent) } : {}),
+            ...(input.status ? { status: input.status } : {}),
+            ...(readTrimmedString(input.description)
+                ? { description: readTrimmedString(input.description) }
+                : {}),
+            ...(readTrimmedString(input.childSessionId)
+                ? { childSessionId: readTrimmedString(input.childSessionId) }
+                : {}),
+        };
+        state.items.set(input.index, item);
+        return item;
+    }
+    stateFor(parentToolCallId) {
+        const existing = this.states.get(parentToolCallId);
+        if (existing) {
+            return existing;
+        }
+        const state = {
+            items: new Map(),
+            emitToolCall: this.emitToolCall,
+            lastEmitMs: null,
+            trailingTimer: null,
+            dirty: false,
+        };
+        this.states.set(parentToolCallId, state);
+        return state;
+    }
+    appendLine(item, key, text) {
+        const normalizedText = normalizeLine(text);
+        if (!normalizedText || item.lineKeys.has(key)) {
+            return;
+        }
+        item.lines.push({ key, text: normalizedText });
+        item.lineKeys.add(key);
+        while (item.lines.length > MAX_LOG_LINES_PER_ITEM) {
+            const removed = item.lines.shift();
+            if (removed) {
+                item.lineKeys.delete(removed.key);
+            }
+        }
+    }
+    requestEmit(toolCallId) {
+        const state = this.stateFor(toolCallId);
+        const now = this.scheduler.now();
+        const elapsedMs = state.lastEmitMs === null ? THROTTLE_INTERVAL_MS : now - state.lastEmitMs;
+        if (elapsedMs >= THROTTLE_INTERVAL_MS) {
+            this.emitNow(toolCallId, state);
+            return;
+        }
+        state.dirty = true;
+        if (state.trailingTimer) {
+            return;
+        }
+        state.trailingTimer = this.scheduler.setTimeout(() => {
+            state.trailingTimer = null;
+            if (state.dirty) {
+                this.emitNow(toolCallId, state);
+            }
+        }, THROTTLE_INTERVAL_MS - elapsedMs);
+    }
+    emitNow(toolCallId, state) {
+        if (state.trailingTimer) {
+            this.scheduler.clearTimeout(state.trailingTimer);
+            state.trailingTimer = null;
+        }
+        state.dirty = false;
+        state.lastEmitMs = this.scheduler.now();
+        state.emitToolCall(toolCallId);
+    }
+}
+function buildLog(items, fallback) {
+    const itemCount = Math.max(...items.map((item) => item.index)) + 1;
+    const lines = items.flatMap((item) => {
+        const prefix = itemCount > 1 ? `[${item.index + 1}/${itemCount}] ` : "";
+        return item.lines.map((line) => `${prefix}${line.text}`);
+    });
+    return lines.length > 0 ? lines.join("\n") : fallback;
+}
+function summarizeTool(tool) {
+    if (!tool) {
+        return null;
+    }
+    const toolName = readTrimmedString(tool.tool) ?? readTrimmedString(tool.name);
+    if (!toolName) {
+        return null;
+    }
+    const args = readTrimmedString(tool.args) ?? summarizeUnknown(tool.input);
+    const endMs = typeof tool.endMs === "number" ? `:${tool.endMs}` : "";
+    return {
+        key: `${toolName}:${args ?? ""}${endMs}`,
+        text: args ? `[${toolName}] ${args}` : `[${toolName}]`,
+    };
+}
+function readOutputLines(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return value.flatMap((item) => {
+        const text = readTrimmedString(item) ??
+            (isRecord(item)
+                ? (readTrimmedString(item.text) ??
+                    readTrimmedString(item.output) ??
+                    readTrimmedString(item.content))
+                : undefined);
+        return text ? [text] : [];
+    });
+}
+function readRecord(value) {
+    return isRecord(value) ? value : null;
+}
+function readRecordArray(value) {
+    return Array.isArray(value) ? value.filter(isRecord) : [];
+}
+function summarizeUnknown(value) {
+    if (value === undefined || value === null) {
+        return undefined;
+    }
+    if (typeof value === "string") {
+        return readTrimmedString(value);
+    }
+    const json = JSON.stringify(value);
+    return typeof json === "string" ? normalizeLine(json) : undefined;
+}
+function normalizeLine(value) {
+    const normalized = value.trim().replace(/\s+/g, " ");
+    if (!normalized) {
+        return undefined;
+    }
+    if (normalized.length <= MAX_LOG_LINE_CHARS) {
+        return normalized;
+    }
+    return `${normalized.slice(0, MAX_LOG_LINE_CHARS)}...`;
+}
+function readTrimmedString(value) {
+    return typeof value === "string" && value.trim().length > 0 ? value.trim() : undefined;
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+//# sourceMappingURL=subagent-card-tracker.js.map

package/dist/server/server/agent/providers/omp/subagent-index.d.ts

@@ -0,0 +1,13 @@
+import type { AgentStreamEvent } from "../../agent-sdk-types.js";
+import type { OmpSubagentEventPayload, OmpSubagentLifecyclePayload, OmpSubagentProgressPayload } from "./rpc-types.js";
+export declare class OmpSubagentIndex {
+    private readonly statesByParent;
+    handleLifecycle(parent: object, payload: OmpSubagentLifecyclePayload): AgentStreamEvent[];
+    handleProgress(parent: object, payload: OmpSubagentProgressPayload): AgentStreamEvent[];
+    handleEvent(parent: object, payload: OmpSubagentEventPayload): AgentStreamEvent[];
+    terminalizeRunning(parent: object): AgentStreamEvent[];
+    clear(parent: object): void;
+    private stateFor;
+    private upsert;
+}
+//# sourceMappingURL=subagent-index.d.ts.map