@kortix/ui 0.0.0-stage → 0.14.4

package/dist/session/tool/tools/codemode-tool.js

@@ -0,0 +1,106 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { HighlightedCode } from '../../../markdown/code/index.js';
+import { CopyButton } from '../../../markdown/copy-button.js';
+import Loading from '../../../primitives/loading.js';
+import { TextShimmer } from '../../../primitives/text-shimmer.js';
+import { BasicTool, partError, partInput, partMetadata, partOutput, partStatus, ToolRunningContext, useToolCardFrame, useToolCardPad, useToolIndent, useToolOpen, } from '../shared/infrastructure.js';
+import { ToolRegistry } from '../shared/registry.js';
+import { useTranslations } from '../../../i18n/index.js';
+import { cn } from '../../../lib/utils.js';
+import { getToolPrimaryArg } from '@kortix/sdk';
+import { CheckIcon, CodeIcon, MinusIcon, ProhibitIcon, WarningIcon } from '@phosphor-icons/react';
+import { useContext } from 'react';
+const STATUS = {
+    running: 'running',
+    ok: 'ok',
+    complete: 'ok',
+    error: 'error',
+    cancelled: 'cancelled',
+    interrupted: 'cancelled',
+};
+/** The reasons the pi runtime blocks a call with (kortixd `pi/runtime.ts`: `decide`, `nestedCallGate`). */
+const REFUSED = /^(The project policy denies|The user rejected|Call \S+ directly, not from a script)/;
+function callArg(name, input) {
+    if (input === undefined || input === '')
+        return '';
+    // pi's live record sends the arguments as truncated JSON; it may not parse.
+    let value = input;
+    if (typeof input === 'string') {
+        try {
+            value = JSON.parse(input);
+        }
+        catch {
+            return input;
+        }
+    }
+    const primary = value && typeof value === 'object'
+        ? getToolPrimaryArg({ type: 'tool', tool: name, state: { status: 'completed', input: value } })
+        : '';
+    return primary || (typeof value === 'string' ? value : JSON.stringify(value));
+}
+/**
+ * The calls a script made, from its tool metadata: pi's live record while it runs
+ * (`id`, `args` as JSON text, `ok`/`cancelled`) or the session log's at rest
+ * (`call_id`, `input`, `complete`/`interrupted`).
+ */
+export function scriptCalls(metadata) {
+    const calls = Array.isArray(metadata.calls) ? metadata.calls : [];
+    return calls.map((c) => ({
+        id: String(c.id ?? c.call_id ?? ''),
+        name: String(c.name ?? ''),
+        arg: callArg(String(c.name ?? ''), c.args ?? c.input),
+        status: STATUS[String(c.status)] === 'error' && typeof c.error === 'string' && REFUSED.test(c.error) ? 'refused' : (STATUS[String(c.status)] ?? 'cancelled'),
+        ...(typeof (c.durationMs ?? c.duration_ms) === 'number' ? { durationMs: Number(c.durationMs ?? c.duration_ms) } : {}),
+        ...(typeof c.error === 'string' && c.error ? { error: c.error } : {}),
+    }));
+}
+/** The script's result without pi's `Script completed|failed`, `Wall time` and `Output:` header lines. */
+export function scriptResult(text) {
+    return text.replace(/^Script (?:completed|failed)\n(?:Wall time [^\n]*\n)?(?:Output:\n)?/, '').trim();
+}
+function formatDuration(ms) {
+    return ms < 1000 ? `${Math.round(ms)} ms` : `${(ms / 1000).toFixed(1)} s`;
+}
+function CallMark({ status }) {
+    if (status === 'running')
+        return _jsx(Loading, { className: "text-muted-foreground size-3 shrink-0" });
+    if (status === 'ok')
+        return _jsx(CheckIcon, { className: "text-kortix-green size-3 shrink-0" });
+    if (status === 'error')
+        return _jsx(WarningIcon, { weight: "fill", className: "text-kortix-red size-3 shrink-0" });
+    if (status === 'refused')
+        return _jsx(ProhibitIcon, { weight: "fill", className: "text-kortix-orange size-3 shrink-0" });
+    return _jsx(MinusIcon, { className: "text-muted-foreground size-3 shrink-0" });
+}
+/**
+ * The script's tool calls, one row each: what ran, its main argument, how long it took.
+ * This list is what sets a script apart from every other tool row, so it sits first.
+ * pi keeps no output per call; a failed call shows its error.
+ */
+function CallList({ calls }) {
+    return (_jsx("ul", { className: "space-y-1", children: calls.map((call, index) => (_jsxs("li", { className: "text-xs leading-relaxed", children: [_jsxs("div", { className: "flex min-w-0 items-center gap-2", children: [_jsx(CallMark, { status: call.status }), _jsx("span", { className: "text-foreground shrink-0 font-mono", children: call.name }), _jsx("span", { className: "text-muted-foreground min-w-0 flex-1 truncate font-mono", title: call.arg, children: call.arg }), call.durationMs !== undefined && (_jsx("span", { className: "text-muted-foreground shrink-0 tabular-nums", children: formatDuration(call.durationMs) }))] }), call.error && _jsx("p", { className: "text-muted-foreground pl-5 font-mono wrap-break-word", children: call.error })] }, call.id || index))) }));
+}
+/** The row's words stay ink: the outcome mark `BasicTool` draws carries a failure's hue. */
+function ScriptTrigger({ title, live, summary }) {
+    const open = useToolOpen();
+    return (_jsxs("div", { className: "flex min-w-0 flex-1 items-center gap-1.5 overflow-hidden text-xs", children: [live ? (_jsx(TextShimmer, { duration: 1, spread: 2, className: "shrink-0 text-xs", children: title })) : (_jsx("span", { className: "text-foreground shrink-0", children: title })), !open && summary && _jsx("span", { className: "text-muted-foreground min-w-0 truncate", children: summary })] }));
+}
+export function CodemodeTool({ call, defaultOpen, forceOpen, locked }) {
+    const t = useTranslations('tools.codemode');
+    const running = useContext(ToolRunningContext);
+    const frame = useToolCardFrame();
+    const pad = useToolCardPad();
+    const indent = useToolIndent();
+    const paneInset = pad || 'py-2';
+    const code = typeof partInput(call).code === 'string' ? partInput(call).code.trim() : '';
+    const calls = scriptCalls(partMetadata(call));
+    const status = partStatus(call);
+    const failed = status === 'error';
+    const live = running && !failed && status !== 'completed';
+    const result = scriptResult(failed ? (partError(call) ?? '') : partOutput(call));
+    const names = [...new Set(calls.map((c) => c.name))].join(' · ');
+    const summary = calls.length ? `${t('calls', { count: calls.length })}${names ? ` · ${names}` : ''}` : '';
+    return (_jsx(BasicTool, { icon: _jsx(CodeIcon, { className: "size-4 shrink-0" }), trigger: _jsx(ScriptTrigger, { title: live ? t('runningScript') : failed ? t('scriptFailed') : t('ranScript'), live: live, summary: summary }), defaultOpen: defaultOpen, forceOpen: forceOpen, locked: locked, children: _jsx("div", { className: cn(indent && 'mt-1.5', indent), children: _jsxs("div", { className: cn('relative overflow-hidden', frame), children: [calls.length > 0 && (_jsx("div", { className: cn(paneInset, 'border-border/60 border-b'), children: _jsx(CallList, { calls: calls }) })), code && (_jsxs("div", { className: "relative", children: [_jsx("div", { "data-scrollable": true, className: cn('max-h-64 overflow-auto', frame && 'bg-muted/40'), children: _jsx("pre", { className: cn('text-foreground font-mono text-xs leading-relaxed wrap-break-word whitespace-pre-wrap [&_code]:border-none [&_code]:bg-transparent [&_code]:p-0 [&_code]:text-xs [&_code]:leading-relaxed [&_code]:whitespace-pre-wrap [&_pre]:whitespace-pre-wrap [&_span]:border-none [&_span]:outline-none', paneInset, 'pr-11'), children: _jsx(HighlightedCode, { code: code, language: "javascript", children: code }) }) }), _jsx("div", { className: "absolute top-2 right-2", children: _jsx(CopyButton, { code: code, className: "text-muted-foreground hover:text-foreground" }) })] })), (result || status === 'completed') && (_jsxs("div", { className: "border-border/60 relative border-t", children: [_jsx("div", { "data-scrollable": true, className: "max-h-80 overflow-auto", children: _jsx("div", { className: cn('font-mono text-xs leading-relaxed wrap-break-word whitespace-pre-wrap', failed ? 'text-foreground' : 'text-muted-foreground', paneInset, 'pr-11'), children: result || t('noOutput') }) }), result && (_jsx("div", { className: "absolute top-2 right-2", children: _jsx(CopyButton, { code: result, className: "text-muted-foreground hover:text-foreground" }) }))] }))] }) }) }));
+}
+ToolRegistry.register('codemode', CodemodeTool);

