#3463 · Provider defaults overwrite earlier preferences

import { writeFileSync } from "node:fs";
import { join } from "node:path";
import { createHash } from "node:crypto";
import { afterAll, describe, expect, it } from "vitest";
import { eq } from "drizzle-orm";
import { getProjectExecutionDefaults, getThreadExecutionOverride, projectExecutionDefaults, setThreadExecutionOverride, upsertProjectExecutionDefaults } from "@bb/db";
import { createTestAppHarness } from "../../helpers/test-app.js";
import { seedHostSession, seedProjectWithSource, seedEnvironment, seedThread, seedThreadRuntimeState } from "../../helpers/seed.js";
import { registerProviderHostRpcResponder } from "../../helpers/host-rpc.js";
import { availableModelFixture } from "../../helpers/available-models.js";
import { resolveProjectExecutionDefaultsForCreate, rememberProjectExecutionDefaultsForCreate } from "../../../src/services/threads/project-execution-defaults.js";
import { resolveExistingThreadExecutionPlan } from "../../../src/services/threads/thread-execution-plan.js";
import { applyThreadExecutionOverride } from "../../../src/services/threads/thread-execution-override.js";
import type { ThreadCreateServiceRequest } from "../../../src/services/threads/thread-create-request.js";

const evidence: object[] = [];
afterAll(() => writeFileSync("issue-3463-results.json", JSON.stringify(evidence, null, 2) + "\n"));
const a = { providerId: "synthetic-a", model: "gpt-5-mini", reasoningLevel: "low", permissionMode: "full", serviceTier: "default" } as const;
const b = { providerId: "synthetic-b", model: "claude-haiku-4-5", reasoningLevel: "high", permissionMode: "full", serviceTier: "default" } as const;
async function setup() {
  const harness = await createTestAppHarness({ seedFirstPartyProviders: false, extraProviders: [a, b].map(({ providerId }) => ({
    pluginId: `provider-${providerId}`,
    declaration: { composerActions: [], id: providerId, displayName: providerId, maintenance: { health: false, usage: false, installation: false }, capabilities: { supportsServiceTier: true, supportsNativeUserQuestion: false, fork: "none", supportsManualCompaction: false, supportsThreadArchive: false, supportsThreadRename: false, permissionModes: ["full"], reasoningLevels: ["low", "medium", "high"] } },
  })) });
  const { host, session } = seedHostSession(harness.deps);
  const { project } = seedProjectWithSource(harness.deps, { hostId: host.id });
  const environment = seedEnvironment(harness.deps, { hostId: host.id, projectId: project.id });
  const thread = seedThread(harness.deps, { projectId: project.id, environmentId: environment.id, providerId: a.providerId });
  const save = (value: typeof a | typeof b) => upsertProjectExecutionDefaults(harness.db, { projectId: project.id, ...value });
  const read = () => getProjectExecutionDefaults(harness.db, { projectId: project.id });
  const plan = () => resolveExistingThreadExecutionPlan(harness.deps, { threadId: thread.id, input: {}, executionSource: "client/turn/requested" });
  return { harness, host, session, project, environment, thread, save, read, plan };
}

