Skip to content

Local UI to run and train LLMs and diffusion models. Supports GGUF, MLX, Qwen3.8, DeepSeek-V4.1, MiniMax-H3, Gemma 4, FLUX and more.

33.0 KB
Raw Blame
import assert from "node:assert/strict";
import { readFileSync } from "node:fs";
import { register } from "node:module";
import test, { type TestContext } from "node:test";
import type * as chatRuntime from "../src/features/chat/stores/chat-runtime-store.ts";
import { installLocalStorageFake } from "./helpers/kit.ts";

const { store: storage } = installLocalStorageFake();
register("./thread-sampling-resolver.mjs", import.meta.url);

const { settingsHttp } = await import("./helpers/store-stubs/settings-http.ts");
const { threadRows } = await import(
  "./helpers/store-stubs/chat-history-storage.ts"
);
const { useExternalProvidersStore } = await import(
  "../src/features/chat/stores/external-providers-store.ts"
);
const { setProviderModelCapabilities } = await import(
  "../src/features/chat/external-providers.ts"
);
type RuntimeModule = typeof chatRuntime;
const runtimeUrl = new URL(
  "../src/features/chat/stores/chat-runtime-store.ts",
  import.meta.url,
).href;
const THREAD = "tool-selection-chat";
const MODEL = "unsloth/tool-capable-model";
const LOCAL_TOOL_KEYS = [
  "toolsEnabled",
  "codeToolsEnabled",
  "mcpEnabledForChat",
  "ragEnabled",
] as const;
const TOOL_KEYS = [
  ...LOCAL_TOOL_KEYS,
  "imageToolsEnabled",
  "webFetchToolsEnabled",
] as const;

async function boot(t: TestContext, hydrate = true): Promise<RuntimeModule> {
  storage.clear();
  storage.set("unsloth_chat_settings_imported_to_studio_db", "true");
  settingsHttp.settings = { rememberParamsPerModel: false };
  settingsHttp.puts.length = 0;
  threadRows.reset();
  useExternalProvidersStore.setState({ providers: [] });
  const runtime = (await import(
    `${runtimeUrl}?scenario=${encodeURIComponent(t.name)}`
  )) as RuntimeModule;
  t.after(async () => {
    await runtime.awaitThreadScopedSettingsWrite(THREAD);
    await runtime.flushPendingChatSettings();
    await runtime.awaitStartedThreadScopedSettingsWrites();
  });
  const store = runtime.useChatRuntimeStore;
  if (hydrate) await store.getState().hydratePersistedSettings();
  store.getState().setCheckpoint(MODEL, null);
  store.setState({ supportsTools: true });
  return runtime;
}

for (const scope of ["defaults", "chat", "pending chat"] as const) {
  for (const search of [false, true]) {
    for (const code of [false, true]) {
      test(`${scope} remembers Search=${search} and Code=${code} across unload and reload`, async (t) => {
        const runtime = await boot(t);
        const store = runtime.useChatRuntimeStore;
        const original = { toolsEnabled: !search, codeToolsEnabled: !code };
        if (scope !== "defaults") {
          store.getState().setActiveThreadId(THREAD);
          if (scope === "pending chat") {
            runtime.beginThreadScopedPairing(THREAD);
          } else {
            store.getState().applyThreadScopedSettings(THREAD, original);
          }
        }
        store.getState().setToolsEnabled(search);
        store.getState().setCodeToolsEnabled(code);
        store.getState().setImageToolsEnabled(search);
        store.getState().setWebFetchToolsEnabled(code);
        store.getState().setMcpEnabledForChat(search);
        store.getState().setRagEnabled(code);
        const expected = Object.fromEntries(
          TOOL_KEYS.map((key) => [key, store.getState()[key]]),
        );

        store.getState().clearCheckpoint();
        assert.equal(store.getState().params.checkpoint, "");
        assert.equal(store.getState().supportsTools, false);
        for (const key of TOOL_KEYS) {
          assert.equal(store.getState()[key], expected[key], key);
        }

        if (scope === "pending chat") {
          store.getState().applyThreadScopedSettings(THREAD, original);
        }
        await runtime.awaitThreadScopedSettingsWrite(THREAD);
        await runtime.flushPendingChatSettings();
        if (scope !== "defaults") {
          for (const key of TOOL_KEYS) {
            assert.equal(
              threadRows.rows.get(THREAD)?.[key],
              expected[key],
              key,
            );
          }
          assert.equal(storage.get("unsloth_chat_tools_enabled"), undefined);
          assert.equal(
            storage.get("unsloth_chat_code_tools_enabled"),
            undefined,
          );
        }

        store.getState().setCheckpoint(MODEL, null);
        store.setState({
          supportsTools: true,
          ...runtime.resolveToolsEnabledOnLoad(true),
        });
        for (const key of LOCAL_TOOL_KEYS) {
          assert.equal(store.getState()[key], expected[key], key);
        }
        assert.deepEqual(runtime.resolveToolsEnabledOnLoad(false), {
          toolsEnabled: false,
          codeToolsEnabled: false,
          deepResearchEnabled: false,
        });
      });
    }
  }
}

