fix: preserve gateway billing metadata

Author: btriapitsyn

src/gateway-types.ts

@@ -225,3 +225,15 @@ export function addUsage(a: WireUsage, b: WireUsage): WireUsage {
     ...(costUsd > 0 ? { costUsd } : {}),
   };
 }
+
+/** Extract the authoritative billed USD amount from gateway metadata events. */
+export function costFromProviderMetadata(event: unknown): number | undefined {
+  if (!event || typeof event !== "object") return undefined;
+  const providerMetadata = (event as { providerMetadata?: unknown }).providerMetadata;
+  if (!providerMetadata || typeof providerMetadata !== "object") return undefined;
+  const gateway = (providerMetadata as { gateway?: unknown }).gateway;
+  if (!gateway || typeof gateway !== "object") return undefined;
+  const raw = (gateway as { cost?: unknown }).cost;
+  const cost = typeof raw === "number" ? raw : typeof raw === "string" ? Number(raw) : NaN;
+  return Number.isFinite(cost) && cost >= 0 ? cost : undefined;
+}

src/gateway.ts

@@ -8,6 +8,7 @@ import { spawnSync } from "node:child_process";
 import { COMMAND_CODE_GATEWAY_VERSION } from "./constants.js";
 import {
   GENERATE_ROUTE,
+  costFromProviderMetadata,
   usageFromFinishEvent,
   getApiBaseUrl,
   type GenerateBody,
@@ -440,6 +441,8 @@ export async function* streamGenerate(
     let finished = false;
     let retry = false;
     let terminalError = false;
+    let pendingFinish: Extract<GatewayMappedEvent, { kind: "finish" }> | null = null;
+    let providerCostUsd: number | undefined;
     try {
       for await (const line of readNdjsonLines(stream)) {
         let parsed: StreamEvent;
@@ -464,6 +467,10 @@ export async function* streamGenerate(
             break;
           }
         }
+        if (parsed.type === "provider-metadata") {
+          providerCostUsd = costFromProviderMetadata(parsed) ?? providerCostUsd;
+          continue;
+        }
         const mapped = mapStreamEvent(parsed);
         if (
           mapped.kind === "text" ||
@@ -473,10 +480,18 @@ export async function* streamGenerate(
         ) {
           emittedVisible = true;
         }
-        if (mapped.kind === "finish") finished = true;
+        if (mapped.kind === "finish") {
+          finished = true;
+          pendingFinish = mapped;
+          continue;
+        }
         if (mapped.kind === "error") terminalError = true;
         yield mapped;
       }
+      if (pendingFinish) {
+        if (providerCostUsd !== undefined) pendingFinish.usage.costUsd = providerCostUsd;
+        yield pendingFinish;
+      }
     } catch (err) {
       if (params.signal?.aborted) throw err;
       if (!emittedVisible && attempt < MODEL_CALL_MAX_ATTEMPTS - 1) {

src/index.ts

@@ -77,6 +77,40 @@ function zeroCost() {
   };
 }
 
+function billedCostUsd(value: unknown): number | undefined {
+  if (!value || typeof value !== "object") return undefined;
+  const usage = (value as { usage?: unknown }).usage;
+  if (!usage || typeof usage !== "object") return undefined;
+  const raw = (usage as { cost_usd?: unknown }).cost_usd;
+  const cost = typeof raw === "number" ? raw : typeof raw === "string" ? Number(raw) : NaN;
+  return Number.isFinite(cost) && cost >= 0 ? cost : undefined;
+}
+
+/** Bridge Command Code's exact billed USD into OpenCode's supported billed-cost metadata. */
+export function commandCodeMetadataExtractor() {
+  const metadata = (value: unknown) => {
+    const cost = billedCostUsd(value);
+    if (cost === undefined) return undefined;
+    return { copilot: { totalNanoAiu: Math.round(cost * 100_000_000_000) } };
+  };
+  return {
+    async extractMetadata({ parsedBody }: { parsedBody: unknown }) {
+      return metadata(parsedBody);
+    },
+    createStreamExtractor() {
+      let result: ReturnType<typeof metadata>;
+      return {
+        processChunk(chunk: unknown) {
+          result = metadata(chunk) ?? result;
+        },
+        buildMetadata() {
+          return result;
+        },
+      };
+    },
+  };
+}
+
 function buildProviderModel(
   model: CommandModel,
   id: string,
@@ -210,6 +244,7 @@ function ensureProviderConfig(
       baseURL,
       apiKey: "command-code-proxy",
       includeUsage: true,
+      metadataExtractor: commandCodeMetadataExtractor(),
       ...existingOptions,
     },
     models: {
@@ -329,6 +364,7 @@ export const CommandCodePlugin: Plugin = async (
         return {
           baseURL: getCommandProxyBaseUrl(),
           apiKey: "command-code-proxy",
+          metadataExtractor: commandCodeMetadataExtractor(),
           async fetch(
             requestInput: RequestInfo | URL,
             init?: RequestInit,

src/prompt.ts

@@ -326,6 +326,7 @@ export function openaiMessagesToWire(
 ): { system: string; messages: WireMessage[] } {
   const systemParts: string[] = [];
   const wire: WireMessage[] = [];
+  const toolNames = new Map<string, string>();
 
   for (const msg of messages) {
     const role = msg.role || "";
@@ -350,6 +351,7 @@ export function openaiMessagesToWire(
           const id = tc.id || "";
           const name = tc.function?.name || "";
           if (!id || !name) continue;
+          toolNames.set(id, name);
           let input: Record<string, unknown> = {};
           try {
             input = JSON.parse(tc.function?.arguments || "{}") as Record<
@@ -374,13 +376,19 @@ export function openaiMessagesToWire(
     if (role === "tool") {
       const toolCallId = msg.tool_call_id || "";
       if (!toolCallId) continue;
+      const toolName = msg.name || toolNames.get(toolCallId) || "";
+      if (!toolName) {
+        throw new Error(
+          `Tool result ${toolCallId} has no matching assistant tool call`,
+        );
+      }
       wire.push({
         role: "tool",
         content: [
           {
             type: "tool-result",
             toolCallId,
-            toolName: msg.name ? toWireName(msg.name) : "",
+            toolName: toWireName(toolName),
             output: {
               type: "text",
               value: extractTextContent(msg.content),

src/proxy.ts

@@ -619,78 +619,78 @@ function safeParse(raw: string): Record<string, unknown> {
   }
 }
 
-function streamOpenAIResponse(
+function upstreamErrorResponse(message: string, status = 502): Response {
+  return Response.json(
+    {
+      error: {
+        message,
+        type: "upstream_error",
+        code: "provider_error",
+      },
+    },
+    { status },
+  );
+}
+
+async function streamOpenAIResponse(
   events: AsyncIterable<unknown>,
   model: string,
   stream: boolean,
   bridge: ParkedBridge,
   includeUsage: boolean,
-): Response {
+): Promise<Response> {
   const completionId = stableCompletionId(bridge.id);
   const created = Math.floor(Date.now() / 1000);
 
   if (!stream) {
-    const bodyStream = new ReadableStream<Uint8Array>({
-      async start(controller) {
-        try {
-          let content = "";
-          let reasoning = "";
-          const toolCalls: ParkedToolCall[] = [];
-          let usage = emptyUsage();
-          for await (const event of events) {
-            const mapped = normalizeEvent(event);
-            if (mapped.kind === "park") toolCalls.push(...mapped.tools);
-            else if (mapped.kind === "text") content += mapped.text;
-            else if (mapped.kind === "reasoning") reasoning += mapped.text;
-            else if (mapped.kind === "finish") usage = mapped.usage;
-            else if (mapped.kind === "error") content += `\n\n[command-code error] ${mapped.text}`;
-          }
-          const payload = {
-            id: completionId,
-            object: "chat.completion",
-            created,
-            model,
-            choices: [
-              {
-                index: 0,
-                message: {
-                  role: "assistant",
-                  content,
-                  ...(reasoning ? { reasoning_content: reasoning } : {}),
-                  ...(toolCalls.length
-                    ? {
-                        tool_calls: toolCalls.map((t) => ({
-                          id: t.id,
-                          type: "function",
-                          function: {
-                            name: t.name,
-                            arguments: t.arguments,
-                          },
-                        })),
-                      }
-                    : {}),
-                },
-                finish_reason: toolCalls.length ? "tool_calls" : "stop",
-              },
-            ],
-            ...(includeUsage ? usageChunkFields(usage) : {}),
-          };
-          controller.enqueue(
-            new TextEncoder().encode(JSON.stringify(payload)),
-          );
-        } catch (err) {
-          const message = err instanceof Error ? err.message : String(err);
-          controller.enqueue(
-            new TextEncoder().encode(
-              JSON.stringify({ error: { message, type: "server_error" } }),
-            ),
-          );
-        } finally {
-          controller.close();
+    let content = "";
+    let reasoning = "";
+    const toolCalls: ParkedToolCall[] = [];
+    let usage = emptyUsage();
+    try {
+      for await (const event of events) {
+        const mapped = normalizeEvent(event);
+        if (mapped.kind === "park") toolCalls.push(...mapped.tools);
+        else if (mapped.kind === "text") content += mapped.text;
+        else if (mapped.kind === "reasoning") reasoning += mapped.text;
+        else if (mapped.kind === "finish") usage = mapped.usage;
+        else if (mapped.kind === "error") {
+          deleteBridge(bridge.id);
+          return upstreamErrorResponse(mapped.text);
         }
-      },
-    });
-    return new Response(bodyStream, {
+      }
+    } catch (err) {
+      deleteBridge(bridge.id);
+      return upstreamErrorResponse(err instanceof Error ? err.message : String(err));
+    }
+    const payload = {
+      id: completionId,
+      object: "chat.completion",
+      created,
+      model,
+      choices: [
+        {
+          index: 0,
+          message: {
+            role: "assistant",
+            content,
+            ...(reasoning ? { reasoning_content: reasoning } : {}),
+            ...(toolCalls.length
+              ? {
+                  tool_calls: toolCalls.map((t) => ({
+                    id: t.id,
+                    type: "function",
+                    function: { name: t.name, arguments: t.arguments },
+                  })),
+                }
+              : {}),
+          },
+          finish_reason: toolCalls.length ? "tool_calls" : "stop",
+        },
+      ],
+      ...(includeUsage ? usageChunkFields(usage) : {}),
+    };
+    return new Response(JSON.stringify(payload), {
       headers: { "Content-Type": "application/json" },
     });
   }
@@ -787,38 +787,18 @@ function streamOpenAIResponse(
             usage = mapped.usage;
           }
           if (mapped.kind === "error") {
-            send({
-              id: completionId,
-              object: "chat.completion.chunk",
-              created,
-              model,
-              choices: [
-                {
-                  index: 0,
-                  delta: {
-                    content: `\n\n[command-code error] ${mapped.text}`,
-                  },
-                  finish_reason: null,
-                },
-              ],
-            });
+            deleteBridge(bridge.id);
+            send({ error: { message: mapped.text, type: "upstream_error", code: "provider_error" } });
+            controller.close();
+            return;
           }
         }
       } catch (err) {
         const message = err instanceof Error ? err.message : String(err);
-        send({
-          id: completionId,
-          object: "chat.completion.chunk",
-          created,
-          model,
-          choices: [
-            {
-              index: 0,
-              delta: { content: `\n\n[command-code error] ${message}` },
-              finish_reason: null,
-            },
-          ],
-        });
+        deleteBridge(bridge.id);
+        send({ error: { message, type: "upstream_error", code: "provider_error" } });
+        controller.close();
+        return;
       }
 
       send({