package/dist/session/tool/tools/connector-get-tool.d.ts

@@ -0,0 +1,2 @@
+import type { ToolProps } from '../shared/types.js';
+export declare function ConnectorGetTool({ call, defaultOpen, forceOpen }: ToolProps): import("react").JSX.Element;

package/dist/session/tool/tools/connector-get-tool.js

@@ -0,0 +1,22 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Badge } from '../../../primitives/badge.js';
+import { BasicTool, partInput, partOutput, ToolEmptyState, ToolOutputFallback, } from '../shared/infrastructure.js';
+import { ToolRegistry } from '../shared/registry.js';
+import { ToolResultCard } from '../shared/result-card.js';
+import { PlugIcon as Plug } from '@phosphor-icons/react';
+import { useTranslations } from '../../../i18n/index.js';
+import { useMemo } from 'react';
+import { parseConnectorGetOutput } from '../../../internal/lib/utils/kortix-tool-output.js';
+export function ConnectorGetTool({ call, defaultOpen, forceOpen }) {
+    const tI18nComplete = useTranslations('hardcodedUi.i18nComplete');
+    const input = partInput(call);
+    const output = partOutput(call);
+    const name = input.name || '';
+    const data = useMemo(() => parseConnectorGetOutput(output || ''), [output]);
+    return (_jsx(BasicTool, { icon: _jsx(Plug, { className: "text-muted-foreground size-3.5" }), trigger: {
+            title: data?.name || tI18nComplete.raw('textf51e3554540b'),
+            subtitle: name && name !== data?.name ? name : data?.description || 'Fetching...',
+        }, defaultOpen: defaultOpen, forceOpen: forceOpen, children: data ? (_jsxs(ToolResultCard, { bodyClassName: "space-y-2 p-2", children: [data.description && (_jsx("div", { className: "text-muted-foreground mb-1 text-xs", children: data.description })), _jsx("div", { className: "flex gap-2 text-xs", children: _jsx(Badge, { variant: "outline", className: "h-5 py-0 capitalize", children: data.source }) }), data.env && (_jsxs("div", { className: "text-xs", children: [_jsxs("span", { className: "text-muted-foreground/60", children: [tI18nComplete.raw('text146cd06d5026'), ' '] }), _jsx("code", { className: "bg-muted rounded px-1 text-xs", children: data.env })] })), data.notes && (_jsx("div", { className: "text-muted-foreground border-border/30 mt-2 border-t pt-2 text-xs whitespace-pre-wrap", children: data.notes }))] })) : output ? (_jsx(ToolOutputFallback, { output: output, toolName: "connector_get" })) : (_jsx(ToolResultCard, { children: _jsx(ToolEmptyState, { message: tI18nComplete.raw('text6cd606384bc7') }) })) }));
+}
+ToolRegistry.register('connector-get', ConnectorGetTool);

package/dist/session/tool/tools/connector-list-tool.d.ts

@@ -0,0 +1,2 @@
+import type { ToolProps } from '../shared/types.js';
+export declare function ConnectorListTool({ call, defaultOpen, forceOpen }: ToolProps): import("react").JSX.Element;

package/dist/session/tool/tools/connector-list-tool.js