test("unloading does not overwrite a settled chat or its defaults", async (t) => {
  const runtime = await boot(t);
  const store = runtime.useChatRuntimeStore;
  store.getState().setToolsEnabled(false);
  store.getState().setCodeToolsEnabled(false);
  store.getState().setActiveThreadId(THREAD);
  store.getState().applyThreadScopedSettings(THREAD, {
    toolsEnabled: true,
    codeToolsEnabled: true,
  });
  await runtime.flushPendingChatSettings();
  const writesBeforeUnload = settingsHttp.puts.length;

  store.getState().clearCheckpoint();
  await runtime.awaitThreadScopedSettingsWrite(THREAD);
  await runtime.flushPendingChatSettings();
  assert.equal(threadRows.writes.length, 0);
  assert.equal(settingsHttp.puts.length, writesBeforeUnload);

  store.getState().setPermissionMode("ask");
  await runtime.awaitThreadScopedSettingsWrite(THREAD);
  assert.equal(threadRows.rows.get(THREAD)?.toolsEnabled, true);
  assert.equal(threadRows.rows.get(THREAD)?.codeToolsEnabled, true);

  store.getState().setActiveThreadId(null);
  store.getState().applyThreadScopedSettings(null, null);
  assert.equal(store.getState().toolsEnabled, false);
  assert.equal(store.getState().codeToolsEnabled, false);
  store.getState().setActiveThreadId(THREAD);
  store
    .getState()
    .applyThreadScopedSettings(THREAD, threadRows.rows.get(THREAD)!);
  assert.equal(store.getState().toolsEnabled, true);
  assert.equal(store.getState().codeToolsEnabled, true);
});

test("unloading preserves armed research without changing tool exclusivity", async (t) => {
  const runtime = await boot(t);
  const store = runtime.useChatRuntimeStore;
  store.getState().setToolsEnabled(true);
  store.getState().setCodeToolsEnabled(true);
  store.getState().setDeepResearchEnabled(true);
  store.getState().clearCheckpoint();
  assert.equal(store.getState().deepResearchEnabled, true);
  assert.equal(store.getState().toolsEnabled, false);
  assert.equal(store.getState().codeToolsEnabled, false);
  assert.equal(storage.get("unsloth_chat_deep_research_enabled"), "true");

  store.getState().setCodeToolsEnabled(true);
  assert.equal(store.getState().deepResearchEnabled, false);
});

for (const scope of ["defaults", "chat", "pending chat"] as const) {
  test(`${scope} disables Research for an incompatible local model and restores its preference`, async (t) => {
    const runtime = await boot(t);
    const store = runtime.useChatRuntimeStore;
    if (scope !== "defaults") {
      store.getState().setActiveThreadId(THREAD);
      if (scope === "pending chat") {
        runtime.beginThreadScopedPairing(THREAD);
      } else {
        store
          .getState()
          .applyThreadScopedSettings(THREAD, { deepResearchEnabled: false });
      }
    }
    store.getState().setDeepResearchEnabled(true);
    store.getState().clearCheckpoint();
    store.getState().setCheckpoint("unsloth/no-tools", null);
    store.setState({
      supportsTools: false,
      ...runtime.resolveToolsEnabledOnLoad(false),
    });
    assert.equal(store.getState().deepResearchEnabled, false);
    store.getState().setDeepResearchEnabled(true);
    assert.equal(store.getState().deepResearchEnabled, false);

    if (scope === "pending chat") {
      store
        .getState()
        .applyThreadScopedSettings(THREAD, { deepResearchEnabled: false });
    }
    store.getState().setPermissionMode("ask");
    await runtime.awaitThreadScopedSettingsWrite(THREAD);
    assert.equal(store.getState().deepResearchEnabled, false);
    if (scope !== "defaults") {
      assert.equal(threadRows.rows.get(THREAD)?.deepResearchEnabled, true);
      store
        .getState()
        .applyThreadScopedSettings(THREAD, threadRows.rows.get(THREAD)!);
      assert.equal(store.getState().deepResearchEnabled, false);
    } else {
      assert.equal(storage.get("unsloth_chat_deep_research_enabled"), "true");
    }

    store.getState().clearCheckpoint();
    store.getState().setCheckpoint(MODEL, null);
    store.setState({
      supportsTools: true,
      ...runtime.resolveToolsEnabledOnLoad(true),
    });
    assert.equal(store.getState().deepResearchEnabled, true);
    store.getState().setDeepResearchEnabled(false);
    store.setState(runtime.resolveToolsEnabledOnLoad(true));
    assert.equal(store.getState().deepResearchEnabled, false);
  });
}