describe("current provider switching defaults", () => {
  it("replaces stored provider preferences only for eligible app creation", async () => {
    const s = await setup();
    try {
      s.save(a);
      const request: ThreadCreateServiceRequest = { projectId: s.project.id, providerId: b.providerId, origin: "app", originKind: null, startedOnBehalfOf: null, input: [], environment: { type: "host", hostId: s.host.id, workspace: { type: "unmanaged", path: null } }, pluginMetadata: null, titleFallback: null, visibility: "visible" };
      rememberProjectExecutionDefaultsForCreate(s.harness.deps, { request: { ...request, environment: { type: "reuse", environmentId: s.environment.id } }, execution: b });
      expect(s.read()).toEqual(a);
      rememberProjectExecutionDefaultsForCreate(s.harness.deps, { request: { ...request, origin: "cli" }, execution: b });
      expect(s.read()).toEqual(a);
      rememberProjectExecutionDefaultsForCreate(s.harness.deps, { request, execution: b });
      expect(s.read()).toEqual(b);
      const rows = s.harness.db.select({ providerId: projectExecutionDefaults.providerId, model: projectExecutionDefaults.model }).from(projectExecutionDefaults).where(eq(projectExecutionDefaults.projectId, s.project.id)).all();
      expect(rows).toEqual([{ providerId: b.providerId, model: b.model }]);
      evidence.push({ case: "remember policy", reusePreservedA: true, cliPreservedA: true, eligibleAppStored: s.read(), rows });
    } finally { await s.harness.cleanup(); }
  });

  it("filters mismatched project reads while retaining explicit and last-execution controls", async () => {
    const s = await setup();
    try {
      s.save(a);
      expect((await s.plan()).resolvedExecution.model).toBe(a.model);
      s.save(b);
      const automatic = resolveProjectExecutionDefaultsForCreate(s.harness.deps, { projectId: s.project.id });
      const explicitA = resolveProjectExecutionDefaultsForCreate(s.harness.deps, { projectId: s.project.id, providerId: a.providerId });
      expect(automatic).toMatchObject({ providerId: b.providerId, executionDefaults: b });
      expect(explicitA).toMatchObject({ providerId: a.providerId, executionDefaults: null });
      await expect(s.plan()).rejects.toThrow("has no stored execution model");
      setThreadExecutionOverride(s.harness.db, { threadId: s.thread.id, modelOverride: a.model, reasoningLevelOverride: "low" });
      expect((await s.plan()).resolvedExecution.model).toBe(a.model);
      setThreadExecutionOverride(s.harness.db, { threadId: s.thread.id, modelOverride: null, reasoningLevelOverride: null });
      seedThreadRuntimeState(s.harness.deps, { threadId: s.thread.id, environmentId: s.environment.id, providerThreadId: "synthetic-history", model: a.model, reasoningLevel: "low", permissionMode: "full" });
      expect((await s.plan()).resolvedExecution.model).toBe(a.model);
      evidence.push({ case: "read policies", automatic, explicitA, noModelAfterSwitch: true, modelOverridePreserved: a.model, lastExecutionPreserved: a.model });
    } finally { await s.harness.cleanup(); }
  });

  it("exercises cross-provider fallback through the actual override service", async () => {
    const s = await setup();
    const bytes = Buffer.from("export {};\n");
    const path = join(s.harness.config.dataDir, "synthetic-artifact.mjs");
    writeFileSync(path, bytes);
    s.harness.deps.pluginHostArtifacts.set(`provider-${a.providerId}`, { path, digest: createHash("sha256").update(bytes).digest("hex"), byteLength: bytes.length, generation: "synthetic" });
    const responder = registerProviderHostRpcResponder(s.harness, { hostId: s.host.id, sessionId: s.session.id, modelsByProviderId: { [a.providerId]: { models: [availableModelFixture({ model: a.model, reasoningLevels: ["low"], isDefault: true })], selectedOnlyModels: [] } } });
    try {
      const update = () => applyThreadExecutionOverride(s.harness.deps, { thread: s.thread, patch: { reasoningLevel: "high" } });
      s.save(a);
      await expect(update()).rejects.toThrow('not supported by model "gpt-5-mini"');
      s.save(b);
      await update();
      expect(getThreadExecutionOverride(s.harness.db, s.thread.id)).toEqual({ modelOverride: null, reasoningLevelOverride: "high" });
      setThreadExecutionOverride(s.harness.db, { threadId: s.thread.id, modelOverride: null, reasoningLevelOverride: null });
      seedThreadRuntimeState(s.harness.deps, { threadId: s.thread.id, environmentId: s.environment.id, providerThreadId: "synthetic-history", model: a.model, reasoningLevel: "low", permissionMode: "full" });
      await expect(update()).rejects.toThrow('not supported by model "gpt-5-mini"');
      evidence.push({ case: "override fallback", matchingModelRejectsHigh: true, foreignModelPermitsProviderLevelHigh: true, lastExecutionRestoresModelValidation: true, requestedProviders: responder.requests.map(x => x.command.type === "provider.list_models" ? x.command.providerId : x.command.type) });
    } finally { responder.unregister(); await s.harness.cleanup(); }
  });
});

[
  {
    "case": "remember policy",
    "reusePreservedA": true,
    "cliPreservedA": true,
    "eligibleAppStored": {
      "providerId": "synthetic-b",
      "model": "claude-haiku-4-5",
      "reasoningLevel": "high",
      "permissionMode": "full",
      "serviceTier": "default"
    },
    "rows": [
      {
        "providerId": "synthetic-b",
        "model": "claude-haiku-4-5"
      }
    ]
  },
  {
    "case": "read policies",
    "automatic": {
      "executionDefaults": {
        "providerId": "synthetic-b",
        "model": "claude-haiku-4-5",
        "reasoningLevel": "high",
        "permissionMode": "full",
        "serviceTier": "default"
      },
      "providerId": "synthetic-b",
      "providerFallbackCandidates": [],
      "requestedModel": null
    },
    "explicitA": {
      "executionDefaults": null,
      "providerId": "synthetic-a",
      "providerFallbackCandidates": [],
      "requestedModel": null
    },
    "noModelAfterSwitch": true,
    "modelOverridePreserved": "gpt-5-mini",
    "lastExecutionPreserved": "gpt-5-mini"
  },
  {
    "case": "override fallback",
    "matchingModelRejectsHigh": true,
    "foreignModelPermitsProviderLevelHigh": true,
    "lastExecutionRestoresModelValidation": true,
    "requestedProviders": [
      "synthetic-a"
    ]
  }
]