@saadnvd1/agent-os 0.3.715 → 0.3.723

package/lib/analyst/types.ts

@@ -0,0 +1,140 @@
+import { z } from "zod";
+
+// What the analyst says the coding agent should do next.
+export const VERDICTS = ["continue", "done", "blocked", "needs_you"] as const;
+export type Verdict = (typeof VERDICTS)[number];
+
+export const RECOMMENDATION_STATES = [
+  "open",
+  "sent",
+  "dismissed",
+  "superseded",
+  "invalid",
+] as const;
+export type RecommendationState = (typeof RECOMMENDATION_STATES)[number];
+
+export const issueSchema = z.object({
+  severity: z.enum(["high", "medium", "low"]),
+  title: z.string().trim().min(1).max(200),
+  detail: z.string().trim().max(2_000).default(""),
+  where: z.string().trim().max(300).optional(),
+});
+export type Issue = z.infer<typeof issueSchema>;
+
+export const MAX_ISSUES = 8;
+export const MAX_PROMPT = 4_000;
+
+// The fenced `agentos-review` block the analyst ends each review with.
+export const reviewSchema = z.object({
+  verdict: z.enum(VERDICTS),
+  summary: z.string().trim().min(1).max(1_000),
+  issues: z.array(issueSchema).max(MAX_ISSUES).default([]),
+  prompt: z.string().trim().max(MAX_PROMPT).nullable().optional(),
+});
+export type Review = z.infer<typeof reviewSchema>;
+
+// What a batch of the coding agent's turns did, worked out without a model.
+export interface DigestSignals {
+  turns: number;
+  toolCalls: number;
+  failedTools: number;
+  // Test, build, typecheck or lint commands, and whether each passed.
+  checks: { command: string; passed: boolean }[];
+  filesChanged: string[];
+  durationMs: number;
+  costUsd: number;
+  interrupted: boolean;
+  errors: number;
+  // Turns that ended without a single tool call.
+  noToolTurns: number;
+  // Fetched web content: a prompt built on it shouldn't be sent unseen.
+  readWeb: boolean;
+}
+
+export interface AnalystLink {
+  id: string;
+  coderSessionId: string;
+  analystSessionId: string;
+  paused: boolean;
+  // The coding agent's last turn_end the analyst has answered for.
+  reviewedThrough: string | null;
+  // A digest sent and not yet answered, the turn_end it runs to, and what
+  // its turns did.
+  pendingDigestId: string | null;
+  pendingThrough: string | null;
+  digestSignals: DigestSignals | null;
+  createdAt: number;
+  endedAt: number | null;
+}
+
+export interface Recommendation {
+  id: string;
+  linkId: string;
+  analystItemId: string;
+  coderThrough: string | null;
+  verdict: Verdict | null;
+  summary: string;
+  issues: Issue[];
+  signals: DigestSignals | null;
+  prompt: string | null;
+  state: RecommendationState;
+  // Why it's invalid.
+  error: string | null;
+  sentText: string | null;
+  sentItemId: string | null;
+  edited: boolean;
+  createdAt: number;
+  decidedAt: number | null;
+}
+
+export interface PaneSession {
+  id: string;
+  name: string;
+  agentType: string;
+  model: string | null;
+}
+
+// A link as the panes and the native app read it.
+export interface AnalystLinkView extends AnalystLink {
+  coder: PaneSession;
+  analyst: PaneSession;
+  // The coding agent's latest finished turn, to tell a card it has moved on.
+  coderLastTurn: string | null;
+  recommendations: Recommendation[];
+}
+
+export class AnalystError extends Error {
+  constructor(
+    message: string,
+    readonly status: 400 | 404 | 409 = 400
+  ) {
+    super(message);
+  }
+}
+
+export const createLinkSchema = z
+  .object({
+    coderSessionId: z.string().min(1).optional(),
+    newCoder: z
+      .object({
+        projectId: z.string().min(1),
+        agentType: z.string().min(1),
+        model: z.string().trim().min(1).optional(),
+        prompt: z.string().trim().max(20_000).optional(),
+        useWorktree: z.boolean().optional(),
+      })
+      .optional(),
+    // The analyst's model for this pair, "provider/model"; else its role's.
+    analystModel: z.string().trim().min(1).max(200).optional(),
+    reviewLast: z.boolean().optional(),
+  })
+  .refine((b) => !!b.coderSessionId !== !!b.newCoder, {
+    message: "Give coderSessionId or newCoder, not both",
+  });
+export type CreateLinkInput = z.infer<typeof createLinkSchema>;
+
+export const patchLinkSchema = z.object({ paused: z.boolean() });
+
+export const sendSchema = z.object({
+  text: z.string().trim().min(1).max(20_000).optional(),
+});