test("late settings hydration cannot arm Research on an incompatible local model", async (t) => {
  const runtime = await boot(t, false);
  const store = runtime.useChatRuntimeStore;
  settingsHttp.settings = { deepResearchEnabled: true };
  store.setState({
    supportsTools: false,
    ...runtime.resolveToolsEnabledOnLoad(false),
  });
  await store.getState().hydratePersistedSettings();
  assert.equal(store.getState().deepResearchEnabled, false);
  assert.equal(storage.get("unsloth_chat_deep_research_enabled"), "true");
  store.setState({
    supportsTools: true,
    ...runtime.resolveToolsEnabledOnLoad(true),
  });
  assert.equal(store.getState().deepResearchEnabled, true);
});

test("suppressed Research remains scoped to its chat", async (t) => {
  const runtime = await boot(t);
  const store = runtime.useChatRuntimeStore;
  store.getState().setActiveThreadId(THREAD);
  store
    .getState()
    .applyThreadScopedSettings(THREAD, { deepResearchEnabled: true });
  store.setState({
    supportsTools: false,
    ...runtime.resolveToolsEnabledOnLoad(false),
  });
  store.getState().setActiveThreadId("other-chat");
  store
    .getState()
    .applyThreadScopedSettings("other-chat", { deepResearchEnabled: false });
  store.setState({
    supportsTools: true,
    ...runtime.resolveToolsEnabledOnLoad(true),
  });
  assert.equal(store.getState().deepResearchEnabled, false);
  store.getState().setActiveThreadId(THREAD);
  store
    .getState()
    .applyThreadScopedSettings(THREAD, { deepResearchEnabled: true });
  assert.equal(store.getState().deepResearchEnabled, true);
  store.getState().setToolsEnabled(true);
  store.setState(runtime.resolveToolsEnabledOnLoad(true));
  assert.equal(store.getState().toolsEnabled, true);
  assert.equal(store.getState().deepResearchEnabled, false);
});

const CLAMPED_TOOLS = [
  ["toolsEnabled", "setToolsEnabled"],
  ["codeToolsEnabled", "setCodeToolsEnabled"],
  ["imageToolsEnabled", "setImageToolsEnabled"],
  ["webFetchToolsEnabled", "setWebFetchToolsEnabled"],
] as const;

for (const [key, setter] of CLAMPED_TOOLS) {
  for (const scope of ["pending chat", "pending save", "saved chat"] as const) {
    test(`${key} survives capability suppression with a ${scope}`, async (t) => {
      const runtime = await boot(t);
      const store = runtime.useChatRuntimeStore;
      store.getState().setActiveThreadId(THREAD);
      if (scope === "pending chat") {
        runtime.beginThreadScopedPairing(THREAD);
      } else {
        store.getState().applyThreadScopedSettings(THREAD, { [key]: false });
      }
      store.getState()[setter](true);
      if (scope === "saved chat") {
        await runtime.awaitThreadScopedSettingsWrite(THREAD);
      }
      store.getState().clearCheckpoint();
      store.getState().setCheckpoint("unsloth/no-tools", null);
      store.setState({ [key]: false, supportsTools: false });
      if (scope === "pending chat") {
        store.getState().applyThreadScopedSettings(THREAD, { [key]: false });
      }
      store.getState().clearCheckpoint();
      store.getState().setPermissionMode("ask");
      await runtime.awaitThreadScopedSettingsWrite(THREAD);
      assert.equal(threadRows.rows.get(THREAD)?.[key], true);
      assert.equal(runtime.threadScopedOverride(key), true);

      store.getState()[setter](false);
      await runtime.awaitThreadScopedSettingsWrite(THREAD);
      assert.equal(threadRows.rows.get(THREAD)?.[key], false);
    });
  }

  test(`${key} keeps the default when a chat opens under an incompatible model`, async (t) => {
    const runtime = await boot(t);
    const store = runtime.useChatRuntimeStore;
    store.getState()[setter](true);
    store.setState({ [key]: false, supportsTools: false });
    store.getState().setActiveThreadId(THREAD);
    store.getState().applyThreadScopedSettings(THREAD, null);
    await runtime.awaitThreadScopedSettingsWrite(THREAD);
    assert.equal(threadRows.rows.get(THREAD)?.[key], true);
  });
}

