dsh-ntr 0.3.1 → 0.3.3

package/src/client/composer-mode.tsx

@@ -65,6 +65,44 @@ export function agentModeTitle(agentId: string | undefined, acp: AcpStore): stri
   )
 }
 
+/**
+ * Whether this conversation is one the agent-mode control may serve.
+ *
+ * An EXPLICIT non-ACP verdict outranks a lingering session row: switching a
+ * conversation off the NTR preset does not close its ACP session, so "a row
+ * exists" alone would keep this control on an ordinary conversation — the same
+ * precedence the agent tag, the context ring and the released banner already
+ * apply. Only while the host has not answered (`undefined`) does a bound
+ * session count as proof, which is what keeps the control available before the
+ * host's first `session/chat-list` answer lands.
+ */
+export function agentModeVisible(
+  acpMode: boolean | undefined,
+  hasBoundSession: boolean,
+): boolean {
+  if (acpMode === false) return false
+  return acpMode === true || hasBoundSession
+}
+
+/**
+ * The mode the select shows as in force.
+ *
+ * A LIVE session is the authority (it is what the agent runs right now). A
+ * RELEASED row only describes the mode the agent was parked ON, so a newer
+ * pick — which `applyChatChoice` will apply on the next resume — outranks it
+ * (and the parked row still beats the catalog default). Same precedence as
+ * the model and thought level in `describeRoute`: a pre-switch on a parked
+ * session must be visible or the control reads as dead.
+ */
+export function modeInForce(
+  target: { released?: boolean; modes?: { currentModeId?: string } } | undefined,
+  persisted: string | undefined,
+  fallback?: string,
+): string {
+  const live = target !== undefined && target.released !== true ? target.modes?.currentModeId : undefined
+  return live ?? persisted ?? target?.modes?.currentModeId ?? fallback ?? ''
+}
+
 export function AcpComposerMode({ acp, sessionId, useSession }: ComposerModeProps) {
   const ui = useUi(acp)
   const dshSessionId = String(sessionId)
@@ -85,9 +123,10 @@ export function AcpComposerMode({ acp, sessionId, useSession }: ComposerModeProp
   // unconditionally), so it must gate itself. The `defaultAgent` fallback below
   // would otherwise put an ACP mode select into ORDINARY conversations: the
   // agent id is plugin-global, so "an agent is configured" is not the same
-  // question as "this conversation is served by one". A live session is itself
-  // proof; otherwise it is the same host verdict the seat gate reads.
-  const isAcp = target !== undefined || ui.acpMode[dshSessionId] === true
+  // question as "this conversation is served by one". A live session is proof
+  // only while the host has not answered; an explicit `false` wins over the
+  // lingering row a preset switch leaves behind (see `agentModeVisible`).
+  const isAcp = agentModeVisible(ui.acpMode[dshSessionId], target !== undefined)
   // The agent this conversation is set up on, live session or not. Before the
   // first message there is no session to read a mode list from, yet the user is
   // already choosing the agent — and the mode is one of the things they may
@@ -116,6 +155,12 @@ export function AcpComposerMode({ acp, sessionId, useSession }: ComposerModeProp
     void acp.loadAgentCatalog(agentId)
   }, [acp, agentId, isAcp, target])
 
+  // The whole control is ACP-only: a lingering live session row survives a
+  // preset switch, so its `availableModes` are NOT a licence to render here.
+  // Without this guard an ordinary conversation kept an agent-mode select
+  // beside its native controls (reported as "the bottom bar lost its native
+  // capabilities").
+  if (!isAcp) return null
   const live = target?.modes?.availableModes ?? []
   // TWO sources, one list. A live session's `session/new` answer is the
   // authority on which modes exist and which is in force; the probed catalog
@@ -123,20 +168,21 @@ export function AcpComposerMode({ acp, sessionId, useSession }: ComposerModeProp
   // agent published on ITS throwaway session). A live session always wins.
   const modes = live.length > 0
     ? live
-    : (isAcp ? catalog?.mode?.choices ?? [] : []).map(choice => ({ id: choice.id, name: choice.name, description: choice.description }))
+    : (catalog?.mode?.choices ?? []).map(choice => ({ id: choice.id, name: choice.name, description: choice.description }))
   if (modes.length === 0) return null
-  // The mode IN FORCE comes from the live session; before one exists the only
-  // claims available are the agent's own reported current mode and the pick this
-  // conversation recorded (a pick outranks the agent's default, exactly like the
-  // model and thought level do in `describeRoute`).
+  // The mode IN FORCE: a live session is the authority, before one exists (or
+  // while one is parked) the claims available are the pick this conversation
+  // recorded and the agent's own reported current mode (a pick outranks the
+  // agent's default, exactly like the model and thought level do in
+  // `describeRoute`; the parked row yields to the pick — see `modeInForce`).
   const persisted = ui.chatChoice[dshSessionId]?.agentId === agentId
     ? ui.chatChoice[dshSessionId]?.mode
     : undefined
-  const current = target?.modes?.currentModeId
-    ?? persisted
-    ?? catalog?.mode?.currentValue
-    ?? modes[0]?.id
-    ?? ''
+  const current = modeInForce(
+    target,
+    persisted,
+    catalog?.mode?.currentValue ?? modes[0]?.id,
+  )
 
   return (
     <label

package/src/client/context-meter.tsx

@@ -0,0 +1,128 @@
+/**
+ * Composer context-occupancy ring at `conversation.composer.dock` — the bottom
+ * info row below the input card, where the host also renders its ContextMeter.
+ *
+ * WHY A PLUGIN-OWNED RING: the host's meter reads its `contextPressure`
+ * projection, folded from DSH provider-usage samples plus a route capacity. An
+ * ACP conversation produces neither — the agent owns the request and the host
+ * never sees its prompt — so the native meter renders nothing there. This ring
+ * reports the agent's OWN `usage_update` used/size instead: occupancy only. ACP
+ * declares no system/tools/messages split, so no breakdown is invented.
+ *
+ * Registered for every conversation and gating itself: it renders only for an
+ * ACP conversation whose session row carries usage. The row comes from
+ * `session/chat-list`; the store live-patches it from the coalesced
+ * `usage_update` frames (see `AcpStore.flushUpdates`).
+ */
+
+import { useEffect } from 'react'
+// Type-only: pulls the ui-conversation SlotMap merge into this program.
+import type {} from '@deepseek-ai/dsh-client-ui-conversation/client'
+import { ensureAcpStyle, useUi } from './acp-ui.tsx'
+import type { AcpSessionHook } from './acp-ui.tsx'
+import type { AcpStore, UiState } from './store.ts'
+import type { SessionView } from '../protocol.ts'
+
+/** Props of the composer entry (injected face + the frame's standard kit). */
+export interface AcpContextMeterProps {
+  /** Injected face: the chat session id this entry belongs to. */
+  sessionId: string
+  /** Framework-bound conversation snapshot hook (`SessionStandardProps.useSession`). */
+  useSession: AcpSessionHook
+  acp: AcpStore
+}
+
+export interface ContextOccupancy {
+  /** Rounded occupancy percentage, clamped to 0..100. */
+  percent: number
+  used: number
+  size: number
+}
+
+/**
+ * The sample this conversation's ring should show, or `undefined` when the
+ * entry must render nothing. An explicit `acpMode === false` outranks a stale
+ * `chatSessions` row: the conversation's preset left NTR while its ACP session
+ * was still alive, and the ring must leave with it (same precedence as the
+ * agent tag's `agentTagVisible`). While the verdict is unknown, a LIVE row is
+ * proof; a PARKED one is not — it can outlive the preset switch, and the ring
+ * must not appear on an ordinary conversation during the answer window.
+ */
+export function acpMeterUsage(
+  ui: Pick<UiState, 'acpMode' | 'chatSessions' | 'chatSessionsFor'>,
+  dshSessionId: string,
+): SessionView['usage'] | undefined {
+  if (ui.acpMode[dshSessionId] === false) return undefined
+  if (ui.chatSessionsFor !== dshSessionId) return undefined
+  const live = ui.chatSessions.find(row => !row.released)
+  // A PARKED row alone is not proof this conversation is still in NTR mode:
+  // switching off the preset leaves the ACP session record alive, and while the
+  // host has not answered (`undefined`) the ring must not appear on an
+  // ordinary conversation. A live row is proof; a parked one needs the
+  // affirmative verdict.
+  if (live === undefined && ui.acpMode[dshSessionId] !== true) return undefined
+  return (live ?? ui.chatSessions[0])?.usage
+}
+
+/**
+ * Bounded display occupancy from one agent sample. `undefined` (no meter) for
+ * an absent / malformed / zero-capacity sample rather than a made-up 0%.
+ */
+export function contextOccupancy(usage: SessionView['usage'] | undefined): ContextOccupancy | undefined {
+  if (usage === undefined) return undefined
+  const { used, size } = usage
+  if (!Number.isFinite(used) || !Number.isFinite(size) || used < 0 || size <= 0) return undefined
+  return { percent: Math.min(100, Math.round(used / size * 100)), used, size }
+}
+
+/** Compact token count for the tooltip, in the host meter's K/M shape. */
+export function compactTokenCount(value: number): string {
+  if (value < 1e3) return String(Math.round(value))
+  const thousands = value / 1e3
+  if (value < 1e6) {
+    return `${thousands >= 100 ? String(Math.round(thousands)) : String(Math.round(thousands * 10) / 10)}K`
+  }
+  const millions = value / 1e6
+  return `${millions >= 100 ? String(Math.round(millions)) : String(Math.round(millions * 10) / 10)}M`
+}
+
+/** Ring geometry matches the host ContextMeter: 14px viewBox, 2px stroke. */
+const RADIUS = 5.5
+const CIRCUMFERENCE = 2 * Math.PI * RADIUS
+
+export function AcpContextMeter({ acp, sessionId, useSession }: AcpContextMeterProps) {
+  ensureAcpStyle()
+  const ui = useUi(acp)
+  const dshSessionId = String(sessionId)
+  // A fresh conversation gets its ACP session binding during its first turn,
+  // and no SSE frame announces that; the running flip is the re-read trigger
+  // every composer entry shares.
+  const running = useSession(snapshot => snapshot.running)
+  useEffect(() => {
+    void acp.loadChatSessions(dshSessionId)
+  }, [acp, dshSessionId, running])
+
+  const context = contextOccupancy(acpMeterUsage(ui, dshSessionId))
+  if (context === undefined) return null
+
+  const title = acp.label(
+    `上下文已用 ${String(context.percent)}% · ${compactTokenCount(context.used)} / ${compactTokenCount(context.size)}`,
+    `${String(context.percent)}% of context used · ${compactTokenCount(context.used)} / ${compactTokenCount(context.size)}`,
+  )
+  return (
+    <span className="ntr-acp-meter" role="img" aria-label={title} title={title}>
+      <svg viewBox="0 0 14 14" width="14" height="14" aria-hidden="true">
+        <circle className="ntr-acp-meter-track" cx="7" cy="7" r={RADIUS} />
+        <circle
+          className="ntr-acp-meter-fill"
+          cx="7"
+          cy="7"
+          r={RADIUS}
+          strokeDasharray={`${String(CIRCUMFERENCE * context.percent / 100)} ${String(CIRCUMFERENCE)}`}
+          transform="rotate(-90 7 7)"
+        />
+      </svg>
+      <span className="ntr-acp-meter-percent">{context.percent}%</span>
+    </span>
+  )
+}