@saadnvd1/agent-os 0.3.744 → 0.3.749

package/lib/chat/turn-end.ts

@@ -0,0 +1,16 @@
+import type { TurnEndReason } from "./events";
+
+// The ends a Retry button can resume: the model's side failed or went quiet.
+const RETRYABLE: TurnEndReason[] = [
+  "error",
+  "empty",
+  "stalled",
+  "compaction_empty",
+  "cut_off",
+];
+
+export const retryableEnd = (reason: TurnEndReason) =>
+  RETRYABLE.includes(reason);
+
+// What Retry sends: the steps that ran stay, the model carries on.
+export const RETRY_TEXT = "continue";

package/lib/drafts.ts

@@ -35,6 +35,8 @@ export interface Draft {
   roleModel?: string | null;
   // Pair it with an analyst that reviews each turn (a local chat only).
   withAnalyst?: boolean;
+  // The analyst's model, "provider/model"; unset, the analyst role's.
+  analystModel?: string | null;
   // A task's priority in the queue; unset: normal.
   taskPriority?: Priority;
   createdAt: number;

package/lib/models/agent-binding.ts

@@ -9,6 +9,7 @@ import { AGENT_ROLE_DEFS, type AgentRole } from "./agent-roles";
 import { modelAvailability, choiceFor } from "./catalog";
 import { savedModelSettings } from "./config";
 import { PI } from "./providers";
+import { checkToolUse, ollamaOrigin } from "./tool-use";
 import { resolveRole, type RoleSource, type RoutedModel } from "./resolve";
 
 export interface RoleBinding {
@@ -50,6 +51,22 @@ export class ModelUnavailableError extends Error {
   }
 }
 
+// An analyst reads code and transcripts through tools: a model its server
+// says can't call them is refused, with the reason.
+export async function assertCanCallTools(
+  role: AgentRole,
+  ref: string
+): Promise<void> {
+  if (role !== "analyst") return;
+  const choice = choiceFor(ref);
+  if (!choice || choice.locality !== "local" || !choice.endpoint) return;
+  const model = choice.ref.split("/").slice(choice.agent === "pi" ? 2 : 1);
+  if (!(await checkToolUse(ollamaOrigin(choice.endpoint), model.join("/"))))
+    throw new Error(
+      `${choice.label} can't call tools; an analyst reads code through tools`
+    );
+}
+
 export interface RoleStart {
   role: AgentRole;
   routed: RoutedModel;
@@ -82,13 +99,17 @@ export async function prepareRoleStart(
 ): Promise<RoleStart> {
   const binding = bindingFor(role, opts);
   const state = await modelAvailability(binding.routed.ref);
-  if (state.state !== "down")
+  if (state.state !== "down") {
+    await assertCanCallTools(role, binding.routed.ref);
     return startFrom(role, binding.routed, binding.routed.source);
+  }
   if (opts.useFallback && binding.fallback) {
     const alt = bindingFor(role, { ...opts, override: binding.fallback });
     const altState = await modelAvailability(alt.routed.ref);
-    if (altState.state !== "down")
+    if (altState.state !== "down") {
+      await assertCanCallTools(role, alt.routed.ref);
       return startFrom(role, alt.routed, "fallback");
+    }
   }
   throw new ModelUnavailableError(
     role,

package/lib/models/catalog.ts

@@ -10,7 +10,8 @@ import os from "os";
 import path from "path";
 import { effectiveModels, type EffectiveModels } from "./config";
 import { ANTHROPIC } from "./roles";
-import { PI, type ModelProvider } from "./providers";
+import { PI, providerProblem, type ModelProvider } from "./providers";
+import { cachedToolUse, ollamaOrigin } from "./tool-use";
 import { hostLocality, type Locality } from "./locality";
 import {
   cachedAvailability,
@@ -31,6 +32,10 @@ export interface ModelChoice {
   availability: Availability;
   // May serve a merge gate: Claude Code can run it.
   gateCapable: boolean;
+  // May call tools, which an analyst needs (lib/models/tool-use).
+  toolUse: boolean;
+  // Why it can't be started at all (its provider is off or half set up).
+  unusable?: string;
   // Where the server is (never a key).
   endpoint?: string;
 }
@@ -84,6 +89,16 @@ export function piProviders(file = piModelsFile()): PiProvider[] {
 const providerEndpoint = (p: ModelProvider) =>
   p.baseUrl ? probeUrl(p.baseUrl, p.api) : undefined;
 
+// Anthropic's and cloud models can; a model on a local server is asked of it.
+const toolUseOf = (
+  baseUrl: string | undefined,
+  locality: Locality,
+  model: string
+) =>
+  baseUrl && locality === "local"
+    ? cachedToolUse(ollamaOrigin(baseUrl), model)
+    : true;
+
 export function modelCatalog(
   effective: EffectiveModels = effectiveModels(),
   pi: PiProvider[] = piProviders()
@@ -98,6 +113,7 @@ export function modelCatalog(
         : locality === "local" && endpoint
           ? cachedAvailability(endpoint)
           : { state: "unknown", checkedAt: null };
+    const unusable = providerProblem(p) ?? undefined;
     for (const m of p.models)
       out.push({
         ref: `${p.id}/${m}`,
@@ -107,6 +123,8 @@ export function modelCatalog(
         locality,
         availability,
         gateCapable: p.api === "anthropic",
+        toolUse: toolUseOf(p.baseUrl, locality, m),
+        ...(unusable && { unusable }),
         endpoint: p.baseUrl,
       });
   }
@@ -126,12 +144,36 @@ export function modelCatalog(
         locality,
         availability,
         gateCapable: false,
+        toolUse: toolUseOf(p.baseUrl, locality, m.id),
         endpoint: p.baseUrl,
       });
   }
   return out;
 }
 
+// The models of providers that are turned off, so a picker can show them
+// greyed with the reason rather than leave them out.
+export function unconfiguredChoices(
+  effective: EffectiveModels = effectiveModels()
+): ModelChoice[] {
+  return effective.providers
+    .filter((p) => !p.enabled)
+    .flatMap((p) =>
+      p.models.map((m) => ({
+        ref: `${p.id}/${m}`,
+        label: m,
+        group: p.label,
+        agent: "claude" as const,
+        locality: hostLocality(p.baseUrl),
+        availability: { state: "unknown" as const, checkedAt: null },
+        gateCapable: false,
+        toolUse: true,
+        unusable: providerProblem(p) ?? undefined,
+        endpoint: p.baseUrl,
+      }))
+    );
+}
+
 export const choiceFor = (
   ref: string,
   effective?: EffectiveModels

package/lib/models/providers.ts

@@ -50,6 +50,18 @@ export interface ModelPrice {
   output: number;
 }
 
+// Why a provider can't run a Claude Code session, or null when it can.
+export function providerProblem(p: ModelProvider): string | null {
+  if (!p.enabled) return `The ${p.label} provider is turned off`;
+  // Anthropic runs on the Claude login: no URL or key of ours.
+  if (p.id === ANTHROPIC) return null;
+  if (!p.baseUrl || !p.auth)
+    return `The ${p.label} provider needs a base URL and a key`;
+  if (p.api !== "anthropic")
+    return `${p.label} speaks the OpenAI API; Claude Code needs an Anthropic-compatible endpoint`;
+  return null;
+}
+
 export const ANTHROPIC_PROVIDER: ModelProvider = {
   id: ANTHROPIC,
   label: "Anthropic (Claude login)",

package/lib/models/resolve.ts

@@ -21,6 +21,7 @@ import {
   ANTHROPIC_PROVIDER,
   PI,
   PI_PROVIDER,
+  providerProblem,
   type ModelProvider,
 } from "./providers";
 import {
@@ -111,13 +112,8 @@ export function providerFor(
   }
   const p = models.providers.find((x) => x.id === id);
   if (!p) throw new Error(`No model provider "${id}" (Settings > Models)`);
-  if (!p.enabled) throw new Error(`The ${p.label} provider is turned off`);
-  if (!p.baseUrl || !p.auth)
-    throw new Error(`The ${p.label} provider needs a base URL and a key`);
-  if (p.api !== "anthropic")
-    throw new Error(
-      `${p.label} speaks the OpenAI API; Claude Code needs an Anthropic-compatible endpoint`
-    );
+  const problem = providerProblem(p);
+  if (problem) throw new Error(problem);
   return p;
 }
 

package/lib/models/session-model.ts

@@ -7,10 +7,18 @@
  */
 
 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";
+import { getSession, registry } from "../chat/registry";
+import { emitCapabilities, setChatModel } from "../chat/settings";
+import {
+  providerFor,
+  sessionRole,
+  setSessionModel,
+  type RoutedModel,
+} from "./resolve";
+import { PI } from "./providers";
+import { isAgentRole } from "./agent-roles";
+import { assertCanCallTools } from "./agent-binding";
+import { ANTHROPIC, formatModelRef, parseModelRef } from "./roles";
 
 export async function switchSessionModel(
   sessionId: string,
@@ -38,3 +46,61 @@ export async function applySessionModel(
   if (registry.live.has(sessionId))
     (await import("../chat/runner")).stopChat(sessionId);
 }
+
+// Moves a session to "provider/model" (or "pi/<provider>/<model>" for a Pi
+// session), keeping its conversation. Only this session's row changes: no
+// other session's model and no role setting.
+export async function switchSessionModelRef(
+  session: Session,
+  ref: string
+): Promise<void> {
+  const parsed = parseModelRef(ref);
+  if (isAgentRole(session.agent_role))
+    await assertCanCallTools(session.agent_role, formatModelRef(parsed));
+  if (session.agent_type === "pi") {
+    if (parsed.provider !== PI)
+      throw new Error(
+        "A Pi session runs on a Pi model (pi/<provider>/<model>)"
+      );
+    await setChatModel(session.id, parsed.model);
+    return;
+  }
+  if (parsed.provider === PI)
+    throw new Error("Only a Pi session can move to a Pi model");
+  await switchSessionModel(session.id, {
+    role: sessionRole(session),
+    ref: formatModelRef(parsed),
+    provider: providerFor(parsed.provider),
+    model: parsed.model,
+    source: "task",
+  });
+}
+
+// A pick in a chat's model list. A full ref ("provider/model") moves the
+// session across providers; a bare model on a session routed to another
+// provider goes back to Anthropic, so "opus" is never asked of another
+// provider's endpoint. Anything else is the agent's own model name.
+export async function setComposerModel(
+  sessionId: string,
+  value: string
+): Promise<void> {
+  const session = db
+    .prepare(`SELECT * FROM session_rows WHERE id = ?`)
+    .get(sessionId) as Session | undefined;
+  const model = value.trim();
+  if (!session || !model) return;
+  const claude = session.agent_type === "claude";
+  const ref = claude
+    ? model.includes("/")
+      ? model
+      : session.model_provider
+        ? `${ANTHROPIC}/${model}`
+        : null
+    : session.agent_type === "pi" && model.startsWith(`${PI}/`)
+      ? model
+      : null;
+  if (!ref) return setChatModel(sessionId, model);
+  await switchSessionModelRef(session, ref);
+  // A move across providers stops the worker, which tells nobody.
+  emitCapabilities(getSession(sessionId));
+}

package/lib/models/tool-use.ts

@@ -0,0 +1,78 @@
+/**
+ * Whether a model can call tools, which an analyst needs to read code and
+ * transcripts. There is no list of it to read, so the server asks: an Ollama
+ * server reports each model's capabilities (POST /api/show), and one that
+ * answers without "tools" is out. Anything that can't be told (a server with
+ * no such endpoint, one that doesn't answer, a cloud provider) counts as
+ * able: Pi turns text tool calls into real ones, and hiding a model we can't
+ * judge is worse than letting it try. Cached, and never awaited by a request
+ * handler unless it asks to.
+ */
+
+const TTL_MS = 10 * 60_000;
+const TIMEOUT_MS = 1_500;
+
+interface Entry {
+  toolUse: boolean;
+  at: number;
+}
+const cache = new Map<string, Entry>();
+const probing = new Map<string, Promise<boolean>>();
+
+// Where Ollama's own API lives for an OpenAI- or Anthropic-style base URL.
+export const ollamaOrigin = (baseUrl: string): string =>
+  baseUrl.replace(/\/+$/, "").replace(/\/v1$/, "");
+
+const key = (origin: string, model: string) => `${origin}\n${model}`;
+
+async function probe(origin: string, model: string): Promise<boolean> {
+  try {
+    const res = await fetch(`${origin}/api/show`, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ model }),
+      signal: AbortSignal.timeout(TIMEOUT_MS),
+      redirect: "manual",
+    });
+    if (!res.ok) return true;
+    const body = (await res.json()) as { capabilities?: unknown };
+    return Array.isArray(body.capabilities)
+      ? body.capabilities.includes("tools")
+      : true;
+  } catch {
+    return true;
+  }
+}
+
+// The last answer, probing in the background when it is stale.
+export function cachedToolUse(origin: string, model: string): boolean {
+  const k = key(origin, model);
+  const hit = cache.get(k);
+  if (!hit || Date.now() - hit.at >= TTL_MS) void checkToolUse(origin, model);
+  return hit?.toolUse ?? true;
+}
+
+export async function checkToolUse(
+  origin: string,
+  model: string
+): Promise<boolean> {
+  const k = key(origin, model);
+  const hit = cache.get(k);
+  if (hit && Date.now() - hit.at < TTL_MS) return hit.toolUse;
+  let running = probing.get(k);
+  if (!running) {
+    running = probe(origin, model)
+      .then((toolUse) => {
+        cache.set(k, { toolUse, at: Date.now() });
+        return toolUse;
+      })
+      .finally(() => probing.delete(k));
+    probing.set(k, running);
+  }
+  return running;
+}
+
+export function clearToolUse(): void {
+  cache.clear();
+  probing.clear();
+}

package/lib/models/usable.ts

@@ -0,0 +1,45 @@
+/**
+ * Why a model in the server's list can't be picked for a role, and the name
+ * a role's default shows. Imported by the browser too, so no Node modules.
+ */
+
+import { modelDisplayName } from "../model-catalog";
+import { ANTHROPIC } from "./roles";
+import type { ModelChoice } from "./catalog";
+
+// Why a model can't be picked for an analyst, or null when it can. An
+// analyst reads code and transcripts through tools, so a model that can't
+// call them is out; one whose server isn't answering is too.
+export function analystBlock(
+  c: Pick<ModelChoice, "unusable" | "toolUse" | "availability" | "agent">,
+  opts: { agent?: "claude" | "pi" } = {}
+): string | null {
+  if (c.unusable) return c.unusable;
+  if (!c.toolUse) return "Can't call tools";
+  if (c.availability.state === "down")
+    return c.availability.error
+      ? `Not answering (${c.availability.error})`
+      : "Not answering";
+  if (opts.agent && c.agent !== opts.agent)
+    return c.agent === "pi"
+      ? "Runs on Pi: start a new analyst on it"
+      : "Runs on Claude Code: start a new analyst on it";
+  return null;
+}
+
+// "Opus 5.5" for an Anthropic ref, the list's own label for any other.
+export function defaultModelName(
+  ref: string | null | undefined,
+  choices: Pick<ModelChoice, "ref" | "label">[]
+): string {
+  if (!ref) return "…";
+  const found = choices.find((c) => c.ref === ref);
+  if (ref.startsWith(`${ANTHROPIC}/`))
+    return modelDisplayName(ref.slice(ANTHROPIC.length + 1));
+  return found?.label ?? ref.split("/").slice(1).join("/");
+}
+
+export const defaultAnalystLabel = (
+  ref: string | null | undefined,
+  choices: Pick<ModelChoice, "ref" | "label">[]
+) => `Default analyst model (${defaultModelName(ref, choices)})`;

package/lib/updates/check.ts

@@ -163,6 +163,38 @@ export async function compare(deps: CheckDeps): Promise<CheckResult> {
   };
 }
 
+/**
+ * A cached answer was worked out against whatever HEAD was then. If the
+ * checkout has since moved (a pull by hand, a switch to another branch) and
+ * now contains the latest commit, there's nothing to update to.
+ */
+export async function reconcile(
+  check: CheckResult | null,
+  deps: Pick<CheckDeps, "git">
+): Promise<CheckResult | null> {
+  if (!check?.available || !check.latest) return check;
+  try {
+    const head = (await deps.git(["rev-parse", "HEAD"])).trim();
+    if (head === check.current?.sha) return check;
+    const has = await deps
+      .git(["merge-base", "--is-ancestor", check.latest.sha, "HEAD"])
+      .then(
+        () => true,
+        () => false
+      );
+    return has
+      ? {
+          ...check,
+          available: false,
+          behind: 0,
+          current: { version: check.latest.version, sha: head },
+        }
+      : check;
+  } catch {
+    return check;
+  }
+}
+
 let memo: CheckResult | null = null;
 let inflight: Promise<CheckResult> | null = null;
 

package/lib/updates/view.ts

@@ -2,7 +2,7 @@
 // whether the caller may start an update.
 
 import { isActivePhase, type UpdateView } from "./banner";
-import { cachedCheck, checkForUpdate } from "./check";
+import { cachedCheck, checkForUpdate, reconcile } from "./check";
 import {
   preflight,
   readLog,
@@ -40,6 +40,7 @@ export async function updateView(
   )
     check = (await checkForUpdate({ force: true, always: true }, deps.check))
       .result;
+  check = await reconcile(check, deps.check);
   // The log can carry paths and remote URLs; only a device that may update sees it.
   const run =
     stored && (stored.phase === "failed" || stored.phase === "built")

package/package.json

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