@bitkyc08/opencodex 2.7.41 → 2.7.42

package/src/server/request-log-conversation.ts

@@ -0,0 +1,168 @@
+/**
+ * Best-effort chat/session correlation for Logs / usage.jsonl (#330).
+ * Opaque ids only — never persist raw emails or Claude Desktop system-hash fallbacks.
+ */
+import { createHash } from "node:crypto";
+
+/** Reject absurdly long client strings before hashing (DoS / JSONL bloat). */
+export const LOG_CONVERSATION_ID_INPUT_MAX = 4096;
+/** Persisted / filterable form is always a 32-char hex digest. */
+export const LOG_CONVERSATION_ID_LEN = 32;
+
+function hasControlChars(value: string): boolean {
+  for (let i = 0; i < value.length; i++) {
+    const code = value.charCodeAt(i);
+    if (code <= 0x1f || code === 0x7f) return true;
+  }
+  return false;
+}
+
+function sanitizeConversationIdInput(raw: string | undefined | null): string | undefined {
+  if (typeof raw !== "string") return undefined;
+  const trimmed = raw.trim();
+  if (!trimmed) return undefined;
+  // Reject control characters that would break JSONL / UI paste.
+  if (hasControlChars(trimmed)) return undefined;
+  if (trimmed.length > LOG_CONVERSATION_ID_INPUT_MAX) return undefined;
+  return trimmed;
+}
+
+/**
+ * Cap / sanitize a correlation id for persistence.
+ * Always hashes so client-controlled headers cannot land emails or short secrets in usage.jsonl.
+ */
+export function normalizeLogConversationId(raw: string | undefined | null): string | undefined {
+  const trimmed = sanitizeConversationIdInput(raw);
+  if (!trimmed) return undefined;
+  return createHash("sha256").update(trimmed).digest("hex").slice(0, LOG_CONVERSATION_ID_LEN);
+}
+
+/**
+ * Filter match: accept either the persisted digest or the original preimage
+ * (so pasting from Logs detail or the client-facing session id both work).
+ */
+export function matchesLogConversationId(
+  stored: string | undefined,
+  query: string | undefined | null,
+): boolean {
+  if (!stored) return false;
+  const trimmed = typeof query === "string" ? query.trim() : "";
+  if (!trimmed) return false;
+  if (stored === trimmed) return true;
+  const hashed = normalizeLogConversationId(trimmed);
+  return hashed !== undefined && stored === hashed;
+}
+
+/**
+ * Codex/Claude/Cursor priority for Responses-shaped requests:
+ * parent thread header > session_id / session-id > thread-id > cursor conversation id.
+ */
+export function sessionIdHeaderFromRequest(headers: Headers): string | null {
+  return headers.get("session_id") ?? headers.get("session-id");
+}
+
+export function conversationIdFromResponsesRequest(input: {
+  clientThreadId?: string;
+  sessionIdHeader?: string | null;
+  threadIdHeader?: string | null;
+  cursorConversationId?: string;
+}): string | undefined {
+  return normalizeLogConversationId(
+    input.clientThreadId
+      ?? input.sessionIdHeader
+      ?? input.threadIdHeader
+      ?? input.cursorConversationId,
+  );
+}
+
+/**
+ * Claude Code metadata.user_id only — never the system-hash Desktop fallback.
+ * Hashes the raw user_id once (same opacity goal as inbound prompt_cache_key).
+ */
+export function conversationIdFromClaudeMetadata(
+  metadata: { user_id?: unknown } | null | undefined,
+): string | undefined {
+  if (!metadata || typeof metadata.user_id !== "string") return undefined;
+  return normalizeLogConversationId(metadata.user_id);
+}
+
+/** @deprecated Prefer conversationIdFromClaudeMetadata; kept for call-site clarity. */
+export function conversationIdFromClaudeCacheKey(
+  cacheKeySource: "metadata" | "system" | null | undefined,
+  promptCacheKey: string | undefined,
+): string | undefined {
+  if (cacheKeySource !== "metadata") return undefined;
+  // prompt_cache_key is already sha256(user_id)[:32] from inbound — persist as-is
+  // (do not re-hash) so native and translated paths stay aligned when callers pass
+  // the preimage via conversationIdFromClaudeMetadata instead.
+  const trimmed = sanitizeConversationIdInput(promptCacheKey);
+  if (!trimmed) return undefined;
+  if (trimmed.length === LOG_CONVERSATION_ID_LEN && /^[0-9a-f]+$/i.test(trimmed)) return trimmed.toLowerCase();
+  return normalizeLogConversationId(trimmed);
+}
+
+export interface ConversationLogTotals {
+  requests: number;
+  totalTokens: number;
+  estimatedCostUsd: number;
+  pricedRequests: number;
+  unpricedRequests: number;
+  unmeteredRequests: number;
+}
+
+type TotalsSource = {
+  totalTokens?: number;
+  usage?: { inputTokens?: number; outputTokens?: number; totalTokens?: number };
+  usageStatus?: string;
+  displayMetrics?: {
+    cost?:
+      | { kind: "value"; estimate: { cost: { total: number } } }
+      | { kind: "unavailable"; reason: string };
+  };
+};
+
+function rowTokenTotal(entry: TotalsSource): number | undefined {
+  if (typeof entry.totalTokens === "number" && Number.isFinite(entry.totalTokens) && entry.totalTokens >= 0) {
+    return entry.totalTokens;
+  }
+  const usageTotal = entry.usage?.totalTokens;
+  if (typeof usageTotal === "number" && Number.isFinite(usageTotal) && usageTotal >= 0) return usageTotal;
+  const input = entry.usage?.inputTokens;
+  const output = entry.usage?.outputTokens;
+  if (typeof input === "number" && typeof output === "number" && Number.isFinite(input) && Number.isFinite(output)) {
+    return Math.max(0, input) + Math.max(0, output);
+  }
+  return undefined;
+}
+
+/** Sum tokens/cost for the currently loaded log slice matching a conversation filter. */
+export function summarizeConversationLogs(entries: readonly TotalsSource[]): ConversationLogTotals {
+  let totalTokens = 0;
+  let estimatedCostUsd = 0;
+  let pricedRequests = 0;
+  let unpricedRequests = 0;
+  let unmeteredRequests = 0;
+  for (const entry of entries) {
+    const tokens = rowTokenTotal(entry);
+    if (tokens !== undefined) totalTokens += tokens;
+    if (entry.usageStatus === "unsupported") {
+      unmeteredRequests += 1;
+      continue;
+    }
+    const cost = entry.displayMetrics?.cost;
+    if (cost?.kind === "value" && Number.isFinite(cost.estimate.cost.total) && cost.estimate.cost.total >= 0) {
+      estimatedCostUsd += cost.estimate.cost.total;
+      pricedRequests += 1;
+      continue;
+    }
+    unpricedRequests += 1;
+  }
+  return {
+    requests: entries.length,
+    totalTokens,
+    estimatedCostUsd,
+    pricedRequests,
+    unpricedRequests,
+    unmeteredRequests,
+  };
+}

