@kortix/ui 0.14.12 → 0.14.14

package/dist/session/tool/tools/kortix-action-tool.js

@@ -0,0 +1,148 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { Badge } from '../../../primitives/badge.js';
+import { Button } from '../../../primitives/button.js';
+import { ButtonGroup } from '../../../primitives/button-group.js';
+import { StatusDot } from '../../../primitives/status.js';
+import { TextShimmer } from '../../../primitives/text-shimmer.js';
+import { GenericTool } from '../generic-tool.js';
+import { BasicTool, partError, partInput, partRawOutput, partStatus, ToolOutcomeContext, ToolRunningContext, useToolIndent, useToolOpen, } from '../shared/infrastructure.js';
+import { FoldedSection, OutputBlock } 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 { UiLink } from '../../../providers/ui-provider.js';
+import { ArrowRightIcon, ArrowSquareOutIcon, CalendarDotsIcon, CaretRightIcon, ChartBarIcon, ChatsCircleIcon, CheckIcon, GitPullRequestIcon, SunDimIcon, HandPointingIcon, LockKeyIcon, PlugIcon, RobotIcon, UsersIcon, WarningIcon, } from '@phosphor-icons/react';
+import { useContext, useMemo } from 'react';
+import { MULTI_AGENT_ICON, multiAgentBody, runningKey } from './multi-agent-tool-bodies.js';
+import { KORTIX_PLATFORM_TOOLS, isReadAction, kortixCardTool, kortixPlatformTool, multiAgentTool, parseKortixToolResult, } from './kortix-tool-card.js';
+const TOOL_META = {
+    kortix_agents: { icon: RobotIcon, object: 'agents' },
+    kortix_sessions: { icon: ChatsCircleIcon, object: 'sessions' },
+    kortix_schedules: { icon: CalendarDotsIcon, object: 'schedules' },
+    kortix_connectors: { icon: PlugIcon, object: 'connectors' },
+    kortix_people: { icon: UsersIcon, object: 'people' },
+    kortix_access: { icon: LockKeyIcon, object: 'access' },
+    kortix_usage: { icon: ChartBarIcon, object: 'usage' },
+    kortix_change_requests: { icon: GitPullRequestIcon, object: 'changeRequests' },
+    kortix_memory: { icon: SunDimIcon, object: 'memory' },
+};
+/** Row badge words that name a state with a hue (color.md status table). Any other word stays neutral. */
+const SUCCESS_WORDS = new Set(['running', 'active', 'connected', 'enabled', 'done', 'live', 'merged', 'on']);
+const ATTENTION_WORDS = new Set(['paused', 'expired', 'not signed in', 'disconnected', 'needs you']);
+function badgeVariant(badge) {
+    const word = badge.toLowerCase();
+    if (SUCCESS_WORDS.has(word))
+        return 'success';
+    if (ATTENTION_WORDS.has(word))
+        return 'warning';
+    return 'muted';
+}
+/** Raw output for "Show details": the result pretty-printed, capped. */
+const DETAILS_LIMIT = 8_000;
+function detailsText(raw) {
+    let text = raw;
+    try {
+        text = JSON.stringify(JSON.parse(raw), null, 2);
+    }
+    catch {
+        // keep the raw text
+    }
+    return text.length > DETAILS_LIMIT ? `${text.slice(0, DETAILS_LIMIT)}\n…` : text;
+}
+/** The card's state at the row's right edge. The glyph carries the hue; the word is for a screen reader. */
+function StatusMark({ status }) {
+    const t = useTranslations('tools.kortixAction.status');
+    const glyph = status === 'done' ? (_jsx(CheckIcon, { "aria-hidden": true, className: "text-kortix-green size-3.5 shrink-0" })) : status === 'running' ? (
+    // The thing the tool started runs on (a session). No spinner: the call itself is over.
+    _jsx(StatusDot, { tone: "success" })) : status === 'needs_you' ? (_jsx(HandPointingIcon, { weight: "fill", "aria-hidden": true, className: "text-kortix-yellow size-3.5 shrink-0" })) : status === 'denied' ? (_jsx(LockKeyIcon, { weight: "fill", "aria-hidden": true, className: "text-kortix-orange size-3.5 shrink-0" })) : (_jsx(WarningIcon, { weight: "fill", "aria-hidden": true, className: "text-kortix-red size-3.5 shrink-0" }));
+    const label = { done: t('done'), running: t('running'), needs_you: t('needsYou'), denied: t('denied'), error: t('error') }[status];
+    return (_jsxs("span", { className: "ml-auto flex shrink-0 items-center pl-1", children: [glyph, _jsx("span", { className: "sr-only", children: label })] }));
+}
+/** The row's words stay ink; the status mark at the right edge carries the hue. */
+function CardTrigger({ title, subtitle, live, status, }) {
+    return (_jsxs("div", { className: "flex min-w-0 flex-1 items-center gap-1.5 overflow-hidden text-sm", children: [live ? (_jsx(TextShimmer, { duration: 1, spread: 2, className: "min-w-0 truncate text-sm", children: title })) : (_jsx("span", { className: "text-foreground min-w-0 truncate", title: title, children: title })), subtitle && (_jsx("span", { className: "text-muted-foreground min-w-0 flex-1 truncate", title: subtitle, children: subtitle })), status && _jsx(StatusMark, { status: status })] }));
+}
+const ROW_CLASS = 'flex min-w-0 items-center gap-2 rounded-sm px-2 py-1.5 text-xs';
+function CardRowLine({ row }) {
+    const body = (_jsxs(_Fragment, { children: [_jsx("span", { className: "text-foreground min-w-0 truncate font-medium", title: row.title, children: row.title }), row.detail ? (_jsx("span", { className: "text-muted-foreground min-w-0 flex-1 truncate", title: row.detail, children: row.detail })) : (_jsx("span", { className: "flex-1" })), row.badge && (_jsx(Badge, { variant: badgeVariant(row.badge), size: "sm", className: "shrink-0", children: row.badge })), row.href && _jsx(CaretRightIcon, { "aria-hidden": true, className: "text-muted-foreground size-3 shrink-0" })] }));
+    return row.href ? (_jsx(UiLink, { href: row.href, className: cn(ROW_CLASS, 'hover:bg-muted/40 transition-colors'), children: body })) : (_jsx("div", { className: ROW_CLASS, children: body }));
+}
+function ChangeLine({ change }) {
+    const t = useTranslations('tools.kortixAction');
+    return (_jsxs("li", { className: ROW_CLASS, children: [_jsx("span", { className: "text-muted-foreground shrink-0", children: change.field }), change.before === null ? (_jsxs(_Fragment, { children: [_jsx(Badge, { variant: "new", size: "sm", className: "shrink-0", children: t('newSetting') }), _jsx("span", { className: "text-foreground min-w-0 truncate", title: change.after ?? '', children: change.after })] })) : change.after === null ? (_jsxs(_Fragment, { children: [_jsx("span", { className: "text-muted-foreground min-w-0 truncate line-through", title: change.before, children: change.before }), _jsx(Badge, { variant: "muted", size: "sm", className: "shrink-0", children: t('removedSetting') })] })) : (_jsxs(_Fragment, { children: [_jsx("span", { className: "text-muted-foreground min-w-0 truncate", title: change.before, children: change.before }), _jsx(ArrowRightIcon, { "aria-hidden": true, className: "text-muted-foreground size-3 shrink-0" }), _jsx("span", { className: "text-foreground min-w-0 truncate", title: change.after, children: change.after })] }))] }));
+}
+/** "Needs a permission", then who can grant it. The brand's refusal wording when the tool could not read them. */
+function DeniedNotice({ error }) {
+    const t = useTranslations('tools.kortixAction');
+    const grantors = error?.grantors ?? [];
+    return (_jsxs(ToolResultCard, { bodyClassName: "space-y-1.5 px-2 py-1.5 text-xs", children: [_jsxs("div", { className: "text-foreground flex items-center gap-1.5 font-medium", children: [_jsx(LockKeyIcon, { weight: "fill", "aria-hidden": true, className: "text-kortix-orange size-3.5 shrink-0" }), t('deniedTitle')] }), grantors.length > 0 ? (_jsxs("div", { className: "space-y-1", children: [_jsx("div", { className: "text-muted-foreground", children: t('grantors') }), _jsx("ul", { className: "space-y-0.5", children: grantors.map((grantor, index) => (_jsxs("li", { className: "flex min-w-0 items-center gap-1.5", children: [_jsx("span", { className: "text-foreground min-w-0 truncate", children: grantor.name }), grantor.role && (_jsxs(_Fragment, { children: [_jsx("span", { "aria-hidden": true, className: "text-muted-foreground shrink-0", children: "\u00B7" }), _jsx("span", { className: "text-muted-foreground shrink-0", children: grantor.role })] }))] }, `${grantor.name}-${index}`))) })] })) : (_jsx("p", { className: "text-muted-foreground", children: t('grantorsUnknown') }))] }));
+}
+/**
+ * The card's links. An absolute `https://` link (a connector sign-in) is the card's
+ * primary action and opens a new tab; in-app paths stay in the app.
+ */
+function CardLinks({ links }) {
+    const t = useTranslations('tools.kortixAction');
+    const indent = useToolIndent();
+    const external = links.filter((link) => link.external);
+    const internal = links.filter((link) => !link.external);
+    const internalButtons = internal.map((link) => (_jsx(Button, { asChild: true, variant: "outline", size: "xs", children: _jsx(UiLink, { href: link.href, children: link.label }) }, `${link.label}-${link.href}`)));
+    return (_jsxs("div", { className: cn('flex flex-wrap items-center gap-1.5', indent && 'mt-1.5', indent), children: [external.map((link) => (_jsx(Button, { asChild: true, size: "xs", children: _jsxs("a", { href: link.href, target: "_blank", rel: "noopener noreferrer", title: t('opensInNewTab'), children: [link.label, _jsx(ArrowSquareOutIcon, { "aria-hidden": true, className: "size-3 shrink-0" })] }) }, `${link.label}-${link.href}`))), internalButtons.length > 1 ? _jsx(ButtonGroup, { children: internalButtons }) : internalButtons] }));
+}
+function CardDetails({ raw }) {
+    const t = useTranslations('tools.kortixAction');
+    const indent = useToolIndent();
+    const text = useMemo(() => detailsText(raw), [raw]);
+    return (_jsx("div", { className: cn(indent && 'mt-1.5', indent), children: _jsx(FoldedSection, { label: t('showDetails'), children: _jsx(OutputBlock, { text: text }) }) }));
+}
+/** The trigger subtitle while the row is closed; open, the body says it in full. */
+function SettledTrigger({ title, subtitle, subtitleInBody, status, }) {
+    const open = useToolOpen();
+    return (_jsx(CardTrigger, { title: title, subtitle: open && subtitleInBody ? undefined : subtitle, live: false, status: status }));
+}
+export function KortixActionTool(props) {
+    const { call, defaultOpen, forceOpen, locked } = props;
+    const t = useTranslations('tools.kortixAction');
+    const tMulti = useTranslations('multiAgent.tools');
+    const running = useContext(ToolRunningContext);
+    const tool = kortixCardTool(call.name);
+    const platform = kortixPlatformTool(call.name);
+    const multi = multiAgentTool(call.name);
+    const status = partStatus(call);
+    const settled = status === 'completed' || status === 'error';
+    const raw = status === 'error' ? (partError(call) ?? '') : partRawOutput(call);
+    const result = useMemo(() => (settled ? parseKortixToolResult(raw, call.name) : null), [settled, raw, call.name]);
+    if (!tool || (settled && !result)) {
+        return _jsx(GenericTool, { call: call, defaultOpen: defaultOpen, forceOpen: forceOpen, locked: locked });
+    }
+    const ToolIcon = platform ? TOOL_META[platform].icon : MULTI_AGENT_ICON[multi];
+    const icon = _jsx(ToolIcon, { className: "size-4 shrink-0" });
+    if (!result) {
+        const title = platform
+            ? t(`running.${TOOL_META[platform].object}.${isReadAction(partInput(call).action) ? 'read' : 'change'}`)
+            : tMulti(`running.${runningKey(multi)}`);
+        return (_jsx(BasicTool, { icon: icon, trigger: _jsx(CardTrigger, { title: title, live: running }), defaultOpen: defaultOpen, forceOpen: forceOpen, locked: locked }));
+    }
+    const { card, error } = result;
+    const denied = card.status === 'denied';
+    const failure = card.status === 'error' && error && error.message && error.message !== card.title ? error.message : undefined;
+    // A multi-agent result draws its own body from `data`; the card's rows would say it twice.
+    const rich = multi && !denied ? multiAgentBody(multi, result) : null;
+    // `fail()` puts the error message in the subtitle, and a rich body says what
+    // the subtitle sums up: the open card shows it in full instead.
+    const subtitleInBody = denied || Boolean(rich) || (failure !== undefined && failure === card.subtitle);
+    const hasBody = denied || Boolean(failure) || Boolean(rich) || card.rows.length > 0 || card.changes.length > 0 || card.links.length > 0 || Boolean(raw);
+    // What the person must see or act on opens itself: a refusal, a change, a sign-in link.
+    const attention = denied || card.status === 'needs_you' || card.changes.length > 0 || card.links.some((link) => link.external);
+    return (
+    // The card names its own outcome (the status mark); the shared failure triangle would repeat it.
+    _jsx(ToolOutcomeContext.Provider, { value: "ok", children: _jsx(BasicTool, { icon: icon, trigger: _jsx(SettledTrigger, { title: card.title, subtitle: card.subtitle, subtitleInBody: subtitleInBody, status: card.status }), defaultOpen: defaultOpen, forceOpen: forceOpen || attention, locked: locked, children: hasBody ? (_jsxs(_Fragment, { children: [denied && _jsx(DeniedNotice, { error: error }), failure && (_jsx(ToolResultCard, { bodyClassName: "px-2 py-1.5", children: _jsx("p", { className: "text-muted-foreground text-xs wrap-break-word", children: failure }) })), rich, !rich && card.rows.length > 0 && (_jsx(ToolResultCard, { bodyClassName: "py-0.5", children: _jsx("ul", { children: card.rows.map((row, index) => (_jsx("li", { children: _jsx(CardRowLine, { row: row }) }, `${row.title}-${index}`))) }) })), card.changes.length > 0 && (_jsx(ToolResultCard, { bodyClassName: "py-0.5", children: _jsx("ul", { children: card.changes.map((change, index) => (_jsx(ChangeLine, { change: change }, `${change.field}-${index}`))) }) })), card.links.length > 0 && _jsx(CardLinks, { links: card.links }), raw && !rich && _jsx(CardDetails, { raw: raw })] })) : undefined }) }));
+}
+for (const name of KORTIX_PLATFORM_TOOLS)
+    ToolRegistry.register(name, KortixActionTool);
+// The multi-agent tools no older tool shares a name with. `task_create`, `task_list`,
+// `task_get` and `task_update` register in `multi-agent-tools.tsx`, beside the older tools.
+for (const name of ['send_message', 'list_agents', 'task_stop'])
+    ToolRegistry.register(name, KortixActionTool);

