@saadnvd1/agent-os 0.3.691 → 0.3.692

package/app/api/discovered-models/route.ts

@@ -0,0 +1,34 @@
+import { NextRequest, NextResponse } from "next/server";
+import { z } from "zod";
+import { discoveredModels } from "@/lib/chat/discovered-models";
+import { getProject } from "@/lib/projects";
+
+const query = z.object({
+  agent: z.string().min(1),
+  projectId: z.string().optional(),
+  refresh: z.string().optional(),
+});
+
+// GET /api/discovered-models?agent=&projectId=&refresh=1 - the models an agent
+// reports for a project's folder, for a draft that has no session yet. Empty
+// for an agent with a fixed list.
+export async function GET(request: NextRequest) {
+  const parsed = query.safeParse(
+    Object.fromEntries(request.nextUrl.searchParams)
+  );
+  if (!parsed.success)
+    return NextResponse.json({ error: "agent is required" }, { status: 400 });
+  const { agent, projectId, refresh } = parsed.data;
+  const folder = projectId ? getProject(projectId)?.working_directory : null;
+  try {
+    return NextResponse.json({
+      models: await discoveredModels(agent, folder, refresh !== undefined),
+    });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return NextResponse.json(
+      { error: `Couldn't list the models: ${message}` },
+      { status: 502 }
+    );
+  }
+}

package/components/Draft/DraftPanel.tsx

@@ -8,7 +8,8 @@ import { Button } from "@/components/ui/button";
 import type { ChatFile, ChatImage } from "@/lib/chat/events";
 import type { Project } from "@/lib/db";
 import { draftComposerKey, type Draft } from "@/lib/drafts";
-import { getModelOptions } from "@/lib/model-catalog";
+import { discoversModels } from "@/lib/model-catalog";
+import { useDiscoveredModels } from "@/data/agents";
 import { useHostsQuery } from "@/data/hosts";
 import { useGitCheck } from "@/data/git/queries";
 import { useLaunchSession } from "@/data/sessions";
@@ -18,6 +19,7 @@ import { setPendingPrompt } from "@/stores/initialPrompt";
 import { draftsActions, draftsStore, newDraft } from "@/stores/drafts";
 import { DraftChips } from "./DraftChips";
 import { DraftHeading } from "./DraftHeading";
+import { draftModels } from "./draftModels";
 
 // A new session before its first send: choices on top, a composer below.
 // Sending makes the session (and its worktree) and turns this tab into it.
