@dudousxd/nestjs-agent-opencode 0.2.0 → 0.2.1

package/dist/{engine-JnBbcRxh.d.cts → engine-0YkBLWZR.d.cts}

@@ -40,6 +40,9 @@ interface OpenCodeClient {
             metadata?: {
                 readonly [key: string]: OpenCodeJson;
             };
+            /** What the session spent so far, every model call OpenCode made for it (the title too). */
+            cost?: number;
+            tokens?: OpenCodeTokens;
         }>;
         /** Resolves when the session goes idle. Optional: a safety net for a missed terminal event. */
         wait?(args: {
@@ -204,6 +207,16 @@ interface OpenCodeFormField {
     /** The user may type their own answer instead of picking one of `options`. */
     custom?: boolean;
 }
+/** A token count as OpenCode reports it: `input` is the uncached input, the cache beside it. */
+interface OpenCodeTokens {
+    input: number;
+    output: number;
+    reasoning?: number;
+    cache?: {
+        read: number;
+        write: number;
+    };
+}
 
 /** How an OpenCode execution ended. */
 type TurnOutcome = {
@@ -344,6 +357,10 @@ declare class OpenCodeTurn {
     private reported;
     private priced;
     private model;
+    /** What the session had spent when this turn prompted it; what OpenCode reported since. */
+    private baseline;
+    private readonly seen;
+    private compacted;
     private stepOpen;
     private sawText;
     private separator;
@@ -352,6 +369,16 @@ declare class OpenCodeTurn {
     private ended;
     private stepError;
     constructor(a: OpenCodeTurnArgs);
+    /**
+     * 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: {
+        cost?: number;
+        tokens?: OpenCodeTokens;
+    } | undefined): void;
     /** What the run spent so far: carried from before this turn object, plus what it saw. */
     totalUsage(): OpenCodeUsage;
     get sessionId(): string;
@@ -418,6 +445,8 @@ declare class OpenCodeTurn {
     private onForm;
     private answered;
     private addResult;
+    /** What the session spent since the baseline that no event of this turn reported. */
+    private unreported;
     private end;
 }
 /**
@@ -889,6 +918,8 @@ declare class OpenCodeTurns implements OnApplicationShutdown {
      */
     reply(runId: string, input: AgentRunInput, handle: SessionHandle, ask: PendingAsk, reply: HumanReply, spent?: OpenCodeUsage): Promise<SessionHandle>;
     private continueAfterRestart;
+    /** What a session spent so far (`session.get`), or nothing when OpenCode does not say. */
+    private sessionUsage;
     /** Interrupt the thread's session (cancel). */
     interrupt(input: AgentRunInput): Promise<void>;
     private ensureLive;

package/dist/{engine-JnBbcRxh.d.ts → engine-0YkBLWZR.d.ts}

@@ -40,6 +40,9 @@ interface OpenCodeClient {
             metadata?: {
                 readonly [key: string]: OpenCodeJson;
             };
+            /** What the session spent so far, every model call OpenCode made for it (the title too). */
+            cost?: number;
+            tokens?: OpenCodeTokens;
         }>;
         /** Resolves when the session goes idle. Optional: a safety net for a missed terminal event. */
         wait?(args: {
@@ -204,6 +207,16 @@ interface OpenCodeFormField {
     /** The user may type their own answer instead of picking one of `options`. */
     custom?: boolean;
 }
+/** A token count as OpenCode reports it: `input` is the uncached input, the cache beside it. */
+interface OpenCodeTokens {
+    input: number;
+    output: number;
+    reasoning?: number;
+    cache?: {
+        read: number;
+        write: number;
+    };
+}
 
 /** How an OpenCode execution ended. */
 type TurnOutcome = {
@@ -344,6 +357,10 @@ declare class OpenCodeTurn {
     private reported;
     private priced;
     private model;
+    /** What the session had spent when this turn prompted it; what OpenCode reported since. */
+    private baseline;
+    private readonly seen;
+    private compacted;
     private stepOpen;
     private sawText;
     private separator;
@@ -352,6 +369,16 @@ declare class OpenCodeTurn {
     private ended;
     private stepError;
     constructor(a: OpenCodeTurnArgs);
+    /**
+     * 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: {
+        cost?: number;
+        tokens?: OpenCodeTokens;
+    } | undefined): void;
     /** What the run spent so far: carried from before this turn object, plus what it saw. */
     totalUsage(): OpenCodeUsage;
     get sessionId(): string;
@@ -418,6 +445,8 @@ declare class OpenCodeTurn {
     private onForm;
     private answered;
     private addResult;
+    /** What the session spent since the baseline that no event of this turn reported. */
+    private unreported;
     private end;
 }
 /**
@@ -889,6 +918,8 @@ declare class OpenCodeTurns implements OnApplicationShutdown {
      */
     reply(runId: string, input: AgentRunInput, handle: SessionHandle, ask: PendingAsk, reply: HumanReply, spent?: OpenCodeUsage): Promise<SessionHandle>;
     private continueAfterRestart;
+    /** What a session spent so far (`session.get`), or nothing when OpenCode does not say. */
+    private sessionUsage;
     /** Interrupt the thread's session (cancel). */
     interrupt(input: AgentRunInput): Promise<void>;
     private ensureLive;

package/dist/index.cjs

@@ -395,6 +395,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;
@@ -406,6 +417,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);
@@ -662,6 +686,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;
@@ -831,6 +859,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"
@@ -1298,9 +1333,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);
     }
@@ -2417,6 +2482,7 @@ ${body}
           })
         } : {}
       };
+      live.turn.setBaseline(await this.sessionUsage(live.client, handle.sessionId));
       await live.client.session.prompt({
         sessionID: handle.sessionId,
         text: prompt.text,
@@ -2496,12 +2562,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);