@bitkyc08/opencodex 2.52.0 → 2.53.0

package/src/adapters/kiro/adapter.ts

@@ -0,0 +1,316 @@
+import { debugProviderDiagnostic } from "../../lib/debug";
+import { isDebugEnabled } from "../../lib/debug-settings";
+import {
+  releaseTranslatedEvent,
+  retainTranslatedEvent,
+  type TranslatorBudget,
+} from "../../lib/translator-budget";
+import { resolveKiroApiRegion, resolveKiroRequestProfile } from "../../oauth/kiro";
+import type {
+  AdapterEvent,
+  OcxParsedRequest,
+  OcxProviderConfig,
+} from "../../types";
+import type { ProviderAdapter } from "../base";
+import type { AdapterFetchContext, AdapterRequest } from "../base";
+import { safeKiroHttpErrorMessage } from "../kiro-errors";
+import { calibrateKiroEstimate } from "../kiro-calibration";
+import { normalizeKiroImages } from "../kiro-images";
+import type { KiroCompletionMode } from "../kiro-constants";
+import { fetchKiroWithRetry } from "../kiro-retry";
+import { fingerprint, invocationId, osTag } from "../kiro-wire";
+import { hasTrailingDeliveredFinalAnswer } from "./conversation";
+import { buildKiroPayload } from "./payload";
+import {
+  jsonStringSerializedUtf8Bytes,
+  parseKiroStream,
+  type KiroFallbackFactory,
+} from "./stream";
+import {
+  estimateKiroInputTokens,
+  estimateKiroLogInputTokens,
+  estimateKiroPayloadInputTokens,
+  kiroPayloadMessages,
+  kiroUpstreamContextWindow,
+} from "./usage";
+import {
+  AMZ_TARGET,
+  KIRO_FALLBACK_SERIALIZATION_ENVELOPE_BYTES,
+  KIRO_IDE_VERSION,
+  kiroCliUserAgent,
+  kiroRuntimeEndpoint,
+  NODE_VERSION,
+  SDK_VERSION,
+  type KiroWireClient,
+} from "./wire";
+
+// Adapter
+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;
+  let conversationId: string | undefined;
+  let completionMode: KiroCompletionMode = "disabled";
+  let requestSnapshot: OcxParsedRequest | undefined;
+  let firstRequestBodyBytes = 0;
+  let requestAbortSignal: AbortSignal | undefined;
+
+  const build = async (
+    parsed: OcxParsedRequest,
+    forcedCompletionMode?: KiroCompletionMode,
+  ): Promise<{
+    request: AdapterRequest;
+    nameMap: Map<string, string>;
+    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");
+    }
+    const region = resolveKiroApiRegion(parsed._kiroAuthContext);
+    // Request-scoped: an AWS Builder ID account has no profile of its own and resolves to Kiro's
+    // fixed service profile here, without that value ever becoming the account's stored identity.
+    const requestProfile = resolveKiroRequestProfile(parsed._kiroAuthContext);
+    const resolvedProfileArn = requestProfile.profileArn;
+    const isApiKey = provider.apiKey.trim().startsWith("ksk_");
+    const profileArn = isApiKey ? undefined : resolvedProfileArn;
+    // Builder ID and Kiro API keys are accepted only on Kiro's CLI request path; enterprise
+    // profiles retain the IDE-shaped request. Builder ID now carries a profile ARN, so a truthy
+    // `profileArn` no longer implies "enterprise". The wire path reads the resolver's own verdict
+    // rather than re-deriving it, so the accountless path — where the auth type comes from the
+    // local import, not the request context — cannot send the fallback inside an IDE-shaped call.
+    const isBuilderId = requestProfile.builderIdFallback;
+    const wireClient: KiroWireClient = isApiKey || isBuilderId || !profileArn ? "cli" : "ide";
+    const fp = fingerprint().slice(0, 64);
+    const headers: Record<string, string> = wireClient === "cli" ? {
+      authorization: `Bearer ${provider.apiKey}`,
+      "content-type": "application/x-amz-json-1.0",
+      accept: "*/*",
+      "x-amz-target": AMZ_TARGET,
+      "user-agent": kiroCliUserAgent(true),
+      "x-amz-user-agent": kiroCliUserAgent(false),
+      "x-amzn-codewhisperer-optout": "true",
+      "amz-sdk-request": "attempt=1; max=3",
+      "amz-sdk-invocation-id": invocationId(),
+      ...(isApiKey ? { tokentype: "API_KEY" } : {}),
+    } : {
+      authorization: `Bearer ${provider.apiKey}`,
+      "content-type": "application/x-amz-json-1.0",
+      accept: "application/vnd.amazon.eventstream",
+      "x-amz-target": AMZ_TARGET,
+      "user-agent": `aws-sdk-js/${SDK_VERSION} ua/2.1 os/${osTag()} lang/js md/nodejs#${NODE_VERSION} api/codewhispererstreaming#${SDK_VERSION} m/E KiroIDE-${KIRO_IDE_VERSION}-${fp}`,
+      "x-amz-user-agent": `aws-sdk-js/${SDK_VERSION} KiroIDE-${KIRO_IDE_VERSION}-${fp}`,
+      "x-amzn-codewhisperer-optout": "true",
+      "x-amzn-kiro-agent-mode": "vibe",
+      "amz-sdk-invocation-id": invocationId(),
+    };
+    if (profileArn) headers["x-amzn-kiro-profile-arn"] = profileArn;
+    const built = buildKiroPayload(parsed, profileArn, forcedCompletionMode, wireClient);
+    await normalizeKiroImages(built.payload);
+    // Apply what earlier turns of THIS conversation measured. An unseen conversation is
+    // unchanged, so a first turn behaves exactly as it would without calibration.
+    const rawContextInputEstimate = estimateKiroPayloadInputTokens(built.payload, parsed.modelId);
+    const contextInputEstimate = calibrateKiroEstimate(built.conversationId, rawContextInputEstimate);
+    const body = JSON.stringify(built.payload);
+    // Every field below is evaluated before the call, so an unguarded call re-encodes the
+    // whole request body on each request even when provider debug is off. Gate the details.
+    if (isDebugEnabled()) {
+      debugProviderDiagnostic("kiro", "request", {
+        region,
+        requestedModel: parsed.modelId,
+        completionMode: built.completionMode,
+        bodyBytes: new TextEncoder().encode(body).length,
+        messageCount: kiroPayloadMessages(parsed).length,
+        toolCount: parsed.context.tools?.length ?? 0,
+        hasProfileArn: Boolean(profileArn),
+        wireClient,
+        hasPreviousResponseId: Boolean(parsed.previousResponseId),
+      });
+    }
+    return {
+      request: {
+        url: kiroRuntimeEndpoint(provider, region),
+        method: "POST",
+        headers,
+        body,
+        usageLog: { inputTokens: estimateKiroLogInputTokens(parsed), estimated: true },
+      },
+      nameMap: built.nameMap,
+      conversationId: built.conversationId,
+      completionMode: built.completionMode,
+      inputTokens: estimateKiroInputTokens(parsed),
+      contextInputEstimate,
+    };
+  };
+
+  const fallbackFactory: KiroFallbackFactory = async (
+    returnedConversationId,
+    assistantText,
+    _sawReasoning,
+    budget,
+  ) => {
+    if (!requestSnapshot) throw new Error("Kiro completion retry lost its request state");
+    if (requestAbortSignal?.aborted) {
+      throw requestAbortSignal.reason instanceof Error
+        ? requestAbortSignal.reason
+        : new DOMException("Kiro request was cancelled", "AbortError");
+    }
+    const retryParsed = structuredClone(requestSnapshot);
+    retryParsed._providerContinuation = {
+      ...(retryParsed._providerContinuation ?? {}),
+      ...(returnedConversationId ? { kiro: { conversationId: returnedConversationId } } : {}),
+    };
+    // Reasoning is not replayable on the Kiro wire. Adding an empty assistant turn merely to mark
+    // that reasoning existed creates REQUEST_BODY_INVALID; only visible text earns a replay turn.
+    if (assistantText.trim()) {
+      retryParsed.context.messages.push({
+        role: "assistant",
+        content: [{ type: "text" as const, text: assistantText }],
+        phase: "commentary",
+        model: retryParsed.modelId,
+        timestamp: Date.now(),
+      });
+    }
+    // The retry starts from the already measured first wire body, adds one JSON-escaped replay
+    // string, and only changes bounded Kiro-owned fields (completion prompt/tool, history wrapper,
+    // and <=256-byte conversation id). 64 KiB is a conservative envelope for those fixed fields.
+    // Reserve that complete upper bound while the first-attempt collectors are still charged so a
+    // near-cap turn fails before build() can materialize the retry payload or serialized body.
+    const retryBodyUpperBound = firstRequestBodyBytes
+      + jsonStringSerializedUtf8Bytes(assistantText)
+      + KIRO_FALLBACK_SERIALIZATION_ENVELOPE_BYTES;
+    const retryBodyReservation = budget.reserveTransient(retryBodyUpperBound, { kind: "request_copies" });
+    let retryBodyBytes = 0;
+    let retryBodyRetained = false;
+    let requestBodyReleased = false;
+    const releaseRequestBody = () => {
+      if (requestBodyReleased) return;
+      requestBodyReleased = true;
+      if (retryBodyRetained) budget.releaseRetained(retryBodyBytes, { kind: "request_copies" });
+      else retryBodyReservation.release();
+    };
+    try {
+      const retry = await build(retryParsed, "text_fallback");
+      retryBodyBytes = Buffer.byteLength(retry.request.body);
+      if (retryBodyBytes > retryBodyUpperBound) {
+        throw new Error("Kiro retry serialization exceeded its pre-admitted upper bound");
+      }
+      retryBodyReservation.commitRetained();
+      retryBodyRetained = true;
+      budget.releaseRetained(retryBodyUpperBound - retryBodyBytes, { kind: "request_copies" });
+      const response = await fetchKiroWithRetry(retry.request, {
+        abortSignal: requestAbortSignal,
+        returnRawErrors: true,
+        stream: true,
+      });
+      return {
+        response,
+        inputTokens: retry.inputTokens,
+        contextInputEstimate: retry.contextInputEstimate,
+        nameMap: retry.nameMap,
+        conversationId: retry.conversationId,
+        releaseRequestBody,
+      };
+    } catch (error) {
+      releaseRequestBody();
+      throw error;
+    }
+  };
+
+  return {
+    name: "kiro",
+    // A replayed history that already ENDS with a delivered final answer has nothing to ask Kiro.
+    // Before this hook the adapter still appended a trailing user turn — a neutral acknowledgement,
+    // but structurally still a prompt — and performed a real inference, so the model answered the
+    // closed task again and the finished turn behaved like a still-open goal.
+    //
+    // Suppressing the completion contract (above) removed the instruction to complete; it could not
+    // remove the inference. This is the boundary: no request is built, nothing is sent, and no token
+    // estimate is recorded.
+    //
+    // The forced-fallback build is deliberately NOT consulted here: this hook runs on the inbound
+    // turn only, and the adapter-owned bounded retry passes "text_fallback" through `build`
+    // directly, never through this path.
+    localTerminal(parsed: OcxParsedRequest) {
+      return hasTrailingDeliveredFinalAnswer(kiroPayloadMessages(parsed), parsed)
+        ? { reason: "kiro_final_answer_already_delivered" }
+        : undefined;
+    },
+
+    async buildRequest(parsed: OcxParsedRequest, incoming) {
+      const built = await build(parsed);
+      modelId = parsed.modelId;
+      contextWindow = kiroUpstreamContextWindow(parsed.modelId);
+      inputTokens = built.inputTokens;
+      contextInputEstimate = built.contextInputEstimate;
+      toolNameMap = built.nameMap;
+      conversationId = built.conversationId;
+      completionMode = built.completionMode;
+      requestSnapshot = structuredClone(parsed);
+      firstRequestBodyBytes = Buffer.byteLength(built.request.body);
+      requestAbortSignal = incoming?.abortSignal;
+      return built.request;
+    },
+
+    parseStream(response: Response, budget: TranslatorBudget): AsyncGenerator<AdapterEvent> {
+      return parseKiroStream(
+        response,
+        budget,
+        modelId,
+        inputTokens,
+        contextWindow,
+        toolNameMap,
+        conversationId,
+        completionMode,
+        completionMode === "required" ? fallbackFactory : undefined,
+        contextInputEstimate,
+      );
+    },
+
+    fetchResponse(request: AdapterRequest, ctx?: AdapterFetchContext): Promise<Response> {
+      // The normal Responses path supplies cancellation at fetch time rather than build time.
+      // 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;
+      return fetchKiroWithRetry(request, ctx);
+    },
+
+    formatErrorBody(status: number, headers: Headers, payloadText: string): string {
+      return safeKiroHttpErrorMessage(status, headers, payloadText);
+    },
+
+    // Kiro always returns an event stream, including for non-streaming Responses requests. Drain
+    // the decoder into a budget-owned batch so an upstream stream cannot grow this array without
+    // bound while the caller waits for the complete JSON response.
+    async parseResponse(response: Response, budget: TranslatorBudget): Promise<AdapterEvent[]> {
+      const events: AdapterEvent[] = [];
+      try {
+        for await (const e of parseKiroStream(
+          response,
+          budget,
+          modelId,
+          inputTokens,
+          contextWindow,
+          toolNameMap,
+          conversationId,
+          completionMode,
+          completionMode === "required" ? fallbackFactory : undefined,
+          contextInputEstimate,
+        )) {
+          retainTranslatedEvent(e, budget, events.at(-1));
+          events.push(e);
+        }
+        return events;
+      } catch (error) {
+        for (const event of events) releaseTranslatedEvent(event, budget);
+        throw error;
+      }
+    },
+  };
+}