@@ -41,6 +43,12 @@ export function DraftPanel({
   const { data: git } = useGitCheck(
     project && draft?.hostId === "local" ? project.working_directory : ""
   );
+  const discovers = !!draft && discoversModels(draft.agentType);
+  const found = useDiscoveredModels(
+    draft?.agentType ?? "",
+    draft?.projectId ?? null,
+    discovers
+  );
   const launch = useLaunchSession();
   const createTask = useCreateTask();
   const [prefill, setPrefill] = useState<{ text: string; at: number }>();
@@ -148,7 +156,7 @@ export function DraftPanel({
           }
           onSend={(text, images, files) => void send(text, images, files)}
           onStop={() => {}}
-          models={getModelOptions(draft.agentType)}
+          models={draftModels(draft.agentType, found)}
           model={draft.model}
           onSetModel={(model) => draftsActions.update(draft.id, { model })}
           access={draft.openPr ? undefined : draft.access}

package/components/Draft/draftModels.test.ts

@@ -0,0 +1,31 @@
+import { describe, expect, it } from "vitest";
+import { draftModels } from "./draftModels";
+
+const qwen = { value: "ollama/qwen3", label: "Qwen 3" };
+
+describe("draftModels", () => {
+  it("lists the default and then what OpenCode reports", () => {
+    const list = draftModels("opencode", {
+      data: [qwen],
+      isPending: false,
+      isError: false,
+    });
+    expect(list.map((m) => m.value)).toEqual(["default", "ollama/qwen3"]);
+  });
+
+  it("says so beside the default while loading and on failure", () => {
+    const loading = draftModels("opencode", {
+      isPending: true,
+      isError: false,
+    });
+    const failed = draftModels("opencode", { isPending: false, isError: true });
+    expect(loading).toHaveLength(1);
+    expect(loading[0].label).toContain("loading");
+    expect(failed[0].label).toContain("couldn't");
+  });
+
+  it("keeps a fixed list as it is", () => {
+    const list = draftModels("claude", { isPending: true, isError: false });
+    expect(list.map((m) => m.value)).toContain("opus");
+  });
+});

package/components/Draft/draftModels.ts

@@ -0,0 +1,17 @@
+import type { ChatModel } from "@/lib/chat/events";
+import type { Draft } from "@/lib/drafts";
+import { discoversModels, getModelOptions } from "@/lib/model-catalog";
+
+// A fixed list, or the agent's default followed by what it reports; while it
+// loads or if it fails, the default alone says so.
+export function draftModels(
+  agentType: Draft["agentType"],
+  found: { data?: ChatModel[]; isPending: boolean; isError: boolean }
+): ChatModel[] {
+  const options = getModelOptions(agentType);
+  if (!discoversModels(agentType)) return options;
+  if (found.data) return [...options, ...found.data];
+  const [first, ...rest] = options;
+  const note = found.isError ? "couldn't list models" : "loading models…";
+  return [{ ...first, label: `${first.label} (${note})` }, ...rest];
+}

package/data/agents/index.ts

@@ -1,5 +1,6 @@
 import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
 import type { AgentProbe } from "@/lib/agents/probe";
+import type { ChatModel } from "@/lib/chat/events";
 
 export const agentKeys = {
   all: ["agents"] as const,
@@ -35,3 +36,39 @@ export function useRecheckAgents() {
     onSuccess: (agents) => client.setQueryData(agentKeys.status(), agents),
   });
 }
+
+export const discoveredModelKeys = {
+  list: (agent: string, projectId: string | null) =>
+    [...agentKeys.all, "models", agent, projectId] as const,
+};
+
+// What an agent without a fixed list reports it can run, for a draft's
+// picker. Off for agents with a fixed list.
+export function useDiscoveredModels(
+  agent: string,
+  projectId: string | null,
+  enabled: boolean
+) {
+  const client = useQueryClient();
+  const key = discoveredModelKeys.list(agent, projectId);
+  const fetchModels = async (refresh: boolean) => {
+    const params = new URLSearchParams({ agent });
+    if (projectId) params.set("projectId", projectId);
+    if (refresh) params.set("refresh", "1");
+    const res = await fetch(`/api/discovered-models?${params}`);
+    const data = await res.json().catch(() => ({}));
+    if (!res.ok) throw new Error(data.error || "Couldn't list the models");
+    return data.models as ChatModel[];
+  };
+  const query = useQuery({
+    queryKey: key,
+    queryFn: () => fetchModels(false),
+    enabled,
+    staleTime: 5 * 60_000,
+    retry: false,
+  });
+  return {
+    ...query,
+    refresh: async () => client.setQueryData(key, await fetchModels(true)),
+  };
+}

package/lib/chat/discovered-models.ts

@@ -0,0 +1,87 @@
+import os from "os";
+import { discoversModels } from "../model-catalog";
+import { chatDriverFor } from "./drivers";
+import type { ChatModel } from "./events";
+
+const TTL_MS = 5 * 60_000;
+const TIMEOUT_MS = 30_000;
+
+interface Entry {
+  models: ChatModel[];
+  at: number;
+}
+const cache = new Map<string, Entry>();
+const loading = new Map<string, Promise<ChatModel[]>>();
+
+const expand = (p: string) => p.replace(/^~(?=$|\/)/, os.homedir());
+
+async function discover(agentType: string, cwd: string): Promise<ChatModel[]> {
+  const driver = chatDriverFor(agentType);
+  if (!driver) return [];
+  const ac = new AbortController();
+  const timer = setTimeout(
+    () => ac.abort(new Error("Discovery timed out")),
+    TIMEOUT_MS
+  );
+  timer.unref?.();
+  try {
+    const found = await Promise.race([
+      driver.discover({ cwd, env: {}, signal: ac.signal }),
+      new Promise<never>((_, reject) =>
+        ac.signal.addEventListener("abort", () => reject(ac.signal.reason), {
+          once: true,
+        })
+      ),
+    ]);
+    return found.models;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+// The models an agent reports for a folder, cached for a few minutes.
+// `refresh` skips the cache; a failure throws and is never cached.
+export async function discoveredModels(
+  agentType: string,
+  folder: string | null | undefined,
+  refresh = false
+): Promise<ChatModel[]> {
+  if (!discoversModels(agentType)) return [];
+  const cwd = expand(folder?.trim() || "~");
+  const key = `${agentType}:${cwd}`;
+  const hit = cache.get(key);
+  if (!refresh && hit && Date.now() - hit.at < TTL_MS) return hit.models;
+  const running = loading.get(key);
+  if (running && !refresh) return running;
+  const run = discover(agentType, cwd)
+    .then((models) => {
+      cache.set(key, { models, at: Date.now() });
+      return models;
+    })
+    .finally(() => {
+      if (loading.get(key) === run) loading.delete(key);
+    });
+  loading.set(key, run);
+  return run;
+}
+
+export function clearDiscoveredModels(): void {
+  cache.clear();
+  loading.clear();
+}
+
+// Whether the agent reports this model. A failed discovery says no, so a
+// launch falls back to the agent's default rather than failing.
+export async function isDiscoveredModel(
+  agentType: string,
+  folder: string | null | undefined,
+  model: string
+): Promise<boolean> {
+  try {
+    return (await discoveredModels(agentType, folder)).some(
+      (m) => m.value === model
+    );
+  } catch {
+    return false;
+  }
+}

package/lib/model-catalog.ts

@@ -1,5 +1,6 @@
 import type { AgentType } from "./providers";
 import { AGENT_DEFAULT_MODEL } from "./providers/registry";
+import { supportsChat } from "./chat/capabilities";
 
 export interface ModelOption {
   value: string;
@@ -48,6 +49,14 @@ const DEFAULT_MODEL_BY_AGENT: Partial<Record<AgentType, string>> = {
   gemini: "gemini-3.8-flash",
 };
 
+export function hasStaticModelCatalog(agentType: string): boolean {
+  return agentType in MODEL_OPTIONS_BY_AGENT;
+}
+
+// A chat agent with no fixed list: it reports what it can run itself.
+export const discoversModels = (agentType: string): boolean =>
+  supportsChat(agentType) && !hasStaticModelCatalog(agentType);
+
 export function getModelOptions(agentType: AgentType): ModelOption[] {
   return MODEL_OPTIONS_BY_AGENT[agentType] ?? AGENT_DEFAULT_OPTIONS;
 }

package/lib/sessions/launch.ts

@@ -11,7 +11,8 @@ import { randomUUID } from "crypto";
 import { db, queries, type Session } from "../db";
 import type { AgentType } from "../providers";
 import type { ChatAccess, ChatFile, ChatImage } from "../chat/events";
-import { resolveModelForAgent } from "../model-catalog";
+import { discoversModels, resolveModelForAgent } from "../model-catalog";
+import { isDiscoveredModel } from "../chat/discovered-models";
 import { parseOverride, resolveRole, setSessionModel } from "../models/resolve";
 import { ANTHROPIC } from "../models/roles";
 import { getProject } from "../projects";
@@ -251,12 +252,18 @@ async function launch(input: LaunchInput, id: string): Promise<Launched> {
     routed && (routed.provider.id === ANTHROPIC || view === "chat")
       ? routed
       : null;
+  const wanted = input.model?.trim() || project?.default_model;
+  // An agent without a static list runs what it reports for this folder.
+  const discovered =
+    !interactive &&
+    wanted &&
+    discoversModels(agentType) &&
+    (await isDiscoveredModel(agentType, projectPath, wanted));
   const model = interactive
     ? interactive.model
-    : resolveModelForAgent(
-        agentType,
-        input.model?.trim() || project?.default_model
-      );
+    : discovered && wanted
+      ? wanted
+      : resolveModelForAgent(agentType, wanted);
   const text = input.prompt?.trim() ?? "";
   const naming: Naming = text
     ? await nameFor(text, projectPath, input.name)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@saadnvd1/agent-os",
-  "version": "0.3.691",
+  "version": "0.3.692",
   "description": "Self-hosted web UI for managing Claude Code sessions",
   "bin": {
     "agent-os": "scripts/agent-os"