package/dist/session/tool/tools/kortix-tool-card.d.ts

@@ -0,0 +1,83 @@
+/**
+ * The My Kortix platform tools' result, parsed defensively.
+ *
+ * The shape is `KortixToolResult` in `packages/api-contract/src/kortix-tool-card.ts`.
+ * `@kortix/ui` does not depend on that package, so the types are mirrored here
+ * and every field is checked. A result that does not parse is `null`, and the
+ * call renders as the generic tool card instead of a half-drawn one.
+ */
+/** `KORTIX_PLATFORM_TOOL_NAMES` in `packages/api-contract/src/kortix-tool-card.ts`. */
+export declare const KORTIX_PLATFORM_TOOLS: readonly ["kortix_agents", "kortix_sessions", "kortix_schedules", "kortix_connectors", "kortix_people", "kortix_access", "kortix_usage", "kortix_change_requests", "kortix_memory"];
+export type KortixPlatformTool = (typeof KORTIX_PLATFORM_TOOLS)[number];
+/**
+ * The multi-agent tools (`packages/api-contract/src/multi-agent.ts`): the same
+ * `KortixToolResult`, with `data` = the contract object the card body draws.
+ * `task_create`, `task_list`, `task_get` and `task_update` are also the names of
+ * older plugin tools: `multi-agent-tools.tsx` tells the two apart by the output.
+ */
+export declare const MULTI_AGENT_TOOLS: readonly ["send_message", "list_agents", "task_create", "task_list", "task_get", "task_update", "task_stop"];
+export type MultiAgentTool = (typeof MULTI_AGENT_TOOLS)[number];
+/** Every tool whose result is a `KortixToolResult` card. */
+export type KortixCardTool = KortixPlatformTool | MultiAgentTool;
+export type KortixCardStatus = 'done' | 'running' | 'needs_you' | 'denied' | 'error';
+export interface KortixCardRow {
+    title: string;
+    detail?: string;
+    badge?: string;
+    /** In-app path (`/projects/…`). A row never links outside the app. */
+    href?: string;
+}
+/** A `before` of `null` is a new setting; an `after` of `null` is a removed one. */
+export interface KortixCardChange {
+    field: string;
+    before: string | null;
+    after: string | null;
+}
+export interface KortixCardLink {
+    label: string;
+    /** An in-app path, or an absolute `https://` URL (a connector sign-in link). */
+    href: string;
+    /** True for an absolute `https://` URL: it opens in a new tab and is the card's primary action. */
+    external: boolean;
+}
+export interface KortixToolCard {
+    title: string;
+    subtitle?: string;
+    status: KortixCardStatus;
+    rows: KortixCardRow[];
+    changes: KortixCardChange[];
+    links: KortixCardLink[];
+}
+export interface KortixGrantor {
+    name: string;
+    role: string;
+}
+export interface KortixToolError {
+    kind: 'denied' | 'not_found' | 'invalid' | 'failed';
+    message: string;
+    grantors: KortixGrantor[];
+}
+export interface KortixToolResult {
+    ok: boolean;
+    tool: KortixCardTool;
+    action: string;
+    card: KortixToolCard;
+    error?: KortixToolError;
+    /** What the model reads. Only the multi-agent card bodies draw it, each through its own defensive parser. */
+    data?: unknown;
+}
+/** The platform tool a call name names: `kortix_agents`, also as `kortix-agents` or `oc-kortix_agents`. */
+export declare function kortixPlatformTool(name: string): KortixPlatformTool | undefined;
+/** A multi-agent tool a call name names: `send_message`, also as `send-message` or `oc-send_message`. */
+export declare function multiAgentTool(name: string): MultiAgentTool | undefined;
+/** Any tool that answers with a `KortixToolResult` card. */
+export declare function kortixCardTool(name: string): KortixCardTool | undefined;
+/** An in-app path: one leading `/`, never `//` (a protocol-relative URL leaves the app). */
+export declare function inAppHref(value: unknown): string | undefined;
+/**
+ * The result in a platform call's output (or its error text, when the call threw
+ * it): one JSON object. `null` when the text is not that object. `callName` names
+ * the tool when the result leaves `tool` out.
+ */
+export declare function parseKortixToolResult(raw: string | undefined, callName?: string): KortixToolResult | null;
+export declare function isReadAction(action: unknown): boolean;

