@saadnvd1/agent-os 0.3.470 → 0.3.472

package/components/Workspaces/WorkspaceModelsForm.tsx

@@ -0,0 +1,71 @@
+"use client";
+
+import { useState } from "react";
+import { ModelSelect } from "@/components/Models/ModelSelect";
+import {
+  useModelsQuery,
+  useUpdateWorkspaceModels,
+  useWorkspaceModelsQuery,
+} from "@/data/models";
+import { MODEL_ROLES, ROLE_LABELS, type ModelRole } from "@/lib/models/roles";
+
+// The roles that run inside a workspace; interactive sessions and helpers
+// follow Settings.
+const WORKSPACE_ROLES = MODEL_ROLES.filter(
+  (r): r is Exclude<ModelRole, "interactive" | "helper"> =>
+    r !== "interactive" && r !== "helper"
+);
+
+// A workspace's own role models, over Settings > Models.
+export function WorkspaceModelsForm({ workspaceId }: { workspaceId: string }) {
+  const [open, setOpen] = useState(false);
+  const models = useModelsQuery(open);
+  const own = useWorkspaceModelsQuery(workspaceId);
+  const update = useUpdateWorkspaceModels(workspaceId);
+  const roles = own.data?.roles ?? {};
+  const set = Object.keys(roles).length;
+
+  return (
+    <div className="space-y-2">
+      <button
+        type="button"
+        className="text-muted-foreground hover:text-foreground h-11 text-left text-xs md:h-auto"
+        onClick={() => setOpen((o) => !o)}
+        aria-expanded={open}
+      >
+        Models: {set ? `${set} set for this workspace` : "as Settings › Models"}{" "}
+        {open ? "▴" : "▾"}
+      </button>
+      {open && (
+        <ul className="space-y-2">
+          {WORKSPACE_ROLES.map((role) => (
+            <li key={role} className="space-y-1">
+              <label
+                htmlFor={`ws-${workspaceId}-${role}`}
+                className="text-muted-foreground block text-xs"
+              >
+                {ROLE_LABELS[role].label}
+              </label>
+              <ModelSelect
+                id={`ws-${workspaceId}-${role}`}
+                value={roles[role] ?? null}
+                effective={models.data?.effective}
+                inheritLabel={`As Settings (${models.data?.effective.roles[role] ?? "…"})`}
+                disabled={update.isPending || !models.data}
+                onChange={(ref) => {
+                  const next = { ...roles };
+                  if (ref) next[role] = ref;
+                  else delete next[role];
+                  update.mutate({ roles: next });
+                }}
+              />
+            </li>
+          ))}
+        </ul>
+      )}
+      {update.isError && (
+        <p className="text-destructive text-xs">{update.error.message}</p>
+      )}
+    </div>
+  );
+}

package/components/Workspaces/WorkspaceSettings.tsx

@@ -5,6 +5,7 @@ import { useUpdateWorkspace, useWorkspacesQuery } from "@/data/workspaces";
 import { TaskLimitForm } from "./TaskLimitForm";
 import { RulesForm } from "./RulesForm";
 import { FreshStartForm } from "./FreshStartForm";
