@dudousxd/nestjs-agent-opencode 0.3.0 → 0.4.1

package/dist/index.cjs

@@ -23,6 +23,7 @@ var index_exports = {};
 __export(index_exports, {
   FormAnswerError: () => FormAnswerError,
   InMemoryOpenCodeSessionStore: () => InMemoryOpenCodeSessionStore,
+  LOST_ANSWER_ERROR: () => LOST_ANSWER_ERROR,
   OPENCODE_HOST: () => OPENCODE_HOST,
   OPENCODE_MCP_ENDPOINT: () => OPENCODE_MCP_ENDPOINT,
   OPENCODE_OPTIONS: () => OPENCODE_OPTIONS,
@@ -195,6 +196,7 @@ OpenCodeMcpController = _ts_decorate([
 // src/mcp.ts
 var import_node_crypto = require("crypto");
 var import_nestjs_agent_core3 = require("@dudousxd/nestjs-agent-core");
+var import_genui = require("@dudousxd/nestjs-agent-core/genui");
 var import_server = require("@modelcontextprotocol/sdk/server/index.js");
 var import_streamableHttp = require("@modelcontextprotocol/sdk/server/streamableHttp.js");
 var import_zod_json_schema_compat = require("@modelcontextprotocol/sdk/server/zod-json-schema-compat.js");
@@ -325,6 +327,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",
@@ -413,6 +418,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);
@@ -430,6 +443,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);
@@ -520,7 +557,11 @@ var OpenCodeTurn = class {
     this.reported = {
       ...this.spent
     };
-    const milestone = {
+    const milestone = reached.kind === "ask" ? {
+      ...reached,
+      usage,
+      progress: this.progress()
+    } : {
       ...reached,
       usage
     };
@@ -575,6 +616,7 @@ var OpenCodeTurn = class {
         innerSettled: /* @__PURE__ */ new Set()
       };
       this.tools.set(id, state);
+      this.took.called.add(id);
       this.segment.calls.push({
         id,
         name,
@@ -702,6 +744,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();
@@ -723,6 +766,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;
@@ -777,6 +821,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":
@@ -817,10 +862,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,
@@ -1370,9 +1421,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);
@@ -1389,6 +1602,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;
@@ -1515,6 +1748,8 @@ var OpenCodeMcpEndpoint2 = class {
   }
   turns;
   tokens;
+  /** Genui telemetry of the UI calls OpenCode makes (its code mode calls tools here, not in the loop). */
+  genui = new import_nestjs_agent_core3.GenuiRunRecorder();
   constructor(turns, tokens) {
     this.turns = turns;
     this.tokens = tokens;
@@ -1646,7 +1881,7 @@ var OpenCodeMcpEndpoint2 = class {
     if (spec.kind === "action" && !await this.turns.spendApproval(turn.runId, name, turn.input)) {
       throw new OpenCodeToolRefusedError(`"${name}" is an action and nobody approved this call; ask for the permission first.`);
     }
-    return registry.invoke(name, args ?? {}, {
+    const invoke = /* @__PURE__ */ __name(() => registry.invoke(name, args ?? {}, {
       actor,
       threadId: turn.ctx.threadId,
       runId: turn.runId,
@@ -1663,7 +1898,24 @@ var OpenCodeMcpEndpoint2 = class {
       } : {}
     }, this.turns.rolesPolicyFor(turn.input), allowed !== void 0 ? {
       allowedTools: allowed
-    } : {});
+    } : {}), "invoke");
+    return this.genui.track({
+      store: this.turns.store,
+      marker: spec.genui,
+      runId: turn.runId,
+      threadId: turn.ctx.threadId,
+      actorRef: actor.id,
+      ...turn.input.agentName !== void 0 ? {
+        agentName: turn.input.agentName
+      } : {},
+      channel: (0, import_genui.turnChannel)(turn.input.pageContext),
+      modelId: turn.input.model ?? "opencode",
+      call: {
+        id: `mcp:${turn.runId}:${requestId}`,
+        name,
+        input: args ?? {}
+      }
+    }, invoke);
   }
   /** `remember`: one fact, at the actor's own scope only — as the loop serves it. */
   async remember(turn, args) {
@@ -2515,7 +2767,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}`);
@@ -2528,9 +2784,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;
@@ -2569,12 +2827,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;
   }
@@ -2592,7 +2850,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;
   }
@@ -2616,9 +2877,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);
@@ -2649,6 +2911,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) ?? [];
@@ -2668,7 +2934,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. */
@@ -3211,6 +3477,7 @@ __name(openCodeProviders, "openCodeProviders");
 0 && (module.exports = {
   FormAnswerError,
   InMemoryOpenCodeSessionStore,
+  LOST_ANSWER_ERROR,
   OPENCODE_HOST,
   OPENCODE_MCP_ENDPOINT,
   OPENCODE_OPTIONS,