@deepseek-ai/dsh-client-ui-tool 0.0.1-rc.1

package/lib/index.js

@@ -0,0 +1,6 @@
+//#region lib/types/index.js
+/** Host loader entry for the browser-only Tool UI plugin. */
+/** Provides no host-side behavior. */
+function apply() {}
+//#endregion
+export { apply };

package/lib/invariant.js

@@ -0,0 +1,23 @@
+//#region lib/types/invariant.js
+/**
+* Package-owned invariant companion for `@deepseek-ai/dsh-client-ui-tool`.
+* @module @deepseek-ai/dsh-client-ui-tool/invariant
+*/
+const PACKAGE_NAME = "@deepseek-ai/dsh-client-ui-tool";
+/** Cordis companion plugin name. */
+const name = "client-ui-tool-invariant";
+/** Service required before the companion can reserve package ownership. */
+const inject = ["invariants"];
+/**
+* No runtime invariant: Tool composition is browser-only and contributes no
+* events or cross-plugin mutable state; slot ownership is checked by ui-slots.
+*/
+const install = () => {};
+/**
+* Register this package's invariant companion.
+* @param ctx - Cordis context carrying the invariant service.
+* @returns the installed registration's disposer after setup succeeds.
+*/
+const apply = (ctx) => Promise.resolve(ctx.invariants.register(PACKAGE_NAME, install));
+//#endregion
+export { apply, inject, name };

package/lib/types/client/apply.d.ts

@@ -0,0 +1,10 @@
+/** Register the Tool call tree, details renderer, and built-in atomic views. */
+import type { ClientContext } from '@deepseek-ai/dsh-client-runtime/client';
+/** Required service: the slot registry that owns both Tool render seats. */
+export declare const inject: string[];
+/**
+ * Mount the whole-Tool renderers and built-in atomic Tool registrations.
+ * @param ctx - Client root context.
+ */
+export declare function apply(ctx: ClientContext): void;
+//# sourceMappingURL=apply.d.ts.map

package/lib/types/client/contract/slots.d.ts

@@ -0,0 +1,35 @@
+/** Tool UI slot declarations and their composed component props. */
+import type { PropsLocale, PropsRenderSlots, PropsRuntime } from '@deepseek-ai/dsh-client-ui-slots';
+import type { ToolCallBlock } from '@deepseek-ai/dsh-client-runtime/client';
+declare module '@deepseek-ai/dsh-client-ui-slots' {
+    interface SlotMap {
+        /** Keyed atomic Tool call view, dispatched by the wire Tool name. */
+        'tool.call.toolview': {
+            kind: 'keyed';
+            scope: 'session';
+            owner: ToolCallOwnerProps;
+        };
+    }
+}
+/** Standard owner currency supplied to every atomic Tool view. */
+export interface ToolCallOwnerProps {
+    /** Tool call identity, stable across running and settled forms. */
+    callId: string;
+    /** Wire Tool name and keyed dispatch value. */
+    toolName: string;
+    /** Frozen running call or settled result node. */
+    block: ToolCallBlock;
+    /** Session workspace root for relative summaries. */
+    cwd?: string | undefined;
+    /** Open a Tool argument path through the Host. */
+    openFile: (path: string) => void;
+    /** Inspect this call in the trajectory view when available. */
+    inspect?: (() => void) | undefined;
+}
+/** Full props of a registered atomic Tool view. */
+export type ToolCallViewProps = PropsRuntime<'tool.call.toolview'>;
+/** Full props of the Tool call-tree renderer registered as a `tool-call` Chat Node. */
+export type ToolTreeProps = PropsRuntime<'conversation.chat.node', 'tool-call'> & PropsRenderSlots<'tool.call.toolview'> & PropsLocale<'conversation'>;
+/** Full props of the selected Tool output renderer in the details panel. */
+export type ToolDetailsProps = PropsRuntime<'conversation.details.tool'> & PropsLocale<'conversation'>;
+//# sourceMappingURL=slots.d.ts.map

package/lib/types/client/index.d.ts