+import { WorkspaceModelsForm } from "./WorkspaceModelsForm";
 
 // Settings > Workspaces: each workspace's own settings.
 export function WorkspaceSettings() {
@@ -41,6 +42,7 @@ export function WorkspaceSettings() {
             workspace={w}
           />
           <RulesForm workspaceId={w.id} />
+          <WorkspaceModelsForm workspaceId={w.id} />
           <SettingToggle
             title="Wake tasks on CI failures and reviews"
             detail="A task's agent is messaged once when a check fails on its PR's head, with the log's tail, and when someone reviews or comments on it."

package/data/models/index.ts

@@ -0,0 +1,125 @@
+import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+import type {
+  EffectiveModels,
+  ModelSettings,
+  WorkspaceModels,
+} from "@/lib/models/config";
+import type { ModelRole } from "@/lib/models/roles";
+import type { ProviderTest } from "@/lib/models/test-provider";
+import type { ResumeResult } from "@/lib/models/resume";
+import type { ModelOverride } from "@/lib/models/resolve";
+import type { Comparison } from "@/lib/usage/compare";
+
+// Model routing (lib/models): role models, providers, prices.
+export const modelKeys = {
+  all: ["models"] as const,
+  workspace: (id: string) => [...modelKeys.all, "workspace", id] as const,
+  compare: (days: number) => [...modelKeys.all, "compare", days] as const,
+};
+
+export interface ModelsResponse {
+  saved: ModelSettings;
+  effective: EffectiveModels;
+  defaults: Record<ModelRole, string>;
+}
+
+async function json<T>(res: Response): Promise<T> {
+  const data = await res.json().catch(() => ({}));
+  if (!res.ok) throw new Error(data.error || `Request failed (${res.status})`);
+  return data;
+}
+
+const send = (url: string, method: string, body: unknown) =>
+  fetch(url, {
+    method,
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(body),
+  });
+
+export function useModelsQuery(enabled = true) {
+  return useQuery({
+    queryKey: modelKeys.all,
+    queryFn: async () => json<ModelsResponse>(await fetch("/api/models")),
+    staleTime: 60_000,
+    enabled,
+  });
+}
+
+export function useUpdateModels() {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: async (settings: ModelSettings) =>
+      json<ModelsResponse>(await send("/api/models", "PUT", settings)),
+    onSuccess: (data) => queryClient.setQueryData(modelKeys.all, data),
+  });
+}
+
+export function useTestProvider() {
+  return useMutation({
+    mutationFn: async (input: { provider: string; model?: string }) =>
+      json<ProviderTest>(await send("/api/models/test", "POST", input)),
+  });
+}
+
+export function useWorkspaceModelsQuery(workspaceId: string) {
+  return useQuery({
+    queryKey: modelKeys.workspace(workspaceId),
+    queryFn: async () =>
+      json<WorkspaceModels>(
+        await fetch(`/api/workspaces/${workspaceId}/models`)
+      ),
+    staleTime: 60_000,
+  });
+}
+
+export function useUpdateWorkspaceModels(workspaceId: string) {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: async (models: WorkspaceModels) =>
+      json<WorkspaceModels>(
+        await send(`/api/workspaces/${workspaceId}/models`, "PUT", models)
+      ),
+    onSuccess: (data) =>
+      queryClient.setQueryData(modelKeys.workspace(workspaceId), data),
+  });
+}
+
+export function useResumeOnModel() {
+  return useMutation({
+    mutationFn: async (input: {
+      taskId: string;
+      model: ModelOverride;
+      message?: string;
+    }) =>
+      json<ResumeResult>(
+        await send(`/api/tasks/${input.taskId}/model`, "POST", {
+          model: input.model,
+          message: input.message,
+        })
+      ),
+  });
+}
+
+export function useCompareQuery(days: number, enabled = true) {
+  return useQuery({
+    queryKey: modelKeys.compare(days),
+    queryFn: async () =>
+      json<Comparison>(await fetch(`/api/usage/compare?days=${days}`)),
+    enabled,
+    staleTime: 60_000,
+    placeholderData: (prev) => prev,
+  });
+}
+
+// Every model a role can be set to: each usable provider's, as references.
+export function modelChoices(effective: EffectiveModels | undefined) {
+  return (effective?.providers ?? [])
+    .filter((p) => p.enabled)
+    .flatMap((p) =>
+      p.models.map((m) => ({
+        ref: `${p.id}/${m}`,
+        label: m,
+        provider: p.label,
+      }))
+    );
+}

package/data/usage/index.ts

@@ -1,6 +1,7 @@
 import { useQuery } from "@tanstack/react-query";
 import type { UsageRange, UsageReport } from "@/lib/usage/aggregate";
 import type { UsageWindows } from "@/lib/usage/windows";
