@saadnvd1/agent-os 0.3.738 → 0.3.742

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

@@ -0,0 +1,78 @@
+import { writeEditGuard } from "./edit-guard";
+
+// OpenCode's edit and write tools, with the edit guard beside them as a
+// plugin. A throw in tool.execute.before becomes the tool's error, so a
+// doomed edit never runs and the model reads why; tool.execute.after adds
+// what a finished edit broke to the result. OpenCode runs every export of a
+// plugin file as a plugin, so this has exactly one. Exported for its test.
+export const OPENCODE_GUARD_PLUGIN = String.raw`import { createHash } from "node:crypto";
+import {
+  FailureLog,
+  absolute,
+  failureMessage,
+  guardEdit,
+  readText,
+  syntaxReport,
+} from "./agentos-edit-guard-lib.mjs";
+
+const EDITS = new Set(["edit", "multiedit"]);
+const hash = (t) => createHash("sha1").update(String(t ?? "")).digest("hex");
+
+function oldTexts(args) {
+  if (Array.isArray(args?.edits)) return args.edits.map((e) => e?.oldString).filter((t) => typeof t === "string");
+  return typeof args?.oldString === "string" ? [args.oldString] : [];
+}
+
+export const AgentOSGuard = async (ctx) => {
+  const cwd = ctx?.directory || process.cwd();
+  const log = new FailureLog();
+  const before = new Map();
+  // Edits that passed the check but never reached tool.execute.after: the
+  // tool itself failed them.
+  const inflight = new Map();
+  return {
+    "tool.execute.before": async (input, output) => {
+      const tool = input?.tool;
+      const args = output?.args || {};
+      if (!EDITS.has(tool) && tool !== "write") return;
+      if (typeof args.filePath !== "string") return;
+      const file = absolute(args.filePath, cwd);
+      if (EDITS.has(tool)) {
+        const why = guardEdit(log, args.filePath, oldTexts(args), cwd);
+        if (why) throw new Error(why);
+        const old = oldTexts(args)[0];
+        const text = readText(file);
+        if (tool === "edit" && old !== undefined && text != null) {
+          const key = log.key(file, old);
+          for (const [id, e] of inflight) {
+            if (id === input.callID || e.key !== key || e.hash !== hash(text)) continue;
+            inflight.delete(id);
+            log.record(file, old);
+            throw new Error(failureMessage(args.filePath, old, text, log.record(file, old)));
+          }
+          inflight.set(input.callID, { key, hash: hash(text) });
+        }
+      }
+      before.set(input.callID, readText(file));
+    },
+    "tool.execute.after": async (input, output) => {
+      try {
+        const tool = input?.tool;
+        const args = input?.args || {};
+        if (!EDITS.has(tool) && tool !== "write") return;
+        if (typeof args.filePath !== "string") return;
+        const file = absolute(args.filePath, cwd);
+        const prior = before.get(input.callID);
+        before.delete(input.callID);
+        inflight.delete(input.callID);
+        log.clear(file);
+        const report = syntaxReport(args.filePath, prior, readText(file), cwd);
+        if (report && output) output.output = String(output.output ?? "") + "\n\n" + report;
+      } catch {}
+    },
+  };
+};
+`;
+
+export const writeOpenCodeGuard = (folder?: string) =>
+  writeEditGuard("agentos-opencode-guard.mjs", OPENCODE_GUARD_PLUGIN, folder);

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

@@ -85,7 +85,12 @@ export class OpenCodeServer {
   }
 
   // One JSON call. Errors carry OpenCode's message, never the URL.