test("Research can be selected while model capabilities are still loading", async (t) => {
  const runtime = await boot(t);
  const store = runtime.useChatRuntimeStore;
  store.getState().setCheckpoint("unsloth/no-tools", null);
  store.setState({ supportsTools: false });
  const lease = store.getState().beginModelLoading("loading");
  assert.ok(lease !== null);
  store.getState().setDeepResearchEnabled(true);
  store.getState().setCheckpoint(MODEL, null);
  store.setState({ supportsTools: true, ...runtime.resolveToolsEnabledOnLoad(true) });
  store.getState().endModelLoading(lease);
  assert.equal(store.getState().deepResearchEnabled, true);
});

test("Research hydration keeps the global default separate from a held chat edit", async (t) => {
  const runtime = await boot(t, false);
  const store = runtime.useChatRuntimeStore;
  settingsHttp.settings = { deepResearchEnabled: true };
  store.setState({ supportsTools: false });
  store.getState().setActiveThreadId(THREAD);
  runtime.beginThreadScopedPairing(THREAD);
  store.getState().setDeepResearchEnabled(false);
  await store.getState().hydratePersistedSettings();
  store.getState().applyThreadScopedSettings(THREAD, null);
  await runtime.awaitThreadScopedSettingsWrite(THREAD);
  assert.equal(threadRows.rows.get(THREAD)?.deepResearchEnabled, false);
  assert.equal(runtime.threadScopedDefault("deepResearchEnabled"), true);
  store.getState().setActiveThreadId(null);
  store.getState().applyThreadScopedSettings(null, null);
  store.setState({ supportsTools: true, ...runtime.resolveToolsEnabledOnLoad(true) });
  assert.equal(store.getState().deepResearchEnabled, true);
});

for (const scope of ["defaults", "chat"] as const) {
  test(`${scope} restores Research across incompatible and compatible external models`, async (t) => {
    const runtime = await boot(t);
    const store = runtime.useChatRuntimeStore;
    useExternalProvidersStore.getState().setProviders([{
      id: "tools-provider",
      providerType: "vllm",
      name: "Tool capability fixture",
      baseUrl: "http://localhost:8000/v1",
      models: ["capable", "unsupported"],
      createdAt: 0,
      updatedAt: 0,
    }]);
    setProviderModelCapabilities("vllm", {
      capable: { studio_tools: true },
      unsupported: { studio_tools: false },
    });
    if (scope === "chat") {
      store.getState().setActiveThreadId(THREAD);
      store.getState().applyThreadScopedSettings(THREAD, { deepResearchEnabled: false });
    }
    store.getState().setDeepResearchEnabled(true);
    store.getState().setCheckpoint("external::tools-provider::unsupported", null);
    assert.equal(store.getState().deepResearchEnabled, false);
    store.getState().setPermissionMode("ask");
    await runtime.awaitThreadScopedSettingsWrite(THREAD);
    assert.equal(
      scope === "chat"
        ? threadRows.rows.get(THREAD)?.deepResearchEnabled
        : storage.get("unsloth_chat_deep_research_enabled") === "true",
      true,
    );
    store.getState().setCheckpoint("external::tools-provider::capable", null);
    assert.equal(store.getState().deepResearchEnabled, true);
    if (scope === "chat") {
      store.getState().applyThreadScopedSettings(THREAD, threadRows.rows.get(THREAD)!);
      assert.equal(store.getState().deepResearchEnabled, true);
    }
    store.getState().setDeepResearchEnabled(false);
    store.getState().setCheckpoint("external::tools-provider::unsupported", null);
    store.getState().setCheckpoint("external::tools-provider::capable", null);
    assert.equal(store.getState().deepResearchEnabled, false);
  });
}

