@saadnvd1/agent-os 0.3.470 → 0.3.472

package/lib/chat/worker/host.ts

@@ -29,7 +29,11 @@ import {
 } from "../store";
 import { claimNext, enqueue, listQueue, moveToFront } from "../queued";
 import { isHeld } from "../hold";
-import { recordTurn, startingTotals } from "../../usage/turns";
+import {
+  recordCompaction,
+  recordTurn,
+  startingTotals,
+} from "../../usage/turns";
 import {
   VISUALS_BRIEF,
   VISUALS_SERVER,
@@ -37,7 +41,7 @@ import {
 } from "../../artifacts/tools";
 import type { RoleExtras } from "./extras";
 import { refreshSettings, refreshedNote } from "../refresh";
-import { staleLabel, staleness, type Staleness } from "../stale";
+import { compactionDue, staleLabel, type Staleness } from "../stale";
 import type { WorkerCommand, WorkerEvent } from "./protocol";
 
 // How soon after a stopped turn ends a turn the agent starts on its own
@@ -72,6 +76,8 @@ export class ChatHost {
   // resumed conversation's saved totals.
   private usage: UsageTotals | null;
   private turnsRecorded = 0;
+  // When the running turn started, for its wall time.
+  private turnStartedAt: number | null = null;
   // A permission mode change still on its way to the agent: a message sent
   // right after it (carrying out a plan) must not overtake it.
   private modeChange: Promise<void> = Promise.resolve();
@@ -127,15 +133,17 @@ export class ChatHost {
   private contextBase: number | null = null;
   // How full the conversation was at its last turn's end (lib/chat/stale).
   private context: ChatContext | null = null;
-  // A compaction run ahead of a message to a stale chat: the message waits
-  // at the front of the queue until it ends (compactFirst).
+  // A compaction run ahead of a message (compactFirst): the message waits
+  // at the front of the queue until it ends.
   private compacting: {
-    idleMs: number;
+    // Set when it ran because the chat was stale.
+    idleMs?: number;
     before: number;
     done?: boolean;
   } | null = null;
   // Its line, until the agent's next measure gives the size after.
   private compactedLine: Extract<ChatItem, { kind: "compacted" }> | null = null;
+  private compactedBy = "threshold";
   // An orchestrator gone stale starts over rather than compacting.
   private staleRefresh: Staleness | null = null;
   readonly done: Promise<void>;
@@ -155,7 +163,7 @@ export class ChatHost {
       throw new Error(`${session.agent_type} can't enforce this role's tools`);
     this.atRest = driver.atRest !== false;
     const cwd = session.working_directory.replace(/^~/, os.homedir());
-    const env = agentEnv(session.id);
+    const env = { ...agentEnv(session.id), ...extras.env };
     // Every chat can show visuals, asked for like any tool under its access
     // setting (they read files and reach the web). Not an orchestrator: it
     // reads other sessions' text, and a browser would be a way out for it.
@@ -253,8 +261,10 @@ export class ChatHost {
           // a failed one printed still shows.
           if (this.compacting?.done && e.item.kind === "command_output")
             continue;
-          if (this.compacting && e.item.kind === "compacted")
-            e.item = this.compactedItem(e.item);
+          if (e.item.kind === "compacted") {
+            if (this.compacting) e.item = this.compactedItem(e.item);
+            else this.logCompacted(e.item, e.item.trigger ?? "manual");
+          }
           if ("streaming" in e.item && e.item.streaming)
             this.streaming.set(e.item.id, e.item);
           else this.streaming.delete(e.item.id);
@@ -282,7 +292,15 @@ export class ChatHost {
           this.setSuggestion(e.text);
           this.retireIfDone();
         } else if (e.type === "usage") {
-          this.usage = recordTurn(this.session, this.usage, e.totals);
+          const at = Date.now();
+          this.usage = recordTurn(
+            this.session,
+            this.usage,
+            e.totals,
+            at,
+            this.turnStartedAt === null ? null : at - this.turnStartedAt
+          );
+          this.turnStartedAt = null;
           this.turnsRecorded++;
         } else if (e.type === "usage_start") {
           // Too late once a turn was measured without it.
@@ -298,6 +316,7 @@ export class ChatHost {
           this.refreshIfFull(e.context.usedTokens);
         } else if (e.type === "turn_start") {
           this.turnsStarted++;
+          this.turnStartedAt ??= Date.now();
           if (this.behind) this.behind--;
           clearTimeout(this.restTimer);
           this.restTimer = undefined;
@@ -663,15 +682,19 @@ export class ChatHost {
     this.close();
   }
 
-  // A stale chat (lib/chat/stale) is compacted before the message goes in,
-  // only between turns: the message waits at the front of the queue, and
-  // the compaction's end sends it. "yes" is the reader's choice, made on
-  // what the composer showed; "auto" checks for itself.
+  // A chat over the compact threshold or stale (lib/chat/stale) is
+  // compacted before the message goes in, only between turns: the message
+  // waits at the front of the queue, and the compaction's end sends it.
+  // "yes" is the reader's choice, made on what the composer showed; "auto"
+  // checks for itself.
   private compactFirst(cmd: Extract<WorkerCommand, { type: "send" }>): boolean {
     if (!cmd.compact || this.busy() || this.closed || this.handingOver())
       return false;
     const stale = this.staleNow(cmd.compact);
-    if (!stale) return false;
+    // An orchestrator starts over at its own threshold (lib/chat/refresh);
+    // only one gone stale does it early.
+    if (!stale || (this.session.role === "orchestrator" && !stale.stale))
+      return false;
     try {
       enqueue(this.session.id, cmd);
     } catch {
@@ -692,13 +715,16 @@ export class ChatHost {
       this.retireIfDone();
       return true;
     }
-    this.compacting = { idleMs: stale.idleMs, before: stale.tokens };
+    this.compacting = {
+      idleMs: stale.stale ? stale.idleMs : undefined,
+      before: stale.tokens,
+    };
     this.currentTurn = null;
     this.stopping = null;
     this.conversation.send("/compact");
     this.setState("running");
     console.error(
-      `${new Date().toISOString()} compacting ${this.session.id} before a message: idle ${Math.round(stale.idleMs / 60_000)}m, ${stale.tokens} tokens`
+      `${new Date().toISOString()} compacting ${this.session.id} before a message: ${stale.stale ? `idle ${Math.round(stale.idleMs / 60_000)}m, ` : ""}${stale.tokens} tokens`
     );
     return true;
   }
@@ -707,11 +733,17 @@ export class ChatHost {
     const context = this.context;
     // Only an agent that says which cache it uses has one to lose.
     if (!context?.cacheTtlMs) return null;
-    if (compact === "yes")
-      return { idleMs: Date.now() - context.at, tokens: context.usedTokens };
-    return staleness(context, {
+    if (compact === "yes") {
+      const idleMs = Date.now() - context.at;
+      return {
+        idleMs,
+        tokens: context.usedTokens,
+        stale: idleMs > context.cacheTtlMs,
+      };
+    }
+    return compactionDue(context, {
       state: this.state,
-      thresholdTokens: refreshSettings().staleCompactTokens,
+      thresholdTokens: refreshSettings().compactTokens,
     });
   }
 
@@ -724,8 +756,9 @@ export class ChatHost {
       idleMs: this.compacting?.idleMs,
       before: item.before ?? this.compacting?.before,
     };
+    this.compactedBy = line.idleMs !== undefined ? "stale" : "threshold";
     this.compactedLine = line.after === undefined ? line : null;
-    if (line.after !== undefined) this.logCompacted(line);
+    if (line.after !== undefined) this.logCompacted(line, this.compactedBy);
     return line;
   }
 
@@ -736,13 +769,26 @@ export class ChatHost {
     this.compactedLine = null;
     const settled = { ...line, after: usedTokens };
     this.record(settled);
-    this.logCompacted(settled);
+    this.logCompacted(settled, this.compactedBy);
   }
 
-  private logCompacted(line: { before?: number; after?: number }): void {
+  // Logged, and kept for the usage history (lib/usage/turns).
+  private logCompacted(
+    line: { before?: number; after?: number },
+    trigger: string
+  ): void {
     console.error(
-      `${new Date().toISOString()} compacted ${this.session.id}: ${line.before ?? "?"} -> ${line.after ?? "?"} tokens`
+      `${new Date().toISOString()} compacted ${this.session.id} (${trigger}): ${line.before ?? "?"} -> ${line.after ?? "?"} tokens`
     );
+    try {
+      recordCompaction(this.session, {
+        trigger,
+        before: line.before,
+        after: line.after,
+      });
+    } catch (e) {
+      console.error(`recording ${this.session.id}'s compaction:`, e);
+    }
   }
 
   // Past its threshold, once: it retires at the next turn boundary, as for

package/lib/chat/worker/main.ts

@@ -29,13 +29,16 @@ async function main(sessionId: string) {
   const { db } = await import("../../db");
   const { ChatHost } = await import("./host");
 
-  const session = db
+  const row = db
     .prepare(`SELECT * FROM sessions WHERE id = ?`)
     .get(sessionId) as Session | undefined;
-  if (!session) {
+  if (!row) {
     console.error(`No session ${sessionId}`);
     process.exit(1);
   }
+  const session = await (
+    await import("../../models/launch")
+  ).routeOrchestrator(row);
 
   const clients = new Set<net.Socket>();
   const emit = (e: WorkerEvent) => {

package/lib/db/migrations.ts

@@ -1358,6 +1358,76 @@ const migrations: Migration[] = [
       `);
     },
   },
+  {
+    id: 60,
+    name: "check_runs_and_compactions",
+    up: (db) => {
+      // What each run of the independent reviewer and the scope check cost,
+      // from its claude -p result: it leaves no transcript, so this is the
+      // only record. And each compaction a chat's agent made, so tokens per
+      // task can be compared before and after the threshold moved.
+      db.exec(`
+        CREATE TABLE IF NOT EXISTS check_runs (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          workspace_id TEXT NOT NULL,
+          session_id TEXT NOT NULL,
+          label TEXT NOT NULL,
+          pr_number INTEGER,
+          sha TEXT NOT NULL,
+          kind TEXT NOT NULL,
+          model TEXT,
+          input_tokens INTEGER NOT NULL,
+          cache_write_tokens INTEGER NOT NULL,
+          cache_read_tokens INTEGER NOT NULL,
+          output_tokens INTEGER NOT NULL,
+          cost_usd REAL NOT NULL,
+          duration_ms INTEGER,
+          at INTEGER NOT NULL
+        );
+        CREATE INDEX IF NOT EXISTS idx_check_runs_at ON check_runs(at);
+        CREATE INDEX IF NOT EXISTS idx_check_runs_sha ON check_runs(session_id, sha, kind);
+        CREATE TABLE IF NOT EXISTS chat_compactions (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          session_id TEXT NOT NULL,
+          session_name TEXT NOT NULL,
+          workspace_id TEXT,
+          at INTEGER NOT NULL,
+          trigger TEXT NOT NULL,
+          before_tokens INTEGER,
+          after_tokens INTEGER
+        );
+        CREATE INDEX IF NOT EXISTS idx_chat_compactions_at ON chat_compactions(at);
+      `);
+    },
+  },
+  {
+    id: 61,
+    name: "model_routing",
+    // One transaction, so a crash part-way leaves nothing to skip as
+    // "duplicate column" on the next start.
+    up: (db) =>
+      db.transaction(() => {
+        // What a session runs on beyond the model name: its provider (NULL is
+        // Anthropic), a task's own models by role (JSON), and a task's plan
+        // step (planning, then implementing). Each turn keeps the model,
+        // provider and role it ran as, how long it took, and the plan's 5-hour
+        // window when it ended, so spend compares by model. A check run keeps the
+        // provider its model came from.
+        for (const col of [
+          `ALTER TABLE sessions ADD COLUMN model_provider TEXT`,
+          `ALTER TABLE sessions ADD COLUMN model_overrides TEXT`,
+          `ALTER TABLE sessions ADD COLUMN plan_phase TEXT`,
+          `ALTER TABLE task_queue ADD COLUMN model_overrides TEXT`,
+          `ALTER TABLE chat_turns ADD COLUMN model TEXT`,
+          `ALTER TABLE chat_turns ADD COLUMN provider TEXT`,
+          `ALTER TABLE chat_turns ADD COLUMN role TEXT`,
+          `ALTER TABLE chat_turns ADD COLUMN duration_ms INTEGER`,
+          `ALTER TABLE chat_turns ADD COLUMN window_pct REAL`,
+          `ALTER TABLE check_runs ADD COLUMN provider TEXT`,
+        ])
+          db.exec(col);
+      })(),
+  },
 ];
 
 // `upTo`: stop after this id (tests that start from an older database).

package/lib/db/types.ts

@@ -14,6 +14,12 @@ export interface Session {
   parent_session_id: string | null;
   claude_session_id: string | null;
   model: string;
+  // The model's provider (lib/models), NULL for Anthropic.
+  model_provider?: string | null;
+  // A task's own models: "provider/model", or JSON of role to one.
+  model_overrides?: string | null;
+  // A task's plan step: planning on the planning model, then implementing.
+  plan_phase?: "planning" | "implementing" | null;
   system_prompt: string | null;
   group_path: string; // Deprecated - use project_id
   project_id: string | null;

package/lib/drafts.ts

@@ -23,6 +23,9 @@ export interface Draft {
   openPr: boolean;
   // A task that runs in a terminal rather than a chat (the default).
   terminal?: boolean;
+  // A task's own model, "provider/model"; unset, its roles' models
+  // (lib/models).
+  taskModel?: string | null;
   createdAt: number;
 }
 

package/lib/models/config.ts

@@ -0,0 +1,218 @@
+/**
+ * Model routing settings, kept in the settings table: the model each role
+ * runs on, the providers (the presets, edited or added to), the price table,
+ * and whether tasks plan first. A workspace may set its own role models.
+ * Nothing here is ever a key: a provider names where its key lives.
+ */
+
+import { z } from "zod";
+import { db } from "../db";
+import { ENV_NAME, RESERVED_ENV } from "../project-config/schema";
+import { KEY_ENV_NAME } from "./secrets";
+import {
+  DEFAULT_PRICES,
+  PROVIDER_PRESETS,
+  type ModelPrice,
+  type ModelProvider,
+} from "./providers";
+import {
+  ANTHROPIC,
+  DEFAULT_ROLE_MODELS,
+  MODEL_ROLES,
+  REF_PATTERN,
+  type ModelRole,
+} from "./roles";
+
+// A name passed to `tv` or `security` as its own argument: no option, no
+// line break, nothing a shell would read.
+const refName = z
+  .string()
+  .trim()
+  .min(1)
+  .max(120)
+  .regex(/^[\w .@:+-]+$/, "letters, digits, spaces and . @ : + - _ only")
+  .refine((s) => !s.startsWith("-"), "can't start with -");
+
+const secretRef = z.discriminatedUnion("kind", [
+  z.strictObject({
+    kind: z.literal("tokenvault"),
+    project: refName,
+    desc: refName.optional(),
+  }),
+  z.strictObject({
+    kind: z.literal("keychain"),
+    service: refName,
+    account: refName.optional(),
+  }),
+  z.strictObject({
+    kind: z.literal("env"),
+    name: z
+      .string()
+      .regex(
+        KEY_ENV_NAME,
+        "must be a *_API_KEY variable, not ANTHROPIC_, CLAUDE_ or AGENTOS_"
+      ),
+  }),
+]);
+
+const modelId = z
+  .string()
+  .trim()
+  .min(1)
+  .max(120)
+  .regex(/^[\w.:@/-]+$/, "not a model id");
+
+const baseUrl = z
+  .string()
+  .trim()
+  .url()
+  .refine(
+    (u) =>
+      u.startsWith("https://") ||
+      /^http:\/\/(localhost|127\.0\.0\.1|\[::1\])(:\d+)?(\/|$)/.test(u),
+    "must be https (or http on localhost)"
+  );
+
+const providerSchema = z.strictObject({
+  id: z
+    .string()
+    .regex(/^[a-z0-9][a-z0-9_-]{0,39}$/, "lowercase letters, digits, - and _"),
+  label: z.string().trim().min(1).max(60),
+  api: z.enum(["anthropic", "openai"]),
+  baseUrl: baseUrl.optional(),
+  auth: secretRef.optional(),
+  authHeader: z.enum(["bearer", "x-api-key"]).optional(),
+  models: z.array(modelId).max(40),
+  tiers: z
+    .strictObject({
+      opus: modelId.optional(),
+      sonnet: modelId.optional(),
+      haiku: modelId.optional(),
+    })
+    .optional(),
+  // A key can't hide here: no name an agent CLI reads for credentials.
+  env: z
+    .record(
+      z
+        .string()
+        .regex(ENV_NAME)
+        .refine((n) => !RESERVED_ENV.test(n), "is reserved"),
+      z.string().max(200)
+    )
+    .optional(),
+  enabled: z.boolean(),
+});
+
+const price = z.strictObject({
+  input: z.number().min(0),
+  cacheWrite: z.number().min(0),
+  cacheRead: z.number().min(0),
+  output: z.number().min(0),
+});
+
+const roleRef = z.string().trim().regex(REF_PATTERN, "must be provider/model");
+const roleMap = z.partialRecord(z.enum(MODEL_ROLES), roleRef);
+
+export const modelSettingsSchema = z.strictObject({
+  roles: roleMap.optional(),
+  providers: z.array(providerSchema).optional(),
+  prices: z.record(z.string().regex(REF_PATTERN), price).optional(),
+  planStep: z.boolean().optional(),
+});
+
+export const workspaceModelsSchema = z.strictObject({
+  roles: roleMap.optional(),
+});
+
+export type ModelSettings = z.infer<typeof modelSettingsSchema>;
+export type WorkspaceModels = z.infer<typeof workspaceModelsSchema>;
+export type RoleMap = Partial<Record<ModelRole, string>>;
+export const roleMapSchema = roleMap;
+
+const GLOBAL_KEY = "models";
+const workspaceKey = (id: string) => `models.workspace.${id}`;
+
+function read<T>(key: string, schema: z.ZodType<T>): T | null {
+  const row = db
+    .prepare(`SELECT value FROM settings WHERE key = ?`)
+    .get(key) as { value: string } | undefined;
+  if (!row) return null;
+  try {
+    const got = schema.safeParse(JSON.parse(row.value));
+    return got.success ? got.data : null;
+  } catch {
+    return null;
+  }
+}
+
+function problems(error: z.ZodError): string {
+  return error.issues
+    .map((i) => `${i.path.join(".") || "(top level)"}: ${i.message}`)
+    .join("; ");
+}
+
+function write<T>(key: string, schema: z.ZodType<T>, value: unknown): T {
+  const got = schema.safeParse(value ?? {});
+  if (!got.success)
+    throw new Error(`Invalid model settings: ${problems(got.error)}`);
+  db.prepare(
+    `INSERT INTO settings (key, value) VALUES (?, ?)
+     ON CONFLICT(key) DO UPDATE SET value = excluded.value`
+  ).run(key, JSON.stringify(got.data));
+  return got.data;
+}
+
+export const savedModelSettings = (): ModelSettings =>
+  read(GLOBAL_KEY, modelSettingsSchema) ?? {};
+
+export function setModelSettings(value: unknown): ModelSettings {
+  const parsed = modelSettingsSchema.safeParse(value ?? {});
+  if (!parsed.success)
+    throw new Error(`Invalid model settings: ${problems(parsed.error)}`);
+  const ids = parsed.data.providers?.map((p) => p.id) ?? [];
+  if (new Set(ids).size !== ids.length)
+    throw new Error("Invalid model settings: two providers share an id");
+  const anthropic = parsed.data.providers?.find((p) => p.id === ANTHROPIC);
+  if (anthropic && (anthropic.baseUrl || anthropic.auth || !anthropic.enabled))
+    throw new Error(
+      "Invalid model settings: anthropic is the Claude login; add another provider for an endpoint"
+    );
+  return write(GLOBAL_KEY, modelSettingsSchema, parsed.data);
+}
+
+export const workspaceModels = (workspaceId: string): WorkspaceModels =>
+  read(workspaceKey(workspaceId), workspaceModelsSchema) ?? {};
+
+export function setWorkspaceModels(
+  workspaceId: string,
+  value: unknown
+): WorkspaceModels {
+  const saved = write(workspaceKey(workspaceId), workspaceModelsSchema, value);
+  if (!Object.keys(saved.roles ?? {}).length)
+    db.prepare(`DELETE FROM settings WHERE key = ?`).run(
+      workspaceKey(workspaceId)
+    );
+  return saved;
+}
+
+// The settings in force: the presets with any saved edits laid over them
+// (by id), saved providers that aren't presets, and every role filled.
+export interface EffectiveModels {
+  roles: Record<ModelRole, string>;
+  providers: ModelProvider[];
+  prices: Record<string, ModelPrice>;
+  planStep: boolean;
+}
+
+export function effectiveModels(
+  saved: ModelSettings = savedModelSettings()
+): EffectiveModels {
+  const byId = new Map(PROVIDER_PRESETS.map((p) => [p.id, p]));
+  for (const p of saved.providers ?? []) byId.set(p.id, p as ModelProvider);
+  return {
+    roles: { ...DEFAULT_ROLE_MODELS, ...saved.roles },
+    providers: [...byId.values()],
+    prices: { ...DEFAULT_PRICES, ...saved.prices },
+    planStep: saved.planStep ?? true,
+  };
+}

package/lib/models/launch.ts

@@ -0,0 +1,93 @@
+/**
+ * What an agent is launched with to run on its routed model: the model
+ * name for its CLI, and the provider's endpoint and key in its environment.
+ */
+
+import type { Session } from "../db";
+import {
+  defaultRoute,
+  providerEnv,
+  providerFor,
+  providerShellEnv,
+  resolveRole,
+  setSessionModel,
+  type ModelOverride,
+} from "./resolve";
+import { ANTHROPIC, type ModelRole } from "./roles";
+import { redact, type SecretCommand } from "./secrets";
+
+const why = (error: unknown) =>
+  redact(error instanceof Error ? error.message : String(error));
+
+// A chat session's provider environment, or null on Anthropic.
+export async function sessionProviderEnv(
+  session: Pick<Session, "model" | "model_provider">,
+  exec?: SecretCommand
+): Promise<Record<string, string> | null> {
+  if (!session.model_provider) return null;
+  return providerEnv(providerFor(session.model_provider), session.model, exec);
+}
+
+// A terminal session's: plain settings for its tmux environment, and shell
+// text that sets the key from its reference inside the pane.
+export function sessionShellEnv(
+  session: Pick<Session, "model" | "model_provider">
+): { env: Record<string, string>; exportKey: string } {
+  if (!session.model_provider) return { env: {}, exportKey: "" };
+  return providerShellEnv(providerFor(session.model_provider), session.model);
+}
+
+export interface RoutedRun {
+  model: string;
+  provider: string;
+  env: Record<string, string>;
+}
+
+// A one-shot run (a review, a scope check, a title) on its role's model,
+// or on the role's default when its provider is off or its key can't be
+// read: a title or a review still happens.
+export async function routedRun(
+  role: ModelRole,
+  opts: { workspaceId?: string | null; override?: ModelOverride | null } = {},
+  exec?: SecretCommand
+): Promise<RoutedRun> {
+  try {
+    const routed = resolveRole(role, opts);
+    return {
+      model: routed.model,
+      provider: routed.provider.id,
+      env: await providerEnv(routed.provider, routed.model, exec),
+    };
+  } catch (error) {
+    const routed = defaultRoute(role);
+    console.warn(`[models] ${role}: ${why(error)}; on ${routed.ref} instead`);
+    return { model: routed.model, provider: ANTHROPIC, env: {} };
+  }
+}
+
+// An orchestrator runs on its role's model, as its workspace and Settings
+// say now: each worker start picks up a change. When that provider is off
+// or its key can't be read, it starts on the default rather than not at all.
+export async function routeOrchestrator(
+  session: Session,
+  exec?: SecretCommand
+): Promise<Session> {
+  if (session.role !== "orchestrator") return session;
+  let routed;
+  try {
+    routed = resolveRole("orchestrator", { workspaceId: session.workspace_id });
+    await providerEnv(routed.provider, routed.model, exec);
+  } catch (error) {
+    routed = defaultRoute("orchestrator");
+    console.warn(
+      `[models] orchestrator: ${why(error)}; on ${routed.ref} instead`
+    );
+  }
+  setSessionModel(session.id, routed);
+  return {
+    ...session,
+    model: routed.model,
+    model_provider:
+      routed.provider.id === ANTHROPIC ? null : routed.provider.id,
+  };
+}