@morlay/dsh-session-mode 0.0.1-alpha.4 → 0.0.1-alpha.5

package/src/client/SessionModeSeat.tsx

@@ -1,9 +1,13 @@
 /**
- * 新会话屏幕上的模式 chip：**切换列表**就在这里（点开是 coding / chat 两项）。
+ * composer 里的模式 chip：**本包在会话里唯一的面**（点开是 coding / chat 两项）。
  *
- * 为什么住在新会话屏幕而不是输入框上方：选择只在会话开始**之前**有效——一旦跑过 turn，那段历史是在某个
- * 模式的工具与提示词下产生的，host 会拒绝换（与上游 `agentPresets.select` 同一条判据）。一个大半辈子都
- * 该禁用的控件，放在它仍然可用的那块屏幕上更诚实。
+ * 选择只在会话开始**之前**有效——一旦跑过 turn，那段历史是在某个模式的工具与提示词下产生的。所以 chip 在
+ * 会话里有两个形态：空白期是选择器，开过 turn 之后**只读**（只写当前模式，点不动）。判据是 host 的投影
+ * `sessionModeEditable`（`turn/start` 一落库就为 `false`），与服务端拒绝切换读的是同一份事实。
+ *
+ * 它挂在 composer 上：新会话屏也是一个 blank session 的 composer，选择正好发生在那里；会话头部则没有它的
+ * 位置——头部只在"跑起来之后"值得看，而那时的 chip 已经把当前模式写在脸上，再挂一个只读标签就是同一句话的
+ * 复读。
  */
 
 import { useState } from "react";
