@vellumai/assistant 0.12.3 → 0.12.4-dev.202609231620.a15f321

package/src/runtime/routes/__tests__/plugins-routes.test.ts

@@ -165,8 +165,14 @@ const getCatalogSpy = mock(
   },
 );
 
+const getInstalledMetadataCatalogSpy = mock(
+  (ref: string, deps: SearchPluginsDeps): Promise<PluginCatalog> =>
+    getCatalogSpy(ref, deps),
+);
+
 mock.module("../../../cli/lib/plugin-catalog-cache.js", () => ({
   getPluginCatalog: getCatalogSpy,
+  getPluginCatalogForInstalledMetadata: getInstalledMetadataCatalogSpy,
 }));
 
 // Mock uninstallPlugin. The handler's error mapping is the wiring under
@@ -471,6 +477,7 @@ beforeEach(() => {
 describe("GET /v1/plugins", () => {
   beforeEach(() => {
     getCatalogSpy.mockClear();
+    getInstalledMetadataCatalogSpy.mockClear();
     // Default to an empty catalog so every installed plugin's category resolves
     // to `null` (bucketed under "system"). Tests that exercise real categories
     // override this.
@@ -849,6 +856,7 @@ describe("GET /v1/plugins", () => {
     );
 
     const map = await loadCategoryMapBounded();
+    expect(getInstalledMetadataCatalogSpy).toHaveBeenCalledTimes(1);
     expect(map.get("alpha")).toBe("productivity");
   });
 

package/src/runtime/routes/conversation-list-routes.ts

@@ -31,16 +31,14 @@ import {
 import { resolveConversationId } from "../../persistence/conversation-key-store.js";
 import {
   type ConversationListFilter,
+  type ConversationListTypeFilter,
   countConversations,
   countConversationSections,
   countUnreadConversations,
   listConversations,
   listPinnedConversations,
 } from "../../persistence/conversation-queries.js";
-import {
-  ASSISTANT_INITIATED_GROUP_ID,
-  type ConversationType,
-} from "../../persistence/conversation-types.js";
+import { ASSISTANT_INITIATED_GROUP_ID } from "../../persistence/conversation-types.js";
 import { getBindingsForConversations } from "../../persistence/external-conversation-store.js";
 import { listGroups } from "../../persistence/group-crud.js";
 import { UserError } from "../../util/errors.js";
@@ -252,12 +250,14 @@ function handleListConversations({
   const limit = Number(queryParams.limit ?? 50);
   const offset = Number(queryParams.offset ?? 0);
   // "background" is the back-compat umbrella (background + scheduled); newer
-  // clients can pass "scheduled" to load only the Scheduled section. Absent
-  // defaults to the standard foreground list.
-  const conversationType: ConversationType =
+  // clients can pass "scheduled" to load only the Scheduled section, or "all"
+  // to page a user's whole history in one cursor. Absent defaults to the
+  // standard foreground list.
+  const conversationType: ConversationListTypeFilter =
     parseEnumQueryParam(queryParams, "conversationType", [
       "background",
       "scheduled",
+      "all",
     ]) ?? "standard";
   // Defaults to `active` so sidebar restores no longer pull archived rows.
   // The Archive page opts into `archived` to render only archived rows
@@ -294,7 +294,9 @@ function handleListConversations({
      read withholds them, so they appear in their own section and nowhere
      else. Confined to `standard`: the background and scheduled buckets are
      back-compat umbrellas addressed by conversation type, and narrowing them
-     by source would drop rows their callers still page through. Confined to
+     by source would drop rows their callers still page through, while `all`
+     is a whole-history read with no second section to defer those rows to,
+     so withholding there would simply lose them. Confined to
      active reads too: the Archive view asks `archiveStatus=archived` with no
      `groupId`, and the section only ever lists active rows, so withholding
      there would leave an archived section thread visible nowhere. */
@@ -584,10 +586,7 @@ function handleMarkUnread({ body = {}, headers }: RouteHandlerArgs) {
   }
 }
 
-function handleGetConversation({
-  pathParams = {},
-  headers,
-}: RouteHandlerArgs) {
+function handleGetConversation({ pathParams = {}, headers }: RouteHandlerArgs) {
   const detail = buildConversationDetailResponse(
     pathParams.id!,
     localeFromAcceptLanguage(headers?.["accept-language"]),
@@ -633,8 +632,11 @@ export const ROUTES: RouteDefinition[] = [
         type: "string",
         required: false,
         description:
-          'Filter by conversation type. Pass "background" to list background and scheduled conversations together (the back-compat umbrella), or "scheduled" to list only scheduled conversations.',
-        schema: { type: "string", enum: ["background", "scheduled"] },
+          'Filter by conversation type. Pass "background" to list background and scheduled conversations together (the back-compat umbrella), "scheduled" to list only scheduled conversations, or "all" for the union of the standard listing and that umbrella, so one paginated cursor spans every type. Combine "all" with archiveStatus=all for a whole-history read; rows are recency-ordered (COALESCE(last_message_at, updated_at) descending) like every other list read, and pinned rows are never appended to it.',
+        schema: {
+          type: "string",
+          enum: ["background", "scheduled", "all"],
+        },
       },
       {
         name: "archiveStatus",

package/src/runtime/routes/conversation-query-routes.ts

@@ -65,6 +65,7 @@ import {
 } from "../../config/schemas/llm.js";
 import { VALID_MEMORY_EMBEDDING_PROVIDERS } from "../../config/schemas/memory-storage.js";
 import { ServiceModeSchema } from "../../config/schemas/services.js";
+import { isSidebarDoneEnabled } from "../../config/sidebar-done-gate.js";
 import {
   describeShadowedConfigSet,
   findSubstrateShadowing,
@@ -2108,6 +2109,9 @@ async function handleSearchConversations({
     query: q,
     limit,
     maxMessagesPerConversation: maxMessages,
+    // Under `sidebar-done` a done chat is filed rather than hidden, so the
+    // agent's own history search reaches it the same way the user's does.
+    includeArchived: isSidebarDoneEnabled(),
   });
   return { query: q, results };
 }

package/src/runtime/routes/conversation-routes.ts

@@ -42,7 +42,7 @@ import {
   supportsHostProxy,
 } from "../../channels/types.js";
 import { isAssistantFeatureFlagEnabled } from "../../config/assistant-feature-flags.js";
-import { getUserSelectableProfilesForProvider } from "../../config/default-profile-catalog.js";
+import { getConversationProfilesForProvider } from "../../config/default-profile-catalog.js";
 import { isHttpAuthDisabled } from "../../config/env.js";
 import { getConfig } from "../../config/loader.js";
 import { isModeSessionRecoveryHealthy } from "../../config/session-groups-gate.js";
@@ -1754,7 +1754,9 @@ export async function handleSendMessage(
   }
   if (requestedInferenceProfile !== undefined) {
     const { llm } = getConfig();
-    const profiles = getUserSelectableProfilesForProvider(
+    // The conversation view: a sticky pin runs the main agent's turns, so a
+    // profile whose model returns verdicts rather than text is not offered.
+    const profiles = getConversationProfilesForProvider(
       llm.profiles,
       llm.defaultProvider ?? null,
     );

package/src/runtime/routes/diagnostics-routes.ts

@@ -22,7 +22,6 @@ import {
   getConfiguredProvider,
   userMessage,
 } from "../../providers/provider-send-message.js";
-import { isMaxTokensStopReason } from "../../providers/stop-reasons.js";
 import { getLogger } from "../../util/logger.js";
 import { safeStringSlice } from "../../util/unicode.js";
 import { ACTOR_PRINCIPALS } from "../auth/route-policy.js";
@@ -73,56 +72,14 @@ function buildAppMetadataBlock(context: DictationContext): string {
   ].join("\n");
 }
 
-function buildCombinedDictationPrompt(
-  body: DictationBody,
-  stylePrompt?: string,
-): string {
-  // Every line here is read on every hold, so the prompt says each thing
-  // once and leaves the model no reasoning to write.
-  const sections = [
-    "You are a voice input assistant. Given a speech transcription, classify it and, if it is dictation, clean it up.",
-    "",
-    "## Classification",
+function buildDictationClassificationPrompt(body: DictationBody): string {
+  return [
+    "Classify the speech transcription without rewriting it.",
     "dictation: the user is composing text to be typed as-is.",
-    "action: the user is asking an assistant to do something (send, message, open, search, create, schedule). Return the transcription unchanged.",
+    "action: the user is asking an assistant to do something (send, message, open, search, create, schedule).",
     `Cursor in text field: ${body.context.cursorInTextField ? "yes" : "no"}. If yes, lean toward dictation unless the intent to command is clear.`,
-    "",
-    "## Cleanup",
-    "- Fix grammar, punctuation and capitalization; remove filler words",
-    "- Rewrite hedging into clear statements, keeping the speaker's meaning",
-    "- When the speaker enumerates items, lay them out as a list, one per line",
-    "- Keep the user's natural voice; do not over-formalize casual speech",
-  ];
-
-  if (stylePrompt) {
-    sections.push(
-      "",
-      "## User Style (highest priority)",
-      "The user's own writing preferences. They override the tone guidance below.",
-      "",
-      stylePrompt,
-    );
-  }
-
-  sections.push(
-    "",
-    "## Tone",
-    stylePrompt
-      ? "Fallback guidance where the User Style above is silent:"
-      : "Adapt tone to the active application:",
-    "- Email: professional but warm, greetings and sign-offs where they fit",
-    "- Slack: casual and conversational",
-    "- Code editors: technical and concise",
-    "- Terminal: terse, command-like",
-    "- Messages: very casual, short sentences",
-    "- Notes and docs: neutral, clear writing",
-    "- Otherwise: the user's natural voice",
-    "The window title may name the recipient; adapt formality to the apparent relationship.",
-    "",
     buildAppMetadataBlock(body.context),
-  );
-
-  return sections.join("\n");
+  ].join("\n");
 }
 
 function buildCommandPrompt(body: DictationBody, stylePrompt?: string): string {
@@ -184,44 +141,10 @@ function buildCommandPrompt(body: DictationBody, stylePrompt?: string): string {
 
 export function computeMaxTokens(inputLength: number): number {
   const estimatedInputTokens = Math.ceil(inputLength / 3);
-  // The cleanup tool call carries the whole transcript back in its `text`
-  // argument, plus a `reasoning` string and the JSON scaffolding around both,
-  // so the budget has to cover well more than the input alone. `max_tokens` is
-  // a ceiling rather than a target: a call that stops short of it costs no
-  // extra latency.
+  // Leave room for the transformed selection and tool-call JSON.
   return Math.max(512, estimatedInputTokens * 2 + 256);
 }
 
-export type CleanupRejection = "truncated";
-
-/**
- * Decide whether the cleanup model's rewrite is safe to use as the payload.
- *
- * The rewrite replaces what the user actually said. A token-cap stop means the
- * tool JSON was cut mid-argument, so however complete the `text` argument
- * happens to look, it is a fragment; the raw transcript is the safer payload
- * then. Unpolished beats wrong.
- *
- * Whether a shorter rewrite still preserved the meaning is the model's call
- * (the prompt asks it to drop fillers and tighten phrasing), so there is no
- * length check here: a deterministic ratio cannot tell a concise cleanup from
- * a summary.
- */
-export function resolveCleanedDictation(
-  raw: string,
-  cleaned: string,
-  stopReason: string | null | undefined,
-): { text: string; rejected: CleanupRejection | null } {
-  const trimmed = cleaned.trim();
-  if (!trimmed) {
-    return { text: raw, rejected: null };
-  }
-  if (isMaxTokensStopReason(stopReason)) {
-    return { text: raw, rejected: "truncated" };
-  }
-  return { text: trimmed, rejected: null };
-}
-
 interface DictationResult {
   text: string;
   mode: DictationMode;
@@ -263,174 +186,88 @@ async function handleDictation(body: DictationBody): Promise<DictationResult> {
     return handleCommandMode(body, profile, profileMeta, stylePrompt);
   }
 
-  // Non-command: single LLM call that classifies AND cleans in one shot
-  const transcription = expandSnippets(body.transcription, profile.snippets);
+  const mode = await classifyDictation(body);
+  if (mode === "action") {
+    return {
+      text: body.transcription,
+      mode,
+      actionPlan: `User wants to: ${body.transcription}`,
+      ...profileMeta,
+    };
+  }
 
-  // Covers provider resolution as well as the call, which is what the caller
-  // waits for.
-  const modelStartedAt = Date.now();
+  // Only explicit user-authored replacements may change dictated words.
+  const text = applyDictionary(
+    expandSnippets(body.transcription, profile.snippets),
+    profile.dictionary,
+  );
+  return { text, mode, ...profileMeta };
+}
+
+async function classifyDictation(
+  body: DictationBody,
+): Promise<"dictation" | "action"> {
   try {
     const provider = await getConfiguredProvider("interactionClassifier");
-    if (!provider) {
-      log.warn(
-        "Dictation: no provider available, using heuristic + raw transcription",
+    if (provider) {
+      const { signal, cleanup } = createTimeout(
+        DICTATION_CLASSIFICATION_TIMEOUT_MS,
       );
-      // Build a compatible msg for the heuristic
-      const mode = detectDictationModeHeuristic({
-        type: "dictation_request",
-        transcription: body.transcription,
-        context: body.context,
-      } as DictationRequest);
-      const normalizedText = applyDictionary(transcription, profile.dictionary);
-      if (mode === "action") {
-        return {
-          text: body.transcription,
-          mode: "action",
-          actionPlan: `User wants to: ${body.transcription}`,
-          ...profileMeta,
-        };
-      }
-      return {
-        text: normalizedText,
-        mode,
-        ...profileMeta,
-      };
-    }
-
-    const systemPrompt = buildCombinedDictationPrompt(body, stylePrompt);
-    const maxTokens = computeMaxTokens(transcription.length);
-    const { signal, cleanup } = createTimeout(
-      DICTATION_CLASSIFICATION_TIMEOUT_MS,
-    );
-
-    try {
-      const response = await provider.sendMessage(
-        [userMessage(`Transcription: "${transcription}"`)],
-        {
-          tools: [
-            {
-              name: "process_dictation",
-              description: "Classify the voice input and return cleaned text",
-              input_schema: {
-                type: "object" as const,
-                properties: {
-                  mode: {
-                    type: "string",
-                    enum: ["dictation", "action"],
-                    description:
-                      "dictation = user wants text inserted/cleaned up for typing. action = user wants the assistant to perform a task.",
-                  },
-                  text: {
-                    type: "string",
-                    description:
-                      "If dictation: the cleaned/formatted text ready for insertion. If action: the raw transcription unchanged.",
+      try {
+        const response = await provider.sendMessage(
+          [userMessage(body.transcription)],
+          {
+            tools: [
+              {
+                name: "process_dictation",
+                description: "Classify the voice input",
+                input_schema: {
+                  type: "object" as const,
+                  properties: {
+                    mode: {
+                      type: "string",
+                      enum: ["dictation", "action"],
+                      description:
+                        "dictation = user wants text inserted. action = user wants the assistant to perform a task.",
+                    },
                   },
+                  required: ["mode"],
                 },
-                required: ["mode", "text"],
               },
+            ],
+            systemPrompt: buildDictationClassificationPrompt(body),
+            config: {
+              callSite: "interactionClassifier",
+              max_tokens: 512,
+              tool_choice: { type: "tool" as const, name: "process_dictation" },
             },
-          ],
-          systemPrompt,
-          config: {
-            callSite: "interactionClassifier",
-            max_tokens: maxTokens,
-            tool_choice: {
-              type: "tool" as const,
-              name: "process_dictation",
-            },
+            signal,
           },
-          signal,
-        },
-      );
-      cleanup();
-
-      const toolBlock = extractToolUse(response);
-      if (toolBlock) {
-        const input = toolBlock.input as {
-          mode?: string;
-          text?: string;
-        };
-        const mode: DictationMode =
-          input.mode === "action" ? "action" : "dictation";
-        log.info(
-          {
-            mode,
-            modelMs: Date.now() - modelStartedAt,
-            inChars: transcription.length,
-            outChars: input.text?.length ?? 0,
-          },
-          "LLM dictation classify+clean",
         );
-
-        if (mode === "action") {
-          return {
-            text: body.transcription,
-            mode: "action",
-            actionPlan: `User wants to: ${body.transcription}`,
-            ...profileMeta,
-          };
+        const input = extractToolUse(response)?.input as
+          | { mode?: string }
+          | undefined;
+        if (input?.mode === "action" || input?.mode === "dictation") {
+          return input.mode;
         }
-        const { text: cleanedText, rejected } = resolveCleanedDictation(
-          transcription,
-          input.text ?? "",
-          response.stopReason,
-        );
-        if (rejected) {
-          // Lengths only -- transcript content must never be logged.
-          log.warn(
-            {
-              rejected,
-              stopReason: response.stopReason,
-              rawChars: transcription.length,
-              cleanedChars: input.text?.trim().length ?? 0,
-            },
-            "Dictation cleanup rejected, using raw transcription",
-          );
-        }
-        const normalizedText = applyDictionary(cleanedText, profile.dictionary);
-        return {
-          text: normalizedText,
-          mode: "dictation",
-          ...profileMeta,
-        };
+      } finally {
+        cleanup();
       }
-
-      log.warn(
-        { modelMs: Date.now() - modelStartedAt },
-        "No tool_use block in combined dictation call, using heuristic",
-      );
-    } finally {
-      cleanup();
     }
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
     log.warn(
-      { err: message, modelMs: Date.now() - modelStartedAt },
-      "Combined dictation LLM call failed, using heuristic",
+      { err: message },
+      "Dictation classification failed, using heuristic",
     );
   }
 
-  // Heuristic fallback
-  const fallbackMode = detectDictationModeHeuristic({
+  const mode = detectDictationModeHeuristic({
     type: "dictation_request",
     transcription: body.transcription,
     context: body.context,
   } as DictationRequest);
-  log.info({ mode: fallbackMode }, "Using heuristic fallback");
-  if (fallbackMode === "action") {
-    return {
-      text: body.transcription,
-      mode: "action",
-      actionPlan: `User wants to: ${body.transcription}`,
-      ...profileMeta,
-    };
-  }
-  const normalizedText = applyDictionary(transcription, profile.dictionary);
-  return {
-    text: normalizedText,
-    mode: fallbackMode,
-    ...profileMeta,
-  };
+  return mode === "action" ? "action" : "dictation";
 }
 
 async function handleCommandMode(
@@ -560,7 +397,7 @@ export const ROUTES: RouteDefinition[] = [
     },
     summary: "Process dictation",
     description:
-      "Classify voice input as dictation or action, clean up text, and apply user style preferences.",
+      "Preserve dictated words with explicit dictionary and snippet replacements, classify actions, or edit selected text when instructed.",
     tags: ["diagnostics"],
     requestBody: DictationRequestSchema,
     responseBody: z.object({

package/src/runtime/routes/global-search-routes.ts

@@ -11,6 +11,7 @@
 import { z } from "zod";
 
 import { getConfig } from "../../config/loader.js";
+import { isSidebarDoneEnabled } from "../../config/sidebar-done-gate.js";
 import { searchContacts } from "../../contacts/contact-store.js";
 import { searchConversations } from "../../persistence/conversation-queries.js";
 import { getMemorySqlite } from "../../persistence/db-connection.js";
@@ -123,23 +124,32 @@ function parseCategories(raw: string | undefined): Set<Category> {
  * cleaned term as a literal query, so unknown filters are visible to lexical
  * matching rather than silently dropped.
  *
- * Examples:
+ * `defaultArchived` is what an unfiltered query means. It is `false` by
+ * default and `true` under the `sidebar-done` flag, where a done chat is a
+ * filed chat rather than a hidden one and search is how the user reaches it.
+ * Either way both filters still say exactly what they say, so `is:unarchived`
+ * is the opt-out whenever the default is on.
+ *
+ * Examples (with `defaultArchived: false`):
  *   "foo bar"            -> { term: "foo bar",        archived: false }
  *   "is:archived foo"    -> { term: "foo",            archived: true  }
  *   "foo is:archived"    -> { term: "foo",            archived: true  }
  *   "is:archived"        -> { term: "",               archived: true  }
  *   "is:starred foo"     -> { term: "is:starred foo", archived: false }
  */
-function parseSearchQuery(rawQ: string | undefined): {
+function parseSearchQuery(
+  rawQ: string | undefined,
+  defaultArchived: boolean,
+): {
   term: string;
   archived: boolean;
 } {
   if (!rawQ) {
-    return { term: "", archived: false };
+    return { term: "", archived: defaultArchived };
   }
   const tokens = rawQ.split(/\s+/).filter((t) => t.length > 0);
   const termTokens: string[] = [];
-  let archived = false;
+  let archived = defaultArchived;
   for (const tok of tokens) {
     const lower = tok.toLowerCase();
     if (
@@ -291,11 +301,16 @@ async function handleGlobalSearch({
     throw new BadRequestError("q query parameter is required");
   }
 
-  // Pull the archive opt-in out of the query string itself (`is:archived` /
+  // Pull the archive filter out of the query string itself (`is:archived` /
   // `archive:yes` / etc.) so the user controls it the same way they control
   // every other modifier: by typing it into the search box. The cleaned term
-  // is what the backends actually search on.
-  const { term, archived: includeArchived } = parseSearchQuery(rawQ);
+  // is what the backends actually search on. Under `sidebar-done` the
+  // unfiltered default flips to including done chats, and `is:unarchived`
+  // becomes the token that narrows back to the live set.
+  const { term, archived: includeArchived } = parseSearchQuery(
+    rawQ,
+    isSidebarDoneEnabled(),
+  );
 
   const limit = Math.max(1, Math.min(Number(queryParams.limit ?? 20), 100));
   const categories = parseCategories(queryParams.categories);

package/src/runtime/routes/inference-provider-connection-routes.ts

@@ -24,8 +24,10 @@ import {
   CHATGPT_SUBSCRIPTION_CONNECTION_NAME,
   type ConnectionModel,
   ConnectionModelSchema,
+  type ConnectionProvider,
   ConnectionProviderSchema,
   deriveAuthForProvider,
+  normalizeConnectionProvider,
   ProviderConnectionSchema,
   PROVIDERS_ALLOWING_CUSTOM_BASE_URL,
   VALID_CONNECTION_PROVIDERS,
@@ -379,8 +381,15 @@ async function handleCreateConnection({ body = {} }: RouteHandlerArgs) {
       `Provider "chatgpt" is reserved for the "${CHATGPT_SUBSCRIPTION_CONNECTION_NAME}" connection. Run the ChatGPT sign-in flow to connect a subscription.`,
     );
   }
+  // Resolved before auth derivation so an opencode.ai endpoint is held to
+  // OpenCode's keyed auth rather than the keyless option the generic
+  // provider allows.
+  const resolvedProvider = normalizeConnectionProvider(
+    providerResult.data,
+    body.base_url,
+  ) as ConnectionProvider;
   const authResult = AuthSchema.safeParse(
-    auth ?? deriveConnectionAuth(providerResult.data, body.credential),
+    auth ?? deriveConnectionAuth(resolvedProvider, body.credential),
   );
   if (!authResult.success) {
     throw new BadRequestError(`Invalid auth: ${authResult.error.message}`);
@@ -388,7 +397,7 @@ async function handleCreateConnection({ body = {} }: RouteHandlerArgs) {
   // Asserted on derived auth as well: derivation pairs every provider
   // correctly except the chatgpt identity, whose fallthrough would mint
   // api_key auth from a bare credential.
-  assertAuthMatchesProvider(providerResult.data, authResult.data);
+  assertAuthMatchesProvider(resolvedProvider, authResult.data);
 
   const labelRaw = body.label;
   if (
@@ -401,18 +410,15 @@ async function handleCreateConnection({ body = {} }: RouteHandlerArgs) {
     );
   }
 
-  const customFields = await parseCustomProviderFields(
-    body,
-    providerResult.data,
-  );
+  const customFields = await parseCustomProviderFields(body, resolvedProvider);
 
   // Same event-loop turn as the write: no await separates this check from
   // createConnection, so concurrent requests cannot both pass it.
-  assertValidCustomProviderIdentity(providerResult.data, labelRaw, name);
+  assertValidCustomProviderIdentity(resolvedProvider, labelRaw, name);
 
   const result = createConnection(getDb(), {
     name,
-    provider: providerResult.data,
+    provider: resolvedProvider,
     auth: authResult.data,
     ...(labelRaw !== undefined ? { label: labelRaw as string | null } : {}),
     ...customFields,
@@ -525,6 +531,17 @@ async function handleUpdateConnection({
     );
   }
   const customFields = await parseCustomProviderFields(body, existing.provider);
+  // Provider is immutable on PATCH, and profiles bound to this row under the
+  // legacy `{provider, provider_connection}` shape declare its kind, so the
+  // row cannot be repointed at an endpoint that needs a different kind.
+  if (
+    normalizeConnectionProvider(existing.provider, customFields.baseUrl) !==
+    existing.provider
+  ) {
+    throw new BadRequestError(
+      `base_url points at OpenCode, which needs an "opencode" connection. Create a new connection with provider "opencode" instead of repointing "${name}".`,
+    );
+  }
 
   // Only a CHANGED label is validated: keeping a stored label — whatever it
   // is — must never block unrelated edits (key rotation, models).