@saadnvd1/agent-os 0.3.471 → 0.3.473

package/lib/models/session-model.ts

@@ -0,0 +1,40 @@
+/**
+ * Moving a session to another model without losing its conversation or
+ * worktree. On the same provider a live conversation switches in place;
+ * across providers the endpoint and key are in the agent's environment, so
+ * its worker goes and the next message starts one that resumes the same
+ * conversation on the new provider.
+ */
+
+import { db, type Session } from "../db";
+import { registry } from "../chat/registry";
+import { setChatModel } from "../chat/settings";
+import { setSessionModel, type RoutedModel } from "./resolve";
+import { ANTHROPIC } from "./roles";
+
+export async function switchSessionModel(
+  sessionId: string,
+  routed: RoutedModel
+): Promise<void> {
+  const before = db
+    .prepare(`SELECT model_provider FROM sessions WHERE id = ?`)
+    .get(sessionId) as Pick<Session, "model_provider"> | undefined;
+  setSessionModel(sessionId, routed);
+  await applySessionModel(
+    sessionId,
+    before?.model_provider ?? ANTHROPIC,
+    routed
+  );
+}
+
+// What's live catches up with the row: the model now, or a fresh worker.
+export async function applySessionModel(
+  sessionId: string,
+  fromProvider: string,
+  routed: RoutedModel
+): Promise<void> {
+  if (fromProvider === routed.provider.id)
+    return setChatModel(sessionId, routed.model);
+  if (registry.live.has(sessionId))
+    (await import("../chat/runner")).stopChat(sessionId);
+}

package/lib/models/test-provider.ts

@@ -0,0 +1,116 @@
+/**
+ * "Test provider": one tiny request to a provider's endpoint with its key,
+ * reporting whether it answered. The key goes only into the request's
+ * header; what comes back is scrubbed of it before anyone sees it.
+ */
+
+import { runClaude, type ClaudeRunner } from "../orchestrator/claude-cli";
+import { effectiveModels } from "./config";
+import type { ModelProvider } from "./providers";
+import { ANTHROPIC } from "./roles";
+import { redact, resolveSecret, type SecretCommand } from "./secrets";
+import os from "os";
+
+export interface ProviderTest {
+  ok: boolean;
+  message: string;
+  ms: number;
+}
+
+const PROMPT = "Reply with the word OK.";
+
+export async function testProvider(
+  providerId: string,
+  model?: string,
+  deps: {
+    exec?: SecretCommand;
+    fetch?: typeof fetch;
+    claude?: ClaudeRunner;
+  } = {}
+): Promise<ProviderTest> {
+  const started = Date.now();
+  const done = (ok: boolean, message: string): ProviderTest => ({
+    ok,
+    message: redact(message).slice(0, 300),
+    ms: Date.now() - started,
+  });
+  const p = effectiveModels().providers.find((x) => x.id === providerId);
+  if (!p) return done(false, `No provider "${providerId}"`);
+  const m = model || p.tiers?.haiku || p.models[0];
+  if (!m) return done(false, "It lists no model to try");
+  try {
+    if (p.id === ANTHROPIC) {
+      await (deps.claude ?? runClaude)({
+        cwd: os.tmpdir(),
+        system: "Answer in the schema.",
+        prompt: PROMPT,
+        schema: {
+          type: "object",
+          properties: { ok: { type: "boolean" } },
+          required: ["ok"],
+        },
+        tools: [],
+        model: m,
+        timeoutMs: 60_000,
+      });
+      return done(true, `${m} answered through the Claude login`);
+    }
+    if (!p.baseUrl || !p.auth) return done(false, "Set its base URL and key");
+    const key = await resolveSecret(p.auth, deps.exec);
+    const res = await (deps.fetch ?? fetch)(...request(p, m, key));
+    // Never followed: a redirect would carry the key somewhere else.
+    if (res.status >= 300 && res.status < 400)
+      return done(
+        false,
+        `HTTP ${res.status}: the endpoint redirected; set its final URL`
+      );
+    if (res.ok) return done(true, `${m} answered (HTTP ${res.status})`);
+    const body = (await res.text().catch(() => ""))
+      .slice(0, 200)
+      .replace(/[\u0000-\u001f\u007f-\u009f]/g, " ");
+    return done(false, `HTTP ${res.status}: ${body}`);
+  } catch (e) {
+    return done(false, e instanceof Error ? e.message : String(e));
+  }
+}
+
+function request(
+  p: ModelProvider,
+  model: string,
+  key: string
+): [string, RequestInit] {
+  const base = p.baseUrl!.replace(/\/+$/, "");
+  const messages = [{ role: "user", content: PROMPT }];
+  const signal = AbortSignal.timeout(30_000);
+  const redirect = "manual" as const;
+  if (p.api === "openai")
+    return [
+      `${base}/chat/completions`,
+      {
+        method: "POST",
+        redirect,
+        signal,
+        headers: {
+          "content-type": "application/json",
+          authorization: `Bearer ${key}`,
+        },
+        body: JSON.stringify({ model, max_tokens: 8, messages }),
+      },
+    ];
+  return [
+    `${base}/v1/messages`,
+    {
+      method: "POST",
+      redirect,
+      signal,
+      headers: {
+        "content-type": "application/json",
+        "anthropic-version": "2023-06-01",
+        ...(p.authHeader === "x-api-key"
+          ? { "x-api-key": key }
+          : { authorization: `Bearer ${key}` }),
+      },
+      body: JSON.stringify({ model, max_tokens: 8, messages }),
+    },
+  ];
+}

