@circuitwall/jarela 2.2.0 → 2.2.1

package/app/api/v1/models/[name]/route.ts

@@ -1,6 +1,16 @@
 import { NextRequest, NextResponse } from "next/server";
 import { z } from "zod";
-import { deleteModelConfig, getModelConfig, upsertModelConfig, withModelConfigMutation } from "@/lib/stores/model-config";
+import {
+  deleteModelConfig,
+  getModelConfig,
+  isModelConfigEnabled,
+  ModelConfigStateError,
+  setDefaultModelConfig,
+  setModelConfigEnabled,
+  upsertModelConfig,
+  withModelConfigMutation,
+} from "@/lib/stores/model-config";
+import { withDbTransaction } from "@/lib/db/transaction";
 import { validateBody } from "@/lib/api/responses";
 import { parseJsonSafe } from "@/lib/utils/json";
 import { enrichParamsWithDiscoveredContext } from "@/lib/models/discover-context-window";
@@ -15,6 +25,17 @@ const PutBody = z.object({
   credential_id: z.string().nullable().optional(),
 });
 
+// Targeted state changes that must not re-send (and re-process) the whole
+// config. Each request is applied in a single transaction.
+const PatchBody = z.object({
+  enabled: z.boolean().optional(),
+  is_default: z.literal(true).optional(),
+}).strict().refine((b) => b.enabled !== undefined || b.is_default !== undefined, {
+  message: "provide enabled and/or is_default",
+}).refine((b) => !(b.enabled === false && b.is_default === true), {
+  message: "a disabled model cannot be the default",
+});
+
 // Mirror /api/v1/models GET: never echo plaintext secrets back to the
 // client. Authoritative storage lives in `credentials`; per-model rows
 // retain only non-secret overrides post-migration.
@@ -64,13 +85,43 @@ export async function PUT(req: NextRequest, { params }: Params) {
       body.provider,
       body.model_id,
       enriched,
-      body.is_default ?? false,
+      body.is_default,
       body.credential_id ?? null,
     );
-    return NextResponse.json({ ...r, params: redactInlineParams(r.params), is_default: Boolean(r.is_default) });
+    return NextResponse.json(toResponse(r));
   });
 }
 
+export async function PATCH(req: NextRequest, { params }: Params) {
+  const { name } = await params;
+  const body = await validateBody(req, PatchBody);
+  if (body instanceof NextResponse) return body;
+  try {
+    const r = withDbTransaction(() => {
+      let row = getModelConfig(name);
+      if (!row) throw new ModelConfigStateError(`Model config "${name}" not found`, 404);
+      if (body.enabled !== undefined) row = setModelConfigEnabled(name, body.enabled);
+      if (body.is_default) row = setDefaultModelConfig(name);
+      return row;
+    });
+    return NextResponse.json(toResponse(r));
+  } catch (err) {
+    if (err instanceof ModelConfigStateError) {
+      return NextResponse.json({ error: err.message }, { status: err.status });
+    }
+    throw err;
+  }
+}
+
+function toResponse(r: NonNullable<ReturnType<typeof getModelConfig>>) {
+  return {
+    ...r,
+    params: redactInlineParams(r.params),
+    is_default: Boolean(r.is_default),
+    enabled: isModelConfigEnabled(r),
+  };
+}
+
 export async function DELETE(_req: NextRequest, { params }: Params) {
   const { name } = await params;
   return withModelConfigMutation(name, () => {

package/app/api/v1/models/route.ts

@@ -7,7 +7,7 @@
 
 import { NextRequest, NextResponse } from "next/server";
 import { z } from "zod";
-import { getModelConfig, listModelConfigs, upsertModelConfig, withModelConfigMutation } from "@/lib/stores/model-config";
+import { getModelConfig, isModelConfigEnabled, listModelConfigs, upsertModelConfig, withModelConfigMutation } from "@/lib/stores/model-config";
 import { createdResponse, cachedJson, validateBody } from "@/lib/api/responses";
 import { parseJsonSafe } from "@/lib/utils/json";
 import { enrichParamsWithDiscoveredContext } from "@/lib/models/discover-context-window";
@@ -65,6 +65,7 @@ export function GET() {
     ...r,
     params: redactInlineParams(r.params),
     is_default: Boolean(r.is_default),
+    enabled: isModelConfigEnabled(r),
   })), 15, 60);
 }
 
