@dudousxd/nestjs-agent-opencode 0.2.0 → 0.2.1

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"
@@ -1257,9 +1292,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);
     }
@@ -2376,6 +2441,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 +2521,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);