@@ -0,0 +1,4 @@
+/** Browser Tool plugin: whole-call composition and keyed atomic Tool views. */
+export { apply, inject } from './apply.ts';
+export type { ToolCallOwnerProps, ToolCallViewProps, ToolDetailsProps, ToolTreeProps } from './contract/slots.ts';
+//# sourceMappingURL=index.d.ts.map

package/lib/types/client/locale.d.ts

@@ -0,0 +1,3 @@
+/** Locale namespace supplied by the conversation owner to Tool renderers. */
+export declare const CONVERSATION_NS = "conversation";
+//# sourceMappingURL=locale.d.ts.map

package/lib/types/client/tool/ToolCallTree.d.ts

@@ -0,0 +1,9 @@
+import type { ToolTreeProps } from '../contract/slots.ts';
+/**
+ * Render one root Tool call and its recursive children through the same
+ * atomic keyed dispatch.
+ * @param props - whole-Tool owner data and the Tool-owned child-slot share.
+ * @returns the Tool call tree.
+ */
+export declare function ToolCallTree({ renderSlot, node, selectedCallId, cwd, openFile, inspectCall, t, }: ToolTreeProps): import("react").JSX.Element;
+//# sourceMappingURL=ToolCallTree.d.ts.map

package/lib/types/client/tool/ToolDetails.d.ts

@@ -0,0 +1,16 @@
+import type { ToolDetailsProps } from '../contract/slots.ts';
+/** Pure details-body inputs; framework session seats stay at the slot boundary. */
+interface ToolDetailsContentProps {
+    block: ToolDetailsProps['block'];
+    cwd?: ToolDetailsProps['cwd'];
+    t: ToolDetailsProps['t'];
+}
+/**
+ * Render the selected Tool call's structured output when its presentation
+ * intent is known, otherwise preserve the flattened result text.
+ * @param props - selected call slice, workspace root, and locale seat.
+ * @returns the details output body.
+ */
+export declare function ToolDetails({ block, cwd, t }: ToolDetailsContentProps): import("react").JSX.Element;
+export {};
+//# sourceMappingURL=ToolDetails.d.ts.map

package/lib/types/client/tool/components/ToolRow.d.ts

@@ -0,0 +1,79 @@
+import { type ReactNode } from 'react';
+import type { WebBlockProps } from '@deepseek-ai/dsh-client-ui-primitives';
+import type { TranslateNS } from '@deepseek-ai/dsh-client-ui-slots';
+import { type DiffCardModel } from '../models/diff-card-model.ts';
+import { type ReadCardModel } from '../models/read-card-model.ts';
+import { type SearchCardModel } from '../models/search-card-model.ts';
+import { type TerminalCardModel } from '../models/terminal-card-model.ts';
+import type { ToolRowState, ToolRowVariant } from '../models/tool-call-model.ts';
+export interface ToolRowProps {
+    /** The render site's conversation locale seat (terminal/code body copy). */
+    t: TranslateNS<'conversation'>;
+    variant: ToolRowVariant;
+    /** Wire tool name for tool-owned styling layered over the generic variant. */
+    toolName?: string | undefined;
+    /** Leading 16px tool icon, shown while collapsed and not running/failed. */
+    icon: ReactNode;
+    title: string;
+    summary: string;
+    /**
+     * Trailing summary fragment rendered outside the ellipsized summary text, so
+     * a narrow row clips the summary before this. For a fragment whose whole
+     * value is surviving that clip — the todo row's parallel-active count.
+     * null/absent = the summary is the whole collapsed content. Dropped on an
+     * error row, whose collapsed summary is the failure line instead.
+     */
+    summarySuffix?: string | null | undefined;
+    /** Expanded-body input text; null = no input section. */
+    body: string | null;
+    /** Flattened result text for the expanded Output section; null/absent = no output section. */
+    output?: string | null | undefined;
+    /** Error first line shown as the collapsed summary on an error row; null/absent = keep `summary`. */
+    errorSummary?: string | null | undefined;
+    /**
+     * Terminal-card material for a call whose render intent is a terminal card
+     * (derived by `terminalCardModel`); it replaces the text sections when
+     * present. A call carries at most one card kind, so the card props below are
+     * mutually exclusive.
+     */
+    terminal?: TerminalCardModel | null | undefined;
+    /**
+     * Diff-card material for a call whose render intent is a diff card (derived by
+     * `diffCardModel`); it replaces the text body when present, the same way
+     * `terminal` does.
+     */
+    diff?: DiffCardModel | null | undefined;
+    /**
+     * Read-card material for a call whose render intent is a read card (derived by
+     * `readCardModel`); it replaces the text body with the file's line-numbered,
+     * syntax-highlighted window when present.
+     */
+    read?: ReadCardModel | null | undefined;
+    /**
+     * Search-card material for a call whose render intent is a search card
+     * (derived by `searchCardModel`); it replaces the text body with grouped
+     * matches or a path list when present.
+     */
+    search?: SearchCardModel | null | undefined;
+    /**
+     * Web-card material for a call whose render intent is a web card (derived by
+     * `webCardModel`); it replaces the text body with the retrieval's citation
+     * list or fetched-source card when present.
+     */
+    web?: WebBlockProps | null | undefined;
+    state: ToolRowState;
+    /**
+     * Filesystem path from tool args; when set with onOpenFile, the summary
+     * renders as a hover-underline link that opens the host default app.
+     */
+    filePath?: string | undefined;
+    /** Open the path with the host OS default application (already cwd-resolved). */
+    onOpenFile?: ((path: string) => void) | undefined;
+    /**
+     * Jump to this call in the trajectory view: a hover-revealed Inspect pill
+     * over the expanded body. Absent = no affordance.
+     */
+    inspect?: (() => void) | undefined;
+}
+export declare function ToolRow({ t, variant, toolName, icon, title, summary, summarySuffix, body, output, errorSummary, terminal, diff, read, search, web, state, filePath, onOpenFile, inspect, }: ToolRowProps): import("react").JSX.Element;
+//# sourceMappingURL=ToolRow.d.ts.map