package/dist/session/tool/tools/kortix-tool-card.js

@@ -0,0 +1,186 @@
+/**
+ * The My Kortix platform tools' result, parsed defensively.
+ *
+ * The shape is `KortixToolResult` in `packages/api-contract/src/kortix-tool-card.ts`.
+ * `@kortix/ui` does not depend on that package, so the types are mirrored here
+ * and every field is checked. A result that does not parse is `null`, and the
+ * call renders as the generic tool card instead of a half-drawn one.
+ */
+/** `KORTIX_PLATFORM_TOOL_NAMES` in `packages/api-contract/src/kortix-tool-card.ts`. */
+export const KORTIX_PLATFORM_TOOLS = [
+    'kortix_agents',
+    'kortix_sessions',
+    'kortix_schedules',
+    'kortix_connectors',
+    'kortix_people',
+    'kortix_access',
+    'kortix_usage',
+    'kortix_change_requests',
+    'kortix_memory',
+];
+/**
+ * The multi-agent tools (`packages/api-contract/src/multi-agent.ts`): the same
+ * `KortixToolResult`, with `data` = the contract object the card body draws.
+ * `task_create`, `task_list`, `task_get` and `task_update` are also the names of
+ * older plugin tools: `multi-agent-tools.tsx` tells the two apart by the output.
+ */
+export const MULTI_AGENT_TOOLS = [
+    'send_message',
+    'list_agents',
+    'task_create',
+    'task_list',
+    'task_get',
+    'task_update',
+    'task_stop',
+];
+const STATUSES = new Set(['done', 'running', 'needs_you', 'denied', 'error']);
+const ERROR_KINDS = new Set(['denied', 'not_found', 'invalid', 'failed']);
+/** A card holds a short list; a longer one is the tool's mistake, not a page to render. */
+const MAX_ITEMS = 50;
+const isObject = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
+const text = (value) => typeof value === 'string' && value.trim() ? value.trim() : undefined;
+/** The platform tool a call name names: `kortix_agents`, also as `kortix-agents` or `oc-kortix_agents`. */
+export function kortixPlatformTool(name) {
+    const normalized = name.replace(/^oc[-_]/, '').replace(/-/g, '_');
+    return KORTIX_PLATFORM_TOOLS.includes(normalized)
+        ? normalized
+        : undefined;
+}
+/** A multi-agent tool a call name names: `send_message`, also as `send-message` or `oc-send_message`. */
+export function multiAgentTool(name) {
+    const normalized = name.replace(/^oc[-_]/, '').replace(/-/g, '_');
+    return MULTI_AGENT_TOOLS.includes(normalized) ? normalized : undefined;
+}
+/** Any tool that answers with a `KortixToolResult` card. */
+export function kortixCardTool(name) {
+    return kortixPlatformTool(name) ?? multiAgentTool(name);
+}
+/** An in-app path: one leading `/`, never `//` (a protocol-relative URL leaves the app). */
+export function inAppHref(value) {
+    const href = text(value);
+    return href && href.startsWith('/') && !href.startsWith('//') && !href.includes('\\') ? href : undefined;
+}
+function externalHref(value) {
+    const href = text(value);
+    if (!href)
+        return undefined;
+    try {
+        return new URL(href).protocol === 'https:' ? href : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function list(value, item) {
+    if (!Array.isArray(value))
+        return [];
+    const out = [];
+    for (const entry of value.slice(0, MAX_ITEMS)) {
+        const parsed = item(entry);
+        if (parsed !== undefined)
+            out.push(parsed);
+    }
+    return out;
+}
+function row(entry) {
+    if (!isObject(entry))
+        return undefined;
+    const title = text(entry.title);
+    if (!title)
+        return undefined;
+    const detail = text(entry.detail);
+    const badge = text(entry.badge);
+    const href = inAppHref(entry.href);
+    return { title, ...(detail ? { detail } : {}), ...(badge ? { badge } : {}), ...(href ? { href } : {}) };
+}
+const setting = (value) => value === null ? null : typeof value === 'string' ? value : typeof value === 'number' || typeof value === 'boolean' ? String(value) : undefined;
+function change(entry) {
+    if (!isObject(entry))
+        return undefined;
+    const field = text(entry.field);
+    const before = setting(entry.before);
+    const after = setting(entry.after);
+    if (!field || before === undefined || after === undefined || (before === null && after === null))
+        return undefined;
+    return { field, before, after };
+}
+function link(entry) {
+    if (!isObject(entry))
+        return undefined;
+    const label = text(entry.label);
+    if (!label)
+        return undefined;
+    const internal = inAppHref(entry.href);
+    if (internal)
+        return { label, href: internal, external: false };
+    const external = externalHref(entry.href);
+    return external ? { label, href: external, external: true } : undefined;
+}
+function grantor(entry) {
+    if (!isObject(entry))
+        return undefined;
+    const name = text(entry.name);
+    return name ? { name, role: text(entry.role) ?? '' } : undefined;
+}
+function toolError(value) {
+    if (!isObject(value) || !ERROR_KINDS.has(value.kind))
+        return undefined;
+    return {
+        kind: value.kind,
+        message: text(value.message) ?? '',
+        grantors: list(value.grantors, grantor),
+    };
+}
+/**
+ * The result in a platform call's output (or its error text, when the call threw
+ * it): one JSON object. `null` when the text is not that object. `callName` names
+ * the tool when the result leaves `tool` out.
+ */
+export function parseKortixToolResult(raw, callName) {
+    const source = raw?.trim();
+    if (!source || !source.startsWith('{'))
+        return null;
+    let value;
+    try {
+        value = JSON.parse(source);
+    }
+    catch {
+        return null;
+    }
+    if (!isObject(value) || typeof value.ok !== 'boolean' || !isObject(value.card))
+        return null;
+    const tool = typeof value.tool === 'string' ? kortixCardTool(value.tool) : callName !== undefined ? kortixCardTool(callName) : undefined;
+    const title = text(value.card.title);
+    if (!tool || !title)
+        return null;
+    const error = toolError(value.error);
+    // A refusal reads as one whatever status the card names: the error kind is the fact.
+    const status = error?.kind === 'denied'
+        ? 'denied'
+        : STATUSES.has(value.card.status)
+            ? value.card.status
+            : value.ok
+                ? 'done'
+                : 'error';
+    const subtitle = text(value.card.subtitle);
+    return {
+        ok: value.ok,
+        tool,
+        action: text(value.action) ?? '',
+        card: {
+            title,
+            ...(subtitle ? { subtitle } : {}),
+            status,
+            rows: list(value.card.rows, row),
+            changes: list(value.card.changes, change),
+            links: list(value.card.links, link),
+        },
+        ...(error ? { error } : {}),
+        ...(value.data !== undefined ? { data: value.data } : {}),
+    };
+}
+/** The actions that only read; every other action changes something (the SDK narration uses the same set). */
+const READ_ACTIONS = new Set(['', 'list', 'get', 'read', 'find', 'show', 'view', 'events', 'search', 'check', 'status', 'pending', 'who']);
+export function isReadAction(action) {
+    return READ_ACTIONS.has(typeof action === 'string' ? action : '');
+}

package/dist/session/tool/tools/multi-agent-tool-bodies.d.ts

@@ -0,0 +1,11 @@
+import { type Icon } from '@phosphor-icons/react';
+import { type ReactNode } from 'react';
+import type { KortixToolResult, MultiAgentTool } from './kortix-tool-card.js';
+export declare const MULTI_AGENT_ICON: Record<MultiAgentTool, Icon>;
+/** The key under `multiAgent.tools.running` for a call still in flight. */
+export declare function runningKey(tool: MultiAgentTool): 'sending' | 'checkingAgents' | 'checkingTasks' | 'updatingTasks' | 'stopping';
+/**
+ * The body a multi-agent result draws from its `data`, or `null` when the data
+ * does not parse or holds nothing to show (the card's own rows draw instead).
+ */
+export declare function multiAgentBody(tool: MultiAgentTool, result: KortixToolResult): ReactNode | null;

package/dist/session/tool/tools/multi-agent-tool-bodies.js

@@ -0,0 +1,141 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { Badge } from '../../../primitives/badge.js';
+import { Button } from '../../../primitives/button.js';
+import { Hint } from '../../../primitives/hint.js';
+import { ToolResultCard } from '../shared/result-card.js';
+import { SubagentDialog } from '../../agents/subagent-view.js';
+import { useTranslations } from '../../../i18n/index.js';
+import { AgentStateMark } from '../../agents/agent-state-mark.js';
+import { subagentTitle } from '../../agents/agent-model.js';
+import { agentDisplayName } from '../../../internal/components/agent-mark.js';
+import { ArrowSquareOutIcon, ArrowUpRightIcon, ListChecksIcon, PaperPlaneTiltIcon, StopCircleIcon, UsersThreeIcon, } from '@phosphor-icons/react';
+import { useState } from 'react';
+import { parsePeerSend, parseReachable, parseStoppedChild, parseTasks, } from './multi-agent-tool-data.js';
+export const MULTI_AGENT_ICON = {
+    send_message: PaperPlaneTiltIcon,
+    list_agents: UsersThreeIcon,
+    task_create: ListChecksIcon,
+    task_list: ListChecksIcon,
+    task_get: ListChecksIcon,
+    task_update: ListChecksIcon,
+    task_stop: StopCircleIcon,
+};
+/** The key under `multiAgent.tools.running` for a call still in flight. */
+export function runningKey(tool) {
+    switch (tool) {
+        case 'send_message':
+            return 'sending';
+        case 'list_agents':
+            return 'checkingAgents';
+        case 'task_list':
+        case 'task_get':
+            return 'checkingTasks';
+        case 'task_create':
+        case 'task_update':
+            return 'updatingTasks';
+        case 'task_stop':
+            return 'stopping';
+    }
+}
+const PEER_VARIANT = {
+    delivered: 'success',
+    held: 'warning',
+    refused: 'warning',
+    denied: 'warning',
+    expired: 'muted',
+    dropped: 'muted',
+};
+const TASK_VARIANT = {
+    pending: 'muted',
+    in_progress: 'info',
+    completed: 'success',
+};
+const STATE_KEY = {
+    working: 'working',
+    needs_input: 'needsInput',
+    idle: 'idle',
+    completed: 'completed',
+    failed: 'failed',
+    stopped: 'stopped',
+};
+const TASK_KEY = {
+    pending: 'pending',
+    in_progress: 'inProgress',
+    completed: 'completed',
+};
+const ROW_CLASS = 'flex min-w-0 items-center gap-2 rounded-sm px-2 py-1.5 text-xs';
+function PeerSendBody({ send }) {
+    const t = useTranslations('multiAgent.tools');
+    const preview = send.summary ?? send.message;
+    return (_jsxs(ToolResultCard, { bodyClassName: "space-y-1 px-2 py-1.5 text-xs", children: [_jsxs("div", { className: "flex min-w-0 items-center gap-1.5", "data-testid": "peer-send-body", children: [send.to && (_jsxs(_Fragment, { children: [_jsx("span", { className: "text-muted-foreground shrink-0", children: t('to') }), _jsxs("span", { className: "text-foreground min-w-0 truncate font-medium", children: ["@", send.to] })] })), _jsx("span", { className: "flex-1" }), _jsx(Badge, { variant: PEER_VARIANT[send.status], size: "sm", className: "shrink-0", children: t(`peerStatus.${send.status}`) })] }), preview && _jsx("p", { className: "text-muted-foreground line-clamp-3 whitespace-pre-wrap wrap-break-word", children: preview }), send.note && send.status !== 'delivered' && _jsx("p", { className: "text-muted-foreground", children: send.note })] }));
+}
+/** Row actions: shown on hover and on keyboard focus, always on a touch screen (as in the agents line). */
+const ROW_ACTIONS = 'flex shrink-0 items-center pr-1 opacity-0 group-hover/row:opacity-100 group-focus-within/row:opacity-100 [@media(hover:none)]:opacity-100';
+/**
+ * One agent `list_agents` found, drawn as the agents line draws it: the state
+ * mark, the handle and its state, then one muted line with what it works on
+ * and how it relates to this session. The row opens the agent's session.
+ */
+function AgentLine({ agent }) {
+    const t = useTranslations('multiAgent.tools');
+    const tStrip = useTranslations('multiAgent.strip');
+    const [viewing, setViewing] = useState(false);
+    const title = agent.title ? subagentTitle(agent.title) || null : null;
+    const relation = t.has(`relation.${agent.relation}`) ? t(`relation.${agent.relation}`) : null;
+    const meta = [
+        title ?? (agent.agentName ? tStrip('runsAs', { agent: agentDisplayName(agent.agentName) }) : null),
+        relation,
+        agent.canReceive ? null : t('cannotReceive'),
+    ]
+        .filter(Boolean)
+        .join(' · ');
+    const name = `@${agent.handle}`;
+    return (_jsxs("li", { className: "group/row hover:bg-hover focus-within:bg-hover flex min-w-0 items-center gap-1 rounded-sm", "data-agent-row": agent.sessionId, children: [_jsxs("button", { type: "button", onClick: () => setViewing(true), className: "flex min-w-0 flex-1 cursor-pointer items-center gap-2 py-1.5 pl-2 text-left text-xs outline-none", children: [agent.state ? _jsx(AgentStateMark, { state: agent.state }) : _jsx("span", { "aria-hidden": true, className: "size-3 shrink-0" }), _jsxs("span", { className: "min-w-0 flex-1", children: [_jsxs("span", { className: "flex min-w-0 items-baseline gap-2", children: [_jsx("span", { className: "text-foreground min-w-0 truncate font-medium", children: name }), agent.state && (_jsx("span", { className: "text-muted-foreground shrink-0", children: t(`state.${STATE_KEY[agent.state]}`) }))] }), meta && (_jsx("span", { className: "text-muted-foreground block truncate", title: meta, children: meta }))] })] }), _jsx("div", { className: ROW_ACTIONS, children: _jsx(Hint, { label: tStrip('openAgent', { name }), side: "top", children: _jsx(Button, { type: "button", variant: "ghost", size: "icon-xs", "aria-label": tStrip('openAgent', { name }), onClick: () => setViewing(true), className: "text-muted-foreground hover:text-foreground", children: _jsx(ArrowUpRightIcon, { className: "size-3.5 shrink-0" }) }) }) }), _jsx(SubagentDialog, { open: viewing, onOpenChange: setViewing, sessionId: agent.sessionId, title: name })] }));
+}
+function TaskLine({ task }) {
+    const t = useTranslations('multiAgent.tools');
+    return (_jsxs("div", { className: ROW_CLASS, "data-task-seq": task.seq, children: [_jsxs("span", { className: "text-muted-foreground shrink-0 tabular-nums", children: ["#", task.seq] }), _jsx("span", { className: "text-foreground min-w-0 flex-1 truncate", title: task.subject, children: task.subject }), task.blockedBy.length > 0 && task.blocked && (_jsx("span", { className: "text-muted-foreground shrink-0", children: t('blockedBy', { tasks: task.blockedBy.map((n) => `#${n}`).join(', ') }) })), task.owner && (_jsxs(Badge, { variant: "outline", size: "sm", className: "shrink-0", children: ["@", task.owner] })), _jsx(Badge, { variant: TASK_VARIANT[task.status], size: "sm", className: "shrink-0", children: t(`taskStatus.${TASK_KEY[task.status]}`) })] }));
+}
+/** `task_stop`: the agent it stopped, whether it was still running, and a way into its session. */
+function StoppedChildBody({ child }) {
+    const t = useTranslations('multiAgent.tools');
+    const [viewing, setViewing] = useState(false);
+    const name = child.handle ? `@${child.handle}` : (child.title ?? child.sessionId.slice(0, 8));
+    const detail = child.handle ? child.title : null;
+    return (_jsxs(ToolResultCard, { bodyClassName: "py-0.5", children: [_jsxs("div", { className: ROW_CLASS, "data-testid": "stopped-child-body", children: [_jsx("span", { className: "text-foreground shrink-0 font-medium", children: name }), detail ? (_jsxs(_Fragment, { children: [_jsx("span", { "aria-hidden": true, className: "text-muted-foreground shrink-0", children: "\u00B7" }), _jsx("span", { className: "text-muted-foreground min-w-0 flex-1 truncate", title: detail, children: detail })] })) : (_jsx("span", { className: "flex-1" })), _jsx(Badge, { variant: "muted", size: "sm", className: "shrink-0", children: child.stopped ? t('stopped') : t('alreadyEnded') }), _jsx(Hint, { label: t('openSession'), children: _jsx(Button, { type: "button", variant: "ghost", size: "icon-xs", "aria-label": t('openSession'), onClick: () => setViewing(true), className: "text-muted-foreground hover:text-foreground shrink-0", children: _jsx(ArrowSquareOutIcon, { className: "size-3.5 shrink-0" }) }) })] }), _jsx(SubagentDialog, { open: viewing, onOpenChange: setViewing, sessionId: child.sessionId, title: name })] }));
+}
+function RowList({ children }) {
+    return (_jsx(ToolResultCard, { bodyClassName: "py-0.5", children: _jsx("ul", { children: children }) }));
+}
+/**
+ * The body a multi-agent result draws from its `data`, or `null` when the data
+ * does not parse or holds nothing to show (the card's own rows draw instead).
+ */
+export function multiAgentBody(tool, result) {
+    switch (tool) {
+        case 'send_message': {
+            const send = parsePeerSend(result.data);
+            return send ? _jsx(PeerSendBody, { send: send }) : null;
+        }
+        case 'list_agents': {
+            const agents = parseReachable(result.data);
+            if (!agents || agents.length === 0)
+                return null;
+            return (_jsx(ToolResultCard, { bodyClassName: "p-1", children: _jsx("ul", { children: agents.map((agent) => (_jsx(AgentLine, { agent: agent }, agent.sessionId))) }) }));
+        }
+        case 'task_create':
+        case 'task_list':
+        case 'task_get':
+        case 'task_update': {
+            const tasks = parseTasks(result.data);
+            if (!tasks || tasks.length === 0)
+                return null;
+            return (_jsx(RowList, { children: tasks.map((task) => (_jsx("li", { children: _jsx(TaskLine, { task: task }) }, task.seq))) }));
+        }
+        case 'task_stop': {
+            const child = parseStoppedChild(result.data);
+            return child ? _jsx(StoppedChildBody, { child: child }) : null;
+        }
+    }
+}

package/dist/session/tool/tools/multi-agent-tool-data.d.ts

@@ -0,0 +1,63 @@
+/**
+ * The `data` of a multi-agent tool result, parsed defensively for its card body.
+ *
+ * The shapes are in `packages/api-contract/src/multi-agent.ts` (`PeerMessageSendResult`,
+ * `ReachableAgents`, `SessionTask`). `@kortix/ui` does not depend on that package, so
+ * only the fields a card draws are mirrored here, and every one is checked. A value
+ * that does not parse is `null`: the card then draws its own rows, as every platform
+ * card does.
+ */
+export type PeerSendStatus = 'delivered' | 'held' | 'refused' | 'denied' | 'expired' | 'dropped';
+export type AgentBoardState = 'working' | 'needs_input' | 'idle' | 'completed' | 'failed' | 'stopped';
+export type TeamTaskStatus = 'pending' | 'in_progress' | 'completed';
+export interface PeerSendSummary {
+    status: PeerSendStatus;
+    /** The receiver's handle, without `@`. */
+    to: string | null;
+    /** The message text the sender wrote. */
+    message: string | null;
+    summary: string | null;
+    /** The sentence the API wrote for the sending agent ("Not sent: reviewer refuses messages."). */
+    note: string | null;
+}
+export interface ReachableAgentRow {
+    handle: string;
+    sessionId: string;
+    title: string | null;
+    agentName: string | null;
+    relation: string;
+    state: AgentBoardState | null;
+    canReceive: boolean;
+}
+/** `task_stop`: `StopChildResult` (apps/kortix-sandbox-agent-server/src/harness/pi/cloud-subagent.ts). */
+export interface StoppedChild {
+    sessionId: string;
+    handle: string | null;
+    title: string | null;
+    /** False: it had already ended, and nothing was stopped. */
+    stopped: boolean;
+}
+export interface TeamTaskRow {
+    seq: number;
+    subject: string;
+    status: TeamTaskStatus;
+    owner: string | null;
+    blockedBy: number[];
+    blocked: boolean;
+}
+/** `send_message`: `PeerMessageSendResult`. */
+export declare function parsePeerSend(data: unknown): PeerSendSummary | null;
+/** `list_agents`: `ReachableAgents` (the asking session itself is left out). */
+export declare function parseReachable(data: unknown): ReachableAgentRow[] | null;
+/** `task_*`: one `SessionTask`, or `{ tasks: SessionTask[] }`. */
+export declare function parseTasks(data: unknown): TeamTaskRow[] | null;
+/** `task_stop`: the child it stopped, or null. */
+export declare function parseStoppedChild(data: unknown): StoppedChild | null;
+/**
+ * True when a running call's input has the shape of pi's `task_*` tools
+ * (apps/kortix-sandbox-agent-server/src/harness/pi/extensions/team-tasks.ts):
+ * `task_create { subject, … }`, `task_get { seq }`, `task_update { seq, … }`.
+ * The older plugin tools that share these names take neither. pi's
+ * `task_list {}` has no input to tell: its output decides once it settles.
+ */
+export declare function looksLikeTeamTaskInput(input: unknown): boolean;