dsh-ntr 0.1.6 → 0.2.1

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

@@ -84,16 +84,49 @@ export type Block = {
     tone: 'info' | 'error';
     text: string;
 };
+/**
+ * One permission ask waiting for a human. Every field is copied VERBATIM from
+ * the host's `permission/request` frame: the host owns what the ask is called
+ * (`toolName` / `reason`), which options the agent offered (order included),
+ * and whether the ask carries a deadline. The browser does not derive a title
+ * from `toolCall` and does not second-guess the agent's option labels.
+ */
 export interface PendingPermission {
     requestId: string;
+    /** ACP session id. */
     sessionId: string;
-    title: string;
+    /** DSH chat session id; absent for `/acp` RPC-only sessions (settings-only ask). */
+    dshSessionId?: string;
+    toolName: string;
+    reason?: string;
     options: Array<{
         optionId: string;
         name: string;
         kind: string;
     }>;
+    timeoutMode: PermissionTimeoutMode;
+    /** Epoch ms; absent in `wait` mode. */
+    deadlineAt?: number;
 }
+/** Returned by {@link deadlineRemainingLabel} once the deadline has passed. */
+export declare const PERMISSION_DEADLINE_EXPIRED = "expired";
+/**
+ * The asks that belong to one DSH chat conversation. An ask without a
+ * `dshSessionId` belongs to no conversation (an `/acp` RPC-only session), so it
+ * is deliberately absent from every conversation's dock and stays in the
+ * settings-panel ledger.
+ */
+export declare function permissionsForSession(permissions: readonly PendingPermission[], dshSessionId: string): PendingPermission[];
+/**
+ * Compact countdown for one ask, or `undefined` when there is nothing to count
+ * down (`wait` mode, or a frame without a deadline). Pure so the formatting is
+ * testable without a clock: the dock passes `Date.now()` on its tick.
+ *
+ * Past the deadline the answer is {@link PERMISSION_DEADLINE_EXPIRED} rather
+ * than a negative number — the host has already armed the expiry, and a card
+ * counting backwards would claim a deadline that no longer exists.
+ */
+export declare function deadlineRemainingLabel(deadlineAt: number | undefined, now: number, mode: PermissionTimeoutMode): string | undefined;
 /**
  * One observed ACP transcript, keyed by ACP session id. This is the ACP view
  * tab's data source: the native chat plane can only render text/reasoning
@@ -164,17 +197,6 @@ export interface UiState {
      * that never answers, …) reads as a dead button.
      */
     probeErrors: Record<string, string>;
-    /**
-     * Host reports that it HAS the native approval chain (permission asks are
-     * answered in the chat composer). This is a capability report, not a
-     * per-ask promise: an individual ask still falls back to the settings-panel
-     * ledger when the service is unavailable this time, or when the session has
-     * no chat identity behind it (`AgentBridge.askNativeApproval`). The panel
-     * therefore answers ANY pending ask, whatever this flag says — see
-     * `permissionLedgerCard` in panel.tsx. False on an older host or when the
-     * approval service is missing, in which case the ledger is the only path.
-     */
-    approvalRouted: boolean;
     /**
      * ACP agent sessions backing the chat session the composer control sits in.
      * Only meaningful together with {@link chatSessionsFor}: the control reads it
@@ -556,6 +578,14 @@ export declare class AcpStore {
     /** Mirror the running flag onto a transcript the ACP view is showing. */
     private markWatchedRunning;
     setConfigOption(configId: string, value: string): Promise<void>;
