@athenaintel/react 0.18.0 → 0.19.0

package/dist/tools/index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * The generic tool card and the primitives dedicated tool cards are built
+ * from, as a lean entry point for hosts that render their own thread and
+ * register their own tool UIs (Olympus). The full `@athenaintel/react` entry
+ * re-exports everything here alongside the SDK's built-in tool UI registry.
+ *
+ * Published as the `@athenaintel/react/tools` sub-path.
+ */
+export { clearAutoOpenedAssets, ToolFallback, ToolFallbackArgs, ToolFallbackContent, type ToolFallbackContext, ToolFallbackError, ToolFallbackNotice, type ToolFallbackOptions, type ToolFallbackProps, ToolFallbackResult, ToolFallbackRoot, type ToolFallbackRootProps, ToolFallbackTrigger, type ToolFallbackTriggerProps, } from "./tool-fallback";
+export { CopyToolSpecButton, ExpandableSection, formatToolName, normalizeResult, ToolCard, type ToolStatus, truncate, tryParseJson, } from "./primitives";
+export { TOOL_ICONS, toolIcon } from "./tool-icons";
+export { NestedPtcComponentsProvider, NestedPtcMessages, type NestedPtcMessagesProps, useNestedPtcComponents, } from "./NestedPtcMessages";
+export { InstallPackageToolUI } from "./misc-tool-uis";
+export { classifyToolResult, describeToolArgs, getToolDisplayMeta, isToolResultSuccess, resultMessage, toolActiveLabel, toolCompletedLabel, type ToolDisplayMeta, type ToolResultClassification, } from "@athenaintel/agent-runtime";

package/dist/tools/misc-tool-uis.d.ts

@@ -0,0 +1,2 @@
+import type { ToolCallMessagePartComponent } from "@assistant-ui/react";
+export declare const InstallPackageToolUI: ToolCallMessagePartComponent;

package/dist/tools/primitives.d.ts

