@dudousxd/nestjs-agent-opencode 0.1.2 → 0.2.1

package/dist/durable/index.cjs

@@ -249,6 +249,41 @@ function toFormAnswer(form, answers = {}) {
 __name(toFormAnswer, "toFormAnswer");
 
 // src/turn.ts
+function emptyUsage() {
+  return {
+    inputTokens: 0,
+    outputTokens: 0,
+    cacheReadTokens: 0,
+    cacheWriteTokens: 0,
+    reasoningTokens: 0,
+    costUsd: 0
+  };
+}
+__name(emptyUsage, "emptyUsage");
+function addUsage(a, b) {
+  const x = a ?? emptyUsage();
+  const y = b ?? emptyUsage();
+  return {
+    inputTokens: x.inputTokens + (y.inputTokens ?? 0),
+    outputTokens: x.outputTokens + (y.outputTokens ?? 0),
+    cacheReadTokens: (x.cacheReadTokens ?? 0) + (y.cacheReadTokens ?? 0),
+    cacheWriteTokens: (x.cacheWriteTokens ?? 0) + (y.cacheWriteTokens ?? 0),
+    reasoningTokens: (x.reasoningTokens ?? 0) + (y.reasoningTokens ?? 0),
+    costUsd: x.costUsd + (y.costUsd ?? 0)
+  };
+}
+__name(addUsage, "addUsage");
+function subUsage(a, b) {
+  return {
+    inputTokens: a.inputTokens - b.inputTokens,
+    outputTokens: a.outputTokens - b.outputTokens,
+    cacheReadTokens: a.cacheReadTokens - b.cacheReadTokens,
+    cacheWriteTokens: a.cacheWriteTokens - b.cacheWriteTokens,
+    reasoningTokens: a.reasoningTokens - b.reasoningTokens,
+    costUsd: a.costUsd - b.costUsd
+  };
+}
+__name(subUsage, "subUsage");
 var ASK_TOOL_NAME = "ask";
 var FAILED_STATUSES = /* @__PURE__ */ new Set([
   "error",
@@ -314,11 +349,22 @@ var OpenCodeTurn = class {
   hidden = /* @__PURE__ */ new Set();
   milestones = [];
   waiting;
-  usage = {
-    inputTokens: 0,
-    outputTokens: 0
+  /** What this turn object saw spent, and how much of it a milestone already reported. */
+  spent = emptyUsage();
+  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
   };
-  costUsd;
+  compacted = false;
   stepOpen = false;
   sawText = false;
   separator = false;
@@ -328,6 +374,24 @@ var OpenCodeTurn = class {
   stepError;
   constructor(a) {
     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);
   }
   get sessionId() {
     return this.a.sessionId;
@@ -410,7 +474,15 @@ var OpenCodeTurn = class {
       this.chain = this.chain.then(() => ask.kind === "approval" ? this.decided(ask, reply, tell) : this.answered(ask, reply, tell)).then(resolve, reject);
     });
   }
-  reach(milestone) {
+  reach(reached) {
+    const usage = subUsage(this.spent, this.reported);
+    this.reported = {
+      ...this.spent
+    };
+    const milestone = {
+      ...reached,
+      usage
+    };
     const waiting = this.waiting;
     if (waiting !== void 0) {
       this.waiting = void 0;
@@ -566,9 +638,26 @@ var OpenCodeTurn = class {
     }
   }
   async onEvent(e) {
-    if (this.ended) return;
     const d = e.data ?? {};
+    if (e.type === "session.usage.recorded") {
+      await this.usageRecorded(d);
+      return;
+    }
+    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;
+        if (typeof model?.id === "string" && typeof model.providerID === "string") this.model = {
+          providerID: model.providerID,
+          id: model.id
+        };
+        return;
+      }
       case "session.text.delta": {
         const delta = typeof d.delta === "string" ? d.delta : "";
         if (!delta) return;
@@ -722,42 +811,70 @@ ${delta}` : delta;
       });
     }
   }
-  async stepEnded(d) {
-    const usage = {
-      inputTokens: Number(d.tokens?.input) || 0,
-      outputTokens: Number(d.tokens?.output) || 0,
-      ...Number(d.tokens?.cache?.read) ? {
-        cacheReadTokens: Number(d.tokens.cache.read)
-      } : {},
-      ...Number(d.tokens?.cache?.write) ? {
-        cacheWriteTokens: Number(d.tokens.cache.write)
-      } : {}
-    };
-    const costUsd = typeof d.cost === "number" ? d.cost : void 0;
-    this.usage.inputTokens += usage.inputTokens;
-    this.usage.outputTokens += usage.outputTokens;
-    if (costUsd !== void 0) this.costUsd = (this.costUsd ?? 0) + costUsd;
+  modelId() {
+    return this.model !== void 0 ? `${this.model.providerID}/${this.model.id}` : this.a.modelLabel;
+  }
+  /** One model call's usage and cost, into the ledger and the run's total. */
+  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"
+    } : {};
+    let cost = fallback;
+    if (this.a.priceStep !== void 0) {
+      cost = await this.a.priceStep({
+        model: this.model,
+        usage,
+        reportedCostUsd
+      }).catch(() => fallback);
+    }
+    this.spent = addUsage(this.spent, {
+      inputTokens: usage.inputTokens,
+      outputTokens: usage.outputTokens,
+      cacheReadTokens: usage.cacheReadTokens ?? 0,
+      cacheWriteTokens: usage.cacheWriteTokens ?? 0,
+      reasoningTokens: usage.reasoningTokens ?? 0,
+      costUsd: cost.costUsd ?? 0
+    });
+    if (cost.costUsd !== void 0) this.priced = true;
     await this.a.store.recordUsage({
       threadId: this.a.input.threadId,
       actorRef: this.a.input.actor.id,
-      modelId: this.a.modelLabel,
-      purpose: "chat",
+      modelId: this.modelId(),
+      purpose,
       usage,
-      ...costUsd !== void 0 ? {
-        costUsd,
-        costSource: "provider"
-      } : {}
+      ...cost
     });
+    return {
+      usage,
+      cost
+    };
+  }
+  /** `session.usage.recorded`: a call OpenCode made besides the steps (the title, a compaction). */
+  async usageRecorded(d) {
+    await this.spend(d, d.source === "title" ? "title" : "history_summary");
+  }
+  async stepEnded(d) {
+    const { usage, cost } = await this.spend(d, "chat");
     if (!this.stepOpen) return;
     this.stepOpen = false;
     await this.write({
       kind: "step-finish",
       usage,
-      costUsd: costUsd ?? null,
+      costUsd: cost.costUsd ?? null,
       ...this.segment.reasoningMs > 0 ? {
         reasoningMs: this.segment.reasoningMs
       } : {},
-      model: this.a.modelLabel
+      model: this.modelId()
     });
   }
   /**
@@ -776,12 +893,7 @@ ${delta}` : delta;
       content: s.text,
       runId: this.a.runId,
       ...final ? {
-        usage: {
-          ...this.usage,
-          ...this.costUsd !== void 0 ? {
-            costUsd: this.costUsd
-          } : {}
-        }
+        usage: this.messageUsage()
       } : {},
       ...this.a.input.agentName !== void 0 ? {
         agentName: this.a.input.agentName
@@ -809,6 +921,26 @@ ${delta}` : delta;
     ]);
     return message.id;
   }
+  /** The run's usage as its last message carries it: the whole run, cache tokens included. */
+  messageUsage() {
+    const total = this.totalUsage();
+    return {
+      inputTokens: total.inputTokens,
+      outputTokens: total.outputTokens,
+      ...total.cacheReadTokens > 0 ? {
+        cacheReadTokens: total.cacheReadTokens
+      } : {},
+      ...total.cacheWriteTokens > 0 ? {
+        cacheWriteTokens: total.cacheWriteTokens
+      } : {},
+      ...total.reasoningTokens > 0 ? {
+        reasoningTokens: total.reasoningTokens
+      } : {},
+      ...this.priced || (this.a.carried?.costUsd ?? 0) > 0 ? {
+        costUsd: total.costUsd
+      } : {}
+    };
+  }
   /** A request recorded by an earlier process (a turn resumed after a restart). */
   async alreadyRecorded(id) {
     return (await this.a.store.toolCallApproval?.(id) ?? null) !== null;
@@ -1160,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);
     }
@@ -1178,6 +1340,35 @@ ${delta}` : delta;
     });
   }
 };
+function modelOfLabel(label) {
+  const slash = label?.indexOf("/") ?? -1;
+  if (label === void 0 || slash <= 0 || slash === label.length - 1) return void 0;
+  return {
+    providerID: label.slice(0, slash),
+    id: label.slice(slash + 1)
+  };
+}
+__name(modelOfLabel, "modelOfLabel");
+function usageOf(tokens) {
+  const n = /* @__PURE__ */ __name((v) => typeof v === "number" && Number.isFinite(v) && v > 0 ? v : 0, "n");
+  const read = n(tokens?.cache?.read);
+  const write = n(tokens?.cache?.write);
+  const reasoning = n(tokens?.reasoning);
+  return {
+    inputTokens: n(tokens?.input) + read + write,
+    outputTokens: n(tokens?.output),
+    ...read > 0 ? {
+      cacheReadTokens: read
+    } : {},
+    ...write > 0 ? {
+      cacheWriteTokens: write
+    } : {},
+    ...reasoning > 0 ? {
+      reasoningTokens: reasoning
+    } : {}
+  };
+}
+__name(usageOf, "usageOf");
 
 // src/mcp.ts
 var LOOP_SERVED_KINDS = /* @__PURE__ */ new Set([
@@ -1609,7 +1800,7 @@ var OpenCodeTurns = class {
   spent = /* @__PURE__ */ new Set();
   /** When the tools endpoint was last registered for a location (`server|boot|directory|actor`). */
   toolsIssued = /* @__PURE__ */ new Map();
-  constructor(host, sessions, settings, store, sink, deps, registry, skills, memory, queue, toolsTokens2) {
+  constructor(host, sessions, settings, store, sink, deps, registry, skills, memory, queue, toolsTokens2, pricingStore, agentOptions) {
     this.host = host;
     this.sessions = sessions;
     this.settings = settings;
@@ -1621,6 +1812,30 @@ var OpenCodeTurns = class {
     this.memory = memory;
     this.queue = queue;
     this.toolsTokens = toolsTokens2;
+    this.prices = new import_nestjs_agent_core4.ModelPriceResolver({
+      pricingStore,
+      catalog: agentOptions?.priceCatalog,
+      log: {
+        info: /* @__PURE__ */ __name((message) => this.logger.log(message), "info"),
+        warn: /* @__PURE__ */ __name((message) => this.logger.warn(message), "warn")
+      }
+    });
+  }
+  prices;
+  /**
+  * What a model call OpenCode made cost, by the same rule the library's loop records its own steps
+  * at: a reported figure wins, else an estimate off the model's price — see
+  * {@link OpenCodeEngineSettings.cost}.
+  */
+  async priceStep(step) {
+    const { model, usage, reportedCostUsd } = step;
+    const tokens = usage.inputTokens + usage.outputTokens;
+    const reported = reportedCostUsd !== void 0 && (reportedCostUsd > 0 || tokens === 0);
+    if (reported && this.settings.cost !== "estimate") {
+      return (0, import_nestjs_agent_core4.resolveUsageCost)(usage, reportedCostUsd, void 0);
+    }
+    const price = model !== void 0 && tokens > 0 ? await this.prices.priceFor(priceRef(model)) : void 0;
+    return (0, import_nestjs_agent_core4.resolveUsageCost)(usage, price === void 0 ? reportedCostUsd : void 0, price);
   }
   /** The tools server's name in OpenCode. */
   get toolsServer() {
@@ -2210,8 +2425,8 @@ ${body}
   }
   // ---- prompt / observe / reply --------------------------------------------------------------
   /** Start listening to the session (so nothing it says is missed), then send the user message. */
-  async prompt(runId, input, handle) {
-    const live = await this.ensureLive(runId, input, handle, false);
+  async prompt(runId, input, handle, spent) {
+    const live = await this.ensureLive(runId, input, handle, false, spent);
     try {
       const prompt = await this.host.promptFor?.({
         input,
@@ -2226,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,
@@ -2241,9 +2457,12 @@ ${body}
   * Wait for the turn's next milestone. In a process that was not following the turn (a resumed
   * durable run), the turn is rebuilt and first catches up on requests OpenCode raised meanwhile;
   * `session.wait` is the safety net for a terminal event that was missed.
+  *
+  * `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.
   */
-  async observe(runId, input, handle) {
-    const live = await this.ensureLive(runId, input, handle, true);
+  async observe(runId, input, handle, spent) {
+    const live = await this.ensureLive(runId, input, handle, true, spent);
     const { turn, client } = live;
     if (turn.hasMilestone()) return this.reached(runId, input, handle, await turn.next());
     let done = false;
@@ -2282,32 +2501,43 @@ ${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) {
+  async reply(runId, input, handle, ask, reply, spent) {
     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);
+      return this.continueAfterRestart(runId, input, server, ask, reply, spent);
     }
-    const live = await this.ensureLive(runId, input, handle, false);
+    const live = await this.ensureLive(runId, input, handle, false, spent);
     await live.turn.decide(ask, reply);
     return handle;
   }
-  async continueAfterRestart(runId, input, server, ask, reply) {
+  async continueAfterRestart(runId, input, server, ask, reply, spent) {
     const approved = "approved" in reply && reply.approved === true;
     const note = ask.kind === "approval" ? approved ? `The user approved the action ${ask.action} you asked permission for. Continue the task.` : `The user did not approve the action ${ask.action}. Continue without it and explain.` : `The user answered your question: ${JSON.stringify("answers" in reply ? reply.answers : {})}. Continue.`;
     const thread = await this.store.getThread(input.threadId);
     const handle = await this.createSession(runId, input, server, thread?.messages ?? [], note);
     await this.refreshInstructions(runId, input, server.client, handle.sessionId);
     this.drop(runId);
-    const live = await this.ensureLive(runId, input, handle, false);
+    const live = await this.ensureLive(runId, input, handle, false, spent);
     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);
@@ -2318,7 +2548,7 @@ ${body}
       sessionID: known.sessionId
     });
   }
-  async ensureLive(runId, input, handle, catchUp) {
+  async ensureLive(runId, input, handle, catchUp, spent) {
     const current = this.live.get(runId);
     if (current !== void 0 && current.handle.sessionId === handle.sessionId) return current;
     current?.stop();
@@ -2344,6 +2574,10 @@ ${body}
         } : {}
       }), "approvalFor"),
       modelLabel: input.model ?? "opencode",
+      priceStep: /* @__PURE__ */ __name((step) => this.priceStep(step), "priceStep"),
+      ...spent !== void 0 ? {
+        carried: spent
+      } : {},
       logger: this.logger,
       onGranted: /* @__PURE__ */ __name((action, id) => {
         const grants = this.grants.get(runId) ?? [];
@@ -2390,20 +2624,14 @@ ${body}
     }
     return milestone;
   }
-  /** What the run produced, as the host's settle hooks see it. */
-  async runResult(runId, input, outcome, durationMs) {
+  /**
+  * What the run produced, as the host's settle hooks see it. `usage` is what the run spent — the
+  * runner's sum of its milestones' usage, which a resumed run reads back from its journal — else
+  * what the turn this process follows saw.
+  */
+  async runResult(runId, input, outcome, durationMs, usage) {
     const thread = await this.store.getThread(input.threadId);
     const messages = (thread?.messages ?? []).filter((m) => m.role === "assistant" && m.runId === runId);
-    const usage = {
-      inputTokens: 0,
-      outputTokens: 0,
-      costUsd: 0
-    };
-    for (const m of messages) {
-      usage.inputTokens += m.usage?.inputTokens ?? 0;
-      usage.outputTokens += m.usage?.outputTokens ?? 0;
-      usage.costUsd += m.usage?.costUsd ?? 0;
-    }
     return {
       runId,
       input,
@@ -2448,15 +2676,31 @@ ${body}
       this.logger.warn(`onSettled failed: ${errorText(error, "error")}`);
     }
   }
-  /** End the run's stream and bookkeeping for how its execution ended. */
-  async settle(runId, input, outcome, durationMs) {
+  /**
+  * What the run spent: the runner's sum of its milestones, or what the turn this process follows
+  * saw (which starts from that sum) when it saw more — a run that failed or was cancelled between
+  * two milestones.
+  */
+  spentBy(runId, spent) {
+    const seen = this.live.get(runId)?.turn.totalUsage();
+    if (spent === void 0) return seen ?? emptyUsage();
+    if (seen === void 0) return spent;
+    const tokens = /* @__PURE__ */ __name((u) => u.inputTokens + u.outputTokens, "tokens");
+    return tokens(seen) > tokens(spent) ? seen : spent;
+  }
+  /**
+  * End the run's stream and bookkeeping for how its execution ended. `spent` is what the run spent
+  * (the sum of its milestones' `usage`); omit → what the turn this process follows saw.
+  */
+  async settle(runId, input, outcome, durationMs, spent) {
     if (outcome.status === "failed") {
-      await this.settleFailed(runId, input, outcome.error, durationMs);
+      await this.settleFailed(runId, input, outcome.error, durationMs, spent);
       return;
     }
+    const usage = this.spentBy(runId, spent);
     this.forget(runId);
     const writer = await this.sink.open(runId);
-    const result = await this.runResult(runId, input, outcome, durationMs);
+    const result = await this.runResult(runId, input, outcome, durationMs, usage);
     await this.amend(writer, result);
     if (outcome.status === "interrupted") {
       this.logger.log(`agent run ${runId} cancelled`);
@@ -2484,13 +2728,14 @@ ${body}
     }
     await this.settled(result);
   }
-  async settleFailed(runId, input, error, durationMs = 0) {
+  async settleFailed(runId, input, error, durationMs = 0, spent) {
+    const usage = this.spentBy(runId, spent);
     this.forget(runId);
     const writer = await this.sink.open(runId);
     const result = await this.runResult(runId, input, {
       status: "failed",
       error
-    }, durationMs);
+    }, durationMs, usage);
     const worded = (await this.amend(writer, result)).error;
     const message = worded ?? (0, import_nestjs_agent_core4.streamFailure)(new Error(error)).message;
     this.logger.error(`agent run ${runId} failed: ${error}`);
@@ -2560,6 +2805,10 @@ OpenCodeTurns = _ts_decorate2([
   _ts_param2(9, (0, import_common4.Inject)(import_nestjs_agent.AGENT_CHAT_QUEUE)),
   _ts_param2(10, (0, import_common4.Optional)()),
   _ts_param2(10, (0, import_common4.Inject)(OPENCODE_TOOLS_TOKENS)),
+  _ts_param2(11, (0, import_common4.Optional)()),
+  _ts_param2(11, (0, import_common4.Inject)(import_nestjs_agent_core4.AGENT_PRICING_STORE)),
+  _ts_param2(12, (0, import_common4.Optional)()),
+  _ts_param2(12, (0, import_common4.Inject)(import_nestjs_agent_core4.AGENT_OPTIONS)),
   _ts_metadata2("design:type", Function),
   _ts_metadata2("design:paramtypes", [
     typeof OpenCodeHost === "undefined" ? Object : OpenCodeHost,
@@ -2572,6 +2821,8 @@ OpenCodeTurns = _ts_decorate2([
     typeof SkillsConfig === "undefined" ? Object : SkillsConfig,
     typeof MemoryConfig === "undefined" ? Object : MemoryConfig,
     typeof ChatQueueService === "undefined" ? Object : ChatQueueService,
+    Object,
+    typeof AgentPricingStore === "undefined" ? Object : AgentPricingStore,
     Object
   ])
 ], OpenCodeTurns);
@@ -2614,6 +2865,19 @@ function uiEmitter(scope, push) {
   };
 }
 __name(uiEmitter, "uiEmitter");
+function priceRef(model) {
+  const aliases = [
+    model.id
+  ];
+  const tail = model.id.slice(model.id.lastIndexOf("/") + 1);
+  if (tail !== model.id && (0, import_nestjs_agent_core4.parseBedrockModelId)(tail) !== void 0) aliases.push(tail);
+  return {
+    modelId: `${model.providerID}/${model.id}`,
+    provider: model.providerID,
+    aliases
+  };
+}
+__name(priceRef, "priceRef");
 
 // src/runner.ts
 function _ts_decorate3(decorators, target, key, desc) {
@@ -2715,18 +2979,20 @@ var OpenCodeAgentRunner = class {
   async run(runId, input) {
     const started = Date.now();
     this.inputs.set(runId, input);
+    let spent = emptyUsage();
     try {
       let handle = await this.turns.begin(runId, input);
       if (this.cancelled.has(runId)) throw new import_nestjs_agent_core5.RunCancelledError();
-      await this.turns.prompt(runId, input, handle);
+      await this.turns.prompt(runId, input, handle, spent);
       for (; ; ) {
-        const milestone = await this.turns.observe(runId, input, handle);
+        const milestone = await this.turns.observe(runId, input, handle, spent);
+        spent = addUsage(spent, milestone.usage);
         if (milestone.kind === "finished") {
-          await this.turns.settle(runId, input, milestone.outcome, Date.now() - started);
+          await this.turns.settle(runId, input, milestone.outcome, Date.now() - started, spent);
           return;
         }
         const reply = await this.park(runId, milestone.ask.id, milestone.ask.kind === "approval" ? "approval" : "answers", milestone.timeoutMs);
-        handle = await this.turns.reply(runId, input, handle, milestone.ask, reply);
+        handle = await this.turns.reply(runId, input, handle, milestone.ask, reply, spent);
       }
     } catch (error) {
       if (error instanceof import_nestjs_agent_core5.RunCancelledError) {
@@ -2736,7 +3002,7 @@ var OpenCodeAgentRunner = class {
         }, Date.now() - started);
         return;
       }
-      await this.turns.settleFailed(runId, input, errorText(error, "the turn failed"));
+      await this.turns.settleFailed(runId, input, errorText(error, "the turn failed"), Date.now() - started);
     } finally {
       this.inputs.delete(runId);
     }
@@ -2908,6 +3174,7 @@ var OpenCodeRunWorkflow = class {
     this.runs = runs;
   }
   async run(ctx, input) {
+    let spent = emptyUsage();
     try {
       const begun = await ctx.localStep("begin", async () => ({
         handle: await this.turns.begin(ctx.runId, input),
@@ -2915,15 +3182,18 @@ var OpenCodeRunWorkflow = class {
       }));
       let handle = begun.handle;
       await ctx.localStep("prompt", async () => {
-        await this.turns.prompt(ctx.runId, input, handle);
+        await this.turns.prompt(ctx.runId, input, handle, spent);
         return true;
       });
       for (let n = 0; ; n += 1) {
-        const milestone = await ctx.localStep(`observe:${n}`, () => this.turns.observe(ctx.runId, input, handle));
+        const before = spent;
+        const milestone = await ctx.localStep(`observe:${n}`, () => this.turns.observe(ctx.runId, input, handle, before));
+        spent = addUsage(spent, milestone.usage);
+        const total = spent;
         if (milestone.kind === "finished") {
           await ctx.localStep("finish", async () => {
             if (await this.cancelled(ctx.runId)) this.turns.drop(ctx.runId);
-            else await this.turns.settle(ctx.runId, input, milestone.outcome, Date.now() - begun.startedAt);
+            else await this.turns.settle(ctx.runId, input, milestone.outcome, Date.now() - begun.startedAt, total);
             return true;
           });
           return {
@@ -2943,12 +3213,12 @@ var OpenCodeRunWorkflow = class {
           };
         }
         const ask = milestone.ask;
-        handle = await ctx.localStep(`reply:${n}`, () => this.turns.reply(ctx.runId, input, handle, ask, reply));
+        handle = await ctx.localStep(`reply:${n}`, () => this.turns.reply(ctx.runId, input, handle, ask, reply, total));
       }
     } catch (error) {
       if ((0, import_nestjs_durable_core.isWorkflowControlFlowSignal)(error)) throw error;
       await ctx.localStep("fail", async () => {
-        await this.turns.settleFailed(ctx.runId, input, errorText(error, "the turn failed"));
+        await this.turns.settleFailed(ctx.runId, input, errorText(error, "the turn failed"), 0, spent);
         return true;
       });
       return {