+import type { SpendByModel } from "@/lib/usage/by-model";
 
 export const usageKeys = {
   all: ["usage"] as const,
@@ -9,7 +10,11 @@ export const usageKeys = {
 
 export interface UsageResponse {
   report: UsageReport;
+  // The orchestrator's reviewer and scope check runs, by PR.
+  reviews: UsageReport;
   windows: UsageWindows;
+  // By model and role, in the plan's 5-hour window and the last 24 hours.
+  models: { fiveHour: SpendByModel; day: SpendByModel };
 }
 
 export function useUsageQuery(range: UsageRange, enabled = true) {

package/lib/agents/launch.ts

@@ -4,11 +4,13 @@ import path from "path";
 import { execFile } from "child_process";
 import { promisify } from "util";
 import { getProvider } from "../providers";
+import { sessionShellEnv } from "../models/launch";
 import { shellQuote } from "../hosts/ssh";
 import { runInBackground } from "../async-operations";
 import { trustPromptKeys } from "../tasks/state";
 import { BUS_BRIEF } from "./brief";
 import { selfUrl } from "./self-env";
+import { autoCompactEnv } from "../chat/refresh";
 import { CLAUDE_STATUS_SETTINGS_FLAG } from "../program-status/claude-flag";
 import {
   sessionProjectEnv,
@@ -35,6 +37,7 @@ export function ensureBusBrief(): void {
 export function agentEnv(sessionId: string): Record<string, string> {
   return {
     ...sessionProjectEnv(sessionId),
+    ...autoCompactEnv(sessionId),
     AGENTOS_SESSION_ID: sessionId,
     AGENTOS_URL: selfUrl(),
     PATH: `${AOS_BIN_DIR}:${process.env.PATH ?? ""}`,
@@ -62,6 +65,8 @@ export async function launchClaude(opts: {
   tmuxName: string;
   cwd: string;
   model: string;
+  // The model's provider (lib/models); Anthropic when absent.
+  provider?: string | null;
   prompt: string;
   brief?: string;
   // Continue this Claude conversation; the prompt is its next message.
@@ -86,7 +91,13 @@ export async function launchClaude(opts: {
       sessionId: opts.resume,
     })
     .join(" ");
-  const agent = `export PATH=${shellQuote(AOS_BIN_DIR)}:"$HOME/.local/bin:$PATH"; ${provider.command} ${flags} ${CLAUDE_STATUS_SETTINGS_FLAG} --append-system-prompt-file ${shellQuote(briefFile)} "$(cat ${shellQuote(promptFile)})"; exec "\${SHELL:-/bin/sh}" -l`;
+  // The provider's key is fetched by the pane's own shell from its
+  // reference: only the reference is in this command line.
+  const routing = sessionShellEnv({
+    model: opts.model,
+    model_provider: opts.provider ?? null,
+  });
+  const agent = `export PATH=${shellQuote(AOS_BIN_DIR)}:"$HOME/.local/bin:$PATH"; ${routing.exportKey} ${provider.command} ${flags} ${CLAUDE_STATUS_SETTINGS_FLAG} --append-system-prompt-file ${shellQuote(briefFile)} "$(cat ${shellQuote(promptFile)})"; exec "\${SHELL:-/bin/sh}" -l`;
   await execFileAsync(
     "tmux",
     [
@@ -96,7 +107,7 @@ export async function launchClaude(opts: {
       opts.tmuxName,
       "-c",
       opts.cwd,
-      ...envArgs(agentEnv(opts.sessionId)),
+      ...envArgs({ ...agentEnv(opts.sessionId), ...routing.env }),
       agent,
     ],
     { cwd: opts.cwd }

package/lib/chat/context.ts

@@ -49,7 +49,7 @@ export function formatTokens(n: number): string {
   return String(n);
 }
 
-type ModelUsage = Record<
+export type ModelUsage = Record<
   string,
   {
     inputTokens?: number;

package/lib/chat/refresh.ts

@@ -6,8 +6,8 @@
  * default: its state is in the database and its brief carries it
  * (lib/orchestrator/digest). A task keeps its progress only in its
  * conversation and its branch, so for tasks it's off unless switched on.
- * App-wide, in Settings → Workspaces, with the size past which an idle
- * chat is compacted before a message goes in (lib/chat/stale).
+ * App-wide, in Settings → Workspaces, with the size at which chats and
+ * tasks compact (lib/chat/stale).
  */
 
 import { db } from "../db";
@@ -15,18 +15,20 @@ import { MAX_REFRESH_TOKENS, MIN_REFRESH_TOKENS } from "./refresh-limits";
 
 export const ORCHESTRATOR_KEY = "orchestrator.refresh_tokens";
 export const TASK_KEY = "chat.task_refresh_tokens";
-export const STALE_COMPACT_KEY = "chat.stale_compact_tokens";
+// Named for what it first did: compact chats idle past their cache.
+export const COMPACT_KEY = "chat.stale_compact_tokens";
 export const DEFAULT_ORCHESTRATOR_TOKENS = 200_000;
-export const DEFAULT_STALE_COMPACT_TOKENS = 150_000;
+export const DEFAULT_COMPACT_TOKENS = 150_000;
 export { MIN_REFRESH_TOKENS, MAX_REFRESH_TOKENS } from "./refresh-limits";
 
 export interface RefreshSettings {
   // Context tokens at which a conversation starts over; 0 is off.
   orchestratorTokens: number;
   taskTokens: number;
-  // Context tokens above which a chat whose prompt cache has expired is
-  // compacted before the next message; 0 is off.
-  staleCompactTokens: number;
+  // Context tokens at which a chat's or task's agent compacts: Claude
+  // Code's own auto-compact window, and between turns a chat over it (or
+  // idle past its cache) is compacted before the next message. 0 is off.
+  compactTokens: number;
 }
 
 function read(key: string, fallback: number): number {
@@ -41,7 +43,7 @@ export function refreshSettings(): RefreshSettings {
   return {
     orchestratorTokens: read(ORCHESTRATOR_KEY, DEFAULT_ORCHESTRATOR_TOKENS),
     taskTokens: read(TASK_KEY, 0),
-    staleCompactTokens: read(STALE_COMPACT_KEY, DEFAULT_STALE_COMPACT_TOKENS),
+    compactTokens: read(COMPACT_KEY, DEFAULT_COMPACT_TOKENS),
   };
 }
 
@@ -74,16 +76,32 @@ export function setRefreshSettings(input: Partial<RefreshSettings>): void {
     ]);
   if (input.taskTokens !== undefined)
     checked.push([TASK_KEY, checkRefreshTokens(input.taskTokens)]);
-  if (input.staleCompactTokens !== undefined)
-    checked.push([
-      STALE_COMPACT_KEY,
-      checkRefreshTokens(input.staleCompactTokens),
-    ]);
+  if (input.compactTokens !== undefined)
+    checked.push([COMPACT_KEY, checkRefreshTokens(input.compactTokens)]);
   db.transaction(() => {
     for (const [key, n] of checked) put.run(key, String(n));
   })();
 }
 
+// Claude Code's own auto-compact window, in plain tokens (it reads "150k"
+// as 150 and clamps anything under 100k up to it).
+export const AUTO_COMPACT_ENV = "CLAUDE_CODE_AUTO_COMPACT_WINDOW";
+const AUTO_COMPACT_MIN = 100_000;
+
+// What an agent is launched with so it compacts itself at the threshold.
+// Not an orchestrator: it starts over from its brief at its own threshold
+// instead, since a summary would carry what it read from tasks and CI
+// without its untrusted fence. Nothing when it's off, so a window set in
+// the user's own environment still applies.
+export function autoCompactEnv(sessionId: string): Record<string, string> {
+  const row = db
+    .prepare(`SELECT role FROM sessions WHERE id = ?`)
+    .get(sessionId) as { role: string | null } | undefined;
+  const tokens = refreshSettings().compactTokens;
+  if (row?.role === "orchestrator" || tokens <= 0) return {};
+  return { [AUTO_COMPACT_ENV]: String(Math.max(AUTO_COMPACT_MIN, tokens)) };
+}
+
 const k = (tokens: number) => `${Math.round(tokens / 1000)}k`;
 
 // What the agent reads ahead of its first message in the new conversation.

package/lib/chat/runner.ts

@@ -5,6 +5,7 @@
  * events to whoever is watching. Restarting the server leaves turns running.
  */
 
+import { handoffAfterPlan } from "../models/plan-step";
 import { randomUUID } from "crypto";
 import os from "os";
 import { db, type Session } from "../db";
@@ -163,6 +164,10 @@ function onWorkerEvent(sessionId: string, live: Live, e: WorkerEvent): void {
     clearTimeout(live.retiring);
     live.retiring = undefined;
     retireIfStale(sessionId, live);
+    if (e.state === "idle")
+      void handoffAfterPlan(sessionId, (id, m) => sendQueuedNow(id, m)).catch(
+        (err) => console.error(`Plan handoff for ${sessionId} failed:`, err)
+      );
   } else if (e.type === "suggestion") {
     emit(sessionId, e);
     if (live.retiring && e.text) retire(sessionId, live);

package/lib/chat/stale.ts

@@ -1,10 +1,13 @@
 /**
- * Stale chats: a message sent to a conversation whose prompt cache has
- * expired re-reads the whole history at the cache-write price. When it is
- * also long, compacting first is far cheaper than carrying it (one summary
- * turn, then a small cache write instead of a huge one). The one check every
- * send path uses: the composer to offer it (components/Chat/StaleChip), the
- * chat worker to do it for automated sends (lib/chat/worker/host).
+ * Compacting between turns. A chat's agent compacts itself at the compact
+ * threshold (Claude Code's auto-compact window, set at launch by
+ * lib/agents/launch). Between turns AgentOS catches what it didn't: a chat
+ * over the threshold is compacted before the next message, and so is one
+ * whose prompt cache has expired, since that message would re-read the
+ * whole history at the cache-write price (one summary turn, then a small
+ * cache write instead of a huge one). The one check every send path uses:
+ * the composer to offer it (components/Chat/StaleChip), the chat worker to
+ * do it for automated sends (lib/chat/worker/host).
  *
  * Pure, so the browser and the worker read the same rule.
  */
@@ -38,21 +41,26 @@ export function cacheTtlMs(
 export interface Staleness {
   idleMs: number;
   tokens: number;
+  // Idle past the cache its last turn wrote, not only over the threshold.
+  stale: boolean;
 }
 
-// Stale: no turn running, the last one ended longer ago than the cache it
-// wrote lives, and the context is above the threshold (0 is off). Null when
-// it isn't, or when the chat never said which cache it uses.
-export function staleness(
+// Due a compaction before the next message: no turn running and the
+// context above the threshold (0 is off). Null when it isn't, or when the
+// chat never said which cache it uses (only Claude's chats do).
+export function compactionDue(
   context: ChatContext | null | undefined,
   opts: { state: ChatState; thresholdTokens: number; now?: number }
 ): Staleness | null {
   if (opts.state === "running" || opts.state === "waiting") return null;
   if (!context?.cacheTtlMs || opts.thresholdTokens <= 0) return null;
-  const idleMs = (opts.now ?? Date.now()) - context.at;
-  if (idleMs <= context.cacheTtlMs) return null;
   if (context.usedTokens <= opts.thresholdTokens) return null;
-  return { idleMs, tokens: context.usedTokens };
+  const idleMs = (opts.now ?? Date.now()) - context.at;
+  return {
+    idleMs,
+    tokens: context.usedTokens,
+    stale: idleMs > context.cacheTtlMs,
+  };
 }
 
 export function formatIdle(ms: number): string {
@@ -62,9 +70,10 @@ export function formatIdle(ms: number): string {
   return h < 48 ? `${h}h` : `${Math.floor(h / 24)}d`;
 }
 
-// "Idle 47m · 412k context"
+// "Idle 47m · 412k context", or "412k context" while its cache is warm.
 export function staleLabel(s: Staleness): string {
-  return `Idle ${formatIdle(s.idleMs)} · ${formatTokens(s.tokens)} context`;
+  const size = `${formatTokens(s.tokens)} context`;
+  return s.stale ? `Idle ${formatIdle(s.idleMs)} · ${size}` : size;
 }
 
 // Whether the composer's send compacts first: the chip was showing and the
@@ -75,7 +84,7 @@ export function composerCompacts(
   opts: { state: ChatState; thresholdTokens: number; asIs: boolean }
 ): boolean {
   if (opts.asIs || text.trimStart().startsWith("/")) return false;
-  return !!staleness(context, opts);
+  return !!compactionDue(context, opts);
 }
 
 // The chat's line for a compaction: "Compacted before sending · idle 47m ·

package/lib/chat/worker/extras.ts

@@ -1,6 +1,7 @@
 import type { Session } from "../../db";
 import type { ChatStartOptions } from "../driver";
 import { refreshSettings } from "../refresh";
+import { sessionProviderEnv } from "../../models/launch";
 
 export type RoleExtras = Pick<
   ChatStartOptions,
@@ -17,11 +18,22 @@ export type RoleExtras = Pick<
   // Start over on a new conversation once its context passes this many
   // tokens (lib/chat/refresh); absent or 0, never.
   refresh?: { atTokens: number; role: "orchestrator" | "task" };
+  // What the session's model provider needs in the agent's environment
+  // (lib/models), its key fetched just now. Held by this process only.
+  env?: Record<string, string>;
 };
 
 // What a session's role adds to its chat. An orchestrator's module loads
 // only for one; a task's chat gets its brief, as its terminal agent would.
 export async function roleExtras(session: Session): Promise<RoleExtras> {
+  const [extras, env] = await Promise.all([
+    ownExtras(session),
+    sessionProviderEnv(session),
+  ]);
+  return env ? { ...extras, env } : extras;
+}
+
+async function ownExtras(session: Session): Promise<RoleExtras> {
   if (session.role === "orchestrator")
     return (await import("../../orchestrator/worker")).orchestratorExtras(
       session