@saadnvd1/agent-os 0.3.738 → 0.3.743

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

@@ -2,12 +2,16 @@ 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";
+import { logTurnEnd, needsSummary, turnOutcome } from "./turn-outcome";
+import { retryNotice, TurnRetry, type RetryDecision } from "./transient-retry";
 
 type P = Record<string, unknown>;
 const str = (v: unknown) => (typeof v === "string" ? v : "");
 const num = (v: unknown) => Number(v) || 0;
 
+// A prompt this big (tokens) is worth compacting before the last retry.
+const HEAVY_TOKENS = 16_000;
+
 const TODO = new Set(["pending", "in_progress", "completed"]);
 
 // OpenCode's event stream as chat items, for one session (its subagents'
@@ -37,6 +41,10 @@ export class OpenCodeMapper {
     calls: new Set<string>(),
   };
   private aborted = false;
+  // Tool calls this turn, kept through the nudged run that continues it.
+  private toolIds = new Set<string>();
+  private nudged = false;
+  private nudgeDue = false;
   // Idle from before the prompt is stale until the session goes busy.
   private admitted = false;
   totals: UsageTotals = {
@@ -47,15 +55,34 @@ export class OpenCodeMapper {
     cacheWriteTokens: 0,
   };
 
+  // Retrying a turn the model's server dropped.
+  readonly retry = new TurnRetry();
+  // OpenCode retried the failure itself: AgentOS adds nothing on top.
+  private agentRetried = false;
+  // The last answer's prompt size, to judge whether compacting would help.
+  lastInputTokens = 0;
+  // Compacting between retries makes the session busy and idle: not a turn.
+  private holding = false;
+
   constructor(
     private sessionId: () => string | null,
-    private emit: (e: DriverEvent) => void
+    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);
   }
 
-  // A prompt went out: its turn starts now.
-  prompted(): void {
+  // A prompt went out: its turn starts now. A retry is the same turn.
+  prompted(retried = false): void {
+    this.retrying = false;
+    if (!retried) {
+      this.retry.reset();
+      this.agentRetried = false;
+    }
     this.admitted = false;
     this.items.startTurn();
   }
@@ -66,9 +93,18 @@ export class OpenCodeMapper {
     switch (e.type) {
       case "session.status": {
         const type = str((p.status as P)?.type);
+        if (type === "retry") this.agentRetried = true;
         if (type === "busy" || type === "retry") {
           this.admitted = true;
           this.items.startTurn();
+          if (type === "retry") {
+            const st = p.status as P;
+            this.emit({
+              type: "model_retry",
+              attempt: num(st.attempt) || 1,
+              message: str(st.message) || undefined,
+            });
+          }
         } else if (type === "idle") this.idle();
         return;
       }
@@ -125,6 +161,12 @@ export class OpenCodeMapper {
     this.counted.add(id);
     const t = (info.tokens ?? {}) as P;
     const cache = (t.cache ?? {}) as P;
+    this.lastInputTokens = num(t.input) + num(cache.read);
+    if (this.lastInputTokens + num(cache.write) > 0)
+      this.emit({
+        type: "prompt_tokens",
+        tokens: this.lastInputTokens + num(cache.write),
+      });
     this.totals = {
       costUsd: this.totals.costUsd + num(info.cost),
       inputTokens: this.totals.inputTokens + num(t.input),
@@ -157,6 +199,7 @@ export class OpenCodeMapper {
       return;
     }
     if (part.type === "tool") {
+      this.toolIds.add(id);
       if (this.last.id === str(part.messageID)) this.last.calls.add(id);
       this.tool(id, part);
     }
@@ -183,7 +226,9 @@ export class OpenCodeMapper {
     if (tool === "todowrite" || status === "pending") return;
     const start = openCodeTool(tool, state.input);
     if (!this.items.hasTool(id)) this.items.tool(id, start);
-    if (status === "completed")
+    if (status === "running")
+      this.items.progress(id, str((state.metadata as P | undefined)?.output));
+    else if (status === "completed")
       this.items.toolDone(id, "done", str(state.output), start);
     else if (status === "error")
       this.items.toolDone(id, "error", str(state.error), start);
@@ -197,10 +242,72 @@ export class OpenCodeMapper {
         str((error.data as P)?.message) || str(error.name) || "OpenCode failed";
   }
 
+  // A turn that failed on a dropped request goes on in place: the notice,
+  // then the driver sends the prompt again. False when it should end.
+  private retryTurn(): boolean {
+    const error = this.error ?? "";
+    const d = this.retry.next({
+      error,
+      harnessRetried: this.agentRetried,
+      contextHeavy: this.lastInputTokens >= HEAVY_TOKENS,
+    });
+    if (!d.retry) return false;
+    this.items.note(retryNotice(d, error));
+    this.clearTurn();
+    this.retrying = true;
+    this.onRetry(d, error);
+    return true;
+  }
+
+  private clearTurn(): void {
+    this.error = null;
+    this.last.id = "";
+    this.toolIds.clear();
+    this.aborted = false;
+    this.admitted = false;
+    for (const id of this.current) this.past.add(id);
+    this.current.clear();
+    this.parts.clear();
+  }
+
+  // A failed turn is waiting for its retry to go out.
+  retrying = false;
+
+  // The reader stopped the turn while it waited to retry.
+  stopRetrying(): void {
+    this.retrying = false;
+    this.holding = false;
+    this.emit({ type: "usage", totals: { ...this.totals } });
+    this.items.endTurn({ interrupted: true });
+  }
+
+  holdIdle(on: boolean): void {
+    this.holding = on;
+  }
+
   private idle(): void {
-    if (!this.admitted || !this.items.inTurn) return;
+    if (this.holding || !this.admitted || !this.items.inTurn) return;
+    if (this.error && !this.aborted && this.retryTurn()) return;
     this.emit({ type: "usage", totals: { ...this.totals } });
     const text = [...this.last.text.values()].join("\n");
+    if (
+      !this.nudged &&
+      needsSummary({
+        toolsRun: this.toolIds.size,
+        text,
+        toolCalls: this.last.calls.size,
+        finishReason: this.last.finish,
+        error: this.error ?? undefined,
+        aborted: this.aborted,
+      })
+    ) {
+      // The turn stays open: the driver asks for the summary, once.
+      this.nudged = this.nudgeDue = true;
+      this.last.id = "";
+      this.admitted = false;
+      console.info("[chat] asked the model for its results summary");
+      return;
+    }
     const ended =
       this.aborted || !this.last.id
         ? undefined
@@ -209,6 +316,9 @@ export class OpenCodeMapper {
             text,
             toolCalls: this.last.calls.size,
             error: this.error ?? undefined,
+            retries: this.retry.tried,
+            agentRetried: this.agentRetried,
+            summary: this.items.summary(),
           });
     if (ended)
       logTurnEnd({
@@ -225,13 +335,15 @@ export class OpenCodeMapper {
       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);
-    this.current.clear();
-    this.parts.clear();
+    this.clearTurn();
+    this.nudged = this.nudgeDue = false;
+  }
+
+  // True once after a turn ended without its results: send SUMMARY_NUDGE.
+  takeNudge(): boolean {
+    const due = this.nudgeDue;
+    this.nudgeDue = false;
+    return due;
   }
 
   // The prompt never reached a busy session (it failed, or finished before

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);