@@ -79,13 +80,14 @@ export async function POST(req: NextRequest) {
       body.provider,
       body.model_id,
       enriched,
-      body.is_default ?? false,
+      body.is_default,
       body.credential_id ?? null,
     );
     return createdResponse({
       ...r,
       params: redactInlineParams(r.params),
       is_default: Boolean(r.is_default),
+      enabled: isModelConfigEnabled(r),
     });
   });
 }

package/app/api/v1/providers/[provider]/models/route.test.ts

@@ -0,0 +1,53 @@
+import { afterAll, afterEach, describe, expect, it, vi } from "vitest";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { NextRequest } from "next/server";
+
+const tmpRoot = mkdtempSync(join(tmpdir(), "jarela-test-provider-models-"));
+process.env.JARELA_DB_DIR = tmpRoot;
+
+const { upsertModelConfig, deleteModelConfig } = await import("@/lib/stores/model-config");
+const { GET } = await import("./route");
+
+const params = { params: Promise.resolve({ provider: "github-copilot" }) };
+const request = () => new NextRequest("http://localhost/api/v1/providers/github-copilot/models?fresh=1");
+
+afterEach(() => {
+  deleteModelConfig("copilot-config");
+  vi.unstubAllEnvs();
+  vi.unstubAllGlobals();
+});
+
+afterAll(() => {
+  try { rmSync(tmpRoot, { recursive: true, force: true }); } catch { /* */ }
+});
+
+describe("provider model catalogs", () => {
+  it("rejects a retired PAT config as a configuration error", async () => {
+    upsertModelConfig("copilot-config", "github-copilot", "gpt-4o", {
+      api_key: "github_pat_synthetic",
+    }, true);
+
+    const response = await GET(request(), params);
+
+    expect(response.status).toBe(400);
+    await expect(response.json()).resolves.toMatchObject({
+      error: expect.stringMatching(/PAT.*GitHub Models.*retired/i),
+    });
+  });
+
+  it("ignores a GITHUB_TOKEN PAT and returns the curated Copilot list", async () => {
+    upsertModelConfig("copilot-config", "github-copilot", "gpt-4o", {}, true);
+    vi.stubEnv("GITHUB_TOKEN", "ghp_synthetic");
+    const fetch = vi.fn();
+    vi.stubGlobal("fetch", fetch);
+
+    const response = await GET(request(), params);
+
+    expect(response.status).toBe(200);
+    const models = await response.json() as Array<{ id: string }>;
+    expect(models.length).toBeGreaterThan(0);
+    expect(fetch).not.toHaveBeenCalled();
+  });
+});

package/app/api/v1/providers/[provider]/models/route.ts

@@ -56,10 +56,19 @@ export async function GET(req: NextRequest, { params }: Params) {
       },
     });
   } catch (err) {
-    return NextResponse.json({ error: String(err) }, { status: 500 });
+    return catalogErrorResponse(err);
   }
 }
 
+// Raised when the saved configuration itself is unusable, so callers get a
+// 4xx they can act on instead of a generic server error.
+class CatalogConfigError extends Error {}
+
+function catalogErrorResponse(err: unknown): NextResponse {
+  const status = err instanceof CatalogConfigError ? 400 : 500;
+  return NextResponse.json({ error: String(err) }, { status });
+}
+
 // POST allows the editor to ship the in-form credentials (api_key /
 // base_url / extra_headers) before the user has saved them. We never cache
 // these responses since they're keyed on user-supplied secrets.
@@ -71,7 +80,7 @@ export async function POST(req: NextRequest, { params }: Params) {
     const models = await fetchCatalog(provider, body.params);
     return NextResponse.json(models, { headers: { "Cache-Control": "no-store" } });
   } catch (err) {
-    return NextResponse.json({ error: String(err) }, { status: 500 });
+    return catalogErrorResponse(err);
   }
 }
 