package/lib/types/client/tool/models/diff-card-model.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Pure derivation of the diff-card props from a frozen call slice: the
+ * `card:'diff'` render intent the write/edit tools declare arrives on the
+ * snapshot as `callView`/`resultView`, and this is the one place that turns
+ * that pair into what {@link DiffBlock} draws. Both conversation render sites
+ * (the chat tool row's expanded body and the details panel's Output section)
+ * call this, so the hunks they show are derived once.
+ * @module
+ */
+import type { DiffBlockProps } from '@deepseek-ai/dsh-client-ui-primitives';
+import type { ToolCallBlock } from './tool-call-model.ts';
+/**
+ * Diff-body lines the chat row shows before collapsing the middle — half the
+ * primitive's own default, which the details panel keeps. A chat row is a
+ * summary surface inside the message flow: the flow must stay scannable across
+ * many calls, while the details panel is the single-call reading surface. The
+ * same split {@link CHAT_TERMINAL_MAX_LINES} draws for a terminal card, so the
+ * two card kinds cap a long body at the same place in the flow. A design
+ * constant of this UI's row geometry, not a deployment choice.
+ */
+export declare const CHAT_DIFF_MAX_LINES = 8;
+/**
+ * The {@link DiffBlock} props this derivation owns. Picked off the primitive's
+ * props so the two stay in step; `maxLines`/`className` belong to each render
+ * site.
+ */
+export interface DiffCardModel {
+    /**
+     * The props {@link DiffBlock} draws. Held as a nested object so a render site
+     * spreads exactly the primitive's own surface and can never leak a
+     * neighbouring field into it.
+     */
+    card: Pick<DiffBlockProps, 'diffs'>;
+}
+/**
+ * Derive the diff-card props for a tool call, or null when this call is not a
+ * diff card and belongs on the generic path.
+ *
+ * The result side is authoritative once the call settles: the write/edit tools
+ * return the applied contextual hunks there (an edit's real before/after, a
+ * create's whole-file diff), which replace the call-time diff derived from the
+ * arguments alone. While the call is still running only the call side exists,
+ * so a running write/edit shows its intended change. Null is the documented
+ * generic-card default and covers every non-diff card — including a `card`
+ * value this UI version does not know, which arrives over the wire and cannot
+ * be trusted to be one of the compiled variants — and a settled call whose
+ * result view is generic (how write/edit keep their execution errors on the
+ * generic path).
+ *
+ * This derivation consumes only `diffs`; the render intent's `title` field is
+ * deliberately dropped. The row supplies its own title (`Edit`/`Write · path`
+ * from the args), which outranks the view's `title`. A tool that names its own
+ * diff header therefore does not surface that text on the Web row.
+ * @param block - RunningToolCall or ToolResultNode off the snapshot caches.
+ * @returns the diff-card props, or null for the generic path.
+ */
+export declare function diffCardModel(block: ToolCallBlock): DiffCardModel | null;
+//# sourceMappingURL=diff-card-model.d.ts.map