@@ -15,46 +19,61 @@ import {
 import type { PropsLocale, PropsRuntime } from "@deepseek-ai/dsh-client-ui-slots";
 // Type-only：拉入本包 host 半的 Context / 投影声明（`sessionMode`），让 `projectionValues` 有类型。
 import type {} from "../index.ts";
-// Type-only：拉入 ui-conversation 的 SlotMap 合并（hero 的座位）。
+// Type-only：拉入 ui-conversation 的 SlotMap 合并（composer 工具行的座位）。
 import type {} from "@morlay/dsh-client-ui-conversation/client";
 import { selectMode } from "./api.ts";
 import { useRoster } from "./use-roster.ts";
 import css from "./SessionModeSeat.module.css";
 
-/** 完整 props：hero 槽位的运行时 props + 本包的字典。 */
-export type SessionModeSeatProps = PropsRuntime<"conversation.hero.agentPreset"> &
+/** 完整 props：composer 工具行左侧槽位的运行时 props + 本包的字典。 */
+export type SessionModeSeatProps = PropsRuntime<"conversation.input.left"> &
   PropsLocale<"session-mode">;
 
 /**
- * 渲染新会话的模式 chip。
+ * 渲染 composer 里的模式切换 chip。
+ *
+ * 为什么在 composer（`conversation.input.left`）：**新会话屏也是一个 blank session 的 composer**，选择正好
+ * 发生在那里；会话头部槽位在新会话屏根本不存在，而会话跑起来之后头部也不该重复说一遍 chip 已经写着的事。
+ * 官方 roster 那个座位（`conversation.hero.agentPreset`）是单注册槽位、已被官方占了，所以用自己的 list 槽位
+ * 并存。
  * @param props - 槽位合成的 props。
- * @returns chip；清单没读到、或不是主视图的会话时返回 null。
+ * @returns chip；清单没读到、或会话未知时返回 null。
  */
-export function SessionModeSeat({
-  sessionId,
-  useSessions,
-  useSessionRetainInfo,
-  t,
-}: SessionModeSeatProps) {
+export function SessionModeSeat({ sessionId, useSessions, t }: SessionModeSeatProps) {
   const roster = useRoster();
   const selected = useSessions((state) => {
     const value =
       sessionId === undefined ? undefined : state.byId[sessionId]?.projectionValues?.sessionMode;
     return typeof value === "string" ? value : undefined;
   });
-  const main = useSessionRetainInfo(
-    (info) => sessionId === undefined || (info?.retainedBy.mainView ?? 0) > 0,
-  );
+  const editable = useSessions((state) => {
+    const value =
+      sessionId === undefined
+        ? undefined
+        : state.byId[sessionId]?.projectionValues?.sessionModeEditable;
+    return typeof value === "boolean" ? value : undefined;
+  });
   const [open, setOpen] = useState(false);
   const [busy, setBusy] = useState(false);
   const [error, setError] = useState<string | null>(null);
 
-  if (!main || roster === undefined) return null;
+  if (roster === undefined) return null;
 
   const current = selected ?? roster.default;
   const chosen = roster.modes.find((mode) => mode.id === current);
   const label = chosen?.name ?? current;
 
+  // 开过 turn 的会话**只读**：chip 只写当前模式，点不动也不给清单。判据与 host 拒绝切换读的是同一个投影
+  // （`sessionModeEditable`），所以不会出现"看起来能选、点了报错"。
+  if (editable === false) {
+    return (
+      <button type="button" className={css.seat} disabled title={t("lockedHint")}>
+        <IconAgentPresetOutlineRegular className={css.seatIcon} />
+        <span className={css.seatLabel}>{label}</span>
+      </button>
+    );
+  }
+
   return (
     <Menu
       open={open}

package/src/client/index.ts

@@ -1,40 +1,35 @@
 /**
- * client 半：会话里的两个面（模式 chip 与头部标签）+ 设置页里那张「会话模式」卡片。
+ * client 半：会话里那一个面（模式 chip）+ 设置页里那张「会话模式」卡片。
  *
- * | 槽位                                     | 呈现                                          |
- * | ---------------------------------------- | --------------------------------------------- |
- * | `conversation.hero.agentPreset`          | 新会话屏幕的顶部占位——chip 点开就是切换列表   |
- * | `conversation.session.header.actions`    | 会话头部的只读模式标签（`order: -10`，贴标题） |
- * | `plugins.row.config`（key 见下）         | 设置页里**本行**的配置入口：各模式的默认模型（`config.models`） |
+ * | 槽位                      | 呈现                                                |
+ * | ------------------------- | --------------------------------------------------- |
+ * | `conversation.input.left` | chip——点开就是切换列表（新会话屏也是一个 composer）  |
  *
- * 官方的 `@deepseek-ai/dsh-client-ui-agent-preset` 在装配里被禁用（它同时带来设置页那块 roster 面板），
- * 所以这两个面归我们。设置页那张卡片编辑的是**各模式的默认模型**——配置事实（`config.models`），不是模式
- * 清单；模式清单仍然是装配配置，改它不需要页面。
+ * 官方 `@deepseek-ai/dsh-client-ui-agent-preset` 保留（它提供 preset 的选择面与设置页 roster）：官方管"挂哪套
+ * 行"，我们管"会话级扩展"，两套入口并存、互不遮挡。
  *
- * 卡片的数据面是 host 行的 settings namespace `session-mode`（namespace 名就是行 id）：host 行被描述出来
- * 之后（`configForms.whileServed`）条目才注册，行不在时条目也一起消失。注册到 `plugins.row.config` 而不是
- * 官方分组 `plugins.item`：后者按上游契约由官方那几张设置卡占用（一个 host 命名空间一个伴生包），行自己的
- * 配置就该挂在自己的行上——key 由 `SESSION_MODE_ROW_CONFIG_KEY` 给出。
+ * 头部的只读标签**没有**：chip 本来就把当前模式写在脸上（会话与新会话屏都有 composer），右上角再写一遍是
+ * 同一句话的复读。
+ *
+ * 本行的配置页（各模式的默认模型 `config.models`）不再由本包画：那个字段是 volatile 的，页面由
+ * `@morlay/dsh-client-ui-primitives` 按 schema 自动生成（它注册到本行的配置入口 `plugins.row.config`，
+ * key = `<bundle 包名>#<行 id>`）。本包只管会话里那一个面。
  */
 
 import type { Context } from "@deepseek-ai/cordis";
+// Type-only：`ctx.remote` 的合并面（选模型的候选来自 LLM 目录）。
 import type {} from "@deepseek-ai/dsh-api-remotes/client";
 import type {} from "@deepseek-ai/dsh-client-locale/client";
-import type {} from "@deepseek-ai/dsh-client-ui-plugin-manager/client";
-import type {} from "@deepseek-ai/dsh-client-ui-settings/client";
 import type {} from "@deepseek-ai/dsh-client-ui-slots";
+
 // Type-only：槽位声明与 standard props（session / session-maybe / global）。
 import type {} from "@morlay/dsh-client-ui-conversation/client";
-import { ModelDefaultsCard } from "./ModelDefaultsCard.tsx";
-import { SESSION_MODE_NS, ModelDefaultsCardController } from "./model-defaults-card-controller.ts";
-import { SessionModeLabel } from "./SessionModeLabel.tsx";
 import { SessionModeSeat } from "./SessionModeSeat.tsx";
-import { fetchRoster } from "./api.ts";
 import { en, zh, type SessionModeLocaleKey } from "./locales.ts";
 
 declare module "@deepseek-ai/dsh-client-ui-slots" {
   interface LocaleNamespaceMap {
-    /** 模式选择面与设置卡片的文案。 */
+    /** 会话里两个面的文案（配置页文案在通用 schema 表单的字典里）。 */
     "session-mode": SessionModeLocaleKey;
   }
 }
@@ -42,101 +37,157 @@ declare module "@deepseek-ai/dsh-client-ui-slots" {
 /** 浏览器半插件的字典命名空间。 */
 const NS = "session-mode";
 
-/**
- * 本行的配置入口 key：`<bundle 包名>#<行 id>`。
- *
- * 页面侧由 `ui-plugin-manager` 的 `rowConfigKey(bundle, rowId)` 生成同一个串——bundle 是本包
- * （`dsh.profile.bundles` 里那一项），行 id 是本包 patch 里插的 `session-mode`。
- */
-export const SESSION_MODE_ROW_CONFIG_KEY = "@morlay/dsh-session-mode#session-mode";
+/** 这一行里需要中文文案的字段（都在 `modes.<模式>.defaultModel` 里，所以按模板路径注册一次）。 */
+const FIELDS = ["provider", "model", "reasoningEffort"] as const;
+
+/** 动态键的占位段（与通用表单的字段树同一约定）。 */
+const DYNAMIC = "*";
+
+/** 一个可配置 provider 的候选信息：显示名 + 它的配置在哪（模型清单从那份配置里读）。 */
+interface ProviderEntry {
+  value: string;
+  label: string;
+  settingsNs: string;
+  settingsPath: readonly string[];
+}
 
-export type { ModelDefaultsCardProps } from "./ModelDefaultsCard.tsx";
-export type {
-  ModelDefaultsCardFace,
-  ModelDefaultsCardState,
-  ModelDefaultsRow,
-  ModelDirectory,
-  ModelDefaultsSources,
-  SessionModeSettings,
-} from "./model-defaults-card-controller.ts";
-export { ModelDefaultsCardController, SESSION_MODE_NS } from "./model-defaults-card-controller.ts";
-export type { SessionModeLabelProps } from "./SessionModeLabel.tsx";
 export type { SessionModeSeatProps } from "./SessionModeSeat.tsx";
 export type { SessionModeLocaleKey } from "./locales.ts";
 
 /** 需要的服务：槽位与字典（会话列表经槽位的标准 props 到达组件，不必自己 inject）。 */
 export const inject = ["slots", "locale"];
 
+/** 本包 host 行 id：行配置页读的就是这个命名空间。 */
+export const SESSION_MODE_NS = "session-mode";
+
+/** 按路径读一段配置里的值（本包只读 provider 档案里的模型清单）。 */
+function readAt(root: unknown, path: readonly string[]): unknown {
+  return path.reduce<unknown>((node, segment) => {
+    if (Array.isArray(node)) return node[Number(segment)];
+    if (typeof node !== "object" || node === null) return undefined;
+    return Reflect.get(node, segment);
+  }, root);
+}
+
 /**
- * 装上三个面。
+ * 装上会话里的两个面，以及本行配置页的字段文案。
+ *
  * @param ctx - 浏览器插件上下文。
  */
 export function apply(ctx: Context): void {
+  const t = ctx.locale.bind(NS);
   ctx.effect(() => ctx.locale.register(NS, { zh, en }), "session-mode: dictionaries");
 
-  // 会话里的两个面都要求会话流的上下文（hero 的座位与头部动作行挂在 conversation 上）。
+  // 本行的配置页由通用 schema 表单按 volatile 字段生成；这里给 `modes.<模式>.defaultModel` 里的三个字段补
+  // 中文标签与说明。
+  ctx.inject(["schemaFormHints"], (scope) =>
+    scope.effect(() => {
+      const hints = scope.schemaFormHints;
+      const offs = FIELDS.map((key) =>
+        hints.describe(SESSION_MODE_NS, ["modes", DYNAMIC, "defaultModel", key], () => ({
+          label: t(key),
+          hint: t(`${key}Hint` as "providerHint"),
+        })),
+      );
+      return () => {
+        for (const off of offs) off();
+      };
+    }, "session-mode: field wording"),
+  );
+
+  // 选模型的候选不在本行的 schema 里：provider 是部署里的 LLM 目录（活着的路由 + 可配置声明），模型清单读那份声明
+  // 指向的配置（`settingsNs` / `settingsPath`）。目录异步取到后注册——注册本身就是一次变更通知。
+  ctx.inject(["schemaFormHints"], (scope) =>
+    scope.effect(() => {
+      const hints = scope.schemaFormHints;
+      const remote = scope.get("remote");
+      const forms = scope.get("configForms");
+      if (remote === undefined || forms === undefined) return () => {};
+      let providers: ProviderEntry[] = [];
+      const load = async (): Promise<void> => {
+        const [routes, directory] = await Promise.all([
+          remote.llm.listProviders(),
+          remote.llm.listConfigurableProviders(),
+        ]);
+        if (!routes.ok || !directory.ok) return;
+        const merged = new Map<string, ProviderEntry>();
+        for (const entry of directory.value) {
+          merged.set(entry.provider, {
+            value: entry.provider,
+            label: entry.displayName,
+            settingsNs: entry.settingsNs,
+            settingsPath: [...entry.settingsPath],
+          });
+        }
+        for (const route of routes.value) {
+          if (!merged.has(route.id)) {
+            merged.set(route.id, {
+              value: route.id,
+              label: route.name,
+              settingsNs: "",
+              settingsPath: [],
+            });
+          }
+        }
+        providers = [...merged.values()];
+        hints.refresh();
+      };
+      const modelsOf = (provider: unknown): readonly { value: string }[] => {
+        if (typeof provider !== "string") return [];
+        const entry = providers.find((candidate) => candidate.value === provider);
+        if (entry === undefined || entry.settingsNs === "") return [];
+        const profile = readAt(forms.get(entry.settingsNs).getSnapshot().value, entry.settingsPath);
+        const models =
+          typeof profile === "object" && profile !== null
+            ? Reflect.get(profile, "models")
+            : undefined;
+        if (!Array.isArray(models)) return [];
+        return models.flatMap((model) => {
+          const id =
+            typeof model === "object" && model !== null ? Reflect.get(model, "id") : undefined;
+          return typeof id === "string" ? [{ value: id }] : [];
+        });
+      };
+      const offs = [
+        // 两个具名源：schema 上 `role('select', { source })` 认领它们，本包因此不必知道行 id 与字段路径。
+        hints.source("llm-providers", {
+          options: () => providers.map((entry) => ({ value: entry.value, label: entry.label })),
+        }),
+        // 换服务商就换模型清单：依赖声明让表单在投影时按当前 provider 重算候选。
+        hints.source("llm-models", {
+          dependsOn: [["provider"]],
+          options: (read) => modelsOf(read(["provider"])),
+        }),
+        remote.$on("llm/adapters-updated", () => {
+          void load();
+        }),
+        remote.$on("settings/document-updated", () => {
+          hints.refresh();
+        }),
+      ];
+      void load();
+      return () => {
+        for (const off of offs) off();
+      };
+    }, "session-mode: model candidates"),
+  );
+
+  // chip 挂 **composer 工具行左侧**（`conversation.input.left`，list + session scope）：新会话屏也是一个
+  // blank session 的 composer，所以那里也能选模式——头部槽位在新会话屏不存在。
   ctx.inject(["slots", "conversation"], (scope) => {
     scope.effect(() => {
       const seat = scope.slots.register(
-        { name: "conversation.hero.agentPreset", locale: NS },
-        SessionModeSeat,
-      );
-      const label = scope.slots.register(
         {
-          name: "conversation.session.header.actions",
+          name: "conversation.input.left",
           id: "session-mode",
-          // 静态会话上下文占头部前导的负序位（与官方那一行同位）。
-          order: -10,
+          order: 0,
           locale: NS,
         },
-        SessionModeLabel,
+        SessionModeSeat,
       );
       return () => {
         seat();
-        label();
-      };
-    }, "session-mode: hero chip and header label");
-  });
-
-  // 设置页那张卡片要 `configForms`（共享配置表单）、`remote.session`（模型目录）与 `plugins.item`
-  // （Plugins 页的槽）。它们都可能比本行晚到、或在这个部署里根本没有，所以走 `ctx.inject` 与
-  // `slots.inject` 等它们就位——本行的基础 `inject` 不点它们，缺了也不影响上面两个面。
-  ctx.inject(["slots", "locale", "configForms", "remote", "remote.session"], (forms) => {
-    const t = forms.locale.bind(NS);
-    forms.effect(() => {
-      const controller = new ModelDefaultsCardController(
-        forms.configForms.get(SESSION_MODE_NS),
-        {
-          roster: fetchRoster,
-          // 目录只在打开卡片时读一次：它决定选择器的选项，页面生命周期里不会变。
-          directory: async () => {
-            const response = await forms.remote.session.modelCatalog();
-            if (!response.ok) throw new Error("model catalog is unavailable");
-            return {
-              groups: response.value.groups,
-              failures: response.value.failures.map((failure) => failure.name),
-            };
-          },
-        },
-      );
-      const face = controller.inject();
-      const page = forms.configForms.whileServed([SESSION_MODE_NS], () =>
-        forms.slots.inject("plugins.row.config", () =>
-          forms.slots.register(
-            {
-              name: "plugins.row.config",
-              key: SESSION_MODE_ROW_CONFIG_KEY,
-              // 文案经我们自己的注入面传：keyed 槽的注册项不带 `locale` 声明，不赌页面一定注入字典。
-              inject: () => ({ ...face, t }),
-            },
-            ModelDefaultsCard,
-          ),
-        ),
-      );
-      return () => {
-        page();
-        controller.dispose();
       };
-    }, "session-mode: settings card");
+    }, "session-mode: composer chip");
   });
 }

package/src/client/locales.ts

@@ -1,88 +1,34 @@
 /**
  * client 半的文案：命名空间 `session-mode`（与 locale 注册时用的 key 一致）。
  *
- * 两个面共用这一份字典：会话里的两个槽位（模式 chip 与头部标签）与设置页那张卡片。模式的名字与说明由
- * host 的清单给（那是数据，不是文案）。
+ * 只有会话里那个模式 chip 用这份字典：模式的名字与说明由 host 的清单给（那是数据，不是文案）。本行的配置页
+ * （各模式的默认模型）由通用 schema 表单渲染，文案在它自己的字典里。
  */
 
-import type { SettingsFormLabels } from "@morlay/dsh-client-ui-primitives/client";
-
 export const zh = {
   seatHint: "选择这个会话的模式",
-  headerHint: "这个会话运行的模式",
+  lockedHint: "这个会话已经开始：换模式请新开一个会话",
   noDescription: "（无说明）",
-  switchRefused: "切换失败：{reason}",
-  loadFailed: "读不到模式清单",
-  cardTitle: "会话模式",
-  cardDescription: "给每个会话模式指定默认模型；不指定就跟全局默认模型。",
-  defaultsTitle: "各模式的默认模型",
-  defaultsHint:
-    "只在会话还没有模型事实（没选过模型、也还没跑过请求）时生效；留空就是跟全局默认模型。改完按下面的保存写进设置。",
-  providerLabel: "服务商",
-  modelLabel: "模型",
-  effortLabel: "思考档位",
-  inheritOption: "跟全局默认",
-  chooseModel: "选择模型…",
-  effortDefaultOption: "跟模型默认",
-  staleOption: "{value}（不在目录里）",
-  overridden: "已覆盖",
-  reset: "恢复默认",
-  modelRequired: "还没选模型",
-  readOnly: "本部署的设置为只读。",
-  unavailable: "本插件当前未加载，暂时无法配置。",
-  save: "保存",
-  saving: "保存中…",
-  saveFailed: "本部署没有接受这些值，已保留供你修改。",
-  rosterFailed: "读不到会话模式清单，暂时列不出模式。",
-  directoryFailed: "读不到模型目录，暂时只能看当前值或恢复默认。",
-  directoryPartial: "这些服务商的目录没读到：{names}",
+  provider: "服务商",
+  providerHint:
+    "服务商 id：部署里注册的任意路由——不论哪个适配器插件注册的（官方的、我们自己的都算）。",
+  model: "模型",
+  modelHint: "模型 id。",
+  reasoningEffort: "思考档位",
+  reasoningEffortHint: "省略就跟服务商自己的默认。",
 };
 
 export const en: Record<keyof typeof zh, string> = {
   seatHint: "Pick the mode for this session",
-  headerHint: "The mode this session runs",
+  lockedHint: "This session has started: start a new one to pick a mode",
   noDescription: "(no description)",
-  switchRefused: "Switch refused: {reason}",
-  loadFailed: "Could not load the mode roster",
-  cardTitle: "Session mode",
-  cardDescription: "Set the default model of each session mode; unset follows the global default.",
-  defaultsTitle: "Default model per mode",
-  defaultsHint:
-    "Applies only while a session has no model fact yet (no model picked, no request made); unset follows the global default model. Save writes it into the settings document.",
-  providerLabel: "Provider",
-  modelLabel: "Model",
-  effortLabel: "Reasoning effort",
-  inheritOption: "Same as global default",
-  chooseModel: "Choose a model…",
-  effortDefaultOption: "Model default",
-  staleOption: "{value} (not in the directory)",
-  overridden: "Overridden",
-  reset: "Reset to default",
-  modelRequired: "No model picked yet",
-  readOnly: "This deployment stores settings read-only.",
-  unavailable: "This plugin is not loaded, so it cannot be configured right now.",
-  save: "Save",
-  saving: "Saving…",
-  saveFailed: "The deployment did not accept these values; they were left for you to correct.",
-  rosterFailed: "Could not load the session mode roster, so no mode can be listed.",
-  directoryFailed:
-    "Could not read the model directory, so only the current value or a reset is available.",
-  directoryPartial: "These providers could not be read: {names}",
+  provider: "Provider",
+  providerHint:
+    "Provider id: any route registered in this deployment, whichever adapter plugin supplies it.",
+  model: "Model",
+  modelHint: "Model id.",
+  reasoningEffort: "Reasoning effort",
+  reasoningEffortHint: "Unset keeps the provider's own default.",
 };
 
 export type SessionModeLocaleKey = keyof typeof zh;
-
-/**
- * 共享设置表单外框的文案，从本页字典里读。
- * @param t - 本页的字典读取器。
- * @returns `SettingsForm` 渲染用的标签。
- */
-export function formLabels(t: (key: SessionModeLocaleKey) => string): SettingsFormLabels {
-  return {
-    unavailable: t("unavailable"),
-    readOnly: t("readOnly"),
-    saveFailed: t("saveFailed"),
-    save: t("save"),
-    saving: t("saving"),
-  };
-}