+    /**
+     * Answer one ask (`optionId` absent = cancel it). A failure is reported
+     * through the store's notice — the settings panel renders that — AND
+     * rethrown, so the conversation dock can pin the message next to the card
+     * that failed instead of leaving it on a settings page the user may not
+     * have open. Callers that cannot show it (the settings panel) swallow it
+     * after the notice.
+     */
     respondPermission(requestId: string, optionId?: string): Promise<void>;
     stopAgent(agentId: string): Promise<void>;
     /**

package/lib/types/impl.d.ts

@@ -561,6 +561,21 @@ export declare class EventHub {
     subscribe(sink: (event: AcpEvent) => void): () => void;
     broadcast(event: AcpEvent): void;
 }
+/** Everything a `permission/request` frame carries besides the ids the ledger owns. */
+export interface PendingPermissionFields {
+    /** DSH chat session id; absent for `/acp` RPC-only sessions. */
+    dshSessionId?: string;
+    toolCall: unknown;
+    /** Host-derived human name (`permissionToolName`). */
+    toolName: string;
+    /** One-line detail from the agent's declared input, when it has any. */
+    reason?: string;
+    options: PermissionOptionView[];
+    /** What an unanswered ask does when its deadline fires. */
+    timeoutMode: PermissionTimeoutMode;
+    /** Epoch ms of the deadline; absent in `wait` mode (no deadline). */
+    deadlineAt?: number;
+}
 export interface PendingPermission {
     requestId: string;
     sessionId: string;
@@ -570,17 +585,12 @@ export interface PendingPermission {
      * client receives (see `permissionReplayFrames`). Absent on entries created
      * without a view — those still answer, they just cannot be re-shown.
      */
-    view?: {
-        toolCall: unknown;
-        options: PermissionOptionView[];
-    };
+    view?: PendingPermissionFields;
 }
 /** One outstanding ask as a reconnecting client must be re-shown it. */
-export interface PendingPermissionView {
+export interface PendingPermissionView extends PendingPermissionFields {
     requestId: string;
     sessionId: string;
-    toolCall: unknown;
-    options: PermissionOptionView[];
 }
 export declare class PermissionLedger {
     private readonly pending;
@@ -603,6 +613,16 @@ export declare class PermissionLedger {
      */
     pendingViews(): PendingPermissionView[];
 }
+/**
+ * The `permission/request` frame for one ask.
+ *
+ * ONE builder for both the live broadcast and the reconnect replay, so the two
+ * can never drift: a client that reconnects must receive exactly the frame the
+ * live one carried (its conversation card filters on `dshSessionId` and shows
+ * `toolName` / `deadlineAt`, so a replay missing them would silently drop the
+ * ask).
+ */
+export declare function permissionRequestFrame(view: PendingPermissionView): AcpEvent;
 /**
  * Frames that re-establish a freshly connected client's view of the pending
  * permission asks: every outstanding ask re-sent as its original
@@ -610,10 +630,10 @@ export declare class PermissionLedger {
  *
  * Why a replay at all: a `permission/request` is broadcast ONCE, when the ask is
  * created. A client that connects later — page reload, second tab, stream
- * outage — never receives it, and for a ledger ask (the `/acp` RPC path, or a
- * native route that degraded) that card is the ONLY answer entry, so the ask is
- * invisible to exactly the client that needs it. OmniTerm closes the same hole
- * with `PermissionManager::pending_events()` + a `PermissionsSynced` marker on
+ * outage — never receives it, and that card (conversation or settings ledger)
+ * is the ONLY answer entry for the ask, so the ask is invisible to exactly the
+ * client that needs it. OmniTerm closes the same hole with
+ * `PermissionManager::pending_events()` + a `PermissionsSynced` marker on
  * every WS connect.
  *
  * Why the terminator is mandatory: the replay is a snapshot, so an ask resolved
@@ -706,12 +726,6 @@ export interface AcpManager {
      * cache (newly published models appear, withdrawn ones drop out).
      */
     cachedAgentModels?(agentId: string): AgentProbeModelsResult | undefined;
-    /**
-     * True when ACP permission asks are routed to the host's native approval
-     * service (answered in the chat composer) instead of the settings-panel
-     * ledger. Read-only capability report for `agents/list`.
-     */
-    approvalRouting?(): boolean;
     /**
      * ACP agent sessions backing one DSH chat session (looked up by chat session
      * id), so the composer can offer the agent's OWN mode list. Empty when no

package/lib/types/protocol.d.ts

@@ -349,12 +349,35 @@ export type AcpEvent = {
     agentId: string;
     exposedModels: string[];
     autoDiscoverModels: boolean;
-} | {
+}
+/**
+ * One outstanding ask, broadcast ONCE when it is created and replayed as-is
+ * to every freshly connected client (see `permission/synced`).
+ *
+ * Every ACP permission ask carries everything the conversation card needs:
+ * who owns it (`dshSessionId`), what it is about (`toolCall` + the derived
+ * `toolName` / `reason`), the options to render verbatim, and the deadline in
+ * force. The host never answers on its own outside an expired `abort` /
+ * `auto` deadline, so this frame (and its replay) is the answer entry.
+ */
+ | {
     type: 'permission/request';
     requestId: string;
+    /** ACP session id the ask belongs to. */
     sessionId: string;
+    /** DSH chat session id; absent for `/acp` RPC-only sessions. */
+    dshSessionId?: string;
+    /** Raw ACP `ToolCallUpdate` the agent sent — never summarized away. */
     toolCall: unknown;
+    /** Host-derived human name (`permissionToolName`, `_meta` fallback included). */
+    toolName: string;
+    /** One-line detail from the agent's declared input, when it has any. */
+    reason?: string;
     options: PermissionOptionView[];
+    /** What an unanswered ask does when its deadline fires. */
+    timeoutMode: PermissionTimeoutMode;
+    /** Epoch ms of the deadline; absent in `wait` mode (no deadline). */
+    deadlineAt?: number;
 } | {
     type: 'permission/resolved';
     requestId: string;
@@ -366,11 +389,9 @@ export type AcpEvent = {
  * (`abort`), or answered with the option the agent's own kinds imply
  * (`auto`).
  *
- * A native ask (the composer takeover) never became a ledger entry, so this
- * frame is the ONLY trace of the expiry in the conversation: without it the
- * user would watch the composer card vanish with nothing said about it. The
- * ledger path does not need it — its card sits on the settings panel and the
- * chat line already pointed there.
+ * This is the conversation's record of the expiry: the card it was answering
+ * is gone, so without this frame the user would see it vanish with nothing
+ * said about it.
  */
  | {
     type: 'permission/expired';
@@ -495,12 +516,6 @@ export type RpcResult<T> = {
 };
 export interface AgentsListResult {
     agents: AgentView[];
-    /**
-     * True when permission asks are routed to the host approval chain and the
-     * browser must stop rendering the settings-panel permission card. False (or
-     * absent on an older host) keeps the degraded ledger path visible.
-     */
-    approvalRouted?: boolean;
 }
 export type SessionPromptResult = {
     accepted: true;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-ntr",
-  "version": "0.1.6",
+  "version": "0.2.1",
   "description": "Interactive Agent Client Protocol (ACP) client for the DSH web UI: attach any ACP-capable agent and stream its session.",
   "repository": "https://github.com/GDWhisper/dsh-ntr.git",
   "type": "module",
@@ -48,9 +48,13 @@
     "@deepseek-ai/dsh-client-ui-sidebar": "0.1.5-rc.1",
     "@deepseek-ai/dsh-client-ui-slots": "0.1.5-rc.1",
     "@deepseek-ai/dsh-host-webserver": "0.1.5-rc.1",
+    "@testing-library/react": "^16.3.3",
     "@types/node": "^22.19.0",
     "@types/react": "^19.2.0",
+    "@types/react-dom": "^19.3.0",
+    "jsdom": "^27.4.0",
     "react": "^19.2.0",
+    "react-dom": "^19.3.1",
     "tsdown": "^0.23.0",
     "typescript": "^5.9.0",
     "vitest": "^3.2.0"