for (const scope of ["defaults", "chat", "pending chat"] as const) {
  test(`${scope} restores Research when switching from an incompatible local model to Codex`, async (t) => {
    const runtime = await boot(t);
    const store = runtime.useChatRuntimeStore;
    useExternalProvidersStore.getState().setProviders([{
      id: "codex",
      providerType: "openai_codex",
      name: "Codex fixture",
      baseUrl: "https://chatgpt.com/backend-api/codex",
      models: ["gpt-5.4"],
      createdAt: 0,
      updatedAt: 0,
    }]);
    setProviderModelCapabilities("openai_codex", {
      "gpt-5.4": { studio_tools: true },
    });
    if (scope !== "defaults") {
      store.getState().setActiveThreadId(THREAD);
      if (scope === "pending chat") {
        runtime.beginThreadScopedPairing(THREAD);
      } else {
        store.getState().applyThreadScopedSettings(THREAD, { deepResearchEnabled: false });
      }
    }
    store.getState().setDeepResearchEnabled(true);
    store.getState().clearCheckpoint();
    store.getState().setCheckpoint("unsloth/no-tools", null);
    store.setState({ supportsTools: false, ...runtime.resolveToolsEnabledOnLoad(false) });
    assert.equal(store.getState().deepResearchEnabled, false);
    store.getState().setCheckpoint("external::codex::gpt-5.4", null);
    assert.equal(store.getState().deepResearchEnabled, true);
    if (scope === "pending chat") {
      store.getState().applyThreadScopedSettings(THREAD, { deepResearchEnabled: false });
      assert.equal(store.getState().deepResearchEnabled, true);
    }
  });
}

test("an unresolved external provider preserves Research until its capabilities arrive", async (t) => {
  const runtime = await boot(t);
  const store = runtime.useChatRuntimeStore;
  store.getState().setDeepResearchEnabled(true);
  store.getState().setCheckpoint("external::late-provider::research-model", null);
  assert.equal(store.getState().deepResearchEnabled, false);
  assert.equal(storage.get("unsloth_chat_deep_research_enabled"), "true");
  store.getState().setDeepResearchEnabled(true);
  assert.equal(store.getState().deepResearchEnabled, false);
  useExternalProvidersStore.getState().setProviders([{
    id: "late-provider",
    providerType: "vllm",
    name: "Late provider fixture",
    baseUrl: "http://localhost:8000/v1",
    models: ["research-model"],
    createdAt: 0,
    updatedAt: 0,
  }]);
  setProviderModelCapabilities("vllm", { "research-model": { studio_tools: true } });
  store.setState({ supportsTools: true, ...runtime.resolveToolsEnabledOnLoad(true) });
  assert.equal(store.getState().deepResearchEnabled, true);
});

test("a temporary chat keeps Research off when another tab stores it on", async (t) => {
  const runtime = await boot(t);
  const store = runtime.useChatRuntimeStore;
  useExternalProvidersStore.getState().setProviders([{
    id: "codex",
    providerType: "openai_codex",
    name: "Codex fixture",
    baseUrl: "https://chatgpt.com/backend-api/codex",
    models: ["gpt-5.4"],
    createdAt: 0,
    updatedAt: 0,
  }]);
  setProviderModelCapabilities("openai_codex", {
    "gpt-5.4": { studio_tools: true },
  });
  store.getState().setIncognito(true);
  storage.set("unsloth_chat_deep_research_enabled", "true");
  assert.equal(runtime.resolveToolsEnabledOnLoad(true).deepResearchEnabled, false);
  store.getState().setCheckpoint("external::codex::gpt-5.4", null);
  assert.equal(store.getState().deepResearchEnabled, false);
  store.getState().clearCheckpoint();
  assert.equal(store.getState().deepResearchEnabled, false);
});

test("Kimi keeps Search off and Thinking on when a chat opens without stored pills", async (t) => {
  const runtime = await boot(t);
  const store = runtime.useChatRuntimeStore;
  store.getState().setToolsEnabled(true);
  assert.equal(storage.get("unsloth_chat_tools_enabled"), "true");
  useExternalProvidersStore.getState().setProviders([{
    id: "kimi",
    providerType: "kimi",
    name: "Kimi fixture",
    baseUrl: "https://api.moonshot.ai/v1",
    models: ["kimi-k2.5"],
    createdAt: 0,
    updatedAt: 0,
  }]);
  store.getState().setCheckpoint("external::kimi::kimi-k2.5", null);
  store.setState({
    supportsTools: false,
    supportsBuiltinWebSearch: true,
    toolsEnabled: false,
    reasoningEnabled: true,
  });
  store.getState().setActiveThreadId(THREAD);
  store.getState().applyThreadScopedSettings(THREAD, null);
  assert.equal(store.getState().toolsEnabled, false);
  assert.equal(store.getState().reasoningEnabled, true);
  await runtime.awaitThreadScopedSettingsWrite(THREAD);
  assert.equal(threadRows.rows.get(THREAD)?.toolsEnabled, false);
  assert.equal(threadRows.rows.get(THREAD)?.reasoningEnabled, true);
  store.getState().setActiveThreadId(null);
  store.getState().applyThreadScopedSettings(null, null);
  assert.equal(store.getState().toolsEnabled, false);
  assert.equal(store.getState().reasoningEnabled, true);
  assert.equal(storage.get("unsloth_chat_tools_enabled"), "true");
});