package/lib/types/client/tool/models/read-card-model.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Pure derivation of the read-card props from a frozen call slice: the
+ * `card:'read'` render intent the read tool declares arrives on the snapshot as
+ * the settled result node's `resultView`, and this is the one place that turns
+ * it into what {@link ReadBlock} draws. Both conversation render sites (the chat
+ * tool row's resident body and the details panel's Output section) call this, so
+ * the path, lines, total, and language they show are derived once.
+ *
+ * The read card is result-side only ([read card note](../../../../../../.agents/notes/implemented/feature/2026-07-30-web-read-card.md)):
+ * a call carries no file content until `execute` returns, so the pending call
+ * stays a generic card (`kind: 'read'`). A running read therefore has no read
+ * card, and this returns null for it — the row keeps its args-derived summary
+ * until the result arrives.
+ * @module
+ */
+import type { ReadBlockProps } from '@deepseek-ai/dsh-client-ui-primitives';
+import { type ToolCallBlock } from './tool-call-model.ts';
+/**
+ * Content lines the chat row's resident read body shows before collapsing the
+ * middle — half the primitive's own default, which the details panel keeps. A
+ * chat row is a summary surface inside the message flow: the flow must stay
+ * scannable across many calls, while the details panel is the single-call
+ * reading surface. A design constant of this UI's row geometry, not a
+ * deployment choice, so it is fixed here rather than a plugin Config field. The
+ * same split [`CHAT_TERMINAL_MAX_LINES`](./terminal-card-model.ts) draws for
+ * terminal output.
+ */
+export declare const CHAT_READ_MAX_LINES = 8;
+/**
+ * The {@link ReadBlock} props this derivation owns. Picked off the primitive's
+ * props so the two stay in step; `maxLines`/`className` belong to each render
+ * site.
+ */
+export type ReadCardModel = Pick<ReadBlockProps, 'label' | 'lines' | 'totalLines' | 'lang'>;
+/**
+ * Derive the read-card props for a tool call, or null when this call is not a
+ * read card and belongs on the generic path.
+ *
+ * The read card is result-side only, so only a settled call whose result view
+ * declares `card:'read'` produces one. Every other case is null — the
+ * documented generic-card default:
+ *
+ * - A running call: it has no result view yet, and a read carries no content at
+ *   call time.
+ * - A settled call whose result view is not a read card — including a `card`
+ *   value this UI version does not know, which arrives over the wire and cannot
+ *   be trusted to be one of the compiled variants, and the read tool's own
+ *   generic fallback for an error result or a non-envelope body.
+ *
+ * The label is the read view's `title` when the tool supplied one (the
+ * presentation contract's replacement-title rule), otherwise the file path
+ * relativized to the session workspace so a workspace-rooted absolute path
+ * displays the same short form the row summary shows.
+ * @param block - RunningToolCall or ToolResultNode off the snapshot caches.
+ * @param sessionCwd - the session workspace root; a workspace-rooted absolute
+ *   path label displays relative to it. Absent leaves the path as authored.
+ * @returns the read-card props, or null for the generic path.
+ */
+export declare function readCardModel(block: ToolCallBlock, sessionCwd?: string): ReadCardModel | null;
+//# sourceMappingURL=read-card-model.d.ts.map

package/lib/types/client/tool/models/search-card-model.d.ts

