cartethyia 2.7.4 → 2.7.5

package/src/providers/integrations/grok/grok-quota.ts

@@ -7,6 +7,7 @@ import {
   grokHeaderRequestsWindow,
   grokHeaderWindow,
   GROK_FREE_USAGE_EXHAUSTED,
+  GROK_SPENDING_LIMIT_EXHAUSTED,
   parseGrokFreeUsageVerdict,
   readGrokRateLimitHeaders,
 } from "./grok-ratelimit";
@@ -15,7 +16,6 @@ import { storedGrokRateLimit } from "./grok-ratelimit-store";
 import type { QuotaCollectionContext } from "../../quota/quota-support";
 
 const BILLING_URL = "https://cli-chat-proxy.grok.com/v1/billing?format=credits";
-const BILLING_SOURCE = "cli-chat-proxy.grok.com/v1/billing";
 const USER_URL = "https://cli-chat-proxy.grok.com/v1/user?include=subscription";
 const GRPC_CREDITS_URL = "https://grok.com/grok_api_v2.GrokBuildBilling/GetGrokCreditsConfig";
 const GRPC_EMPTY_FRAME = new Uint8Array([0, 0, 0, 0, 0]);
@@ -31,10 +31,10 @@ const GRPC_EMPTY_FRAME = new Uint8Array([0, 0, 0, 0, 0]);
  */
 const PROBE_URL = "https://cli-chat-proxy.grok.com/v1/responses";
 const PROBE_BODY = {
-  model: "grok-4.6",
-  stream: false,
-  max_output_tokens: 1,
-  input: [{ type: "message", role: "user", content: [{ type: "input_text", text: "hi" }] }],
+  model: "grok-4.7",
+  stream: true,
+  max_output_tokens: 256,
+  input: [{ type: "message", role: "user", content: [{ type: "input_text", text: "Hi" }] }],
 };
 
 /**
@@ -194,10 +194,21 @@ async function probeRateLimit(
       const verdict = parseGrokFreeUsageVerdict(parsePayload(body), body);
       authoritative = verdict ? grokAuthoritativeWindow(verdict) : null;
       note = GROK_FREE_USAGE_EXHAUSTED;
+    } else if (response.status === 402) {
+      // A 402 names a spend/entitlement wall (e.g.
+      // `personal-team-blocked:spending-limit`), not a reading failure. The
+      // account cannot serve, so it is a refusal — but there is no token
+      // allowance to display, so we carry the note without a window.
+      await response.text();
+      note = GROK_SPENDING_LIMIT_EXHAUSTED;
     } else if (!response.ok) {
       // Drain so the connection is reusable, then report nothing: an unrelated
       // failure must not read as an exhausted allowance.
       await response.text();
+    } else {
+      // A 2xx stream is read for its headers only; cancel the body so the
+      // connection is released without waiting for the full completion.
+      await response.body?.cancel?.();
     }
     return {
       header: grokHeaderWindow(reading),
@@ -275,5 +286,3 @@ export async function fetchGrokQuota(
   // broken; the authoritative window below is what carries the verdict.
   return { source: "grok", plan, windows: ordered, error: null };
 }
-
-export { BILLING_SOURCE as GROK_BILLING_SOURCE };

package/src/providers/integrations/grok/grok-ratelimit-store.ts

@@ -62,11 +62,6 @@ export function storedGrokRateLimit(accountId: string, now = Date.now()): readon
   return snapshot.windows;
 }
 
-/** Whether a fresh reading exists, so the collector can skip its probe. */
-export function hasFreshGrokRateLimit(accountId: string, now = Date.now()): boolean {
-  return storedGrokRateLimit(accountId, now) !== null;
-}
-
 /** Test seam. */
 export function clearGrokRateLimitSnapshots(): void {
   snapshots.clear();

package/src/providers/integrations/grok/grok-ratelimit.ts

@@ -37,6 +37,9 @@ const HEADER_RESET_TOKENS = "x-ratelimit-reset-tokens";
 /** The upstream code that carries the authoritative free-usage allowance. */
 export const GROK_FREE_USAGE_EXHAUSTED = "subscription:free-usage-exhausted";
 
+/** A spend/entitlement wall code (402) — the account cannot serve. */
+export const GROK_SPENDING_LIMIT_EXHAUSTED = "spending-limit";
+
 /** Kinds, so the view can tell an indicator from a verdict. */
 export const GROK_HEADER_WINDOW_KIND = "grok:cli-header";
 export const GROK_HEADER_REQUESTS_WINDOW_KIND = "grok:cli-header-requests";

package/src/providers/integrations/grok/grok.ts

@@ -35,15 +35,25 @@ export const GROK_BASE_URL = providerBaseUrl("grok");
 export const GROK_CLIENT_IDENTIFIER = "grok-shell" as const;
 export const GROK_TOKEN_AUTH = "xai-grok-cli" as const;
 
+/**
+ * Tool types the Grok Build proxy accepts verbatim (hosted tools). Verified
+ * live 2026-11-02: a `web_search_preview` (OpenAI Responses spelling) was
+ * rejected with `tools[0].type: unknown variant, expected one of function,
+ * web_search, x_search, image_generation, collections_search, file_search,
+ * code_execution, code_interpreter, mcp, shell, tool_search`. Anything not in
+ * this set is normalized to a flat `function` tool instead.
+ */
 const GROK_HOSTED_TOOLS = new Set([
   "web_search",
   "x_search",
-  "web_search_preview",
-  "file_search",
   "image_generation",
+  "collections_search",
+  "file_search",
+  "code_execution",
   "code_interpreter",
   "mcp",
-  "local_shell",
+  "shell",
+  "tool_search",
 ]);
 const GROK_ALLOWED_FIELDS = new Set([
   "model",
@@ -62,6 +72,24 @@ const GROK_ALLOWED_FIELDS = new Set([
   "text",
   "metadata",
   "prompt_cache_key",
+  // Session/response linkage fields — verified in the 1.0.70 binary's
+  // `struct Response with 31 elements` / `struct Conversation with 1 element`
+  // (OpenAI Responses shape). Without them a fresh request cannot reference
+  // earlier turns, and the proxy treats each call as a brand-new session.
+  "previous_response_id",
+  "conversation",
+  // Extra Responses fields the binary accepts; harmless and useful for parity.
+  "background",
+  "truncation",
+  "max_tool_calls",
+  "stream_options",
+  "prompt_cache_retention",
+  "top_logprobs",
+  "moderation",
+  "safety_identifier",
+  "prompt",
+  "context_management",
+  "user",
 ]);
 const GROK_SERVER_ID = /^(rs|fc|resp|msg)_/i;
 const GROK_NATIVE_ID = /^(rs|msg|fc)_[0-9a-f-]{20,}$/i;
@@ -166,7 +194,7 @@ export async function fetchGrokModels(
         authorization: `Bearer ${options.credential}`,
         "x-xai-token-auth": GROK_TOKEN_AUTH,
         "x-grok-client-identifier": GROK_CLIENT_IDENTIFIER,
-        "x-grok-client-mode": "headless",
+        "x-grok-client-mode": "Desktop",
         "x-grok-client-version": getGrokVersion(),
         "user-agent": buildGrokUserAgent(),
         accept: "application/json",
@@ -177,8 +205,6 @@ export async function fetchGrokModels(
     const entries = modelEntries(await response.json());
     if (entries === null) return null;
     const models = new Map<string, ModelDefinition>();
-    const profiles = new Map<string, ModelDefinition>();
-    const defaultEfforts = new Map<string, ReasoningEffortLevel>();
     for (const raw of entries) {
       const entry = raw as GrokModelCatalogEntry;
       const metadata = isRecord(entry._meta) ? entry._meta : undefined;
@@ -197,7 +223,6 @@ export async function fetchGrokModels(
           max: 10_000_000,
         }) ?? reference?.outputLimit ?? 64_000;
       const menu = parseGrokReasoningMenu(entry.reasoning_efforts ?? entry.reasoningEfforts);
-      const metadataEffort = normalizeEffort(entry.reasoning_effort ?? entry.reasoningEffort);
       const supportsReasoning =
         entry.supports_reasoning_effort ?? entry.supportsReasoningEffort;
       const reasoning =
@@ -217,18 +242,15 @@ export async function fetchGrokModels(
         cost: modelsDevCatalog.costFor(GROK_PROVIDER_ID, id),
       };
       models.set(id, model);
-      profiles.set(id.toLowerCase(), model);
-      if (metadataEffort !== undefined) defaultEfforts.set(id.toLowerCase(), metadataEffort);
     }
     if (models.size === 0) return null;
-    discoveredModels.clear();
-    for (const [id, model] of profiles) discoveredModels.set(id, model);
-    // Replace discovered defaults, retaining the static defaults as fallback
-    // only for catalog ids absent from this upstream response.
-    for (const id of defaultGrokEfforts.keys()) {
-      if (profiles.has(id)) defaultGrokEfforts.delete(id);
-    }
-    for (const [id, effort] of defaultEfforts) defaultGrokEfforts.set(id, effort);
+    // Deliberately no module-global cache here. Discovery results are persisted
+    // to the DB (source=discovered) by the probing service; a process-global
+    // `discoveredModels` map was clobbered by whichever account synced last —
+    // the per-account catalog can differ by plan, so account B's sync replaced
+    // account A's limits/reasoning menus for the whole process. Dispatch reads
+    // the static `GROK_MODELS` fallback (which is verified accurate against the
+    // live `/v1/models`), and the DB rows feed routing.
     return [...models.values()].sort((a, b) => a.modelId.localeCompare(b.modelId));
   } catch {
     return null;
@@ -245,28 +267,29 @@ export async function fetchGrokModels(
  * a model is effort-capable exactly when it is a served model that the catalog
  * declares as reasoning-capable. Suffixed variants of a served model (e.g.
  * `grok-4.6-high`) inherit that capability, matching the previous prefix rule.
+ *
+ * There is intentionally no discovered/cached map here: the static catalog is
+ * the single source for dispatch-time limits and reasoning, so a per-account
+ * catalog can never clobber another account's model behavior (see
+ * `fetchGrokModels`).
  */
-const discoveredModels = new Map<string, ModelDefinition>();
-const defaultGrokEfforts = new Map<string, ReasoningEffortLevel>([
-  ["grok-4.7", "high"],
-  ["grok-4.5", "high"],
-  ["grok-4.6", "high"],
-]);
-
 function grokModelDefinition(modelId: string): ModelDefinition | undefined {
   const normalized = modelId.toLowerCase();
-  return (
-    discoveredModels.get(normalized) ??
-    GROK_MODELS.find((model) => model.modelId.toLowerCase() === normalized)
-  );
+  return GROK_MODELS.find((model) => model.modelId.toLowerCase() === normalized);
 }
 
+const GROK_STATIC_DEFAULT_EFFORTS: Readonly<Record<string, ReasoningEffortLevel>> = {
+  "grok-4.7": "high",
+  "grok-4.5": "high",
+  "grok-4.6": "high",
+};
+
 function grokDefaultEffort(modelId: string): ReasoningEffortLevel | undefined {
   const exact = modelId.toLowerCase();
-  const discovered = defaultGrokEfforts.get(exact);
-  if (discovered !== undefined) return discovered;
-  for (const [id, effort] of defaultGrokEfforts) {
-    if (exact === id || exact.startsWith(`${id}-`)) return effort;
+  const exactDefault = GROK_STATIC_DEFAULT_EFFORTS[exact];
+  if (exactDefault !== undefined) return exactDefault;
+  for (const [id, effort] of Object.entries(GROK_STATIC_DEFAULT_EFFORTS)) {
+    if (exact.startsWith(`${id}-`)) return effort;
   }
   return undefined;
 }
@@ -300,14 +323,24 @@ async function grokHeaders(
     "x-xai-token-auth": GROK_TOKEN_AUTH,
     "x-grok-client-identifier": GROK_CLIENT_IDENTIFIER,
     "x-grok-client-version": version,
-    "x-grok-client-mode": "headless",
+    // Client-mode enum recovered from the 1.0.70 binary: Generic, GrokTUI,
+    // GrokWeb, NebulaExtension, GrokPager, Desktop. We present as `Desktop`
+    // (the desktop-app surface) — all values are accepted by the proxy, and
+    // `Desktop` is the closest 1:1 match to a hosted/BYOK runtime.
+    "x-grok-client-mode": "Desktop",
     "x-authenticateresponse": "authenticate-response",
     "user-agent": buildGrokUserAgent(version),
     "x-grok-agent-id": agentId,
     "x-grok-req-id": randomUUID(),
   };
-  // The auth store retains the display label, not xAI's upstream user ID, so
-  // do not substitute a local account or tenant id in identity headers.
+  // The real CLI's sampler header builder stamps the upstream user id on every
+  // request when it is known (xai-grok-sampler client.rs). The OAuth flow
+  // already persisted it as `auth_state.userId` from `/v1/user`; sending it
+  // makes our wire match the first-party client 1:1. It is an upstream
+  // identity, not a local account/tenant id — never substitute those.
+  const authState = isRecord(context.credential.auth_state) ? context.credential.auth_state : undefined;
+  const userId = typeof authState?.userId === "string" ? authState.userId.trim() : "";
+  if (userId.length > 0) headers["x-grok-user-id"] = userId;
   if (candidate?.model_id) {
     headers["x-grok-model-override"] = candidate.model_id;
   }
@@ -347,6 +380,12 @@ function normalizeInput(input: unknown): unknown {
   // request/preparer, which runs for every route including grok) plus the
   // factory Responses payload path — wire-side pairing filters duplicated
   // that logic and are deleted.
+  //
+  // The proxy is stateless: the model sees ONLY what is in `input`, so the
+  // full conversation history must survive to it (verified live 2026-11-02 —
+  // a turn 2 with the same session id but no history loses the turn 1
+  // context). We therefore never drop message items; only server-scoped id
+  // hygiene is applied.
   return input.filter((item) => {
     if (typeof item === "string") return !GROK_SERVER_ID.test(item);
     if (!item || typeof item !== "object" || Array.isArray(item)) return false;
@@ -493,19 +532,30 @@ function normalizeGrokPayload(
   if (cacheKey !== undefined && typeof payload.prompt_cache_key !== "string")
     payload.prompt_cache_key = cacheKey.slice(0, 512);
 
+  // The Grok Build proxy does NOT persist responses: a `previous_response_id`
+  // (even from a real `response.id` of an earlier turn, with `store:true`)
+  // returns 404 "Previous response cannot be found" — verified live
+  // 2026-11-02. The proxy is stateless; continuity comes only from the full
+  // `input` history, so referencing a previous response id can never succeed
+  // and would fail the whole request. Drop it here.
+  delete payload.previous_response_id;
+
   for (const key of Object.keys(payload)) {
     if (!GROK_ALLOWED_FIELDS.has(key)) delete payload[key];
   }
 }
 
 
-const GrokConfig = withBearerAuthentication({
+export const GrokConfig = withBearerAuthentication({
   provider_id: GROK_PROVIDER_ID,
   base_url: GROK_BASE_URL,
   endpoint_paths_by_wire_family: { responses: "/v1/responses" },
   extra_headers: { accept: "text/event-stream", "accept-encoding": "identity" },
   buildExtraHeaders: grokHeaders,
   prePayload: normalizeGrokPayload,
+  // The real CLI compresses the request body with zstd (sampler
+  // `request_compression`); stamp the matching Content-Encoding and compress.
+  request_compression: "zstd",
 });
 
 /**

package/src/providers/integrations/kilo/kilo-oauth.ts

@@ -30,7 +30,7 @@ import type { OAuthTokenRefreshResult } from "../../authentication/oauth-refresh
 import { OAuthDeviceFlow } from "../../authentication/oauth-device-flow";
 import type { FetchLike } from "../../authentication/oauth-client";
 
-export const KILO_API_BASE_URL = "https://api.kilo.ai" as const;
+const KILO_API_BASE_URL = "https://api.kilo.ai" as const;
 export const KILO_DEVICE_CODES_URL = `${KILO_API_BASE_URL}/api/device-auth/codes` as const;
 export const KILO_PROFILE_URL = `${KILO_API_BASE_URL}/api/profile` as const;
 

package/src/providers/integrations/kiro/kiro-cache.ts

@@ -0,0 +1,31 @@
+// Kiro session-cache estimation.
+//
+// The Kiro runtime surface never reports prompt-cache hits: the EventStream
+// carries only `contextUsageEvent` (window percentage) and `meteringEvent`
+// (billed credits), with no metrics event and no cache token counters. The
+// underlying models do cache byte-identical prefixes, so for the same
+// conversation we ESTIMATE the hit locally from the request history — exactly
+// how the Trae adapter bridges the same gap. This only fills the gap when
+// upstream reports nothing (0 or unavailable); a genuine upstream report (>0)
+// is trusted and left untouched.
+//
+// The state lives in a factory-created instance, so Kiro's sessions are fully
+// isolated from Trae's (and any other consumer of the shared factory).
+
+import type { CanonicalMessage, UsageRecord } from "../../../protocol/canonical-model";
+import { createSessionCache, estimateSessionCache, resetSessionCacheForTesting } from "../shared/session-cache";
+
+const cache = createSessionCache();
+
+export function estimateKiroSessionCache(
+  record: UsageRecord,
+  sessionId: string | undefined,
+  messages: readonly CanonicalMessage[] | undefined,
+): UsageRecord {
+  return estimateSessionCache(cache, record, sessionId, messages);
+}
+
+/** Drops all tracked sessions. Test-only. */
+export function resetKiroSessionCacheForTesting(): void {
+  resetSessionCacheForTesting(cache);
+}

package/src/providers/integrations/kiro/kiro-catalog.ts

@@ -12,6 +12,25 @@ export const KIRO_PROVIDER_ID = "kiro" as const;
  */
 export const KIRO_GENERATE_PATH = "/generateAssistantResponse" as const;
 
+/** AWS region shape, checked before a region is interpolated into a URL. */
+export const AWS_REGION_PATTERN = /^[a-z]{2}-[a-z]+-\d{1,2}$/;
+
+/** Fallback region when no (or an invalid) region is configured. */
+export const KIRO_DEFAULT_REGION = "us-east-1" as const;
+
+/**
+ *  Runtime service host template (generation). `{region}` is interpolated.
+ *
+ *  The 1.4.62 IDE targets the Kiro runtime service (`KiroRuntimeService`,
+ *  apiVersion 2026-01-13) at `https://runtime.{region}.kiro.dev` instead of the
+ *  legacy `q.{region}.amazonaws.com` AWS surface. Discovery/usage use the
+ *  control-plane `management` host; generation uses `runtime`.
+ */
+export const KIRO_RUNTIME_HOST_TEMPLATE = "https://runtime.{region}.kiro.dev" as const;
+
+/** Control-plane (management) service host template (models/usage). */
+export const KIRO_MANAGEMENT_HOST_TEMPLATE = "https://management.{region}.kiro.dev" as const;
+
 /**
  * Effort tiers the Kiro models that accept an effort field advertise.
  *
@@ -39,6 +58,8 @@ function kiroModel(options: {
   readonly reasoning?: boolean;
   readonly toolCall?: boolean;
   readonly webSearch?: boolean;
+  /** Marks the row as served on the provider's free plan tier (the free pill). */
+  readonly freeTier?: boolean;
 }): ModelDefinition {
   return defineModel({
     id: options.id,
@@ -51,6 +72,7 @@ function kiroModel(options: {
     ...(options.reasoning === undefined ? {} : { reasoning: options.reasoning }),
     ...(options.toolCall === undefined ? {} : { toolCall: options.toolCall }),
     ...(options.webSearch === undefined ? {} : { webSearch: options.webSearch }),
+    ...(options.freeTier === undefined ? {} : { freeTier: options.freeTier }),
     ...(options.reasoning ? { reasoningEfforts: KIRO_EFFORTS } : {}),
   });
 }
@@ -64,7 +86,14 @@ function kiroModel(options: {
  * guessing at what an individual account's plan reaches.
  */
 export const KIRO_MODELS: readonly ModelDefinition[] = [
-  kiroModel({ id: "auto", ctx: 1_000_000, out: 32_000, reasoning: true, toolCall: true }),
+  // Free-tier rows (KIRO FREE plan): the models the free tier serves. Marked
+  // `freeTier` so the model list groups them under the free pill like every
+  // other provider's free roster; latency measured live 2026-11-02.
+  kiroModel({ id: "auto", ctx: 1_000_000, out: 32_000, reasoning: true, toolCall: true, freeTier: true }),
+  kiroModel({ id: "claude-haiku-4.5", ctx: 200_000, out: 64_000, vision: true, reasoning: true, toolCall: true, freeTier: true }),
+  kiroModel({ id: "claude-sonnet-4.5", ctx: 200_000, out: 64_000, vision: true, reasoning: true, toolCall: true, freeTier: true }),
+  kiroModel({ id: "glm-5", ctx: 200_000, out: 64_000, reasoning: true, toolCall: true, freeTier: true }),
+  // Paid-tier rows (Pro).
   kiroModel({ id: "claude-opus-5", ctx: 1_000_000, out: 128_000, vision: true, reasoning: true, toolCall: true }),
   kiroModel({ id: "claude-opus-4.8", ctx: 1_000_000, out: 128_000, vision: true, reasoning: true, toolCall: true }),
   kiroModel({ id: "claude-opus-4.7", ctx: 1_000_000, out: 128_000, vision: true, reasoning: true, toolCall: true }),
@@ -74,8 +103,6 @@ export const KIRO_MODELS: readonly ModelDefinition[] = [
   // 200K, not the 1M the 1M-window models use: Sonnet 4.5 predates it. The
   // million-token window arrived with Opus 4.6 and the 5.x generation; the 4.5
   // trio is 200K, and Opus and Haiku here already say so.
-  kiroModel({ id: "claude-sonnet-4.5", ctx: 200_000, out: 64_000, vision: true, reasoning: true, toolCall: true }),
-  kiroModel({ id: "claude-haiku-4.5", ctx: 200_000, out: 64_000, vision: true, reasoning: true, toolCall: true }),
   // 1M/128K, not the 200K/64K of the 4.5 row above it: Haiku moved to the
   // million-token window and the doubled output ceiling with the rest of the
   // 5.x generation, and this line had been copied from its predecessor.
@@ -85,7 +112,6 @@ export const KIRO_MODELS: readonly ModelDefinition[] = [
   kiroModel({ id: "gpt-5.6-terra", ctx: 272_000, out: 128_000, reasoning: true, toolCall: true }),
   kiroModel({ id: "gpt-5.6-luna", ctx: 272_000, out: 128_000, reasoning: true, toolCall: true }),
   // The non-Anthropic rows reject image and audio input upstream.
-  kiroModel({ id: "glm-5", ctx: 200_000, out: 64_000, reasoning: true, toolCall: true }),
 ];
 
 /**
@@ -109,4 +135,4 @@ export function kiroContextWindow(modelId: string): number {
 }
 
 /** Window used for a model this catalog does not name; the Anthropic rows' value. */
-export const KIRO_DEFAULT_CONTEXT_WINDOW = 200_000;
+const KIRO_DEFAULT_CONTEXT_WINDOW = 200_000;

package/src/providers/integrations/kiro/kiro-discovery.ts

@@ -1,13 +1,16 @@
 // Kiro model discovery.
 //
 // The account's own model list is authoritative — which models a credential
-// reaches depends on the plan it is bound to — and it is served by the Amazon Q
-// catalog for a resolved profile. The request is scoped by the account's region
-// and profile for the same reason dispatch is.
+// reaches depends on the plan it is bound to — and it is served by the Kiro
+// control-plane (management) service for a resolved profile. The request is
+// scoped by the account's region and profile for the same reason dispatch is.
 //
-// This surface has its own client identity: it is the IDE's model-list call,
-// not the agent's chat call, and the upstream validates the User-Agent's shape
-// rather than ignoring it.
+// This surface has its own client identity: it is the IDE's model-list call
+// (client `@amzn/kiro-control-plane-bearer-client`), not the agent's chat
+// call, and the upstream validates the User-Agent's shape rather than ignoring
+// it. In the 1.4.62 build the operation is bound to `GET /List-Available-Models`
+// on `https://management.{region}.kiro.dev` (awsJson1_0, `x-amz-target`
+// `KiroControlPlaneBearerService.ListAvailableModels`).
 
 import type { FetchLike } from "../../quota/quota-contracts";
 import type { ModelDefinition } from "../../provider-model-definition";
@@ -19,10 +22,7 @@ import {
 } from "../../operations/client-versions";
 import { machineIdForAuthState } from "./kiro-machine-id";
 import { resolveKiroProfileArn } from "./kiro-profile";
-import { KIRO_MODELS } from "./kiro-catalog";
-
-/** AWS region shape, checked before a region is interpolated into a URL. */
-const AWS_REGION_PATTERN = /^[a-z]{2}-[a-z]+-\d{1,2}$/;
+import { AWS_REGION_PATTERN, KIRO_DEFAULT_REGION, KIRO_GENERATE_PATH, KIRO_MODELS, KIRO_MANAGEMENT_HOST_TEMPLATE } from "./kiro-catalog";
 
 /** Longest model list this will read; the upstream sends a few dozen at most. */
 const MAX_DISCOVERED_MODELS = 500;
@@ -30,6 +30,9 @@ const MAX_DISCOVERED_MODELS = 500;
 /** Effort tiers the models that accept an effort field advertise. */
 const KIRO_EFFORTS = ["low", "medium", "high", "xhigh"] as const;
 
+/** The management service target used in `x-amz-target`. */
+const KIRO_MANAGEMENT_TARGET = "KiroControlPlaneBearerService.ListAvailableModels" as const;
+
 /**
  * Ids the seed catalog deliberately excludes.
  *
@@ -44,7 +47,6 @@ const RETIRED_KIRO_MODEL_IDS: ReadonlySet<string> = new Set([
 ]);
 
 /** Path the adapter dispatches to; recorded on every discovered row. */
-const KIRO_GENERATE_PATH = "/generateAssistantResponse";
 /** Options for one discovery run. */
 export interface KiroModelDiscoveryOptions {
   readonly credential: string;
@@ -61,7 +63,7 @@ interface DiscoveryScope {
 
 function readScope(authState: Readonly<Record<string, unknown>> | undefined): DiscoveryScope {
   const regionRaw = typeof authState?.["region"] === "string" ? authState["region"].trim() : "";
-  const region = AWS_REGION_PATTERN.test(regionRaw) ? regionRaw : "us-east-1";
+  const region = AWS_REGION_PATTERN.test(regionRaw) ? regionRaw : KIRO_DEFAULT_REGION;
   const profileArn = resolveKiroProfileArn(authState);
   return { region, profileArn };
 }
@@ -80,36 +82,42 @@ export async function fetchKiroModels(
   if (credential.length === 0) return null;
   const fetcher = options.fetcher ?? fetch;
   const scope = readScope(options.authState);
+  const version = getKiroVersion();
+  const machineId = machineIdForAuthState(options.authState);
+  const host = KIRO_MANAGEMENT_HOST_TEMPLATE.replace("{region}", scope.region);
   const params = new URLSearchParams({ origin: "AI_EDITOR" });
   if (scope.profileArn.length > 0) params.set("profileArn", scope.profileArn);
 
   let response: Response;
   try {
-    // The catalog surface correlates the credential against the same device the
-    // generation surface sees, so it resolves the identity through the shared
-    // resolver rather than stating one of its own.
-    const version = getKiroVersion();
-    const machineId = machineIdForAuthState(options.authState);
-    response = await fetcher(
-      `https://q.${scope.region}.amazonaws.com/ListAvailableModels?${params.toString()}`,
-      {
-        headers: {
-          authorization: `Bearer ${credential}`,
-          accept: "application/json",
-          connection: "close",
-          "x-amzn-kiro-agent-mode": "vibe",
-          "x-amzn-codewhisperer-optout": "true",
-          "amz-sdk-request": "attempt=1; max=1",
-          "amz-sdk-invocation-id": crypto.randomUUID(),
-          // The upstream validates this value's shape and rejects a malformed
-          // one outright, so it is built from the same source the generation
-          // surface uses rather than spelled out here.
-          "user-agent": buildKiroRuntimeUserAgent(version, machineId),
-          "x-amz-user-agent": buildKiroAmzUserAgent(version, machineId),
-        },
-        signal: AbortSignal.timeout(20_000),
-      },
-    );
+    const headers: Record<string, string> = {
+      authorization: `Bearer ${credential}`,
+      accept: "application/json",
+      connection: "close",
+      "x-amz-target": KIRO_MANAGEMENT_TARGET,
+      "amz-sdk-request": "attempt=1; max=1",
+      "amz-sdk-invocation-id": crypto.randomUUID(),
+      "user-agent": buildKiroRuntimeUserAgent(version, machineId),
+      "x-amz-user-agent": buildKiroAmzUserAgent(version, machineId),
+      "x-kiro-machineid": machineId,
+    };
+    // The management surface labels API-key/enterprise/IdC credentials with
+    // `TokenType`; social/Builder-ID sessions send none. Mirror the client's
+    // `qje` map and the probe verified against the live service.
+    const authMethod = options.authState?.["authMethod"];
+    const tokenType =
+      authMethod === "api_key"
+        ? "API_KEY"
+        : authMethod === "external_idp"
+          ? "EXTERNAL_IDP"
+          : authMethod === "idc"
+            ? "SSO_OIDC"
+            : undefined;
+    if (tokenType !== undefined) headers["TokenType"] = tokenType;
+    response = await fetcher(`${host}/List-Available-Models?${params.toString()}`, {
+      headers,
+      signal: AbortSignal.timeout(20_000),
+    });
   } catch {
     return null;
   }
@@ -131,9 +139,6 @@ export async function fetchKiroModels(
     const modelId = typeof rawId === "string" ? rawId.trim() : "";
     if (modelId.length === 0 || seen.has(modelId) || RETIRED_KIRO_MODEL_IDS.has(modelId)) continue;
     seen.add(modelId);
-    // The seed row owns the limits and capabilities of an id it declares. The
-    // upstream listing reports an input ceiling only, and trusting it overwrote
-    // the output ceiling the catalog states.
     const seeded = KIRO_MODELS.find((model) => model.modelId === modelId);
     if (seeded !== undefined) {
       definitions.push(seeded);
@@ -145,8 +150,6 @@ export async function fetchKiroModels(
         ? (limits as Record<string, unknown>)["maxInputTokens"]
         : undefined;
     const contextLimit = typeof maxInput === "number" && maxInput > 0 ? Math.trunc(maxInput) : null;
-    // The catalog reports an input ceiling, not an output one; the static row
-    // carries the output ceiling the model family advertises.
     definitions.push(
       defineModel({
         id: modelId,
@@ -157,7 +160,8 @@ export async function fetchKiroModels(
         vision: true,
         reasoning: true,
         reasoningEfforts: KIRO_EFFORTS,
-        toolCall: true,}),
+        toolCall: true,
+      }),
     );
   }
   return definitions.length > 0 ? definitions : null;

package/src/providers/integrations/kiro/kiro-machine-id.ts

@@ -18,9 +18,12 @@ import { sha256Hex } from "../../../shared/hash";
  * account's `auth_state` so a refresh — which rotates the refresh token, and
  * with it any value derived from that token — cannot silently change it.
  *
- * The salts below are wire facts: they are what the observed client hashes.
- * They are deliberately different per credential family, because an API key and
- * a refresh token for the same account must not derive the same device id.
+ * The salts below are locally derived (stable per credential, distinct
+ * between credentials). They are NOT proven upstream wire facts: the
+ * unpacked IDE 1.4.62 uses VS Code's `machineIdSync()` and sends the device
+ * in `KiroIDE-{version}-{machineId}` (UA) plus `x-kiro-machineid` (header);
+ * the CLI 2.37.0 sends `x-kiro-machineid`. The legacy `KotlinNativeAPI`,
+ * `KiroAPIKey`, `KiroFallback` salts are absent from both binaries.
  */
 
 /** Prefix the observed client hashes for an OAuth (refresh-token) credential. */