@bitkyc08/opencodex 2.46.0-preview.20260907 → 2.47.0-preview.20260908

package/src/bridge.ts

@@ -493,7 +493,7 @@ export function bridgeToResponsesSSE(
         const previousBytes = pendingSignatureBytes
           + pendingRedacted.reduce((sum, value) => sum + bytesOf(value), 0)
           + (hiddenText ? hiddenThinkingBytes : 0);
-        const encoded = encodeReasoningEnvelope(envelope);
+        const encoded = encodeReasoningEnvelope(envelope, budget);
         const reservation = budget?.reserveTransient(bytesOf(encoded), { kind: "reasoning" });
         pendingSignature = undefined;
         pendingSignatureBytes = 0;
@@ -533,7 +533,7 @@ export function bridgeToResponsesSSE(
         if (!hiddenRawReasoningText) return;
         rawReasoningForNextToolCall = hiddenRawReasoningText;
         const previousBytes = hiddenRawReasoningBytes;
-        const encrypted = encodeReasoningEnvelope({ txt: hiddenRawReasoningText });
+        const encrypted = encodeReasoningEnvelope({ txt: hiddenRawReasoningText }, budget);
         const reservation = budget?.reserveTransient(bytesOf(encrypted), { kind: "reasoning" });
         hiddenRawReasoningText = "";
         hiddenRawReasoningBytes = 0;
@@ -556,7 +556,7 @@ export function bridgeToResponsesSSE(
       const flushKiroRedactedReasoning = () => {
         if (!pendingKiroRedacted) return;
         const previousBytes = pendingKiroRedactedBytes;
-        const encrypted = encodeReasoningEnvelope({ krc: pendingKiroRedacted });
+        const encrypted = encodeReasoningEnvelope({ krc: pendingKiroRedacted }, budget);
         const reservation = budget?.reserveTransient(bytesOf(encrypted), { kind: "reasoning" });
         pendingKiroRedacted = undefined;
         pendingKiroRedactedBytes = 0;
@@ -902,6 +902,16 @@ export function bridgeToResponsesSSE(
         gated = true;
         stepping = false;
       };
+      const attemptTerminationCleanup = (action: () => void): boolean => {
+        try {
+          action();
+          return !terminated && !closed;
+        } catch (error) {
+          if (!isTranslatorBudgetExceededError(error)) throw error;
+          terminateForTranslatorOverflow(error);
+          return false;
+        }
+      };
       const step = async () => {
         if (stepping || closed) return;
         stepping = true;
@@ -1415,10 +1425,12 @@ export function bridgeToResponsesSSE(
           return;
         }
         if (!terminated) {
-          flushHiddenRawReasoning();
-          if (currentToolCall) failCurrentToolCall();
-          if (currentWebSearch) closeCurrentWebSearch("failed", []);
-          releasePendingWebSources();
+          if (!attemptTerminationCleanup(() => {
+            flushHiddenRawReasoning();
+            if (currentToolCall) failCurrentToolCall();
+            if (currentWebSearch) closeCurrentWebSearch("failed", []);
+            releasePendingWebSources();
+          })) return;
           const failure = responseError(
             500,
             "proxy_error",
@@ -1448,13 +1460,15 @@ export function bridgeToResponsesSSE(
       if (!terminated) {
         // The adapter generator ended without an explicit done/error event. Mark as incomplete
         // rather than completed so Codex can distinguish a clean finish from a truncated stream.
-        if (currentMsg) closeCurrentMessage();
-        if (currentReasoning) closeCurrentReasoning();
-        if (currentRawReasoning) closeCurrentRawReasoning();
-        flushHiddenRawReasoning();
-        if (currentToolCall) failCurrentToolCall();
-        if (currentWebSearch) closeCurrentWebSearch("failed", []);
-        releasePendingWebSources();
+        if (!attemptTerminationCleanup(() => {
+          if (currentMsg) closeCurrentMessage();
+          if (currentReasoning) closeCurrentReasoning();
+          if (currentRawReasoning) closeCurrentRawReasoning();
+          flushHiddenRawReasoning();
+          if (currentToolCall) failCurrentToolCall();
+          if (currentWebSearch) closeCurrentWebSearch("failed", []);
+          releasePendingWebSources();
+        })) return;
         options?.onUsage?.(undefined);
         await awaitThoughtSignatureDurability();
         emit("response.incomplete", {
@@ -1493,13 +1507,15 @@ export function bridgeToResponsesSSE(
             upstreamActivity = false;
             stallTicks = 0;
           } else if (++stallTicks >= maxStallTicks) {
-            if (currentMsg) closeCurrentMessage();
-            if (currentReasoning) closeCurrentReasoning();
-            if (currentRawReasoning) closeCurrentRawReasoning();
-            flushHiddenRawReasoning();
-            if (currentToolCall) failCurrentToolCall();
-            if (currentWebSearch) closeCurrentWebSearch("failed", []);
-            releasePendingWebSources();
+            if (!attemptTerminationCleanup(() => {
+              if (currentMsg) closeCurrentMessage();
+              if (currentReasoning) closeCurrentReasoning();
+              if (currentRawReasoning) closeCurrentRawReasoning();
+              flushHiddenRawReasoning();
+              if (currentToolCall) failCurrentToolCall();
+              if (currentWebSearch) closeCurrentWebSearch("failed", []);
+              releasePendingWebSources();
+            })) return;
             // #1926 gap 2 residual: this beat callback is synchronous, so the durability
             // barrier is not awaited on the stall-timeout kill path. The in-memory store is
             // already updated; only a crash between here and the queued write loses it,
@@ -1728,7 +1744,7 @@ function buildResponseJSONWithBudget(
     if (batchRedacted.length > 0) envelope.red = batchRedacted;
     const hidden = options?.hideThinkingSummary === true;
     if (hidden && currentSummaryReasoning && (envelope.sig || envelope.red)) envelope.txt = currentSummaryReasoning;
-    const encrypted = envelope.sig || envelope.red || envelope.txt ? encodeReasoningEnvelope(envelope) : undefined;
+    const encrypted = envelope.sig || envelope.red || envelope.txt ? encodeReasoningEnvelope(envelope, budget) : undefined;
     const sourceBytes = currentSummaryReasoningBytes + batchSignatureBytes + batchRedactedBytes;
     batchSignature = undefined;
     batchSignatureBytes = 0;
@@ -1756,7 +1772,7 @@ function buildResponseJSONWithBudget(
       // Same contract as the streaming path: no visible reasoning, txt-only envelope round-trip.
       pushOutput({
         type: "reasoning", id: `rs_${uuid()}`, summary: [],
-        encrypted_content: encodeReasoningEnvelope({ txt: currentRawReasoning }),
+        encrypted_content: encodeReasoningEnvelope({ txt: currentRawReasoning }, budget),
       }, currentRawReasoningBytes, "reasoning");
       currentRawReasoning = "";
       currentRawReasoningBytes = 0;
@@ -2044,7 +2060,7 @@ function buildResponseJSONWithBudget(
     // pushOutput reserves the item itself and releases the retained raw blob it replaces.
     pushOutput({
       type: "reasoning", id: `rs_${uuid()}`, summary: [],
-      encrypted_content: encodeReasoningEnvelope({ krc: batchKiroRedacted }),
+      encrypted_content: encodeReasoningEnvelope({ krc: batchKiroRedacted }, budget),
     }, batchKiroRedactedBytes, "reasoning");
     batchKiroRedacted = undefined;
     batchKiroRedactedBytes = 0;

package/src/claude/inbound.ts

@@ -18,6 +18,7 @@ import { AnthropicRequestError, isRec, type Rec } from "./inbound-records";
 import { resolveInboundModel, effortForThinkingBudget, effortFromOutputConfig, formatFromOutputConfig } from "./inbound-model-options";
 import { systemToInstructions, toolsToResponses, toolChoiceToResponses } from "./inbound-content-options";
 import { decodeReasoningEnvelope, encodeReasoningEnvelope, OCX_REASONING_PREFIX } from "../responses/reasoning-envelope";
+import { createTranslatorBudget, type TranslatorBudget } from "../lib/translator-budget";
 
 
 
@@ -210,7 +211,7 @@ function userMessageToItems(content: unknown, input: Rec[], elide: SkillElisionC
   pushUserMessage(input, pending);
 }
 
-function assistantMessageToItems(content: unknown, input: Rec[]): void {
+function assistantMessageToItems(content: unknown, input: Rec[], budget: TranslatorBudget): void {
   if (typeof content === "string") {
     if (content.length > 0) input.push({ type: "message", role: "assistant", content: [{ type: "output_text", text: content }] });
     return;
@@ -240,11 +241,12 @@ function assistantMessageToItems(content: unknown, input: Rec[]): void {
         const thinking = typeof raw.thinking === "string" ? raw.thinking : "";
         const signature = typeof raw.signature === "string" ? raw.signature : "";
         if (signature.startsWith(OCX_REASONING_PREFIX)) {
-          const owned = decodeReasoningEnvelope(signature);
+          const owned = decodeReasoningEnvelope(signature, budget);
           if (!owned) throw new AnthropicRequestError("malformed ocxr1 reasoning signature");
           if (Object.hasOwn(owned, "sig")) throw new AnthropicRequestError("OpenCodex reasoning continuity cannot be replayed as an Anthropic signature");
         }
-        const encrypted = signature.length === 0 ? undefined : signature.startsWith(OCX_REASONING_PREFIX) ? signature : encodeReasoningEnvelope({ sig: signature });
+        const encrypted = signature.length === 0 ? undefined : signature.startsWith(OCX_REASONING_PREFIX) ? signature : encodeReasoningEnvelope({ sig: signature }, budget);
+        if (encrypted) budget.chargeRetained(2 * encrypted.length, { kind: "reasoning" });
         if (thinking.length === 0 && !encrypted) break;
         input.push({ type: "reasoning", id: `rs_${crypto.randomUUID().replace(/-/g, "")}`, summary: thinking.length > 0 ? [{ type: "summary_text", text: thinking }] : [], ...(encrypted ? { encrypted_content: encrypted } : {}) });
         break;
@@ -252,7 +254,11 @@ function assistantMessageToItems(content: unknown, input: Rec[]): void {
       case "redacted_thinking": {
         flush();
         const data = typeof raw.data === "string" ? raw.data : "";
-        if (data.length > 0) input.push({ type: "reasoning", id: `rs_${crypto.randomUUID().replace(/-/g, "")}`, summary: [], encrypted_content: encodeReasoningEnvelope({ red: [data] }) });
+        if (data.length > 0) {
+          const encrypted = encodeReasoningEnvelope({ red: [data] }, budget);
+          budget.chargeRetained(2 * encrypted.length, { kind: "reasoning" });
+          input.push({ type: "reasoning", id: `rs_${crypto.randomUUID().replace(/-/g, "")}`, summary: [], encrypted_content: encrypted });
+        }
         break;
       }
       default:
@@ -294,7 +300,16 @@ export function anthropicToResponsesBody(raw: unknown, cc?: OcxClaudeCodeConfig)
  * OUT-OF-BODY tuple (audit 133 R3#1 — an in-body marker would leak upstream through
  * the native Responses forward and 400).
  */
-export function anthropicToResponsesTranslation(raw: unknown, cc?: OcxClaudeCodeConfig): ClaudeInboundTranslation {
+export function anthropicToResponsesTranslation(raw: unknown, cc?: OcxClaudeCodeConfig, budget?: TranslatorBudget): ClaudeInboundTranslation {
+  const activeBudget = budget ?? createTranslatorBudget();
+  try {
+    return translateAnthropicRequest(raw, cc, activeBudget);
+  } finally {
+    if (!budget) activeBudget.dispose();
+  }
+}
+
+function translateAnthropicRequest(raw: unknown, cc: OcxClaudeCodeConfig | undefined, budget: TranslatorBudget): ClaudeInboundTranslation {
   if (!isRec(raw)) throw new AnthropicRequestError("request body must be a JSON object");
   if (typeof raw.model !== "string" || raw.model.length === 0) {
     throw new AnthropicRequestError("model is required");
@@ -315,7 +330,7 @@ export function anthropicToResponsesTranslation(raw: unknown, cc?: OcxClaudeCode
   for (const msg of raw.messages) {
     if (!isRec(msg)) throw new AnthropicRequestError("each message must be an object");
     if (msg.role === "user") userMessageToItems(msg.content, input, elide);
-    else if (msg.role === "assistant") assistantMessageToItems(msg.content, input);
+    else if (msg.role === "assistant") assistantMessageToItems(msg.content, input, budget);
     else if (msg.role === "system") {
       const text = systemMessageText(msg.content);
       if (text.length > 0) systemParts.push(text);

package/src/claude/outbound.ts

@@ -215,6 +215,8 @@ interface OpenBlock {
   callId?: string;
   /** Last fixed-size reasoning identity (item + summary/content index) seen by this block. */
   reasoningPartKey?: string;
+  /** Fixed-size item identity; missing IDs only match other missing IDs. */
+  reasoningItemKey?: string;
   thinkingBuf?: string;
   thinkingBufBytes?: number;
   reasoningSig?: string;
@@ -308,7 +310,21 @@ export function responsesSseToAnthropicSse(
           open.webSearchArgsEmitted = true;
         }
         if (open.kind === "thinking") {
-          const signature = open.reasoningSig ?? encodeReasoningEnvelope({ txt: open.thinkingBuf ?? "" });
+          // Delay the index and all thinking frames until closure so a matching
+          // done envelope can put its redacted blocks first. The existing buffer
+          // remains charged through signature emission, including queued frames.
+          open.index = blockIndex++;
+          emit("content_block_start", {
+            type: "content_block_start", index: open.index,
+            content_block: { type: "thinking", thinking: "", signature: "" },
+          });
+          if (open.thinkingBuf) {
+            emit("content_block_delta", {
+              type: "content_block_delta", index: open.index,
+              delta: { type: "thinking_delta", thinking: open.thinkingBuf },
+            });
+          }
+          const signature = open.reasoningSig ?? encodeReasoningEnvelope({ txt: open.thinkingBuf ?? "" }, translatorBudget);
           emit("content_block_delta", {
             type: "content_block_delta", index: open.index,
             delta: { type: "signature_delta", signature },
@@ -323,12 +339,13 @@ export function responsesSseToAnthropicSse(
         ensureStarted();
         if (open && open.kind === kind) return;
         closeOpenBlock();
+        if (kind === "thinking") {
+          open = { kind, index: -1, thinkingBuf: "", thinkingBufBytes: 0 };
+          return;
+        }
         const index = blockIndex++;
-        const contentBlock: Rec = kind === "text"
-          ? { type: "text", text: "" }
-          : { type: "thinking", thinking: "", signature: "" };
-        emit("content_block_start", { type: "content_block_start", index, content_block: contentBlock });
-        open = { kind, index, thinkingBuf: "", thinkingBufBytes: 0 };
+        emit("content_block_start", { type: "content_block_start", index, content_block: { type: "text", text: "" } });
+        open = { kind, index };
       };
       const finish = (stopReason: string, usage: unknown) => {
         if (terminated) return;
@@ -405,11 +422,13 @@ export function responsesSseToAnthropicSse(
           case "response.reasoning_summary_text.delta":
           case "response.reasoning_text.delta": {
             if (typeof data.delta !== "string" || data.delta.length === 0) break;
+            const itemKey = boundedReasoningIdentity(data.item_id);
+            if (open?.kind === "thinking" && open.reasoningItemKey !== itemKey) closeOpenBlock();
             ensureBlock("thinking");
             const active = open;
             if (!active || active.kind !== "thinking") break;
             // The JSON path joins reasoning summary/content parts with "\n\n"
-            // (responsesJsonToAnthropicMessage); mirror that at part and item boundaries
+            // (responsesJsonToAnthropicMessage); mirror that at part boundaries
             // so multi-part summaries do not glue into one run-on paragraph. Frames
             // without part indices produce a constant key and never get a separator.
             const slot = eventName === "response.reasoning_summary_text.delta"
@@ -418,7 +437,7 @@ export function responsesSseToAnthropicSse(
             // Upstream string metadata can be arbitrarily large. Hash strings into fixed-size
             // components while retaining item and part equality, rather than dropping item_id and
             // accidentally joining distinct malformed reasoning items.
-            const partKey = `${boundedReasoningIdentity(data.item_id)}:${slot}`;
+            const partKey = `${itemKey}:${slot}`;
             const needsPartSeparator = active.reasoningPartKey !== undefined
               && active.reasoningPartKey !== partKey;
             const appended = `${needsPartSeparator ? "\n\n" : ""}${data.delta}`;
@@ -436,17 +455,8 @@ export function responsesSseToAnthropicSse(
               reservation.release();
               throw error;
             }
-            if (needsPartSeparator) {
-              emit("content_block_delta", {
-                type: "content_block_delta", index: active.index,
-                delta: { type: "thinking_delta", thinking: "\n\n" },
-              });
-            }
+            active.reasoningItemKey = itemKey;
             active.reasoningPartKey = partKey;
-            emit("content_block_delta", {
-              type: "content_block_delta", index: active.index,
-              delta: { type: "thinking_delta", thinking: data.delta },
-            });
             break;
           }
           case "response.output_item.added": {
@@ -561,22 +571,29 @@ export function responsesSseToAnthropicSse(
             else if (open && open.kind === "text" && item.type === "message") closeOpenBlock();
             else if (item.type === "reasoning") {
               const encrypted = typeof item.encrypted_content === "string" ? item.encrypted_content : "";
-              const env = encrypted ? decodeReasoningEnvelope(encrypted) : null;
+              const env = encrypted ? decodeReasoningEnvelope(encrypted, translatorBudget) : null;
               const red = env?.red ?? [];
-              if (env?.sig && open?.kind !== "thinking") ensureBlock("thinking");
-              if (open?.kind === "thinking") {
-                if (env?.sig) open.reasoningSig = env.sig;
+              const itemKey = boundedReasoningIdentity(item.id);
+              // A late/unrelated done cannot reorder or sign another item's text.
+              if (open?.kind === "thinking" && open.reasoningItemKey !== itemKey) {
                 closeOpenBlock();
               }
               if (red.length > 0) {
                 ensureStarted();
-                closeOpenBlock();
+                if (open?.kind !== "thinking") closeOpenBlock();
               }
               for (const data of red) {
                 const idx = blockIndex++;
                 emit("content_block_start", { type: "content_block_start", index: idx, content_block: { type: "redacted_thinking", data } });
                 emit("content_block_stop", { type: "content_block_stop", index: idx });
               }
+              if (env?.sig && open?.kind !== "thinking") {
+                ensureBlock("thinking");
+              }
+              if (open?.kind === "thinking") {
+                if (env?.sig) open.reasoningSig = env.sig;
+                closeOpenBlock();
+              }
             }
             break;
           }
@@ -785,7 +802,7 @@ export function responsesSseToAnthropicSse(
 }
 
 /** Non-streaming: /v1/responses JSON -> Anthropic message JSON. */
-export function responsesJsonToAnthropicMessage(json: unknown, model: string): Rec {
+export function responsesJsonToAnthropicMessage(json: unknown, model: string, translatorBudget?: TranslatorBudget): Rec {
   const body = isRec(json) ? json : {};
   const output = Array.isArray(body.output) ? body.output : [];
   const content: Rec[] = [];
@@ -817,14 +834,14 @@ export function responsesJsonToAnthropicMessage(json: unknown, model: string): R
           }
         }
         const encrypted = typeof raw.encrypted_content === "string" ? raw.encrypted_content : "";
-        const env = encrypted ? decodeReasoningEnvelope(encrypted) : null;
+        const env = encrypted ? decodeReasoningEnvelope(encrypted, translatorBudget) : null;
         // Legacy combined envelopes place redacted blocks before the signed block,
         // matching the Anthropic adapter. New bridge output uses separate items.
         for (const data of env?.red ?? []) content.push({ type: "redacted_thinking", data });
         // env.txt may be locally hidden text. Do not expose it here or manufacture
         // a new signed continuity carrier; hidden-summary replay remains limited.
         if (parts.length > 0 || env?.sig) {
-          content.push({ type: "thinking", thinking: parts.join("\n\n"), signature: env?.sig ?? encodeReasoningEnvelope({ txt: parts.join("\n\n") }) });
+          content.push({ type: "thinking", thinking: parts.join("\n\n"), signature: env?.sig ?? encodeReasoningEnvelope({ txt: parts.join("\n\n") }, translatorBudget) });
         }
         break;
       }

package/src/cli/capabilities.ts

@@ -95,6 +95,31 @@ export const HEAD_CAPABILITIES: readonly HeadCapability[] = [
  * A capability must not name a route the command does not actually fetch.
  */
 export const CAPABILITIES: readonly Capability[] = [
+  {
+    command: ["models", "price"],
+    summary: "Read the saved manual price for an exact provider/model selector.",
+    routes: [{ method: "GET", path: "/api/providers/{provider}/model-costs" }],
+    flags: [{ name: "--json", value: "boolean", summary: "Emit provider, modelId, and cost (null for automatic pricing)." }],
+    mutates: false,
+    json: "envelope",
+    details: ["The provider must be configured; everything after the first slash is the exact upstream model ID."],
+  },
+  {
+    command: ["models", "set-price"],
+    summary: "Save four manual USD-per-1M-token rates, or restore automatic pricing for one model.",
+    routes: [{ method: "PUT", path: "/api/providers/{provider}/model-costs" }],
+    flags: [
+      { name: "--input", value: "number", summary: "Input rate; required unless --auto is used." },
+      { name: "--output", value: "number", summary: "Output rate; required unless --auto is used." },
+      { name: "--cache-read", value: "number", summary: "Cache read rate; defaults to 0." },
+      { name: "--cache-write", value: "number", summary: "Cache write rate; defaults to 0." },
+      { name: "--auto", value: "boolean", summary: "Remove this model's override; cannot be combined with rates." },
+      { name: "--json", value: "boolean", summary: "Emit the saved price or reset result as JSON." },
+    ],
+    mutates: true,
+    json: "payload",
+    details: ["Uses the exact upstream model ID after the first slash. Omitted cache rates default to zero; sibling model prices are preserved."],
+  },
   {
     command: ["status"],
     summary: "Proxy status, injection state, and version skew between this CLI and the running proxy.",
@@ -200,6 +225,8 @@ export const CAPABILITIES: readonly Capability[] = [
     routes: [{ method: "GET", path: "/api/usage" }],
     flags: [
       { name: "--range", value: "string", summary: "today | 1d | 7d | 30d | all" },
+      { name: "--since", value: "string", summary: "Inclusive start: epoch milliseconds or full ISO datetime with timezone; requires --until and overrides --range." },
+      { name: "--until", value: "string", summary: "Inclusive end: epoch milliseconds or full ISO datetime with timezone; requires --since." },
       { name: "--provider", value: "string", summary: "Restrict to one provider." },
       { name: "--model", value: "string", summary: "Restrict to one model id." },
       { name: "--json", value: "boolean", summary: "Emit the usage report as JSON." },

package/src/cli/integrations.ts

@@ -189,7 +189,7 @@ function singleClientStatusLines(result: unknown): string[] {
   const rest = Object.fromEntries(Object.entries(result as Record<string, unknown>).filter(([key]) => key !== "raycast"));
   const lines = [...summaryLines(rest), `plan: ${raycast.plan}`];
   if (!raycast.aiDirPresent) {
-    lines.push('Open Raycast → Settings → AI → "Reveal Providers Config" once so the ai folder exists.');
+    lines.push('On macOS or Windows, open Raycast → Settings → AI → "Reveal Providers Config" once so the ai folder exists.');
   }
   return lines;
 }

package/src/cli/models-runtime-subcommands.ts

@@ -15,6 +15,8 @@
  */
 export const MODELS_RUNTIME_SUBCOMMANDS = [
   "live",
+  "price",
+  "set-price",
   "edit",
   "enable",
   "disable",

package/src/cli/models-runtime.ts

@@ -13,9 +13,18 @@ import {
   type RuntimeApiDeps,
 } from "./runtime-api";
 import { isModelsRuntimeSubcommand } from "./models-runtime-subcommands";
+import { isValidProviderName } from "../config/provider-name";
+import { isValidModelDiscoveryModelId } from "../providers/model-discovery-limits";
+import { redactSecretString } from "../lib/redact";
+import type { ProviderCostOverlay } from "../types";
+import { MAX_COST4_RATE } from "../usage/expected-prices";
+import { isValidCost4Rate } from "../usage/user-cost-overlays";
 
 const USAGE = `Usage:
   ocx models live [--provider <name>] [--json]
+  ocx models price <provider/model> [--json]
+  ocx models set-price <provider/model> --input N --output N [--cache-read N] [--cache-write N] [--json]
+  ocx models set-price <provider/model> --auto [--json]
   ocx models edit <custom-id> [--model-id <id>] [--display-name <name|->]
       [--context-window <tokens|0>] [--modalities <text,image,audio|->]
       [--reasoning-efforts <none,minimal,low,medium,high,xhigh,max,ultra|->]
@@ -28,7 +37,10 @@ const USAGE = `Usage:
   ocx models new-policy [on|off] [--provider <name>] [--json]
   ocx models new-arrivals [--json]
   ocx models context <status|value <tokens> [--set-all]|provider <name> on [--value <tokens>]|provider <name> off|all <on|off>> [--json]
-  ocx models shadow <status|set> [model|-] [--enabled <on|off>] [--json]`;
+  ocx models shadow <status|set> [model|-] [--enabled <on|off>] [--json]
+
+Prices are USD per 1M tokens. Omitted cache rates default to 0.
+Price selectors use the exact upstream model ID after the first slash.`;
 
 type ModelRow = {
   provider?: string;
@@ -55,6 +67,99 @@ async function live(argv: string[], deps: RuntimeApiDeps): Promise<void> {
   }));
 }
 
+function priceRecord(value: unknown): value is Record<string, unknown> {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+const PRICE_RATE_KEYS = ["input", "output", "cacheRead", "cacheWrite"] as const;
+
+function validPriceCost(value: unknown): value is ProviderCostOverlay {
+  return priceRecord(value) && Object.keys(value).length === PRICE_RATE_KEYS.length
+    && PRICE_RATE_KEYS.every(key => Object.hasOwn(value, key) && isValidCost4Rate(value[key]));
+}
+
+async function price(write: boolean, argv: string[], deps: RuntimeApiDeps): Promise<void> {
+  try {
+    await priceRequest(write, argv, deps);
+  } catch (error) {
+    // Duplicated, inline and stray options also reach parser diagnostics.
+    // Keep HTTP-specific RuntimeApiError exits while masking usage errors.
+    if (error instanceof CliUsageError) {
+      throw new CliUsageError(redactSecretString(error.message), error.usage);
+    }
+    throw error;
+  }
+}
+
+async function priceRequest(write: boolean, argv: string[], deps: RuntimeApiDeps): Promise<void> {
+  const args = [...argv];
+  const selector = args.shift() ?? "";
+  const slash = selector.indexOf("/");
+  const provider = selector.slice(0, slash);
+  const modelId = selector.slice(slash + 1);
+  if (slash < 1 || !isValidProviderName(provider) || !isValidModelDiscoveryModelId(modelId)) {
+    throw new CliUsageError("model selector must be provider/model with an exact upstream model id", USAGE);
+  }
+  if (redactSecretString(modelId) !== modelId) {
+    throw new CliUsageError("modelId cannot be displayed safely", USAGE);
+  }
+  const wantsJson = takeFlag(args, "--json");
+  const path = `/api/providers/${encodeURIComponent(provider)}/model-costs`;
+  if (!write) {
+    rejectArgs(args, USAGE);
+    const result = await runtimeRequest<unknown>(path, {}, deps);
+    if (!priceRecord(result) || result.provider !== provider || !priceRecord(result.modelCosts)
+      || !Object.values(result.modelCosts).every(validPriceCost)) {
+      throw new Error("Invalid model price response");
+    }
+    let cost: ProviderCostOverlay | null = null;
+    if (Object.hasOwn(result.modelCosts, modelId)) {
+      const stored = result.modelCosts[modelId];
+      if (!validPriceCost(stored)) throw new Error("Invalid model price response");
+      cost = { ...stored };
+    }
+    printData({ provider, modelId, cost }, wantsJson, [
+      cost === null ? `${selector}: automatic pricing` : `${selector}: ${JSON.stringify(cost)} USD per 1M tokens`,
+    ]);
+    return;
+  }
+  const auto = takeFlag(args, "--auto");
+  const input = takeOption(args, "--input");
+  const output = takeOption(args, "--output");
+  const cacheRead = takeOption(args, "--cache-read");
+  const cacheWrite = takeOption(args, "--cache-write");
+  rejectArgs(args, USAGE);
+  if (auto && [input, output, cacheRead, cacheWrite].some(value => value !== undefined)) {
+    throw new CliUsageError("--auto cannot be combined with price rates", USAGE);
+  }
+  if (!auto && (input === undefined || output === undefined)) {
+    throw new CliUsageError("--input and --output are required unless --auto is used", USAGE);
+  }
+  const rate = (raw: string, flag: string): number => {
+    const value = Number(raw);
+    if (!raw.trim() || !isValidCost4Rate(value)) {
+      throw new CliUsageError(`${flag} must be a finite number between 0 and ${MAX_COST4_RATE}`, USAGE);
+    }
+    return value;
+  };
+  const cost: ProviderCostOverlay | null = auto ? null : {
+    input: rate(input!, "--input"),
+    output: rate(output!, "--output"),
+    cacheRead: rate(cacheRead ?? "0", "--cache-read"),
+    cacheWrite: rate(cacheWrite ?? "0", "--cache-write"),
+  };
+  const result = await runtimeRequest(path, { method: "PUT", body: JSON.stringify({ modelId, cost }) }, deps);
+  const receivedCost = priceRecord(result) ? result.cost : undefined;
+  if (!priceRecord(result) || result.ok !== true || result.provider !== provider || result.modelId !== modelId
+    || (cost === null ? receivedCost !== null : !validPriceCost(receivedCost)
+      || !PRICE_RATE_KEYS.every(key => receivedCost[key] === cost[key]))) {
+    throw new Error("Invalid model price persistence receipt");
+  }
+  // Project the acknowledged fields only; unrelated response fields are not CLI output.
+  printData({ ok: true, provider, modelId, cost }, wantsJson,
+    [auto ? `${selector}: automatic pricing restored.` : `${selector}: manual pricing saved.`]);
+}
+
 async function edit(argv: string[], deps: RuntimeApiDeps): Promise<void> {
   const args = [...argv];
   const id = args.shift()?.trim();
@@ -328,6 +433,8 @@ export async function handleModelsRuntimeCommand(sub: string, argv: string[], de
   if (!isModelsRuntimeSubcommand(sub)) return null;
   let action: (() => Promise<void>) | undefined;
   if (sub === "live") action = () => live(argv, deps);
+  else if (sub === "price") action = () => price(false, argv, deps);
+  else if (sub === "set-price") action = () => price(true, argv, deps);
   else if (sub === "edit") action = () => edit(argv, deps);
   else if (sub === "enable") action = () => visibility(true, argv, deps);
   else if (sub === "disable") action = () => visibility(false, argv, deps);

package/src/cli/observe.ts

@@ -11,7 +11,9 @@ import {
   type RuntimeApiDeps,
 } from "./runtime-api";
 import { formatUsageReport } from "./usage-report";
-import { USAGE_RANGES, USAGE_SURFACES } from "../usage/summary";
+import { USAGE_RANGES, USAGE_SURFACES, type UsageSummary } from "../usage/summary";
+import { parseUsageTimeWindow, type UsageTimeWindow } from "../usage/time-range";
+import { redactSecretString } from "../lib/redact";
 
 const USAGE = `Usage:
   ocx observe logs [--provider <name>] [--model <id>] [--status <code>]
@@ -20,6 +22,7 @@ const USAGE = `Usage:
   ocx logs rebuild-index
   ocx logs index-status
   ocx observe usage [--range <today|1d|7d|30d|all>] [--surface <all|codex|claude|grok>]
+      [--since <epoch-ms|ISO-datetime>] [--until <epoch-ms|ISO-datetime>]
       [--provider <name>] [--model <id>] [--json]
   ocx observe storage [codex-logs [status|protect|unprotect|repair|compact] [--mode <compat|quiet>]] [--json]
   ocx observe memory [--json]
@@ -146,6 +149,14 @@ async function usage(argv: string[], deps: RuntimeApiDeps): Promise<void> {
   const surface = takeOption(args, "--surface") ?? "all";
   const provider = takeOption(args, "--provider");
   const model = takeOption(args, "--model");
+  const since = takeOption(args, "--since");
+  const until = takeOption(args, "--until");
+  let window: UsageTimeWindow | undefined;
+  try {
+    window = parseUsageTimeWindow(since, until);
+  } catch (error) {
+    throw new CliUsageError(error instanceof Error ? error.message : "invalid usage time window", USAGE);
+  }
   // `1d` is accepted here as well as server-side so the CLI does not reject an
   // alias the API would have understood.
   const ranges = [...USAGE_RANGES, "1d"];
@@ -153,8 +164,12 @@ async function usage(argv: string[], deps: RuntimeApiDeps): Promise<void> {
   if (!USAGE_SURFACES.includes(surface as (typeof USAGE_SURFACES)[number])) {
     throw new CliUsageError(`--surface must be one of ${USAGE_SURFACES.join(", ")}`, USAGE);
   }
-  rejectArgs(args, USAGE);
-  const result = await runtimeRequest(`/api/usage${query({ range, surface, provider, model })}`, {}, deps);
+  rejectArgs(args.map(redactSecretString), USAGE);
+  const result = await runtimeRequest<UsageSummary>(`/api/usage${query({ range, surface, provider, model, since: window?.since, until: window?.until })}`, {}, deps);
+  // Older daemons ignore custom bounds and return successful preset reports.
+  if (window && (result?.customWindow !== true || result.since !== window.since || result.until !== window.until)) {
+    throw new Error("The server did not confirm the requested custom usage window. Upgrade and restart the proxy, then retry.");
+  }
   // Built only when it will be printed: JavaScript evaluates arguments before
   // the call, so passing formatUsageReport(...) inline would run the human
   // renderer during --json and let its assumptions affect a path that is meant

package/src/cli/usage-report.ts

@@ -24,6 +24,8 @@ interface UsageReportInput {
   range?: string;
   surface?: string;
   since?: number | null;
+  until?: number;
+  customWindow?: boolean;
   summary?: {
     requests?: number;
     totalTokens?: number;
@@ -90,7 +92,10 @@ function table(header: string[], rows: string[][]): string[] {
 }
 
 function describeScope(data: UsageReportInput): string {
-  const parts = [`Usage — ${data.range ?? "?"}`];
+  const interval = data.customWindow && typeof data.since === "number" && typeof data.until === "number"
+    ? `custom ${new Date(data.since).toISOString()} to ${new Date(data.until).toISOString()} (inclusive)`
+    : data.range ?? "?";
+  const parts = [`Usage — ${interval}`];
   if (data.surface && data.surface !== "all") parts.push(`surface=${data.surface}`);
   if (data.filter?.provider) parts.push(`provider=${data.filter.provider}`);
   if (data.filter?.model) parts.push(`model=${data.filter.model}`);