@orion-agents/orion-code 0.1.0

package/dist/runtime/ui-view-model.js

@@ -0,0 +1,700 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.subtaskEventToTimelineEntry = subtaskEventToTimelineEntry;
+exports.subtaskTimelineLabel = subtaskTimelineLabel;
+exports.contextUsageStatusText = contextUsageStatusText;
+exports.rendererStatus = rendererStatus;
+exports.rendererCapabilityLabels = rendererCapabilityLabels;
+exports.createRuntimeCapabilitySummary = createRuntimeCapabilitySummary;
+exports.createSessionRestoredView = createSessionRestoredView;
+exports.sessionPickerTitle = sessionPickerTitle;
+exports.clampPromptCursor = clampPromptCursor;
+exports.createPromptState = createPromptState;
+exports.createCommandPickerState = createCommandPickerState;
+exports.getFileMentionQuery = getFileMentionQuery;
+exports.createFilePickerState = createFilePickerState;
+exports.createPermissionDecisionPickerState = createPermissionDecisionPickerState;
+exports.createEditPreviewPickerState = createEditPreviewPickerState;
+exports.createModelPickerState = createModelPickerState;
+exports.permissionScopeFromArgs = permissionScopeFromArgs;
+exports.permissionScopeDisplayValue = permissionScopeDisplayValue;
+exports.permissionRiskDisplayValue = permissionRiskDisplayValue;
+exports.createPermissionPromptState = createPermissionPromptState;
+exports.createSessionPickerState = createSessionPickerState;
+exports.movePickerPageOffset = movePickerPageOffset;
+exports.createStatusSnapshot = createStatusSnapshot;
+exports.transcriptEntryToBlock = transcriptEntryToBlock;
+exports.toolActivityBatchLabel = toolActivityBatchLabel;
+exports.toolActivityFromStarted = toolActivityFromStarted;
+exports.toolActivityFromFinished = toolActivityFromFinished;
+exports.formatToolActivityTranscript = formatToolActivityTranscript;
+const ui_events_1 = require("./ui-events");
+const format_1 = require("../services/format");
+const verification_profile_1 = require("../services/verification-profile");
+/**
+ * Map a {@link RuntimeSubtaskEvent} to a timeline entry. Pure: renderers call
+ * this from their `subtaskEvent` consumer and store the result keyed by
+ * `taskId`, so each task has exactly one entry whose state advances.
+ */
+function subtaskEventToTimelineEntry(event) {
+    const terminalStates = [
+        'completed',
+        'failed',
+        'cancelled',
+        'timed_out',
+        'rejected',
+    ];
+    return {
+        batchId: event.batchId,
+        taskId: event.taskId,
+        role: event.role,
+        state: event.state,
+        objective: event.objective,
+        summary: event.summary,
+        durationMs: event.durationMs,
+        terminal: terminalStates.includes(event.state),
+    };
+}
+/** A short human-readable label for a timeline entry, used by renderers. */
+function subtaskTimelineLabel(entry) {
+    const arrow = entry.terminal ? '◂' : '▸';
+    const tail = entry.summary ? ` - ${entry.summary.slice(0, 120)}` : '';
+    const dur = entry.durationMs ? ` (${entry.durationMs}ms)` : '';
+    return `${arrow} subtask ${entry.role} ${entry.state}${tail}${dur}`;
+}
+function contextUsageStatusText(usage) {
+    if (!usage)
+        return '';
+    const label = `ctx=${usage.percent}%`;
+    if (usage.autoCompactEnabled && usage.percent >= usage.autoCompactThresholdPercent) {
+        return `${label} auto-compact`;
+    }
+    if (usage.percent >= usage.warningThresholdPercent) {
+        return `${label} /compact`;
+    }
+    return label;
+}
+const COMMAND_CATEGORY_LABELS = {
+    workflow: 'Workflow',
+    session: 'Session',
+    context: 'Context',
+    tools: 'Tools',
+    model: 'Model',
+    system: 'System',
+    diagnostics: 'Diagnostics',
+    legacy: 'Legacy',
+};
+function rendererStatus(renderer) {
+    if (renderer === 'terminal')
+        return 'stable';
+    if (renderer === 'tui')
+        return 'beta';
+    if (renderer === 'ink')
+        return 'deprecated';
+    if (renderer === 'print')
+        return 'non-interactive';
+    return 'custom';
+}
+function rendererCapabilityLabels(capabilities) {
+    return [
+        capabilities.structuredPickers ? 'pickers' : 'text-pickers',
+        capabilities.inlineProgress ? 'inline-progress' : 'legacy-progress',
+        capabilities.suppressLegacyTokenMeta ? 'clean-meta' : 'legacy-meta',
+        capabilities.extraAssistantSpacing ? 'assistant-spacing' : 'compact-spacing',
+        capabilities.suppressAbortNotice ? 'quiet-abort' : 'abort-notice',
+    ];
+}
+function createRuntimeCapabilitySummary(input = {}) {
+    const hasProjectRules = Boolean(input.projectInstructionsContent?.trim());
+    const hasSkills = Boolean(input.skillsContent?.trim());
+    const hasMemory = Boolean(input.memoryContent?.trim());
+    const hasMcp = Boolean(input.tools?.some(tool => tool.name.startsWith('mcp__')));
+    const hasWebSearch = Boolean(input.webSearchConfigured);
+    const labels = ['scrollback', 'CJK input', 'paste/edit', 'trace'];
+    if (hasProjectRules)
+        labels.push('repo rules');
+    if (hasSkills)
+        labels.push('skills');
+    if (hasMemory)
+        labels.push('memory');
+    if (hasMcp)
+        labels.push('MCP');
+    if (hasWebSearch)
+        labels.push('web search');
+    return {
+        labels,
+        text: labels.join(', '),
+        hasProjectRules,
+        hasSkills,
+        hasMemory,
+        hasMcp,
+        hasWebSearch,
+    };
+}
+function normalizeSingleLineText(value) {
+    return value.replace(/\s+/g, ' ').trim();
+}
+function createSessionRestoredView(event) {
+    const shortId = event.sessionId.slice(0, 8);
+    const summary = event.summary ? normalizeSingleLineText(event.summary) : undefined;
+    const hasDetailedCounts = typeof event.transcriptMessages === 'number';
+    const total = typeof event.messageCount === 'number' ? `/${event.messageCount}` : '';
+    const view = {
+        sessionId: event.sessionId,
+        shortId,
+        projectPath: event.projectPath,
+        model: event.model,
+        restoredMessages: event.restoredMessages,
+        messageCount: event.messageCount,
+        summary: summary || undefined,
+        headline: hasDetailedCounts
+            ? `Resumed session ${shortId} · restored ${event.restoredMessages} model-context / ${event.transcriptMessages} transcript messages`
+            : `Resumed session ${shortId} · restored ${event.restoredMessages}${total} messages`,
+    };
+    if (event.summaryGeneratedAt !== undefined)
+        view.summaryGeneratedAt = event.summaryGeneratedAt;
+    if (event.summarySource !== undefined)
+        view.summarySource = event.summarySource;
+    if (event.summaryCoveredMessages !== undefined) {
+        view.summaryCoveredMessages = event.summaryCoveredMessages;
+    }
+    if (event.checkpointId !== undefined)
+        view.checkpointId = event.checkpointId;
+    if (event.transcriptMessages !== undefined)
+        view.transcriptMessages = event.transcriptMessages;
+    return view;
+}
+function sessionPickerTitle(session) {
+    return session.name || session.taskSummary || '(untitled)';
+}
+function clampPromptCursor(value, cursor) {
+    if (typeof cursor !== 'number' || !Number.isFinite(cursor))
+        return value.length;
+    return Math.min(Math.max(0, Math.floor(cursor)), value.length);
+}
+function promptCompletionState(value) {
+    const commandMatch = value.match(/^\/([^\s]*)$/u);
+    if (commandMatch) {
+        return { kind: 'command', query: commandMatch[1] ?? '' };
+    }
+    const fileQuery = getFileMentionQuery(value);
+    if (fileQuery) {
+        return { kind: 'file', base: fileQuery.base, query: fileQuery.query };
+    }
+    return { kind: 'none' };
+}
+function promptHistoryState(index, size) {
+    const safeSize = typeof size === 'number' && Number.isFinite(size) && size > 0 ? Math.floor(size) : 0;
+    const safeIndex = typeof index === 'number' && Number.isFinite(index) ? Math.floor(index) : -1;
+    const active = safeIndex >= 0 && safeIndex < safeSize;
+    return {
+        index: active ? safeIndex : -1,
+        size: safeSize,
+        active,
+        canMovePrevious: safeSize > 0 && (!active || safeIndex < safeSize - 1),
+        canMoveNext: active,
+    };
+}
+function createPromptState(input) {
+    const cursor = clampPromptCursor(input.value, input.cursor);
+    const before = input.value.slice(0, cursor);
+    const after = input.value.slice(cursor);
+    const currentLineIndex = before.split('\n').length - 1;
+    const lineStart = before.lastIndexOf('\n') + 1;
+    const nextLineBreak = input.value.indexOf('\n', cursor);
+    const lineEnd = nextLineBreak === -1 ? input.value.length : nextLineBreak;
+    const currentLine = input.value.slice(lineStart, lineEnd);
+    return {
+        value: input.value,
+        cursor,
+        modeText: input.modeText,
+        running: Boolean(input.running),
+        isEmpty: input.value.length === 0,
+        lineCount: input.value.split('\n').length,
+        currentLineIndex,
+        currentLine,
+        cursorInCurrentLine: cursor - lineStart,
+        textBeforeCursor: before,
+        textAfterCursor: after,
+        completion: promptCompletionState(input.value),
+        history: promptHistoryState(input.historyIndex, input.historySize),
+    };
+}
+function commandCategoryLabel(category) {
+    return COMMAND_CATEGORY_LABELS[category ?? 'system'];
+}
+function commandPickerQuery(input) {
+    return input.startsWith('/') ? input.slice(1).toLowerCase() : '';
+}
+function commandMatchRank(command, query) {
+    if (!query)
+        return 0;
+    const name = command.name.toLowerCase();
+    const aliases = command.aliases?.map(alias => alias.toLowerCase()) ?? [];
+    if (name === query)
+        return 0;
+    if (aliases.some(alias => alias === query))
+        return 1;
+    if (name.startsWith(query))
+        return 2;
+    if (aliases.some(alias => alias.startsWith(query)))
+        return 3;
+    return 4;
+}
+function commandMatchesQuery(command, query) {
+    if (!query)
+        return true;
+    const name = command.name.toLowerCase();
+    const aliases = command.aliases?.map(alias => alias.toLowerCase()) ?? [];
+    return name.startsWith(query) || aliases.some(alias => alias.startsWith(query));
+}
+function commandPickerLabel(command) {
+    const hint = command.argumentHint ? ` ${command.argumentHint}` : '';
+    const aliases = command.aliases?.length ? ` (${command.aliases.join(', ')})` : '';
+    return `/${command.name}${hint}${aliases}`;
+}
+function createCommandPickerState(input) {
+    const query = commandPickerQuery(input.input);
+    const getCategoryLabel = input.categoryLabel ?? commandCategoryLabel;
+    const ranked = input.commands
+        .map((command, index) => ({
+        command,
+        index,
+        matchRank: commandMatchRank(command, query),
+    }))
+        .filter(item => commandMatchesQuery(item.command, query))
+        .sort((left, right) => {
+        const rankDelta = left.matchRank - right.matchRank;
+        return rankDelta !== 0 ? rankDelta : left.index - right.index;
+    });
+    const totalItems = ranked.length;
+    const visibleLimit = normalizeVisibleLimit(totalItems, input.maxVisibleItems ?? totalItems);
+    const maxOffset = maxPickerOffset(totalItems, visibleLimit);
+    const visibleStart = Math.max(0, Math.min(input.visibleStart ?? 0, maxOffset));
+    const visibleItems = ranked.slice(visibleStart, visibleStart + visibleLimit).map(item => {
+        const category = getCategoryLabel(item.command.category);
+        const aliases = item.command.aliases ?? [];
+        return {
+            command: item.command,
+            name: item.command.name,
+            value: item.command.name,
+            label: commandPickerLabel(item.command),
+            description: `${category}  ${item.command.description}`,
+            categoryLabel: category,
+            aliases,
+            matchRank: item.matchRank,
+        };
+    });
+    return {
+        kind: 'command',
+        title: input.title ?? (query ? `Commands "${query}"` : 'Commands'),
+        totalItems,
+        visibleStart,
+        visibleLimit,
+        page: totalItems === 0 ? 1 : Math.floor(visibleStart / visibleLimit) + 1,
+        pageCount: totalItems === 0 ? 1 : Math.ceil(totalItems / visibleLimit),
+        visibleItems,
+        hasPreviousPage: visibleStart > 0,
+        hasNextPage: visibleStart < maxOffset,
+    };
+}
+function getFileMentionQuery(input) {
+    const match = input.match(/(^|\s)@([^\s]*)$/u);
+    if (!match || match.index === undefined)
+        return null;
+    const atIndex = match.index + match[1].length;
+    return {
+        base: input.slice(0, atIndex),
+        query: match[2] ?? '',
+    };
+}
+function filePickerValue(file) {
+    return file.isDirectory ? `${file.path}/` : file.path;
+}
+function filePickerLabel(file) {
+    return `${file.isDirectory ? 'dir' : 'file'} ${filePickerValue(file)}`;
+}
+function createFilePickerState(input) {
+    const query = getFileMentionQuery(input.input);
+    if (!query)
+        return null;
+    const totalItems = input.files.length;
+    const visibleLimit = normalizeVisibleLimit(totalItems, input.maxVisibleItems ?? totalItems);
+    const maxOffset = maxPickerOffset(totalItems, visibleLimit);
+    const visibleStart = Math.max(0, Math.min(input.visibleStart ?? 0, maxOffset));
+    return {
+        kind: 'file',
+        title: input.title ?? (query.query ? `Files "${query.query}"` : 'Files'),
+        totalItems,
+        visibleStart,
+        visibleLimit,
+        page: totalItems === 0 ? 1 : Math.floor(visibleStart / visibleLimit) + 1,
+        pageCount: totalItems === 0 ? 1 : Math.ceil(totalItems / visibleLimit),
+        visibleItems: input.files.slice(visibleStart, visibleStart + visibleLimit).map(file => ({
+            file,
+            path: file.path,
+            value: filePickerValue(file),
+            label: filePickerLabel(file),
+            description: file.isDirectory ? 'directory' : 'file',
+            isDirectory: file.isDirectory,
+        })),
+        hasPreviousPage: visibleStart > 0,
+        hasNextPage: visibleStart < maxOffset,
+    };
+}
+function previewText(value, maxLength) {
+    const singleLine = value.replace(/\s+/g, ' ').trim();
+    if (singleLine.length <= maxLength)
+        return singleLine;
+    return `${singleLine.slice(0, Math.max(0, maxLength - 3))}...`;
+}
+function createPermissionDecisionPickerState(request) {
+    const scope = permissionScopeDisplayValue(permissionScopeFromArgs(request.args));
+    const reason = request.reason?.trim();
+    const allowDescription = [scope === 'scope=unknown' ? '' : scope, reason]
+        .filter(Boolean)
+        .join('  ');
+    const items = [
+        {
+            value: 'allow',
+            label: `Allow ${request.name}`,
+            description: allowDescription,
+            approved: true,
+        },
+        {
+            value: 'deny',
+            label: `Deny ${request.name}`,
+            description: 'Do not run this tool call',
+            approved: false,
+        },
+    ];
+    return {
+        kind: 'permission',
+        title: 'Tool Permission',
+        totalItems: items.length,
+        visibleStart: 0,
+        visibleLimit: items.length,
+        page: 1,
+        pageCount: 1,
+        visibleItems: items,
+        hasPreviousPage: false,
+        hasNextPage: false,
+    };
+}
+function createEditPreviewPickerState(input) {
+    const { request } = input;
+    const totalItems = request.candidates.length;
+    const visibleLimit = normalizeVisibleLimit(totalItems, input.maxVisibleItems ?? totalItems);
+    const maxOffset = maxPickerOffset(totalItems, visibleLimit);
+    const visibleStart = Math.max(0, Math.min(input.visibleStart ?? 0, maxOffset));
+    const matchLimit = input.maxMatchLength ?? 50;
+    const replacementLimit = input.maxReplacementLength ?? 40;
+    const kindLabel = request.kind === 'fuzzy' ? `fuzzy (${request.strategy ?? 'match'})` : 'exact';
+    return {
+        kind: 'edit-preview',
+        title: `Edit Preview: ${request.path} (${kindLabel}, ${totalItems} candidate${totalItems === 1 ? '' : 's'})`,
+        totalItems,
+        visibleStart,
+        visibleLimit,
+        page: totalItems === 0 ? 1 : Math.floor(visibleStart / visibleLimit) + 1,
+        pageCount: totalItems === 0 ? 1 : Math.ceil(totalItems / visibleLimit),
+        visibleItems: request.candidates
+            .slice(visibleStart, visibleStart + visibleLimit)
+            .map(candidate => {
+            const matchPreview = previewText(candidate.match, matchLimit);
+            const replacementPreview = previewText(request.newString, replacementLimit);
+            return {
+                candidate,
+                value: String(candidate.line),
+                label: `line ${candidate.line}: ${matchPreview}`,
+                description: `→ ${replacementPreview}`,
+                line: candidate.line,
+                matchPreview,
+                replacementPreview,
+            };
+        }),
+        hasPreviousPage: visibleStart > 0,
+        hasNextPage: visibleStart < maxOffset,
+    };
+}
+function normalizePickerModelId(value) {
+    return (value ?? '').trim().toLowerCase();
+}
+function createModelPickerState(input) {
+    const current = normalizePickerModelId(input.currentModel);
+    const totalItems = input.models.length;
+    const visibleLimit = normalizeVisibleLimit(totalItems, input.maxVisibleItems ?? totalItems);
+    const maxOffset = maxPickerOffset(totalItems, visibleLimit);
+    const visibleStart = Math.max(0, Math.min(input.visibleStart ?? 0, maxOffset));
+    return {
+        kind: 'model',
+        title: input.title ?? 'Available Models',
+        totalItems,
+        visibleStart,
+        visibleLimit,
+        page: totalItems === 0 ? 1 : Math.floor(visibleStart / visibleLimit) + 1,
+        pageCount: totalItems === 0 ? 1 : Math.ceil(totalItems / visibleLimit),
+        visibleItems: input.models.slice(visibleStart, visibleStart + visibleLimit).map(model => {
+            const name = model.name;
+            const alias = model.alias?.trim() || undefined;
+            const isCurrent = current !== '' &&
+                (normalizePickerModelId(name) === current || normalizePickerModelId(alias) === current);
+            const aliasLabel = alias ? ` (${alias})` : '';
+            const description = [
+                model.provider,
+                typeof model.contextWindow === 'number' ? `${model.contextWindow} ctx` : undefined,
+                typeof model.maxOutputTokens === 'number' ? `${model.maxOutputTokens} output` : undefined,
+                model.source,
+            ]
+                .filter(Boolean)
+                .join('  ');
+            return {
+                model,
+                name,
+                value: name,
+                alias,
+                provider: model.provider,
+                contextWindow: model.contextWindow,
+                maxOutputTokens: model.maxOutputTokens,
+                source: model.source,
+                isCurrent,
+                label: `${name}${aliasLabel}`,
+                description,
+            };
+        }),
+        hasPreviousPage: visibleStart > 0,
+        hasNextPage: visibleStart < maxOffset,
+    };
+}
+function summarizePermissionValue(value) {
+    if (typeof value === 'string')
+        return value;
+    try {
+        const serialized = JSON.stringify(value);
+        return typeof serialized === 'string' ? serialized : String(value);
+    }
+    catch {
+        return String(value);
+    }
+}
+function summarizePermissionArgs(args) {
+    return Object.entries(args)
+        .slice(0, 4)
+        .map(([key, value]) => `${key}=${summarizePermissionValue(value)}`)
+        .join(' ');
+}
+function permissionScopeFromArgs(args) {
+    if (typeof args.command === 'string' && args.command.trim()) {
+        return { kind: 'command', value: `$ ${args.command}` };
+    }
+    if (typeof args.path === 'string' && args.path.trim()) {
+        return { kind: 'path', value: args.path };
+    }
+    if (Array.isArray(args.paths) && args.paths.length > 0) {
+        return { kind: 'paths', count: args.paths.length };
+    }
+    const detail = summarizePermissionArgs(args);
+    return detail ? { kind: 'args', value: detail } : { kind: 'unknown' };
+}
+function permissionScopeDisplayValue(scope) {
+    if (scope.kind === 'command')
+        return `cmd=${scope.value ?? ''}`;
+    if (scope.kind === 'path')
+        return `path=${scope.value ?? ''}`;
+    if (scope.kind === 'paths')
+        return `paths=${scope.count ?? 0}`;
+    if (scope.kind === 'args')
+        return `args=${scope.value ?? ''}`;
+    return 'scope=unknown';
+}
+function permissionRiskLevel(toolName, args = {}) {
+    if (toolName === 'exec_command' && typeof args.command === 'string') {
+        return (0, verification_profile_1.classifyCommandSafety)(args.command).risk;
+    }
+    const normalized = toolName.toLowerCase();
+    if (/(?:write|edit|delete|remove|patch|git_push|publish)/.test(normalized))
+        return 'high';
+    if (/(?:read|search|list|grep|find|stat|ls|cat)/.test(normalized))
+        return 'low';
+    return 'medium';
+}
+function permissionRiskDisplayValue(risk) {
+    const label = risk.level === 'high' ? 'HIGH' : risk.level === 'medium' ? 'med' : risk.level;
+    return `${label}: ${risk.reason}`;
+}
+function createPermissionPromptState(request, cwd) {
+    return {
+        requestId: request.id,
+        toolName: request.name,
+        scope: permissionScopeFromArgs(request.args),
+        cwd,
+        risk: {
+            level: permissionRiskLevel(request.name, request.args),
+            reason: request.reason?.trim() || 'approval required',
+        },
+        options: {
+            approve: 'y=yes',
+            deny: 'n=no',
+        },
+    };
+}
+function normalizeVisibleLimit(totalItems, requestedLimit) {
+    const safeRequested = Number.isFinite(requestedLimit) && requestedLimit && requestedLimit > 0
+        ? Math.floor(requestedLimit)
+        : 10;
+    return Math.max(1, Math.min(safeRequested, Math.max(1, totalItems)));
+}
+function maxPickerOffset(totalItems, visibleLimit) {
+    return Math.max(0, Math.ceil(totalItems / visibleLimit) - 1) * visibleLimit;
+}
+function createSessionPickerState(request, visibleStart = 0) {
+    const totalItems = request.sessions.length;
+    const visibleLimit = normalizeVisibleLimit(totalItems, request.maxVisibleItems);
+    const maxOffset = maxPickerOffset(totalItems, visibleLimit);
+    const clampedStart = Math.max(0, Math.min(visibleStart, maxOffset));
+    const visibleSessions = request.sessions.slice(clampedStart, clampedStart + visibleLimit);
+    return {
+        kind: 'session',
+        title: request.title,
+        totalItems,
+        visibleStart: clampedStart,
+        visibleLimit,
+        page: totalItems === 0 ? 1 : Math.floor(clampedStart / visibleLimit) + 1,
+        pageCount: totalItems === 0 ? 1 : Math.ceil(totalItems / visibleLimit),
+        visibleItems: visibleSessions.map((session, index) => ({
+            session,
+            globalIndex: clampedStart + index + 1,
+            sessionId: session.id,
+            shortId: session.id.slice(0, 8),
+            title: sessionPickerTitle(session),
+            messageCount: session.messageCount ?? 0,
+            historySizeBytes: session.historySizeBytes ?? 0,
+            model: session.model,
+            projectPath: session.projectPath,
+            showProject: Boolean(request.showProject),
+        })),
+        hasPreviousPage: clampedStart > 0,
+        hasNextPage: clampedStart < maxOffset,
+    };
+}
+function movePickerPageOffset(state, delta) {
+    const maxOffset = maxPickerOffset(state.totalItems, state.visibleLimit);
+    return Math.max(0, Math.min(state.visibleStart + delta * state.visibleLimit, maxOffset));
+}
+function createStatusSnapshot(input = {}) {
+    const rendererName = typeof input.renderer === 'string' && input.renderer.trim() ? input.renderer : 'terminal';
+    const capabilities = (0, ui_events_1.resolveUiRendererCapabilities)(input.capabilities, rendererName);
+    return {
+        model: input.model,
+        sessionId: input.sessionId,
+        tokens: input.tokens,
+        costUsd: input.costUsd,
+        context: input.context,
+        runningState: input.runningState,
+        permissionMode: input.permissionMode,
+        loop: input.loop,
+        renderer: {
+            name: rendererName,
+            status: rendererStatus(rendererName),
+            capabilities,
+            capabilityLabels: rendererCapabilityLabels(capabilities),
+        },
+    };
+}
+function transcriptEntryToBlock(entry) {
+    const kind = entry.title === 'resume' ? 'resume' : entry.role;
+    return {
+        id: entry.id,
+        kind,
+        role: entry.role,
+        title: entry.title,
+        content: entry.content,
+        errorLayer: entry.errorLayer,
+        toolActivity: entry.toolActivity,
+        restored: entry.title === 'resume' ? true : undefined,
+    };
+}
+function toolActivityBatchLabel(activity) {
+    if (typeof activity.batchCount !== 'number' ||
+        activity.batchCount <= 1 ||
+        typeof activity.batchIndex !== 'number' ||
+        activity.batchIndex < 0 ||
+        activity.batchIndex >= activity.batchCount) {
+        return '';
+    }
+    return `Batch ${activity.batchIndex + 1}/${activity.batchCount} · `;
+}
+function toolActivityFromStarted(event, detail = '') {
+    const command = event.name === 'exec_command' && typeof event.args.command === 'string'
+        ? event.args.command
+        : undefined;
+    return {
+        callId: event.callId,
+        name: event.name,
+        state: 'running',
+        detail: command ? undefined : detail || undefined,
+        command,
+        seq: event.sequence,
+        batchCount: event.batchCount,
+        batchIndex: event.batchIndex,
+    };
+}
+function toolActivityFromFinished(event, detail = '') {
+    return {
+        callId: event.callId,
+        name: event.name,
+        state: event.skipped ? 'skipped' : event.success ? 'success' : 'error',
+        detail: detail || undefined,
+        command: event.name === 'exec_command' && typeof event.args.command === 'string'
+            ? event.args.command
+            : undefined,
+        summary: event.summary,
+        durationMs: event.duration,
+        error: event.error,
+        outputBytes: event.outputBytes,
+        artifactRef: event.artifactRef,
+        seq: event.sequence,
+        batchCount: event.batchCount,
+        batchIndex: event.batchIndex,
+    };
+}
+function formatToolActivityTranscript(activity) {
+    const prefix = toolActivityBatchLabel(activity);
+    const lines = [];
+    const detailLooksTruncated = Boolean(activity.detail?.includes('...'));
+    if (activity.state === 'queued') {
+        lines.push(`${prefix}Queued ${activity.name}${activity.detail ? ` ${activity.detail}` : ''}`);
+    }
+    else if (activity.state === 'running') {
+        lines.push(`${prefix}Running ${activity.name}${activity.detail ? ` ${activity.detail}` : ''}`);
+    }
+    else if (activity.state === 'requested') {
+        lines.push(`${prefix}Requested ${activity.name}${activity.detail ? ` ${activity.detail}` : ''}`);
+    }
+    else if (activity.state === 'skipped') {
+        lines.push(`${prefix}Skipped ${activity.name}${activity.detail ? ` ${activity.detail}` : ''}`);
+    }
+    else {
+        const symbol = activity.state === 'success' ? '✓' : '✗';
+        const suffix = activity.detail ? ` ${activity.detail}` : '';
+        const duration = typeof activity.durationMs === 'number' ? ` (${activity.durationMs}ms)` : '';
+        lines.push(`${prefix}${activity.summary || `${symbol} ${activity.name}${suffix}${duration}`}`);
+    }
+    if (activity.command) {
+        lines.push(`  $ ${activity.command}`);
+    }
+    if (activity.artifactRef) {
+        lines.push(`  Full output: /artifacts show ${activity.artifactRef.id} --full (${(0, format_1.formatBytes)(activity.artifactRef.outputBytes)})`);
+    }
+    else if (typeof activity.outputBytes === 'number') {
+        lines.push(`  output ${(0, format_1.formatBytes)(activity.outputBytes)}`);
+    }
+    if (activity.error) {
+        lines.push(`Error: ${activity.error}`);
+    }
+    if (detailLooksTruncated || activity.artifactRef || activity.error) {
+        lines.push('  Details: /last-tool or /trace latest');
+    }
+    return lines.filter(Boolean).join('\n');
+}
+//# sourceMappingURL=ui-view-model.js.map