@dudousxd/nestjs-agent-opencode 0.4.0 → 0.5.0

package/README.md

@@ -94,8 +94,9 @@ the dashboard and `GET /quota` see an OpenCode turn like any other.
   the turn's last message) is added up from the turn's own calls, not read back from the store: each
   milestone carries what was spent since the last one, and a durable run journals it with the
   milestone, so a run resumed in another process (an approval answered after a restart) still reports
-  the whole run, cache tokens included. A process that dies while OpenCode works loses the calls it
-  saw from that total (their ledger rows are already written).
+  the whole run, cache tokens included. A process that dies while OpenCode works does not lose the
+  calls it saw: the `observe` re-run reads each step's usage back from the session's messages (see
+  below).
 
 ## Durable turns
 
@@ -109,7 +110,13 @@ AgentModule.forRoot({ engine: openCodeDurable({ host: MyOpenCodeHost, sessions:
 Every step of a turn is checkpointed (`begin → prompt → observe → [wait for a person → reply →
 observe]* → finish`) and a person's decision is a durable signal: a turn waiting on an approval
 survives restarts and is resumed by whichever process gets the decision. If OpenCode restarted
-meanwhile, a new session is opened with the conversation and the decision. `openCode()` runs the
+meanwhile, a new session is opened with the conversation and the decision. If the API restarted
+while OpenCode worked (its `observe` step re-runs), the rebuilt turn catches up on what OpenCode
+asked meanwhile and, when the execution ends, on what it said: the text, tool calls and results and
+each step's usage are read back from the session's messages after the turn's prompt (the prompt
+carries the run id in its `metadata`), less what was already taken before the restart (journaled
+with each ask). A session that left no answer at all fails the turn (`LOST_ANSWER_ERROR`) instead
+of settling it as an empty success. It needs the client's `message.list`. `openCode()` runs the
 same steps in memory (single replica). Several processes need a cross-process sink and a persistent
 `OpenCodeSessionStore`.
 

package/dist/durable/index.cjs

@@ -285,6 +285,9 @@ function subUsage(a, b) {
   };
 }
 __name(subUsage, "subUsage");
+var LOST_ANSWER_ERROR = "The answer was lost while the agent restarted; ask again.";
+var RECOVER_PAGES = 10;
+var RECOVER_PAGE_SIZE = 100;
 var ASK_TOOL_NAME = "ask";
 var FAILED_STATUSES = /* @__PURE__ */ new Set([
   "error",
@@ -373,6 +376,14 @@ var OpenCodeTurn = class {
   wroteMessage = false;
   ended = false;
   stepError;
+  /** What this turn object took from the session's assistant messages (see {@link TurnProgress}). */
+  took = {
+    text: /* @__PURE__ */ new Map(),
+    reasoning: /* @__PURE__ */ new Map(),
+    called: /* @__PURE__ */ new Set(),
+    settled: /* @__PURE__ */ new Set(),
+    steps: /* @__PURE__ */ new Set()
+  };
   constructor(a) {
     this.a = a;
     this.model = modelOfLabel(a.input.model);
@@ -390,6 +401,30 @@ var OpenCodeTurn = class {
       tokens: info.tokens
     };
   }
+  /** What the turn took so far: carried from before this turn object, plus what it took. */
+  progress() {
+    const before = this.a.progress;
+    const merged = /* @__PURE__ */ __name((carried, own) => {
+      const out = {
+        ...carried ?? {}
+      };
+      for (const [id, n] of own) out[id] = (out[id] ?? 0) + n;
+      return out;
+    }, "merged");
+    const union = /* @__PURE__ */ __name((carried, own) => [
+      .../* @__PURE__ */ new Set([
+        ...carried ?? [],
+        ...own
+      ])
+    ], "union");
+    return {
+      text: merged(before?.text, this.took.text),
+      reasoning: merged(before?.reasoning, this.took.reasoning),
+      called: union(before?.called, this.took.called),
+      settled: union(before?.settled, this.took.settled),
+      steps: union(before?.steps, this.took.steps)
+    };
+  }
   /** What the run spent so far: carried from before this turn object, plus what it saw. */
   totalUsage() {
     return addUsage(this.a.carried, this.spent);
@@ -480,7 +515,11 @@ var OpenCodeTurn = class {
     this.reported = {
       ...this.spent
     };
-    const milestone = {
+    const milestone = reached.kind === "ask" ? {
+      ...reached,
+      usage,
+      progress: this.progress()
+    } : {
       ...reached,
       usage
     };
@@ -535,6 +574,7 @@ var OpenCodeTurn = class {
         innerSettled: /* @__PURE__ */ new Set()
       };
       this.tools.set(id, state);
+      this.took.called.add(id);
       this.segment.calls.push({
         id,
         name,
@@ -662,6 +702,7 @@ var OpenCodeTurn = class {
       case "session.text.delta": {
         const delta = typeof d.delta === "string" ? d.delta : "";
         if (!delta) return;
+        this.count(this.took.text, d.assistantMessageID, delta.length);
         this.endReasoning();
         if (!this.sawText && !delta.trim()) return;
         await this.step();
@@ -683,6 +724,7 @@ ${delta}` : delta;
       case "session.reasoning.delta": {
         const delta = typeof d.delta === "string" ? d.delta : "";
         if (!delta) return;
+        this.count(this.took.reasoning, d.assistantMessageID, delta.length);
         this.reasoningSince ??= Date.now();
         await this.step();
         this.segment.reasoning += delta;
@@ -737,6 +779,7 @@ ${delta}` : delta;
       }
       case "session.step.ended":
         this.endReasoning();
+        if (typeof d.assistantMessageID === "string") this.took.steps.add(d.assistantMessageID);
         await this.stepEnded(d);
         return;
       case "session.step.failed":
@@ -777,10 +820,16 @@ ${delta}` : delta;
         return;
     }
   }
+  /** Characters taken from an assistant message's text or reasoning. */
+  count(into, messageId, n) {
+    if (typeof messageId !== "string") return;
+    into.set(messageId, (into.get(messageId) ?? 0) + n);
+  }
   async settleTool(id, ok, error = "failed") {
     const state = this.tool(id);
     if (state.settled) return;
     state.settled = true;
+    this.took.settled.add(id);
     if (ok) {
       this.segment.results.push({
         id,
@@ -1330,9 +1379,171 @@ ${delta}` : delta;
       cost: cost < 1e-9 ? 0 : cost
     }, this.compacted ? "history_summary" : "title");
   }
-  async end(outcome) {
+  /**
+  * The session's messages since this turn's prompt, oldest first: everything after its newest user
+  * message. `undefined` when they cannot be read (no `message.list`, no prompt within reach); empty
+  * when the newest prompt is another run's (this turn's never reached the session).
+  */
+  async messagesSincePrompt() {
+    const messages = this.a.client.message;
+    if (messages === void 0) return void 0;
+    const since = [];
+    let cursor;
+    for (let page = 0; page < RECOVER_PAGES; page += 1) {
+      const listed = await messages.list({
+        sessionID: this.a.sessionId,
+        order: "desc",
+        limit: RECOVER_PAGE_SIZE,
+        ...cursor !== void 0 ? {
+          cursor
+        } : {}
+      });
+      for (const message of listed.data) {
+        if (message.type === "user") {
+          const runId = message.metadata?.runId;
+          if (typeof runId === "string" && runId !== this.a.runId) return [];
+          return since.reverse();
+        }
+        since.push(message);
+      }
+      const next = listed.cursor?.next;
+      if (typeof next !== "string" || next.length === 0 || listed.data.length === 0) break;
+      cursor = next;
+    }
+    return void 0;
+  }
+  /**
+  * A turn rebuilt after a restart heard only what the session said once it re-attached: what it
+  * said in between — read back from the session's messages since the prompt, less what an earlier
+  * process already took ({@link TurnProgress}) and what this one heard — is taken now, as its
+  * events would have been: text, reasoning, tool calls and results, each step's usage. A session
+  * that left nothing for the turn fails it ({@link LOST_ANSWER_ERROR}) rather than reading as an
+  * empty answer.
+  */
+  async recover(outcome) {
+    const messages = await this.messagesSincePrompt().catch((error) => {
+      this.a.logger.warn(`run ${this.a.runId}: ${errorText(error, "could not read the session messages")}`);
+      return void 0;
+    });
+    const before = this.a.progress;
+    const text = [];
+    let reasoning = "";
+    let lastError;
+    for (const message of messages ?? []) {
+      if (message.type !== "assistant") continue;
+      const id = message.id;
+      const parts = message.content ?? [];
+      text.push(...missed(parts, "text", before?.text[id] ?? 0, this.took.text.get(id) ?? 0));
+      reasoning += missed(parts, "reasoning", before?.reasoning[id] ?? 0, this.took.reasoning.get(id) ?? 0).map((piece) => piece.text).join("");
+      for (const part of parts) if (part.type === "tool") await this.missedTool(part);
+      if (message.tokens !== void 0 && !before?.steps.includes(id) && !this.took.steps.has(id)) {
+        this.took.steps.add(id);
+        const model = message.model;
+        if (typeof model?.id === "string" && typeof model.providerID === "string") this.model = {
+          providerID: model.providerID,
+          id: model.id
+        };
+        await this.spend({
+          tokens: message.tokens,
+          cost: message.cost
+        }, "chat");
+      }
+      if (message.error?.message) lastError = message.error.message;
+    }
+    const recovered = text.map((piece) => piece.text).join("\n\n").trimStart();
+    if (recovered.trim()) {
+      await this.step();
+      const joint = this.segment.text && !text.at(-1)?.continues ? "\n\n" : "";
+      this.segment.text = `${recovered}${joint}${this.segment.text}`;
+      this.sawText = true;
+      await this.write({
+        kind: "text",
+        text: recovered
+      });
+    }
+    if (reasoning) {
+      await this.step();
+      this.segment.reasoning = `${reasoning}${this.segment.reasoning}`;
+      await this.write({
+        kind: "reasoning",
+        text: reasoning
+      });
+    }
+    if (outcome.status !== "succeeded") return outcome;
+    const idle = (messages ?? []).filter((m) => m.type === "idle").at(-1);
+    if (idle?.outcome === "failed") return {
+      status: "failed",
+      error: lastError ?? this.stepError ?? "the execution failed"
+    };
+    if (idle?.outcome === "interrupted") return {
+      status: "interrupted"
+    };
+    const s = this.segment;
+    const said = s.text || s.reasoning || s.calls.length > 0 || s.ui.length > 0;
+    const progress = this.progress();
+    const tookAny = Object.keys(progress.text).length > 0 || progress.called.length > 0 || progress.steps.length > 0;
+    if (!said && !this.wroteMessage && !tookAny) return {
+      status: "failed",
+      error: LOST_ANSWER_ERROR
+    };
+    return outcome;
+  }
+  /** A tool part of a message the turn did not hear: its call, its result, whichever it lacks. */
+  async missedTool(part) {
+    const id = part.id;
+    const name = part.name ?? "tool";
+    if (id === void 0 || HIDDEN_TOOLS.has(name)) return;
+    const state = part.state ?? {};
+    const before = this.a.progress;
+    if (!before?.called.includes(id) && !this.tools.has(id)) {
+      await this.step();
+      this.setInput(id, state.input, name);
+      await this.makeAvailable(id);
+    }
+    const ok = state.status === "completed";
+    if (!ok && state.status !== "error" || before?.settled.includes(id)) return;
+    const error = errorText(state.error, "tool failed");
+    if (this.tools.has(id)) {
+      await this.settleTool(id, ok, error);
+      return;
+    }
+    this.took.settled.add(id);
+    const result = ok ? {
+      id,
+      name,
+      output: {
+        ok: true
+      }
+    } : {
+      id,
+      name,
+      output: {
+        ok: false
+      },
+      error
+    };
+    const messageId = await this.messageOf(id);
+    if (messageId !== void 0) await this.addResult(messageId, result);
+    else this.segment.results.push(result);
+    await this.write(ok ? {
+      kind: "tool-output",
+      id,
+      output: {
+        ok: true
+      }
+    } : {
+      kind: "tool-output-error",
+      id,
+      error
+    });
+  }
+  async end(ended) {
     if (this.ended) return;
     this.ended = true;
+    const outcome = this.a.resumed === true ? await this.recover(ended).catch((error) => {
+      this.a.logger.warn(`run ${this.a.runId}: ${errorText(error, "could not recover the turn")}`);
+      return ended;
+    }) : ended;
     await this.unreported().catch((error) => this.a.logger.warn(`run ${this.a.runId}: ${errorText(error, "could not read the session usage")}`));
     if (outcome.status !== "failed" || this.segment.text || this.segment.calls.length > 0 || this.segment.ui.length > 0) {
       await this.flush(true);
@@ -1349,6 +1560,26 @@ ${delta}` : delta;
     });
   }
 };
+function missed(parts, type, head, tail) {
+  const texts = parts.flatMap((p) => p.type === type && typeof p.text === "string" ? [
+    p.text
+  ] : []);
+  const total = texts.reduce((n, t) => n + t.length, 0);
+  const end = total - tail;
+  const out = [];
+  let at = 0;
+  for (const t of texts) {
+    const from = Math.max(head, at);
+    const to = Math.min(end, at + t.length);
+    if (to > from) out.push({
+      text: t.slice(from - at, to - at),
+      continues: to < at + t.length
+    });
+    at += t.length;
+  }
+  return out;
+}
+__name(missed, "missed");
 function modelOfLabel(label) {
   const slash = label?.indexOf("/") ?? -1;
   if (label === void 0 || slash <= 0 || slash === label.length - 1) return void 0;
@@ -2494,7 +2725,11 @@ ${body}
         text: prompt.text,
         ...prompt.files?.length ? {
           files: prompt.files
-        } : {}
+        } : {},
+        // Marks the prompt as this run's: a turn resumed after a restart reads what came after it.
+        metadata: {
+          runId
+        }
       });
     } catch (error) {
       live.turn.fail(`OpenCode refused the message: ${error.message}`);
@@ -2507,9 +2742,11 @@ ${body}
   *
   * `spent` is what the run spent before (the sum of the `usage` of its earlier milestones): a turn
   * rebuilt here starts from it, so the answer it persists carries the whole run's usage.
+  * `progress` is what the turn took before (its last `ask` milestone's): a turn rebuilt here reads
+  * back from the session's messages, when the execution ends, what nobody heard after that.
   */
-  async observe(runId, input, handle, spent) {
-    const live = await this.ensureLive(runId, input, handle, true, spent);
+  async observe(runId, input, handle, spent, progress) {
+    const live = await this.ensureLive(runId, input, handle, true, spent, progress);
     const { turn, client } = live;
     if (turn.hasMilestone()) return this.reached(runId, input, handle, await turn.next());
     let done = false;
@@ -2548,12 +2785,12 @@ ${body}
   * request is gone with it: a new session is opened, told what the person decided, and prompted
   * to go on.
   */
-  async reply(runId, input, handle, ask, reply, spent) {
+  async reply(runId, input, handle, ask, reply, spent, progress) {
     const server = await this.host.server(input.actor);
     if (server.key !== handle.serverKey || server.bootId !== handle.bootId) {
       return this.continueAfterRestart(runId, input, server, ask, reply, spent);
     }
-    const live = await this.ensureLive(runId, input, handle, false, spent);
+    const live = await this.ensureLive(runId, input, handle, false, spent, progress);
     await live.turn.decide(ask, reply);
     return handle;
   }
@@ -2571,7 +2808,10 @@ ${body}
     live.turn.setBaseline(await this.sessionUsage(live.client, handle.sessionId));
     await live.client.session.prompt({
       sessionID: handle.sessionId,
-      text: note
+      text: note,
+      metadata: {
+        runId
+      }
     });
     return handle;
   }
@@ -2595,9 +2835,10 @@ ${body}
       sessionID: known.sessionId
     });
   }
-  async ensureLive(runId, input, handle, catchUp, spent) {
+  async ensureLive(runId, input, handle, catchUp, spent, progress) {
     const current = this.live.get(runId);
     if (current !== void 0 && current.handle.sessionId === handle.sessionId) return current;
+    const resumed = catchUp && current === void 0;
     current?.stop();
     const server = await this.host.server(input.actor);
     const deps = this.deps.forAgent(input.agentName);
@@ -2628,6 +2869,10 @@ ${body}
       ...spent !== void 0 ? {
         carried: spent
       } : {},
+      ...progress !== void 0 ? {
+        progress
+      } : {},
+      resumed,
       logger: this.logger,
       onGranted: /* @__PURE__ */ __name((action, id) => {
         const grants = this.grants.get(runId) ?? [];
@@ -2647,7 +2892,7 @@ ${body}
       stop
     };
     this.live.set(runId, live);
-    if (catchUp && current === void 0) await turn.catchUp().catch(() => void 0);
+    if (resumed) await turn.catchUp().catch(() => void 0);
     return live;
   }
   /** Stop following a run in this process. */
@@ -2761,6 +3006,12 @@ ${body}
         kind: "cancelled"
       }));
       await writer.end();
+      (0, import_nestjs_agent_core4.publishAgentRunCancelled)({
+        runId,
+        threadId: input.threadId,
+        durationMs,
+        context: (0, import_nestjs_agent_core4.agentRunContext)(input)
+      });
       await this.store.recordRunEnd?.({
         runId,
         status: "cancelled",
@@ -2791,12 +3042,16 @@ ${body}
     this.logger.error(`agent run ${runId} failed: ${error}`);
     (0, import_nestjs_agent_core4.publishAgentRunFailed)({
       runId,
+      threadId: input.threadId,
       code: "opencode_failed",
-      message: error
+      message: error,
+      durationMs,
+      context: (0, import_nestjs_agent_core4.agentRunContext)(input)
     });
     await this.store.recordRunEnd?.({
       runId,
       status: "failed",
+      durationMs,
       errorCode: "opencode_failed",
       errorMessage: error
     });
@@ -3225,6 +3480,7 @@ var OpenCodeRunWorkflow = class {
   }
   async run(ctx, input) {
     let spent = emptyUsage();
+    let progress;
     try {
       const begun = await ctx.localStep("begin", async () => ({
         handle: await this.turns.begin(ctx.runId, input),
@@ -3237,7 +3493,8 @@ var OpenCodeRunWorkflow = class {
       });
       for (let n = 0; ; n += 1) {
         const before = spent;
-        const milestone = await ctx.localStep(`observe:${n}`, () => this.turns.observe(ctx.runId, input, handle, before));
+        const taken = progress;
+        const milestone = await ctx.localStep(`observe:${n}`, () => this.turns.observe(ctx.runId, input, handle, before, taken));
         spent = addUsage(spent, milestone.usage);
         const total = spent;
         if (milestone.kind === "finished") {
@@ -3263,7 +3520,9 @@ var OpenCodeRunWorkflow = class {
           };
         }
         const ask = milestone.ask;
-        handle = await ctx.localStep(`reply:${n}`, () => this.turns.reply(ctx.runId, input, handle, ask, reply, total));
+        progress = milestone.progress ?? progress;
+        const tookSoFar = progress;
+        handle = await ctx.localStep(`reply:${n}`, () => this.turns.reply(ctx.runId, input, handle, ask, reply, total, tookSoFar));
       }
     } catch (error) {
       if ((0, import_nestjs_durable_core.isWorkflowControlFlowSignal)(error)) throw error;