@bitkyc08/opencodex 2.7.40 → 2.7.41

package/src/adapters/kiro.ts

@@ -32,6 +32,7 @@ import type {
 import type { ProviderAdapter } from "./base";
 import type { AdapterFetchContext, AdapterRequest } from "./base";
 import { extractKiroImages, normalizeKiroImages, type KiroImage } from "./kiro-images";
+import { sniffImageDimensions } from "./anthropic-image-guard";
 import { fetchKiroWithRetry } from "./kiro-retry";
 import { convertKiroToolContext } from "./kiro-tools";
 import { neutralizeIdentity } from "./identity";
@@ -134,6 +135,52 @@ function messageLogText(msg: OcxMessage): string {
   }).filter(Boolean).join("\n");
 }
 
+function estimateKiroImageTokens(image: KiroImage): number {
+  const dimensions = sniffImageDimensions(image.source.bytes);
+  if (dimensions) {
+    return Math.max(256, Math.ceil(dimensions.width * dimensions.height / 750));
+  }
+  const decodedBytes = Math.floor(image.source.bytes.length * 3 / 4);
+  return Math.max(256, Math.ceil(decodedBytes / 512));
+}
+
+function estimateKiroTokens(text: string, modelId?: string): number {
+  return estimateTokens(text, modelId ? `kiro/${modelId}` : "kiro");
+}
+
+function estimateKiroPayloadInputTokens(payload: Record<string, unknown>, modelId: string): number {
+  const conversationState = (payload as {
+    conversationState?: {
+      history?: KiroHistoryEntry[];
+      currentMessage?: KiroHistoryEntry;
+    };
+  }).conversationState;
+  if (!conversationState) return 0;
+
+  const parts: string[] = [];
+  let imageTokens = 0;
+  const entries = [
+    ...(conversationState.history ?? []),
+    ...(conversationState.currentMessage ? [conversationState.currentMessage] : []),
+  ];
+  for (const entry of entries) {
+    const user = entry.userInputMessage;
+    if (user) {
+      if (user.content) parts.push(user.content);
+      for (const image of user.images ?? []) imageTokens += estimateKiroImageTokens(image);
+      const context = user.userInputMessageContext;
+      if (context?.tools?.length) parts.push(serializeForUsage(context.tools));
+      if (context?.toolResults?.length) parts.push(serializeForUsage(context.toolResults));
+    }
+    const assistant = entry.assistantResponseMessage;
+    if (assistant) {
+      if (assistant.content) parts.push(assistant.content);
+      if (assistant.toolUses?.length) parts.push(serializeForUsage(assistant.toolUses));
+    }
+  }
+  return estimateKiroTokens(parts.join("\n"), modelId) + imageTokens;
+}
+
 function shouldCountStablePromptOverhead(parsed: OcxParsedRequest): boolean {
   return !parsed.previousResponseId && !parsed.context.messages.some(m => m.role === "assistant");
 }
@@ -148,25 +195,21 @@ function estimateKiroInputTokens(parsed: OcxParsedRequest): number {
     if (parsed.context.tools?.length) parts.push(serializeForUsage(parsed.context.tools));
   }
 
-  return estimateTokens(parts.join("\n"), parsed.modelId);
+  return estimateKiroTokens(parts.join("\n"), parsed.modelId);
 }
 
 function estimateKiroLogInputTokens(parsed: OcxParsedRequest): number {
   const parts = parsed.context.messages.map(messageLogText).filter(Boolean);
   if (parsed.context.systemPrompt?.length) parts.push(...parsed.context.systemPrompt);
   if (parsed.context.tools?.length) parts.push(serializeForUsage(parsed.context.tools));
-  return Math.max(estimateKiroInputTokens(parsed), estimateTokens(parts.join("\n"), parsed.modelId));
+  return Math.max(estimateKiroInputTokens(parsed), estimateKiroTokens(parts.join("\n"), parsed.modelId));
 }
 