test("unloading drops a Search pill the provider lit over the stored preference", async (t) => {
  const runtime = await boot(t);
  const store = runtime.useChatRuntimeStore;
  store.getState().setToolsEnabled(false);
  store.getState().setCodeToolsEnabled(false);
  store.setState({ toolsEnabled: true, codeToolsEnabled: true });
  assert.equal(storage.get("unsloth_chat_tools_enabled"), "false");
  store.getState().clearCheckpoint();
  assert.equal(store.getState().toolsEnabled, false);
  assert.equal(store.getState().codeToolsEnabled, false);
  store.getState().setToolsEnabled(true);
  store.getState().clearCheckpoint();
  assert.equal(store.getState().toolsEnabled, true);
});

test("a held edit committed on leave cannot re-arm Research on an incompatible local model", async (t) => {
  const runtime = await boot(t);
  const store = runtime.useChatRuntimeStore;
  store.getState().setDeepResearchEnabled(true);
  store.getState().clearCheckpoint();
  store.getState().setCheckpoint("unsloth/no-tools", null);
  store.setState({ supportsTools: false, ...runtime.resolveToolsEnabledOnLoad(false) });
  assert.equal(store.getState().deepResearchEnabled, false);
  store.getState().setActiveThreadId(THREAD);
  runtime.beginThreadScopedPairing(THREAD);
  store.getState().setMcpEnabledForChat(true);
  store.getState().setActiveThreadId(null);
  const commit = runtime.commitHeldThreadScopedEditsToTheirThread();
  assert.equal(store.getState().deepResearchEnabled, false);
  assert.equal(store.getState().mcpEnabledForChat, false);
  await commit;
  assert.equal(threadRows.rows.get(THREAD)?.deepResearchEnabled, false);
  assert.equal(threadRows.rows.get(THREAD)?.mcpEnabledForChat, true);
  assert.equal(storage.get("unsloth_chat_deep_research_enabled"), "true");
  store.getState().clearCheckpoint();
  store.getState().setCheckpoint(MODEL, null);
  store.setState({ supportsTools: true, ...runtime.resolveToolsEnabledOnLoad(true) });
  assert.equal(store.getState().deepResearchEnabled, true);
});

test("a chat's stored Search and Code stay off in the composer under a model without tools", async (t) => {
  const runtime = await boot(t);
  const store = runtime.useChatRuntimeStore;
  store.getState().clearCheckpoint();
  store.getState().setCheckpoint("unsloth/no-tools", null);
  store.setState({ supportsTools: false, ...runtime.resolveToolsEnabledOnLoad(false) });
  store.getState().setActiveThreadId(THREAD);
  store.getState().applyThreadScopedSettings(THREAD, {
    toolsEnabled: true,
    codeToolsEnabled: true,
  });
  assert.equal(store.getState().toolsEnabled, false);
  assert.equal(store.getState().codeToolsEnabled, false);
  assert.equal(runtime.threadScopedOverride("toolsEnabled"), true);
  store.getState().setPermissionMode("ask");
  await runtime.awaitThreadScopedSettingsWrite(THREAD);
  assert.equal(threadRows.rows.get(THREAD)?.toolsEnabled, true);
  assert.equal(threadRows.rows.get(THREAD)?.codeToolsEnabled, true);
  store.getState().clearCheckpoint();
  assert.equal(store.getState().toolsEnabled, true);
  store.getState().setCheckpoint(MODEL, null);
  store.setState({ supportsTools: true, ...runtime.resolveToolsEnabledOnLoad(true) });
  assert.equal(store.getState().toolsEnabled, true);
  assert.equal(store.getState().codeToolsEnabled, true);
});