package/src/adapters/kiro/conversation.ts

@@ -0,0 +1,136 @@
+import { hasRecordedTrailingDeliveredFinalAnswer } from "../../responses/turn-termination";
+import type {
+  OcxAssistantMessage,
+  OcxMessage,
+  OcxParsedRequest,
+} from "../../types";
+import type { KiroImage } from "../kiro-images";
+import type { KiroHistoryEntry, KiroToolResult, KiroToolUse } from "./wire";
+
+export function validateKiroCapabilities(parsed: OcxParsedRequest): void {
+  const choice = parsed.options.toolChoice;
+  if (choice !== undefined && choice !== "auto" && choice !== "none") {
+    throw new Error("Kiro supports only automatic tool choice or tool_choice:none");
+  }
+  if (parsed.options.serviceTier !== undefined) {
+    throw new Error("Kiro does not support service tiers");
+  }
+  // Structured output is a real contract Kiro cannot honour: the wire has no
+  // schema-constrained response mode, so a caller expecting parseable JSON would receive
+  // prose and fail downstream. Refuse it.
+  //
+  // The rest of the Responses `text` object is not that. `text.verbosity` is a length
+  // preference and `text.format: {type:"text"}` is ordinary prose — the default output
+  // mode, which no capability flag governs and every correct client may send. Testing
+  // `_rawBody.text !== undefined` refused those turns for the mere PRESENCE of the key,
+  // the same mistake db040e70f removed one condition earlier where a permissive
+  // `parallel_tool_calls` hint was read as a requirement.
+  //
+  // Nothing needs stripping the way openai-responses strips a no-op verbosity:
+  // buildKiroPayload composes conversationState field by field from `parsed` and never
+  // spreads `_rawBody`, so a tolerated control is dropped by construction. The test
+  // asserts that absence so it stays true.
+  if (parsed._structuredOutput) {
+    throw new Error("Kiro does not support Responses structured output");
+  }
+}
+
+export type KiroTurn =
+  | {
+      kind: "user";
+      content: string;
+      images: KiroImage[];
+      toolResults: KiroToolResult[];
+      /**
+       * True only for the proxy-generated acknowledgement that follows a delivered final answer.
+       * A flag rather than a content comparison: a real user message may legitimately quote the
+       * same sentence, and treating that as internal state would strip its thinking tags and
+       * completion retry.
+       */
+       answerDeliveredAck?: boolean;
+    }
+  | {
+      kind: "assistant";
+      content: string;
+      toolUses: KiroToolUse[];
+      redactedReasoning?: string;
+      /**
+       * True when this assistant turn was the DELIVERED final answer (Responses
+       * `phase: "final_answer"`). A trailing assistant turn normally means the model stopped
+       * mid-task and needs a continuation prompt, but a delivered final answer already ended its
+       * turn — prompting it again restarts finished work as if a goal were still open.
+       */
+      finalAnswer?: boolean;
+    };
+
+/**
+ * True when the LAST content-bearing message is an assistant final answer that closed its turn.
+ *
+ * Mirrors the turn-merge rule: a tool call in that message, or any later user/tool-result message,
+ * means work continued, so the turn is no longer terminal. Empty assistant messages are skipped
+ * rather than treated as continuation, since they carry no visible turn.
+ */
+export function hasTrailingDeliveredFinalAnswer(messages: readonly OcxMessage[], parsed?: OcxParsedRequest): boolean {
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const msg = messages[i];
+    if (msg.role !== "assistant") return false;
+    const aMsg = msg as OcxAssistantMessage;
+    const hasToolCall = (aMsg.content ?? []).some(part => part.type === "toolCall");
+    if (hasToolCall) return false;
+    const hasText = (aMsg.content ?? []).some(part => part.type === "text" && part.text.trim());
+    if (!hasText) continue;
+    return aMsg.phase === "final_answer"
+      || (parsed !== undefined && hasRecordedTrailingDeliveredFinalAnswer(parsed, messages));
+  }
+  return false;
+}
+
+export function appendTurnText(target: string, next: string): string {
+  if (!next) return target;
+  return target ? `${target}\n\n${next}` : next;
+}
+
+export function validateKiroConversationState(history: KiroHistoryEntry[], currentMessage: KiroHistoryEntry): void {
+  const entries = [...history, currentMessage];
+  const pendingToolUses = new Set<string>();
+  let previousRole: "user" | "assistant" | undefined;
+
+  for (const entry of entries) {
+    const user = entry.userInputMessage;
+    const assistant = entry.assistantResponseMessage;
+    if (Boolean(user) === Boolean(assistant)) {
+      throw new Error("Kiro conversation entries must contain exactly one message role");
+    }
+    const role = user ? "user" : "assistant";
+    if (role === previousRole) throw new Error("Kiro conversation roles must alternate");
+    previousRole = role;
+
+    if (user) {
+      const hasPayload = Boolean(user.content.trim())
+        || Boolean(user.images?.length)
+        || Boolean(user.userInputMessageContext?.toolResults?.length);
+      if (!hasPayload) throw new Error("Kiro user messages must not be empty");
+      for (const result of user.userInputMessageContext?.toolResults ?? []) {
+        if (!pendingToolUses.delete(result.toolUseId)) {
+          throw new Error(`Kiro tool result has no matching tool use ${JSON.stringify(result.toolUseId)}`);
+        }
+        if (!result.content.some(part => part.text.trim())) {
+          throw new Error(`Kiro tool result must not be empty ${JSON.stringify(result.toolUseId)}`);
+        }
+      }
+      continue;
+    }
+
+    const toolUses = assistant?.toolUses ?? [];
+    if (!assistant?.content.trim() && toolUses.length === 0) {
+      throw new Error("Kiro assistant messages must not be empty");
+    }
+    for (const toolUse of toolUses) {
+      if (pendingToolUses.has(toolUse.toolUseId)) {
+        throw new Error(`Kiro conversation contains duplicate tool use ${JSON.stringify(toolUse.toolUseId)}`);
+      }
+      pendingToolUses.add(toolUse.toolUseId);
+    }
+  }
+  if (pendingToolUses.size > 0) throw new Error("Kiro conversation contains an unanswered tool use");
+}