@@ -0,0 +1,27 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Badge } from '../../../primitives/badge.js';
+import { BasicTool, isErrorOutput, partInput, partOutput, ToolEmptyState, ToolOutputFallback, } from '../shared/infrastructure.js';
+import { ToolRegistry } from '../shared/registry.js';
+import { ToolResultCard } from '../shared/result-card.js';
+import { PlugIcon as Plug } from '@phosphor-icons/react';
+import { useTranslations } from '../../../i18n/index.js';
+import { useMemo } from 'react';
+import { parseConnectorListOutput } from '../../../internal/lib/utils/kortix-tool-output.js';
+export function ConnectorListTool({ call, defaultOpen, forceOpen }) {
+    const tI18nComplete = useTranslations('hardcodedUi.i18nComplete');
+    const input = partInput(call);
+    const output = partOutput(call);
+    const filter = input.filter || '';
+    const connectors = useMemo(() => parseConnectorListOutput(output || ''), [output]);
+    // `isErrorOutput` trims a copy of the whole output and runs `JSON.parse` over
+    // it. Called from the render body it did that on every frame of the stream.
+    const isError = useMemo(() => isErrorOutput(output), [output]);
+    return (_jsx(BasicTool, { icon: _jsx(Plug, { className: "text-muted-foreground size-3.5" }), trigger: {
+            title: tI18nComplete.raw('textc023d120dd17'),
+            subtitle: filter
+                ? `Filter: ${filter}`
+                : `${connectors.length} connector${connectors.length !== 1 ? 's' : ''}`,
+        }, defaultOpen: defaultOpen || connectors.length === 0, forceOpen: forceOpen, children: connectors.length > 0 ? (_jsx(ToolResultCard, { bodyClassName: "space-y-1", children: connectors.map((conn) => (_jsxs("div", { className: "hover:bg-muted/30 flex items-start gap-2 rounded px-2 py-1 text-xs", children: [_jsx(Plug, { className: "text-muted-foreground mt-0.5 size-3.5 shrink-0" }), _jsxs("div", { className: "min-w-0 flex-1", children: [_jsx("div", { className: "text-foreground truncate font-medium", children: conn.name }), conn.description && (_jsx("div", { className: "text-muted-foreground/60", children: conn.description }))] }), _jsx(Badge, { variant: "outline", className: "h-5 shrink-0 py-0 text-xs capitalize", children: conn.source })] }, conn.name))) })) : isError ? (_jsx(ToolOutputFallback, { output: output, toolName: "connector_list" })) : output ? (_jsx(ToolResultCard, { children: _jsx(ToolEmptyState, { message: tI18nComplete.raw('textd4f603db3f57') }) })) : (_jsx(ToolResultCard, { children: _jsx(ToolEmptyState, { message: tI18nComplete.raw('text47c3d9d2f5c7') }) })) }));
+}
+ToolRegistry.register('connector-list', ConnectorListTool);

package/dist/session/tool/tools/connector-setup-tool.d.ts

@@ -0,0 +1,2 @@
+import type { ToolProps } from '../shared/types.js';
+export declare function ConnectorSetupTool({ call, defaultOpen, forceOpen }: ToolProps): import("react").JSX.Element;

package/dist/session/tool/tools/connector-setup-tool.js

@@ -0,0 +1,39 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { BasicTool, isErrorOutput, partInput, partOutput, ToolEmptyState, ToolOutputFallback, } from '../shared/infrastructure.js';
+import { ToolRegistry } from '../shared/registry.js';
+import { ToolResultCard } from '../shared/result-card.js';
+import { PlugIcon as Plug } from '@phosphor-icons/react';
+import { useTranslations } from '../../../i18n/index.js';
+import { useMemo } from 'react';
+import { parseConnectorSetupOutput } from '../../../internal/lib/utils/kortix-tool-output.js';
+export function ConnectorSetupTool({ call, defaultOpen, forceOpen }) {
+    const tHardcodedUi = useTranslations('hardcodedUi');
+    const input = partInput(call);
+    const output = partOutput(call);
+    const data = useMemo(() => parseConnectorSetupOutput(output || ''), [output]);
+    // `isErrorOutput` trims a copy of the whole output and runs `JSON.parse` over
+    // it, and this row asked it twice per render — once for the subtitle, once for
+    // the body.
+    const isError = useMemo(() => isErrorOutput(output), [output]);
+    // Connector names are the row identity — disambiguate a repeated name with
+    // an occurrence counter instead of the iteration index.
+    const keyedConnectors = useMemo(() => {
+        const seen = new Map();
+        return (data?.connectors ?? []).map((conn) => {
+            const n = seen.get(conn) ?? 0;
+            seen.set(conn, n + 1);
+            return { conn, key: n === 0 ? conn : `${conn}#${n}` };
+        });
+    }, [data]);
+    return (_jsx(BasicTool, { icon: _jsx(Plug, { className: "text-muted-foreground size-3.5" }), trigger: {
+            title: tHardcodedUi.raw('i18nComplete.text0df337fc286c'),
+            subtitle: isError
+                ? 'failed'
+                : data
+                    ? `${data.count} connector${data.count !== 1 ? 's' : ''} configured`
+                    : tHardcodedUi.raw('i18nComplete.texte9d6212ef873'),
+            args: data?.success ? ['configured'] : undefined,
+        }, defaultOpen: defaultOpen, forceOpen: forceOpen, children: isError ? (_jsx(ToolOutputFallback, { output: output, toolName: "connector_setup" })) : data && data.connectors.length > 0 ? (_jsx(ToolResultCard, { bodyClassName: "space-y-0.5", children: keyedConnectors.map(({ conn, key }) => (_jsxs("div", { className: "flex items-center gap-2 px-2 py-1 text-xs", children: [_jsx(Plug, { className: "text-muted-foreground size-3.5 shrink-0" }), _jsx("span", { className: "font-medium", children: conn })] }, key))) })) : output ? (_jsx(ToolOutputFallback, { output: output, toolName: "connector_setup" })) : (_jsx(ToolResultCard, { children: _jsx(ToolEmptyState, { message: tHardcodedUi.raw('componentsSessionToolRenderers.line7398JsxTextSettingUpConnectors') }) })) }));
+}
+ToolRegistry.register('connector-setup', ConnectorSetupTool);

package/dist/session/tool/tools/connector-tools.d.ts