@@ -0,0 +1,89 @@
+/**
+ * Pure derivation of the search-card props from a frozen call slice: the
+ * `card:'search'` render intent the `grep` and `glob` tools declare arrives on
+ * the snapshot as `resultView`, and this is the one place that turns it into
+ * what {@link SearchBlock} draws. Both conversation render sites (the chat tool
+ * row's resident body and the details panel's Output section) call this, so the
+ * grouped matches or the path list they show are derived once.
+ *
+ * The search card is result-time only: a search call has no matches or paths
+ * before `execute`, so its pending state stays a `GenericCallView`
+ * ({@link module:@deepseek-ai/dsh-tools/src/presentation}). This derivation
+ * therefore reads only `resultView` and returns null for a still-running call,
+ * unlike the terminal card whose call view carries the command before
+ * execution.
+ *
+ * A capped result also carries a recovery locator (grep/glob's `Full … stored
+ * at …` footer) in the raw `tool/result` content, not in the structured
+ * matches/paths the view carries. Since both render sites replace that raw
+ * result with the card, this derivation surfaces the block's own result text as
+ * {@link SearchCardModel.recovery} so the one path to the dropped rows is not
+ * lost.
+ * @module
+ */
+import type { SearchBlockProps } from '@deepseek-ai/dsh-client-ui-primitives';
+import type { ToolCallBlock } from './tool-call-model.ts';
+/**
+ * Distributive `Omit`: a plain `Omit<A | B, K>` keeps only the keys common to
+ * both members, which would drop the `files`/`paths` discriminated fields.
+ * Distributing over the naked type parameter `T` preserves each shape.
+ */
+type DistributiveOmit<T, K extends keyof T> = T extends unknown ? Omit<T, K> : never;
+/** The {@link SearchBlockProps} union minus each render site's own fields. */
+type SearchBlockModelProps = DistributiveOmit<SearchBlockProps, 'maxLines' | 'className'>;
+/**
+ * Result rows the chat row's resident search body shows before collapsing the
+ * middle — half the primitive's own default, which the details panel keeps. A
+ * chat row is a summary surface inside the message flow: the flow must stay
+ * scannable across many calls, while the details panel is the single-call
+ * reading surface. A design constant of this UI's row geometry, not a
+ * deployment choice, so it is fixed here rather than a plugin Config field.
+ */
+export declare const CHAT_SEARCH_MAX_LINES = 8;
+/**
+ * The {@link SearchBlock} props this derivation owns. Held as a nested object
+ * (`card`) so a render site spreads exactly the primitive's own surface and can
+ * never leak a neighbouring field into it. `maxLines`/`className` belong to each
+ * render site.
+ */
+export interface SearchCardModel {
+    /**
+     * The props {@link SearchBlock} draws, minus each render site's own
+     * `maxLines`/`className`.
+     */
+    card: SearchBlockModelProps;
+    /**
+     * The result view's replacement title, which the presentation contract lets a
+     * search tool set at settle time. Absent when the presenter supplied none; a
+     * row then keeps its args-derived summary.
+     */
+    title: string | undefined;
+    /**
+     * The raw `tool/result` text, flattened, surfaced only when the search was
+     * capped. The card renders the retained matches or paths, but the recovery
+     * locator a capped result carries — grep/glob's `Full … stored at: <locator>`
+     * footer, the one way to reach the rows the cap dropped — lives only in the raw
+     * result text, which the card replaces. A UI that shows the card would
+     * otherwise lose it. Absent when the result was not capped (the card holds
+     * every result) or the block carries no text.
+     */
+    recovery: string | undefined;
+}
+/**
+ * Derive the search-card props for a tool call, or null when this call is not a
+ * search card and belongs on the generic path.
+ *
+ * Only the result side matters: the search card carries no call-time state, so
+ * a still-running call (no result view) is null, as is a settled call whose
+ * result view is not a search card — including a `card` value this UI version
+ * does not know, which arrives over the wire and cannot be trusted to be one of
+ * the compiled variants, a `card: 'search'` view whose `shape` is neither
+ * `matches` nor `paths` (equally untrusted wire data), and a generic result a
+ * `grep`/`glob` failure or nested `run_code` dispatch produces (its text keeps
+ * the generic path).
+ * @param block - RunningToolCall or ToolResultNode off the snapshot caches.
+ * @returns the search-card props, or null for the generic path.
+ */
+export declare function searchCardModel(block: ToolCallBlock): SearchCardModel | null;
+export {};
+//# sourceMappingURL=search-card-model.d.ts.map