-  async call<T>(method: string, path: string, body?: unknown): Promise<T> {
+  async call<T>(
+    method: string,
+    path: string,
+    body?: unknown,
+    timeoutMs = CALL_MS
+  ): Promise<T> {
     await this.ready;
     const res = await fetch(this.endpoint(path), {
       method,
@@ -94,7 +99,7 @@ export class OpenCodeServer {
         ...(body !== undefined && { "content-type": "application/json" }),
       },
       body: body === undefined ? undefined : JSON.stringify(body),
-      signal: AbortSignal.timeout(CALL_MS),
+      signal: AbortSignal.timeout(timeoutMs),
     });
     const text = await res.text();
     const data = text ? (JSON.parse(text) as T & P) : (undefined as T);

package/lib/chat/drivers/opencode.ts

@@ -7,14 +7,52 @@ import { OpenCodeMapper } from "./opencode-mapper";
 import { openCodeRules } from "./opencode-rules";
 import { OpenCodeServer } from "./opencode-server";
 import { OpenCodeApprovals } from "./opencode-approvals";
+import { RESULTS_BRIEF, SUMMARY_NUDGE } from "./turn-outcome";
+import { openCodeConfigContent } from "./opencode-config";
+import { writeOpenCodeGuard } from "./opencode-plugin";
+import { typescriptPath } from "./edit-guard";
+import { continuePrompt, type RetryDecision } from "./transient-retry";
 
 type P = Record<string, unknown>;
 const str = (v: unknown) => (typeof v === "string" ? v : "");
 
+// Compacting can take a while; the retry waits for it.
+const COMPACT_MS = 300_000;
+
+// The server's environment for one conversation: the edit guard plugin, a
+// longer header wait for its providers, and the TypeScript to check syntax
+// with. Where any of it can't be set up the conversation runs without it.
+function conversationEnv(
+  cwd: string,
+  model: string,
+  env: NodeJS.ProcessEnv
+): NodeJS.ProcessEnv {
+  try {
+    const ts = typescriptPath();
+    const withTs = { ...env, ...(ts && { AGENTOS_TYPESCRIPT: ts }) };
+    return {
+      ...withTs,
+      OPENCODE_CONFIG_CONTENT: openCodeConfigContent({
+        cwd,
+        env: withTs,
+        model,
+        pluginFile: writeOpenCodeGuard(),
+      }),
+    };
+  } catch {
+    return env;
+  }
+}
+
 // How long a prompt may go without the session turning busy before the
 // turn is checked on.
 const ADMIT_MS = 15_000;
 
+// AgentOS's own brief, then the results line every session gets.
+export function openCodeSystem(append?: string): string {
+  return [append, RESULTS_BRIEF].filter(Boolean).join("\n\n");
+}
+
 export function openCodeModel(model: string) {
   const slash = model.indexOf("/");
   if (!model || model === AGENT_DEFAULT_MODEL || slash < 1) return undefined;
@@ -79,13 +117,23 @@ export const openCodeDriver: ChatDriver = {
   start(options): ChatConversation {
     const out = new InputQueue<DriverEvent>();
     const emit = (e: DriverEvent) => out.push(e);
-    const server = new OpenCodeServer(options.cwd, {
-      ...sessionBaseEnv(),
-      ...options.env,
-    });
+    const server = new OpenCodeServer(
+      options.cwd,
+      conversationEnv(options.cwd, options.model ?? "", {
+        ...sessionBaseEnv(),
+        ...options.env,
+      })
+    );
     let sessionId: string | null = null;
     const children = new Set<string>();
-    const mapper = new OpenCodeMapper(() => sessionId, emit);
+    let retryTimer: ReturnType<typeof setTimeout> | null = null;
+    // Bumped when a retry is cancelled, so one already under way stops.
+    let retryGen = 0;
+    const mapper = new OpenCodeMapper(
+      () => sessionId,
+      emit,
+      (d, error) => scheduleRetry(d, error)
+    );
     const approvals = new OpenCodeApprovals(emit, server, (e) => fail(e));
     let access = options.access;
     let plan = !!options.plan;
@@ -106,6 +154,7 @@ export const openCodeDriver: ChatDriver = {
       if (ours(p.sessionID)) approvals.handle(e.type, p);
       const wasInTurn = mapper.items.inTurn;
       mapper.map(e);
+      if (mapper.takeNudge()) return void prompt(SUMMARY_NUDGE);
       if (wasInTurn && !mapper.items.inTurn && held.length) {
         const next = held.shift()!;
         void prompt(next.text, next.images);
@@ -153,15 +202,59 @@ export const openCodeDriver: ChatDriver = {
       });
     }
 
-    async function prompt(text: string, images?: ChatImage[]) {
-      mapper.prompted();
+    // The failed request goes again after its wait, on a compacted context
+    // for the last try. Stopping or closing cancels it.
+    function scheduleRetry(
+      d: Extract<RetryDecision, { retry: true }>,
+      error: string
+    ) {
+      cancelRetry();
+      const gen = retryGen;
+      retryTimer = setTimeout(() => {
+        retryTimer = null;
+        void resume(d, error, gen);
+      }, d.delayMs);
+    }
+
+    // Whether a retry was waiting or under way.
+    function cancelRetry(): boolean {
+      const pending = retryTimer !== null || mapper.retrying;
+      if (retryTimer) clearTimeout(retryTimer);
+      retryTimer = null;
+      retryGen++;
+      return pending;
+    }
+
+    async function resume(
+      d: Extract<RetryDecision, { retry: true }>,
+      error: string,
+      gen: number
+    ) {
+      const live = () => !closed && mapper.items.inTurn && gen === retryGen;
+      if (!live()) return;
+      if (d.compactFirst && model) {
+        mapper.holdIdle(true);
+        await server
+          .call("POST", `/session/${sessionId}/summarize`, model, COMPACT_MS)
+          .catch(() => {});
+        mapper.holdIdle(false);
+        if (!live()) return;
+      }
+      await prompt(continuePrompt(error), undefined, true);
+    }
+
+    async function prompt(text: string, images?: ChatImage[], retried = false) {
+      if (!retried) cancelRetry();
+      mapper.prompted(retried);
       try {
         await ready;
         await server.call("POST", `/session/${sessionId}/prompt_async`, {
           model,
           agent: plan ? "plan" : "build",
-          system: options.systemAppend || undefined,
-          parts: openCodeParts(text, images),
+          system: openCodeSystem(options.systemAppend),
+          parts: retried
+            ? [{ type: "text", text, synthetic: true }]
+            : openCodeParts(text, images),
         });
       } catch (error) {
         fail(error as Error);
@@ -180,6 +273,11 @@ export const openCodeDriver: ChatDriver = {
     }
 
     async function abort() {
+      // A turn waiting to retry has nothing running to abort: it ends here.
+      if (cancelRetry()) {
+        mapper.stopRetrying();
+        for (const next of held.splice(0)) void prompt(next.text, next.images);
+      }
       await ready;
       for (const id of [sessionId, ...children])
         await server.call("POST", `/session/${id}/abort`).catch(() => {});
@@ -188,6 +286,7 @@ export const openCodeDriver: ChatDriver = {
     function close() {
       if (closed) return;
       closed = true;
+      cancelRetry();
       approvals.pending.expireAll();
       stream.abort();
       server.close();

package/lib/chat/drivers/pi-edit-guard.ts

@@ -0,0 +1,87 @@
+import { writeEditGuard } from "./edit-guard";
+
+// Pi's edit and write tools, with the edit guard beside them: a doomed edit
+// is blocked before it runs (and before the approvals extension asks about
+// it), and what a finished edit or write broke comes back in its result.
+// Exported for its test.
+export const PI_EDIT_GUARD_EXTENSION = String.raw`import {
+  FailureLog,
+  absolute,
+  closestMatch,
+  guardEdit,
+  readText,
+  syntaxReport,
+} from "./agentos-edit-guard-lib.mjs";
+
+const log = new FailureLog();
+const before = new Map();
+
+function oldTexts(input) {
+  let edits = input?.edits;
+  if (typeof edits === "string") {
+    try {
+      edits = JSON.parse(edits);
+    } catch {
+      edits = null;
+    }
+  }
+  if (Array.isArray(edits)) return edits.map((e) => e?.oldText).filter((t) => typeof t === "string");
+  return typeof input?.oldText === "string" ? [input.oldText] : [];
+}
+
+const textOf = (content) =>
+  (Array.isArray(content) ? content : []).map((c) => (typeof c?.text === "string" ? c.text : "")).join("\n");
+
+export default function (pi) {
+  pi.on("tool_call", async (event) => {
+    try {
+      const tool = event.toolName;
+      const input = event.input || {};
+      if (typeof input.path !== "string") return;
+      const file = absolute(input.path, process.cwd());
+      if (tool === "read") return void log.clear(file);
+      if (tool !== "edit" && tool !== "write") return;
+      if (tool === "edit") {
+        const why = guardEdit(log, input.path, oldTexts(input), process.cwd());
+        if (why) return { block: true, reason: why };
+      }
+      before.set(event.toolCallId, readText(file));
+    } catch {}
+  });
+
+  pi.on("tool_result", async (event) => {
+    try {
+      const tool = event.toolName;
+      const input = event.input || {};
+      if ((tool !== "edit" && tool !== "write") || typeof input.path !== "string") return;
+      const file = absolute(input.path, process.cwd());
+      const prior = before.get(event.toolCallId);
+      before.delete(event.toolCallId);
+      const content = Array.isArray(event.content) ? event.content : [];
+      if (event.isError) {
+        const said = textOf(content);
+        if (tool !== "edit" || !/could not find|not find/i.test(said)) return;
+        const olds = oldTexts(input);
+        const named = /edits\[(\d+)\]/.exec(said);
+        const old = olds[named ? Number(named[1]) : 0];
+        const text = readText(file);
+        if (old === undefined || text == null) return;
+        const repeat = log.record(file, old);
+        const near = closestMatch(text, old);
+        const more = [
+          repeat >= 2 ? "This is the same edit that has already failed " + (repeat - 1) + " time(s). Do not send it again unchanged." : "",
+          near ? "The file's current text near the closest match (lines " + near.from + "-" + near.to + "):\n" + near.excerpt : "",
+          "Read " + input.path + " again and build the edit from what is there now.",
+        ].filter(Boolean);
+        return { content: [...content, { type: "text", text: more.join("\n") }] };
+      }
+      log.clear(file);
+      const report = syntaxReport(input.path, prior, readText(file), process.cwd());
+      if (report) return { content: [...content, { type: "text", text: report }] };
+    } catch {}
+  });
+}
+`;
+
+export const writePiEditGuard = (folder?: string) =>
+  writeEditGuard("agentos-pi-edit-guard.mjs", PI_EDIT_GUARD_EXTENSION, folder);

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

@@ -3,6 +3,12 @@ import type { DriverEvent, UsageTotals } from "../events";
 import { toolDiff, toolTitle } from "../tools";
 import { TurnItems, type ToolStart } from "./turn-items";
 import { logTurnEnd, needsSummary, turnOutcome } from "./turn-outcome";
+import {
+  COMPACT_AT_PERCENT,
+  retryNotice,
+  TurnRetry,
+  type RetryDecision,
+} from "./transient-retry";
 
 type P = Record<string, unknown>;
 const str = (v: unknown) => (typeof v === "string" ? v : "");
@@ -63,10 +69,31 @@ export class PiMapper {
     cacheWriteTokens: 0,
   };
 
-  constructor(private emit: (e: DriverEvent) => void) {
+  // Retrying a turn the model's server dropped, when Pi didn't.
+  readonly retry = new TurnRetry();
+  private agentRetried = false;
+  // A failed turn is waiting for its retry to go out.
+  retrying = false;
+  // The context's fill, as last reported.
+  contextPercent = 0;
+
+  constructor(
+    private emit: (e: DriverEvent) => void,
+    // Called when a failed turn is to be tried again.
+    private onRetry: (
+      d: Extract<RetryDecision, { retry: true }>,
+      error: string
+    ) => void = () => {}
+  ) {
     this.items = new TurnItems(emit);
   }
 
+  // The reader sent a message: a new turn's retries start over.
+  userPrompt(): void {
+    this.retry.reset();
+    this.agentRetried = false;
+  }
+
   // The last answer in the run stopped because the reader stopped it.
   get aborted(): boolean {
     return this.stopReason === "aborted";
@@ -93,12 +120,31 @@ export class PiMapper {
           str(e.toolCallId),
           piTool(str(e.toolName), e.args)
         );
+      case "tool_execution_update":
+        return this.items.progress(
+          str(e.toolCallId),
+          resultText(e.partialResult)
+        );
       case "tool_execution_end":
         return this.items.toolDone(
           str(e.toolCallId),
           e.isError ? "error" : "done",
           resultText(e.result)
         );
+      case "auto_retry_start":
+        this.emit({
+          type: "model_retry",
+          attempt: Number(e.attempt) || 1,
+          message: str(e.errorMessage) || undefined,
+        });
+        this.agentRetried = true;
+        return this.items.note(
+          `Pi is trying again (${str(e.attempt)} of ${str(e.maxAttempts)}): ${str(e.errorMessage).slice(0, 160)}`
+        );
+      case "auto_retry_end":
+        if (e.success === false && e.finalError && !this.error)
+          this.error = str(e.finalError);
+        return;
       case "compaction_start":
         return this.emit({ type: "compacting", active: true });
       case "compaction_end":
@@ -163,6 +209,8 @@ export class PiMapper {
       this.items.retext(`${this.message}:${fixed.index}`, str(fixed.text));
     const u = (m.usage ?? {}) as P;
     const n = (k: string) => Number(u[k]) || 0;
+    const prompt = n("input") + n("cacheRead") + n("cacheWrite");
+    if (prompt > 0) this.emit({ type: "prompt_tokens", tokens: prompt });
     this.totals = {
       costUsd: this.totals.costUsd + (Number((u.cost as P)?.total) || 0),
       inputTokens: this.totals.inputTokens + n("input"),
@@ -184,9 +232,31 @@ export class PiMapper {
     });
   }
 
+  private retryTurn(): boolean {
+    const d = this.retry.next({
+      error: this.error,
+      harnessRetried: this.agentRetried,
+      contextHeavy: this.contextPercent >= COMPACT_AT_PERCENT,
+    });
+    if (!d.retry) return false;
+    this.items.note(retryNotice(d, this.error));
+    this.retrying = true;
+    this.onRetry(d, this.error);
+    return true;
+  }
+
+  // The reader stopped the turn while it waited to retry.
+  stopRetrying(): void {
+    this.retrying = false;
+    this.emit({ type: "usage", totals: { ...this.totals } });
+    this.items.endTurn({ interrupted: true });
+  }
+
   // The run is over: Pi has nothing left to do for it.
   endTurn(): void {
     if (!this.items.inTurn) return;
+    if (this.error && !this.aborted && this.retryTurn()) return;
+    this.retrying = false;
     this.emit({ type: "usage", totals: { ...this.totals } });
     const ended = this.aborted
       ? undefined
@@ -195,6 +265,9 @@ export class PiMapper {
           text: this.last.text,
           toolCalls: this.last.calls,
           error: this.error || undefined,
+          retries: this.retry.tried,
+          agentRetried: this.agentRetried,
+          summary: this.items.summary(),
         });
     if (ended)
       logTurnEnd({

package/lib/chat/drivers/pi.ts

@@ -6,12 +6,17 @@ 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 { writePiEditGuard } from "./pi-edit-guard";
+import { typescriptPath } from "./edit-guard";
+import { continuePrompt, type RetryDecision } from "./transient-retry";
 import { PiRpc } from "./pi-rpc";
 import { RESULTS_BRIEF, SUMMARY_NUDGE } from "./turn-outcome";
 
 type P = Record<string, unknown>;
 
 const SETTLE_TRIES = 5;
+// Compacting can take a while; the retry waits for it.
+const COMPACT_MS = 300_000;
 
 export function piArgs(o: ChatStartOptions, ...extensions: string[]): string[] {
   const args = extensions.flatMap((e) => ["-e", e]);
@@ -42,6 +47,15 @@ const splitModel = (model: string) => {
     : null;
 };
 
+// The edit guard extension, or none where it can't be written.
+function guardExtension(): string[] {
+  try {
+    return [writePiEditGuard()];
+  } catch {
+    return [];
+  }
+}
+
 export const piDriver: ChatDriver = {
   id: "pi",
   plan: false,
@@ -78,7 +92,11 @@ export const piDriver: ChatDriver = {
   start(options): ChatConversation {
     const out = new InputQueue<DriverEvent>();
     const emit = (e: DriverEvent) => out.push(e);
-    const mapper = new PiMapper(emit);
+    let retryTimer: ReturnType<typeof setTimeout> | null = null;
+    // Bumped when a retry is cancelled, so one already under way stops.
+    let retryGen = 0;
+    let closed = false;
+    const mapper = new PiMapper(emit, (d, error) => scheduleRetry(d, error));
     const dialogs = new PiDialogs(emit);
     const access = new PiAccess(options.access);
     // Sent now: goes once the stopped run has ended.
@@ -87,6 +105,7 @@ export const piDriver: ChatDriver = {
     const rpc: PiRpc = new PiRpc(
       piArgs(
         options,
+        ...guardExtension(),
         writeExtension(),
         writeExtension("agentos-text-tools.mjs", TEXT_TOOLS_EXTENSION)
       ),
@@ -96,6 +115,7 @@ export const piDriver: ChatDriver = {
           ...sessionBaseEnv(),
           ...options.env,
           AGENTOS_PI_ACCESS_FILE: access.file,
+          ...(typescriptPath() && { AGENTOS_TYPESCRIPT: typescriptPath() }),
           PI_OFFLINE: "1",
         },
       },
@@ -110,6 +130,7 @@ export const piDriver: ChatDriver = {
           });
         },
         exit(error) {
+          cancelRetry();
           dialogs.pending.expireAll();
           mapper.items.endTurn({ error });
           access.remove();
@@ -150,6 +171,7 @@ export const piDriver: ChatDriver = {
         .then((s) => {
           const c = s.contextUsage;
           if (c?.tokens == null || !c.contextWindow) return;
+          mapper.contextPercent = Number(c.percent) || 0;
           emit({
             type: "context",
             context: {
@@ -164,8 +186,50 @@ export const piDriver: ChatDriver = {
         .catch(() => {});
     }
 
-    const prompt = (text: string, images?: ChatImage[]) =>
-      rpc
+    // The failed request goes again after its wait, on a compacted context
+    // for the last try. Stopping or closing cancels it.
+    function scheduleRetry(
+      d: Extract<RetryDecision, { retry: true }>,
+      error: string
+    ) {
+      cancelRetry();
+      const gen = retryGen;
+      retryTimer = setTimeout(() => {
+        retryTimer = null;
+        void resume(d, error, gen);
+      }, d.delayMs);
+    }
+
+    // Whether a retry was waiting or under way.
+    function cancelRetry(): boolean {
+      const pending = retryTimer !== null || mapper.retrying;
+      if (retryTimer) clearTimeout(retryTimer);
+      retryTimer = null;
+      retryGen++;
+      return pending;
+    }
+
+    async function resume(
+      d: Extract<RetryDecision, { retry: true }>,
+      error: string,
+      gen: number
+    ) {
+      const live = () => !closed && mapper.retrying && gen === retryGen;
+      if (!live()) return;
+      if (d.compactFirst) {
+        await rpc.request("compact", {}, COMPACT_MS).catch(() => {});
+        if (!live()) return;
+      }
+      mapper.retrying = false;
+      await prompt(continuePrompt(error), undefined, true);
+    }
+
+    const prompt = (text: string, images?: ChatImage[], retried = false) => {
+      if (!retried) {
+        cancelRetry();
+        mapper.userPrompt();
+      }
+      return rpc
         .request("prompt", {
           message: text,
           images: piImages(images),
@@ -175,10 +239,22 @@ export const piDriver: ChatDriver = {
         .catch((error: Error) => {
           mapper.items.error(error.message);
         });
+    };
+
+    // A turn waiting to retry has nothing running to abort: it ends here.
+    function stopWaiting(): boolean {
+      if (!cancelRetry()) return false;
+      mapper.stopRetrying();
+      return true;
+    }
 
     return {
       send(text, images, sendOptions) {
         if (sendOptions?.now && mapper.items.inTurn) {
+          if (stopWaiting()) {
+            void prompt(text, images);
+            return undefined;
+          }
           held.push({ text, images });
           // Abort answers once the run has stopped; what was held goes then.
           void rpc
@@ -193,6 +269,7 @@ export const piDriver: ChatDriver = {
       },
       // Stops the run only: a message already sent still goes after it.
       async interrupt() {
+        if (stopWaiting()) return;
         await rpc.request("abort", {}, 0);
       },
       async setModel(model) {
@@ -211,6 +288,8 @@ export const piDriver: ChatDriver = {
         return { canUndo: false, error: "Pi can't undo from chat", files: [] };
       },
       close() {
+        closed = true;
+        cancelRetry();
         dialogs.pending.expireAll();
         rpc.close();
         out.end();