for (const pills of [
  { toolsEnabled: true, codeToolsEnabled: true },
  { deepResearchEnabled: true },
] as const) {
  test(`a snapshot written while a model loads keeps ${Object.keys(pills).join(" and ")} on the chat`, async (t) => {
    const runtime = await boot(t);
    const store = runtime.useChatRuntimeStore;
    store.getState().clearCheckpoint();
    store.getState().setCheckpoint("unsloth/no-tools", null);
    store.setState({ supportsTools: false, ...runtime.resolveToolsEnabledOnLoad(false) });
    store.getState().setActiveThreadId(THREAD);
    store.getState().applyThreadScopedSettings(THREAD, pills);
    for (const key of Object.keys(pills) as (keyof typeof pills)[]) {
      assert.equal(store.getState()[key], false, key);
    }
    const lease = store.getState().beginModelLoading("loading");
    assert.ok(lease !== null);
    store.getState().setPermissionMode("ask");
    await runtime.awaitThreadScopedSettingsWrite(THREAD);
    store.setState({ supportsTools: false, ...runtime.resolveToolsEnabledOnLoad(false) });
    store.getState().setPermissionMode("auto");
    await runtime.awaitThreadScopedSettingsWrite(THREAD);
    for (const key of Object.keys(pills) as (keyof typeof pills)[]) {
      assert.equal(threadRows.rows.get(THREAD)?.[key], true, key);
      assert.equal(runtime.threadScopedOverride(key), true, key);
    }
    store.getState().setCheckpoint(MODEL, null);
    store.setState({ supportsTools: true, ...runtime.resolveToolsEnabledOnLoad(true) });
    store.getState().endModelLoading(lease);
    for (const key of Object.keys(pills) as (keyof typeof pills)[]) {
      assert.equal(store.getState()[key], true, key);
    }
  });
}

for (const leave of [false, true]) {
  test(`Kimi keeps a Thinking click over a held Search click when the chat ${leave ? "is left" : "opens"}`, async (t) => {
    const runtime = await boot(t);
    const store = runtime.useChatRuntimeStore;
    useExternalProvidersStore.getState().setProviders([{
      id: "kimi",
      providerType: "kimi",
      name: "Kimi fixture",
      baseUrl: "https://api.moonshot.ai/v1",
      models: ["kimi-k2.5"],
      createdAt: 0,
      updatedAt: 0,
    }]);
    store.getState().setCheckpoint("external::kimi::kimi-k2.5", null);
    store.setState({
      supportsTools: false,
      supportsBuiltinWebSearch: true,
      toolsEnabled: false,
      reasoningEnabled: false,
    });
    store.getState().setActiveThreadId(THREAD);
    runtime.beginThreadScopedPairing(THREAD);
    store.getState().setToolsEnabled(true);
    store.getState().setReasoningEnabled(true);
    store.getState().setToolsEnabled(false, { persist: false });
    if (leave) {
      store.getState().setActiveThreadId(null);
      await runtime.commitHeldThreadScopedEditsToTheirThread();
    } else {
      store.getState().applyThreadScopedSettings(THREAD, null);
      assert.equal(store.getState().toolsEnabled, false);
      assert.equal(store.getState().reasoningEnabled, true);
      await runtime.awaitThreadScopedSettingsWrite(THREAD);
    }
    assert.equal(threadRows.rows.get(THREAD)?.toolsEnabled, false);
    assert.equal(threadRows.rows.get(THREAD)?.reasoningEnabled, true);
  });
}

for (const saved of [false, true]) {
  test(`Kimi's Thinking click after ${saved ? "a saved" : "an unsaved"} Search click leaves Search ${saved ? "on" : "off"} for the next model`, async (t) => {
    const runtime = await boot(t);
    const store = runtime.useChatRuntimeStore;
    useExternalProvidersStore.getState().setProviders([{
      id: "kimi",
      providerType: "kimi",
      name: "Kimi fixture",
      baseUrl: "https://api.moonshot.ai/v1",
      models: ["kimi-k2.5"],
      createdAt: 0,
      updatedAt: 0,
    }]);
    store.getState().setCheckpoint("external::kimi::kimi-k2.5", null);
    store.setState({
      supportsTools: false,
      supportsBuiltinWebSearch: true,
      toolsEnabled: false,
      reasoningEnabled: true,
    });
    store.getState().setActiveThreadId(THREAD);
    store.getState().applyThreadScopedSettings(THREAD, {
      toolsEnabled: false,
      reasoningEnabled: true,
    });
    store.getState().setToolsEnabled(true);
    store.getState().setReasoningEnabled(false, { persist: false });
    if (saved) await runtime.awaitThreadScopedSettingsWrite(THREAD);
    store.getState().setReasoningEnabled(true);
    store.getState().setToolsEnabled(false, { persist: false });
    assert.equal(runtime.threadScopedOverride("toolsEnabled"), saved);
    store.getState().clearCheckpoint();
    assert.equal(store.getState().toolsEnabled, saved);
    await runtime.awaitThreadScopedSettingsWrite(THREAD);
    assert.equal(threadRows.rows.get(THREAD)?.toolsEnabled, saved);
  });
}

