chat

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133// Regression coverage for models using the real chat modules.
// Fixtures exercise the same behavior and assertions as the JavaScript tests.
import assert from "node:assert/strict";
import test from "node:test";
import * as Effect from "effect/Effect";
import type { Chat, ConfigOption } from "convergence";
import { sections, createModelPicker } from "./models.ts";
import { harness, tree as inspect, nodes, chat as makeChat } from "./ui-for-tests.test.ts";
assert.ok(typeof sections === "function");
const choices = [
  { value: "a/fast", name: "Fast", group: "Provider A" },
  { value: "a/deep", name: "Deep", group: "Provider A" },
  { value: "b/deep", name: "Deep", group: "Provider B" },
  { value: "local", name: "Local" },
];

test("favorites are unique, provider-qualified, and leave catalog order intact", () => {
  const result = sections(choices, ["b/deep", "removed"], "");
  assert.deepEqual(
    result.map((group) => [group.name, group.choices.map((choice) => choice.value)]),
    [
      ["Favorites", ["b/deep"]],
      ["Provider A", ["a/fast", "a/deep"]],
      ["", ["local"]],
    ],
  );
});

test("search matches names, ids, and providers together, ignoring case and whitespace", () => {
  assert.deepEqual(sections(choices, [], "  DEEP provider B ")[0].choices, [choices[2]]);
  assert.deepEqual(sections(choices, [], "a/fast")[0].choices, [choices[0]]);
  assert.deepEqual(sections(choices, [], "missing"), []);
  assert.equal(sections(choices, [], "Local")[0].name, "");
});

test("ungrouped models stay flat, with only favorites getting a heading", () => {
  const flat = [
    { value: "default", name: "Default", group: undefined },
    { value: "fast", name: "Fast" },
  ];
  assert.deepEqual(sections(flat, [], ""), [{ name: "", choices: flat }]);
  assert.deepEqual(sections(flat, ["fast"], ""), [
    { name: "Favorites", favorite: true, choices: [flat[1]] },
    { name: "", choices: [flat[0]] },
  ]);
});

test("the settings menu lists each setting with its value, the models grouped with favorites first", async () => {
  const h = harness(),
    selections: string[][] = [];
  h.controller.setOption = (...args) =>
    Effect.sync(() => {
      selections.push(args);
    });
  const chat = makeChat({ id: "chat", agentId: "one" });
  const model: ConfigOption = { id: "model", name: "Model", kind: "select", category: "model", value: "a/fast", choices };
  const effort: ConfigOption = {
    id: "effort",
    name: "Effort",
    kind: "select",
    category: "reasoning",
    value: "high",
    choices: [
      { value: "low", name: "Low", description: "Quick answers" },
      { value: "high", name: "High" },
    ],
  };
  const speed: ConfigOption = {
    id: "speed",
    name: "Speed",
    kind: "select",
    category: "other",
    value: "standard",
    choices: [{ value: "standard", name: "Standard" }],
  };
  const open = async () => {
    const picker = createModelPicker(h.controller);
    await Effect.runPromise(picker.load);
    return (chat: Chat) => inspect(picker.render(h.v, chat, { ...model, choices: model.choices?.map((c) => ({ ...c, description: "About it" })) }, [effort, speed]));
  };
  type Menu = {
    type: string;
    label: string;
    detail: string;
    options: unknown;
    onStar: (e: { value: string; option?: string }) => void;
    onChange: (e: { value: string; option?: string }) => void;
  };
  let menu = (await open())(chat) as unknown as Menu;
  assert.equal(menu.type, "combobox");
  // The trigger names the model and, fainter, its effort only.
  assert.equal(menu.label, "Fast");
  assert.equal(menu.detail, "High");
  const rows = menu.options as { value: string; label: string; detail: string; submenu: { value: string; options: { value: string; group?: string; starred?: boolean; description?: string }[] } }[];
  assert.deepEqual(
    rows.map((row) => [row.label, row.detail, row.submenu.value]),
    [
      ["Model", "Fast", "a/fast"],
      ["Effort", "High", "high"],
      ["Speed", "Standard", "standard"],
    ],
  );
  assert.deepEqual(
    rows[0].submenu.options.map((o) => [o.value, o.group, o.starred]),
    [
      ["a/fast", "Provider A", false],
      ["a/deep", "Provider A", false],
      ["b/deep", "Provider B", false],
      ["local", undefined, false],
    ],
  );
  // Choices are names only: their descriptions only took room.
  assert.ok(rows.every((row) => row.submenu.options.every((o) => o.description === undefined)));

  // A star saves the favorite without choosing the model; the starred one
  // moves to its own group on top.
  menu.onStar({ value: "b/deep", option: "model" });
  await new Promise(setImmediate);
  assert.equal(selections.length, 0);
  assert.deepEqual(h.stored.modelFavorites, { one: ["b/deep"] });
  menu = (await open())(chat) as unknown as Menu;
  const models = (menu.options as typeof rows)[0].submenu.options;
  assert.deepEqual([models[0].value, models[0].group, models[0].starred], ["b/deep", "Favorites", true]);
  // Favorites are the agent's own.
  const other = (await open())({ ...chat, agentId: "two" });
  assert.ok((other.options as typeof rows)[0].submenu.options.every((o) => !o.starred));

  // A choice in a submenu sets that setting and gives the prompt the keyboard.
  menu.onChange({ value: "low", option: "effort" });
  await h.settle();
  assert.deepEqual(selections, [["chat", "effort", "low"]]);
  assert.ok(h.focused.at(-1)?.startsWith("prompt-"));
});