@@ -0,0 +1,5 @@
+import type { ToolProps } from '../shared/types.js';
+export declare function ConnectorsTool({ call, defaultOpen, forceOpen, locked }: ToolProps): import("react").JSX.Element;
+export declare function ConnectorDiscoverTool({ call, defaultOpen, forceOpen, locked }: ToolProps): import("react").JSX.Element;
+export declare function ConnectorDescribeTool({ call, defaultOpen, forceOpen, locked }: ToolProps): import("react").JSX.Element;
+export declare function ConnectorCallTool({ call, defaultOpen, forceOpen, locked }: ToolProps): import("react").JSX.Element;

package/dist/session/tool/tools/connector-tools.js

@@ -0,0 +1,129 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { STATUS_TEXT } from '../../../primitives/status.js';
+import { ConnectorJson, ConnectorRiskBadge, parseConnectorOutput, } from '../shared/error-and-connector.js';
+import { BasicTool, ToolEmptyState, ToolOutputFallback, ToolRunningContext, isErrorOutput, partInput, partOutput, partStatus, } from '../shared/infrastructure.js';
+import { FoldedSection, ToolSection } from '../shared/output-block.js';
+import { ToolRegistry } from '../shared/registry.js';
+import { ToolResultCard } from '../shared/result-card.js';
+import { useTranslations } from '../../../i18n/index.js';
+import { cn } from '../../../lib/utils.js';
+import { CodeSimpleIcon as Code2, PlugIcon as Plug, MagnifyingGlassIcon as Search, TerminalWindowIcon as Terminal, } from '@phosphor-icons/react';
+import { useContext, useMemo } from 'react';
+/**
+ * The empty answers every "nothing parsed yet" branch shares.
+ *
+ * `?? []` / `?? {}` in the body hands back a fresh identity on every render of
+ * every connector row, and these sit on the streaming path where a row renders
+ * per token. Frozen so a caller cannot mutate what it thinks is its own.
+ */
+const EMPTY_ROWS = Object.freeze([]);
+const EMPTY_ARGS = Object.freeze({});
+const EMPTY_INPUT_SCHEMA = Object.freeze({ type: 'object', properties: {} });
+export function ConnectorsTool({ call, defaultOpen, forceOpen, locked }) {
+    const tI18nComplete = useTranslations('hardcodedUi.i18nComplete');
+    const output = partOutput(call);
+    const status = partStatus(call);
+    const running = useContext(ToolRunningContext);
+    const parsed = useMemo(() => parseConnectorOutput(output), [output]);
+    const connectors = (Array.isArray(parsed?.connectors) ? parsed.connectors : EMPTY_ROWS);
+    const isStreaming = (status === 'pending' && running) || status === 'running';
+    return (_jsx(BasicTool, { icon: _jsx(Plug, { className: "size-3.5 shrink-0" }), trigger: {
+            title: tI18nComplete.raw('textc023d120dd17'),
+            args: status === 'completed' ? [`${connectors.length} available`] : undefined,
+        }, defaultOpen: defaultOpen, forceOpen: forceOpen, locked: locked, children: connectors.length > 0 ? (_jsx(ToolResultCard, { bodyClassName: "space-y-0.5", children: connectors.map((c) => (_jsxs("div", { className: "flex items-center gap-2 px-2 py-1 text-xs", children: [_jsx(Plug, { className: "text-muted-foreground/50 size-3 shrink-0" }), _jsx("span", { className: "text-foreground truncate font-medium", children: String(c.name || c.slug || '') }), _jsx("span", { className: "text-muted-foreground/60 font-mono", children: String(c.provider ?? '') }), _jsxs("span", { className: "text-muted-foreground/50 ml-auto", children: [String(c.tools ?? 0), " ", tI18nComplete.raw('textf9d35d43770d')] }), _jsx("span", { className: cn('text-[10px] font-semibold uppercase', c.status === 'active' ? STATUS_TEXT.success : 'text-muted-foreground/60'), children: String(c.status ?? '') })] }, String(c.slug ?? '') || `${String(c.name ?? '')}:${String(c.provider ?? '')}`))) })) : output ? (_jsx(ToolOutputFallback, { output: output, isStreaming: isStreaming, toolName: "connectors" })) : (_jsx(ToolResultCard, { children: _jsx(ToolEmptyState, { message: isStreaming
+                    ? tI18nComplete.raw('text47c3d9d2f5c7')
+                    : tI18nComplete.raw('textb65b97575287') }) })) }));
+}
+ToolRegistry.register('kortix-connectors_connectors', ConnectorsTool);
+export function ConnectorDiscoverTool({ call, defaultOpen, forceOpen, locked }) {
+    const tI18nComplete = useTranslations('hardcodedUi.i18nComplete');
+    const input = partInput(call);
+    const output = partOutput(call);
+    // `isErrorOutput` trims a copy of the whole output and runs `JSON.parse`
+    // over it. Called straight from JSX it did that on every render.
+    const outputIsError = useMemo(() => isErrorOutput(output), [output]);
+    const status = partStatus(call);
+    const running = useContext(ToolRunningContext);
+    const parsed = useMemo(() => parseConnectorOutput(output), [output]);
+    const matches = (Array.isArray(parsed?.matches) ? parsed.matches : EMPTY_ROWS);
+    const query = String(input.query ?? '').trim();
+    const isStreaming = (status === 'pending' && running) || status === 'running';
+    return (_jsx(BasicTool, { icon: _jsx(Search, { className: "size-3.5 shrink-0" }), trigger: {
+            title: tI18nComplete.raw('text2c496ac4ee78'),
+            subtitle: query || undefined,
+            args: status === 'completed'
+                ? [`${matches.length} ${matches.length === 1 ? 'match' : 'matches'}`]
+                : undefined,
+        }, defaultOpen: defaultOpen, forceOpen: forceOpen, locked: locked, children: outputIsError ? (_jsx(ToolOutputFallback, { output: output, isStreaming: isStreaming, toolName: "discover" })) : matches.length > 0 ? (_jsx(ToolResultCard, { bodyClassName: "space-y-1.5", children: matches.map((m) => (_jsxs("div", { className: "px-2 py-1 text-xs", children: [_jsxs("div", { className: "flex items-center gap-2", children: [_jsx("span", { className: "text-foreground truncate font-mono", children: String(m.tool ?? '') }), _jsx(ConnectorRiskBadge, { risk: m.risk })] }), m.description ? (_jsx("p", { className: "text-muted-foreground mt-0.5 line-clamp-2 text-xs leading-relaxed", children: String(m.description) })) : null] }, String(m.tool ?? '') || String(m.description ?? '').slice(0, 60)))) })) : parsed ? (_jsx(ToolResultCard, { children: _jsx(ToolEmptyState, { message: isStreaming
+                    ? tI18nComplete.raw('textc31723ab3302')
+                    : tI18nComplete('text139dfa78cf32', { value0: query }) }) })) : output ? (_jsx(ToolOutputFallback, { output: output, isStreaming: isStreaming, toolName: "discover" })) : (_jsx(ToolResultCard, { children: _jsx(ToolEmptyState, { message: isStreaming
+                    ? tI18nComplete.raw('textc31723ab3302')
+                    : tI18nComplete.raw('text9d03981932cd') }) })) }));
+}
+ToolRegistry.register('kortix-connectors_discover', ConnectorDiscoverTool);
+export function ConnectorDescribeTool({ call, defaultOpen, forceOpen, locked }) {
+    const tI18nHardcoded = useTranslations('hardcodedUi');
+    const input = partInput(call);
+    const output = partOutput(call);
+    // `isErrorOutput` trims a copy of the whole output and runs `JSON.parse`
+    // over it. Called straight from JSX it did that on every render.
+    const outputIsError = useMemo(() => isErrorOutput(output), [output]);
+    const status = partStatus(call);
+    const running = useContext(ToolRunningContext);
+    const parsed = useMemo(() => parseConnectorOutput(output), [output]);
+    const tool = String(parsed?.tool ?? input.tool ?? '').trim();
+    const isStreaming = (status === 'pending' && running) || status === 'running';
+    return (_jsx(BasicTool, { icon: _jsx(Code2, { className: "size-3.5 shrink-0" }), trigger: {
+            title: tI18nHardcoded.raw('i18nComplete.text2945df36c2f9'),
+            subtitle: tool || undefined,
+            args: parsed?.risk ? [String(parsed.risk)] : undefined,
+        }, defaultOpen: defaultOpen, forceOpen: forceOpen, locked: locked, children: outputIsError ? (_jsx(ToolOutputFallback, { output: output, isStreaming: isStreaming, toolName: "describe" })) : parsed ? (_jsxs(ToolResultCard, { bodyClassName: "space-y-2.5 p-2", children: [_jsxs("div", { className: "flex items-center gap-2", children: [_jsx("span", { className: "text-foreground font-mono text-xs", children: tool }), _jsx(ConnectorRiskBadge, { risk: parsed.risk })] }), parsed.description ? (_jsx("p", { className: "text-muted-foreground text-xs leading-relaxed", children: String(parsed.description) })) : null, _jsx(FoldedSection, { label: tI18nHardcoded.raw('autoFeaturesSessionToolRenderersJsxTextInputSchema878a1df6'), children: _jsx(ConnectorJson, { value: parsed.inputSchema ?? EMPTY_INPUT_SCHEMA }) })] })) : output ? (_jsx(ToolOutputFallback, { output: output, isStreaming: isStreaming, toolName: "describe" })) : (_jsx(ToolResultCard, { children: _jsx(ToolEmptyState, { message: isStreaming
+                    ? tI18nHardcoded.raw('i18nComplete.text3af4d559fa0a')
+                    : tI18nHardcoded.raw('i18nComplete.text63a86e996212') }) })) }));
+}
+ToolRegistry.register('kortix-connectors_describe', ConnectorDescribeTool);
+export function ConnectorCallTool({ call, defaultOpen, forceOpen, locked }) {
+    const tI18nComplete = useTranslations('hardcodedUi.i18nComplete');
+    const input = partInput(call);
+    const output = partOutput(call);
+    // `isErrorOutput` trims a copy of the whole output and runs `JSON.parse`
+    // over it. Called straight from JSX it did that on every render.
+    const outputIsError = useMemo(() => isErrorOutput(output), [output]);
+    const status = partStatus(call);
+    const running = useContext(ToolRunningContext);
+    const parsed = useMemo(() => parseConnectorOutput(output), [output]);
+    const connector = String(input.connector ?? '').trim();
+    const action = String(input.action ?? '').trim();
+    const args = (input.args && typeof input.args === 'object' ? input.args : EMPTY_ARGS);
+    const ref = connector && action ? `${connector}.${action}` : connector || action;
+    const isStreaming = (status === 'pending' && running) || status === 'running';
+    const ok = parsed?.ok === true;
+    const callStatus = typeof parsed?.status === 'string'
+        ? parsed.status
+        : ok
+            ? 'ok'
+            : parsed
+                ? 'error'
+                : '';
+    const outcome = callStatus === 'pending_approval'
+        ? { label: tI18nComplete.raw('textdb0e960b68b5'), tint: STATUS_TEXT.warning }
+        : callStatus === 'denied'
+            ? { label: tI18nComplete.raw('textda404deb110f'), tint: STATUS_TEXT.destructive }
+            : ok
+                ? { label: 'OK', tint: STATUS_TEXT.success }
+                : parsed
+                    ? { label: tI18nComplete.raw('text54a0e8c17ebb'), tint: STATUS_TEXT.destructive }
+                    : null;
+    return (_jsx(BasicTool, { icon: _jsx(Terminal, { className: "size-3.5 shrink-0" }), trigger: {
+            title: tI18nComplete.raw('text7812d84e3512'),
+            subtitle: ref || undefined,
+            args: [
+                ...(parsed?.risk ? [String(parsed.risk)] : []),
+                ...(outcome ? [outcome.label] : []),
+            ].filter(Boolean),
+        }, defaultOpen: defaultOpen, forceOpen: forceOpen, locked: locked, children: _jsxs(_Fragment, { children: [_jsxs(ToolResultCard, { bodyClassName: "space-y-2.5 p-2", children: [_jsxs("div", { className: "flex items-center gap-2 text-xs", children: [_jsx("span", { className: "text-foreground font-mono", children: ref }), _jsx(ConnectorRiskBadge, { risk: parsed?.risk }), outcome && (_jsx("span", { className: cn('ml-auto text-[10px] font-semibold uppercase', outcome.tint), children: outcome.label }))] }), Object.keys(args).length > 0 && (_jsx(FoldedSection, { label: tI18nComplete.raw('text59f03d642b41'), children: _jsx(ConnectorJson, { value: args }) })), !outputIsError && parsed ? (_jsx(ToolSection, { label: tI18nComplete.raw('text9061383b8e22'), children: parsed.reason && !ok ? (_jsx("p", { className: "text-destructive font-mono text-xs", children: String(parsed.reason) })) : (_jsx(ConnectorJson, { value: 'data' in parsed ? parsed.data : parsed })) })) : output ? null : (_jsx(ToolEmptyState, { message: isStreaming
+                                ? tI18nComplete.raw('text46c541363b02')
+                                : tI18nComplete.raw('text752edcfbfb98') }))] }), (outputIsError || (!parsed && output)) && (_jsx(ToolOutputFallback, { output: output, isStreaming: isStreaming, toolName: "call" }))] }) }));
+}
+ToolRegistry.register('kortix-connectors_call', ConnectorCallTool);

