@deepseek-ai/dsh-client-ui-tool 0.1.1-rc.2 → 0.1.2-alpha.2

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

@@ -1,5 +1,6 @@
-import type { ClientContext } from '@deepseek-ai/dsh-client-runtime/client';
-/** Required services: the slot registry and the Host description used for POSIX `~`. */
+/** Register the Tool call tree, details renderer, and built-in atomic views. */
+import type { Context as ClientContext } from '@deepseek-ai/cordis';
+/** Required services: the slot registry and the Remote face carrying the Host home used for POSIX `~`. */
 export declare const inject: string[];
 /**
  * Mount the whole-Tool renderers and built-in atomic Tool registrations.

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

@@ -1,7 +1,7 @@
 /** Tool UI slot declarations and their composed component props. */
-import type { HostDescriptionSource } from '@deepseek-ai/dsh-client-connection/client';
-import type { InjectFace, PropsLocale, PropsRenderSlots, PropsRuntime } from '@deepseek-ai/dsh-client-ui-slots';
-import type { ToolCallBlock } from '@deepseek-ai/dsh-client-runtime/client';
+import type { HostObservable, InjectFace, PropsLocale, PropsRenderSlots, PropsRuntime } from '@deepseek-ai/dsh-client-ui-slots';
+import type { RemoteHostFacts } from '@deepseek-ai/dsh-api-remotes/client';
+import type { ToolCallBlock } from '@deepseek-ai/dsh-client-ui-chat/client';
 declare module '@deepseek-ai/dsh-client-ui-slots' {
     interface SlotMap {
         /**
@@ -45,14 +45,19 @@ export interface ToolCallOwnerProps {
 /** Full props of a registered atomic Tool view. */
 export type ToolCallViewProps = PropsRuntime<'tool.call.toolview'>;
 /** Injected Host description for POSIX home-path display. */
-export type ToolHostDescriptionInjected = {
+export type ToolHostInfoInjected = {
     hooks: {
-        /** Current generation's Host description, bound by the slot renderer. */
-        hostDescription: HostDescriptionSource;
+        /**
+         * Fixed Host facts, reached through a hook rather than injected as values:
+         * the renderer memoizes an entry's inject result for the registration's
+         * lifetime, so facts read there would freeze at whatever the first render
+         * saw. Select the field the view needs (`info => info.home`).
+         */
+        hostInfo: HostObservable<RemoteHostFacts>;
     };
 };
 /** 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'> & InjectFace<ToolHostDescriptionInjected>;
+export type ToolTreeProps = PropsRuntime<'conversation.chat.node', 'tool-call'> & PropsRenderSlots<'tool.call.toolview'> & PropsLocale<'conversation'> & InjectFace<ToolHostInfoInjected>;
 /** Full props of the selected Tool output renderer in the details panel. */
-export type ToolDetailsProps = PropsRuntime<'conversation.details.tool'> & PropsLocale<'conversation'> & InjectFace<ToolHostDescriptionInjected>;
+export type ToolDetailsProps = PropsRuntime<'conversation.details.tool'> & PropsLocale<'conversation'> & InjectFace<ToolHostInfoInjected>;
 //# sourceMappingURL=slots.d.ts.map

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

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

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

@@ -5,5 +5,5 @@ import type { ToolTreeProps } from '../contract/slots.ts';
  * @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, useHostDescription, t, }: ToolTreeProps): import("react").JSX.Element;
+export declare function ToolCallTree({ renderSlot, node, selectedCallId, cwd, openFile, inspectCall, useHostInfo, t, }: ToolTreeProps): import("react").JSX.Element;
 //# sourceMappingURL=ToolCallTree.d.ts.map

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

@@ -1,9 +1,9 @@
 import type { ToolDetailsProps } from '../contract/slots.ts';
 /**
- * Render the selected Tool call's structured output when its presentation
- * intent is known, otherwise preserve the flattened result text.
+ * Render the selected Tool call's structured output when its raw fields form a
+ * supported root card, otherwise preserve the flattened result text.
  * @param props - selected call slice, workspace root, host home, and locale seat.
  * @returns the details output body.
  */
-export declare function ToolDetails({ block, cwd, useHostDescription, t, }: Pick<ToolDetailsProps, 'block' | 'cwd' | 'useHostDescription' | 't'>): import("react").JSX.Element;
+export declare function ToolDetails({ block, cwd, useHostInfo, t, }: Pick<ToolDetailsProps, 'block' | 'cwd' | 'useHostInfo' | 't'>): import("react").JSX.Element;
 //# sourceMappingURL=ToolDetails.d.ts.map

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

@@ -0,0 +1,11 @@
+/** Ask-user transcript rendering from validated plain card data. @module */
+import type { AskQuestionCardModel } from '../models/ask-question-card-model.ts';
+/**
+ * Render a validated ask-user transcript from plain card data.
+ * @param props - Localized transcript card data.
+ * @returns the readable answered or unanswered question list.
+ */
+export declare function AskQuestionCard({ card }: {
+    card: AskQuestionCardModel;
+}): import("react").JSX.Element;
+//# sourceMappingURL=AskQuestionCard.d.ts.map

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

@@ -1,18 +1,17 @@
 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 { AskQuestionCardModel } from '../models/ask-question-card-model.ts';
 import type { ToolRowState, ToolRowVariant } from '../models/tool-call-model.ts';
+import type { WebCardModelProps } from '../models/web-card-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;
@@ -28,39 +27,16 @@ export interface ToolRowProps {
     body: string | null;
     /** Flattened result text for the expanded Output section; null/absent = no output section. */
     output?: string | null | undefined;
+    /** Ask-user transcript card; card fields are mutually exclusive and replace text sections. */
+    askQuestion?: AskQuestionCardModel | 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 card; card fields are mutually exclusive and replace text sections. */
     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;
+    web?: WebCardModelProps | null | undefined;
     state: ToolRowState;
     /**
      * Filesystem path from tool args; when set with onOpenFile, the summary
@@ -75,5 +51,5 @@ export interface ToolRowProps {
      */
     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;
+export declare function ToolRow({ t, variant, toolName, icon, title, summary, summarySuffix, body, output, askQuestion, 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/ask-question-card-model.d.ts

@@ -0,0 +1,22 @@
+/** Pure ask-user transcript card data shared by its presenter and renderer. @module */
+interface AnsweredQuestionCardItem {
+    id: string;
+    question: string;
+    answers: readonly string[];
+}
+interface UnansweredQuestionCardItem {
+    id: string;
+    question: string;
+}
+/** Validated, localized data rendered by the ask-user transcript card. */
+export type AskQuestionCardModel = {
+    kind: 'answered';
+    questions: readonly AnsweredQuestionCardItem[];
+    skippedLabel: string;
+} | {
+    kind: 'unanswered';
+    questions: readonly UnansweredQuestionCardItem[];
+    verdict: string;
+};
+export {};
+//# sourceMappingURL=ask-question-card-model.d.ts.map

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

@@ -1,12 +1,4 @@
-/**
- * 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
- */
+/** Pure diff-card derivation from raw file-mutation calls and result metadata. @module */
 import type { DiffBlockProps } from '@deepseek-ai/dsh-client-ui-primitives';
 import type { ToolCallBlock } from './tool-call-model.ts';
 /**
@@ -33,25 +25,12 @@ export interface DiffCardModel {
     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.
+ * Derive running diffs for root write/edit and `str_replace_editor`
+ * create/replace calls, plus applied settled diffs for root write/edit calls.
+ * A successful write with valid empty metadata uses its argument-derived
+ * whole-file diff, matching create and identical-overwrite presentation;
+ * `str_replace_editor` settles through Generic because it has no result view.
+ * @param block - running or settled Tool block.
  * @returns the diff-card props, or null for the generic path.
  */
 export declare function diffCardModel(block: ToolCallBlock): DiffCardModel | null;

package/lib/types/client/tool/models/primitive-labels.d.ts

@@ -0,0 +1,36 @@
+/** Localized copy adapters for Cordis-free UI primitives used by Tool cards. */
+import type { DiffBlockLabels, MarkdownLabels, ReadBlockLabels, SearchBlockLabels, WebBlockLabels } from '@deepseek-ai/dsh-client-ui-primitives';
+import type { TranslateNS } from '@deepseek-ai/dsh-client-ui-slots';
+type T = TranslateNS<'conversation'>;
+/**
+ * Build localized Markdown chrome labels.
+ * @param t - Conversation locale seat.
+ * @returns Markdown chrome labels.
+ */
+export declare function markdownLabels(t: T): MarkdownLabels;
+/**
+ * Build localized diff-card chrome labels.
+ * @param t - Conversation locale seat.
+ * @returns Diff-card chrome labels.
+ */
+export declare function diffBlockLabels(t: T): DiffBlockLabels;
+/**
+ * Build localized read-card chrome labels.
+ * @param t - Conversation locale seat.
+ * @returns Read-card chrome labels.
+ */
+export declare function readBlockLabels(t: T): ReadBlockLabels;
+/**
+ * Build localized search-card chrome labels.
+ * @param t - Conversation locale seat.
+ * @returns Search-card chrome labels.
+ */
+export declare function searchBlockLabels(t: T): SearchBlockLabels;
+/**
+ * Build localized web-card chrome labels.
+ * @param t - Conversation locale seat.
+ * @returns Web-card chrome labels.
+ */
+export declare function webBlockLabels(t: T): WebBlockLabels;
+export {};
+//# sourceMappingURL=primitive-labels.d.ts.map

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

@@ -0,0 +1,27 @@
+/** Shared narrowing for raw Tool call and result fields consumed by card models. */
+import type { ToolCallBlock, ToolResultNode } from '@deepseek-ai/dsh-client-ui-chat/client';
+/** A parsed, in-window Tool call whose arguments are a JSON object. */
+export interface ParsedToolCall {
+    name: string;
+    args: Record<string, unknown>;
+}
+/**
+ * Parse the call head paired with one immutable Tool block.
+ * @param block - running or settled Tool block.
+ * @returns the Tool name and object arguments, or null when the call head or valid JSON object is unavailable.
+ */
+export declare function parsedToolCall(block: ToolCallBlock): ParsedToolCall | null;
+/**
+ * Read the exact single text block consumed by first-party card derivations.
+ * @param block - settled Tool result.
+ * @returns its text, or undefined for any other content layout.
+ */
+export declare function singleResultText(block: ToolResultNode): string | undefined;
+/**
+ * Validate the optional escalation pair shared by first-party shell and file
+ * mutation tools.
+ * @param args - parsed open-root Tool arguments.
+ * @returns whether the declared escalation fields form a valid pair.
+ */
+export declare function validEscalationFields(args: Record<string, unknown>): boolean;
+//# sourceMappingURL=raw-tool-call.d.ts.map

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

@@ -1,3 +1,4 @@
+/** Pure read-card derivation from raw result content and metadata. @module */
 import type { ReadBlockProps } from '@deepseek-ai/dsh-client-ui-primitives';
 import { type ToolCallBlock } from './tool-call-model.ts';
 /**
@@ -18,25 +19,9 @@ export declare const CHAT_READ_MAX_LINES = 8;
  */
 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
- * shortened the same way the row summary is: workspace-relative first, then
- * POSIX `~` for a leftover host-home path.
- * @param block - RunningToolCall or ToolResultNode off the snapshot caches.
+ * Derive a settled root read card after validating its persisted metadata and
+ * model-facing read envelope.
+ * @param block - running or settled Tool block.
  * @param sessionCwd - the session workspace root; a workspace-rooted absolute
  *   path label displays relative to it. Absent leaves the path as authored.
  * @param home - host account home; a leftover POSIX home path displays as `~`.

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

@@ -1,88 +1,22 @@
-/**
- * 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
- */
+/** Pure search-card derivation from raw grep/glob result metadata. @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.
- */
+type SearchBlockModelProps = DistributiveOmit<SearchBlockProps, 'labels' | 'maxLines' | 'className'>;
+/** Result rows retained in a Chat card before its middle collapses. */
 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.
- */
+/** Search-card props plus an optional locator for a capped full result. */
 export interface SearchCardModel {
-    /**
-     * The props {@link SearchBlock} draws, minus each render site's own
-     * `maxLines`/`className`.
-     */
+    /** Props consumed by {@link SearchBlock}. */
     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.
-     */
+    /** Raw result text containing the full-result locator for a capped search. */
     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.
+ * Derive a settled root grep/glob card from persisted metadata.
+ * @param block - running or settled Tool block.
+ * @returns search-card props, or null for the generic path.
  */
 export declare function searchCardModel(block: ToolCallBlock): SearchCardModel | null;
 export {};

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

@@ -1,3 +1,4 @@
+/** Pure terminal-card derivation from raw Tool call and result fields. @module */
 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';
@@ -12,25 +13,41 @@ import type { ToolCallBlock } from './tool-call-model.ts';
 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.
+ * primitive's props so the two stay in step; `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.
+     * The locale-neutral props {@link TerminalBlock} draws. The render site adds
+     * `command` after resolving {@link copy} through its locale seat.
      */
-    card: Pick<TerminalBlockProps, 'command' | 'cwd' | 'output' | 'exitCode' | 'signal' | 'running'>;
+    card: Pick<TerminalBlockProps, '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.
+     * Verbatim Tool data or semantic `terminal_send` data. Product copy stays
+     * unresolved until a render site supplies its locale seat.
      */
-    description: string | undefined;
+    copy: {
+        readonly kind: 'shell';
+        readonly command: string;
+        readonly description: string | undefined;
+    } | {
+        readonly kind: 'terminal-send';
+        readonly text: string;
+        readonly sessionId: string;
+    };
 }
+interface LocalizedTerminalCardModel {
+    readonly card: Pick<TerminalBlockProps, 'command' | 'cwd' | 'output' | 'exitCode' | 'signal' | 'running'>;
+    readonly description: string | undefined;
+}
+/**
+ * Resolve locale-owned `terminal_send` copy while preserving Tool-authored
+ * shell commands and descriptions verbatim.
+ * @param model - locale-neutral terminal card data.
+ * @param t - the render site's conversation locale seat.
+ * @returns terminal props and description ready for rendering.
+ */
+export declare function localizeTerminalCardModel(model: TerminalCardModel, t: TranslateNS<'conversation'>): LocalizedTerminalCardModel;
 /**
  * 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
@@ -42,30 +59,23 @@ export interface TerminalCardModel {
  */
 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.
+ * Identify a settled root call from the persistent Bash or PowerShell tool.
+ * Its result stays on the generic input/output path because the persistent
+ * shell can report resets and partial output without one process exit status.
+ * @param block - running or settled Tool block.
+ * @returns whether the block is a settled persistent-shell call.
+ */
+export declare function isSettledPersistentShellCall(block: ToolCallBlock): boolean;
+/**
+ * Derive terminal props for supported root shell and terminal-send calls.
+ * Standard shell results parse their final status marker; persistent shell
+ * results, background calls, errors, malformed input, or child dispatches use
+ * the generic path. {@link isSettledPersistentShellCall} lets that generic
+ * persistent result remain expandable without inventing one process status.
+ * @param block - running or settled Tool block.
+ * @param sessionCwd - session workspace root used to resolve workdir.
+ * @returns locale-neutral terminal-card data, or null for the generic path.
  */
 export declare function terminalCardModel(block: ToolCallBlock, sessionCwd?: string): TerminalCardModel | null;
+export {};
 //# sourceMappingURL=terminal-card-model.d.ts.map

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

@@ -1,11 +1,28 @@
-import type { ToolCallBlock, ToolResultNode } from '@deepseek-ai/dsh-client-runtime/client';
-export type { ToolCallBlock } from '@deepseek-ai/dsh-client-runtime/client';
+/**
+ * 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 supported terminal call gets
+ * its expanded body from `terminalCardModel` instead.
+ */
+import type { ToolCallBlock, ToolResultNode } from '@deepseek-ai/dsh-client-ui-chat/client';
+import type { LocaleKeysOf } from '@deepseek-ai/dsh-client-ui-slots';
+export type { ToolCallBlock } from '@deepseek-ai/dsh-client-ui-chat/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>;
+type ToolTitleKey = Extract<LocaleKeysOf<'conversation'>, `tool.title.${string}`>;
+/** Locale key per generic row variant. */
+export declare const VARIANT_TITLE_KEYS: {
+    readonly search: "tool.title.search";
+    readonly read: "tool.title.read";
+    readonly bash: "tool.title.bash";
+    readonly write: "tool.title.write";
+    readonly edit: "tool.title.edit";
+    readonly code: "tool.title.code";
+    readonly others: "tool.title.generic";
+};
 /**
  * Classify a tool name into its row variant.
  * @param toolName - wire tool name.
@@ -15,7 +32,7 @@ export declare function classifyTool(toolName: string): ToolRowVariant;
 /** Everything ToolRow needs, derived once from the frozen slice. */
 export interface ToolRowModel {
     variant: ToolRowVariant;
-    title: string;
+    titleKey: ToolTitleKey;
     summary: string;
     /**
      * Filesystem path from args (`path` / `file_path`) when the row is a file

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

@@ -1,39 +1,14 @@
-/**
- * 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
- */
+/** Pure web-card derivation from raw web result metadata. @module */
 import type { WebBlockProps } from '@deepseek-ai/dsh-client-ui-primitives';
 import type { ToolCallBlock } from './tool-call-model.ts';
+type DistributiveOmit<T, K extends keyof T> = T extends unknown ? Omit<T, K> : never;
+/** Web-card data owned by the presenter; render sites add localized labels and classes. */
+export type WebCardModelProps = DistributiveOmit<WebBlockProps, 'labels' | 'className'>;
 /**
- * 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.
+ * Derive a settled root web-search or web-fetch card from persisted metadata.
+ * @param block - running or settled Tool block.
+ * @returns web-card props, or null for the generic path.
  */
-export declare function webCardModel(block: ToolCallBlock): WebBlockProps | null;
+export declare function webCardModel(block: ToolCallBlock): WebCardModelProps | null;
+export {};
 //# sourceMappingURL=web-card-model.d.ts.map