@bitkyc08/opencodex 2.67.0-preview.20260926 → 2.68.0-preview.20260927

package/src/adapters/coding-agent/turn.ts

@@ -380,7 +380,7 @@ export async function runCodingAgentTurn(input: CodingAgentTurnInput): Promise<v
     sawPartialText: false,
     sawPartialThinking: false,
     sawTerminalResult: false,
-    openToolCallId: undefined,
+    openToolBlocks: new Map(),
     partialToolCallIds: toolBridge ? new Set<string>() : undefined,
   };
 
@@ -422,6 +422,29 @@ export async function runCodingAgentTurn(input: CodingAgentTurnInput): Promise<v
             break;
           }
           if (message.type === "system" && message.subtype === "init") initValidated = true;
+          const rawEvent = message.type === "stream_event" && message.event !== null && typeof message.event === "object"
+            ? message.event as Record<string, unknown>
+            : undefined;
+          const rawBlock = rawEvent?.content_block;
+          if (
+            !initValidated
+            && rawEvent?.type === "content_block_start"
+            && rawBlock !== null
+            && typeof rawBlock === "object"
+            && !Array.isArray(rawBlock)
+            && (rawBlock as Record<string, unknown>).type === "tool_use"
+          ) {
+            emitOnce({
+              type: "error",
+              message: "Coding-agent CLI called a tool before the tool bridge init handshake completed.",
+              status: 502,
+              errorType: "upstream_error",
+              code: "tool_bridge_init_missing",
+              retryable: false,
+            });
+            kill();
+            break;
+          }
         }
         const mappedEvents = mapStreamMessageToEvents(message, state);
         if (toolBridge && state.uncapturedToolUse) {
@@ -451,24 +474,6 @@ export async function runCodingAgentTurn(input: CodingAgentTurnInput): Promise<v
             break;
           }
           if (toolBridge && event.type === "tool_call_start") {
-            // The catalog is only advertised once the CLI has acknowledged the bridge server in
-            // its init handshake. A tool call that arrives before that acknowledgement means the
-            // model acted on a catalog this bridge never validated, so fail closed before the
-            // call is counted or renamed. Checking at arrival matters: a later init frame used to
-            // set initValidated and let an early call finish as a successful done(tool_use).
-            if (!initValidated) {
-              emitOnce({
-                type: "error",
-                message: "Coding-agent CLI called a tool before the tool bridge init handshake completed.",
-                status: 502,
-                errorType: "upstream_error",
-                code: "tool_bridge_init_missing",
-                retryable: false,
-              });
-              failClosed = true;
-              kill();
-              break;
-            }
             toolCallStarts += 1;
             if (toolCallStarts > toolBridge.maxTurnToolCalls) {
               emitOnce({
@@ -527,8 +532,8 @@ export async function runCodingAgentTurn(input: CodingAgentTurnInput): Promise<v
             toolBridge
             && !terminalEmitted
             && event.type === "done"
-            && toolCallStarts > 0
-            && (state.completedToolCalls ?? 0) !== toolCallStarts
+            && (state.toolBlockStarts ?? 0) > 0
+            && (state.completedToolCalls ?? 0) !== (state.toolBlockStarts ?? 0)
           ) {
             // A terminal result that arrives while a captured tool call is still open must not
             // become a successful completion the client can accept. The message_stop check after
@@ -552,8 +557,8 @@ export async function runCodingAgentTurn(input: CodingAgentTurnInput): Promise<v
             toolBridge
             && !terminalEmitted
             && event.type === "done"
-            && toolCallStarts > 0
-            && (state.completedToolCalls ?? 0) === toolCallStarts
+            && (state.toolBlockStarts ?? 0) > 0
+            && (state.completedToolCalls ?? 0) === (state.toolBlockStarts ?? 0)
           ) {
             // Every captured call completed and the CLI settled with a successful result before
             // message_stop (instead of parking on the never-answering capture server). Emitting
@@ -573,8 +578,8 @@ export async function runCodingAgentTurn(input: CodingAgentTurnInput): Promise<v
           toolBridge
           && !terminalEmitted
           && state.sawMessageStop
-          && toolCallStarts > 0
-          && (state.completedToolCalls ?? 0) !== toolCallStarts
+          && (state.toolBlockStarts ?? 0) > 0
+          && (state.completedToolCalls ?? 0) !== (state.toolBlockStarts ?? 0)
         ) {
           emitOnce({
             type: "error",
@@ -588,8 +593,8 @@ export async function runCodingAgentTurn(input: CodingAgentTurnInput): Promise<v
           break;
         }
         if (toolBridge && !terminalEmitted && state.sawMessageStop && (state.completedToolCalls ?? 0) > 0) {
-          // No init re-check here: a completed call implies a tool_call_start was mapped, and the
-          // arrival-time gate above already refuses any start that lands before the handshake.
+          // Raw tool_use starts are gated before buffering, so every completed call was admitted
+          // after the bridge init handshake.
           // The capture-only MCP handler never answers, so the CLI parks after message_stop.
           // The completed tool_use blocks are this turn's structured output: end the leg here
           // and terminate the tree; the client executes, and the next request continues.

package/src/adapters/devin/cloud-direct/index.ts

@@ -51,6 +51,7 @@ export {
 
 export {
   streamChatEventsWithResetRetry,
+  devinStatedResetWaitMs,
   STATED_RESET_MAX_REPLAYS,
   STATED_RESET_MAX_WAIT_MS,
   type StatedResetRetryOptions,

package/src/adapters/devin/cloud-direct/stated-reset-retry.ts

@@ -17,21 +17,26 @@ export const STATED_RESET_MAX_WAIT_MS = 1_800_000;
 /** Absolute maximum cumulative allowance, including explicit overrides. */
 export const STATED_RESET_WAIT_CEILING_MS = 3_600_000;
 
-function statedResetMaxWaitMs(): number {
+function statedResetMaxWaitMs(defaultMs = STATED_RESET_MAX_WAIT_MS): number {
   const raw = process.env.OPENCODEX_DEVIN_STATED_RESET_WAIT_MS?.trim();
-  if (!raw) return STATED_RESET_MAX_WAIT_MS;
+  if (!raw) return defaultMs;
   const parsed = Number(raw);
-  if (!Number.isFinite(parsed) || parsed < 0) return STATED_RESET_MAX_WAIT_MS;
+  if (!Number.isFinite(parsed) || parsed < 0) return defaultMs;
   // Zero explicitly disables local waiting. Values above one hour are capped.
   return Math.min(Math.floor(parsed), STATED_RESET_WAIT_CEILING_MS);
 }
 export const statedResetMaxWaitMsForTests = statedResetMaxWaitMs;
 
+export function devinStatedResetWaitMs(): number {
+  return statedResetMaxWaitMs(0);
+}
+
 export interface StatedResetRetryOptions {
   /** Test seam: defaults to the real cloud stream. */
   stream?: (req: CloudChatRequest) => AsyncGenerator<CloudChatEvent>;
   /** Test seam: must either honour the whole delay or reject on cancellation. */
   sleep?: (ms: number, signal?: AbortSignal) => Promise<void>;
+  onWaitHeartbeat?: () => void;
   maxReplays?: number;
   /** CUMULATIVE wait allowance, not a fresh allowance on every failure. */
   maxWaitMs?: number;
@@ -136,7 +141,16 @@ export async function* streamChatEventsWithResetRetry(
       // scheduling: waking a few milliseconds late must not reject an already
       // approved one-hour retry. No later wait can spend this allowance again.
       waitedMs += waitMs;
-      await sleep(waitMs, req.signal);
+      const heartbeat = options?.onWaitHeartbeat;
+      if (waitMs > 0) heartbeat?.();
+      const beat = heartbeat && waitMs > 0
+        ? setInterval(heartbeat, Math.min(500, Math.max(100, Math.floor(waitMs / 2))))
+        : undefined;
+      try {
+        await sleep(waitMs, req.signal);
+      } finally {
+        if (beat !== undefined) clearInterval(beat);
+      }
       if (req.signal?.aborted) throw abortError(req.signal);
     }
   }

package/src/adapters/devin.ts

@@ -9,7 +9,7 @@
 import type { AdapterEvent, OcxAssistantMessage, OcxContentPart, OcxMessage, OcxParsedRequest, OcxProviderConfig, OcxTool, OcxToolCall, OcxToolResultMessage, OcxUsage } from "../types";
 import { namespacedToolName } from "../types";
 import type { IncomingMeta, ProviderAdapter } from "./base";
-import { streamChatEventsWithResetRetry, allocateCascadeId, CloudChatError, type ChatHistoryItem, type ToolDef } from "./devin/cloud-direct";
+import { streamChatEventsWithResetRetry, devinStatedResetWaitMs, allocateCascadeId, CloudChatError, type ChatHistoryItem, type ToolDef } from "./devin/cloud-direct";
 import type { ContentPart } from "./devin/cloud-direct/chat";
 import { getCachedCatalog, type CacheEntry } from "./devin/cloud-direct/catalog";
 import { collapseDevinModelUid } from "./devin/live-models";
@@ -642,11 +642,12 @@ export function createDevinAdapter(
         const maxOutputTokens = resolveDevinMaxOutputTokens(
           provider, modelUid, parsed.options.maxOutputTokens,
         );
+        // A combo child has not committed an outer response yet. Holding its preflight through
+        // a reset wait would also hold the next-target fallback with no client keepalive.
+        const resetWaitMs = incoming.comboAttempt ? 0 : devinStatedResetWaitMs();
         // An admitted HTTP turn owns globally shared capacity until this call
-        // emits. Never retain that capacity while waiting out a provider 429:
-        // preserve the typed reset delay in generated diagnostic wording,
-        // never the raw trailer text that may reflect a credential. The
-        // refusal returns immediately so the caller can release its slot.
+        // emits. Without an explicit wait allowance, preserve the typed reset
+        // delay in generated diagnostic wording and return immediately.
         for await (const event of streamChatEventsWithResetRetry({
           apiKey,
           apiServerUrl: host,
@@ -665,7 +666,9 @@ export function createDevinAdapter(
           },
           signal: incoming.abortSignal,
         }, {
-          maxWaitMs: 0,
+          maxWaitMs: resetWaitMs,
+          onWaitHeartbeat: resetWaitMs > 0 && parsed.stream
+            ? () => emit({ type: "heartbeat", preflightReady: true }) : undefined,
           execution: {
             executor: incoming.providerFetch,
             sendBudget: incoming.sendBudget,

package/src/adapters/google-http.ts

@@ -14,10 +14,10 @@ import {
   retryBackoffDelayMs,
   sleepWithAbort,
   SendBudgetExhaustedError,
+  TRANSIENT_RETRY_MAX_ATTEMPTS,
   isConnectionResetError,
 } from "../lib/upstream-retry";
 
-const GOOGLE_RETRY_ATTEMPTS = 3;
 const GOOGLE_RETRY_BASE_MS = 250;
 const GOOGLE_RETRY_MAX_MS = 2_000;
 
@@ -60,7 +60,7 @@ export async function fetchGoogleWithRetry(
   let retryDelayMs = 0;
   let sendClass: SendClass = "transient";
   let recovery: AttemptRecoveryKind | undefined;
-  for (let attempt = 0; attempt < GOOGLE_RETRY_ATTEMPTS; attempt++) {
+  for (let attempt = 0; attempt < TRANSIENT_RETRY_MAX_ATTEMPTS; attempt++) {
     if (ctx.abortSignal?.aborted) throw abortError(ctx.abortSignal);
     try {
       const res = await send({ url: activeRequest.url, sendClass, recovery,
@@ -105,7 +105,7 @@ export async function fetchGoogleWithRetry(
           continue;
         }
       }
-      if (!retryableGoogleStatus(res.status) || attempt === GOOGLE_RETRY_ATTEMPTS - 1) {
+      if (!retryableGoogleStatus(res.status) || attempt === TRANSIENT_RETRY_MAX_ATTEMPTS - 1) {
         return ctx.returnRawErrors ? res : normalizeFinalGoogleError(label, res, ctx.abortSignal);
       }
       // A 429 may be a transient rate limit (retry) or hard quota exhaustion (do NOT retry —
@@ -141,7 +141,7 @@ export async function fetchGoogleWithRetry(
         throw err;
       }
       lastError = err;
-      if (attempt === GOOGLE_RETRY_ATTEMPTS - 1) throw err;
+      if (attempt === TRANSIENT_RETRY_MAX_ATTEMPTS - 1) throw err;
       sendClass = "transient";
       recovery = isConnectionResetError(err) ? "connection-reset" : undefined;
       retryDelayMs = retryBackoffDelayMs(attempt, {

package/src/adapters/google.ts

@@ -231,6 +231,72 @@ function toolResultImageParts(content: string | OcxContentPart[]): unknown[] {
  * surfaced on Claude-on-Antigravity; the guard lives here because this is where the parts are
  * built. Mirrors the Anthropic adapter's own empty-block guard (src/adapters/anthropic.ts).
  */
+/**
+ * A video URI Gemini fetches on its own behalf, as a `file_data` reference.
+ *
+ * Deliberately an allowlist of the forms Google documents, not "anything that is
+ * not a data: URL". `file_data` tells Gemini to go and get the bytes; pointing it
+ * at an arbitrary host would either fail upstream or make the proxy the reason a
+ * caller's private URL got dereferenced by Google. Anything not matched here
+ * keeps the existing `[video: …]` text marker.
+ *
+ * Returns the uri alone: the documented REST example for a YouTube part carries
+ * `file_data.file_uri` and nothing else, and the Files API knows the type of what
+ * it stored. An invented `mime_type` would be a guess on both paths.
+ *
+ * https://ai.google.dev/gemini-api/docs/generate-content/video-understanding
+ */
+function geminiFetchableVideoUri(url: string): string | null {
+  let parsed: URL;
+  try {
+    parsed = new URL(url);
+  } catch {
+    return null;
+  }
+  if (parsed.protocol !== "https:") return null;
+
+  const host = parsed.hostname.toLowerCase();
+  const youtubeHosts = new Set([
+    "youtube.com",
+    "www.youtube.com",
+    "m.youtube.com",
+    "music.youtube.com",
+    "youtu.be",
+    "www.youtube-nocookie.com",
+    "youtube-nocookie.com",
+  ]);
+  if (youtubeHosts.has(host)) return url;
+
+  // The Files API resource form, https://generativelanguage.googleapis.com/v1beta/files/<id>.
+  // Anchored at the start so the resumable-upload endpoint (/upload/v1beta/files/<id>) does
+  // not match: that URL is not a readable resource, and passing it as `file_data.file_uri`
+  // would have Gemini dereference something it cannot read. The version segment stays loose
+  // because this service is reachable as v1, v1beta and v1alpha.
+  if (host === "generativelanguage.googleapis.com" && /^\/v1[a-z0-9]*\/files\/[^/]+$/.test(parsed.pathname)) {
+    return url;
+  }
+
+  return null;
+}
+
+/**
+ * The caller's requested video mode as GenerateContent spells it.
+ *
+ * `media_processing` sits on the part beside `inline_data`/`file_data` and takes
+ * `STATIC` (the default) or `AGENTIC`. `processing: "agentic"` — the spelling in
+ * the original request and in Google's Interactions API — is a different API and
+ * is ignored here, so forwarding it verbatim would have looked like a
+ * pass-through while agentic mode never actually engaged.
+ *
+ * Upper-cased and forwarded rather than checked against our own copy of the enum:
+ * that list is Google's to extend, and a stale allowlist here would silently
+ * downgrade a caller using a newer mode. An unrecognized value fails upstream
+ * naming the field, which is a better failure than us dropping it.
+ */
+function geminiMediaProcessing(processing: string | undefined): string | undefined {
+  return processing ? processing.toUpperCase() : undefined;
+}
+
 const GEMINI_EMPTY_PLACEHOLDER = "(empty)";
 const GEMINI_EMPTY_TOOL_OUTPUT_PLACEHOLDER = "(empty tool output)";
 const GEMINI_MISSING_TOOL_RESULT = "[missing tool_result for this tool_use in history]";
@@ -341,10 +407,34 @@ function messagesToGeminiFormat(
               continue;
             }
             if (p.type === "video") {
+              // `media_processing` rides on the PART, so it applies to inline bytes
+              // exactly as it does to a fetched uri — emitting it on only one of the
+              // two would silently drop the mode for data: URLs.
+              const mediaProcessing = geminiMediaProcessing(p.processing);
+              const processingPart = mediaProcessing ? { media_processing: mediaProcessing } : {};
+
+              // Gemini accepts inline video bytes in the same Part union as images.
               const data = parseDataUrl(p.videoUrl);
-              // Gemini accepts inline video bytes in the same Part union as images. Arbitrary
-              // remote URLs are not valid fileData references, so retain only a short marker.
-              parts.push(data ? { inline_data: { mime_type: data.mediaType, data: data.base64 } } : { text: `[video: ${p.videoUrl}]` });
+              if (data) {
+                parts.push({
+                  inline_data: { mime_type: data.mediaType, data: data.base64 },
+                  ...processingPart,
+                });
+                continue;
+              }
+              // Two URI forms Gemini fetches itself: a YouTube watch URL and a Files API
+              // uri. Those ARE valid file_data references (#3271), and flattening them to
+              // a text marker was the whole reason agentic video could not be reached —
+              // the video never arrived as a video. Every other remote URL keeps the
+              // marker: we have no mime type for it and no evidence Gemini can fetch it.
+              const fileUri = geminiFetchableVideoUri(p.videoUrl);
+              if (fileUri) {
+                // Emitted only when the caller asked for a mode, so no existing
+                // request gains a field it did not have.
+                parts.push({ file_data: { file_uri: fileUri }, ...processingPart });
+                continue;
+              }
+              parts.push({ text: `[video: ${p.videoUrl}]` });
               continue;
             }
             if (p.type === "document") {

package/src/adapters/kiro/adapter.ts

@@ -63,6 +63,7 @@ export function createKiroAdapter(provider: OcxProviderConfig): ProviderAdapter
   let requestSnapshot: OcxParsedRequest | undefined;
   let firstRequestBodyBytes = 0;
   let requestAbortSignal: AbortSignal | undefined;
+  let requestExecutor: typeof globalThis.fetch | undefined;
   // Captured the same way as the abort signal, because the text-fallback rebuild below runs
   // outside the fetchResponse frame and used to construct a context without either (#4546).
   let requestSendBudget: RequestExecutionBudget | undefined;
@@ -236,6 +237,8 @@ export function createKiroAdapter(provider: OcxProviderConfig): ProviderAdapter
       const fallbackOrdinalBase = physicalSendsObserved;
       const response = await fetchKiroWithRetry(retry.request, {
         abortSignal: requestAbortSignal,
+        ...(requestExecutor ? { executor: requestExecutor } : {}),
+        allowGatewayRotation: !_sawReasoning && !assistantText.trim(),
         returnRawErrors: true,
         stream: true,
         // The text-fallback rebuild used to construct a fresh context and drop the budget,
@@ -318,6 +321,7 @@ export function createKiroAdapter(provider: OcxProviderConfig): ProviderAdapter
       // Keep it for the adapter-owned bounded continuation so cancelling the client turn aborts
       // both the first Kiro request and its one allowed completion retry.
       if (ctx?.abortSignal) requestAbortSignal = ctx.abortSignal;
+      requestExecutor = ctx?.executor;
       if (ctx?.sendBudget) requestSendBudget = ctx.sendBudget;
       if (ctx?.onPhysicalSend) requestOnPhysicalSend = ctx.onPhysicalSend;
       // Reset per fetch call, because `ordinal` is defined within one call and the caller records
@@ -327,8 +331,8 @@ export function createKiroAdapter(provider: OcxProviderConfig): ProviderAdapter
       // Routed through the same forwarder as the fallback so both legs share one ordinal
       // sequence; a context without an observer is passed through untouched.
       return fetchKiroWithRetry(request, requestOnPhysicalSend
-        ? { ...ctx, onPhysicalSend: (send: KiroPhysicalSend) => forwardPhysicalSend(send, 0) }
-        : ctx);
+        ? { ...ctx, returnRawErrors: true, onPhysicalSend: (send: KiroPhysicalSend) => forwardPhysicalSend(send, 0) }
+        : { ...ctx, returnRawErrors: true });
     },
 
     formatErrorBody(status: number, headers: Headers, payloadText: string): string {

package/src/adapters/kiro/stream.ts

@@ -12,6 +12,7 @@ import {
   classifyKiroHttpError,
   classifyKiroStreamError,
   safeKiroErrorMessage,
+  safeKiroHttpErrorMessage,
   type KiroErrorClassification,
 } from "../kiro-errors";
 import { parseKiroEvent } from "../kiro-events";
@@ -175,6 +176,7 @@ function mergeKiroUsage(
     ...(sumOptional("cachedInputTokens") !== undefined ? { cachedInputTokens: sumOptional("cachedInputTokens") } : {}),
     ...(sumOptional("cacheReadInputTokens") !== undefined ? { cacheReadInputTokens: sumOptional("cacheReadInputTokens") } : {}),
     ...(sumOptional("cacheCreationInputTokens") !== undefined ? { cacheCreationInputTokens: sumOptional("cacheCreationInputTokens") } : {}),
+    ...(sumOptional("providerCredits") !== undefined ? { providerCredits: sumOptional("providerCredits") } : {}),
     ...(sumOptional("reasoningOutputTokens") !== undefined ? { reasoningOutputTokens: sumOptional("reasoningOutputTokens") } : {}),
     ...(first.estimated || second.estimated ? { estimated: true } : {}),
   };
@@ -319,6 +321,7 @@ async function* parseKiroAttemptEvents(
   let completionAnswer: string | undefined;
   let completionCalls = 0;
   let authoritativeUsage: OcxUsage | undefined;
+  let providerCredits: number | undefined;
   let stopReason: string | undefined;
   const fallbackEvents: AdapterEvent[] = [];
   const thinking = new InlineThinkTagParser(budget);
@@ -379,7 +382,11 @@ async function* parseKiroAttemptEvents(
       contextUsageTotalFloor() ?? 0,
       authoritativeTurnTotal,
     );
-    return contextTotal > 0 ? { ...base, contextTotalTokens: contextTotal } : base;
+    return {
+      ...base,
+      ...(contextTotal > 0 ? { contextTotalTokens: contextTotal } : {}),
+      ...(providerCredits !== undefined ? { providerCredits } : {}),
+    };
   };
 
   const classifiedTerminal = (failure: KiroErrorClassification): AdapterEvent => {
@@ -599,6 +606,9 @@ async function* parseKiroAttemptEvents(
       const ev = parseKiroEvent(eventType, msg.payload);
       if (!ev) continue;
       switch (ev.type) {
+        case "metering":
+          if (ev.unit === "credit" || ev.unit === "credits") providerCredits = ev.usage;
+          break;
         case "metadata":
           if (ev.usage) authoritativeUsage = ev.usage;
           if (ev.contextUsagePercentage !== undefined && ev.contextUsagePercentage > 0) {
@@ -1098,7 +1108,7 @@ export async function* parseKiroStream(
       const failure = classifyKiroHttpError(fallback.response.status, fallback.response.headers, payload);
       yield {
         type: "error",
-        message: failure.message,
+        message: safeKiroHttpErrorMessage(fallback.response.status, fallback.response.headers, payload),
         status: failure.status,
         errorType: failure.errorType,
         code: failure.code,

package/src/adapters/kiro/usage.ts

@@ -1,5 +1,6 @@
 import { estimateTokens, estimateTokensFromCharacterCounts } from "../../lib/token-estimate";
 import { KIRO_MODEL_CONTEXT_WINDOWS, normalizeKiroModelId } from "../../providers/kiro-models";
+import { kiroObservedContextWindow } from "../../providers/kiro-model-catalog";
 import { modelRecordValue } from "../../reasoning-effort";
 import { sniffImageDimensions } from "../anthropic-image-guard";
 import type { KiroImage } from "../kiro-images";
@@ -219,7 +220,8 @@ export function kiroUpstreamContextWindow(modelId: string | undefined): number |
   if (!modelId) return undefined;
   const normalizedModelId = normalizeKiroModelId(modelId);
   if (normalizedModelId === "auto") return undefined;
-  const window = modelRecordValue(KIRO_MODEL_CONTEXT_WINDOWS, modelId)
+  const window = kiroObservedContextWindow(modelId)
+    ?? modelRecordValue(KIRO_MODEL_CONTEXT_WINDOWS, modelId)
     ?? modelRecordValue(KIRO_MODEL_CONTEXT_WINDOWS, normalizedModelId);
   return typeof window === "number" && Number.isFinite(window) && window > 0 ? window : undefined;
 }

package/src/adapters/kiro-errors.ts

@@ -1,5 +1,7 @@
 import { parseUpstreamJsonPayload, safeUpstreamErrorString, sanitizeUpstreamErrorText } from "./upstream-http-error";
+import { debugProviderDiagnostic } from "../lib/debug";
 const DETAIL_KEYS = ["__type", "code", "error", "name", "reason", "message", "Message", "errorMessage"];
+const KIRO_5XX_DIAGNOSTIC_STATUSES = new Set([500, 502, 503, 504]);
 
 export interface KiroErrorClassification {
   message: string;
@@ -204,5 +206,13 @@ export function classifyKiroEventError(reason: string | undefined, message: stri
 }
 
 export function safeKiroHttpErrorMessage(status: number, headers: Headers | Record<string, unknown>, payloadText: string): string {
-  return classifyKiroFailure(headers, payloadText, status).message;
+  const failure = classifyKiroFailure(headers, payloadText, status);
+  if (status >= 500) {
+    debugProviderDiagnostic("kiro", "http_error", {
+      status: KIRO_5XX_DIAGNOSTIC_STATUSES.has(status) ? status : "other_5xx",
+      code: failure.code === "server_is_overloaded" ? "server_is_overloaded" : "upstream_server_error",
+    });
+    return status === 504 ? "Kiro upstream gateway timeout" : "Kiro upstream service unavailable";
+  }
+  return failure.message;
 }

package/src/adapters/kiro-events.ts

@@ -1,10 +1,12 @@
 import type { OcxUsage } from "../types";
+import { debugProviderDiagnostic } from "../lib/debug";
 import { kiroTruncationReason } from "./kiro-truncation";
 
 export type ParsedKiroEvent =
   | { type: "content"; data?: string; modelId?: string }
   | { type: "reasoning"; data?: string; signature?: string; redactedContent?: string }
   | { type: "context_usage"; contextUsagePercentage: number }
+  | { type: "metering"; unit: string; usage: number; unitPlural?: string }
   | { type: "tool"; name?: string; toolUseId?: string; input?: string; stop?: boolean }
   | { type: "truncation"; data: string }
   | { type: "metadata"; usage?: OcxUsage; contextUsagePercentage?: number; stopReason?: string }
@@ -17,10 +19,12 @@ const KNOWN_EVENT_TYPES = new Set([
   "reasoningContentEvent",
   "toolUseEvent",
   "messageMetadataEvent",
+  "initial-response",
   "metadataEvent",
   // Authoritative context pressure. Every capture (kiro-cli 2.14.1 and 2.16.0) put the percentage
   // HERE and left `metadataEvent` carrying only `stopReason`; metadataEvent's own
   // contextUsagePercentage stays supported as a fallback rather than being dropped.
+  "meteringEvent",
   "contextUsageEvent",
   "invalidStateEvent",
   "error",
@@ -111,7 +115,11 @@ function parseTokenUsage(eventType: string, value: unknown): OcxUsage | undefine
 /** Decode a known Kiro event using its Smithy `:event-type` header. */
 export function parseKiroEvent(eventType: string, payload: Uint8Array): ParsedKiroEvent | null {
   // Unknown event types are intentionally ignored without parsing or logging their payload.
-  if (!KNOWN_EVENT_TYPES.has(eventType)) return null;
+  if (!KNOWN_EVENT_TYPES.has(eventType)) {
+    // The Smithy header is upstream-controlled too; a raw value can contain private data.
+    debugProviderDiagnostic("kiro", "unknown_event", { eventTypeLength: eventType.length });
+    return null;
+  }
   const parsed = parseObject(eventType, payload);
   // A metadataEvent's `stopReason` is Kiro's own terminal verdict and must reach the parser
   // intact. The generic truncation sniffer matches substrings ("max_tokens", "length",
@@ -174,7 +182,25 @@ export function parseKiroEvent(eventType: string, payload: Uint8Array): ParsedKi
           ? { stop: optionalBoolean(eventType, parsed, "stop") }
           : {}),
       };
+    case "meteringEvent": {
+      const unit = optionalString(eventType, parsed, "unit");
+      if (unit === undefined) {
+        return malformed(eventType, "unit must be a string");
+      }
+      const unitPlural = optionalString(eventType, parsed, "unitPlural");
+      const rawUsage = parsed.usage !== undefined ? parsed.usage : parsed.amount;
+      if (typeof rawUsage !== "number" || !Number.isFinite(rawUsage) || rawUsage < 0) {
+        return malformed(eventType, "usage must be a finite non-negative number");
+      }
+      return {
+        type: "metering",
+        unit,
+        usage: rawUsage,
+        ...(unitPlural !== undefined ? { unitPlural } : {}),
+      };
+    }
     case "messageMetadataEvent":
+    case "initial-response":
       return {
         type: "message_metadata",
         conversationId:

package/src/adapters/kiro-refusal.ts

@@ -0,0 +1,30 @@
+/** Account-scoped Kiro refusals. Unknown data never convicts an account. */
+import { BOUNDED_BODY_MAX_BYTES } from "../lib/bounded-body";
+export type KiroRefusalKind = "rate" | "monthly_quota" | "suspended" | "other";
+export interface KiroRefusal { kind: KiroRefusalKind; resetAt?: number }
+
+const SUSPENSION_WORDS = [
+  "temporarily suspended", "temporarily is suspended",
+  "locked your account", "locked it as a",
+] as const;
+
+export function classifyKiroRefusal(status: number, bodyText: string): KiroRefusal {
+  if (Buffer.byteLength(bodyText, "utf8") > BOUNDED_BODY_MAX_BYTES)
+    return { kind: status === 429 ? "rate" : "other" };
+  let reason: unknown;
+  let message: unknown;
+  try {
+    const row: unknown = JSON.parse(bodyText);
+    if (row && typeof row === "object" && !Array.isArray(row)) {
+      reason = (row as Record<string, unknown>).reason;
+      message = (row as Record<string, unknown>).message;
+    }
+  } catch { /* Unrecognised bodies cannot establish an account verdict. */ }
+  if ((status === 400 || status === 429) && reason === "MONTHLY_REQUEST_COUNT")
+    return { kind: "monthly_quota" };
+  if (status === 403 && (reason === "TEMPORARILY_SUSPENDED"
+    || (typeof message === "string" && SUSPENSION_WORDS.some(word => message.toLowerCase().includes(word)))))
+    return { kind: "suspended" };
+  if (status === 429) return { kind: "rate" };
+  return { kind: "other" };
+}