package/dist/session/tool/tools/edit-tool.d.ts

@@ -0,0 +1,2 @@
+import type { ToolProps } from '../shared/types.js';
+export declare function EditTool({ call, defaultOpen, forceOpen, locked }: ToolProps): import("react").JSX.Element;

package/dist/session/tool/tools/edit-tool.js

@@ -0,0 +1,123 @@
+'use client';
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { filePhase, fileVerb } from '@kortix/sdk';
+import { BasicTool, DiagnosticsDisplay, getToolDiagnostics, InlineDiffView, isErrorOutput, partInput, partOutput, partStatus, partStreamingInput, ToolCodeCard, ToolOutputFallback, ToolRunningContext, useToolIndent, } from '../shared/infrastructure.js';
+import { RawPatchDiffView } from '../shared/patch-helpers.js';
+import { ToolRegistry } from '../shared/registry.js';
+import { ToolResultCard } from '../shared/result-card.js';
+import { cn } from '../../../lib/utils.js';
+import { useFilePreviewStore } from '../../../internal/stores/file-preview-store.js';
+import { getFilename } from '../../../internal/session-types/index.js';
+import { inputPath, toToolView } from '@kortix/sdk';
+import { PencilSimpleIcon } from '@phosphor-icons/react';
+import { diffLines } from 'diff';
+import { useTranslations } from '../../../i18n/index.js';
+import { useCallback, useContext, useMemo } from 'react';
+export function EditTool({ call, defaultOpen, forceOpen, locked }) {
+    const tI18nComplete = useTranslations('hardcodedUi.i18nComplete');
+    const running = useContext(ToolRunningContext);
+    const input = partInput(call);
+    const streamingInput = partStreamingInput(call);
+    const status = partStatus(call);
+    // The harness-neutral file: OpenCode's before/after (or the replaced block),
+    // or pi's unified patch.
+    const file = useMemo(() => toToolView(call).files?.[0], [call]);
+    const filePath = file?.path ||
+        inputPath(streamingInput) ||
+        streamingInput.target_filepath ||
+        undefined;
+    const { filename, ext } = useMemo(() => {
+        const name = getFilename(filePath) || '';
+        return { filename: name, ext: name.split('.').pop() || '' };
+    }, [filePath]);
+    // Unmemoised this ran on every frame of a COLLAPSED row: `partOutput` plus two
+    // full-string `includes`, and — when the output carries `<file_diagnostics>` —
+    // a global regex, a full split and a per-line regex on top.
+    const diagnostics = useMemo(() => getToolDiagnostics(call, filePath), [call, filePath]);
+    const indent = useToolIndent();
+    const isStalePending = !running && !filename && (status === 'pending' || status === 'running');
+    const before = file?.before ??
+        (input.oldString ?? input.old_string) ??
+        streamingInput.oldString ??
+        '';
+    const after = file?.after ??
+        (input.newString ?? input.new_string) ??
+        streamingInput.newString ??
+        '';
+    const patch = file?.patch ?? '';
+    const codeEdit = input.code_edit || streamingInput.code_edit || '';
+    const morphInstructions = input.instructions || streamingInput.instructions || '';
+    const hasDiff = before !== '' || after !== '';
+    const output = partOutput(call);
+    const isError = status === 'completed' && isErrorOutput(output);
+    /**
+     * `Editing` never became `Edited`. The row was a present participle for the
+     * life of the transcript, so a call that finished an hour ago still claimed to
+     * be mid-flight — the single biggest reason a settled session read as a
+     * stalled one. See `file-verb.ts`; every other surface has reported this call
+     * in the right tense for a long time.
+     *
+     * `morph_edit` shares this renderer and therefore this wording, which is
+     * correct: the reader is told what happened to their file, not which of two
+     * edit implementations the agent picked.
+     */
+    const title = fileVerb('edit', filePhase(running, isError));
+    // Line counts for the row, from the same before/after the expanded diff
+    // renders — so the closed row already answers "how big was this edit?".
+    // Settled calls only: while an edit streams, `after` grows by the chunk, and
+    // re-diffing a whole file per chunk is per-frame work a collapsed row must
+    // not do. `maxEditLength` bails on pathological pairs (two rewritten
+    // 10k-line files) — no stat beats a stalled frame; the expanded DiffView
+    // still shows everything.
+    const diffCounts = useMemo(() => {
+        if (status !== 'completed')
+            return undefined;
+        if (!hasDiff) {
+            // pi: the SDK counted the unified patch.
+            return patch && file?.additions !== undefined
+                ? { additions: file.additions, deletions: file.deletions ?? 0 }
+                : undefined;
+        }
+        const changes = diffLines(before, after, { maxEditLength: 1000 });
+        if (!changes)
+            return undefined;
+        let additions = 0;
+        let deletions = 0;
+        for (const change of changes) {
+            if (change.added)
+                additions += change.count;
+            else if (change.removed)
+                deletions += change.count;
+        }
+        return { additions, deletions };
+    }, [status, hasDiff, before, after, patch, file]);
+    // Selector, not the whole store: an unselected `useFilePreviewStore()` makes
+    // every edit row a subscriber of `isOpen` / `filePath` / `lineNumber`, so
+    // opening ONE preview re-rendered every edit row in the session.
+    const openPreview = useFilePreviewStore((s) => s.openPreview);
+    const handleSubtitleClick = useCallback(() => {
+        if (filePath)
+            openPreview(filePath);
+    }, [filePath, openPreview]);
+    return (_jsxs(BasicTool, { icon: _jsx(PencilSimpleIcon, { className: "size-3.5 shrink-0" }), trigger: {
+            title,
+            subtitle: filename || undefined,
+            // No stat on a failed call: the numbers would describe an edit that
+            // did not land.
+            stat: isError ? undefined : diffCounts,
+        }, onSubtitleClick: filePath ? handleSubtitleClick : undefined, defaultOpen: defaultOpen, forceOpen: forceOpen, locked: locked, className: "overflow-hidden p-0", children: [isError ? (_jsx(ToolOutputFallback, { output: output, toolName: "edit" })) : hasDiff ? (_jsx(ToolResultCard, { children: _jsx(InlineDiffView, { oldValue: before, newValue: after, filename: filename }) })) : patch ? (_jsx(ToolResultCard, { children: _jsx(RawPatchDiffView, { patch: patch, filename: filename }) })) : codeEdit ? (_jsxs(_Fragment, { children: [morphInstructions && (
+                    // `mb-1.5` carries the gap to the card BELOW, which no longer draws
+                    // a top margin on the panel. Inline the two collapse to the same
+                    // 6px this line has always had under it.
+                    _jsx("div", { className: cn('text-muted-foreground mb-1.5 text-xs italic', indent && 'mt-1.5', indent), children: morphInstructions })), _jsx(ToolCodeCard, { code: codeEdit, language: ext })] })) : isStalePending ? (
+            // The same statement `write` makes, in the same words, because it is the
+            // same situation: a part that is DONE waiting — the run it belonged to
+            // is over. This row used to shimmer "Waiting for file content" instead,
+            // which is a promise, and on a restored session it was a promise the
+            // transcript could never keep — the animation ran forever over a diff
+            // that was never going to arrive. `write-tool.tsx` dropped that shimmer;
+            // `edit` kept it, so one situation had two answers.
+            _jsx(ToolResultCard, { bodyClassName: "px-2 py-1.5", children: _jsx("span", { className: "text-muted-foreground/60 text-xs", children: tI18nComplete.raw('text93168435f3ae') }) })) : null, _jsx(DiagnosticsDisplay, { diagnostics: diagnostics, filePath: filePath })] }));
+}
+ToolRegistry.register('edit', EditTool);
+ToolRegistry.register('morph_edit', EditTool);

