@kortix/sdk 0.9.102 → 0.9.104

package/dist/{turns/index.js → core/turns/parts.js}

@@ -1,16 +1,11 @@
 /**
- * Turn grouping & part helpers — framework-agnostic.
+ * Part-level helpers — type guards, attachment splitting, tool-part display
+ * info, and everything else that operates on a single part (or a single
+ * part's tool/path/diagnostics data) rather than a whole turn.
  *
- * Pure functions that transform SDK message data into view-model shapes.
- * Single implementation shared by the web and mobile UIs.
- *
- * IMPORTANT: No React / DOM / framework imports allowed in this module.
- * Matches the SolidJS reference in opencode/packages/ui/src/components/session-turn.tsx
+ * Split out of `turns/index.ts` — see that file's history for the original
+ * single-file version. No React / DOM / framework imports allowed.
  */
-export { unwrapError } from './errors.js';
-export * from './tool-registry.js';
-export * from './classify.js';
-export * from './view-model.js';
 import { unwrapError } from './errors.js';
 // ============================================================================
 // Type guards
@@ -74,168 +69,6 @@ export function splitUserParts(parts) {
     }
     return { attachments, stickyParts };
 }
-// ============================================================================
-// Turn grouping
-// ============================================================================
-/**
- * Group messages into turns: each turn starts with a user message followed
- * by 0+ assistant messages.
- *
- * Uses parentID-based linking (matching SolidJS session-turn.tsx:272-292):
- * assistant messages are associated with their parent user message via
- * `parentID`. Falls back to sequential ordering when parentID is absent.
- */
-export function groupMessagesIntoTurns(messages) {
-    const turns = [];
-    const turnsByUserMsgId = new Map();
-    // First pass: create turns from user messages.
-    // Dedupe by id — a user message can transiently appear twice (e.g. an
-    // optimistic copy + the real one before reconcile finishes, or a hydrate
-    // that races a part.updated event). Two turns with the same userMessage.id
-    // would crash list renderers keyed by it (e.g. FlatList's keyExtractor).
-    for (const msg of messages) {
-        if (msg.info.role === 'user') {
-            if (turnsByUserMsgId.has(msg.info.id))
-                continue;
-            const turn = { userMessage: msg, assistantMessages: [] };
-            turns.push(turn);
-            turnsByUserMsgId.set(msg.info.id, turn);
-        }
-    }
-    // Second pass: link assistant messages via parentID or sequential
-    let lastTurn = null;
-    for (const msg of messages) {
-        if (msg.info.role === 'user') {
-            lastTurn = turnsByUserMsgId.get(msg.info.id) ?? null;
-            continue;
-        }
-        if (msg.info.role !== 'assistant')
-            continue;
-        const assistantMsg = msg.info;
-        // Try parentID-based linking first (matches SolidJS)
-        if (assistantMsg.parentID) {
-            const parentTurn = turnsByUserMsgId.get(assistantMsg.parentID);
-            if (parentTurn) {
-                parentTurn.assistantMessages.push(msg);
-                continue;
-            }
-        }
-        // Fall back to sequential ordering — attach to the most recently seen
-        // user turn in iteration order. This keeps streaming parts that arrive
-        // before their parent metadata in the right turn.
-        if (lastTurn) {
-            lastTurn.assistantMessages.push(msg);
-            continue;
-        }
-        // Orphan assistant message that precedes every user message in the
-        // session (e.g. a session-init failure with no parentID). Attaching to
-        // the LAST turn would surface its error under an unrelated, much later
-        // user prompt. Attach to the FIRST turn instead so it renders at its
-        // real chronological position — or create a synthetic turn if no user
-        // messages exist at all.
-        if (turns.length > 0) {
-            turns[0].assistantMessages.unshift(msg);
-            continue;
-        }
-        const syntheticTurn = { userMessage: msg, assistantMessages: [] };
-        turns.push(syntheticTurn);
-    }
-    return turns;
-}
-// ============================================================================
-// Part collection helpers
-// ============================================================================
-/** Collect all parts from a turn's assistant messages. */
-export function collectTurnParts(turn) {
-    const result = [];
-    for (const msg of turn.assistantMessages) {
-        for (const part of msg.parts) {
-            result.push({ part, message: msg });
-        }
-    }
-    return result;
-}
-/** Find the last non-empty text part in a turn (the "response"). */
-export function findLastTextPart(parts) {
-    for (let i = parts.length - 1; i >= 0; i--) {
-        const p = parts[i].part;
-        if (isTextPart(p) && p.text?.trim()) {
-            return p;
-        }
-    }
-    return undefined;
-}
-/** Check if a turn has tool steps. */
-export function turnHasSteps(parts) {
-    return parts.some(({ part }) => part.type === 'tool' ||
-        part.type === 'compaction' ||
-        part.type === 'snapshot' ||
-        part.type === 'patch');
-}
-// ============================================================================
-// Shell mode detection
-// ============================================================================
-/**
- * Detect "shell mode": user message is entirely synthetic text parts AND
- * there's exactly one assistant message with exactly one part which is a bash tool.
- *
- * Stricter than our previous implementation — matches SolidJS session-turn.tsx:364-379
- * which checks `msgParts.length !== 1` (exactly one assistant part total).
- */
-export function isShellMode(turn) {
-    const userParts = turn.userMessage.parts;
-    if (userParts.length === 0)
-        return false;
-    const allSynthetic = userParts.every((p) => isTextPart(p) && p.synthetic);
-    if (!allSynthetic)
-        return false;
-    if (turn.assistantMessages.length !== 1)
-        return false;
-    const assistantParts = turn.assistantMessages[0].parts;
-    // Strict: exactly 1 part total (not just 1 tool part)
-    if (assistantParts.length !== 1)
-        return false;
-    const part = assistantParts[0];
-    return isToolPart(part) && part.tool === 'bash';
-}
-/** Get the bash tool part when in shell mode. */
-export function getShellModePart(turn) {
-    if (!isShellMode(turn))
-        return undefined;
-    return turn.assistantMessages[0].parts[0];
-}
-// ============================================================================
-// Working state
-// ============================================================================
-/** Check if this is the last user message in the session. */
-export function isLastUserMessage(messageId, allMessages) {
-    for (let i = allMessages.length - 1; i >= 0; i--) {
-        if (allMessages[i].info.role === 'user') {
-            return allMessages[i].info.id === messageId;
-        }
-    }
-    return false;
-}
-/** Derive the "working" state for a turn. Only the last turn shows as working. */
-export function getWorkingState(sessionStatus, isLast) {
-    if (!isLast)
-        return false;
-    if (!sessionStatus)
-        return false;
-    return sessionStatus.type !== 'idle';
-}
-// ============================================================================
-// Response part separation
-// ============================================================================
-/**
- * Whether the last text part (the "response") should be extracted from the
- * steps list and shown separately in the Response section.
- *
- * Matches SolidJS session-turn.tsx:440-443
- */
-export function shouldHideResponsePart(working, responsePartId) {
-    return !working && !!responsePartId;
-}
 /**
  * Get the list of tool parts to hide from the step list.
  * Matches SolidJS session-turn.tsx:332-339
@@ -253,209 +86,11 @@ export function isToolPartHidden(part, messageId, hidden) {
     return hidden.some((h) => h.messageID === messageId && h.callID === part.callID);
 }
 // ============================================================================
-// Answered question parts (shown when collapsed)
-// ============================================================================
-/**
- * Collect answered question parts that should be shown outside of the
- * steps list. Questions are always rendered standalone (never inside steps),
- * so answered questions are shown regardless of stepsExpanded state.
- */
-export function getAnsweredQuestionParts(turn, _stepsExpanded, hasActiveQuestion) {
-    // Active question takes precedence — don't also show old answered ones
-    if (hasActiveQuestion)
-        return [];
-    const result = [];
-    for (const msg of turn.assistantMessages) {
-        for (const part of msg.parts) {
-            if (!isToolPart(part))
-                continue;
-            const tp = part;
-            const answers = tp.state?.metadata?.answers;
-            if (tp.tool === 'question' && (answers?.length ?? 0) > 0) {
-                result.push({ part, message: msg });
-            }
-        }
-    }
-    return result;
-}
-// ============================================================================
-// Error extraction — with deep JSON unwrapping
-// ============================================================================
-/** Extract error message from assistant messages in a turn. */
-export function getTurnError(turn) {
-    for (const msg of turn.assistantMessages) {
-        const info = msg.info;
-        if (info.error) {
-            return unwrapError(info.error);
-        }
-    }
-    return undefined;
-}
-// ============================================================================
-// Status text computation
-// ============================================================================
-/**
- * Derive human-readable status from a part.
- * Matches SolidJS computeStatusFromPart — session-turn.tsx:83-119
- */
-export function computeStatusFromPart(part) {
-    if (!part)
-        return undefined;
-    if (isToolPart(part)) {
-        switch (part.tool) {
-            case 'task':
-            case 'session_spawn':
-            case 'session_start_background':
-            case 'session-spawn':
-            case 'session-start-background':
-                return 'Delegating to agent...';
-            case 'agent_spawn':
-            case 'agent-spawn':
-            case 'agent_task':
-            case 'agent-task':
-                return 'Delegating to agent...';
-            case 'agent_task_update':
-            case 'agent-task-update':
-            case 'task_update':
-            case 'task-update':
-                return 'Updating task...';
-            case 'agent_message':
-            case 'agent-message':
-            case 'agent_task_message':
-            case 'agent-task-message':
-            case 'task_message':
-            case 'task-message':
-                return 'Messaging agent...';
-            case 'task_create':
-            case 'task-create':
-            case 'task_start':
-            case 'task-start':
-                return 'Creating task...';
-            case 'task_list':
-            case 'task-list':
-                return 'Listing tasks...';
-            case 'task_done':
-            case 'task-done':
-                return 'Updating task...';
-            case 'todowrite':
-            case 'todoread':
-                return 'Planning...';
-            case 'read':
-                return 'Gathering context...';
-            case 'list':
-            case 'grep':
-            case 'glob':
-                return 'Searching codebase...';
-            case 'webfetch':
-            case 'scrape-webpage':
-                return 'Fetching web page...';
-            case 'websearch':
-            case 'web-search':
-            case 'web_search':
-                return 'Searching web...';
-            case 'image-search':
-                return 'Searching images...';
-            case 'image-gen':
-                return 'Generating image...';
-            case 'video-gen':
-                return 'Generating video...';
-            case 'presentation-gen':
-                return 'Creating presentation...';
-            case 'show':
-            case 'show-user':
-                return 'Showing output...';
-            case 'edit':
-            case 'write':
-            case 'morph_edit':
-                return 'Making edits...';
-            case 'bash':
-                return 'Running commands...';
-            case 'apply_patch':
-                return 'Applying patches...';
-            case 'prune':
-                return 'Pruning context...';
-            case 'distill':
-                return 'Distilling context...';
-            case 'compress':
-                return 'Compressing context...';
-            case 'context_info':
-                return 'Updating context info...';
-            default:
-                return `Running ${part.tool}...`;
-        }
-    }
-    if (isReasoningPart(part)) {
-        const text = part.text?.trimStart();
-        if (text) {
-            const match = text.match(/^\*\*(.+?)\*\*/);
-            if (match)
-                return `Thinking about ${match[1].trim()}...`;
-        }
-        return 'Thinking...';
-    }
-    if (isTextPart(part))
-        return 'Gathering thoughts...';
-    return undefined;
-}
-/**
- * Get status text for a turn, with child session delegation.
- *
- * Matches SolidJS rawStatus — session-turn.tsx:381-428
- * When the last part is a running `task` tool, drills into the child session
- * to derive the real status.
- */
-export function getTurnStatus(parts, childMessages) {
-    // Scan parts in reverse for the last meaningful status
-    for (let i = parts.length - 1; i >= 0; i--) {
-        const p = parts[i].part;
-        // If it's a running task orchestration tool, try to get status from child session
-        const tp = isToolPart(p) ? p : undefined;
-        if (tp &&
-            (tp.tool === 'task' ||
-                tp.tool === 'agent_task' ||
-                tp.tool === 'agent-task' ||
-                tp.tool === 'task_create' ||
-                tp.tool === 'task-create' ||
-                tp.tool === 'task_start' ||
-                tp.tool === 'task-start') &&
-            tp.state.status === 'running' &&
-            childMessages &&
-            childMessages.length > 0) {
-            // Walk child session messages in reverse to find status
-            for (let mi = childMessages.length - 1; mi >= 0; mi--) {
-                const childMsg = childMessages[mi];
-                if (childMsg.info.role !== 'assistant')
-                    continue;
-                for (let pi = childMsg.parts.length - 1; pi >= 0; pi--) {
-                    const childStatus = computeStatusFromPart(childMsg.parts[pi]);
-                    if (childStatus)
-                        return childStatus;
-                }
-            }
-            // Fall through to parent status
-            return 'Delegating to agent...';
-        }
-        const s = computeStatusFromPart(p);
-        if (s)
-            return s;
-    }
-    return 'Considering next steps...';
-}
-// ============================================================================
-// Duration formatting
+// Tool part filtering
 // ============================================================================
