@bitkyc08/opencodex 2.86.0 → 2.88.0

package/src/usage/summary.ts

@@ -10,7 +10,7 @@ import {
   type PersistedUsageEntry,
   type UsageStatus,
 } from "./log";
-import { type AttemptCostEstimate, type CostEstimate, estimateAttemptCost, estimateRequestCost, serviceTierContext, type ServiceTierContext, tokensPerSecond } from "./cost";
+import { type AttemptCostEstimate, type CostEstimate, estimateAttemptCost, estimateRequestCost, isMeasuredStatus, serviceTierContext, type ServiceTierContext, tokensPerSecond } from "./cost";
 
 /**
  * Canonical range members. The warm-up loop in the management usage route
@@ -303,7 +303,10 @@ export function computeEntryCost(entry: PersistedUsageEntry): EntryCostInfo {
         isPriced = true;
       }
     }
-    return { tier, estimate: null, attemptEstimates, costTotal, isPriced };
+    // An unmeasured leg that may have generated billed tokens leaves the total unknown, not short.
+    const unknownCost = entry.attempts.some((attempt, index) =>
+      !attemptEstimates[index] && (!attempt.usage || !isMeasuredStatus(attempt.usageStatus)) && !spentNothing(attempt));
+    return { tier, estimate: null, attemptEstimates, costTotal, isPriced: isPriced && !unknownCost };
   }
   const estimate = estimateRequestCost({
     ...usageModelPriceOptions(entry, entry),
@@ -428,10 +431,6 @@ function blankTotals(): UsageSummaryTotals {
   };
 }
 
-function isMeasuredStatus(status: UsageStatus): boolean {
-  return status === "reported" || status === "estimated";
-}
-
 export interface UsageAttribution {
   requestId: string;
   provider: string;
@@ -666,8 +665,12 @@ function addEstimatedCost(
   entry: Pick<PersistedUsageEntry, "usageStatus" | "usage" | "attempts">,
   costInfo: EntryCostInfo,
 ): void {
-  if (entry.usageStatus === "unreported" || entry.usageStatus === "unsupported"
-    || (!entry.usage && !entry.attempts?.length)) {
+  // A row of attempts reads `unreported` when any leg lacks usage. Once one leg is measured the row
+  // is metered and the attempt-level pricing decides, matching the model and provider breakdowns.
+  const measuredAttempt = entry.attempts?.some(attempt => attempt.usage && isMeasuredStatus(attempt.usageStatus));
+  if (!measuredAttempt
+    && (entry.usageStatus === "unreported" || entry.usageStatus === "unsupported"
+      || (!entry.usage && !entry.attempts?.length))) {
     totals.unmeteredRequests += 1;
     return;
   }
@@ -814,14 +817,30 @@ function blankRequestCounts(): UsageRequestCounts {
   };
 }
 
+/**
+ * A usage-less attempt that provably cost nothing: it never reached upstream, or upstream refused it
+ * with an HTTP error before any output (providers do not bill a pre-generation 429/401/5xx). One
+ * whose stream began, aborted, or ended without a status may have generated billed tokens, so it
+ * stays an unknown cost. A request made only of such zeros carries neither fact and counts unpriced.
+ */
+function spentNothing(attempt: NonNullable<PersistedUsageEntry["attempts"]>[number] | undefined): boolean {
+  if (!attempt || attempt.usage) return false;
+  if (attempt.sendCount === 0 || attempt.locallyAnswered === true) return true;
+  // A 499 is the client hanging up on a send upstream may already be generating for.
+  return attempt.status >= 400 && attempt.status !== 499
+    && attempt.streamAborted !== true && attempt.firstOutputMs === undefined;
+}
+
 function bumpRequestCounts(counts: UsageRequestCounts, facts: number, amount = 1): void {
   counts.requests += amount;
   const status = statusFromRequestFacts(facts);
   if (isMeasuredStatus(status)) counts.measuredRequests += amount;
   if (status === "reported") counts.reportedRequests += amount;
   else if (status === "estimated") counts.estimatedRequests += amount;
-  if ((facts & REQUEST_PRICED) !== 0) counts.pricedRequests += amount;
-  if ((facts & REQUEST_UNPRICED) !== 0) counts.unpricedRequests += amount;
+  // Unpriced dominates: one unpriceable part makes the request's cost unknown, and counting it
+  // on both sides overstated price coverage.
+  if ((facts & REQUEST_PRICED) !== 0 && (facts & REQUEST_UNPRICED) === 0) counts.pricedRequests += amount;
+  else counts.unpricedRequests += amount;
 }
 
 function mergeRequestCounts(target: UsageRequestCounts, source: UsageRequestCounts): void {
@@ -1557,7 +1576,7 @@ class StreamingUsageSummaryAccumulator implements UsageSummaryAccumulator {
         : costInfo.estimate;
       const ordinal = this.nextOrdinal++;
       const facts = requestStatusFact(attribution.usageStatus)
-        | (estimate ? REQUEST_PRICED : REQUEST_UNPRICED);
+        | (estimate ? REQUEST_PRICED : spentNothing(entry.attempts?.[index]) ? 0 : REQUEST_UNPRICED);
       const modelKey = this.addModelAttribution(partition, attribution, estimate, ordinal);
       modelFacts.set(modelKey, (modelFacts.get(modelKey) ?? 0) | facts);
       if (this.mode === "row-unique") {

package/src/usage/telemetry-contract.ts

@@ -32,6 +32,7 @@ export const ATTEMPT_RECOVERY_KIND_ROSTER = Object.freeze([
   "rate-limit-429",
   "anthropic-oauth-429",
   "oauth-account-429",
+  "oauth-account-402",
   "image-413",
   "console-go-upload-retry",
   "opaque-blob-rejection",

package/src/usage/user-cost-overlays.ts

@@ -18,8 +18,10 @@
  *
  * Display-time estimation only — these rows never affect billing.
  */
-import type { OcxConfig, OcxProviderConfig, ProviderCostOverlay } from "../types";
-import { MAX_COST4_RATE, type ExpectedPriceOverlay } from "./expected-prices";
+import type { OcxConfig, OcxProviderConfig, ProviderCostOverlay, PromptLengthPricing } from "../types";
+import type { ExpectedPriceOverlay } from "./expected-prices";
+import { validCost4 } from "./user-cost-validation";
+export { COST4_RATE_KEYS, isValidCost4Rate, validCost4, isValidPromptLengthPricing } from "./user-cost-validation";
 import { redactSecretString } from "../lib/redact";
 import { isSelectableCodexPoolAccount, MAIN_CODEX_ACCOUNT_ID } from "../codex/account-id";
 import { codexAccountLogLabel } from "../codex/account-label";
@@ -236,22 +238,13 @@ export function resetPreservedDiskOnlyProvidersForTests(): void {
   preservationOwnerStates.clear();
 }
 
-/** Exact four fields accepted for a user-configured cost tuple. */
-export const COST4_RATE_KEYS = ["input", "output", "cacheRead", "cacheWrite"] as const;
-
-/** Shared per-rate predicate used by config validation, display sanitization, and runtime lifting. */
-export function isValidCost4Rate(rate: unknown): rate is number {
-  return typeof rate === "number"
-    && Number.isFinite(rate)
-    && rate >= 0
-    && rate <= MAX_COST4_RATE;
-}
-
-/** True when `value` is a complete cost entry: all four rates are non-negative finite numbers. */
-function validCost4(value: unknown): value is ProviderCostOverlay {
-  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
-  const entry = value as Record<string, unknown>;
-  return COST4_RATE_KEYS.every(key => isValidCost4Rate(entry[key]));
+/** Copy a validated override; automatic is represented by absence. */
+export function copyPromptLengthPricing(policy: PromptLengthPricing): PromptLengthPricing | undefined {
+  if (policy.mode === "automatic") return undefined;
+  if (policy.mode !== "custom") return { mode: policy.mode };
+  const { input, output, cacheRead, cacheWrite } = policy.rates;
+  return { mode: "custom", thresholdTokens: policy.thresholdTokens, comparison: policy.comparison,
+    rates: { input, output, cacheRead, cacheWrite } };
 }
 
 /**
@@ -273,10 +266,11 @@ export function refreshUserCostOverlays(config: OcxConfig): void {
       if (!costs || typeof costs !== "object" || Array.isArray(costs)) continue;
       for (const [modelId, cost4] of Object.entries(costs)) {
         if (!modelId.trim() || !validCost4(cost4)) continue;
+        const policy = cost4.promptLengthPricing && copyPromptLengthPricing(cost4.promptLengthPricing);
         rows.push({
           provider: providerName,
           modelId,
-          // Copy ONLY the four validated rate fields: a hand-edited row may
+          // Copy only validated rates and policy: a hand-edited row may
           // carry extra properties (e.g. a misplaced apiKey) that must never
           // reach display estimates or /api/logs through the registry.
           cost4: {
@@ -285,6 +279,7 @@ export function refreshUserCostOverlays(config: OcxConfig): void {
             cacheRead: cost4.cacheRead,
             cacheWrite: cost4.cacheWrite,
           },
+          ...(policy ? { promptLengthPricing: policy } : {}),
           // Display provenance only: redact token-shaped provider/model ids so
           // the source string can never echo a pasted key. Matching still uses
           // the raw fields, and the change-detection signature below MUST keep

package/src/usage/user-cost-validation.ts

@@ -0,0 +1,38 @@
+/** Pure model-cost validation shared by config, migration, and display lifting. */
+import type { ProviderCostOverlay, PromptLengthPricing } from "../types";
+import { MAX_COST4_RATE } from "./expected-prices";
+
+/** Exact four fields accepted for a user-configured cost tuple. */
+export const COST4_RATE_KEYS = ["input", "output", "cacheRead", "cacheWrite"] as const;
+
+/** Shared per-rate predicate used by config validation, display sanitization, and runtime lifting. */
+export function isValidCost4Rate(rate: unknown): rate is number {
+  return typeof rate === "number"
+    && Number.isFinite(rate)
+    && rate >= 0
+    && rate <= MAX_COST4_RATE;
+}
+
+/** Complete base rates with a valid optional policy; extra top-level fields are never copied. */
+export function validCost4(value: unknown): value is ProviderCostOverlay {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const entry = value as Record<string, unknown>;
+  return COST4_RATE_KEYS.every(key => Object.hasOwn(entry, key) && isValidCost4Rate(entry[key]))
+    && (!Object.hasOwn(entry, "promptLengthPricing") || isValidPromptLengthPricing(entry.promptLengthPricing));
+}
+
+/** Strict nested policy boundary; diagnostics never echo untrusted policy fields. */
+export function isValidPromptLengthPricing(value: unknown): value is PromptLengthPricing {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const policy = value as Record<string, unknown>;
+  if (!Object.hasOwn(policy, "mode")) return false;
+  if (policy.mode === "automatic" || policy.mode === "flat") return Object.keys(policy).length === 1;
+  if (policy.mode !== "custom" || Object.keys(policy).length !== 4
+    || !["mode", "thresholdTokens", "comparison", "rates"].every(key => Object.hasOwn(policy, key))
+    || typeof policy.thresholdTokens !== "number" || !Number.isSafeInteger(policy.thresholdTokens)
+    || policy.thresholdTokens <= 0 || (policy.comparison !== "gt" && policy.comparison !== "gte")) return false;
+  const rates = policy.rates;
+  return !!rates && typeof rates === "object" && !Array.isArray(rates)
+    && Object.keys(rates).length === COST4_RATE_KEYS.length
+    && COST4_RATE_KEYS.every(key => Object.hasOwn(rates, key) && isValidCost4Rate((rates as Record<string, unknown>)[key]));
+}

package/src/vision/eligibility.ts

@@ -226,6 +226,19 @@ export function isVisionSidecarConsumer(config: VisionCapabilityConfig, provider
   return isVisionSidecarConsumerWithCache(config, providerName, modelId, new Map());
 }
 
+/**
+ * `isVisionSidecarConsumer` for many rows of one config. Rows of the same provider share one
+ * registry enrichment instead of rebuilding it per row, which matters for `/api/models`
+ * listings with thousands of rows. Bind it to a single config snapshot; it does not observe
+ * provider changes made after the first lookup.
+ */
+export function visionSidecarConsumerClassifier(
+  config: VisionCapabilityConfig,
+): (providerName: string, modelId: string) => boolean {
+  const cache: EnrichedProviderCache = new Map();
+  return (providerName, modelId) => isVisionSidecarConsumerWithCache(config, providerName, modelId, cache);
+}
+
 /**
  * Can this model accept an image on the wire? Sources are consulted in descending
  * trustworthiness; the first that speaks wins. `undefined` means nothing knows,

package/src/web-search/anthropic-history.ts

@@ -0,0 +1,59 @@
+import type { AdapterEvent, OcxAssistantContentPart, OcxThinkingContent, OcxToolCall } from "../types";
+
+/** Rebuild one validated Anthropic model response without changing its search arguments or order. */
+export function anthropicSearchAssistantContent(events: readonly AdapterEvent[]): OcxAssistantContentPart[] {
+  const content: OcxAssistantContentPart[] = [];
+  let thinking: OcxThinkingContent | undefined;
+  let text: Extract<OcxAssistantContentPart, { type: "text" }> | undefined;
+  let call: OcxToolCall | undefined;
+  let argumentsText = "";
+  for (const event of events) {
+    if (event.type === "heartbeat") continue;
+    // A signature is a replacement snapshot until the next semantic block starts.
+    if (thinking?.signature !== undefined && event.type !== "thinking_signature") thinking = undefined;
+    if (event.type !== "text_delta") text = undefined;
+    switch (event.type) {
+      case "thinking_delta":
+        if (!thinking) { thinking = { type: "thinking", thinking: "" }; content.push(thinking); }
+        thinking.thinking += event.thinking;
+        break;
+      case "thinking_signature":
+        if (!thinking) { thinking = { type: "thinking", thinking: "" }; content.push(thinking); }
+        thinking.signature = event.signature;
+        break;
+      case "redacted_thinking":
+        thinking = undefined;
+        content.push({ type: "thinking", thinking: "", redacted: [event.data] });
+        break;
+      case "text_delta":
+        thinking = undefined;
+        if (event.anthropicThinkingSignature) {
+          text = undefined;
+          content.push({ type: "thinking", thinking: event.text, signature: event.anthropicThinkingSignature });
+          break;
+        }
+        if (!text) { text = { type: "text", text: "" }; content.push(text); }
+        text.text += event.text;
+        break;
+      case "tool_call_start":
+        thinking = undefined;
+        call = { type: "toolCall", id: event.id, name: event.name, arguments: {},
+          ...(event.providerMetadata ? { providerMetadata: event.providerMetadata } : {}) };
+        content.push(call);
+        argumentsText = "";
+        break;
+      case "tool_call_delta":
+        argumentsText += event.arguments;
+        break;
+      case "tool_call_end": {
+        if (!call) throw new Error("search history has an unpaired tool call");
+        const args: unknown = JSON.parse(argumentsText || "{}");
+        if (!args || typeof args !== "object" || Array.isArray(args)) throw new Error("search history tool input is not an object");
+        call.arguments = args as Record<string, unknown>;
+        call = undefined;
+        break;
+      }
+    }
+  }
+  return content;
+}