@@ -0,0 +1,41 @@
+/**
+ * The shared building blocks every SDK tool card is made of — the card shell
+ * (`ToolCard`), the collapsible details section, and the result/text helpers.
+ * Kept apart from the tool UI registry so a tool UI module can use them
+ * without importing the registry that imports it back.
+ */
+import { type ElementType, type ReactNode } from "react";
+import { formatToolName } from "@athenaintel/agent-runtime";
+export { formatToolName };
+/** Parse JSON text into a record, or `null` when it is not one. */
+export declare function tryParseJson(text: string): Record<string, unknown> | null;
+/** Parse a tool result (handles nested `.result`, string-encoded JSON) into a record. */
+export declare function normalizeResult(result: unknown): Record<string, unknown> | null;
+/** Truncate a string with an ellipsis. */
+export declare function truncate(text: string, max: number): string;
+export type ToolStatus = "running" | "complete" | "incomplete" | "requires-action";
+export declare function ToolCard({ icon: Icon, status, title, subtitle, toolName, badge, error, children, args, result, }: {
+    icon: ElementType;
+    status: ToolStatus;
+    title: string;
+    subtitle?: string;
+    toolName?: string;
+    badge?: string;
+    error?: string | null;
+    children?: ReactNode;
+    args?: Record<string, unknown>;
+    result?: unknown;
+}): import("react/jsx-runtime").JSX.Element;
+/** Copies `{ tool_name, arguments, result }` as JSON — the tool spec a support ticket needs. */
+export declare function CopyToolSpecButton({ toolName, args, argsText, result, className, }: {
+    toolName: string;
+    args?: Record<string, unknown>;
+    argsText?: string;
+    result?: unknown;
+    className?: string;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function ExpandableSection({ label, children, defaultOpen, }: {
+    label?: string;
+    children: ReactNode;
+    defaultOpen?: boolean;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/tools/tool-fallback.d.ts

@@ -1,5 +1,54 @@
+import { type ComponentProps, type ElementType, type ReactNode } from "react";
 import { type ToolCallMessagePartStatus, type ToolCallMessagePartComponent } from "@assistant-ui/react";
+import { type ToolResultClassification } from "@athenaintel/agent-runtime";
 import { Collapsible, CollapsibleContent, CollapsibleTrigger } from "../ui/collapsible";
+import { type AssetType } from "../assets/asset-panel-store";
+type ToolCallPartProps = ComponentProps<ToolCallMessagePartComponent>;
+/** What a host slot sees about the call it decorates. */
+export interface ToolFallbackContext {
+    toolName: string;
+    args: Record<string, unknown> | undefined;
+    argsText: string | undefined;
+    result: unknown;
+    status: ToolCallMessagePartStatus | undefined;
+    classification: ToolResultClassification;
+    /** An `asset_…` id found on the result or the arguments, if any. */
+    assetId: string | null;
+}
+export interface ToolFallbackOptions {
+    /** Row title for a settled call (defaults to the registry's `displayName`). */
+    displayName?: string;
+    /** Row title while running (defaults to the registry's `activeLabel`). */
+    activeLabel?: string;
+    /** Row icon (defaults to the registry's icon for the tool). */
+    icon?: ElementType;
+    /**
+     * Hide arguments that are internal identifiers (`asset_id`, `catalog_id`,
+     * `workspace_id`, `user_id`, and any `asset_…`-shaped value) from the
+     * disclosure. On by default — they mean nothing to a reader; a surface that
+     * needs them for review (an approval) turns it off.
+     */
+    hideInternalIdArgs?: boolean;
+    /** An extra control in the header row, outside the toggle (an Excel range jump, a thumbnail). */
+    extraAction?: ReactNode | ((context: ToolFallbackContext) => ReactNode);
+    /** A notice under the header (a prompt-injection warning, a policy note). */
+    notice?: ReactNode;
+    /** Replace the default raw result disclosure with a host renderer (Genie SQL, a table). */
+    renderResult?: (context: ToolFallbackContext) => ReactNode;
+    /** Where "Open" / the asset link goes; defaults to the SDK asset panel. */
+    onOpenAsset?: (assetId: string, meta: {
+        name?: string;
+        type: AssetType;
+    }) => void;
+    /** Extra content in the expanded body (a screenshot, a preview). */
+    children?: ReactNode;
+    /** Start expanded. */
+    defaultOpen?: boolean;
+    className?: string;
+    /** Extra attributes on the card element (`data-testid`, `data-tool-name`). */
+    rootProps?: Omit<ComponentProps<"div">, "className" | "children"> & Record<`data-${string}`, string | undefined>;
+}
+export type ToolFallbackProps = ToolCallPartProps & ToolFallbackOptions;
 export declare function clearAutoOpenedAssets(): void;
 export type ToolFallbackRootProps = Omit<React.ComponentProps<typeof Collapsible>, "open" | "onOpenChange"> & {
     open?: boolean;
@@ -7,28 +56,51 @@ export type ToolFallbackRootProps = Omit<React.ComponentProps<typeof Collapsible
     defaultOpen?: boolean;
 };
 declare function ToolFallbackRoot({ className, open: controlledOpen, onOpenChange: controlledOnOpenChange, defaultOpen, children, ...props }: ToolFallbackRootProps): import("react/jsx-runtime").JSX.Element;
-declare function ToolFallbackTrigger({ toolName, argsText, result, status, className, ...props }: React.ComponentProps<typeof CollapsibleTrigger> & {
+export interface ToolFallbackTriggerProps extends Omit<React.ComponentProps<typeof CollapsibleTrigger>, "children"> {
     toolName: string;
     argsText?: string;
     result?: unknown;
     status?: ToolCallMessagePartStatus;
-}): import("react/jsx-runtime").JSX.Element;
+    isError?: boolean;
+    /** Pre-computed classification (else derived from status/result/isError). */
+    classification?: ToolResultClassification;
+    displayName?: string;
+    activeLabel?: string;
+    icon?: ElementType;
+}
+declare function ToolFallbackTrigger({ toolName, argsText, result, status, isError, classification: givenClassification, displayName, activeLabel, icon, className, ...props }: ToolFallbackTriggerProps): import("react/jsx-runtime").JSX.Element;
 declare function ToolFallbackContent({ className, children, ...props }: React.ComponentProps<typeof CollapsibleContent>): import("react/jsx-runtime").JSX.Element;
-declare function ToolFallbackArgs({ argsText, className, ...props }: React.ComponentProps<"div"> & {
+declare function ToolFallbackArgs({ argsText, hideInternalIdArgs, className, ...props }: React.ComponentProps<"div"> & {
     argsText?: string;
+    hideInternalIdArgs?: boolean;
 }): import("react/jsx-runtime").JSX.Element | null;
-declare function ToolFallbackResult({ result, className, ...props }: React.ComponentProps<"div"> & {
+declare function ToolFallbackResult({ result, classification, className, ...props }: React.ComponentProps<"div"> & {
     result?: unknown;
+    classification?: ToolResultClassification;
 }): import("react/jsx-runtime").JSX.Element | null;
+/**
+ * The failure a status-incomplete call carries, for the expanded body. The
+ * always-visible failure line is {@link ToolFallbackNotice}; this repeats the
+ * raw error text with the details.
+ */
 declare function ToolFallbackError({ status, className, ...props }: React.ComponentProps<"div"> & {
     status?: ToolCallMessagePartStatus;
 }): import("react/jsx-runtime").JSX.Element | null;
-declare const ToolFallback: ToolCallMessagePartComponent & {
+/**
+ * The always-visible line under the header for a failed or paused call — the
+ * failure's code and message, or the runtime's pause notice — so a reader
+ * never has to expand a card to learn a step went wrong.
+ */
+declare function ToolFallbackNotice({ classification, className, ...props }: React.ComponentProps<"div"> & {
+    classification: ToolResultClassification;
+}): import("react/jsx-runtime").JSX.Element | null;
+declare const ToolFallback: ToolCallMessagePartComponent & ((props: ToolFallbackProps) => ReactNode) & {
     Root: typeof ToolFallbackRoot;
     Trigger: typeof ToolFallbackTrigger;
     Content: typeof ToolFallbackContent;
     Args: typeof ToolFallbackArgs;
     Result: typeof ToolFallbackResult;
     Error: typeof ToolFallbackError;
+    Notice: typeof ToolFallbackNotice;
 };
-export { ToolFallback, ToolFallbackRoot, ToolFallbackTrigger, ToolFallbackContent, ToolFallbackArgs, ToolFallbackResult, ToolFallbackError, };
+export { ToolFallback, ToolFallbackRoot, ToolFallbackTrigger, ToolFallbackContent, ToolFallbackArgs, ToolFallbackResult, ToolFallbackError, ToolFallbackNotice, };

package/dist/tools/tool-icons.d.ts

@@ -0,0 +1,10 @@
+/**
+ * The icon component behind each `ToolIconKey` of the shared tool display
+ * registry (`@athenaintel/agent-runtime`'s `tool-metadata`). The registry is
+ * React-free so mobile can share it; this is the web half.
+ */
+import type { ToolIconKey } from "@athenaintel/agent-runtime";
+import { type LucideIcon } from "lucide-react";
+export declare const TOOL_ICONS: Record<ToolIconKey, LucideIcon>;
+/** The icon component for a registry icon key. */
+export declare function toolIcon(key: ToolIconKey): LucideIcon;

package/dist/tools/tool-uis.d.ts

@@ -1,27 +1,6 @@
 import type { ToolCallMessagePartComponent } from "@assistant-ui/react";
 import { type AssetType } from "../assets/asset-panel-store";
-export declare function normalizeResult(result: unknown): Record<string, unknown> | null;
-export declare function truncate(text: string, max: number): string;
-/** Format a tool name like `create_new_sheet` → "Create New Sheet" */
-export declare function formatToolName(name: string): string;
-export type ToolStatus = "running" | "complete" | "incomplete" | "requires-action";
-export declare function ToolCard({ icon: Icon, status, title, subtitle, toolName, badge, error, children, args, result, }: {
-    icon: React.ElementType;
-    status: ToolStatus;
-    title: string;
-    subtitle?: string;
-    toolName?: string;
-    badge?: string;
-    error?: string | null;
-    children?: React.ReactNode;
-    args?: Record<string, unknown>;
-    result?: unknown;
-}): import("react/jsx-runtime").JSX.Element;
-export declare function ExpandableSection({ label, children, defaultOpen, }: {
-    label?: string;
-    children: React.ReactNode;
-    defaultOpen?: boolean;
-}): import("react/jsx-runtime").JSX.Element;
+export { ExpandableSection, formatToolName, normalizeResult, ToolCard, type ToolStatus, truncate, } from "./primitives";
 export declare const WebSearchToolUI: ToolCallMessagePartComponent;
 export declare const BrowseToolUI: ToolCallMessagePartComponent;
 /** Short human date for an email row: "Aug 24" this year, "Aug 24, 2025"
@@ -85,4 +64,3 @@ export declare const CaptureMomentToolUI: ToolCallMessagePartComponent;
 export declare const CaptureSlideScreenshotToolUI: ToolCallMessagePartComponent;
 export declare const OpenBrowserToolUI: ToolCallMessagePartComponent;
 export declare const TOOL_UI_REGISTRY: Record<string, ToolCallMessagePartComponent>;
-export {};

package/dist/tools.cjs

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const toolFallback = require("./tool-fallback-kfhpJQZa.cjs");
+const miscToolUis = require("./misc-tool-uis-B2e0Okkn.cjs");
+require("./trash-2-B5OaNAL7.cjs");
+require("react");
+require("@assistant-ui/tap");
+require("statewire");
+require("@assistant-ui/react-statewire");
+require("@assistant-ui/store");
+require("@assistant-ui/core");
+exports.CopyToolSpecButton = toolFallback.CopyToolSpecButton;
+exports.ExpandableSection = toolFallback.ExpandableSection;
+exports.NestedPtcComponentsProvider = toolFallback.NestedPtcComponentsProvider;
+exports.NestedPtcMessages = toolFallback.NestedPtcMessages;
+exports.TOOL_ICONS = toolFallback.TOOL_ICONS;
+exports.ToolCard = toolFallback.ToolCard;
+exports.ToolFallback = toolFallback.ToolFallback;
+exports.ToolFallbackArgs = toolFallback.ToolFallbackArgs;
+exports.ToolFallbackContent = toolFallback.ToolFallbackContent;
+exports.ToolFallbackError = toolFallback.ToolFallbackError;
+exports.ToolFallbackNotice = toolFallback.ToolFallbackNotice;
+exports.ToolFallbackResult = toolFallback.ToolFallbackResult;
+exports.ToolFallbackRoot = toolFallback.ToolFallbackRoot;
+exports.ToolFallbackTrigger = toolFallback.ToolFallbackTrigger;
+exports.classifyToolResult = toolFallback.classifyToolResult;
+exports.clearAutoOpenedAssets = toolFallback.clearAutoOpenedAssets;
+exports.describeToolArgs = toolFallback.describeToolArgs;
+exports.formatToolName = toolFallback.formatToolName;
+exports.getToolDisplayMeta = toolFallback.getToolDisplayMeta;
+exports.isToolResultSuccess = toolFallback.isToolResultSuccess;
+exports.normalizeResult = toolFallback.normalizeResult;
+exports.resultMessage = toolFallback.resultMessage;
+exports.toolActiveLabel = toolFallback.toolActiveLabel;
+exports.toolCompletedLabel = toolFallback.toolCompletedLabel;
+exports.toolIcon = toolFallback.toolIcon;
+exports.truncate = toolFallback.truncate;
+exports.tryParseJson = toolFallback.tryParseJson;
+exports.useNestedPtcComponents = toolFallback.useNestedPtcComponents;
+exports.InstallPackageToolUI = miscToolUis.InstallPackageToolUI;
+//# sourceMappingURL=tools.cjs.map

package/dist/tools.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"tools.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/tools.js

@@ -0,0 +1,41 @@
+import { C, E, N, a, T, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, t, s, u, v, w, x } from "./tool-fallback-DkQ3DLkn.js";
+import { I } from "./misc-tool-uis-gAiQw0Yl.js";
+import "./trash-2-CCwSURL-.js";
+import "react";
+import "@assistant-ui/tap";
+import "statewire";
+import "@assistant-ui/react-statewire";
+import "@assistant-ui/store";
+import "@assistant-ui/core";
+export {
+  C as CopyToolSpecButton,
+  E as ExpandableSection,
+  I as InstallPackageToolUI,
+  N as NestedPtcComponentsProvider,
+  a as NestedPtcMessages,
+  T as TOOL_ICONS,
+  b as ToolCard,
+  c as ToolFallback,
+  d as ToolFallbackArgs,
+  e as ToolFallbackContent,
+  f as ToolFallbackError,
+  g as ToolFallbackNotice,
+  h as ToolFallbackResult,
+  i as ToolFallbackRoot,
+  j as ToolFallbackTrigger,
+  k as classifyToolResult,
+  l as clearAutoOpenedAssets,
+  m as describeToolArgs,
+  n as formatToolName,
+  o as getToolDisplayMeta,
+  p as isToolResultSuccess,
+  q as normalizeResult,
+  r as resultMessage,
+  t as toolActiveLabel,
+  s as toolCompletedLabel,
+  u as toolIcon,
+  v as truncate,
+  w as tryParseJson,
+  x as useNestedPtcComponents
+};
+//# sourceMappingURL=tools.js.map

package/dist/tools.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tools.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;"}