cartethyia 2.7.4 → 2.7.6

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

@@ -1,9 +1,9 @@
-// Kiro (CodeWhisperer) quota.
+// Kiro (Kiro Control Plane) quota.
 //
-// Billing lives on two hosts and the right one depends on how the account
-// authenticates: an API key or enterprise token is served by the Amazon
-// surfaces, while the interactive families are answered by either. The
-// endpoints are tried in order and the first usable answer wins.
+// Billing lives on the Kiro control-plane (management) service — in the
+// 1.4.62 build `GetUsageLimits` is `GET /Get-Usage-Limits` on
+// `https://management.{region}.kiro.dev`. The legacy `codewhisperer.*` /
+// `q.*` AWS usage surfaces are no longer used.
 //
 // The account's region and profile matter here for the same reason they matter
 // at dispatch: the request is scoped to them, and an account-bound credential
@@ -15,7 +15,6 @@
 // device here and another at dispatch is the shape this gateway exists to avoid.
 
 import type {
-  FetchLike,
   ProviderQuotaResult,
   ProviderQuotaWindow,
 } from "../../quota/quota-contracts";
@@ -35,9 +34,16 @@ import {
 } from "../../operations/client-versions";
 import { machineIdForAuthState } from "./kiro-machine-id";
 import { resolveKiroProfileArn } from "./kiro-profile";