package/lib/bus/condense.ts

@@ -102,7 +102,11 @@ function lineOf(i: ChatItem): string | null {
     case "compacted":
       return "[conversation compacted]";
     case "turn_end":
-      return i.interrupted ? "[turn stopped]" : null;
+      return i.interrupted
+        ? "[turn stopped]"
+        : i.ended
+          ? `[turn ended early: ${i.ended.reason}]`
+          : null;
     default:
       return null;
   }

package/lib/bus/index.ts

@@ -67,6 +67,9 @@ export interface Peer {
   waitedBy: string[];
   // The user's group it sits in, when it is in one.
   group?: string;
+  // The agent role it was started in (lib/models/agent-roles), and its model.
+  agentRole?: string;
+  model?: string;
 }
 
 // A chat has no pane: its worker is the state, and it can always take a
@@ -118,6 +121,8 @@ export async function listPeers(callerId?: string): Promise<Peer[]> {
         orchestratorOf: orchestratorOf(s),
         waitingOn: badges.get(s.id)?.on.map((w) => w.name) ?? [],
         waitedBy: badges.get(s.id)?.by.map((w) => w.name) ?? [],
+        ...(s.agent_role && { agentRole: s.agent_role }),
+        ...(s.agent_role && s.model && { model: s.model }),
         ...(s.session_group_id &&
           groups.has(s.session_group_id) && {
             group: groups.get(s.session_group_id),

package/lib/bus/read-scope.ts

@@ -4,6 +4,7 @@ import { getProject } from "../projects";
 import { getWorkspace } from "../workspaces";
 import { previousNames } from "../session-names";
 import { resolveRef, type Candidate } from "./resolve";
+import { resolveRoleAlias, roleAliasOf } from "./role-alias";
 
 export type ReadableSession = Session & { project_name: string | null };
 
@@ -79,6 +80,17 @@ export function resolveReadable(callerId: string, ref: string): Readable {
     a.updated_at < b.updated_at ? 1 : -1
   );
   const mine = all.filter((s) => inScope(s, scope));
+  const alias = roleAliasOf(ref);
+  if (alias) {
+    const found = resolveRoleAlias(
+      alias,
+      mine.filter(isLive),
+      all.find((s) => s.id === callerId)
+    );
+    return found.ok
+      ? { ok: true, session: found.session }
+      : { ok: false, external: found.none, error: found.error };
+  }
   let none = "";
   for (const group of [mine.filter(isLive), mine.filter((s) => !isLive(s))]) {
     const r = resolveRef(ref, candidates(group));

package/lib/bus/role-alias.ts

@@ -0,0 +1,70 @@
+/**
+ * "@reviewer", "@developer", "@analyst", "@supervisor": the live session in
+ * that agent role. The caller's crew first, then its project; a supervisor
+ * nobody started is the workspace's orchestrator. More than one match
+ * refuses and lists them, like any other name.
+ */
+
+import type { Session } from "../db";
+
+type RoleSession = Pick<
+  Session,
+  | "id"
+  | "name"
+  | "role"
+  | "agent_role"
+  | "crew_id"
+  | "project_id"
+  | "workspace_id"
+>;
+import {
+  AGENT_ROLES,
+  isAgentRole,
+  type AgentRole,
+} from "../models/agent-roles";
+
+export type RoleAlias<T extends RoleSession = Session> =
+  { ok: true; session: T } | { ok: false; none: boolean; error: string };
+
+export const roleAliasOf = (ref: string): AgentRole | null => {
+  const m = /^@([a-z]+)$/i.exec(ref.trim());
+  const role = m?.[1].toLowerCase();
+  return isAgentRole(role) ? role : null;
+};
+
+const label = (s: RoleSession) => `${s.name} (id ${s.id.slice(0, 8)})`;
+
+export function resolveRoleAlias<T extends RoleSession>(
+  role: AgentRole,
+  sessions: T[],
+  caller: RoleSession | undefined
+): RoleAlias<T> {
+  const others = sessions.filter((s) => s.id !== caller?.id);
+  const inRole = others.filter((s) => s.agent_role === role);
+  const scopes = [
+    caller?.crew_id ? inRole.filter((s) => s.crew_id === caller.crew_id) : [],
+    caller?.project_id && caller.project_id !== "uncategorized"
+      ? inRole.filter((s) => s.project_id === caller.project_id)
+      : [],
+  ];
+  for (const found of scopes) {
+    if (found.length === 1) return { ok: true, session: found[0] };
+    if (found.length > 1)
+      return {
+        ok: false,
+        none: false,
+        error: `"@${role}" matches ${found.length} sessions: ${found.map(label).join(", ")}. Use the name or the id`,
+      };
+  }
+  if (role === "supervisor" && caller?.workspace_id) {
+    const orchestrator = others.find(
+      (s) => s.role === "orchestrator" && s.workspace_id === caller.workspace_id
+    );
+    if (orchestrator) return { ok: true, session: orchestrator };
+  }
+  return {
+    ok: false,
+    none: true,
+    error: `No ${role} is running in your crew or project. Roles: ${AGENT_ROLES.map((r) => `@${r}`).join(", ")}. Run: aos peers`,
+  };
+}

package/lib/bus/targets.ts

@@ -9,6 +9,7 @@ import { previousNames } from "../session-names";
 import { sessionWorkspace } from "../schedules/store";
 import { heldTarget } from "./held-reply";
 import { resolveRef, type Candidate } from "./resolve";
+import { resolveRoleAlias, roleAliasOf } from "./role-alias";
 
 export function liveSessions(): Session[] {
   return db
@@ -86,6 +87,8 @@ export function tryResolveTarget(
   | { ok: true; session: Session; note?: string }
   | { ok: false; none: boolean; error: string } {
   const sessions = liveSessions();
+  const alias = roleAliasOf(ref);
+  if (alias) return resolveRoleAlias(alias, sessions, sessionById(callerId));
   const own = ownOrchestrator(ref, sessions, callerId);
   if (own) return { ok: true, session: own };
   const r = resolveRef(ref, candidates(sessions));

package/lib/chat/drivers/opencode-mapper.ts

@@ -2,6 +2,7 @@ import { randomUUID } from "crypto";
 import type { DriverEvent, UsageTotals } from "../events";
 import { openCodeTool } from "./opencode-rules";
 import { TurnItems } from "./turn-items";
+import { logTurnEnd, turnOutcome } from "./turn-outcome";
 
 type P = Record<string, unknown>;
 const str = (v: unknown) => (typeof v === "string" ? v : "");
@@ -26,6 +27,15 @@ export class OpenCodeMapper {
   private current = new Set<string>();
   private past = new Set<string>();
   private error: string | null = null;
+  // The turn's last assistant message: its finish reason, text and calls.
+  private last = {
+    id: "",
+    finish: "",
+    provider: "",
+    model: "",
+    text: new Map<string, string>(),
+    calls: new Set<string>(),
+  };
   private aborted = false;
   // Idle from before the prompt is stale until the session goes busy.
   private admitted = false;
@@ -98,6 +108,18 @@ export class OpenCodeMapper {
     this.current.add(id);
     this.roles.set(id, str(info.role));
     if (info.role !== "assistant") return;
+    if (this.last.id !== id)
+      this.last = {
+        id,
+        finish: "",
+        provider: "",
+        model: "",
+        text: new Map(),
+        calls: new Set(),
+      };
+    this.last.finish = str(info.finish) || this.last.finish;
+    this.last.provider = str(info.providerID) || this.last.provider;
+    this.last.model = str(info.modelID) || this.last.model;
     if (info.error) this.failed(info.error as P);
     if (!(info.time as P)?.completed || this.counted.has(id)) return;
     this.counted.add(id);
@@ -125,6 +147,8 @@ export class OpenCodeMapper {
       const seen = this.parts.get(id) ?? { kind, shown: 0 };
       this.parts.set(id, seen);
       const text = str(part.text);
+      if (kind === "assistant" && this.last.id === str(part.messageID))
+        this.last.text.set(id, text);
       if (text.length > seen.shown) {
         this.items.delta(id, kind, text.slice(seen.shown));
         seen.shown = text.length;
@@ -132,7 +156,10 @@ export class OpenCodeMapper {
       if ((part.time as P)?.end) this.items.finishText(id, kind, text);
       return;
     }
-    if (part.type === "tool") this.tool(id, part);
+    if (part.type === "tool") {
+      if (this.last.id === str(part.messageID)) this.last.calls.add(id);
+      this.tool(id, part);
+    }
   }
 
   private delta(p: P): void {
@@ -140,6 +167,11 @@ export class OpenCodeMapper {
     const seen = this.parts.get(str(p.partID));
     if (!seen || p.field !== "text") return;
     const text = str(p.delta);
+    if (seen.kind === "assistant" && this.last.text.has(str(p.partID)))
+      this.last.text.set(
+        str(p.partID),
+        this.last.text.get(str(p.partID)) + text
+      );
     seen.shown += text.length;
     this.items.delta(str(p.partID), seen.kind, text);
   }
@@ -168,11 +200,33 @@ export class OpenCodeMapper {
   private idle(): void {
     if (!this.admitted || !this.items.inTurn) return;
     this.emit({ type: "usage", totals: { ...this.totals } });
+    const text = [...this.last.text.values()].join("\n");
+    const ended =
+      this.aborted || !this.last.id
+        ? undefined
+        : turnOutcome({
+            finishReason: this.last.finish,
+            text,
+            toolCalls: this.last.calls.size,
+            error: this.error ?? undefined,
+          });
+    if (ended)
+      logTurnEnd({
+        driver: "opencode",
+        provider: this.last.provider,
+        model: this.last.model,
+        finishReason: this.last.finish,
+        reason: ended.reason,
+        text,
+      });
     this.items.endTurn({
       interrupted: this.aborted,
       error: this.error ?? undefined,
+      finishReason: this.last.finish || undefined,
+      ended,
     });
     this.error = null;
+    this.last.id = "";
     this.aborted = false;
     this.admitted = false;
     for (const id of this.current) this.past.add(id);

package/lib/chat/drivers/pi-approvals.ts

@@ -74,11 +74,14 @@ function ensureDir(): void {
   fs.chmodSync(DIR, 0o700);
 }
 
-export function writeExtension(): string {
+export function writeExtension(
+  name = "agentos-approvals.mjs",
+  source = EXTENSION
+): string {
   ensureDir();
-  const file = path.join(DIR, "agentos-approvals.mjs");
-  if (!fs.existsSync(file) || fs.readFileSync(file, "utf8") !== EXTENSION)
-    fs.writeFileSync(file, EXTENSION);
+  const file = path.join(DIR, name);
+  if (!fs.existsSync(file) || fs.readFileSync(file, "utf8") !== source)
+    fs.writeFileSync(file, source);
   return file;
 }
 

package/lib/chat/drivers/pi-mapper.ts

@@ -2,6 +2,7 @@ import { randomUUID } from "crypto";
 import type { DriverEvent, UsageTotals } from "../events";
 import { toolDiff, toolTitle } from "../tools";
 import { TurnItems, type ToolStart } from "./turn-items";
+import { logTurnEnd, turnOutcome } from "./turn-outcome";
 
 type P = Record<string, unknown>;
 const str = (v: unknown) => (typeof v === "string" ? v : "");
@@ -50,6 +51,9 @@ export class PiMapper {
   private message = 0;
   private stopReason = "";
   private error = "";
+  // The last answer's text, its tool calls and who gave it, for the notice
+  // when a turn ends without doing anything.
+  private last = { text: "", calls: 0, provider: "", model: "", api: "" };
   totals: UsageTotals = {
     costUsd: 0,
     inputTokens: 0,
@@ -71,6 +75,7 @@ export class PiMapper {
     switch (e.type) {
       case "agent_start":
         this.stopReason = this.error = "";
+        this.last = { text: "", calls: 0, provider: "", model: "", api: "" };
         return this.items.startTurn();
       case "message_start":
         if ((e.message as P)?.role === "assistant") this.message++;
@@ -136,6 +141,22 @@ export class PiMapper {
     this.stopReason = str(m.stopReason);
     if (this.stopReason === "error")
       this.error = str(m.errorMessage) || "Pi failed";
+    const content = Array.isArray(m.content) ? (m.content as P[]) : [];
+    this.last = {
+      text: content
+        .filter((c) => c.type === "text")
+        .map((c) => str(c.text))
+        .join("\n"),
+      calls: content.filter((c) => c.type === "toolCall").length,
+      provider: str(m.provider),
+      model: str(m.model),
+      api: str(m.api),
+    };
+    // Calls the text-tools extension made out of the reply's markup: the
+    // text that streamed still has it.
+    const fixed = m.aosRecovered as P | undefined;
+    if (fixed)
+      this.items.retext(`${this.message}:${fixed.index}`, str(fixed.text));
     const u = (m.usage ?? {}) as P;
     const n = (k: string) => Number(u[k]) || 0;
     this.totals = {
@@ -151,9 +172,26 @@ export class PiMapper {
   endTurn(): void {
     if (!this.items.inTurn) return;
     this.emit({ type: "usage", totals: { ...this.totals } });
+    const ended = this.aborted
+      ? undefined
+      : turnOutcome({
+          finishReason: this.stopReason,
+          text: this.last.text,
+          toolCalls: this.last.calls,
+          error: this.error || undefined,
+        });
+    if (ended)
+      logTurnEnd({
+        driver: "pi",
+        ...this.last,
+        finishReason: this.stopReason,
+        reason: ended.reason,
+      });
     this.items.endTurn({
       interrupted: this.aborted,
       error: this.error || undefined,
+      finishReason: this.stopReason || undefined,
+      ended,
     });
   }
 }

package/lib/chat/drivers/pi-text-tools.ts

@@ -0,0 +1,104 @@
+// Local models served without tool-call parsing write their calls as text:
+// <tool_call>{"name":…,"arguments":…}</tool_call> (Hermes, Qwen) or
+// <tool_call><function=bash><parameter=command>…</parameter></function>
+// </tool_call> (Qwen3-Coder). Pi only runs structured calls, so this Pi
+// extension turns those trailing blocks in a finished reply into real tool
+// calls. They are ordinary tool calls from then on: Pi's tool_call event
+// fires for them, so the approvals extension (pi-approvals) asks, or lets
+// them through, exactly as for a structured call. Exported for its test.
+export const TEXT_TOOLS_EXTENSION = String.raw`const OPEN = "<tool_call>";
+const CLOSE = "</tool_call>";
+let count = 0;
+const FENCE = String.fromCharCode(96).repeat(3);
+const inFence = (text, at) => text.slice(0, at).split(FENCE).length % 2 === 0;
+const trimOne = (v) => v.replace(/^\r?\n/, "").replace(/\r?\n$/, "");
+
+function parseBody(body, schemas) {
+  const b = body.trim();
+  if (b.startsWith("{")) {
+    let o;
+    try {
+      o = JSON.parse(b);
+    } catch {
+      return null;
+    }
+    let args = o.arguments ?? o.parameters ?? {};
+    if (typeof args === "string") {
+      try {
+        args = JSON.parse(args);
+      } catch {
+        return null;
+      }
+    }
+    if (typeof o.name !== "string" || !args || typeof args !== "object" || Array.isArray(args)) return null;
+    return { name: o.name, arguments: args };
+  }
+  const f = /^<function=([^>\s]+)>([\s\S]*?)(?:<\/function>)?$/.exec(b);
+  if (!f) return null;
+  const props = schemas.get(f[1])?.properties ?? {};
+  const args = {};
+  for (const m of f[2].matchAll(/<parameter=([^>\s]+)>([\s\S]*?)<\/parameter>/g)) {
+    const raw = trimOne(m[2]);
+    let value = raw;
+    if (props[m[1]]?.type && props[m[1]].type !== "string") {
+      try {
+        value = JSON.parse(raw);
+      } catch {}
+    }
+    args[m[1]] = value;
+  }
+  return { name: f[1], arguments: args };
+}
+
+// The calls in a tail that is nothing but call blocks, or null.
+function parseTail(tail, schemas) {
+  const calls = [];
+  let pos = 0;
+  for (;;) {
+    while (pos < tail.length && /\s/.test(tail[pos])) pos++;
+    if (pos >= tail.length) break;
+    if (!tail.startsWith(OPEN, pos)) return null;
+    const start = pos + OPEN.length;
+    const end = tail.indexOf(CLOSE, start);
+    const call = parseBody(end < 0 ? tail.slice(start) : tail.slice(start, end), schemas);
+    if (!call || !schemas.has(call.name)) return null;
+    calls.push(call);
+    if (end < 0) break;
+    pos = end + CLOSE.length;
+  }
+  return calls.length ? calls : null;
+}
+
+export default function (pi) {
+  pi.on("message_end", async (event) => {
+    const m = event.message;
+    if (m?.role !== "assistant" || m.stopReason !== "stop" || !Array.isArray(m.content)) return;
+    if (m.content.some((c) => c.type === "toolCall")) return;
+    let at = -1;
+    for (let i = m.content.length - 1; i >= 0; i--) {
+      if (m.content[i].type === "text") {
+        at = i;
+        break;
+      }
+    }
+    if (at < 0 || !m.content[at].text.includes(OPEN)) return;
+    const text = m.content[at].text;
+    const schemas = new Map();
+    const active = new Set(pi.getActiveTools());
+    for (const t of pi.getAllTools()) if (active.has(t.name)) schemas.set(t.name, t.parameters ?? {});
+    for (let from = text.indexOf(OPEN); from >= 0; from = text.indexOf(OPEN, from + 1)) {
+      if (inFence(text, from)) continue;
+      const calls = parseTail(text.slice(from), schemas);
+      if (!calls) continue;
+      const rest = text.slice(0, from).trimEnd();
+      const content = m.content.slice();
+      content[at] = { ...content[at], text: rest };
+      if (!rest) content.splice(at, 1);
+      for (const c of calls) {
+        content.push({ type: "toolCall", id: "aostext_" + ++count + "_" + Math.random().toString(36).slice(2, 8), name: c.name, arguments: c.arguments });
+      }
+      return { message: { ...m, content, stopReason: "toolUse", aosRecovered: { index: at, text: rest } } };
+    }
+  });
+}
+`;

package/lib/chat/drivers/pi.ts

@@ -4,6 +4,7 @@ import type { ChatImage, DriverEvent } from "../events";
 import { InputQueue } from "../queue";
 import { AGENT_DEFAULT_MODEL } from "../../providers/registry";
 import { PiAccess, PiDialogs, writeExtension } from "./pi-approvals";
+import { TEXT_TOOLS_EXTENSION } from "./pi-text-tools";
 import { PiMapper } from "./pi-mapper";
 import { PiRpc } from "./pi-rpc";
 
@@ -11,8 +12,8 @@ type P = Record<string, unknown>;
 
 const SETTLE_TRIES = 5;
 
-export function piArgs(o: ChatStartOptions, extension: string): string[] {
-  const args = ["-e", extension];
+export function piArgs(o: ChatStartOptions, ...extensions: string[]): string[] {
+  const args = extensions.flatMap((e) => ["-e", e]);
   // A path, so a conversation started elsewhere never makes Pi ask about it.
   if (o.resumeId) args.push("--session", o.resumeId);
   if (o.model && o.model !== AGENT_DEFAULT_MODEL) args.push("--model", o.model);
@@ -79,7 +80,11 @@ export const piDriver: ChatDriver = {
     // Sent now: goes once the stopped run has ended.
     const held: { text: string; images?: ChatImage[] }[] = [];
     const rpc: PiRpc = new PiRpc(
-      piArgs(options, writeExtension()),
+      piArgs(
+        options,
+        writeExtension(),
+        writeExtension("agentos-text-tools.mjs", TEXT_TOOLS_EXTENSION)
+      ),
       {
         cwd: options.cwd,
         env: {