package/lib/types/client/tool/models/terminal-card-model.d.ts

@@ -0,0 +1,71 @@
+import type { TerminalBlockLabels, TerminalBlockProps } from '@deepseek-ai/dsh-client-ui-primitives';
+import type { TranslateNS } from '@deepseek-ai/dsh-client-ui-slots';
+import type { ToolCallBlock } from './tool-call-model.ts';
+/**
+ * Build the TerminalBlock display copy from the conversation locale seat —
+ * the one place the primitive's label surface pairs with this package's
+ * dictionary, shared by every terminal render site (chat row, bash row,
+ * details panel).
+ * @param t - the render site's conversation locale seat.
+ * @returns the full label set for {@link TerminalBlockProps}'s `labels`.
+ */
+export declare function terminalBlockLabels(t: TranslateNS<'conversation'>): TerminalBlockLabels;
+/**
+ * The {@link TerminalBlock} props this derivation owns. Picked off the
+ * primitive's props so the two stay in step; `home` is absent because the web
+ * client has no home path for the session host (a cwd renders as its last
+ * path segment), and `maxLines`/`className` belong to each render site.
+ */
+export interface TerminalCardModel {
+    /**
+     * The props {@link TerminalBlock} draws. Held as a nested object so a render
+     * site spreads exactly the primitive's own surface and can never leak a
+     * neighbouring field into it.
+     */
+    card: Pick<TerminalBlockProps, 'command' | 'cwd' | 'output' | 'exitCode' | 'signal' | 'running'>;
+    /**
+     * The call view's model-authored description, which the contract defines as
+     * rendering ABOVE the card (the card itself has no description slot). Absent
+     * when the presenter supplied none, or when the window dropped the call side;
+     * a row then keeps its args-derived summary.
+     */
+    description: string | undefined;
+}
+/**
+ * True when a settled terminal card reports a failing exit — a non-zero code
+ * or a terminating signal. The bash tool settles a failing command as a
+ * completed call (`isError` stays false: the exit status is result data), so
+ * this is the collapsed row's only failure signal; without it the red exit
+ * pill would be visible only after expanding the card.
+ * @param model - a derived terminal card.
+ * @returns whether the card's exit status is a failure.
+ */
+export declare function terminalFailed(model: TerminalCardModel): boolean;
+/**
+ * Derive the terminal-card props for a tool call, or null when this call is
+ * not a terminal card and belongs on the generic path.
+ *
+ * The call side supplies the command and its working directory; the result
+ * side supplies the captured output and exit status. Three cases produce
+ * null, all of them the documented generic-card default:
+ *
+ * - Neither side declares `card:'terminal'` — including a `card` value this
+ *   UI version does not know, which arrives over the wire and therefore
+ *   cannot be trusted to be one of the compiled variants.
+ * - A settled call whose result view is not a terminal card: the result
+ *   presentation decides how the settled call renders, and the bash tool
+ *   returns a generic fenced card for an execution error or a background
+ *   start, whose text and error styling the generic path preserves.
+ *
+ * Window truncation can drop the call head from a settled result (see
+ * `ToolResultNode.call`/`callView` in dsh-client-runtime), leaving a terminal
+ * result with no call side. That still renders: the command falls back to the
+ * result view's replacement title, then to an empty command (the prompt line
+ * draws bare), and the prompt shows no cwd.
+ * @param block - RunningToolCall or ToolResultNode off the snapshot caches.
+ * @param sessionCwd - the session workspace root, which resolves an omitted or
+ *   relative view cwd (see {@link resolveTerminalCwd}); absent leaves both unresolved.
+ * @returns the terminal-card props, or null for the generic path.
+ */
+export declare function terminalCardModel(block: ToolCallBlock, sessionCwd?: string): TerminalCardModel | null;
+//# sourceMappingURL=terminal-card-model.d.ts.map

