@dudousxd/nestjs-agent-opencode 0.2.0 → 0.3.0

package/README.md

@@ -54,7 +54,7 @@ export class AppModule {}
 | --- | --- |
 | `session.text.delta` / `session.reasoning.delta` | `text` / `reasoning` |
 | a step (`session.step.ended`) | `step-start` … `step-finish` with usage and cost; a `chat` usage row per step (see [Cost and usage](#cost-and-usage)) |
-| `session.usage.recorded` (the title, a compaction) | a `title` / `history_summary` usage row |
+| the title OpenCode generates, a compaction | a `title` / `history_summary` usage row (see [Cost and usage](#cost-and-usage)) |
 | tools (`session.tool.*`) | `tool-input-*` / `tool-output*`, code-mode inner calls nested by `parentId` |
 | `permission.asked` | an `action` call + `approval-requested`, recorded `pending_approval`; `approve` / `reject` → `permission.reply` |
 | `form.created` | `elicitation`; `answer` / `skip` → `session.form.reply` / `cancel` |
@@ -72,6 +72,11 @@ compaction — goes to the same token-usage ledger the library's own loop writes
 `agent_token_usage` with `cost_usd` and `cost_source`), so the ledger quota (`quota: { limits }`),
 the dashboard and `GET /quota` see an OpenCode turn like any other.
 
+- **The title and compactions.** OpenCode records those calls on the session without streaming
+  them. The turn reads what the session had spent (`session.get`) before it prompts, and when the
+  execution ends records what the session spent since that its steps did not report, as a `title`
+  row (`history_summary` when a compaction ran). A `session.usage.recorded` event, from an OpenCode
+  that streams it, is recorded as it arrives and not counted twice.
 - **Tokens.** OpenCode reports the uncached input in `tokens.input` and the cache beside it; the row
   counts the whole input side in `inputTokens`, with `cacheReadTokens` / `cacheWriteTokens` as
   subsets (the library's `MessageUsage`). The row's model is the one OpenCode names for the step

package/dist/durable/index.cjs

@@ -354,6 +354,17 @@ var OpenCodeTurn = class {
   reported = emptyUsage();
   priced = false;
   model;
+  /** What the session had spent when this turn prompted it; what OpenCode reported since. */
+  baseline;
+  seen = {
+    cost: 0,
+    input: 0,
+    output: 0,
+    reasoning: 0,
+    read: 0,
+    write: 0
+  };
+  compacted = false;
   stepOpen = false;
   sawText = false;
   separator = false;
@@ -365,6 +376,19 @@ var OpenCodeTurn = class {
     this.a = a;
     this.model = modelOfLabel(a.input.model);
   }
+  /**
+  * What the session had spent before this turn prompted it (`session.get`). When the execution
+  * ends, what the session spent since that this turn's events did not report — the title OpenCode
+  * generates, a compaction: OpenCode records those calls on the session without streaming them — is
+  * recorded as a usage row of its own.
+  */
+  setBaseline(info) {
+    if (info?.tokens === void 0) return;
+    this.baseline = {
+      cost: Number(info.cost) || 0,
+      tokens: info.tokens
+    };
+  }
   /** What the run spent so far: carried from before this turn object, plus what it saw. */
   totalUsage() {
     return addUsage(this.a.carried, this.spent);
@@ -621,6 +645,10 @@ var OpenCodeTurn = class {
     }
     if (this.ended) return;
     switch (e.type) {
+      case "session.compaction.started":
+      case "session.compaction.ended":
+        this.compacted = true;
+        return;
       case "session.step.started":
       case "session.model.selected": {
         const model = d.model;
@@ -790,6 +818,13 @@ ${delta}` : delta;
   async spend(d, purpose) {
     const usage = usageOf(d.tokens);
     const reportedCostUsd = typeof d.cost === "number" && Number.isFinite(d.cost) && d.cost >= 0 ? d.cost : void 0;
+    const n = /* @__PURE__ */ __name((v) => typeof v === "number" && Number.isFinite(v) && v > 0 ? v : 0, "n");
+    this.seen.cost += reportedCostUsd ?? 0;
+    this.seen.input += n(d.tokens?.input);
+    this.seen.output += n(d.tokens?.output);
+    this.seen.reasoning += n(d.tokens?.reasoning);
+    this.seen.read += n(d.tokens?.cache?.read);
+    this.seen.write += n(d.tokens?.cache?.write);
     const fallback = reportedCostUsd !== void 0 ? {
       costUsd: reportedCostUsd,
       costSource: "provider"
@@ -995,6 +1030,8 @@ ${delta}` : delta;
     }
     const ttlMs = requirement.ttlMs !== void 0 && Number.isFinite(requirement.ttlMs) && requirement.ttlMs > 0 ? Math.floor(requirement.ttlMs) : void 0;
     const expiresAt = ttlMs !== void 0 ? new Date(Date.now() + ttlMs).toISOString() : void 0;
+    const tool = this.a.approvalPresentation?.(action);
+    const confirmation = tool !== void 0 ? (0, import_nestjs_agent_core2.resolveToolConfirmation)(tool.name, args, tool.presentation) : void 0;
     this.segment.calls.push({
       id: req.id,
       name: action,
@@ -1009,6 +1046,9 @@ ${delta}` : delta;
       toolType: "action",
       input: args,
       status: "pending_approval",
+      ...confirmation !== void 0 ? {
+        confirmation
+      } : {},
       runId: this.a.runId,
       approver: requirement.approver,
       ...expiresAt !== void 0 ? {
@@ -1026,6 +1066,9 @@ ${delta}` : delta;
       kind: "approval-requested",
       id: req.id,
       approver: requirement.approver,
+      ...confirmation !== void 0 ? {
+        confirmation
+      } : {},
       ...expiresAt !== void 0 ? {
         expiresAt
       } : {}
@@ -1257,9 +1300,39 @@ ${delta}` : delta;
     this.messageResults.set(messageId, results);
     await this.a.store.setMessageToolResults(messageId, results);
   }
+  /** What the session spent since the baseline that no event of this turn reported. */
+  async unreported() {
+    const baseline = this.baseline;
+    if (baseline === void 0) return;
+    this.baseline = void 0;
+    const info = await this.a.client.session.get?.({
+      sessionID: this.a.sessionId
+    }).catch(() => void 0);
+    const after = info?.tokens;
+    if (after === void 0) return;
+    const before = baseline.tokens;
+    const left = /* @__PURE__ */ __name((now, then, seen) => Math.max(0, (Number(now) || 0) - (Number(then) || 0) - seen), "left");
+    const tokens = {
+      input: left(after.input, before.input, this.seen.input),
+      output: left(after.output, before.output, this.seen.output),
+      reasoning: left(after.reasoning, before.reasoning, this.seen.reasoning),
+      cache: {
+        read: left(after.cache?.read, before.cache?.read, this.seen.read),
+        write: left(after.cache?.write, before.cache?.write, this.seen.write)
+      }
+    };
+    const total = tokens.input + tokens.output + tokens.reasoning + tokens.cache.read + tokens.cache.write;
+    if (total === 0) return;
+    const cost = left(info?.cost, baseline.cost, this.seen.cost);
+    await this.spend({
+      tokens,
+      cost: cost < 1e-9 ? 0 : cost
+    }, this.compacted ? "history_summary" : "title");
+  }
   async end(outcome) {
     if (this.ended) return;
     this.ended = true;
+    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);
     }
@@ -1776,6 +1849,25 @@ var OpenCodeTurns = class {
   get toolsServer() {
     return this.settings.tools?.server ?? "aviary";
   }
+  /** The app tool an OpenCode permission `action` names, and its presentation — `undefined` for a built-in. */
+  presentationOf(action) {
+    if (this.settings.tools === void 0) return void 0;
+    const server = this.toolsServer;
+    for (const prefix of [
+      `${server}.`,
+      `${server}_`
+    ]) {
+      if (!action.startsWith(prefix)) continue;
+      const spec = this.registry.spec(action.slice(prefix.length));
+      if (spec !== void 0) return {
+        name: spec.name,
+        ...spec.presentation !== void 0 ? {
+          presentation: spec.presentation
+        } : {}
+      };
+    }
+    return void 0;
+  }
   /** The roles policy a turn's tools are gated by (the agent's own). */
   rolesPolicyFor(input) {
     return this.deps.forAgent(input.agentName).rolesPolicy;
@@ -2376,6 +2468,7 @@ ${body}
           })
         } : {}
       };
+      live.turn.setBaseline(await this.sessionUsage(live.client, handle.sessionId));
       await live.client.session.prompt({
         sessionID: handle.sessionId,
         text: prompt.text,
@@ -2455,12 +2548,23 @@ ${body}
     await live.turn.decide(ask, reply, {
       tellOpenCode: false
     });
+    live.turn.setBaseline(await this.sessionUsage(live.client, handle.sessionId));
     await live.client.session.prompt({
       sessionID: handle.sessionId,
       text: note
     });
     return handle;
   }
+  /** What a session spent so far (`session.get`), or nothing when OpenCode does not say. */
+  async sessionUsage(client, sessionId) {
+    try {
+      return await client.session.get?.({
+        sessionID: sessionId
+      });
+    } catch {
+      return void 0;
+    }
+  }
   /** Interrupt the thread's session (cancel). */
   async interrupt(input) {
     const known = await this.sessions.get(input.threadId);
@@ -2496,6 +2600,9 @@ ${body}
           agentName: input.agentName
         } : {}
       }), "approvalFor"),
+      // An app tool reaches OpenCode as `<server>.<name>` / `<server>_<name>`: its own presentation
+      // words the approval card. OpenCode's built-ins (`bash`, `edit`) have none.
+      approvalPresentation: /* @__PURE__ */ __name((action) => this.presentationOf(action), "approvalPresentation"),
       modelLabel: input.model ?? "opencode",
       priceStep: /* @__PURE__ */ __name((step) => this.priceStep(step), "priceStep"),
       ...spent !== void 0 ? {