@@ -162,13 +171,8 @@ async function fetchOpenAICatalog(): Promise<CatalogModel[]> {
 // ── GitHub Copilot ────────────────────────────────────────────────────────────
 
 async function fetchGitHubCopilotCatalog(): Promise<CatalogModel[]> {
-  // We deliberately do NOT return the broad GitHub Models cross-publisher
-  // registry here — that lists hundreds of models from every vendor, which is
-  // confusing when the user is configuring the "github-copilot" provider
-  // specifically. We mirror what Copilot Chat actually serves: its own
-  // /models endpoint when we have an exchangeable credential, else a curated
-  // fallback list. Users who want the raw GitHub Models catalog can type the
-  // namespaced model id directly into the Model ID field.
+  // Use Copilot Chat's account-specific /models endpoint when an exchangeable
+  // credential is available, otherwise return a curated fallback list.
 
   // 1. Prefer the in-app device-flow OAuth token — it can be exchanged.
   const { getStoredOAuthToken } = await import("@/lib/providers/github-copilot-auth");
@@ -193,8 +197,16 @@ async function fetchGitHubCopilotCatalog(): Promise<CatalogModel[]> {
         if (list.length > 0) return list;
       } catch { /* fall through */ }
     }
-    const apiKey = (params.api_key as string | undefined) ?? process.env.GITHUB_TOKEN;
-    if (apiKey && !isLikelyGitHubPat(apiKey)) {
+    // Only the Copilot config's own api_key is considered: GITHUB_TOKEN belongs
+    // to the GitHub integration and is usually a PAT unrelated to Copilot.
+    const apiKey = (params.api_key as string | undefined)?.trim();
+    if (apiKey && isLikelyGitHubPat(apiKey)) {
+      throw new CatalogConfigError(
+        "GitHub Copilot: PAT model discovery used GitHub Models, which has been retired. " +
+        "Use device-flow sign-in in the Models panel or set copilot_session_token.",
+      );
+    }
+    if (apiKey) {
       try {
         const sessionToken = await exchangeCopilotSessionToken(apiKey);
         const list = await fetchCopilotChatCatalog(sessionToken);
@@ -203,8 +215,7 @@ async function fetchGitHubCopilotCatalog(): Promise<CatalogModel[]> {
     }
   }
 
-  // 3. Fallback: curated known-models list. Works even on a PAT — those
-  //    model IDs are valid on both Models API and Copilot Chat.
+  // 3. Fallback: curated known-models list when no credential can be exchanged.
   return githubCopilotKnownModels();
 }
 
@@ -241,13 +252,13 @@ async function fetchCopilotChatCatalog(sessionToken: string): Promise<CatalogMod
 }
 
 function isLikelyGitHubPat(token: string): boolean {
-  return token.startsWith("ghp_") || token.startsWith("github_pat_") || token.startsWith("gho_");
+  return token.startsWith("ghp_") || token.startsWith("github_pat_");
 }
 
-async function exchangeCopilotSessionToken(pat: string): Promise<string> {
+async function exchangeCopilotSessionToken(githubToken: string): Promise<string> {
   const res = await fetch("https://api.github.com/copilot_internal/v2/token", {
     headers: {
-      Authorization: `token ${pat}`,
+      Authorization: `token ${githubToken}`,
       "User-Agent": "Jarela/1.0",
     },
   });

package/components/agents/agent-editor/AdvancedSection.tsx

@@ -9,6 +9,7 @@ import { VoiceFields } from "./VoiceFields";
 import { ToolCredentialsSection } from "./ToolCredentialsSection";
 import { Select } from "@/components/ui/Select";
 import { modelSupportsImages } from "@/lib/providers/capabilities";
+import { isModelEnabled } from "@/lib/agents/effective-model";
 import { SelectedModelDescription } from "./ModelSection";
 
 interface Props {
@@ -31,15 +32,20 @@ export function AdvancedSection({ form, models, integrations, isFullMode, onClos
         </p>
         <Select value={form.modelConfigName} onChange={(e) => form.setModelConfigName(e.target.value)}>
           <option value="">Automatic routing (recommended)</option>
-          {models.map((m) => {
+          {models.filter((m) => isModelEnabled(m) || m.name === form.modelConfigName).map((m) => {
             const vision = modelSupportsImages(m.provider, m.model_id);
             return (
               <option key={m.name} value={m.name}>
-                {vision ? "📷 " : ""}{m.name} · {m.provider} / {m.model_id}
+                {vision ? "📷 " : ""}{m.name} · {m.provider} / {m.model_id}{isModelEnabled(m) ? "" : " (disabled)"}
               </option>
             );
           })}
         </Select>
+        {selectedModel && !isModelEnabled(selectedModel) && (
+          <p className="text-[11px] text-amber-700 dark:text-amber-400">
+            This model is disabled, so the agent uses automatic routing until it is enabled again.
+          </p>
+        )}
         {selectedModel && <SelectedModelDescription model={selectedModel} prefix="Forced" />}
       </div>
       <Divider />

package/components/agents/agent-editor/ModelSection.tsx

@@ -1,4 +1,5 @@
 import type { ModelConfig } from "@/api/types";
+import { isModelEnabled } from "@/lib/agents/effective-model";
 import { isProviderClassified, modelSupportsImages } from "@/lib/providers/capabilities";
 import { CapBadges } from "@/components/models/CapBadges";
 import { ProviderLogo } from "@/components/models/ProviderLogo";
@@ -19,8 +20,10 @@ interface Props {
 
 export function ModelSection({ form, models, integrations, onClose }: Props) {
   const { dispatch } = useAppContext();
-  const defaultModel = models.find((m) => m.is_default);
-  const selectedModel = models.find((m) => m.name === form.modelConfigName) ?? defaultModel;
+  const enabledModels = models.filter(isModelEnabled);
+  const defaultModel = enabledModels.find((m) => m.is_default) ?? enabledModels[0];
+  const forcedModel = enabledModels.find((m) => m.name === form.modelConfigName);
+  const selectedModel = forcedModel ?? defaultModel;
   const readiness = computeFeatureReadiness({
     models,
     integrations,
@@ -48,7 +51,7 @@ export function ModelSection({ form, models, integrations, onClose }: Props) {
         ) : (
           <p className="text-[11px] text-amber-700 dark:text-amber-400">No default fallback model is configured yet.</p>
         )}
-        {form.modelConfigName && models.find((m) => m.name === form.modelConfigName) && (
+        {forcedModel && (
           <p className="text-[11px] text-sky-700 dark:text-sky-400">
             This agent currently has a forced model override. Clear it in Advanced settings to return to router-driven selection.
           </p>

package/components/models/ModelEditor.tsx

@@ -9,7 +9,7 @@ import { ModelEditorBody, ModelEditorOverlays } from "./model-editor/ModelEditor
 
 interface Props {
   model?: ModelConfig;
-  onSave: (name: string, data: Omit<ModelConfig, "name" | "created_at" | "updated_at">) => Promise<void>;
+  onSave: (name: string, data: Omit<ModelConfig, "name" | "enabled" | "created_at" | "updated_at">) => Promise<void>;
   onClose: () => void;
 }
 

package/components/models/ModelsPanel.tsx

@@ -1,5 +1,5 @@
 "use client";
-import { ArrowUpRight, Cpu, Plus, Star, Trash2 } from "lucide-react";
+import { ArrowUpRight, Cpu, Plus, Power, PowerOff, Star, Trash2 } from "lucide-react";
 import { HeaderAction, PanelHeader } from "@/components/ui/PanelHeader";
 import { useEffect, useRef, useState } from "react";
 import type { ModelConfig } from "@/api/types";
@@ -37,7 +37,7 @@ interface EnvEntry {
 }
 
 export function ModelsPanel() {
-  const { models, assignments, loading, create, update, remove, refresh } = useModels();
+  const { models, assignments, loading, create, update, setDefault, setEnabled, remove, refresh } = useModels();
   const { agents, loading: agentsLoading } = useAgents();
   const strategyOverrides = agents.filter((agent) => agent.usage_strategy != null);
   const [editing, setEditing] = useState<ModelConfig | null | "new">(null);
@@ -93,14 +93,28 @@ export function ModelsPanel() {
     return () => { cancelled = true; };
   }, []);
 
-  async function handleSave(name: string, data: Omit<ModelConfig, "name" | "created_at" | "updated_at">) {
+  async function handleSave(name: string, data: Omit<ModelConfig, "name" | "enabled" | "created_at" | "updated_at">) {
     if (editing === "new") await create(name, data);
     else if (editing) await update(name, data);
     refresh();
   }
 
   async function handleSetDefault(m: ModelConfig) {
-    await update(m.name, { provider: m.provider, model_id: m.model_id, params: m.params, is_default: true });
+    setDeleteError(null);
+    try {
+      await setDefault(m.name);
+    } catch (e) {
+      setDeleteError(`Could not set "${m.name}" as default: ${errorMessage(e)}`);
+    }
+  }
+
+  async function handleToggleEnabled(m: ModelConfig) {
+    setDeleteError(null);
+    try {
+      await setEnabled(m.name, !m.enabled);
+    } catch (e) {
+      setDeleteError(`Could not ${m.enabled ? "disable" : "enable"} "${m.name}": ${errorMessage(e)}`);
+    }
   }
 
   async function handleRemove(name: string) {
@@ -283,14 +297,17 @@ export function ModelsPanel() {
           {models.map((m) => {
             const inUse = assignments.some((a) => a.model_config_name === m.name);
             return (
-            <div key={m.name} data-deep-link-id={m.name} onClick={() => setEditing(m)} className="flex items-center gap-3 py-2.5 border-b border-border/60 group cursor-pointer hover:bg-surface-3/30 transition-colors">
+            <div key={m.name} data-deep-link-id={m.name} onClick={() => setEditing(m)} className={`flex items-center gap-3 py-2.5 border-b border-border/60 group cursor-pointer hover:bg-surface-3/30 transition-colors ${m.enabled ? "" : "opacity-60"}`}>
               <span className="shrink-0 text-fg-subtle">
                 <ProviderLogo name={m.provider} size={22} />
               </span>
               <div className="flex-1 min-w-0">
                 <div className="flex items-center gap-2 mb-0.5">
-                  <span className="text-sm font-medium text-fg">{m.name}</span>
+                  <span className={`text-sm font-medium ${m.enabled ? "text-fg" : "text-fg-subtle line-through"}`}>{m.name}</span>
                   {m.is_default && <Star size={11} className="text-yellow-700 dark:text-yellow-400 fill-yellow-400 shrink-0" />}
+                  {!m.enabled && (
+                    <span className="text-xs px-1.5 py-0.5 rounded border bg-surface-2 text-fg-muted border-border">disabled</span>
+                  )}
                   <span className={`text-xs px-1.5 py-0.5 rounded border ${PROVIDER_COLORS[m.provider] ?? "bg-surface-2 text-fg-muted border-border"}`}>
                     {m.provider}
                   </span>
@@ -301,11 +318,20 @@ export function ModelsPanel() {
                 </div>
               </div>
               <div className="flex gap-1 opacity-40 group-hover:opacity-100 pointer-coarse:opacity-100 transition-opacity shrink-0">
-                {!m.is_default && (
-                  <button onClick={(e) => { e.stopPropagation(); handleSetDefault(m); }} className="p-1 text-fg-subtle hover:text-yellow-700 dark:hover:text-yellow-400 transition-colors" title="Set as default">
+                {!m.is_default && m.enabled && (
+                  <button onClick={(e) => { e.stopPropagation(); void handleSetDefault(m); }} className="p-1 text-fg-subtle hover:text-yellow-700 dark:hover:text-yellow-400 transition-colors" title="Set as default">
                     <Star size={13} />
                   </button>
                 )}
+                <button
+                  onClick={(e) => { e.stopPropagation(); void handleToggleEnabled(m); }}
+                  className="p-1 text-fg-subtle hover:text-fg transition-colors"
+                  title={m.enabled ? "Disable; hide from model selection" : "Enable; show in model selection"}
+                  aria-label={m.enabled ? `Disable ${m.name}` : `Enable ${m.name}`}
+                  aria-pressed={!m.enabled}
+                >
+                  {m.enabled ? <Power size={13} /> : <PowerOff size={13} />}
+                </button>
                 <button
                   onClick={(e) => { e.stopPropagation(); handleRemove(m.name); }}
                   className="p-1 text-fg-subtle hover:text-red-700 dark:hover:text-red-400 transition-colors"

package/components/models/model-editor/GitHubCopilotAuth.tsx

@@ -27,7 +27,7 @@ function AuthHeader({ status, polling, onSignIn, onSignOut }: HeaderProps) {
       <div className="text-fg-muted">
         <strong>GitHub Copilot sign-in</strong>
         <p className="text-fg-faint mt-0.5">
-          Unlocks full model context windows (vs. the 8k cap on raw PATs via GitHub Models).
+          Required for Copilot models; GitHub PAT authentication is no longer supported.
         </p>
       </div>
       {status?.signed_in ? (

package/components/models/model-editor/save-helpers.ts

@@ -33,7 +33,7 @@ export function buildPayload(form: ModelEditorForm) {
 
 export async function runProbeStep(
   form: ModelEditorForm,
-  payload: Omit<ModelConfig, "name" | "created_at" | "updated_at">,
+  payload: Omit<ModelConfig, "name" | "enabled" | "created_at" | "updated_at">,
 ): Promise<boolean> {
   const probe = await api.models
     .probe(form.provider, payload.model_id, payload.params as Record<string, unknown>, undefined, form.credentialId ?? undefined)
@@ -50,7 +50,7 @@ export async function runProbeStep(
 
 export function shouldStageShrinkConfirm(
   form: ModelEditorForm,
-  result: { name: string; payload: Omit<ModelConfig, "name" | "created_at" | "updated_at"> },
+  result: { name: string; payload: Omit<ModelConfig, "name" | "enabled" | "created_at" | "updated_at"> },
 ): boolean {
   if (!form.model) return false;
   const oldCtx = Number(form.model.params.context_window_tokens) || 0;

package/components/models/model-editor/useModelEditorForm.ts

@@ -9,7 +9,7 @@ export type ShrinkPending =
   | {
       oldSnapshot: { provider: string; model_id: string; params: Record<string, unknown> };
       payloadName: string;
-      payload: Omit<ModelConfig, "name" | "created_at" | "updated_at">;
+      payload: Omit<ModelConfig, "name" | "enabled" | "created_at" | "updated_at">;
     };
 
 export type ProbeResult = { ok: boolean; error?: string } | null;

package/components/models/model-editor/useModelSaveHandlers.ts

@@ -12,7 +12,7 @@ import {
 
 interface Args {
   form: ModelEditorForm;
-  onSave: (name: string, data: Omit<ModelConfig, "name" | "created_at" | "updated_at">) => Promise<void>;
+  onSave: (name: string, data: Omit<ModelConfig, "name" | "enabled" | "created_at" | "updated_at">) => Promise<void>;
   onClose: () => void;
 }
 

package/components/setup/wizard/StepCredentials.tsx

@@ -200,7 +200,7 @@ export function StepCredentials({ definitions, integrations, onChanged }: StepCr
       icon={<KeyRound size={18} />}
       eyebrow="Step 2 · Credentials"
       title="Connect provider credentials in the UI first"
-      description="Use the built-in credential forms as the main setup path. They work for Claude, GPT, Gemini, Copilot, and other providers without depending on your shell environment."
+      description="Use the built-in credential forms as the main setup path for Claude, GPT, Gemini, and other providers. GitHub Copilot uses device-flow sign-in in the Models panel."
     >
       <div className="rounded-xl border border-accent/30 bg-accent/5 px-3 py-2.5 text-xs text-fg">
         <p className="font-medium">Recommended path</p>

package/components/setup/wizard/StepModel.tsx

@@ -21,7 +21,7 @@ export function StepModel({ models, onChanged }: StepModelProps) {
 
   async function handleSave(
     name: string,
-    data: Omit<ModelConfig, "name" | "created_at" | "updated_at">,
+    data: Omit<ModelConfig, "name" | "enabled" | "created_at" | "updated_at">,
   ) {
     setError(null);
     try {
@@ -35,12 +35,7 @@ export function StepModel({ models, onChanged }: StepModelProps) {
 
   async function handleSetDefault(m: ModelConfig) {
     try {
-      await api.models.update(m.name, {
-        provider: m.provider,
-        model_id: m.model_id,
-        params: m.params,
-        is_default: true,
-      });
+      await api.models.patch(m.name, { is_default: true });
       onChanged();
     } catch (e) {
       setError(errorMessage(e));
@@ -114,7 +109,7 @@ export function StepModel({ models, onChanged }: StepModelProps) {
                 <p className="truncate text-[11px] text-fg-faint">{m.model_id}</p>
               </div>
               <div className="flex shrink-0 items-center gap-0.5">
-                {!m.is_default && (
+                {!m.is_default && m.enabled !== false && (
                   <button
                     type="button"
                     onClick={(e) => { e.stopPropagation(); handleSetDefault(m); }}

package/hooks/useModels.ts

@@ -15,6 +15,8 @@ export function useModels(): UnifiedHookResult<
     refresh: () => Promise<void>;
     create: (name: string, data: ModelConfigIn) => Promise<ModelConfig>;
     update: (name: string, data: ModelConfigIn) => Promise<ModelConfig>;
+    setDefault: (name: string) => Promise<ModelConfig>;
+    setEnabled: (name: string, enabled: boolean) => Promise<ModelConfig>;
     remove: (name: string) => Promise<void>;
     assign: (agent_id: string, model_config_name: string, tool_policy?: ToolPolicy) => Promise<TaskAssignment>;
     unassign: (agent_id: string) => Promise<void>;
@@ -61,6 +63,18 @@ export function useModels(): UnifiedHookResult<
     return m;
   }, [refreshModels]);
 
+  const setDefault = useCallback(async (name: string) => {
+    const m = await api.models.patch(name, { is_default: true });
+    await refreshModels();
+    return m;
+  }, [refreshModels]);
+
+  const setEnabled = useCallback(async (name: string, enabled: boolean) => {
+    const m = await api.models.patch(name, { enabled });
+    await refreshModels();
+    return m;
+  }, [refreshModels]);
+
   const remove = useCallback(async (name: string): Promise<void> => {
     await api.models.delete(name);
     await refreshModels();
@@ -82,7 +96,7 @@ export function useModels(): UnifiedHookResult<
   }, [setAssignments]);
 
   const state = { models, assignments, loading, error };
-  const commands = { refresh, create, update, remove, assign, unassign };
+  const commands = { refresh, create, update, setDefault, setEnabled, remove, assign, unassign };
 
   return {
     state,
@@ -94,6 +108,8 @@ export function useModels(): UnifiedHookResult<
     refresh,
     create,
     update,
+    setDefault,
+    setEnabled,
     remove,
     assign,
     unassign,

package/lib/agents/effective-model.test.ts

@@ -0,0 +1,45 @@
+import { describe, expect, it } from "vitest";
+import type { ModelConfig } from "@/api/types";
+import { agentModelStatus, isModelEnabled, resolveAgentModel } from "./effective-model";
+
+function model(name: string, extra: Partial<ModelConfig> = {}): ModelConfig {
+  return {
+    name,
+    provider: "mock",
+    model_id: `${name}-id`,
+    params: {},
+    is_default: false,
+    enabled: true,
+    created_at: "",
+    updated_at: "",
+    ...extra,
+  };
+}
+
+describe("resolveAgentModel", () => {
+  it("uses the explicit model when it is enabled", () => {
+    const models = [model("a", { is_default: true }), model("b")];
+    expect(resolveAgentModel({ model_config_name: "b" }, models)?.name).toBe("b");
+  });
+
+  it("falls back to the default when the explicit model is disabled", () => {
+    const models = [model("a", { is_default: true }), model("b", { enabled: false })];
+    expect(resolveAgentModel({ model_config_name: "b" }, models)?.name).toBe("a");
+  });
+
+  it("never picks a disabled model as the implicit default", () => {
+    const models = [model("a", { enabled: false }), model("b")];
+    expect(resolveAgentModel(null, models)?.name).toBe("b");
+  });
+
+  it("reports no-model when every config is disabled", () => {
+    const models = [model("a", { enabled: false, is_default: true })];
+    expect(agentModelStatus({ model_config_name: null }, models)).toEqual({ state: "no-model" });
+  });
+
+  it("treats rows without the enabled field as enabled", () => {
+    const legacy = { ...model("a") } as Partial<ModelConfig>;
+    delete legacy.enabled;
+    expect(isModelEnabled(legacy as ModelConfig)).toBe(true);
+  });
+});

package/lib/agents/effective-model.ts

@@ -3,9 +3,9 @@ import type { AgentConfig, ModelConfig } from "@/api/types";
 /**
  * Resolve which `ModelConfig` will actually be used for an agent at runtime.
  *
- * Mirrors what `lib/agents/llm.ts` does server-side: when an agent has
- * `model_config_name` set, that wins; otherwise the workspace-wide default
- * model is used. Both client (BridgeEditor, AgentEditor capability hints)
+ * Mirrors what `lib/agents/llm.ts` does server-side: when an agent has an
+ * enabled `model_config_name`, that wins; otherwise the workspace-wide
+ * default among enabled models is used. Both client (BridgeEditor, AgentEditor capability hints)
  * and server need the same logic — this is the single source of truth.
  *
  * Returns `null` only when neither the requested config nor the default
@@ -15,9 +15,15 @@ export function resolveAgentModel(
   agent: Pick<AgentConfig, "model_config_name"> | null | undefined,
   models: readonly ModelConfig[],
 ): ModelConfig | null {
-  const defaultModel = models.find((m) => m.is_default) ?? models[0] ?? null;
+  const enabled = models.filter(isModelEnabled);
+  const defaultModel = enabled.find((m) => m.is_default) ?? enabled[0] ?? null;
   if (!agent?.model_config_name) return defaultModel;
-  return models.find((m) => m.name === agent.model_config_name) ?? defaultModel;
+  return enabled.find((m) => m.name === agent.model_config_name) ?? defaultModel;
+}
+
+/** Disabled configs stay stored but are skipped by runtime resolution. */
+export function isModelEnabled(model: Pick<ModelConfig, "enabled">): boolean {
+  return model.enabled !== false;
 }
 
 export type AgentModelStatus =

package/lib/agents/llm.ts

@@ -9,7 +9,7 @@ import {
 import type { BaseMessage } from "@langchain/core/messages";
 import { getProvider } from "@/lib/providers";
 import { ProviderAuthError, isAuthErrorMessage, isRetryableProviderStreamError } from "@/lib/providers/errors";
-import { getModelConfig, getDefaultModelConfig, getModelParams, upsertModelConfig } from "@/lib/stores/model-config";
+import { getModelParams, resolveRunnableModelConfig, upsertModelConfig } from "@/lib/stores/model-config";
 import { getAllToolsAsync } from "@/lib/tools";
 import { JarelaChatModel } from "@/lib/providers/jarela-chat-model";
 import { SqliteMemoryStore } from "@/lib/stores/langgraph-store";
@@ -226,7 +226,7 @@ async function* streamWithConfigImpl(
   const runCfg = options?.agent_run_config;
 
   const cfgName = runCfg?.model_config_name ?? null;
-  const cfg = (cfgName ? getModelConfig(cfgName) : null) ?? getDefaultModelConfig();
+  const cfg = resolveRunnableModelConfig(cfgName);
 
   if (!cfg) {
     yield { type: "error", data: { message: "No model configured. Add a model in the Models panel.", code: "no_model" } };