-export function formatDuration(ms) {
-    // Sub-second durations are noise — skip the badge entirely. Callers
-    // should conditionally render based on whether the returned string is
-    // non-empty, so nothing visible changes when a tool returns in 200ms.
-    if (!Number.isFinite(ms) || ms < 1000)
-        return '';
-    const seconds = Math.floor(ms / 1000);
-    if (seconds < 60)
-        return `${seconds}s`;
-    const minutes = Math.floor(seconds / 60);
-    const secs = seconds % 60;
-    return secs > 0 ? `${minutes}m ${secs}s` : `${minutes}m`;
+const HIDDEN_TOOLS = new Set(['todoread', 'context_info']);
+export function shouldShowToolPart(part) {
+    return !HIDDEN_TOOLS.has(part.tool);
 }
 // ============================================================================
 // Child session helpers
@@ -559,13 +194,6 @@ export function getChildSessionToolParts(childMessages) {
     return result;
 }
 // ============================================================================
-// Tool part filtering
-// ============================================================================
-const HIDDEN_TOOLS = new Set(['todoread', 'context_info']);
-export function shouldShowToolPart(part) {
-    return !HIDDEN_TOOLS.has(part.tool);
-}
-// ============================================================================
 // Tool info (icon + title + subtitle)
 // ============================================================================
 /**
@@ -971,199 +599,6 @@ export function getQuestionForTool(questions, callID) {
     return questions.find((q) => q.tool?.callID === callID);
 }
 // ============================================================================
-// Cost & Token helpers
-// ============================================================================
-/**
- * Platform markup applied to raw provider costs.
- *
- * The step-finish parts report raw provider cost (what the LLM vendor charges).
- * The billing system deducts cost × COST_MARKUP from the user's credits.
- * We apply the same multiplier here so the UI matches what's actually billed.
- *
- * Must stay in sync with KORTIX_MARKUP in apps/api/src/config.ts.
- */
-export const COST_MARKUP = 1.2;
-function estimateTokenCost(tokens, rates) {
-    if (!tokens)
-        return 0;
-    const input = tokens.input ?? 0;
-    const output = (tokens.output ?? 0) + (tokens.reasoning ?? 0);
-    const cacheRead = tokens.cache?.read ?? 0;
-    const cacheWrite = tokens.cache?.write ?? 0;
-    const regularInput = Math.max(0, input - cacheRead - cacheWrite);
-    let cost = (regularInput / 1_000_000) * rates.inputPer1M;
-    cost += (output / 1_000_000) * rates.outputPer1M;
-    if (cacheRead > 0) {
-        cost += (cacheRead / 1_000_000) * (rates.cacheReadPer1M ?? rates.inputPer1M);
-    }
-    if (cacheWrite > 0) {
-        cost += (cacheWrite / 1_000_000) * rates.inputPer1M;
-    }
-    return cost;
-}
-function stepFinishRawCost(sfp, providerID, modelID, lookup) {
-    const reported = sfp.cost || 0;
-    if (reported > 0)
-        return reported;
-    if (!lookup || !providerID || !modelID)
-        return 0;
-    const rates = lookup(providerID, modelID);
-    if (!rates)
-        return 0;
-    return estimateTokenCost(sfp.tokens, rates);
-}
-function assistantMessageIds(message) {
-    if (message.role !== 'assistant')
-        return {};
-    const assistant = message;
-    return { providerID: assistant.providerID, modelID: assistant.modelID };
-}
-/**
- * Aggregate cost/token info from step-finish parts in a turn.
- * Returns undefined if no step-finish parts found.
- *
- * The cost is multiplied by COST_MARKUP so the displayed value matches
- * the actual credits deducted (raw provider cost × 1.2).
- */
-export function getTurnCost(parts, lookup) {
-    let totalCost = 0;
-    let input = 0;
-    let output = 0;
-    let reasoning = 0;
-    let cacheRead = 0;
-    let cacheWrite = 0;
-    let found = false;
-    for (const { part, message } of parts) {
-        if (part.type === 'step-finish') {
-            found = true;
-            const sfp = part;
-            const { providerID, modelID } = assistantMessageIds(message.info);
-            totalCost += stepFinishRawCost(sfp, providerID, modelID, lookup);
-            input += sfp.tokens?.input || 0;
-            output += sfp.tokens?.output || 0;
-            reasoning += sfp.tokens?.reasoning || 0;
-            cacheRead += sfp.tokens?.cache?.read || 0;
-            cacheWrite += sfp.tokens?.cache?.write || 0;
-        }
-    }
-    if (!found) {
-        for (const { message } of parts) {
-            if (message.info.role !== 'assistant')
-                continue;
-            const assistant = message.info;
-            const stepCost = assistantTokensCost(assistant, lookup);
-            if (stepCost <= 0)
-                continue;
-            found = true;
-            totalCost += stepCost;
-            const t = assistant.tokens;
-            if (t) {
-                input += t.input ?? 0;
-                output += t.output ?? 0;
-                reasoning += t.reasoning ?? 0;
-                cacheRead += t.cache?.read ?? 0;
-                cacheWrite += t.cache?.write ?? 0;
-            }
-        }
-    }
-    if (!found)
-        return undefined;
-    return {
-        cost: totalCost * COST_MARKUP,
-        tokens: { input, output, reasoning, cacheRead, cacheWrite },
-    };
-}
-function assistantTokensCost(assistant, lookup) {
-    if (!lookup || !assistant.providerID || !assistant.modelID || !assistant.tokens)
-        return 0;
-    const rates = lookup(assistant.providerID, assistant.modelID);
-    if (!rates)
-        return 0;
-    return estimateTokenCost({
-        input: assistant.tokens.input,
-        output: assistant.tokens.output,
-        reasoning: assistant.tokens.reasoning,
-        cache: assistant.tokens.cache,
-    }, rates);
-}
-/**
- * Aggregate billed cost for an entire session from step-finish parts.
- * Matches per-turn `getTurnCost` and mobile session stats aggregation.
- */
-export function getSessionCost(messages, lookup) {
-    let totalCost = 0;
-    for (const msg of messages) {
-        if (msg.info?.role !== 'assistant')
-            continue;
-        const assistant = msg.info;
-        const { providerID, modelID } = assistantMessageIds(assistant);
-        let msgCost = 0;
-        let sawStepFinish = false;
-        for (const part of msg.parts) {
-            if (part.type !== 'step-finish')
-                continue;
-            sawStepFinish = true;
-            msgCost += stepFinishRawCost(part, providerID, modelID, lookup);
-        }
-        if (!sawStepFinish) {
-            msgCost += assistantTokensCost(assistant, lookup);
-        }
-        totalCost += msgCost;
-    }
-    return totalCost * COST_MARKUP;
-}
-/** Format cost in USD (e.g. "$0.0032") */
-export function formatCost(cost) {
-    if (cost === 0)
-        return '$0.00';
-    if (cost < 0.001)
-        return `$${cost.toFixed(4)}`;
-    if (cost < 0.01)
-        return `$${cost.toFixed(3)}`;
-    return `$${cost.toFixed(2)}`;
-}
-/** Format token count (e.g. "12.3k") */
-export function formatTokens(tokens) {
-    if (tokens < 1000)
-        return String(tokens);
-    if (tokens < 10000)
-        return `${(tokens / 1000).toFixed(1)}k`;
-    return `${Math.round(tokens / 1000)}k`;
-}
-// ============================================================================
-// Retry helpers
-// ============================================================================
-/**
- * Extract retry info from session status.
- * Truncates message to 60 chars matching SolidJS session-turn.tsx:695
- */
-export function getRetryInfo(status) {
-    if (!status || status.type !== 'retry')
-        return undefined;
-    const retry = status;
-    return {
-        attempt: retry.attempt,
-        message: retry.message.length > 60 ? `${retry.message.slice(0, 60)}...` : retry.message,
-        next: retry.next,
-    };
-}
-/**
- * Extract the full retry error message from session status (not truncated).
- */
-export function getRetryMessage(status) {
-    if (!status || status.type !== 'retry')
-        return undefined;
-    return unwrapError(status.message);
-}
-// ============================================================================
-// hasDiffs check
-// ============================================================================
-/** Check if a user message has associated file diffs. */
-export function hasDiffs(userMessage) {
-    const summary = userMessage.info.summary;
-    return (summary?.diffs?.length ?? 0) > 0;
-}
-// ============================================================================
 // ANSI strip (used by bash tool renderer)
 // ============================================================================
 // OSC payloads (window titles, OSC-8 hyperlink URLs) are never more than a
@@ -1179,65 +614,4 @@ export function stripAnsi(str) {
         return '';
     return str.replace(ANSI_RE, '');
 }
-// ============================================================================
-// Session list helpers (sidebar / tabs)
-// ============================================================================
-/**
- * Build a map from parent session ID → array of child session IDs.
- * Used to aggregate child session status (permissions, busy) in the sidebar.
- * Matches SolidJS reference `childMapByParent()` in helpers.ts.
- */
-export function childMapByParent(sessions) {
-    const map = new Map();
-    for (const session of sessions) {
-        if (!session.parentID)
-            continue;
-        const existing = map.get(session.parentID);
-        if (existing) {
-            existing.push(session.id);
-        }
-        else {
-            map.set(session.parentID, [session.id]);
-        }
-    }
-    return map;
-}
-/**
- * Sort comparator for sessions.
- * Two tiers:
- *  1. Sessions updated within `now - 60s` are pinned to top, sorted by ID (stable).
- *  2. Older sessions sorted by `updated` time descending.
- * Matches SolidJS reference `sortSessions()` in helpers.ts.
- */
-export function sortSessions(now) {
-    const oneMinuteAgo = now - 60 * 1000;
-    return (a, b) => {
-        const aUpdated = a.time.updated ?? a.time.created;
-        const bUpdated = b.time.updated ?? b.time.created;
-        const aRecent = aUpdated > oneMinuteAgo;
-        const bRecent = bUpdated > oneMinuteAgo;
-        if (aRecent && bRecent)
-            return a.id < b.id ? -1 : a.id > b.id ? 1 : 0;
-        if (aRecent && !bRecent)
-            return -1;
-        if (!aRecent && bRecent)
-            return 1;
-        return bUpdated - aUpdated;
-    };
-}
-/**
- * Recursively collect ALL descendant session IDs for a given parent.
- * Walks the full tree so deeply nested sub-agents are included.
- */
-export function allDescendantIds(childMap, sessionId) {
-    const directChildren = childMap.get(sessionId);
-    if (!directChildren || directChildren.length === 0)
-        return [];
-    const result = [];
-    for (const childId of directChildren) {
-        result.push(childId);
-        result.push(...allDescendantIds(childMap, childId));
-    }
-    return result;
-}
-//# sourceMappingURL=index.js.map
+//# sourceMappingURL=parts.js.map