package/lib/types/client/tool/models/tool-call-model.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Pure row-model derivation for tool summary rows: variant classification,
+ * one-line summary, expanded-body text, and flattened result output from the
+ * frozen call slice. Input material comes from the call ARGUMENTS; output and
+ * error material from the settled result node. A call whose render intent is
+ * a terminal card gets its expanded body from the views instead, through
+ * `terminalCardModel` in terminal-card-model.ts.
+ */
+import type { ToolCallBlock, ToolResultNode } from '@deepseek-ai/dsh-client-runtime/client';
+export type { ToolCallBlock } from '@deepseek-ai/dsh-client-runtime/client';
+/** Tool-call row variants selected by the generic atomic renderer. */
+export type ToolRowVariant = 'search' | 'read' | 'bash' | 'write' | 'edit' | 'code' | 'others';
+/** Row state semantic; colors self-supplied via StateDot (design gives none). */
+export type ToolRowState = 'running' | 'ok' | 'error' | 'stopped';
+/** Figma row titles per variant (design literals, not translatable copy). */
+export declare const VARIANT_TITLES: Record<ToolRowVariant, string>;
+/**
+ * Classify a tool name into its row variant.
+ * @param toolName - wire tool name.
+ * @returns matching variant, others when unknown.
+ */
+export declare function classifyTool(toolName: string): ToolRowVariant;
+/** Everything ToolRow needs, derived once from the frozen slice. */
+export interface ToolRowModel {
+    variant: ToolRowVariant;
+    title: string;
+    summary: string;
+    /**
+     * Filesystem path from args (`path` / `file_path`) when the row is a file
+     * tool; absent for URL reads and non-file tools. The chat view resolves
+     * relative values against the session cwd before opening.
+     */
+    filePath: string | undefined;
+    /** Expanded-body input text (pretty args); null = no input section. */
+    body: string | null;
+    /** Flattened result text ({@link resultText}); null while running or when the result carries no text. */
+    output: string | null;
+    /** First line of the result text on an error row; null for every other state. */
+    errorSummary: string | null;
+    state: ToolRowState;
+}
+/**
+ * Flatten a settled result's content blocks to display text: text blocks
+ * verbatim, other block shapes as pretty JSON. Empty content on a failed call
+ * falls back to the structured error's `name: code` line.
+ * @param node - the settled result node.
+ * @returns the flattened result text (may be empty).
+ */
+export declare function resultText(node: ToolResultNode): string;
+/**
+ * Strip the workspace root from a workspace-rooted absolute path (display only).
+ * @param text - the path to shorten.
+ * @param cwd - session workspace root; absent or empty leaves the path unchanged.
+ * @returns the path relative to the workspace root, or unchanged when it is not rooted there.
+ */
+export declare function relativizeToCwd(text: string, cwd: string | undefined): string;
+/**
+ * Derive the full row model from a frozen call slice.
+ * @param toolName - wire tool name (dispatch-supplied; survives windowless results).
+ * @param block - RunningToolCall or ToolResultNode off the snapshot caches.
+ * @param cwd - session workspace root; workspace-rooted path summaries display relative to it.
+ * @returns the row model.
+ */
+export declare function toolRowModel(toolName: string, block: ToolCallBlock, cwd?: string): ToolRowModel;
+//# sourceMappingURL=tool-call-model.d.ts.map