test("enabling Search on a chat whose stored Research is clamped off clears the stored Research", async (t) => {
  const runtime = await boot(t);
  const store = runtime.useChatRuntimeStore;
  useExternalProvidersStore.getState().setProviders([{
    id: "search-only",
    providerType: "vllm",
    name: "Search-only fixture",
    baseUrl: "http://localhost:8000/v1",
    models: ["no-studio-tools"],
    createdAt: 0,
    updatedAt: 0,
  }]);
  setProviderModelCapabilities("vllm", { "no-studio-tools": { studio_tools: false } });
  store.getState().setCheckpoint("external::search-only::no-studio-tools", null);
  store.setState({ supportsTools: false, supportsBuiltinWebSearch: true });
  store.getState().setActiveThreadId(THREAD);
  store.getState().applyThreadScopedSettings(THREAD, { deepResearchEnabled: true });
  assert.equal(store.getState().deepResearchEnabled, false);
  assert.equal(runtime.threadScopedOverride("deepResearchEnabled"), true);
  store.getState().setToolsEnabled(true);
  await runtime.awaitThreadScopedSettingsWrite(THREAD);
  assert.equal(threadRows.rows.get(THREAD)?.toolsEnabled, true);
  assert.equal(threadRows.rows.get(THREAD)?.deepResearchEnabled, false);
  assert.equal(runtime.threadScopedOverride("deepResearchEnabled"), false);
});

test("Research follows the providers store when the browser mirror is empty", async (t) => {
  const runtime = await boot(t);
  const store = runtime.useChatRuntimeStore;
  useExternalProvidersStore.setState({
    providers: [{
      id: "codex",
      providerType: "openai_codex",
      name: "Codex fixture",
      baseUrl: "https://chatgpt.com/backend-api/codex",
      models: ["gpt-5.4"],
      createdAt: 0,
      updatedAt: 0,
    }],
  });
  setProviderModelCapabilities("openai_codex", {
    "gpt-5.4": { studio_tools: true },
  });
  assert.equal(storage.get("unsloth_chat_external_providers"), undefined);
  store.getState().setCheckpoint("external::codex::gpt-5.4", null);
  store.getState().setDeepResearchEnabled(true);
  assert.equal(store.getState().deepResearchEnabled, true);
  assert.equal(runtime.resolveToolsEnabledOnLoad(true).deepResearchEnabled, true);
});

test("a chat stored before the pill keys has no Search override of its own", async (t) => {
  const runtime = await boot(t);
  const store = runtime.useChatRuntimeStore;
  store.getState().setActiveThreadId(THREAD);
  store.getState().applyThreadScopedSettings(THREAD, { permissionMode: "ask" });
  assert.equal(runtime.threadScopedOverride("toolsEnabled"), undefined);
  assert.equal(runtime.resolveToolsEnabledOnLoad(true).toolsEnabled, true);
  assert.equal(runtime.resolveToolsEnabledOnLoad(true).codeToolsEnabled, true);
  store.getState().setToolsEnabled(false);
  assert.equal(runtime.threadScopedOverride("toolsEnabled"), false);
});

test("a fresh profile starts with Search and Code on, and a stored choice wins", async (t) => {
  const runtime = await boot(t);
  const store = runtime.useChatRuntimeStore;
  assert.equal(storage.get("unsloth_chat_tools_enabled"), undefined);
  assert.equal(storage.get("unsloth_chat_code_tools_enabled"), undefined);
  assert.deepEqual(runtime.resolveToolsEnabledOnLoad(true), {
    toolsEnabled: true,
    codeToolsEnabled: true,
    deepResearchEnabled: false,
  });
  store.getState().setToolsEnabled(false);
  store.getState().setCodeToolsEnabled(false);
  assert.equal(runtime.resolveToolsEnabledOnLoad(true).toolsEnabled, false);
  assert.equal(runtime.resolveToolsEnabledOnLoad(true).codeToolsEnabled, false);
});

test("a same-model reload keeps the Search and Code pills the model was running with", () => {
  const hook = readFileSync(
    new URL("../src/features/chat/hooks/use-chat-model-runtime.ts", import.meta.url),
    "utf8",
  );
  const marker = "...(reloadingSameModel && supportsTools";
  const reload = hook.slice(hook.indexOf(marker), hook.indexOf(marker) + 400);
  assert.match(
    reload,
    /\?\s*\{\s*toolsEnabled: stateBeforeUnload\.toolsEnabled,\s*codeToolsEnabled: stateBeforeUnload\.codeToolsEnabled,\s*\}\s*:\s*resolveToolsEnabledOnLoad\(supportsTools\)/,
  );
});