package/dist/session/tool/tools/get-mem-tool.d.ts

@@ -0,0 +1,2 @@
+import type { ToolProps } from '../shared/types.js';
+export declare function GetMemTool({ call, defaultOpen, forceOpen, locked }: ToolProps): import("react").JSX.Element;

package/dist/session/tool/tools/get-mem-tool.js

@@ -0,0 +1,57 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { STATUS_TEXT, StatusDot } from '../../../primitives/status.js';
+import { BasicTool, ToolEmptyState, ToolOutputFallback, ToolRunningContext, partInput, partOutput, partStatus, } from '../shared/infrastructure.js';
+import { FoldedSection, OutputBlock, ToolField, ToolSection, } from '../shared/output-block.js';
+import { ToolRegistry } from '../shared/registry.js';
+import { ToolResultCard } from '../shared/result-card.js';
+import { useTranslations } from '../../../i18n/index.js';
+import { cn } from '../../../lib/utils.js';
+import { parseMemoryEntryOutput } from '../../../_vendor/kortix-shared.js';
+import { BrainIcon as Brain, CalendarDotsIcon as CalendarClock, FingerprintIcon as Fingerprint, } from '@phosphor-icons/react';
+import { useContext, useMemo } from 'react';
+export function GetMemTool({ call, defaultOpen, forceOpen, locked }) {
+    const tHardcodedUi = useTranslations('hardcodedUi');
+    const input = partInput(call);
+    const output = partOutput(call);
+    const status = partStatus(call);
+    const running = useContext(ToolRunningContext);
+    const source = input.source || '';
+    const memoryId = input.id != null ? String(input.id) : '';
+    const report = useMemo(() => parseMemoryEntryOutput(output), [output]);
+    const isStreaming = (status === 'pending' && running) || status === 'running';
+    // What the row says when it is SHUT.
+    //
+    // It used to say `Recalled · #482`, and a group of them said `Recalled ·
+    // #482` / `Recalled · #1180` — two rows that name neither the memory nor
+    // anything a reader could act on. The payload already carries the words: an
+    // observation has a `title`, an LTM entry a `caption`. Those go in the
+    // subtitle; the id, which identifies the record but not the memory, moves to
+    // the badge at the row's right edge. Until the output parses (streaming, or
+    // an unrecognized shape) the id is all there is, so it stays the subtitle
+    // rather than leaving the row with nothing.
+    const recalled = report ? (report.kind === 'observation' ? report.title : report.caption) : '';
+    const idLabel = memoryId ? `#${memoryId}` : undefined;
+    return (_jsx(BasicTool, { icon: _jsx(Brain, { className: "size-3.5 shrink-0" }), trigger: {
+            title: tHardcodedUi.raw('i18nComplete.textb7416a669c6b'),
+            subtitle: recalled || idLabel,
+        }, badge: recalled ? idLabel : undefined, defaultOpen: defaultOpen, forceOpen: forceOpen, locked: locked, children: report ? (
+        // Shared result card, not a bespoke muted div — holds composed fields.
+        //
+        // What a reader opened a recalled memory for is the memory: an
+        // observation's title and narrative, an entry's caption and content.
+        // Everything else here — which call asked for it, which facts and
+        // concepts were extracted, which files it touched, its tags — is
+        // provenance, and it used to stack open underneath the answer as six
+        // more labelled sections. Those fold; the answer does not.
+        _jsxs(ToolResultCard, { bodyClassName: "space-y-2.5 p-2", children: [(source || memoryId) && (_jsx(FoldedSection, { label: tHardcodedUi.raw('i18nComplete.text59f03d642b41'), children: _jsxs("div", { className: "flex flex-wrap items-center gap-1.5", children: [source && (_jsx(ToolField, { label: tHardcodedUi.raw('i18nComplete.text0e570ca6fabe'), value: source })), memoryId && _jsx(ToolField, { label: "ID", value: `#${memoryId}`, mono: true })] }) })), _jsxs("div", { className: "flex flex-wrap items-center gap-x-2 gap-y-1", children: [_jsxs("span", { className: "text-muted-foreground inline-flex items-center gap-1 text-xs", children: [_jsx(Fingerprint, { className: "size-3 shrink-0" }), _jsxs("span", { children: [report.kind === 'observation'
+                                            ? tHardcodedUi.raw('componentsSessionToolRenderers.line1730JsxTextObservation')
+                                            : tHardcodedUi.raw('componentsSessionToolRenderers.line1847JsxTextLTM'), report.id] })] }), _jsx("span", { className: "text-muted-foreground inline-flex items-center text-xs tracking-wide uppercase", children: report.type }), report.created && (_jsxs("span", { className: "text-muted-foreground inline-flex items-center gap-1 text-xs", children: [_jsx(CalendarClock, { className: "size-3 shrink-0" }), _jsx("span", { children: report.created })] }))] }), report.kind === 'observation' ? (_jsxs(_Fragment, { children: [report.title && (_jsx("h3", { className: "text-foreground/90 text-xs font-medium", children: report.title })), report.narrative && (_jsx(ToolSection, { label: tHardcodedUi.raw('i18nComplete.texted2e59c337d0'), children: _jsx(OutputBlock, { text: report.narrative, markdown: true }) })), report.facts.length > 0 && (_jsx(FoldedSection, { label: tHardcodedUi('i18nComplete.text677e3e9ff173', {
+                                value0: report.facts.length,
+                            }), children: _jsx("ul", { className: "space-y-1", children: report.facts.map((fact, index) => (_jsxs("li", { className: "text-foreground/90 flex items-start gap-1.5 text-xs leading-relaxed", children: [_jsx(StatusDot, { tone: "success", className: "mt-[6px]" }), _jsx("span", { children: fact })] }, `${report.id}-${index}`))) }) })), report.concepts.length > 0 && (_jsx(FoldedSection, { label: tHardcodedUi.raw('i18nComplete.text0d0a8c6df3ac'), children: _jsx("div", { className: "flex flex-wrap items-center gap-1.5", children: report.concepts.map((concept) => (_jsx("span", { className: cn('text-xs font-medium', STATUS_TEXT.success), children: concept }, concept))) }) })), (report.tool || report.prompt || report.session || report.filesRead.length > 0) && (_jsxs("div", { className: "space-y-1.5", children: [_jsxs("div", { className: "flex flex-wrap items-center gap-1.5", children: [report.tool && (_jsx(ToolField, { label: tHardcodedUi.raw('i18nComplete.text2e53bdcd0740'), value: report.tool })), report.prompt && (_jsxs("span", { className: "text-muted-foreground/60 inline-flex items-baseline text-xs", children: [tHardcodedUi.raw('componentsSessionToolRenderers.line1811JsxTextPrompt'), _jsx("span", { className: "text-foreground/80", children: report.prompt })] })), report.session && (_jsx(ToolField, { label: tHardcodedUi.raw('i18nComplete.text6959b4159575'), value: report.session, mono: true }))] }), report.filesRead.length > 0 && (_jsx(FoldedSection, { label: `${tHardcodedUi.raw('componentsSessionToolRenderers.line1823JsxTextFilesRead')} (${report.filesRead.length})`, children: _jsx("div", { className: "flex flex-wrap gap-1.5", children: report.filesRead.map((file) => (_jsx("span", { className: "bg-background border-border/70 text-foreground/75 inline-flex h-6 items-center rounded-sm border px-2 font-mono text-xs break-all", children: file }, file))) }) }))] }))] })) : (_jsxs(_Fragment, { children: [report.caption && (_jsx(ToolSection, { label: tHardcodedUi.raw('i18nComplete.text87d296ec9489'), children: _jsx(OutputBlock, { text: report.caption, markdown: true }) })), report.content && (_jsx(ToolSection, { label: tHardcodedUi.raw('i18nComplete.text47bd29075f8b'), children: _jsx(OutputBlock, { text: report.content, markdown: true }) })), report.tags.length > 0 && (_jsx(FoldedSection, { label: tHardcodedUi('i18nComplete.text7964f184beb2', {
+                                value0: report.tags.length,
+                            }), children: _jsx("div", { className: "flex flex-wrap items-center gap-1.5", children: report.tags.map((tag) => (_jsx("span", { className: cn('text-xs font-medium', STATUS_TEXT.success), children: tag }, tag))) }) })), (report.session || report.updated) && (_jsxs("div", { className: "flex flex-wrap items-center gap-1.5", children: [report.session && (_jsx(ToolField, { label: tHardcodedUi.raw('i18nComplete.text6959b4159575'), value: report.session, mono: true })), report.updated && (_jsx(ToolField, { label: tHardcodedUi.raw('i18nComplete.text3a5ecca188c0'), value: report.updated }))] }))] }))] })) : output ? (_jsx(ToolOutputFallback, { output: output, isStreaming: isStreaming, toolName: "get_mem" })) : (_jsx(ToolResultCard, { children: _jsx(ToolEmptyState, { message: isStreaming
+                    ? tHardcodedUi.raw('i18nComplete.textde6a473b60fe')
+                    : tHardcodedUi.raw('i18nComplete.textf82de1c9a1f5') }) })) }));
+}
+ToolRegistry.register('get-mem', GetMemTool);

package/dist/session/tool/tools/glob-tool.d.ts

@@ -0,0 +1,2 @@
+import type { ToolProps } from '../shared/types.js';
+export declare function GlobTool({ call, defaultOpen, forceOpen, locked }: ToolProps): import("react").JSX.Element;