-function configuredKiroContextWindow(provider: OcxProviderConfig, modelId: string | undefined): number | undefined {
+function kiroUpstreamContextWindow(modelId: string | undefined): number | undefined {
   if (!modelId) return undefined;
   const normalizedModelId = normalizeKiroModelId(modelId);
   if (normalizedModelId === "auto") return undefined;
-  const window =
-    modelRecordValue(provider.modelContextWindows, modelId)
-    ?? modelRecordValue(provider.modelContextWindows, normalizedModelId)
-    ?? provider.contextWindow
-    ?? modelRecordValue(KIRO_MODEL_CONTEXT_WINDOWS, modelId)
+  const window = modelRecordValue(KIRO_MODEL_CONTEXT_WINDOWS, modelId)
     ?? modelRecordValue(KIRO_MODEL_CONTEXT_WINDOWS, normalizedModelId);
   return typeof window === "number" && Number.isFinite(window) && window > 0 ? window : undefined;
 }
@@ -184,8 +227,22 @@ function kiroRuntimeEndpoint(provider: OcxProviderConfig, region: string): strin
 
 export type KiroReasoningMode = "native" | "emulated";
 
+// Kiro takes a verified native effort field for these models, and each model family names it
+// differently: the Sol-only `reasoning.effort` versus the Claude-specific `output_config.effort`.
+// Models absent from this table fall back to emulated thinking instructions.
+const KIRO_NATIVE_EFFORT_FIELDS: Record<string, "reasoning" | "output_config"> = {
+  "gpt-5.6-sol": "reasoning",
+  "claude-opus-5": "output_config",
+};
+
+const KIRO_NATIVE_EFFORTS = ["low", "medium", "high", "xhigh", "max"];
+
+function kiroNativeEffortField(modelId: string): "reasoning" | "output_config" | undefined {
+  return KIRO_NATIVE_EFFORT_FIELDS[normalizeKiroModelId(modelId)];
+}
+
 export function kiroReasoningMode(modelId: string): KiroReasoningMode {
-  return normalizeKiroModelId(modelId) === "gpt-5.6-sol" ? "native" : "emulated";
+  return kiroNativeEffortField(modelId) ? "native" : "emulated";
 }
 
 function kiroThinkingBudget(parsed: OcxParsedRequest): number | undefined {
@@ -439,11 +496,12 @@ export function buildKiroPayload(
     },
   };
   const effort = parsed.options.reasoning;
-  if (kiroReasoningMode(parsed.modelId) === "native" && effort && effort !== "none") {
-    if (!["low", "medium", "high", "xhigh", "max"].includes(effort)) {
-      throw new Error(`Kiro gpt-5.6-sol does not support reasoning effort ${JSON.stringify(effort)}`);
+  const effortField = kiroNativeEffortField(parsed.modelId);
+  if (effortField && effort && effort !== "none") {
+    if (!KIRO_NATIVE_EFFORTS.includes(effort)) {
+      throw new Error(`Kiro ${normalizeKiroModelId(parsed.modelId)} does not support reasoning effort ${JSON.stringify(effort)}`);
     }
-    payload.additionalModelRequestFields = { reasoning: { effort } };
+    payload.additionalModelRequestFields = { [effortField]: { effort } };
   }
   if (profileArn) payload.profileArn = profileArn;
   return { payload, nameMap, conversationId, completionMode };
@@ -465,17 +523,26 @@ interface KiroAttemptResult {
 interface KiroFallbackAttempt {
   response: Response;
   inputTokens: number;
+  contextInputEstimate: number;
   nameMap: Map<string, string>;
   conversationId: string;
 }
 
+interface KiroContextWindowState {
+  value?: number;
+}
+
 type KiroFallbackFactory = (
   conversationId: string | undefined,
   assistantText: string,
   sawReasoning: boolean,
 ) => Promise<KiroFallbackAttempt>;
 
-function mergeKiroUsage(first: OcxUsage | undefined, second: OcxUsage | undefined): OcxUsage | undefined {
+function mergeKiroUsage(
+  first: OcxUsage | undefined,
+  second: OcxUsage | undefined,
+  preserveFirstContextGrowth = false,
+): OcxUsage | undefined {
   if (!first) return second;
   if (!second) return first;
   const sumOptional = (key: keyof OcxUsage): number | undefined => {
@@ -488,9 +555,23 @@ function mergeKiroUsage(first: OcxUsage | undefined, second: OcxUsage | undefine
   const totalTokens = typeof first.totalTokens === "number" && typeof second.totalTokens === "number"
     ? first.totalTokens + second.totalTokens
     : undefined;
+  const carriedContextTotal = preserveFirstContextGrowth && typeof first.contextTotalTokens === "number"
+    ? first.contextTotalTokens + second.outputTokens
+    : undefined;
+  const combinedOutputTokens = first.outputTokens + second.outputTokens;
   return {
     inputTokens: first.inputTokens + second.inputTokens,
-    outputTokens: first.outputTokens + second.outputTokens,
+    outputTokens: combinedOutputTokens,
+    ...(typeof first.contextTotalTokens === "number" || typeof second.contextTotalTokens === "number"
+      ? {
+          contextTotalTokens: Math.max(
+            first.contextTotalTokens ?? 0,
+            second.contextTotalTokens ?? 0,
+            carriedContextTotal ?? 0,
+            combinedOutputTokens,
+          ),
+        }
+      : {}),
     ...(totalTokens !== undefined ? { totalTokens } : {}),
     ...(sumOptional("cachedInputTokens") !== undefined ? { cachedInputTokens: sumOptional("cachedInputTokens") } : {}),
     ...(sumOptional("cacheReadInputTokens") !== undefined ? { cacheReadInputTokens: sumOptional("cacheReadInputTokens") } : {}),
@@ -517,6 +598,13 @@ function retryableKiroIncomplete(
   };
 }
 
+/**
+ * Suppress only a whitespace-normalized exact repeat. Semantic/fuzzy matching was rejected
+ * during review: two long near-identical messages can differ by a single status word
+ * ("is still pending" -> "is now complete") and still clear every similarity threshold, so
+ * fuzzy suppression can silently delete the one sentence that carries the result. Showing a
+ * cosmetic restatement is the cheaper failure.
+ */
 function normalizedKiroAnswer(text: string): string {
   return text.trim().replace(/\s+/g, " ");
 }
@@ -525,15 +613,60 @@ function isRepeatedKiroAnswer(text: string, previous?: string): boolean {
   return normalizedKiroAnswer(text) === normalizedKiroAnswer(previous ?? "");
 }
 
+/**
+ * Kiro's native stop reason for a turn the model considers finished. Only this value is
+ * authoritative; `TOOL_USE` and an absent reason both leave the turn incomplete.
+ */
+const KIRO_END_TURN_STOP_REASON = "END_TURN";
+
 async function* parseKiroAttempt(
   response: Response,
   mode: KiroCompletionMode,
   modelId: string | undefined,
   inputTokens: number,
-  contextWindow: number | undefined,
+  contextWindowState: KiroContextWindowState,
   nameMap: Map<string, string> | undefined,
   conversationId: string | undefined,
   previousAssistantText?: string,
+  contextInputEstimate?: number,
+): AsyncGenerator<AdapterEvent, KiroAttemptResult> {
+  // `required` mode holds staged commentary here so a terminal END_TURN can relabel it as the final
+  // answer instead of paying for another inference request. Anything the inner parser leaves behind
+  // — every early error return — is flushed before the terminal event so partial output is never
+  // silently dropped.
+  const deferred: AdapterEvent[] = [];
+  const attempt = parseKiroAttemptEvents(
+    response,
+    mode,
+    modelId,
+    inputTokens,
+    contextWindowState,
+    nameMap,
+    conversationId,
+    deferred,
+    previousAssistantText,
+    contextInputEstimate,
+  );
+  let next = await attempt.next();
+  while (!next.done) {
+    yield next.value;
+    next = await attempt.next();
+  }
+  for (const event of deferred.splice(0)) yield event;
+  return next.value;
+}
+
+async function* parseKiroAttemptEvents(
+  response: Response,
+  mode: KiroCompletionMode,
+  modelId: string | undefined,
+  inputTokens: number,
+  contextWindowState: KiroContextWindowState,
+  nameMap: Map<string, string> | undefined,
+  conversationId: string | undefined,
+  deferred: AdapterEvent[],
+  previousAssistantText?: string,
+  contextInputEstimate?: number,
 ): AsyncGenerator<AdapterEvent, KiroAttemptResult> {
   const emptyResult = (): KiroAttemptResult => ({ assistantText: "", sawReasoning: false });
   if (!response.body) {
@@ -554,17 +687,35 @@ async function* parseKiroAttempt(
   let completionAnswer: string | undefined;
   let completionCalls = 0;
   let authoritativeUsage: OcxUsage | undefined;
+  let stopReason: string | undefined;
   const fallbackEvents: AdapterEvent[] = [];
   const thinking = new KiroThinkingParser();
 
   const providerState = (): { kiro: { conversationId: string } } | undefined =>
     returnedConversationId ? { kiro: { conversationId: returnedConversationId } } : undefined;
 
-  const usage = (): OcxUsage => authoritativeUsage ?? ({
+  const contextUsageTotalFloor = (): number | undefined => {
+    if (contextUsagePercentage === undefined || !contextWindowState.value) return undefined;
+    const floor = Math.ceil(contextWindowState.value * Math.min(contextUsagePercentage, 100) / 100);
+    return Number.isFinite(floor) && floor > 0 ? floor : undefined;
+  };
+  const usage = (): OcxUsage => {
+    const base = authoritativeUsage ?? {
       inputTokens,
-      outputTokens: estimateTokens(outputChars, modelId),
+      outputTokens: estimateKiroTokens(outputChars, modelId),
       estimated: true,
-    });
+    };
+    const estimatedContextTotal = contextInputEstimate !== undefined
+      ? contextInputEstimate + base.outputTokens
+      : undefined;
+    const authoritativeTurnTotal = base.inputTokens + base.outputTokens;
+    const contextTotal = Math.max(
+      estimatedContextTotal ?? 0,
+      contextUsageTotalFloor() ?? 0,
+      authoritativeTurnTotal,
+    );
+    return contextTotal > 0 ? { ...base, contextTotalTokens: contextTotal } : base;
+  };
 
   const classifiedTerminal = (failure: KiroErrorClassification): AdapterEvent => ({
     type: "error",
@@ -627,6 +778,17 @@ async function* parseKiroAttempt(
     return terminal ? { terminal } : { tool: next };
   };
 
+  // In `required` mode Kiro's stop reason only arrives on the terminal metadata event, so staged
+  // commentary is held until either a real tool call proves the turn continues (flush as
+  // commentary) or the stream ends (relabel as the final answer when END_TURN says so). A heartbeat
+  // stands in for each held event so the bridge's stall watchdog stays armed.
+  const defer = (event: AdapterEvent): AdapterEvent[] => {
+    if (sawRealTool) return [...deferred.splice(0), event];
+    if (event.type !== "text_delta" && deferred.length === 0) return [event];
+    deferred.push(event);
+    return [{ type: "heartbeat" }];
+  };
+
   const stage = (event: AdapterEvent): AdapterEvent[] => {
     if (event.type === "text_delta") {
       assistantText += event.text;
@@ -639,7 +801,7 @@ async function* parseKiroAttempt(
         fallbackEvents.push(phased);
         return [];
       }
-      return [phased];
+      return mode === "required" ? defer(phased) : [phased];
     }
     if (event.type === "reasoning_raw_delta" || event.type === "thinking_delta") {
       const text = event.type === "reasoning_raw_delta" ? event.text : event.thinking;
@@ -650,7 +812,7 @@ async function* parseKiroAttempt(
       fallbackEvents.push(event);
       return [];
     }
-    return [event];
+    return mode === "required" ? defer(event) : [event];
   };
 
   const parseCompletion = (chunks: string[]): string | Error => {
@@ -738,11 +900,15 @@ async function* parseKiroAttempt(
           if (ev.contextUsagePercentage !== undefined && ev.contextUsagePercentage > 0) {
             contextUsagePercentage = ev.contextUsagePercentage;
           }
+          if (ev.stopReason !== undefined) stopReason = ev.stopReason;
           break;
         case "message_metadata":
           if (isValidKiroConversationId(ev.conversationId)) returnedConversationId = ev.conversationId;
           break;
         case "content":
+          if (ev.modelId) {
+            contextWindowState.value = kiroUpstreamContextWindow(ev.modelId) ?? contextWindowState.value;
+          }
           if (open) {
             open = null;
             return { assistantText, sawReasoning, terminal: protocolTerminal(kiroTruncationErrorMessage("content arrived before tool stop")) };
@@ -843,18 +1009,47 @@ async function* parseKiroAttempt(
     if (contextUsagePercentage !== undefined) {
       debugProviderDiagnostic("kiro", "context_usage", {
         contextUsagePercentage,
-        ...(contextWindow ? { configuredContextWindow: contextWindow } : {}),
+        ...(contextWindowState.value ? { upstreamContextWindow: contextWindowState.value } : {}),
       });
     }
+    // Kiro's own end-of-turn verdict, trusted only when it is unambiguous: plain assistant text,
+    // with neither a real tool call nor a private completion call to arbitrate against it.
+    // STOP_SEQUENCE is an ordinary native completion just like END_TURN. Both must be decided
+    // here rather than further down, because the deferred text is relabeled to `final_answer`
+    // in this branch — once it flushes as commentary below, that chance is gone.
+    const normalizedStopReason = stopReason?.trim().toUpperCase();
+    const nativeEndTurn = (normalizedStopReason === KIRO_END_TURN_STOP_REASON
+      || normalizedStopReason === "STOP_SEQUENCE")
+      && sawText
+      && !sawRealTool
+      && completionAnswer === undefined
+      && completionCalls === 0;
+
     debugProviderDiagnostic("kiro", "attempt_complete", {
       mode,
       sawText,
       sawReasoning,
       sawRealTool,
       completionCalls,
+      nativeEndTurn,
+      ...(stopReason !== undefined ? { stopReason } : {}),
       assistantChars: assistantText.length,
     });
 
+    if (mode === "required") {
+      if (nativeEndTurn) {
+        for (const event of deferred.splice(0)) {
+          yield event.type === "text_delta" ? { ...event, phase: "final_answer" } : event;
+        }
+        return {
+          assistantText,
+          sawReasoning,
+          terminal: { type: "done", usage: finalUsage, endTurn: true, ...(finalProviderState ? { providerState: finalProviderState } : {}) },
+        };
+      }
+      for (const event of deferred.splice(0)) yield event;
+    }
+
     if (mode === "text_fallback") {
       if (completionAnswer !== undefined) {
         for (const event of fallbackEvents) yield event;
@@ -917,6 +1112,61 @@ async function* parseKiroAttempt(
         terminal: { type: "done", usage: finalUsage, endTurn: false, ...(finalProviderState ? { providerState: finalProviderState } : {}) },
       };
     }
+    // An explicit native stop reason has already terminated this inference. Converting it into
+    // another model request would hide truncation behind a second paid call, and for context
+    // exhaustion it would resubmit a request that cannot fit. Only a MISSING stop reason falls
+    // through to the bounded compatibility fallback below.
+    //
+    // END_TURN and STOP_SEQUENCE with text are handled earlier by `nativeEndTurn`; reaching
+    // here with either means the turn produced no text.
+    if (mode === "required" && normalizedStopReason !== undefined) {
+      const providerStateField = finalProviderState ? { providerState: finalProviderState } : {};
+      const incomplete = (reason: string, retryable: boolean) => ({
+        assistantText,
+        sawReasoning,
+        terminal: {
+          type: "incomplete" as const,
+          reason,
+          message: `Kiro stopped with ${normalizedStopReason} before an explicit final answer`,
+          usage: finalUsage,
+          retryable,
+          endTurn: false,
+          ...providerStateField,
+        },
+      });
+
+      if (normalizedStopReason === "MODEL_CONTEXT_WINDOW_EXCEEDED") {
+        // Reuse the existing context-length contract (kiro-errors.ts) instead of inventing an
+        // incomplete reason: an unrecognized incomplete becomes a retryable 529 in Claude
+        // outbound, and `max_output_tokens` would make responses/state.ts cache this partial
+        // for continuation replay. Both invite a retry that cannot succeed.
+        return {
+          assistantText,
+          sawReasoning,
+          terminal: {
+            type: "error" as const,
+            message: "Kiro stopped because the model context window was exhausted",
+            status: 400,
+            errorType: "invalid_request_error",
+            code: "context_length_exceeded",
+            retryable: false,
+            usage: finalUsage,
+          },
+        };
+      }
+      if (normalizedStopReason === "MAX_TOKENS") return incomplete("max_output_tokens", true);
+      if (normalizedStopReason === "CONTENT_FILTERED" || normalizedStopReason === "GUARDRAIL_INTERVENED") {
+        return incomplete("content_filter", false);
+      }
+      if (normalizedStopReason === "MALFORMED_TOOL_USE") return incomplete("kiro_malformed_tool_use", false);
+      if (normalizedStopReason === "MALFORMED_MODEL_OUTPUT") return incomplete("kiro_malformed_model_output", false);
+      // TOOL_USE here means Kiro claimed a tool call it never emitted.
+      if (normalizedStopReason === "TOOL_USE") return incomplete("kiro_tool_use_without_call", false);
+      if (normalizedStopReason === KIRO_END_TURN_STOP_REASON || normalizedStopReason === "STOP_SEQUENCE") {
+        return incomplete(`kiro_${normalizedStopReason.toLowerCase()}_without_text`, false);
+      }
+      return incomplete(`kiro_${normalizedStopReason.toLowerCase() || "unknown_stop"}`, false);
+    }
     // Kiro text has no trustworthy final/progress marker. When completion is required, ordinary
     // text and reasoning remain unfinished until the one bounded fallback validates the turn.
     if (mode === "required" && (sawText || sawReasoning)) {
@@ -970,15 +1220,19 @@ export async function* parseKiroStream(
   conversationId?: string,
   completionMode: KiroCompletionMode = "disabled",
   fallbackFactory?: KiroFallbackFactory,
+  contextInputEstimate?: number,
 ): AsyncGenerator<AdapterEvent> {
+  const contextWindowState: KiroContextWindowState = { value: contextWindow };
   const first = parseKiroAttempt(
     response,
     completionMode,
     modelId,
     inputTokens,
-    contextWindow,
+    contextWindowState,
     nameMap,
     conversationId,
+    undefined,
+    contextInputEstimate,
   );
   let firstNext = await first.next();
   while (!firstNext.done) {
@@ -1039,10 +1293,11 @@ export async function* parseKiroStream(
     "text_fallback",
     modelId,
     fallback.inputTokens,
-    contextWindow,
+    contextWindowState,
     fallback.nameMap,
     fallback.conversationId,
     firstResult.assistantText,
+    fallback.contextInputEstimate,
   );
   let secondNext = await second.next();
   while (!secondNext.done) {
@@ -1054,7 +1309,8 @@ export async function* parseKiroStream(
     yield retryableKiroIncomplete(
       "empty_kiro_fallback",
       "Kiro's bounded completion retry ended without a terminal result",
-      mergeKiroUsage(firstResult.usage, secondResult.usage) ?? { inputTokens, outputTokens: 0, estimated: true },
+      mergeKiroUsage(firstResult.usage, secondResult.usage, Boolean(firstResult.assistantText))
+        ?? { inputTokens, outputTokens: 0, estimated: true },
       secondResult.providerState ?? firstResult.providerState,
     );
     return;
@@ -1062,7 +1318,7 @@ export async function* parseKiroStream(
   if (secondResult.terminal.type === "done" || secondResult.terminal.type === "incomplete") {
     yield {
       ...secondResult.terminal,
-      usage: mergeKiroUsage(firstResult.usage, secondResult.terminal.usage),
+      usage: mergeKiroUsage(firstResult.usage, secondResult.terminal.usage, Boolean(firstResult.assistantText)),
       providerState: secondResult.terminal.providerState ?? firstResult.providerState,
     };
     return;
@@ -1070,7 +1326,7 @@ export async function* parseKiroStream(
   yield {
     ...secondResult.terminal,
     ...(secondResult.terminal.type === "error"
-      ? { usage: mergeKiroUsage(firstResult.usage, secondResult.terminal.usage) }
+      ? { usage: mergeKiroUsage(firstResult.usage, secondResult.terminal.usage, Boolean(firstResult.assistantText)) }
       : {}),
   };
 }
@@ -1080,6 +1336,7 @@ export function createKiroAdapter(provider: OcxProviderConfig): ProviderAdapter
   // Per-request closure (resolveAdapter builds a fresh adapter per request — server.ts:440 — so this
   // is race-free) carrying the heuristic input-token estimate from buildRequest into the stream.
   let inputTokens = 0;
+  let contextInputEstimate = 0;
   let modelId: string | undefined;
   let contextWindow: number | undefined;
   let toolNameMap: Map<string, string> | undefined;
@@ -1097,6 +1354,7 @@ export function createKiroAdapter(provider: OcxProviderConfig): ProviderAdapter
     conversationId: string;
     completionMode: KiroCompletionMode;
     inputTokens: number;
+    contextInputEstimate: number;
   }> => {
     if (typeof provider.apiKey !== "string" || provider.apiKey.trim() === "") {
       throw new Error("kiro token missing — run ocx login kiro");
@@ -1118,6 +1376,7 @@ export function createKiroAdapter(provider: OcxProviderConfig): ProviderAdapter
     if (profileArn) headers["x-amzn-kiro-profile-arn"] = profileArn;
     const built = buildKiroPayload(parsed, profileArn, forcedCompletionMode);
     await normalizeKiroImages(built.payload);
+    const contextInputEstimate = estimateKiroPayloadInputTokens(built.payload, parsed.modelId);
     const body = JSON.stringify(built.payload);
     debugProviderDiagnostic("kiro", "request", {
       region,
@@ -1141,6 +1400,7 @@ export function createKiroAdapter(provider: OcxProviderConfig): ProviderAdapter
       conversationId: built.conversationId,
       completionMode: built.completionMode,
       inputTokens: estimateKiroInputTokens(parsed),
+      contextInputEstimate,
     };
   };
 
@@ -1179,6 +1439,7 @@ export function createKiroAdapter(provider: OcxProviderConfig): ProviderAdapter
     return {
       response,
       inputTokens: retry.inputTokens,
+      contextInputEstimate: retry.contextInputEstimate,
       nameMap: retry.nameMap,
       conversationId: retry.conversationId,
     };
@@ -1189,8 +1450,9 @@ export function createKiroAdapter(provider: OcxProviderConfig): ProviderAdapter
     async buildRequest(parsed: OcxParsedRequest, incoming) {
       const built = await build(parsed);
       modelId = parsed.modelId;
-      contextWindow = configuredKiroContextWindow(provider, parsed.modelId);
+      contextWindow = kiroUpstreamContextWindow(parsed.modelId);
       inputTokens = built.inputTokens;
+      contextInputEstimate = built.contextInputEstimate;
       toolNameMap = built.nameMap;
       conversationId = built.conversationId;
       completionMode = built.completionMode;
@@ -1209,6 +1471,7 @@ export function createKiroAdapter(provider: OcxProviderConfig): ProviderAdapter
         conversationId,
         completionMode,
         completionMode === "required" ? fallbackFactory : undefined,
+        contextInputEstimate,
       );
     },
 
@@ -1239,6 +1502,7 @@ export function createKiroAdapter(provider: OcxProviderConfig): ProviderAdapter
         conversationId,
         completionMode,
         completionMode === "required" ? fallbackFactory : undefined,
+        contextInputEstimate,
       )) events.push(e);
       return events;
     },