+import { AWS_REGION_PATTERN, KIRO_DEFAULT_REGION, KIRO_MANAGEMENT_HOST_TEMPLATE } 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}$/;
+/**
+ * The fetcher shape this module needs: a plain callable. `FetchLike` from the
+ * quota contracts is the global `typeof fetch` (which carries extra callable
+ * properties like `preconnect`), and the OAuth client passes its narrower
+ * structural `FetchLike` here — so accept the common callable shape instead of
+ * either full type.
+ */
+type KiroFetchLike = (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
 
 interface KiroQuotaAuth {
   readonly region: string;
@@ -50,7 +56,7 @@ interface KiroQuotaAuth {
 function quotaAuth(context: QuotaCollectionContext | undefined): KiroQuotaAuth {
   const raw = context?.auth_state ?? {};
   const regionRaw = typeof raw["region"] === "string" ? raw["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 authMethod = typeof raw["authMethod"] === "string" ? raw["authMethod"] : "builder-id";
   // The usage surface is profile-scoped and refuses a request without the field,
   // exactly as generation does, so it scopes to the same value generation does:
@@ -72,13 +78,13 @@ function usageHeaders(credential: string, auth: KiroQuotaAuth): Record<string, s
     connection: "close",
     "amz-sdk-request": "attempt=1; max=1",
     "amz-sdk-invocation-id": crypto.randomUUID(),
-    "x-amzn-kiro-agent-mode": "vibe",
-    "x-amzn-codewhisperer-optout": "true",
     "x-amz-user-agent": buildKiroAmzUserAgent(version, auth.machineId),
     "user-agent": buildKiroRuntimeUserAgent(version, auth.machineId),
+    "x-kiro-machineid": auth.machineId,
   };
-  if (auth.authMethod === "api_key") headers["tokentype"] = "API_KEY";
-  else if (auth.authMethod === "external_idp") headers["tokentype"] = "EXTERNAL_IDP";
+  if (auth.authMethod === "api_key") headers["TokenType"] = "API_KEY";
+  else if (auth.authMethod === "external_idp") headers["TokenType"] = "EXTERNAL_IDP";
+  else if (auth.authMethod === "idc") headers["TokenType"] = "SSO_OIDC";
   return headers;
 }
 
@@ -127,11 +133,18 @@ function parseUsage(payload: unknown): ProviderQuotaResult {
     }
   }
   const subscription = record(root["subscriptionInfo"]);
+  // The bundle asks with `isEmailRequired: true`, and the upstream then reports
+  // the account's email in `userInfo.email`. That is the only identity a social/
+  // imported token exposes (the access token itself is opaque, not a JWT), so it
+  // becomes the suggested account label for the refresh sweep to adopt.
+  const userInfo = record(root["userInfo"]);
+  const email = text(userInfo?.["email"]);
   return {
     source: "kiro",
     plan: text(subscription?.["subscriptionTitle"]) ?? "Kiro",
     windows,
     error: null,
+    ...(email === null ? {} : { accountLabel: email }),
   };
 }
 
@@ -144,7 +157,7 @@ function parseUsage(payload: unknown): ProviderQuotaResult {
  */
 export async function fetchKiroQuota(
   credential: string,
-  fetcher: FetchLike,
+  fetcher: KiroFetchLike,
   context?: QuotaCollectionContext,
 ): Promise<ProviderQuotaResult> {
   const token = credential.trim();
@@ -156,43 +169,18 @@ export async function fetchKiroQuota(
     origin: "AI_EDITOR",
     resourceType: "AGENTIC_REQUEST",
   });
-  const usageBody = JSON.stringify({
-    origin: "AI_EDITOR",
-    ...(auth.profileArn.length > 0 ? { profileArn: auth.profileArn } : {}),
-    resourceType: "AGENTIC_REQUEST",
-  });
+  // The 1.4.62 client sends the profile in the query (`GetUsageLimitsCommand`
+  // with `{origin, profileArn, resourceType, isEmailRequired}`). Without it the
+  // upstream answers 400 `Invalid profileArn.` — and there is no POST surface;
+  // the legacy `codewhisperer.*`/`q.*` AWS usage paths are gone.
+  if (auth.profileArn.length > 0) query.set("profileArn", auth.profileArn);
 
-  // Which surface answers depends on the account's auth family. The profile
-  // travels in the POST body only: the GET form rejects it in the query with
-  // `400`, which is what a freshly imported account was failing its test on.
+  const managementHost = KIRO_MANAGEMENT_HOST_TEMPLATE.replace("{region}", auth.region);
   const attempts: readonly { readonly name: string; readonly run: () => Promise<Response> }[] = [
     {
-      name: "codewhisperer-get",
-      run: () =>
-        fetcher(`https://codewhisperer.us-east-1.amazonaws.com/getUsageLimits?${query.toString()}`, {
-          method: "GET",
-          headers,
-          signal: AbortSignal.timeout(15_000),
-        }),
-    },
-    {
-      name: "codewhisperer-post",
-      run: () =>
-        fetcher("https://codewhisperer.us-east-1.amazonaws.com", {
-          method: "POST",
-          headers: {
-            ...headers,
-            "content-type": "application/x-amz-json-1.0",
-            "x-amz-target": "AmazonCodeWhispererService.GetUsageLimits",
-          },
-          body: usageBody,
-          signal: AbortSignal.timeout(15_000),
-        }),
-    },
-    {
-      name: "q-get",
+      name: "management-get",
       run: () =>
-        fetcher(`https://q.${auth.region}.amazonaws.com/getUsageLimits?${query.toString()}`, {
+        fetcher(`${managementHost}/Get-Usage-Limits?${query.toString()}`, {
           method: "GET",
           headers,
           signal: AbortSignal.timeout(15_000),

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

@@ -55,15 +55,10 @@ interface KiroToolSpecification {
   };
 }
 
-/** The checkpoint the upstream keys its prompt cache on. */
-interface KiroCachePoint {
-  readonly cachePoint: { readonly type: "default" };
-}
-
 /** One entry of `currentMessage.userInputMessage.userInputMessageContext`. */
 interface KiroUserInputContext {
   readonly toolResults?: readonly KiroToolResult[];
-  readonly tools?: readonly (KiroToolSpecification | KiroCachePoint)[];
+  readonly tools?: readonly KiroToolSpecification[];
 }
 
 interface KiroToolResult {
@@ -111,6 +106,8 @@ export interface KiroConversationError {
 /** Options the adapter supplies that are not part of the canonical request. */
 export interface KiroWireRequestOptions {
   readonly conversationId: string;
+  /** Root conversation id; defaults to `conversationId`, mirroring the client's `rootConversationId ?? conversationId`. */
+  readonly rootConversationId?: string | undefined;
   readonly modelId: string;
   readonly profileArn: string;
   /** Reasoning effort the routed model advertises, already validated by the adapter. */
@@ -176,6 +173,10 @@ export function buildKiroWireRequest(
       agentContinuationId: randomUUID(),
       chatTriggerType: "MANUAL",
       conversationId: options.conversationId,
+      // The client always sends the root conversation id, defaulting to the
+      // conversation id when the conversation is self-rooted (1.4.62 bundle:
+      // `rootConversationId: A ?? S`).
+      rootConversationId: options.rootConversationId ?? options.conversationId,
       currentMessage: { userInputMessage: currentMessage },
       history,
     },
@@ -197,8 +198,7 @@ export function buildKiroWireRequest(
  * This text is deliberately the *only* thing the opening turn carries besides
  * the caller's own words, because it is the prefix the upstream caches: every
  * request in a conversation repeats it byte-for-byte on that same turn. A value
- * that changes per request belongs on the current turn instead — see
- * `buildCurrentTimeLine`.
+ * that changes per request belongs on the current turn instead.
  */
 function buildStablePrefix(request: CanonicalRequest, options: KiroWireRequestOptions): string {
   const parts: string[] = [];
@@ -221,9 +221,6 @@ function buildStablePrefix(request: CanonicalRequest, options: KiroWireRequestOp
  * prefix differ on every request, so the upstream could never reuse the cached
  * one and the whole conversation would be re-read each turn.
  */
-export function buildCurrentTimeLine(now: Date = new Date()): string {
-  return `[Context: Current time is ${now.toISOString()}]`;
-}
 
 /** The marker the upstream reads to enable thinking with a budget. */
 export function buildThinkingMarker(budget: number): string {

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

@@ -132,6 +132,10 @@ export class KiroStreamDecoder {
 
     const eventType = event.headers[":event-type"] ?? "";
     switch (eventType) {
+      // First frame of a stream; carries only an empty conversation id. Nothing
+      // to emit (observed live 2026-11-02: `{"conversationId":""}`).
+      case "initial-response":
+        return { deltas: [] };
       case "assistantResponseEvent":
         return { deltas: this.#textDeltas(readString(event.payload, "content")) };
       case "reasoningContentEvent":
@@ -303,6 +307,13 @@ function readString(payload: string | null, key: string): string {
  *
  * The upstream has sent this payload as a bare string, as `{text}`, and as
  * `{content}` across versions; all three are accepted rather than picking one.
+ *
+ * One shape must NOT be read as text: `{redactedContent:"…"}`. That is an
+ * encrypted envelope (observed live 2026-11-02: base64 → `.KTR~~<base64url-
+ * JSON>` → `{"encryptionRegion":null,"mintedAtMs":…,"modelHash":"…","slots":
+ * [],"v":1}`) whose content the upstream never exposes. Emitting it as
+ * reasoning would leak a blob that is not reasoning, so it is treated as no
+ * text at all.
  */
 function readReasoning(payload: string | null): string {
   const parsed = parsePayload(payload);
@@ -311,6 +322,8 @@ function readReasoning(payload: string | null): string {
   if (typeof value === "string") return value;
   if (value !== null && typeof value === "object") {
     const record = value as Record<string, unknown>;
+    // Redacted envelope: not reasoning text; never surface it.
+    if (typeof record.redactedContent === "string") return "";
     if (typeof record.text === "string") return record.text;
     if (typeof record.content === "string") return record.content;
   }

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

@@ -1,4 +1,4 @@
-// Kiro (CodeWhisperer) adapter.
+// Kiro (CodeWhisperer / Kiro Runtime) adapter.
 //
 // Kiro does not speak a chat-shaped protocol: a request is a `conversationState`
 // ledger, and the answer is an AWS EventStream binary frame sequence. The
@@ -7,19 +7,21 @@
 //
 // Two upstream behaviours drive the header and endpoint logic:
 //
-//  * There is exactly one generation surface, `q.{region}.amazonaws.com`. The
-//    `codewhisperer.*` host and the vendor's own path-style gateway are
-//    not what the real client talks to, and reaching for them is actively
-//    harmful: an account that has just been refused would immediately probe two
-//    other service entries with the same token, which is the shape of credential
-//    probing rather than of a client retrying. A refusal is reported, never
-//    replayed onto another host.
+//  * There is exactly one generation surface, `https://runtime.{region}.kiro.dev`
+//    (the Kiro runtime service). The legacy `q.{region}.amazonaws.com` /
+//    `codewhisperer.*` AWS hosts are what older Kiro builds used; the 1.4.62
+//    IDE ships `KiroRuntimeService` clients against the runtime host, and
+//    reaching for the legacy hosts is actively harmful: an account that has
+//    just been refused would immediately probe other service entries with the
+//    same token, which is the shape of credential probing rather than of a
+//    client retrying. A refusal is reported, never replayed onto another host.
 //  * Every request carries a device identity (`KiroIDE-{version}-{machineId}`
-//    in the User-Agent) and closes its connection. A connection reused across
-//    accounts lets one TCP session carry several tokens that each claim to be a
-//    different machine — the strongest possible evidence of sharing. An account
-//    whose machine id cannot be derived is refused rather than dispatched with a
-//    constant or a per-request random value.
+//    in the User-Agent and `x-kiro-machineid` as a header) and closes its
+//    connection. A connection reused across accounts lets one TCP session carry
+//    several tokens that each claim to be a different machine — the strongest
+//    possible evidence of sharing. An account whose machine id cannot be
+//    derived is refused rather than dispatched with a constant or a per-request
+//    random value.
 //
 // The profile ARN is never manufactured: an account that resolved none sends
 // none. The shared placeholder belongs to the vendor's own account and the
@@ -27,6 +29,7 @@
 
 import type {
   CanonicalEvent,
+  CanonicalMessage,
   CanonicalRequest,
   CanonicalStopReason,
   UsageRecord,
@@ -48,9 +51,16 @@ import {
   type KiroWireRequest,
 } from "./kiro-request";
 import { machineIdForAuthState } from "./kiro-machine-id";
+import { estimateKiroSessionCache } from "./kiro-cache";
 import { resolveKiroProfileArn } from "./kiro-profile";
-import { kiroContextWindow } from "./kiro-catalog";
-import { resolveInboundSessionId, resolvePromptCacheKey } from "../../operations/session-resolution";
+import {
+  AWS_REGION_PATTERN,
+  KIRO_DEFAULT_REGION,
+  kiroContextWindow,
+  KIRO_GENERATE_PATH,
+  KIRO_RUNTIME_HOST_TEMPLATE,
+} from "./kiro-catalog";
+import { resolveInboundSessionId } from "../../operations/session-resolution";
 import { KiroStreamDecoder, isKiroTruncationReason, type KiroUsage } from "./kiro-stream";
 
 /** Provider id this adapter registers under. */
@@ -70,9 +80,6 @@ interface KiroAuthState {
   readonly machineId?: string;
 }
 
-/** AWS region shape, checked before a region is interpolated into a URL. */
-const AWS_REGION_PATTERN = /^[a-z]{2}-[a-z]+-\d{1,2}$/;
-
 interface KiroAdapterOptions {
   readonly fetch?: typeof fetch;
 }
@@ -83,7 +90,7 @@ function readAuthState(context: ProviderDispatchContext): KiroAuthState | undefi
   if (raw === undefined) return undefined;
   const authMethod = typeof raw["authMethod"] === "string" ? raw["authMethod"] : undefined;
   if (authMethod === undefined) return undefined;
-  const region = typeof raw["region"] === "string" && raw["region"].trim().length > 0 ? raw["region"].trim() : "us-east-1";
+  const region = typeof raw["region"] === "string" && raw["region"].trim().length > 0 ? raw["region"].trim() : KIRO_DEFAULT_REGION;
   const profileArn = typeof raw["profileArn"] === "string" && raw["profileArn"].trim().length > 0 ? raw["profileArn"].trim() : undefined;
   const machineId = typeof raw["machineId"] === "string" && raw["machineId"].trim().length > 0 ? raw["machineId"].trim() : undefined;
   return {
@@ -121,35 +128,6 @@ function resolveKiroConversationId(
   );
 }
 
-/**
- * The field the upstream keys its prompt cache on.
- *
- * A stable `conversationId` is not enough: the upstream ignores `cache_control`
- * entirely unless `metadata.user_id` is present, and then recomputes the whole
- * prompt on every turn. The value follows the shape the real client sends, and
- * its session id is the same one the conversation already uses, so turns of one
- * conversation hit and a different conversation does not.
- */
-function withKiroCacheKey(
-  payload: Record<string, unknown>,
-  request: CanonicalRequest,
-  context: ProviderDispatchContext,
-): Record<string, unknown> {
-  const existing = (payload.metadata as { user_id?: unknown } | undefined)?.user_id;
-  if (typeof existing === "string" && existing.length > 0) return payload;
-  const sessionId = resolvePromptCacheKey(request, context) ?? resolveKiroConversationId(request, context);
-  return {
-    ...payload,
-    metadata: {
-      user_id: JSON.stringify({
-        device_id: resolveAccountMachineId(context),
-        account_uuid: "",
-        session_id: sessionId,
-      }),
-    },
-  };
-}
-
 /**
  * The profile ARN this request carries, or `""` when it carries none.
  *
@@ -180,8 +158,8 @@ function resolveAccountMachineId(context: ProviderDispatchContext): string {
 
 /** Region validated before interpolation into an endpoint URL. */
 function safeRegion(authState: KiroAuthState | undefined): string {
-  const region = authState?.region ?? "us-east-1";
-  return AWS_REGION_PATTERN.test(region) ? region : "us-east-1";
+  const region = authState?.region ?? KIRO_DEFAULT_REGION;
+  return AWS_REGION_PATTERN.test(region) ? region : KIRO_DEFAULT_REGION;
 }
 
 /**
@@ -191,9 +169,30 @@ function safeRegion(authState: KiroAuthState | undefined): string {
  * replayed onto another service entry.
  */
 export function kiroEndpoint(authState: KiroAuthState | undefined): string {
-  return `https://q.${safeRegion(authState)}.amazonaws.com/generateAssistantResponse`;
+  const host = KIRO_RUNTIME_HOST_TEMPLATE.replace("{region}", safeRegion(authState));
+  return `${host}${KIRO_GENERATE_PATH}`;
 }
 
+/**
+ * AWS JSON 1.0 target for the runtime generation operation. The service name
+ * and operation are what the 1.4.62 client sends in `x-amz-target` (it is a
+ * Smithy `awsJson1_0` client with serviceTarget `KiroRuntimeService`).
+ */
+export const KIRO_RUNTIME_AWS_JSON_TARGET = "KiroRuntimeService.GenerateAssistantResponse" as const;
+
+/**
+ * Maps an auth method onto the `TokenType` header the 1.4.62 client sends.
+ *
+ * Observed map (`qje`): `api_key → API_KEY`, `external_idp → EXTERNAL_IDP`,
+ * `idc → SSO_OIDC`, `machine_token → KIRO_MACHINE_TOKEN`. Google/GitHub/
+ * Builder-ID sessions send no `TokenType` header.
+ */
+const KIRO_TOKEN_TYPE: Readonly<Record<string, string>> = {
+  api_key: "API_KEY",
+  external_idp: "EXTERNAL_IDP",
+  idc: "SSO_OIDC",
+};
+
 /**
  * Builds the request headers.
  *
@@ -206,37 +205,37 @@ export function kiroEndpoint(authState: KiroAuthState | undefined): string {
  *  * `x-amzn-codewhisperer-optout` — the observed client opts out of data
  *    collection on every generation request.
  *  * `x-amzn-kiro-agent-mode` — the agent mode the observed client declares.
- *  * `tokentype` — an API key or enterprise token is rejected as an OAuth access
- *    token unless it is labelled as one.
+ *  * `TokenType` — an API key or enterprise token is labelled so the upstream
+ *    can tell it apart from an OAuth access token.
  */
 export function kiroHeaders(
   secret: string,
   authState: KiroAuthState | undefined,
   machineId: string,
+  agentMode: string,
 ): Record<string, string> {
   const authMethod = authState?.authMethod;
   const version = getKiroVersion();
   const headers: Record<string, string> = {
-    "content-type": "application/json",
+    "content-type": "application/x-amz-json-1.0",
     accept: KIRO_STREAM_ACCEPT,
     connection: "close",
+    "x-amz-target": KIRO_RUNTIME_AWS_JSON_TARGET,
     "x-amzn-codewhisperer-optout": "true",
-    "x-amzn-kiro-agent-mode": "spec",
+    "x-amzn-kiro-agent-mode": agentMode,
+    "x-kiro-machineid": machineId,
     "amz-sdk-request": "attempt=1; max=3",
     "amz-sdk-invocation-id": crypto.randomUUID(),
     "user-agent": buildKiroUserAgent(version, machineId),
     "x-amz-user-agent": buildKiroAmzUserAgent(version, machineId),
     authorization: `Bearer ${secret}`,
   };
-  if (authMethod === "api_key") {
-    headers["tokentype"] = "API_KEY";
-  } else if (authMethod === "external_idp") {
-    headers["tokentype"] = "EXTERNAL_IDP";
-  } else {
-    headers["x-amz-sso-bearer"] = secret;
+  const tokenType = authMethod === undefined ? undefined : KIRO_TOKEN_TYPE[authMethod];
+  if (tokenType !== undefined) {
+    headers["TokenType"] = tokenType;
   }
   if (authState?.profileArn !== undefined && authState.profileArn.length > 0) {
-    headers["x-amzn-codewhisperer-profile-arn"] = authState.profileArn;
+    headers["x-amzn-kiro-profile-arn"] = authState.profileArn;
   }
   return headers;
 }
@@ -257,11 +256,17 @@ export function kiroHeaders(
  * estimate: the upstream never says how long its own answer was, so the emitted
  * text is counted at the usual ~4 characters per token.
  */
-function kiroUsage(usage: KiroUsage, modelId: string, outputText: string): UsageRecord {
+function kiroUsage(
+  usage: KiroUsage,
+  modelId: string,
+  outputText: string,
+  messages?: readonly CanonicalMessage[],
+  sessionId?: string,
+): UsageRecord {
   const cacheRead = usage.cacheReadTokens ?? 0;
   const cacheWrite = usage.cacheWriteTokens ?? 0;
   const [input, output] = kiroTokenCounts(usage, modelId, outputText);
-  return {
+  const record: UsageRecord = {
     input_tokens: input,
     cached_input_tokens: cacheRead > 0 ? cacheRead : "unavailable",
     cache_write_tokens: cacheWrite > 0 ? cacheWrite : "unavailable",
@@ -275,6 +280,10 @@ function kiroUsage(usage: KiroUsage, modelId: string, outputText: string): Usage
     total_tokens: input + output,
     ...(usage.credits === undefined ? {} : { credit_used: usage.credits }),
   };
+  // The runtime never reports cache hits; close the gap with our own history.
+  // A genuine ( >0) report conserves the complete record. Then the operator's
+  // cache mode decides whether a hit makes the whole input count as cached.
+  return estimateKiroSessionCache(record, sessionId, messages);
 }
 
 /**
@@ -370,6 +379,7 @@ class KiroAdapter implements ProviderAdapter {
         : (request.reasoning?.budget_tokens ?? kiroThinkingBudgetForEffort(requestedEffort));
     const built = buildKiroWireRequest(request, {
       conversationId: resolveKiroConversationId(request, context),
+      rootConversationId: resolveKiroConversationId(request, context),
       modelId,
       profileArn: resolveProfileArn(context),
       ...(effortPath === undefined || effort === undefined ? {} : { effortPath, effort }),
@@ -386,7 +396,8 @@ class KiroAdapter implements ProviderAdapter {
       );
     }
     const fetchFn = (context.outbound_fetch as unknown as typeof fetch | undefined) ?? this.#fetch;
-    const body = JSON.stringify(withKiroCacheKey(built.value.payload, request, context));
+    const builtPayload = { ...built.value.payload, agentMode: "vibe" };
+    const body = JSON.stringify(builtPayload);
     const machineId = resolveAccountMachineId(context);
     const response = await this.#send(
       fetchFn,
@@ -403,7 +414,7 @@ class KiroAdapter implements ProviderAdapter {
       }, "upstream");
     }
 
-    yield* this.#stream(response.body, built.value, request);
+    yield* this.#stream(response.body, built.value, request, context);
   }
 
   /**
@@ -427,7 +438,7 @@ class KiroAdapter implements ProviderAdapter {
     try {
       response = await fetchFn(url, {
         method: "POST",
-        headers: kiroHeaders(secret, authState, machineId),
+        headers: kiroHeaders(secret, authState, machineId, "vibe"),
         body,
         signal: context.abort_signal,
       });
@@ -460,6 +471,7 @@ class KiroAdapter implements ProviderAdapter {
     stream: ReadableStream<Uint8Array>,
     built: KiroWireRequest,
     request: CanonicalRequest,
+    context: ProviderDispatchContext,
   ): AsyncIterable<CanonicalEvent> {
     const decoder = new KiroStreamDecoder();
     const reader = stream.getReader();
@@ -593,7 +605,7 @@ class KiroAdapter implements ProviderAdapter {
       reader.releaseLock();
     }
 
-    const finalUsage = kiroUsage(usage, request.model, outputText);
+    const finalUsage = kiroUsage(usage, request.model, outputText, request.messages, resolveKiroConversationId(request, context));
     yield {
       type: "usage",
       sequence_number: sequence++,

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

@@ -199,4 +199,3 @@ export class MuseCodeOAuthClient extends OAuthDeviceFlow {
 }
 
 export const museCodeOAuthClient = new MuseCodeOAuthClient();
-export { requestMuseCodeKey };

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

@@ -10,8 +10,6 @@ import {
 } from "./muse-oauth";
 import { parseMuseCodeCredential } from "./muse";
 
-const SOURCE = "api.meta.ai/muse-code/key";
-
 interface MuseSubscriptionWindow {
   used_percent?: unknown;
   usedPercent?: unknown;
@@ -132,5 +130,3 @@ export async function fetchMuseQuota(
     error: null,
   };
 }
-
-export { SOURCE as MUSE_QUOTA_SOURCE };

package/src/providers/integrations/opencode/fingerprint.ts

@@ -2,12 +2,14 @@ import { getOpenCodeVersion } from "../../operations/client-versions";
 import { createHash, randomBytes } from "node:crypto";
 
 /**
- * The OpenCode fallback client identity, used only while version discovery has
- * not resolved yet. The live feed (`opencode/latest/<version>/cli`) wins once
- * it is available; upstream accepts a range of releases, so the fallback does
- * not need chasing.
+ * The pinned reference client identity the parity suite asserts on.
+ *
+ * The runtime fallback lives in `VERSION_SOURCES.opencode.fallback`
+ * (`operations/client-versions.ts`); this mirror exists so the parity suite
+ * can pin the exact identity sent before discovery resolves. Keep both in
+ * lockstep when the CLI releases.
  */
-export const OPENCODE_CLIENT_VERSION = "2.1.1";
+export const OPENCODE_CLIENT_VERSION = "2.2.5";
 
 let lastTimestamp = 0;
 let sequenceCounter = 0;

package/src/providers/integrations/opencode/provider.ts

@@ -150,17 +150,6 @@ export function isFreeTierZenModel(modelId: string): boolean {
   return bare.endsWith("-free") || KNOWN_FREE_ZEN_IDS.includes(bare) || bare.toLowerCase().includes("free");
 }
 
-/**
- * The anonymous credential the free tier accepts.
- *
- * Captured from a real client dispatch and confirmed live 2026-10-14: without
- * it a free-model request is refused with 403 `FreeTierError` even when every
- * other field is byte-exact, and with it the same request returns 200. It is a
- * sentinel the upstream recognizes, not a secret — but it is a credential
- * value, so it lives here rather than in the shared fingerprint.
- */
-const ANONYMOUS_ZEN_BEARER = "public";
-
 /**
  * The `Accept` a free-tier dispatch advertises.
  *
@@ -184,9 +173,10 @@ function opencodeDesktopHeaders(
       context.request_headers?.["x-opencode-project"],
       context.request_headers?.["x-opencode-session-id"],
     ),
-    // The gate reads the anonymous sentinel: a free dispatch with no
-    // Authorization is refused regardless of headers, tools, or session shape.
-    ...(freeModel ? { authorization: `Bearer ${ANONYMOUS_ZEN_BEARER}` } : {}),
+    // The free-tier gate accepts dispatches with no `Authorization` at all
+    // (verified live 2026-11-02: the same captured flow answers 200 both with
+    // `Bearer public` and with no auth header, as long as the body/session
+    // fingerprint is valid). No anonymous sentinel is sent.
     // The free-tier gate refuses non-streaming dispatches with 403
     // FreeTierError, so free models always advertise SSE regardless of the
     // client's own Accept; billed models keep the JSON default. The value is
@@ -211,27 +201,28 @@ function opencodeDesktopHeaders(
  * `ToolDefinition`s — every wire codec serializes them, no per-wire patching.
  */
 /**
- * Every tool the free-tier gate recognises, in the order the client declares
- * them, with the client's own description and schema.
+ * Every tool the free-tier gate recognises, in the order the real 2.2.0
+ * client declares them on the wire (mitm capture 2026-11-02, flow 4), with
+ * the client's own description and schema.
  *
  * The gate compares a recognised tool's definition, not just its name: a stub
  * carrying the right name is refused. These are therefore verbatim captures —
- * see `./tool-definitions` for provenance.
+ * see `./tool-definitions` for provenance. A real dispatch carries exactly
+ * these 11 tools (the binary's full `UPt` registry has 14, but the build
+ * agent sends only these).
  */
 const FREE_AGENT_TOOL_NAMES_ORDERED: readonly string[] = [
-  "shell",
+  "edit",
   "glob",
-  "read",
   "grep",
+  "read",
+  "shell",
+  "skill",
+  "subagent",
   "webfetch",
   "websearch",
   "write",
-  "edit",
-  "subagent",
   "execute",
-  "patch",
-  "question",
-  "skill",
 ];
 
 /**
@@ -268,6 +259,8 @@ function ensureFreeAgentRequest(request: CanonicalRequest): CanonicalRequest {
       name,
       description: definition?.description ?? name,
       jsonSchema: (definition?.parameters ?? FREE_AGENT_TOOL_SCHEMA) as ToolDefinition["jsonSchema"],
+      // The real client marks every declared tool strict:false on the wire.
+      strict: false,
     };
   });
   if (missing.length === 0) return request;