package/lib/orchestrator/act.ts

@@ -4,6 +4,7 @@
  * the brakes.
  */
 
+import { parseOverride, type ModelOverride } from "../models/resolve";
 import { sendMessage } from "../bus";
 import { chatState, interruptChat } from "../chat/runner";
 import { hostExec, isRemoteHost } from "../hosts";
@@ -80,9 +81,17 @@ export async function startTask(
   workspaceId: string,
   projectRef: string,
   prompt: string,
-  opts: { base?: string; name?: string; view?: StartView; after?: string } = {}
+  opts: {
+    base?: string;
+    name?: string;
+    view?: StartView;
+    after?: string;
+    model?: ModelOverride;
+    plan?: boolean;
+  } = {}
 ): Promise<string> {
   const project = workspaceProject(workspaceId, projectRef);
+  const model = parseOverride(opts.model) ?? undefined;
   // Its brakes read this machine's usage, not the other machine's account.
   if (isRemoteHost(project.host_id))
     throw new Error(
@@ -97,6 +106,7 @@ export async function startTask(
       prompt,
       name: opts.name,
       view,
+      model,
       baseBranch: opts.base || undefined,
       after: opts.after,
       originWorkspaceId: workspaceId,
@@ -112,6 +122,8 @@ export async function startTask(
             name: opts.name,
             baseBranch: opts.base || undefined,
             view,
+            model,
+            plan: opts.plan,
           }),
         (s) => s.id
       )

package/lib/orchestrator/brief.ts

@@ -92,7 +92,8 @@ Reading:
 Acting:
 - \`${TOOL_NAMES.send}\` (session, message, scope_change?): message a session; it arrives as its next prompt. scope_change records it on the task's brief for its review.
 - \`${TOOL_NAMES.message_orchestrator}\` (workspace, message): message another workspace's orchestrator, the only thing you reach outside this workspace. Use it to hand over a bug or ask for something in its projects; it decides what to do there.
-- \`${TOOL_NAMES.start_task}\` (project, prompt, base?, name?, view?, after?): a task in its own worktree that ends in a PR. Write the prompt as a full brief; name it in 2-6 words, or it's named from the prompt. It runs as a chat; pass view terminal only when the job needs a TUI. Pass after (a task's id or name, or "any") to hold it until that task finishes, instead of remembering it in your notes. Over the workspace's running task limit it's queued too: the result says "Queued (position N)", it starts by itself, and you get an event when it does.
+- \`${TOOL_NAMES.start_task}\` (project, prompt, base?, name?, view?, after?, model?, plan?): a task in its own worktree that ends in a PR. Write the prompt as a full brief; name it in 2-6 words, or it's named from the prompt. It runs as a chat; pass view terminal only when the job needs a TUI. Pass after (a task's id or name, or "any") to hold it until that task finishes, instead of remembering it in your notes. Over the workspace's running task limit it's queued too: the result says "Queued (position N)", it starts by itself, and you get an event when it does. Its models follow the role settings (it plans on the planning model, then implements on the implementation one); pass model ("provider/model", or a map of role to one) only when Saad asks for one, and another provider than anthropic only then.
+- \`${TOOL_NAMES.set_task_model}\` (task, model, message?): move a paused task to another model and carry on in the same conversation and worktree; it keeps that model from then on. Only when Saad asks.
 - \`${TOOL_NAMES.start_session}\` (project, prompt, name?, view?): an interactive session, a chat unless view is terminal.
 - \`${TOOL_NAMES.stack}\` (target, plan_only?): run a board's open cards as stacked tasks; plan_only shows the plan without starting.
 - \`${TOOL_NAMES.land}\` (id): merge a stack bottom-up through the gates.

package/lib/orchestrator/claude-cli.ts

@@ -10,6 +10,9 @@
 
 import { spawn } from "child_process";
 import { runUsageOf, type RunUsage } from "../usage/check-runs";
+import { routedRun } from "../models/launch";
+import type { ModelRole } from "../models/roles";
+import { redact } from "../models/secrets";
 
 export interface ClaudeRun {
   cwd: string;
@@ -21,16 +24,18 @@ export interface ClaudeRun {
   // Permission rules within those, e.g. "Bash(git diff:*)".
   allow?: string[];
   timeoutMs?: number;
-  // A model alias or id; the review model (or the CLI's default) otherwise.
+  // A model alias or id on Anthropic; the role's model otherwise.
   model?: string;
   // What the run cost, from its result, even when it failed.
   onUsage?: (usage: RunUsage) => void;
+  // The kind of work it is, which picks its model and provider
+  // (lib/models): Settings' and the workspace's role models.
+  role?: ModelRole;
+  workspaceId?: string | null;
 }
 
 export type ClaudeRunner = (run: ClaudeRun) => Promise<unknown>;
 
-const MODEL = process.env.AGENTOS_REVIEW_MODEL;
-
 // All a check's process gets from the server's environment: enough to run
 // and to sign in to Claude, nothing else.
 const ENV_ALLOW = [
@@ -57,7 +62,7 @@ export function checkEnv(
 }
 
 export function claudeArgs(run: ClaudeRun): string[] {
-  const model = run.model ?? MODEL;
+  const model = run.model;
   return [
     "-p",
     "--output-format",
@@ -87,12 +92,35 @@ export function claudeArgs(run: ClaudeRun): string[] {
   ];
 }
 
+interface ClaudeResult {
+  is_error?: boolean;
+  result?: string;
+  structured_output?: unknown;
+}
+
 // The structured answer, or throws with what went wrong.
-export const runClaude: ClaudeRunner = (run) =>
-  new Promise((resolve, reject) => {
+export const runClaude: ClaudeRunner = async (run) => {
+  const routed =
+    run.role && !run.model
+      ? await routedRun(run.role, { workspaceId: run.workspaceId })
+      : null;
+  const result = await execClaude(
+    { ...run, model: run.model ?? routed?.model },
+    { ...checkEnv(), ...routed?.env },
+    routed?.provider ?? "anthropic"
+  );
+  return result.structured_output;
+};
+
+function execClaude(
+  run: ClaudeRun,
+  env: NodeJS.ProcessEnv,
+  provider: string
+): Promise<ClaudeResult> {
+  return new Promise((resolve, reject) => {
     const child = spawn("claude", claudeArgs(run), {
       cwd: run.cwd,
-      env: checkEnv(),
+      env,
       stdio: ["pipe", "pipe", "pipe"],
     });
     let out = "";
@@ -113,20 +141,21 @@ export const runClaude: ClaudeRunner = (run) =>
     child.on("close", () => {
       clearTimeout(timer);
       try {
-        const result = JSON.parse(out) as {
-          is_error?: boolean;
-          result?: string;
-          structured_output?: unknown;
-        };
+        const result = JSON.parse(out) as ClaudeResult;
         const usage = runUsageOf(result);
-        if (usage) run.onUsage?.(usage);
+        if (usage) run.onUsage?.({ ...usage, provider });
         if (result.is_error || result.structured_output === undefined)
           throw new Error(result.result || "No answer");
-        resolve(result.structured_output);
+        resolve(result);
       } catch (e) {
         const why = e instanceof Error ? e.message : String(e);
-        reject(new Error(`claude -p failed: ${why} ${err.slice(-300)}`.trim()));
+        reject(
+          new Error(
+            redact(`claude -p failed: ${why} ${err.slice(-300)}`.trim())
+          )
+        );
       }
     });
     child.stdin.end(run.prompt);
   });
+}

package/lib/orchestrator/home.ts

@@ -5,12 +5,12 @@
  * sessions.
  */
 
+import { resolveRoleOrDefault } from "../models/resolve";
 import fs from "fs";
 import os from "os";
 import path from "path";
 import { randomBytes, randomUUID, timingSafeEqual } from "crypto";
 import { db, type Session } from "../db";
-import { resolveModelForAgent } from "../model-catalog";
 import { getWorkspace } from "../workspaces";
 
 // It works through tools, not in a repo: a scratch folder of its own.
@@ -62,7 +62,7 @@ export function ensureOrchestrator(workspaceId: string): Session {
     `${workspace.name} orchestrator`,
     `claude-${id}`,
     dir,
-    resolveModelForAgent("claude", null),
+    resolveRoleOrDefault("orchestrator", { workspaceId }).model,
     workspaceId
   );
   return getOrchestrator(workspaceId)!;

package/lib/orchestrator/review.ts

@@ -155,6 +155,8 @@ async function reviewJob(
         tools: ["Read", "Grep", "Glob"],
         allow: [`Read(/${dir}/**)`, `Grep(/${dir}/**)`, `Glob(/${dir}/**)`],
         onUsage,
+        role: "review",
+        workspaceId,
       });
       verdicts.push(toVerdict(answer));
     }

package/lib/orchestrator/scope.ts

@@ -87,6 +87,8 @@ export async function checkScope(input: {
           sha,
           kind: "scope",
         }),
+        role: "scope",
+        workspaceId,
       })) as { within?: boolean; reason?: string };
       if (answer.within !== true) break;
     }

package/lib/orchestrator/serve.ts

@@ -1,3 +1,5 @@
+import { resumeOnModel } from "../models/resume";
+import { workspaceTask } from "./targets";
 import { getWorkspace } from "../workspaces";
 import {
   done,
@@ -33,6 +35,7 @@ const ACTING = new Set<ToolName>([
   "send",
   "message_orchestrator",
   "start_task",
+  "set_task_model",
   "start_session",
   "stack",
   "land",
@@ -97,8 +100,18 @@ export async function runTool(
         name: a.name,
         view: a.view,
         after: a.after,
+        model: a.model,
+        plan: a.plan,
       });
     }
+    case "set_task_model": {
+      const a = p(tool, raw);
+      const task = workspaceTask(w, a.task);
+      const out = await resumeOnModel(task.id, a.model, a.message);
+      return out.resumed
+        ? `Resumed ${task.name} on ${out.ref}: same conversation and worktree.`
+        : `${task.name} hasn't launched yet; it starts on ${out.ref}.`;
+    }
     case "start_session": {
       const a = p(tool, raw);
       return startSession(w, a.project, a.prompt, {

package/lib/orchestrator/tool-names.ts

@@ -14,6 +14,7 @@ export const TOOL_NAMES = {
   orchestrators: name("orchestrators"),
   message_orchestrator: name("message_orchestrator"),
   start_task: name("start_task"),
+  set_task_model: name("set_task_model"),
   start_session: name("start_session"),
   stack: name("stack"),
   stack_status: name("stack_status"),

package/lib/orchestrator/tool-schemas.ts

@@ -6,6 +6,7 @@ import { BRANCH_NAME } from "../git";
 import { RAISED_KINDS } from "./asks";
 import { MAX_RULE_CHARS } from "./rules";
 import { PROJECT_NAME } from "../project-add/name";
+import { TASK_ROLES, type ModelRole } from "../models/roles";
 
 const ref = (what: string) => z.string().trim().min(1).max(300).describe(what);
 const session = ref("Session name, project/name, or id from sessions");
@@ -19,6 +20,28 @@ const view = z
     "How its agent runs: chat (the default), or terminal only when the job needs a TUI (an interactive program, a full-screen tool)"
   );
 
+const modelRef = z
+  .string()
+  .trim()
+  .regex(/^[a-z0-9][a-z0-9_-]*\/[\w.:@/-]+$/i, 'not "provider/model"');
+const modelOverride = z
+  .union([
+    modelRef,
+    // Named optional keys, not z.partialRecord: its "propertyNames" makes
+    // Claude Code drop every tool on this server, not just this one.
+    z
+      .object(
+        Object.fromEntries(
+          TASK_ROLES.map((role) => [role, modelRef.optional()])
+        ) as Record<ModelRole, z.ZodOptional<typeof modelRef>>
+      )
+      .strict(),
+  ])
+  .optional()
+  .describe(
+    "Its own model, as \"provider/model\" (anthropic/claude-sonnet-5-5, deepseek/deepseek-v4-pro) for all its roles, or a map of role (plan, implement, review, scope) to one. Default: the workspace's and Settings' role models; another provider only when asked"
+  );
+
 export const TOOL_SHAPES = {
   sessions: {},
   read: {
@@ -79,6 +102,26 @@ export const TOOL_SHAPES = {
       .describe(
         'Queue it until this task finishes (id or name), or "any" for whichever running task finishes first'
       ),
+    model: modelOverride,
+    plan: z
+      .boolean()
+      .optional()
+      .describe(
+        "Plan first on the planning model, then implement on the implementation model (default: Settings)"
+      ),
+  },
+  set_task_model: {
+    task,
+    model: modelOverride.unwrap(),
+    message: z
+      .string()
+      .trim()
+      .min(1)
+      .max(8000)
+      .optional()
+      .describe(
+        "What it's told on resuming (default: carry on where it left off)"
+      ),
   },
   start_session: {
     project,

package/lib/orchestrator/tools.ts

@@ -61,7 +61,9 @@ const DESCRIPTIONS: Record<ToolName, string> = {
   message_orchestrator:
     "Message another workspace's orchestrator, by workspace name; never any other session there. It arrives as its next prompt, marked as from you and fenced as untrusted.",
   start_task:
-    "Start a task: an agent in its own worktree that ends in a PR. It runs as a chat unless view is terminal (only for a job that needs a TUI). With after (a task's id or name, or \"any\"), or over the workspace's running task limit, it's queued and starts by itself; the result says Queued (position N). Refused while a brake holds.",
+    "Start a task: an agent in its own worktree that ends in a PR. It runs as a chat unless view is terminal (only for a job that needs a TUI). With after (a task's id or name, or \"any\"), or over the workspace's running task limit, it's queued and starts by itself; the result says Queued (position N). Its models follow the role settings (planning, implementation, review, scope); give model only when Saad asks for one. Refused while a brake holds.",
+  set_task_model:
+    'Resume a paused task on another model ("provider/model", or a map of role to one), keeping its conversation and worktree; it\'s told to carry on (or message). Refused mid-turn.',
   start_session:
     "Start an interactive agent session in a project with a prompt. It runs as a chat unless view is terminal (only for a job that needs a TUI). Refused while a brake holds.",
   stack:

package/lib/pr-generation.ts

@@ -1,3 +1,4 @@
+import { routedRun } from "./models/launch";
 import { execFile } from "child_process";
 import { git as runGit } from "./git-exec";
 import { run } from "./tasks/gh";
@@ -154,13 +155,15 @@ async function generateWithClaude(
 
 // `claude --print` with the prompt on stdin, off the event loop and killed
 // at the ceiling.
-function claudePrint(cwd: string, prompt: string): Promise<string> {
+async function claudePrint(cwd: string, prompt: string): Promise<string> {
+  const routed = await routedRun("helper");
   return new Promise((resolve, reject) => {
     const child = execFile(
       "claude",
-      ["--print"],
+      ["--print", "--model", routed.model],
       {
         cwd,
+        env: { ...process.env, ...routed.env },
         encoding: "utf-8",
         timeout: 30_000,
         killSignal: "SIGKILL",

package/lib/providers/registry.ts

@@ -73,7 +73,7 @@ export const PROVIDERS: ProviderDefinition[] = [
     supportsFork: true,
     resumeArgs: (id) => ["--resume", id],
     forkArgs: (id) => ["--resume", id, "--fork-session"],
-    modelFlag: undefined, // Claude doesn't expose model flag
+    modelFlag: "--model",
     initialPromptFlag: "", // Positional argument
   },
   {

package/lib/session-titles.ts

@@ -174,7 +174,7 @@ export async function generateTitle(
       prompt: input,
       schema: SCHEMA,
       tools: [],
-      model: process.env.AGENTOS_TITLE_MODEL || "haiku",
+      role: "helper",
       timeoutMs: 30_000,
     })) as { title?: unknown };
     return cleanTitle(out?.title);

package/lib/sessions/launch.ts

@@ -11,6 +11,8 @@ import { db, queries, type Session } from "../db";
 import type { AgentType } from "../providers";
 import type { ChatAccess, ChatImage } from "../chat/events";
 import { resolveModelForAgent } from "../model-catalog";
+import { resolveRole, setSessionModel } from "../models/resolve";
+import { ANTHROPIC } from "../models/roles";
 import { getProject } from "../projects";
 import { getHost, isRemoteHost } from "../hosts";
 import { hostLink } from "../hosts/remote-api";
@@ -214,14 +216,26 @@ async function launch(input: LaunchInput, id: string): Promise<Launched> {
     await fs.promises.mkdir(SCRATCH_DIR, { recursive: true });
 
   const agentType = input.agentType;
-  const model = resolveModelForAgent(
-    agentType,
-    input.model?.trim() || project?.default_model
-  );
   const view =
     input.view === "terminal" || !supportsChat(agentType) || remote
       ? "terminal"
       : DEFAULT_START_VIEW;
+  // Claude with no model picked runs on the interactive role's, here; on
+  // another provider only as a chat, whose worker carries its endpoint.
+  const routed =
+    agentType === "claude" && !input.model?.trim() && !remote
+      ? resolveRole("interactive", { workspaceId: project?.workspace_id })
+      : null;
+  const interactive =
+    routed && (routed.provider.id === ANTHROPIC || view === "chat")
+      ? routed
+      : null;
+  const model = interactive
+    ? interactive.model
+    : resolveModelForAgent(
+        agentType,
+        input.model?.trim() || project?.default_model
+      );
   const text = input.prompt?.trim() ?? "";
   const naming: Naming = text
     ? await nameFor(text, projectPath, input.name)
@@ -252,6 +266,7 @@ async function launch(input: LaunchInput, id: string): Promise<Launched> {
   db.prepare(
     `UPDATE sessions SET view = ?, name_source = ?, setup_status = ? WHERE id = ?`
   ).run(view, naming.source, useWorktree ? "running" : null, id);
+  if (interactive) setSessionModel(id, interactive);
   if (input.access)
     db.prepare(`UPDATE sessions SET chat_access = ? WHERE id = ?`).run(
       input.access,

package/lib/settings-url.ts

@@ -7,6 +7,7 @@ export const SETTINGS_PARAM = "settings";
 export const SETTINGS_SECTIONS = [
   "merging",
   "workspaces",
+  "models",
   "devices",
   "notifications",
   "schedules",