@saadnvd1/agent-os 0.3.700 → 0.3.723

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: {

package/lib/chat/drivers/turn-items.ts

@@ -1,5 +1,11 @@
 import { randomUUID } from "crypto";
-import type { ChatItem, DriverEvent, FileDiff, ToolStatus } from "../events";
+import type {
+  ChatItem,
+  DriverEvent,
+  FileDiff,
+  ToolStatus,
+  TurnEndReason,
+} from "../events";
 import { clipOutput } from "../tools";
 
 type Tool = Extract<ChatItem, { kind: "tool" }>;
@@ -41,6 +47,8 @@ export function readableError(text: string): string {
 export class TurnItems {
   private texts = new Map<string, Text>();
   private tools = new Map<string, Tool>();
+  // Texts that finished in this turn, so one can be corrected afterwards.
+  private done = new Map<string, Text>();
   private startedAt = 0;
   inTurn = false;
 
@@ -81,15 +89,23 @@ export class TurnItems {
     this.texts.delete(key);
     const text = full ?? current?.text ?? "";
     if (!text.trim()) return;
-    this.emit({
-      type: "item",
-      item: {
-        id: current?.id ?? randomUUID(),
-        kind,
-        text,
-        createdAt: current?.createdAt ?? Date.now(),
-      },
-    });
+    const item: Text = {
+      id: current?.id ?? randomUUID(),
+      kind,
+      text,
+      createdAt: current?.createdAt ?? Date.now(),
+    };
+    this.done.set(key, item);
+    this.emit({ type: "item", item });
+  }
+
+  // A finished text replaced by `text` (blank hides it): the agent's final
+  // message differs from what streamed.
+  retext(key: string, text: string): void {
+    const item = this.done.get(key);
+    if (!item) return;
+    this.done.set(key, { ...item, text });
+    this.emit({ type: "item", item: { ...item, text } });
   }
 
   tool(id: string, start: ToolStart): void {
@@ -158,7 +174,13 @@ export class TurnItems {
 
   // Closes the turn: text still streaming settles, tools still running
   // were cut off.
-  endTurn(end: { interrupted?: boolean; error?: string; costUsd?: number }) {
+  endTurn(end: {
+    interrupted?: boolean;
+    error?: string;
+    costUsd?: number;
+    finishReason?: string;
+    ended?: { reason: TurnEndReason; notice: string };
+  }) {
     if (!this.inTurn) return;
     this.inTurn = false;
     for (const [key, text] of [...this.texts]) this.finishText(key, text.kind);
@@ -172,9 +194,12 @@ export class TurnItems {
         durationMs: Date.now() - this.startedAt,
         costUsd: end.costUsd,
         interrupted: end.interrupted,
+        finishReason: end.finishReason,
+        ended: end.interrupted ? undefined : end.ended,
         createdAt: Date.now(),
       },
     });
+    this.done.clear();
     this.emit({ type: "state", state: "idle" });
   }
 }

package/lib/chat/drivers/turn-outcome.ts

@@ -0,0 +1,108 @@
+import { redact } from "../../orchestrator/untrusted";
+import type { TurnEndReason } from "../events";
+
+export interface TurnEnded {
+  reason: TurnEndReason;
+  notice: string;
+}
+
+// Said where a reply stopped short, so the fix is in the notice itself.
+const SERVER_HINT =
+  "If you run the model yourself, start its server with tool calling on (llama.cpp: --jinja; vLLM: --enable-auto-tool-choice --tool-call-parser; LM Studio: a model with tool use).";
+
+const TAIL = 300;
+const LOG_TAIL = 240;
+
+const CLOSERS =
+  /\b(let me know|i'?ll (wait|leave|stop|hold)|i will (wait|leave|stop)|if you'?d like|feel free|hope (this|that)|want me to)\b/i;
+const ANNOUNCE =
+  /\b(let me|let'?s|i'?ll|i will|i'?m going to|i am going to|going to|i need to|i should|now i|first,? i|next,? i|then i)\s+(\w+)/i;
+
+// Whether the end of a reply says the model is about to do something.
+export function announcesAction(text: string): boolean {
+  const tail = text.trim().slice(-TAIL);
+  if (!tail) return false;
+  if (tail.endsWith("?")) return false;
+  const last =
+    tail
+      .split(/(?<=[.!:])\s+|\n+/)
+      .filter((s) => s.trim())
+      .slice(-2)
+      .join(" ") || tail;
+  if (CLOSERS.test(last)) return false;
+  return ANNOUNCE.test(last) || /:\s*$/.test(tail);
+}
+
+// Tool-call markup left in a reply: a call that was written, not made.
+export function hasToolMarkup(text: string): boolean {
+  return (
+    /<tool_call>|<function=|<\|tool_call\|>/.test(text) ||
+    /\{\s*"name"\s*:\s*"[^"]+"\s*,\s*"(arguments|parameters)"\s*:\s*\{[\s\S]*\}\s*$/.test(
+      text
+    )
+  );
+}
+
+export function turnOutcome(r: {
+  finishReason?: string;
+  text: string;
+  toolCalls: number;
+  error?: string;
+}): TurnEnded | undefined {
+  if (r.finishReason === "length")
+    return {
+      reason: "length",
+      notice:
+        "The model hit its output limit (finish reason: length) before it finished. Raise maxTokens for this model.",
+    };
+  if (r.error)
+    return {
+      reason: "error",
+      notice: "The model's server returned an error, shown above.",
+    };
+  if (r.toolCalls > 0) return undefined;
+  if (hasToolMarkup(r.text))
+    return {
+      reason: "parse_failure",
+      notice: `The model wrote a tool call as text that AgentOS couldn't run. ${SERVER_HINT}`,
+    };
+  if (!r.text.trim())
+    return {
+      reason: "empty",
+      notice: `The model ended its turn with an empty reply. ${SERVER_HINT}`,
+    };
+  if (announcesAction(r.text))
+    return {
+      reason: "no_tool_call",
+      notice: `The model ended its turn without calling a tool. ${SERVER_HINT}`,
+    };
+  return undefined;
+}
+
+// One line to diagnose a turn that ended early: where, why and how the
+// reply ended. Never the prompt, and the reply's tail is scrubbed and cut.
+export function logTurnEnd(o: {
+  driver: string;
+  provider?: string;
+  model?: string;
+  api?: string;
+  finishReason?: string;
+  reason: TurnEndReason;
+  text: string;
+}): void {
+  const tail = redact(
+    o.text.slice(-LOG_TAIL).replace(/[\u0000-\u001f\u007f]/g, " ")
+  );
+  console.warn(
+    "[chat] turn ended early",
+    JSON.stringify({
+      driver: o.driver,
+      provider: o.provider,
+      model: o.model,
+      api: o.api,
+      finishReason: o.finishReason,
+      reason: o.reason,
+      tail,
+    })
+  );
+}

package/lib/chat/events.ts

@@ -150,6 +150,9 @@ interface Base {
   createdAt: number;
 }
 
+export type TurnEndReason =
+  "no_tool_call" | "length" | "parse_failure" | "empty" | "error";
+
 export type ChatItem =
   | (Base & {
       kind: "user";
@@ -205,6 +208,11 @@ export type ChatItem =
       durationMs?: number;
       costUsd?: number;
       interrupted?: boolean;
+      // The model's last finish reason, as its agent reported it.
+      finishReason?: string;
+      // Set when the turn stopped short of finished work: the reader sees
+      // why instead of a plain "Done".
+      ended?: { reason: TurnEndReason; notice: string };
     })
   | (Base & { kind: "command_output"; text: string })
   // The conversation's MCP servers, as /mcp reports them.

package/lib/chat/registry.ts

@@ -78,6 +78,17 @@ interface Registry {
   listeners: Map<string, Set<Listener>>;
   // What each agent offers per folder: commands, skills, models.
   caps: Map<string, Capabilities>;
+  // Told of every finished turn (lib/analyst), set by the server.
+  turnEndHook?: TurnEndHook;
+}
+
+export type TurnEndHook = (
+  sessionId: string,
+  item: Extract<ChatItem, { kind: "turn_end" }>
+) => void;
+
+export function setTurnEndHook(fn: TurnEndHook): void {
+  registry.turnEndHook = fn;
 }
 
 // Shared across every module instance in the process (custom server and the
@@ -102,6 +113,8 @@ export function emit(sessionId: string, m: ChatServerMessage): void {
     (m.type === "item" && m.item.kind === "turn_end")
   )
     touchActive(sessionId);
+  if (m.type === "item" && m.item.kind === "turn_end")
+    registry.turnEndHook?.(sessionId, m.item);
   registry.listeners.get(sessionId)?.forEach((fn) => fn(m));
   // Idle, running, waiting and back, and a finished turn (unread): the
   // sidebar hears at once.

package/lib/chat/store.ts

@@ -153,6 +153,25 @@ export function lastItems(
   return rows.reverse().map((r) => JSON.parse(r.data) as ChatItem);
 }
 
+// The items after `afterItemId`, oldest first, at most the latest `limit`;
+// with no item given (or one since deleted), just the latest `limit`.
+export function itemsAfter(
+  sessionId: string,
+  afterItemId: string | null,
+  limit = 400
+): ChatItem[] {
+  flushItems();
+  const rows = db
+    .prepare(
+      `SELECT data FROM chat_items WHERE session_id = ?
+         AND seq > COALESCE((SELECT seq FROM chat_items
+           WHERE session_id = ? AND item_id = ?), -1)
+       ORDER BY seq DESC LIMIT ?`
+    )
+    .all(sessionId, sessionId, afterItemId, limit) as { data: string }[];
+  return rows.reverse().map((r) => JSON.parse(r.data) as ChatItem);
+}
+
 // What the agent has said since the last message to it, as text: where a
 // chat task's BLOCKED: line stays until someone answers it.
 export function saidSinceLastMessage(sessionId: string, n = 20): string {

package/lib/chat/turns.ts

@@ -107,6 +107,7 @@ export function eventTurnAt(
     (i) =>
       i.kind === "plan" ||
       i.kind === "error" ||
+      (i.kind === "turn_end" && !!i.ended) ||
       isQuestionTool(i) ||
       isAskTool(i) ||
       (i.kind === "approval" && i.status === "pending")

package/lib/chat/worker/extras.ts

@@ -38,11 +38,13 @@ async function ownExtras(session: Session): Promise<RoleExtras> {
     return (await import("../../orchestrator/worker")).orchestratorExtras(
       session
     );
-  if (!session.task_brief) return {};
+  // A role's brief (and an analyst's) is the session's own system prompt.
+  const own = session.system_prompt?.trim();
+  if (!session.task_brief) return own ? { systemAppend: own } : {};
   const atTokens =
     session.task_status === "running" ? refreshSettings().taskTokens : 0;
   return {
-    systemAppend: session.task_brief,
+    systemAppend: [session.task_brief, own].filter(Boolean).join("\n\n"),
     ...(atTokens > 0 && { refresh: { atTokens, role: "task" as const } }),
   };
 }