package/src/server/request-log.ts

@@ -8,6 +8,7 @@ import {
 import { CODEX_CONFIG_PATH, readRootTomlString } from "../codex/paths";
 import { readCodexCatalogPath } from "../codex/catalog";
 import type { OcxUsage } from "../types";
+import type { AdapterRequest } from "../adapters/base";
 import { redactSecretString } from "../lib/redact";
 import {
   appendUsageEntry,
@@ -28,17 +29,23 @@ import {
   USAGE_DEBUG_BODY_SAMPLE_BYTES,
   type UsageDebugBodyKind,
 } from "../usage/debug";
+import { matchesLogConversationId } from "./request-log-conversation";
 
 export interface RequestLogContext {
   model: string;
   provider: string;
   /** TTFT: ms from request start to the first non-empty model output delta (WP4, devlog 040). */
   firstOutputMs?: number;
+  /** Best-effort chat/session correlation for Logs grouping (#330). Opaque; omit when unknown. */
+  conversationId?: string;
   surface?: "claude" | "claude-desktop" | "grok";
   requestedModel?: string;
   /** Internal structural combo identity; omitted from RequestLogEntry/JSONL. */
   comboId?: string;
   requestedEffort?: string;
+  effectiveEffort?: string;
+  reasoningWireField?: string;
+  reasoningWireValue?: string | number;
   requestedServiceTier?: string;
   requestedSpeedLabel?: string;
   configuredServiceTier?: string;
@@ -70,6 +77,8 @@ export interface RequestLogContext {
   upstreamError?: string;
   /** HTTP status derived from a terminal `response.failed` SSE payload (429/401/503/etc.). */
   terminalHttpStatus?: number;
+  /** Structured reason from `response.incomplete`; internal-only input to log classification. */
+  terminalIncompleteReason?: string;
   affinity?: "reused" | "new_bind" | "rebound" | "cleared";
   transportPhase?: "pre_headers" | "mid_stream" | "terminal_sse";
   terminalSource?: "upstream" | "synthetic";
@@ -83,8 +92,13 @@ export interface RequestLogEntry {
   /** TTFT: ms from request start to the first non-empty model output delta; unset for non-streaming/tool-only. */
   firstOutputMs?: number;
   surface?: "claude" | "claude-desktop" | "grok";
+  /** Best-effort chat/session correlation for Logs grouping (#330). */
+  conversationId?: string;
   requestedModel?: string;
   requestedEffort?: string;
+  effectiveEffort?: string;
+  reasoningWireField?: string;
+  reasoningWireValue?: string | number;
   requestedServiceTier?: string;
   requestedSpeedLabel?: string;
   configuredServiceTier?: string;
@@ -146,8 +160,12 @@ export function requestLogEntryFromPersistedUsage(entry: PersistedUsageEntry): R
     provider: entry.provider,
     ...(entry.firstOutputMs !== undefined ? { firstOutputMs: entry.firstOutputMs } : {}),
     ...(isKnownUsageSurface(entry.surface) ? { surface: entry.surface } : {}),
+    ...(entry.conversationId ? { conversationId: entry.conversationId } : {}),
     ...(entry.requestedModel ? { requestedModel: entry.requestedModel } : {}),
     ...(entry.requestedEffort ? { requestedEffort: entry.requestedEffort } : {}),
+    ...(entry.effectiveEffort ? { effectiveEffort: entry.effectiveEffort } : {}),
+    ...(entry.reasoningWireField ? { reasoningWireField: entry.reasoningWireField } : {}),
+    ...(entry.reasoningWireValue !== undefined ? { reasoningWireValue: entry.reasoningWireValue } : {}),
     ...(entry.requestedServiceTier ? { requestedServiceTier: entry.requestedServiceTier } : {}),
     ...(entry.requestedSpeedLabel ? { requestedSpeedLabel: entry.requestedSpeedLabel } : {}),
     ...(entry.configuredServiceTier ? { configuredServiceTier: entry.configuredServiceTier } : {}),
@@ -222,9 +240,13 @@ export function addRequestLog(entry: RequestLogEntry) {
       provider: entry.provider,
       model: entry.model,
       ...(isKnownUsageSurface(entry.surface) ? { surface: entry.surface } : {}),
+      ...(entry.conversationId ? { conversationId: entry.conversationId } : {}),
       ...(entry.resolvedModel ? { resolvedModel: entry.resolvedModel } : {}),
       ...(entry.requestedModel ? { requestedModel: entry.requestedModel } : {}),
       ...(entry.requestedEffort ? { requestedEffort: entry.requestedEffort } : {}),
+      ...(entry.effectiveEffort ? { effectiveEffort: entry.effectiveEffort } : {}),
+      ...(entry.reasoningWireField ? { reasoningWireField: entry.reasoningWireField } : {}),
+      ...(entry.reasoningWireValue !== undefined ? { reasoningWireValue: entry.reasoningWireValue } : {}),
       ...(entry.requestedServiceTier ? { requestedServiceTier: entry.requestedServiceTier } : {}),
       ...(entry.requestedSpeedLabel ? { requestedSpeedLabel: entry.requestedSpeedLabel } : {}),
       ...(entry.configuredServiceTier ? { configuredServiceTier: entry.configuredServiceTier } : {}),
@@ -272,6 +294,71 @@ export function recordFirstOutput(
   }
 }
 
+/** Snapshot target-specific requested effort even for runTurn adapters with no AdapterRequest. */
+export function recordAttemptRequestedEffort(logCtx: RequestLogContext): void {
+  const attempt = logCtx.activeAttempt;
+  if (!attempt) return;
+  delete attempt.requestedEffort;
+  try {
+    if (typeof logCtx.requestedEffort === "string" && logCtx.requestedEffort) {
+      attempt.requestedEffort = redactSecretString(logCtx.requestedEffort).slice(0, 64);
+    }
+  } catch {
+    // Request logging is best-effort and must not affect request delivery.
+  }
+}
+
+/** Copy the adapter's exact outbound reasoning parameter into the durable request log. */
+export function recordAdapterReasoning(
+  logCtx: RequestLogContext,
+  request: AdapterRequest,
+): void {
+  delete logCtx.effectiveEffort;
+  delete logCtx.reasoningWireField;
+  delete logCtx.reasoningWireValue;
+  const attempt = logCtx.activeAttempt;
+  if (attempt) {
+    delete attempt.effectiveEffort;
+    delete attempt.reasoningWireField;
+    delete attempt.reasoningWireValue;
+  }
+  recordAttemptRequestedEffort(logCtx);
+
+  // Diagnostics must never make an otherwise valid upstream request fail. Config files
+  // written by older versions (or edited by hand) can contain values that violate the
+  // current TypeScript shape, so validate the runtime object before redacting strings.
+  try {
+    const raw: unknown = request.reasoningLog;
+    if (!raw || typeof raw !== "object" || Array.isArray(raw)) return;
+    const reasoning = raw as Record<string, unknown>;
+    if (typeof reasoning.effectiveEffort !== "string" || !reasoning.effectiveEffort
+      || (reasoning.wireField !== "reasoning_effort"
+        && reasoning.wireField !== "thinking_budget"
+        && reasoning.wireField !== "thinking.type")
+      || (!(typeof reasoning.wireValue === "string" && reasoning.wireValue)
+        && !(typeof reasoning.wireValue === "number"
+          && Number.isFinite(reasoning.wireValue)
+          && reasoning.wireValue >= 0))) {
+      return;
+    }
+
+    const effectiveEffort = redactSecretString(reasoning.effectiveEffort).slice(0, 64);
+    const wireValue = typeof reasoning.wireValue === "string"
+      ? redactSecretString(reasoning.wireValue).slice(0, 64)
+      : reasoning.wireValue;
+    logCtx.effectiveEffort = effectiveEffort;
+    logCtx.reasoningWireField = reasoning.wireField;
+    logCtx.reasoningWireValue = wireValue;
+    if (attempt) {
+      attempt.effectiveEffort = effectiveEffort;
+      attempt.reasoningWireField = reasoning.wireField;
+      attempt.reasoningWireValue = wireValue;
+    }
+  } catch {
+    // Request logging is best-effort and must not affect request delivery.
+  }
+}
+
 export function requestLogErrorCode(status: number, upstreamError?: string): string | undefined {
   if (status >= 200 && status < 400) return undefined;
   // Defense in depth: mid-stream web-search aborts used to land as 502 with this message.
@@ -447,7 +534,7 @@ export function inspectResponseLogSsePayload(logCtx: RequestLogContext, payload:
  * run it through redactSecretString so secrets never reach /api/logs. Pure; safe on any text.
  */
 function captureUpstreamError(logCtx: RequestLogContext, text: string | null): void {
-  if (!text || logCtx.upstreamError) return;
+  if (!text) return;
   try {
     const json = JSON.parse(text) as {
       type?: unknown;
@@ -459,6 +546,14 @@ function captureUpstreamError(logCtx: RequestLogContext, text: string | null): v
       };
     };
     captureTerminalHttpStatus(logCtx, json);
+    const reason = json?.response?.incomplete_details?.reason;
+    if (json.type === "response.incomplete"
+      && logCtx.terminalIncompleteReason === undefined
+      && typeof reason === "string"
+      && reason.trim()) {
+      logCtx.terminalIncompleteReason = reason.trim();
+    }
+    if (logCtx.upstreamError) return;
     const message = json?.error?.message
       ?? json?.last_error?.message
       ?? json?.response?.error?.message;
@@ -470,11 +565,11 @@ function captureUpstreamError(logCtx: RequestLogContext, text: string | null): v
     // the bridge on a stall-timeout or adapter EOF (response.incomplete). Maps the raw reason to a
     // reader-facing label so a generic 502 in /api/logs explains WHY the turn ended, not just the
     // mapped HTTP code.
-    const reason = json?.response?.incomplete_details?.reason;
     if (typeof reason === "string" && reason.trim()) {
       logCtx.upstreamError = redactSecretString(incompleteReasonLabel(reason.trim())).slice(0, 500);
     }
   } catch {
+    if (logCtx.upstreamError) return;
     const trimmed = text.trim();
     if (trimmed) {
       logCtx.upstreamError = redactSecretString(trimmed).slice(0, 500);
@@ -485,6 +580,8 @@ function captureUpstreamError(logCtx: RequestLogContext, text: string | null): v
 /** Map a raw `incomplete_details.reason` (emitted by the bridge) to a reader-facing label. */
 function incompleteReasonLabel(reason: string): string {
   switch (reason) {
+    case "max_output_tokens":
+      return `Output reached the requested token limit (${reason})`;
     case "upstream_stall_timeout":
       return `Upstream stalled: no data for the stall-timeout window (${reason})`;
     case "adapter_eof":
@@ -529,6 +626,21 @@ export function httpStatusForRequestLogTerminal(
   status: ResponsesTerminalStatus,
   logCtx?: RequestLogContext,
 ): number {
+  /**
+   * [Decision Log]
+   * - 목적과 의도: Keep request logs aligned with the successful HTTP/SSE contract.
+   * - 기존 구현 및 제약 조건: All incomplete terminals were recorded as 502 even when the
+   *   client-requested output limit was reached normally.
+   * - 검토한 주요 대안: Treat every incomplete as success, or infer the reason from display text.
+   * - 선택한 방식: Only structured max_output_tokens incompletes map to 200.
+   * - 다른 대안 대신 이 방식을 선택한 이유: Stall, EOF, and unknown incompletes must remain
+   *   visible failures, and display text is not a stable classification contract.
+   * - 장점, 단점 및 영향: Logs stop reporting false upstream errors while retaining the
+   *   incomplete terminal detail; native callers without a structured reason keep old behavior.
+   */
+  if (status === "incomplete" && logCtx?.terminalIncompleteReason === "max_output_tokens") {
+    return 200;
+  }
   if (status === "failed" && logCtx?.terminalHttpStatus !== undefined) {
     return logCtx.terminalHttpStatus;
   }
@@ -583,8 +695,12 @@ export function addFinalRequestLog(
     model: isCombo ? logCtx.requestedModel! : logCtx.model,
     provider: isCombo ? "combo" : logCtx.provider,
     ...(logCtx.surface ? { surface: logCtx.surface } : {}),
+    ...(logCtx.conversationId ? { conversationId: logCtx.conversationId } : {}),
     ...(logCtx.requestedModel ? { requestedModel: logCtx.requestedModel } : {}),
     ...(logCtx.requestedEffort ? { requestedEffort: logCtx.requestedEffort } : {}),
+    ...(logCtx.effectiveEffort ? { effectiveEffort: logCtx.effectiveEffort } : {}),
+    ...(logCtx.reasoningWireField ? { reasoningWireField: logCtx.reasoningWireField } : {}),
+    ...(logCtx.reasoningWireValue !== undefined ? { reasoningWireValue: logCtx.reasoningWireValue } : {}),
     ...(logCtx.requestedServiceTier ? { requestedServiceTier: logCtx.requestedServiceTier } : {}),
     ...(logCtx.requestedSpeedLabel ? { requestedSpeedLabel: logCtx.requestedSpeedLabel } : {}),
     ...(logCtx.configuredServiceTier ? { configuredServiceTier: logCtx.configuredServiceTier } : {}),
@@ -629,6 +745,10 @@ export function filterRequestLogs(logs: RequestLogEntry[], params: URLSearchPara
     filtered = filtered.filter(entry => entry.provider === provider
       || entry.attempts?.some(attempt => attempt.provider === provider));
   }
+  const conversationId = params.get("conversationId")?.trim() || params.get("conversation")?.trim();
+  if (conversationId) {
+    filtered = filtered.filter(entry => matchesLogConversationId(entry.conversationId, conversationId));
+  }
   const status = params.get("status")?.trim().toLowerCase();
   if (status) {
     filtered = /^[1-5]xx$/.test(status)

package/src/server/responses/core.ts

@@ -27,6 +27,7 @@ import {
 } from "../../combos";
 import { isInjectionDebugEnabled } from "../../lib/debug-settings";
 import { injectionDebugLog } from "../../lib/injection-debug-log";
+import { resolveClientRetryAfter } from "../../lib/retry-after";
 import { modelInList, namespacedToolName } from "../../types";
 import type { AdapterEvent, OcxConfig, OcxParsedRequest, OcxProviderConfig, OcxProviderContinuationState, OcxUsage } from "../../types";
 import {
@@ -92,11 +93,18 @@ import {
   inspectResponseLogJson,
   noteAttemptSend,
   readConfiguredCodexServiceTier,
+  recordAdapterReasoning,
+  recordAttemptRequestedEffort,
   requestLogSpeedLabel,
   sealRequestAttemptIdentity,
   usageFromResponsesPayload,
   type RequestLogContext,
 } from "../request-log";
+import {
+  conversationIdFromResponsesRequest,
+  normalizeLogConversationId,
+  sessionIdHeaderFromRequest,
+} from "../request-log-conversation";
 import type { AttemptRecoveryKind } from "../../usage/log";
 import {
   consumeForInspection,
@@ -347,14 +355,30 @@ export async function consumeComboFailure(
   const message = classificationText === fallback
     ? fallback
     : `${fallback}: ${classificationText}`;
-  const retryAfter = sanitizedRetryAfter(response.headers.get("retry-after"), now);
+  const upstreamRetryAfter = response.headers.get("retry-after");
+  // Client response may get the synthetic "2" fallback; cooldown metadata must not —
+  // otherwise coolComboTarget treats it as a 2s cooldown instead of the 60s default.
+  const clientRetryAfter = resolveClientRetryAfter({
+    status: response.status,
+    message,
+    upstreamRetryAfter,
+    now,
+  });
+  const cooldownRetryAfter = resolveClientRetryAfter({
+    status: response.status,
+    message,
+    upstreamRetryAfter,
+    now,
+    includeDefault: false,
+  });
   return {
     response: formatErrorResponse(response.status, "upstream_error", message, {
       ...(upstreamCode !== undefined ? { code: upstreamCode } : {}),
+      ...(clientRetryAfter !== undefined ? { retryAfter: clientRetryAfter } : {}),
     }),
     classificationText,
     ...(upstreamCode !== undefined ? { upstreamCode } : {}),
-    ...(retryAfter !== undefined ? { retryAfter } : {}),
+    ...(cooldownRetryAfter !== undefined ? { retryAfter: cooldownRetryAfter } : {}),
     ...(usage ? { usage } : {}),
   };
 }
@@ -593,6 +617,7 @@ async function applyFinalRouteRequestNormalization(args: {
       logCtx.requestedEffort = `${logCtx.requestedEffort ?? "max"}->${clamped}`;
     }
   }
+  recordAttemptRequestedEffort(logCtx);
   logCtx.modelSupportsServiceTier = catalogModelSupportsServiceTier(
     route.modelId,
     logCtx.requestedServiceTier ?? logCtx.configuredServiceTier,
@@ -622,6 +647,19 @@ export async function handleComboResponses(
   if (!combo) {
     return formatErrorResponse(404, "invalid_request_error", `Unknown combo: ${comboId}`);
   }
+  const adoptFailedChildLog = (childLog: RequestLogContext): void => {
+    // Attempts remain the complete physical history; the logical row mirrors the most recent
+    // failed target so an exhausted combo still has useful top-level reasoning diagnostics.
+    Object.assign(logCtx, childLog, {
+      requestedModel,
+      model: requestedModel,
+      provider: "combo",
+      comboId,
+      attempts: logCtx.attempts,
+      activeAttempt: undefined,
+      activeAttemptStartedAt: undefined,
+    });
+  };
 
   const unreadableEncryptedAgentTask = hasUnreadableEncryptedAgentTask(
     (rawBody as { input?: unknown } | undefined)?.input,
@@ -658,6 +696,8 @@ export async function handleComboResponses(
     const childLog: RequestLogContext = {
       model: pick.target.model,
       provider: pick.target.provider,
+      ...(logCtx.conversationId ? { conversationId: logCtx.conversationId } : {}),
+      ...(logCtx.surface ? { surface: logCtx.surface } : {}),
     };
     const targetRoute = routeModel(config, `${pick.target.provider}/${pick.target.model}`);
     const childBody = concreteComboRequestBody(
@@ -792,25 +832,19 @@ export async function handleComboResponses(
     if (comboFailureDecision(failure.response.status, failure.classificationText, {
       code: failure.upstreamCode,
     }) === "stop") {
-      Object.assign(logCtx, childLog, {
-        requestedModel,
-        model: requestedModel,
-        provider: "combo",
-        comboId,
-        attempts: logCtx.attempts,
-        activeAttempt: undefined,
-        activeAttemptStartedAt: undefined,
-      });
+      adoptFailedChildLog(childLog);
       return lastFailure;
     }
     console.warn(
       `[combo] ${comboId}: ${targetKey(pick.target)} failed with ${response.status} after ${Date.now() - started}ms`,
     );
-    pick = advanceComboAfterFailure(config, pick, {
+    const nextPick = advanceComboAfterFailure(config, pick, {
       retryAfter: failure.retryAfter,
       now: Date.now(),
       eligible: payloadEligible,
     });
+    if (!nextPick) adoptFailedChildLog(childLog);
+    pick = nextPick;
   }
   return lastFailure!;
 }
@@ -866,6 +900,16 @@ export async function handleResponses(
   } catch (err) {
     return formatErrorResponse(400, "invalid_request_error", err instanceof Error ? err.message : String(err));
   }
+  // Prefer a pre-populated id (routed Claude) over Responses headers that may be
+  // absent or synthetically injected (session_id from prompt_cache_key).
+  if (!logCtx.conversationId) {
+    logCtx.conversationId = conversationIdFromResponsesRequest({
+      clientThreadId: parsed._clientThreadId,
+      sessionIdHeader: sessionIdHeaderFromRequest(req.headers),
+      threadIdHeader: req.headers.get("thread-id"),
+      cursorConversationId: parsed._cursorConversationId,
+    });
+  }
   logCtx.requestedModel = parsed.modelId;
   logCtx.requestedEffort = parsed.options.reasoning;
   logCtx.requestedServiceTier = parsed.options.serviceTier;
@@ -1124,6 +1168,7 @@ export async function handleResponses(
       );
     }
     let request = await adapter.buildRequest(parsed, { headers: selectedForwardHeaders });
+    recordAdapterReasoning(logCtx, request);
     const passthroughEstimate = typeof request.usageLog?.inputTokens === "number"
       ? request.usageLog.inputTokens
       : undefined;
@@ -1213,6 +1258,7 @@ export async function handleResponses(
           config.cacheRetention,
         );
         request = await retryAdapter.buildRequest(parsed, { headers: retryHeaders });
+        recordAdapterReasoning(logCtx, request);
 
         await upstreamResponse.body?.cancel().catch(() => undefined);
         authCtx = retryAuthCtx;
@@ -1500,6 +1546,11 @@ export async function handleResponses(
           message: err instanceof Error ? err.message : String(err),
         });
       } finally {
+        // Cursor assigns a stable conversation id inside runTurn on the first headerless
+        // turn; backfill so Logs can filter/total that opening request (#330 / #522).
+        if (!logCtx.conversationId && parsed._cursorConversationId) {
+          logCtx.conversationId = normalizeLogConversationId(parsed._cursorConversationId);
+        }
         queue.close();
       }
     };
@@ -1614,6 +1665,7 @@ export async function handleResponses(
       forceEmptyResponseId: true,
       abortSignal: options.abortSignal,
       ...(options.onFirstOutput ? { onFirstOutput: options.onFirstOutput } : {}),
+      onRequestBuilt: request => recordAdapterReasoning(logCtx, request),
       onUsage: usage => {
         logCtx.usageFromBridge = true;
         if (usage) {
@@ -1658,6 +1710,7 @@ export async function handleResponses(
   let activeAdapter = adapter;
 
   const request = await activeAdapter.buildRequest(parsed, { headers: selectedForwardHeaders });
+  recordAdapterReasoning(logCtx, request);
   const inputTokenEstimate = typeof request.usageLog?.inputTokens === "number"
     ? request.usageLog.inputTokens
     : undefined;
@@ -1710,6 +1763,7 @@ export async function handleResponses(
         headers: selectedForwardHeaders,
         ...(imageTierBias > 0 ? { imageTierBias } : {}),
       });
+      recordAdapterReasoning(logCtx, retryRequest);
       const retryEstimate = typeof retryRequest.usageLog?.inputTokens === "number"
         ? retryRequest.usageLog.inputTokens
         : undefined;
@@ -1830,7 +1884,15 @@ export async function handleResponses(
       );
       // Upstreams occasionally echo request details in error bodies — scrub token-shaped
       // material before it reaches the client-facing error surface.
-      return formatErrorResponse(upstreamResponse.status, "upstream_error", `Provider error ${upstreamResponse.status}: ${redactSecretString(errorText.slice(0, 500))}`);
+      const message = `Provider error ${upstreamResponse.status}: ${redactSecretString(errorText.slice(0, 500))}`;
+      const retryAfter = resolveClientRetryAfter({
+        status: upstreamResponse.status,
+        message,
+        upstreamRetryAfter: upstreamResponse.headers.get("retry-after"),
+      });
+      return formatErrorResponse(upstreamResponse.status, "upstream_error", message, {
+        ...(retryAfter !== undefined ? { retryAfter } : {}),
+      });
     }
   }
 
@@ -1850,6 +1912,7 @@ export async function handleResponses(
           headers: selectedForwardHeaders,
           ...(imageTierBias > 0 ? { imageTierBias } : {}),
         });
+        recordAdapterReasoning(logCtx, continuationRequest);
         const continuationEstimate = typeof continuationRequest.usageLog?.inputTokens === "number"
           ? continuationRequest.usageLog.inputTokens
           : undefined;