package/lib/types/client/tool/models/web-card-model.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Pure derivation of the web-card props from a frozen call slice: the
+ * `card:'web'` render intent the `web_search`/`web_fetch` tools declare at
+ * result time arrives on the snapshot as `resultView`, and this is the one
+ * place that turns it into what {@link WebBlock} draws. Both conversation
+ * render sites (the chat tool row's resident/expanded body and the details
+ * panel's Output section) call this, so the sources and fetch summary they
+ * show are derived once.
+ *
+ * The web card is result-only by contract: those tools keep a generic pending
+ * call view, so there is nothing to derive while the call is still running and
+ * a running call always takes the generic path.
+ * @module
+ */
+import type { WebBlockProps } from '@deepseek-ai/dsh-client-ui-primitives';
+import type { ToolCallBlock } from './tool-call-model.ts';
+/**
+ * Derive the web-card props for a tool call, or null when this call is not a
+ * web card and belongs on the generic path.
+ *
+ * The result side supplies the whole card: the sources and answer for a
+ * `search`, the URL and status for a `fetch`. Cases producing null, all of
+ * them the documented generic-card default:
+ *
+ * - A running call (no `resultView` yet): the web tools keep a generic pending
+ *   card, so nothing web-shaped exists until the call settles.
+ * - A settled call whose result view is not a web card — including a `card`
+ *   value this UI version does not know, which arrives over the wire and so
+ *   cannot be trusted to be one of the compiled variants, and a generic result
+ *   view (a web tool's error path returns the generic card, whose text the
+ *   generic path preserves).
+ * - A web card whose `kind` this UI version does not know (a newer host's
+ *   value): the wire cannot be trusted to be `search` or `fetch`, so it takes
+ *   the generic path rather than rendering as a malformed fetch.
+ * @param block - RunningToolCall or ToolResultNode off the snapshot caches.
+ * @returns the web-card props, or null for the generic path.
+ */
+export declare function webCardModel(block: ToolCallBlock): WebBlockProps | null;
+//# sourceMappingURL=web-card-model.d.ts.map

package/lib/types/client/tool/toolviews/GenericToolCard.d.ts

@@ -0,0 +1,7 @@
+import type { ToolCallOwnerProps, ToolTreeProps } from '../../contract/slots.ts';
+/** Card props: the owner payload plus the render site's locale seat (plain prop). */
+export interface GenericToolCardProps extends ToolCallOwnerProps {
+    t: ToolTreeProps['t'];
+}
+export declare function GenericToolCard({ toolName, block, cwd, openFile, inspect, t }: GenericToolCardProps): import("react").JSX.Element;
+//# sourceMappingURL=GenericToolCard.d.ts.map

package/lib/types/client/tool/toolviews/ask-question-row.d.ts

@@ -0,0 +1,23 @@
+import type { Context } from '@deepseek-ai/cordis';
+import type { PropsLocale } from '@deepseek-ai/dsh-client-ui-slots';
+import type { ToolCallViewProps } from '../../contract/slots.ts';
+/** Full row props: the toolview runtime share plus the standard locale seat. */
+type AskQuestionRowProps = ToolCallViewProps & PropsLocale<'conversation'>;
+/** One-line question-interaction row (the whole row toggles the call's
+ *  Input/Output sections, ToolRow's unified expand). */
+export declare function AskQuestionRow({ toolName, block, inspect, t }: AskQuestionRowProps): import("react").JSX.Element;
+/**
+ * The ask-question row as a plain registrant plugin following the chat
+ * toolview declaration across independent activation and reload lifetimes.
+ */
+export declare const askQuestionToolview: {
+    name: string;
+    inject: string[];
+    /**
+     * Register the ask-question row into the Tool-owned keyed view slot.
+     * @param ctx - registrant context (disposal rides ctx.effect inside slots.register).
+     */
+    apply(ctx: Context): void;
+};
+export {};
+//# sourceMappingURL=ask-question-row.d.ts.map

package/lib/types/client/tool/toolviews/bash-sample.d.ts

@@ -0,0 +1,26 @@
+import type { Context } from '@deepseek-ai/cordis';
+import type { PropsLocale } from '@deepseek-ai/dsh-client-ui-slots';
+import type { ToolCallViewProps } from '../../contract/slots.ts';
+/** Bash row props: the toolview runtime share plus the standard locale seat. */
+type BashRowProps = ToolCallViewProps & PropsLocale<'conversation'>;
+/**
+ * Bash row: icon + Bash · {description} in the shared ToolRow chrome, the
+ * whole row toggling the command's terminal or generic error card (ToolRow's unified
+ * expand interaction, replicated locally per the registrant posture).
+ */
+export declare function BashRow({ toolName, block, sessionId, useSessions, inspect, t }: BashRowProps): import("react").JSX.Element;
+/**
+ * The sample as a plain registrant plugin. Slot injection follows the chat
+ * toolview declaration across independent activation and reload lifetimes.
+ */
+export declare const bashToolviewSample: {
+    name: string;
+    inject: string[];
+    /**
+     * Register the bash row into the Tool-owned keyed view slot.
+     * @param ctx - registrant context (disposal rides ctx.effect inside slots.register).
+     */
+    apply(ctx: Context): void;
+};
+export {};
+//# sourceMappingURL=bash-sample.d.ts.map