entasis 0.11.0 → 0.12.0

package/dist/components/AITool/toolRendering.js

@@ -1,20 +1,54 @@
-const activeStatuses = new Set(['pending', 'loading', 'running', 'streaming']);
+// Statuses that show a spinner. Approval requests and denials have no output yet but are not
+// running: they wait on, or were stopped by, the user, so they must never spin.
+const activeStatuses = new Set([
+    'pending',
+    'loading',
+    'running',
+    'streaming',
+    'approval-responded'
+]);
+/**
+ * Maps an AI SDK UI tool part `state` onto an AITool status. Unknown states return `undefined`
+ * so callers can fall back to inference from output and errors.
+ */
+export function getAIToolStatusFromState(state) {
+    switch (state) {
+        case 'input-streaming':
+            return 'streaming';
+        case 'input-available':
+            return 'running';
+        case 'approval-requested':
+            return 'approval-requested';
+        case 'approval-responded':
+            return 'approval-responded';
+        case 'output-available':
+            return 'success';
+        case 'output-error':
+            return 'error';
+        case 'output-denied':
+            return 'output-denied';
+        default:
+            return undefined;
+    }
+}
 export function resolveAIToolStatus(tool) {
+    // A responded approval that was declined is a denial, whatever state the stream reports.
+    if (tool.approval?.approved === false && !hasOutcome(tool))
+        return 'output-denied';
     if (tool.status)
         return tool.status;
     if (tool.error !== undefined || isErrorResult(tool.result))
         return 'error';
-    if (tool.output !== undefined ||
-        tool.structuredContent !== undefined ||
-        tool.result !== undefined) {
+    if (hasOutcome(tool))
         return 'success';
-    }
     return 'pending';
 }
 export function resolveAIToolGroupStatus(tools) {
     const statuses = tools.map(resolveAIToolStatus);
     return (statuses.find((status) => status === 'error') ??
+        statuses.find((status) => status === 'approval-requested') ??
         statuses.find(isActiveAIToolStatus) ??
+        statuses.find((status) => status === 'output-denied') ??
         statuses.find((status) => status === 'cancelled') ??
         (statuses.every((status) => status === 'success') ? 'success' : statuses[0]) ??
         'pending');
@@ -22,21 +56,48 @@ export function resolveAIToolGroupStatus(tools) {
 export function isActiveAIToolStatus(status) {
     return activeStatuses.has(status);
 }
+/** Readable fallback for app-defined statuses: `needs-review` → "Needs review". */
 export function formatAIToolStatus(status) {
-    return status
-        .split(/[-_\s]+/)
-        .filter(Boolean)
-        .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
-        .join(' ');
+    const words = status.split(/[-_\s]+/).filter(Boolean);
+    return capitalize(words.join(' ').toLowerCase());
+}
+/** Localized word for a built-in status; app-defined statuses fall back to their readable form. */
+export function getAIToolStatusLabel(status, t) {
+    switch (status) {
+        case 'pending':
+            return t.aiToolStatusPending;
+        case 'loading':
+        case 'running':
+            return t.aiToolStatusRunning;
+        case 'streaming':
+            return t.aiToolStatusStreaming;
+        case 'success':
+            return t.aiToolStatusSuccess;
+        case 'error':
+            return t.aiToolStatusError;
+        case 'cancelled':
+            return t.aiToolStatusCancelled;
+        case 'approval-requested':
+            return t.aiToolStatusAwaitingApproval;
+        case 'approval-responded':
+            return t.aiToolStatusApproved;
+        case 'output-denied':
+            return t.aiToolStatusDenied;
+        default:
+            return formatAIToolStatus(status);
+    }
 }
 export function getAIToolStatusColor(status) {
-    if (status === 'success')
+    const tone = getAIToolStatusTone(status);
+    if (tone === 'success')
         return 'success';
-    if (status === 'error')
+    if (tone === 'error')
         return 'danger';
-    if (status === 'cancelled')
-        return 'neutral';
-    return 'info';
+    if (tone === 'awaiting')
+        return 'warning';
+    if (tone === 'active')
+        return 'info';
+    return 'neutral';
 }
 export function getAIToolStatusTone(status) {
     if (status === 'success')
@@ -45,6 +106,10 @@ export function getAIToolStatusTone(status) {
         return 'error';
     if (status === 'cancelled')
         return 'cancelled';
+    if (status === 'approval-requested')
+        return 'awaiting';
+    if (status === 'output-denied')
+        return 'denied';
     if (isActiveAIToolStatus(status))
         return 'active';
     return 'default';
@@ -71,6 +136,105 @@ export function getAIToolGroupValue(tools) {
     const firstTool = tools[0];
     return firstTool ? getAIToolValue(firstTool, 0) : 'tools';
 }
+/**
+ * Readable tool title. An explicit `title` wins unless it only repeats the raw `name`, which is
+ * humanized: `searchDocs` → "Search docs", `analyze_release` → "Analyze release",
+ * `mcp__github__list_issues` → "List issues".
+ */
+export function getAIToolTitle(tool, fallback) {
+    if (tool.title && tool.title !== tool.name)
+        return tool.title;
+    const name = tool.name ?? tool.title;
+    return name ? humanizeAIToolName(name) || name : fallback;
+}
+export function humanizeAIToolName(name) {
+    // MCP-style names namespace the tool behind `__`; the last segment is the tool itself.
+    const segments = name.split('__').filter(Boolean);
+    const base = segments[segments.length - 1] ?? name;
+    const words = base
+        .replace(/([a-z\d])([A-Z])/g, '$1 $2')
+        .replace(/([A-Z]+)([A-Z][a-z])/g, '$1 $2')
+        .split(/[\s_\-.:/]+/)
+        .filter(Boolean)
+        .map((word) => (/^[A-Z\d]+$/.test(word) && word.length > 1 ? word : word.toLowerCase()));
+    return capitalize(words.join(' '));
+}
+const SUMMARY_MAX_LENGTH = 80;
+/**
+ * One-line summary of a call's input: an explicit `summary` wins (an empty string hides it),
+ * otherwise the first primitive input value. Strings are quoted so `"3"` differs from `3`.
+ */
+export function getAIToolSummary(tool) {
+    if (tool.summary !== undefined)
+        return tool.summary || undefined;
+    const value = firstPrimitive(tool.input, 0);
+    if (value === undefined)
+        return undefined;
+    const text = typeof value === 'string' ? `"${singleLine(value)}"` : String(value);
+    return text.length > SUMMARY_MAX_LENGTH ? `${text.slice(0, SUMMARY_MAX_LENGTH - 1)}…` : text;
+}
+function firstPrimitive(value, depth) {
+    if (typeof value === 'string')
+        return value.trim() ? value : undefined;
+    if (typeof value === 'number' || typeof value === 'boolean')
+        return value;
+    if (typeof value === 'bigint')
+        return Number(value);
+    if (!value || typeof value !== 'object' || depth > 2)
+        return undefined;
+    const entries = Array.isArray(value) ? value : Object.values(value);
+    for (const entry of entries.slice(0, 8)) {
+        const found = firstPrimitive(entry, depth + 1);
+        if (found !== undefined)
+            return found;
+    }
+    return undefined;
+}
+function singleLine(value) {
+    return value.replace(/\s+/g, ' ').trim();
+}
+function capitalize(value) {
+    return value.charAt(0).toUpperCase() + value.slice(1);
+}
+/** Group header text: "Search docs · 2 calls", or the distinct tool titles when they differ. */
+export function getAIToolGroupSummary(tools, fallbackTitle, t) {
+    const titles = [...new Set(tools.map((tool) => getAIToolTitle(tool, fallbackTitle)))];
+    const shown = titles.slice(0, 2).join(', ');
+    const label = titles.length > 2 ? `${shown} ${t.aiToolMoreTools(titles.length - 2)}` : shown;
+    return t.aiToolGroupSummary(label, tools.length);
+}
+function toMilliseconds(value) {
+    if (value === undefined)
+        return undefined;
+    const time = value instanceof Date ? value.getTime() : new Date(value).getTime();
+    return Number.isFinite(time) ? time : undefined;
+}
+/** Reads the call's own timing fields as epoch milliseconds and a duration in milliseconds. */
+export function getAIToolTiming(tool) {
+    const startedAt = toMilliseconds(tool.startedAt);
+    const completedAt = toMilliseconds(tool.completedAt);
+    const duration = typeof tool.duration === 'number' && Number.isFinite(tool.duration)
+        ? Math.max(0, tool.duration)
+        : startedAt !== undefined && completedAt !== undefined
+            ? Math.max(0, completedAt - startedAt)
+            : undefined;
+    return { startedAt, completedAt, duration };
+}
+/** Compact elapsed time: "<1s", "6s", "1m 12s", "1h 4m". */
+export function formatAIElapsed(milliseconds, t) {
+    const totalSeconds = Math.floor(Math.max(0, milliseconds) / 1000);
+    if (totalSeconds < 1)
+        return t.aiElapsedUnderSecond;
+    if (totalSeconds < 60)
+        return t.aiElapsedSeconds(totalSeconds);
+    const totalMinutes = Math.floor(totalSeconds / 60);
+    if (totalMinutes < 60)
+        return t.aiElapsedMinutes(totalMinutes, totalSeconds % 60);
+    return t.aiElapsedHours(Math.floor(totalMinutes / 60), totalMinutes % 60);
+}
+function hasOutcome(tool) {
+    return (tool.output !== undefined || tool.structuredContent !== undefined || tool.result !== undefined);
+}
 function getAIToolValue(tool, index) {
     return String(tool.id ?? index);
 }

package/dist/components/AITool/toolValueTree.d.ts

@@ -1,5 +1,7 @@
+import { type Messages } from '../../i18n/en.js';
 export type AIToolValueTreeNode = {
     kind: 'branch';
+    /** Object key, or `''` for array items and the root (no key is shown). */
     key: string;
     valueKind: 'object' | 'array';
     summary: string;
@@ -10,4 +12,15 @@ export type AIToolValueTreeNode = {
     value: string;
     valueKind: 'string' | 'number' | 'boolean' | 'null' | 'undefined' | 'empty' | 'unknown';
 };
-export declare function buildToolValueTree(value: unknown, maxDepth?: number, maxEntries?: number): AIToolValueTreeNode[];
+/** Words the value renderers need, read from the i18n catalog. */
+export type AIToolValueMessages = Pick<Messages, 'aiToolValueItems' | 'aiToolValueKeys' | 'aiToolValueMore' | 'aiToolValueEmptyArray' | 'aiToolValueEmptyObject' | 'aiToolValueCircular' | 'aiToolValueMaxDepth' | 'aiToolValueInvalidDate' | 'aiToolValueUnreadable'>;
+export declare function buildToolValueTree(value: unknown, maxDepth?: number, maxEntries?: number, t?: AIToolValueMessages): AIToolValueTreeNode[];
+/** Counts rendered rows so a long tree can collapse behind "Show all". */
+export declare function countToolValueTreeRows(nodes: readonly AIToolValueTreeNode[]): number;
+/**
+ * A JSON-safe copy of an arbitrary tool value, bounded like the tree: circular references, depth
+ * and entry limits become readable markers, Dates become ISO strings, Errors become their message.
+ */
+export declare function toToolJsonValue(value: unknown, maxDepth?: number, maxEntries?: number, t?: AIToolValueMessages): unknown;
+/** Plain sentence for an error value, or `undefined` when it needs the structured view. */
+export declare function getToolErrorSentence(value: unknown): string | undefined;

package/dist/components/AITool/toolValueTree.js

@@ -1,59 +1,154 @@
+import { en } from '../../i18n/en.js';
 const DEFAULT_MAX_DEPTH = 8;
 const DEFAULT_MAX_ENTRIES = 80;
-export function buildToolValueTree(value, maxDepth = DEFAULT_MAX_DEPTH, maxEntries = DEFAULT_MAX_ENTRIES) {
-    const tree = buildNode('', value, new WeakSet(), 0, normalizeLimit(maxDepth, DEFAULT_MAX_DEPTH), normalizeLimit(maxEntries, DEFAULT_MAX_ENTRIES));
+function limits(maxDepth, maxEntries, t) {
+    return {
+        maxDepth: normalizeLimit(maxDepth, DEFAULT_MAX_DEPTH),
+        maxEntries: normalizeLimit(maxEntries, DEFAULT_MAX_ENTRIES),
+        t
+    };
+}
+export function buildToolValueTree(value, maxDepth = DEFAULT_MAX_DEPTH, maxEntries = DEFAULT_MAX_ENTRIES, t = en) {
+    const tree = buildNode('', value, new WeakSet(), 0, limits(maxDepth, maxEntries, t));
     return tree.kind === 'branch' && tree.key === '' ? tree.children : [tree];
 }
-function buildNode(key, value, seen, depth, maxDepth, maxEntries) {
+/** Counts rendered rows so a long tree can collapse behind "Show all". */
+export function countToolValueTreeRows(nodes) {
+    return nodes.reduce((count, node) => count + 1 + (node.kind === 'branch' ? countToolValueTreeRows(node.children) : 0), 0);
+}
+function buildNode(key, value, seen, depth, options) {
+    const { t } = options;
     if (value === null || typeof value !== 'object')
         return leafNode(key, value);
     if (value instanceof Date) {
-        return leafNode(key, Number.isNaN(value.getTime()) ? 'Invalid Date' : value.toISOString());
+        return Number.isNaN(value.getTime())
+            ? leafNode(key, t.aiToolValueInvalidDate, 'unknown')
+            : leafNode(key, value.toISOString(), 'unknown');
     }
     if (value instanceof Error)
-        return leafNode(key, `${value.name}: ${value.message}`);
-    if (depth >= maxDepth)
-        return leafNode(key, 'Max depth reached', 'unknown');
+        return leafNode(key, errorText(value), 'unknown');
+    if (depth >= options.maxDepth)
+        return leafNode(key, t.aiToolValueMaxDepth, 'unknown');
     if (seen.has(value))
-        return leafNode(key, 'Circular reference', 'unknown');
+        return leafNode(key, t.aiToolValueCircular, 'unknown');
     seen.add(value);
     const node = Array.isArray(value)
-        ? arrayNode(key, value, seen, depth, maxDepth, maxEntries)
-        : objectNode(key, value, seen, depth, maxDepth, maxEntries);
+        ? arrayNode(key, value, seen, depth, options)
+        : objectNode(key, value, seen, depth, options);
     seen.delete(value);
     return node;
 }
-function arrayNode(key, value, seen, depth, maxDepth, maxEntries) {
+function arrayNode(key, value, seen, depth, options) {
+    const { t, maxEntries } = options;
+    // Array items carry no key: their position is already the row order, and `[0]` keys were noise.
     const children = value
         .slice(0, maxEntries)
-        .map((entry, index) => buildNode(`[${index}]`, entry, seen, depth + 1, maxDepth, maxEntries));
+        .map((entry) => buildNode('', entry, seen, depth + 1, options));
     if (value.length > maxEntries) {
-        children.push(leafNode('...', `${value.length - maxEntries} more`, 'unknown'));
+        children.push(leafNode('', t.aiToolValueMore(value.length - maxEntries), 'empty'));
     }
+    if (value.length === 0)
+        return leafNode(key, t.aiToolValueEmptyArray, 'empty');
     return {
         kind: 'branch',
         key,
         valueKind: 'array',
-        summary: value.length === 0 ? 'Empty array' : `${value.length} items`,
+        summary: t.aiToolValueItems(value.length),
         children
     };
 }
-function objectNode(key, value, seen, depth, maxDepth, maxEntries) {
+function objectNode(key, value, seen, depth, options) {
+    const { t, maxEntries } = options;
     const { keys, hasMore } = collectEnumerableKeys(value, maxEntries);
     if (keys.length === 0)
-        return leafNode(key, objectLabel(value), 'empty');
-    const children = keys.map((entryKey) => buildNode(entryKey, readProperty(value, entryKey), seen, depth + 1, maxDepth, maxEntries));
-    if (hasMore) {
-        children.push(leafNode('...', 'More entries', 'unknown'));
-    }
+        return leafNode(key, objectLabel(value, t), 'empty');
+    const children = keys.map((entryKey) => buildNode(entryKey, readProperty(value, entryKey, t), seen, depth + 1, options));
+    if (hasMore)
+        children.push(leafNode('', `…`, 'empty'));
     return {
         kind: 'branch',
         key,
         valueKind: 'object',
-        summary: hasMore ? `${maxEntries}+ keys` : `${keys.length} keys`,
+        summary: hasMore ? t.aiToolValueKeys(`${maxEntries}+`) : t.aiToolValueKeys(keys.length),
         children
     };
 }
+/**
+ * A JSON-safe copy of an arbitrary tool value, bounded like the tree: circular references, depth
+ * and entry limits become readable markers, Dates become ISO strings, Errors become their message.
+ */
+export function toToolJsonValue(value, maxDepth = DEFAULT_MAX_DEPTH, maxEntries = DEFAULT_MAX_ENTRIES, t = en) {
+    return jsonNode(value, new WeakSet(), 0, limits(maxDepth, maxEntries, t));
+}
+function jsonNode(value, seen, depth, options) {
+    const { t, maxEntries } = options;
+    if (value === undefined)
+        return null;
+    if (typeof value === 'bigint')
+        return value.toString();
+    if (typeof value === 'number')
+        return Number.isFinite(value) ? value : String(value);
+    if (typeof value === 'symbol' || typeof value === 'function')
+        return formatValue(value);
+    if (value === null || typeof value !== 'object')
+        return value;
+    if (value instanceof Date) {
+        return Number.isNaN(value.getTime()) ? t.aiToolValueInvalidDate : value.toISOString();
+    }
+    if (value instanceof Error)
+        return errorText(value);
+    if (depth >= options.maxDepth)
+        return `[${t.aiToolValueMaxDepth}]`;
+    if (seen.has(value))
+        return `[${t.aiToolValueCircular}]`;
+    seen.add(value);
+    let result;
+    if (Array.isArray(value)) {
+        const items = value
+            .slice(0, maxEntries)
+            .map((entry) => jsonNode(entry, seen, depth + 1, options));
+        if (value.length > maxEntries)
+            items.push(`… ${t.aiToolValueMore(value.length - maxEntries)}`);
+        result = items;
+    }
+    else {
+        const { keys, hasMore } = collectEnumerableKeys(value, maxEntries);
+        const record = {};
+        for (const key of keys) {
+            record[key] = jsonNode(readProperty(value, key, t), seen, depth + 1, options);
+        }
+        if (hasMore)
+            record['…'] = '…';
+        result = record;
+    }
+    seen.delete(value);
+    return result;
+}
+/** Plain sentence for an error value, or `undefined` when it needs the structured view. */
+export function getToolErrorSentence(value) {
+    if (typeof value === 'string')
+        return value;
+    if (value instanceof Error)
+        return value.message || value.name;
+    if (value === null || typeof value !== 'object')
+        return formatValue(value);
+    // MCP results flag errors with `isError` and carry the text in `content[].text`.
+    const content = value.content;
+    if (Array.isArray(content)) {
+        const texts = content
+            .map((part) => part && typeof part === 'object' ? part.text : undefined)
+            .filter((text) => typeof text === 'string' && text.length > 0);
+        if (texts.length > 0 && texts.length === content.length)
+            return texts.join('\n');
+    }
+    const message = value.message;
+    if (typeof message === 'string' && Object.keys(value).length <= 2)
+        return message;
+    return undefined;
+}
+function errorText(value) {
+    return value.message ? `${value.name}: ${value.message}` : value.name;
+}
 function collectEnumerableKeys(value, maxEntries) {
     const keys = [];
     for (const key in value) {
@@ -65,16 +160,20 @@ function collectEnumerableKeys(value, maxEntries) {
     }
     return { keys, hasMore: false };
 }
-function readProperty(value, key) {
+function readProperty(value, key, t) {
     try {
         return Reflect.get(value, key);
     }
-    catch (error) {
-        return error instanceof Error ? error : new Error('Unable to read property.');
+    catch {
+        return new Error(t.aiToolValueUnreadable);
     }
 }
 function leafNode(key, value, valueKind = primitiveKind(value)) {
-    return { kind: 'leaf', key, value: formatValue(value), valueKind };
+    // Strings are quoted so the string "3" reads differently from the number 3.
+    const text = typeof value === 'string' && valueKind === 'string'
+        ? JSON.stringify(value)
+        : formatValue(value);
+    return { kind: 'leaf', key, value: text, valueKind };
 }
 function primitiveKind(value) {
     if (value === null)
@@ -101,10 +200,10 @@ function formatValue(value) {
         return value.name ? `Function ${value.name}` : 'Function';
     return String(value);
 }
-function objectLabel(value) {
+function objectLabel(value, t) {
     const name = value.constructor?.name;
     if (!name || name === 'Object')
-        return 'Empty object';
+        return t.aiToolValueEmptyObject;
     return name;
 }
 function normalizeLimit(value, fallback) {