@javargasm/pi-kiro 0.2.0

package/dist/core.js

@@ -0,0 +1,2849 @@
+import { createRequire } from "node:module";
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/debug.ts
+import { appendFileSync, mkdirSync } from "node:fs";
+import { dirname, isAbsolute, resolve } from "node:path";
+function currentLevel() {
+  const raw = (globalThis.process?.env?.KIRO_LOG ?? "").toLowerCase();
+  if (raw === "error" || raw === "warn" || raw === "info" || raw === "debug")
+    return raw;
+  return "warn";
+}
+function enabled(level) {
+  return LEVEL_ORDER[level] <= LEVEL_ORDER[currentLevel()];
+}
+function currentFilePath() {
+  const raw = globalThis.process?.env?.KIRO_LOG_FILE;
+  if (!raw)
+    return null;
+  return isAbsolute(raw) ? raw : resolve(process.cwd(), raw);
+}
+function writeToFile(filePath, line) {
+  try {
+    const dir = dirname(filePath);
+    if (!ensuredDirs.has(dir)) {
+      mkdirSync(dir, { recursive: true });
+      ensuredDirs.add(dir);
+    }
+    appendFileSync(filePath, line + `
+`);
+  } catch (err) {
+    if (!fileFallbackWarned) {
+      fileFallbackWarned = true;
+      console.error(`[pi-kiro] ERROR failed to write KIRO_LOG_FILE=${filePath}:`, err);
+    }
+  }
+}
+function emit(level, message, data) {
+  if (!enabled(level))
+    return;
+  const filePath = currentFilePath();
+  if (filePath) {
+    const record = {
+      ts: new Date().toISOString(),
+      level,
+      msg: message
+    };
+    if (data !== undefined)
+      record.data = data;
+    let line;
+    try {
+      line = JSON.stringify(record);
+    } catch {
+      line = JSON.stringify({ ...record, data: String(data) });
+    }
+    writeToFile(filePath, line);
+    return;
+  }
+  const prefix = `[pi-kiro] ${level.toUpperCase()}`;
+  const sink = level === "error" ? console.error : level === "warn" ? console.warn : console.log;
+  if (data === undefined) {
+    sink(`${prefix} ${message}`);
+  } else {
+    sink(`${prefix} ${message}`, data);
+  }
+}
+function previewChunk(s) {
+  let out = "";
+  const limit = Math.min(s.length, CHUNK_PREVIEW_LIMIT);
+  for (let i = 0;i < limit; i++) {
+    const c = s.charCodeAt(i);
+    if (c === 10)
+      out += "\\n";
+    else if (c === 13)
+      out += "\\r";
+    else if (c === 9)
+      out += "\\t";
+    else if (c < 32 || c === 127)
+      out += `\\x${c.toString(16).padStart(2, "0")}`;
+    else
+      out += s[i];
+  }
+  if (s.length > CHUNK_PREVIEW_LIMIT)
+    out += `…(+${s.length - CHUNK_PREVIEW_LIMIT} chars)`;
+  return out;
+}
+var LEVEL_ORDER, ensuredDirs, fileFallbackWarned = false, log, CHUNK_PREVIEW_LIMIT = 2048;
+var init_debug = __esm(() => {
+  LEVEL_ORDER = {
+    error: 0,
+    warn: 1,
+    info: 2,
+    debug: 3
+  };
+  ensuredDirs = new Set;
+  log = {
+    error: (msg, data) => emit("error", msg, data),
+    warn: (msg, data) => emit("warn", msg, data),
+    info: (msg, data) => emit("info", msg, data),
+    debug: (msg, data) => emit("debug", msg, data),
+    isDebug: () => enabled("debug")
+  };
+});
+
+// src/kiro-cli-sync.ts
+var exports_kiro_cli_sync = {};
+__export(exports_kiro_cli_sync, {
+  saveKiroCliCredentials: () => saveKiroCliCredentials,
+  importFromKiroCli: () => importFromKiroCli,
+  getKiroCliCredentialsAllowExpired: () => getKiroCliCredentialsAllowExpired
+});
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { existsSync } from "node:fs";
+function getKiroDbPath() {
+  const home = homedir();
+  if (process.platform === "win32") {
+    return join(process.env.APPDATA || join(home, "AppData", "Roaming"), "kiro", "db", "kiro.db");
+  }
+  return join(home, ".kiro", "db", "kiro.db");
+}
+function safeJsonParse(value) {
+  if (typeof value !== "string")
+    return null;
+  try {
+    return JSON.parse(value);
+  } catch {
+    return null;
+  }
+}
+function findClientCreds(obj) {
+  if (!obj || typeof obj !== "object")
+    return {};
+  if (typeof obj.clientId === "string" && typeof obj.clientSecret === "string") {
+    return { clientId: obj.clientId, clientSecret: obj.clientSecret };
+  }
+  for (const key of Object.keys(obj)) {
+    const result = findClientCreds(obj[key]);
+    if (result.clientId)
+      return result;
+  }
+  return {};
+}
+function extractRegionFromArn(arn) {
+  if (!arn)
+    return;
+  const parts = arn.split(":");
+  if (parts.length < 6 || parts[0] !== "arn")
+    return;
+  const region = parts[3];
+  return region && region.length > 0 ? region : undefined;
+}
+async function importFromKiroCli() {
+  const dbPath = getKiroDbPath();
+  if (!existsSync(dbPath)) {
+    log.debug(`Kiro CLI DB not found at ${dbPath}`);
+    return null;
+  }
+  try {
+    let Database;
+    try {
+      Database = (await import("bun:sqlite")).Database;
+    } catch {
+      try {
+        Database = (await import("better-sqlite3")).default;
+      } catch {
+        log.debug("No SQLite driver available (need bun:sqlite or better-sqlite3)");
+        return null;
+      }
+    }
+    const db = new Database(dbPath, { readonly: true });
+    try {
+      db.run?.("PRAGMA busy_timeout = 5000") ?? db.exec?.("PRAGMA busy_timeout = 5000");
+    } catch {}
+    let rows;
+    try {
+      const stmt = db.prepare("SELECT key, value FROM auth_kv");
+      rows = stmt.all();
+    } catch {
+      log.debug("Failed to read auth_kv table from Kiro DB");
+      try {
+        db.close();
+      } catch {}
+      return null;
+    }
+    let activeProfileArn;
+    try {
+      const stateStmt = db.prepare("SELECT value FROM state WHERE key = ?");
+      const stateRow = stateStmt.get("api.codewhisperer.profile");
+      const parsed = safeJsonParse(stateRow?.value);
+      const arn = parsed?.arn || parsed?.profileArn || parsed?.profile_arn;
+      if (typeof arn === "string" && arn.trim()) {
+        activeProfileArn = arn.trim();
+      }
+    } catch {}
+    const deviceRegRow = rows.find((r) => typeof r?.key === "string" && r.key.includes("device-registration"));
+    const deviceReg = safeJsonParse(deviceRegRow?.value);
+    const regCreds = deviceReg ? findClientCreds(deviceReg) : {};
+    for (const row of rows) {
+      if (!row.key.includes(":token"))
+        continue;
+      const data = safeJsonParse(row.value);
+      if (!data)
+        continue;
+      const accessToken = data.accessToken || data.access_token;
+      const refreshToken = data.refreshToken || data.refresh_token;
+      if (!accessToken && !refreshToken)
+        continue;
+      const isIdc = row.key.includes("oidc") || row.key.includes("idc");
+      const authMethod = isIdc ? "idc" : "desktop";
+      const oidcRegion = data.region || "us-east-1";
+      let profileArn = data.profile_arn || data.profileArn;
+      if (!profileArn && isIdc) {
+        profileArn = activeProfileArn;
+      }
+      const serviceRegion = extractRegionFromArn(profileArn) || oidcRegion;
+      const result = {
+        accessToken: accessToken || "",
+        refreshToken: refreshToken || "",
+        region: serviceRegion,
+        authMethod,
+        profileArn,
+        email: data.email || data.emailAddress
+      };
+      if (isIdc && regCreds.clientId) {
+        result.clientId = regCreds.clientId;
+        result.clientSecret = regCreds.clientSecret;
+      }
+      try {
+        db.close();
+      } catch {}
+      log.info(`Imported Kiro CLI credentials (method=${authMethod}, region=${serviceRegion}${result.email ? `, email=${result.email}` : ""})`);
+      return result;
+    }
+    try {
+      db.close();
+    } catch {}
+    log.debug("No valid token entries found in Kiro CLI DB");
+    return null;
+  } catch (err) {
+    log.warn(`Failed to import from Kiro CLI: ${err}`);
+    return null;
+  }
+}
+async function getKiroCliCredentialsAllowExpired() {
+  return importFromKiroCli();
+}
+async function saveKiroCliCredentials(creds) {
+  const dbPath = getKiroDbPath();
+  if (!existsSync(dbPath)) {
+    log.debug(`Kiro CLI DB not found at ${dbPath} — cannot save credentials`);
+    return false;
+  }
+  try {
+    let Database;
+    try {
+      Database = (await import("bun:sqlite")).Database;
+    } catch {
+      try {
+        Database = (await import("better-sqlite3")).default;
+      } catch {
+        log.debug("No SQLite driver available for credential write-back");
+        return false;
+      }
+    }
+    const db = new Database(dbPath);
+    try {
+      db.run?.("PRAGMA busy_timeout = 5000") ?? db.exec?.("PRAGMA busy_timeout = 5000");
+    } catch {}
+    let rows;
+    try {
+      const stmt = db.prepare("SELECT key, value FROM auth_kv");
+      rows = stmt.all();
+    } catch {
+      log.debug("Failed to read auth_kv table for credential write-back");
+      try {
+        db.close();
+      } catch {}
+      return false;
+    }
+    const tokenRow = rows.find((r) => r.key.includes(":token"));
+    if (!tokenRow) {
+      log.debug("No token entry found in auth_kv — cannot write back");
+      try {
+        db.close();
+      } catch {}
+      return false;
+    }
+    const existing = safeJsonParse(tokenRow.value) ?? {};
+    const updated = {
+      ...existing,
+      accessToken: creds.accessToken,
+      access_token: creds.accessToken,
+      refreshToken: creds.refreshToken,
+      refresh_token: creds.refreshToken
+    };
+    try {
+      const updateStmt = db.prepare("UPDATE auth_kv SET value = ? WHERE key = ?");
+      updateStmt.run(JSON.stringify(updated), tokenRow.key);
+    } catch (err) {
+      log.warn(`Failed to write credentials back to Kiro CLI DB: ${err}`);
+      try {
+        db.close();
+      } catch {}
+      return false;
+    }
+    try {
+      db.close();
+    } catch {}
+    log.info("Wrote refreshed credentials back to Kiro CLI DB");
+    return true;
+  } catch (err) {
+    log.warn(`Failed to save credentials to Kiro CLI: ${err}`);
+    return false;
+  }
+}
+var init_kiro_cli_sync = __esm(() => {
+  init_debug();
+});
+
+// src/oauth.ts
+init_debug();
+
+// src/stream.ts
+init_debug();
+import { calculateCost, createAssistantMessageEventStream } from "@earendil-works/pi-ai";
+
+// src/event-parser.ts
+init_debug();
+function findJsonEnd(text, start) {
+  let braceCount = 0;
+  let inString = false;
+  let escapeNext = false;
+  for (let i = start;i < text.length; i++) {
+    const char = text[i];
+    if (escapeNext) {
+      escapeNext = false;
+      continue;
+    }
+    if (char === "\\") {
+      escapeNext = true;
+      continue;
+    }
+    if (char === '"') {
+      inString = !inString;
+      continue;
+    }
+    if (!inString) {
+      if (char === "{")
+        braceCount++;
+      else if (char === "}") {
+        braceCount--;
+        if (braceCount === 0)
+          return i;
+      }
+    }
+  }
+  return -1;
+}
+function parseKiroEvent(parsed) {
+  if (parsed.content !== undefined) {
+    return { type: "content", data: parsed.content };
+  }
+  if (parsed.reasoningText !== undefined || parsed.signature !== undefined || parsed.text !== undefined && !parsed.content && !parsed.name && !parsed.message) {
+    let text = "";
+    let signature;
+    if (parsed.reasoningText) {
+      const rt = parsed.reasoningText;
+      text = (rt.text ?? rt.Text) || "";
+      signature = rt.signature ?? rt.Signature;
+    } else {
+      text = parsed.text || "";
+      signature = parsed.signature;
+    }
+    return {
+      type: "reasoning",
+      data: { text, signature }
+    };
+  }
+  if (parsed.name && parsed.toolUseId) {
+    const rawInput = parsed.input;
+    const input = typeof rawInput === "string" ? rawInput : rawInput && typeof rawInput === "object" && Object.keys(rawInput).length > 0 ? JSON.stringify(rawInput) : "";
+    return {
+      type: "toolUse",
+      data: {
+        name: parsed.name,
+        toolUseId: parsed.toolUseId,
+        input,
+        stop: parsed.stop
+      }
+    };
+  }
+  if (parsed.input !== undefined && !parsed.name) {
+    return {
+      type: "toolUseInput",
+      data: {
+        input: typeof parsed.input === "string" ? parsed.input : JSON.stringify(parsed.input)
+      }
+    };
+  }
+  if (parsed.stop !== undefined && parsed.contextUsagePercentage === undefined) {
+    return { type: "toolUseStop", data: { stop: parsed.stop } };
+  }
+  if (parsed.contextUsagePercentage !== undefined) {
+    return {
+      type: "contextUsage",
+      data: { contextUsagePercentage: parsed.contextUsagePercentage }
+    };
+  }
+  if (parsed.followupPrompt !== undefined) {
+    return { type: "followupPrompt", data: parsed.followupPrompt };
+  }
+  if (parsed.error !== undefined || parsed.Error !== undefined) {
+    const err = parsed.error || parsed.Error || "unknown";
+    const message = parsed.message || parsed.Message || parsed.reason;
+    return {
+      type: "error",
+      data: {
+        error: typeof err === "string" ? err : JSON.stringify(err),
+        message
+      }
+    };
+  }
+  if (parsed.usage !== undefined) {
+    const u = parsed.usage;
+    return {
+      type: "usage",
+      data: {
+        inputTokens: u.inputTokens,
+        outputTokens: u.outputTokens
+      }
+    };
+  }
+  return null;
+}
+var EVENT_PATTERNS = [
+  '{"content":',
+  '{"reasoningText":',
+  '{"signature":',
+  '{"text":',
+  '{"name":',
+  '{"input":',
+  '{"stop":',
+  '{"contextUsagePercentage":',
+  '{"followupPrompt":',
+  '{"usage":',
+  '{"toolUseId":',
+  '{"unit":',
+  '{"error":',
+  '{"Error":',
+  '{"message":'
+];
+function findNextEventStart(buffer, from) {
+  let earliest = -1;
+  for (const pattern of EVENT_PATTERNS) {
+    const idx = buffer.indexOf(pattern, from);
+    if (idx >= 0 && (earliest < 0 || idx < earliest))
+      earliest = idx;
+  }
+  return earliest;
+}
+function parseKiroEvents(buffer) {
+  const events = [];
+  let pos = 0;
+  while (pos < buffer.length) {
+    const jsonStart = findNextEventStart(buffer, pos);
+    if (jsonStart < 0) {
+      if (log.isDebug()) {
+        const gap = buffer.substring(pos);
+        const braceIdx = gap.indexOf('{"');
+        if (braceIdx >= 0) {
+          log.debug("event.unmatchedBrace", {
+            from: pos + braceIdx,
+            preview: gap.substring(braceIdx, Math.min(braceIdx + 200, gap.length))
+          });
+        }
+      }
+      break;
+    }
+    if (log.isDebug() && jsonStart > pos) {
+      const skipped = buffer.substring(pos, jsonStart);
+      const braceIdx = skipped.indexOf('{"');
+      if (braceIdx >= 0) {
+        log.debug("event.skippedBrace", {
+          from: pos + braceIdx,
+          preview: skipped.substring(braceIdx, Math.min(braceIdx + 200, skipped.length))
+        });
+      }
+    }
+    const jsonEnd = findJsonEnd(buffer, jsonStart);
+    if (jsonEnd < 0) {
+      return { events, remaining: buffer.substring(jsonStart) };
+    }
+    try {
+      const parsed = JSON.parse(buffer.substring(jsonStart, jsonEnd + 1));
+      const event = parseKiroEvent(parsed);
+      if (event) {
+        events.push(event);
+      } else if (log.isDebug()) {
+        log.debug("event.unknown", { keys: Object.keys(parsed), raw: parsed });
+      }
+    } catch (err) {
+      if (log.isDebug()) {
+        log.debug("event.parseFail", {
+          err: err instanceof Error ? err.message : String(err),
+          snippet: buffer.substring(jsonStart, Math.min(jsonEnd + 1, jsonStart + 200))
+        });
+      }
+    }
+    pos = jsonEnd + 1;
+  }
+  return { events, remaining: "" };
+}
+
+// src/health.ts
+var PERMANENT_PATTERNS = [
+  "Invalid refresh token",
+  "Invalid grant provided",
+  "InvalidGrantException",
+  "UnauthorizedClientException",
+  "AuthorizationPendingException",
+  "ExpiredTokenException",
+  "client is not registered",
+  "The security token is expired",
+  "Access denied"
+];
+function isPermanentError(reason) {
+  if (!reason)
+    return false;
+  return PERMANENT_PATTERNS.some((p) => reason.includes(p));
+}
+
+// src/thinking-parser.ts
+init_debug();
+var THINKING_END_TAG = "</thinking>";
+var THINKING_TAG_VARIANTS = [
+  { open: "<thinking>", close: "</thinking>" },
+  { open: "<think>", close: "</think>" },
+  { open: "<reasoning>", close: "</reasoning>" },
+  { open: "<thought>", close: "</thought>" }
+];
+function trailingPrefixLength(text, tag) {
+  const max = Math.min(text.length, tag.length - 1);
+  for (let len = max;len > 0; len--) {
+    if (text.endsWith(tag.slice(0, len)))
+      return len;
+  }
+  return 0;
+}
+function maxTrailingPrefixLength(text, tags) {
+  let max = 0;
+  for (const tag of tags) {
+    max = Math.max(max, trailingPrefixLength(text, tag));
+  }
+  return max;
+}
+
+class ThinkingTagParser {
+  output;
+  stream;
+  textBuffer = "";
+  inThinking = false;
+  thinkingExtracted = false;
+  thinkingBlockIndex = null;
+  textBlockIndex = null;
+  lastTextBlockIndex = null;
+  activeEndTag = THINKING_END_TAG;
+  constructor(output, stream) {
+    this.output = output;
+    this.stream = stream;
+  }
+  processChunk(chunk) {
+    this.textBuffer += chunk;
+    if (log.isDebug()) {
+      log.debug("thinking.chunk", {
+        chunkLen: chunk.length,
+        bufferLen: this.textBuffer.length,
+        inThinking: this.inThinking,
+        thinkingExtracted: this.thinkingExtracted
+      });
+    }
+    while (this.textBuffer.length > 0) {
+      const prev = this.textBuffer.length;
+      if (!this.inThinking && !this.thinkingExtracted) {
+        this.processBeforeThinking();
+        if (this.textBuffer.length === 0)
+          break;
+      }
+      if (this.inThinking) {
+        this.processInsideThinking();
+        if (this.textBuffer.length === 0)
+          break;
+      }
+      if (this.thinkingExtracted) {
+        this.processAfterThinking();
+        break;
+      }
+      if (this.textBuffer.length >= prev)
+        break;
+    }
+  }
+  finalize() {
+    if (log.isDebug()) {
+      log.debug("thinking.finalize", {
+        bufferLen: this.textBuffer.length,
+        inThinking: this.inThinking,
+        thinkingExtracted: this.thinkingExtracted,
+        textBlockIndex: this.textBlockIndex,
+        thinkingBlockIndex: this.thinkingBlockIndex
+      });
+    }
+    if (this.textBuffer.length === 0)
+      return;
+    if (this.inThinking && this.thinkingBlockIndex !== null) {
+      const block = this.output.content[this.thinkingBlockIndex];
+      if (block) {
+        block.thinking += this.textBuffer;
+        this.stream.push({
+          type: "thinking_delta",
+          contentIndex: this.thinkingBlockIndex,
+          delta: this.textBuffer,
+          partial: this.output
+        });
+        this.stream.push({
+          type: "thinking_end",
+          contentIndex: this.thinkingBlockIndex,
+          content: block.thinking,
+          partial: this.output
+        });
+      }
+    } else {
+      this.emitText(this.textBuffer);
+    }
+    this.textBuffer = "";
+  }
+  getTextBlockIndex() {
+    return this.textBlockIndex ?? this.lastTextBlockIndex;
+  }
+  processBeforeThinking() {
+    let bestPos = -1;
+    let bestVariant = null;
+    for (const variant of THINKING_TAG_VARIANTS) {
+      const pos = this.textBuffer.indexOf(variant.open);
+      if (pos !== -1 && (bestPos === -1 || pos < bestPos)) {
+        bestPos = pos;
+        bestVariant = variant;
+      }
+    }
+    if (bestPos !== -1 && bestVariant) {
+      if (log.isDebug()) {
+        log.debug("thinking.open", { tag: bestVariant.open, at: bestPos });
+      }
+      if (bestPos > 0)
+        this.emitText(this.textBuffer.slice(0, bestPos));
+      this.textBuffer = this.textBuffer.slice(bestPos + bestVariant.open.length);
+      this.activeEndTag = bestVariant.close;
+      this.inThinking = true;
+      return;
+    }
+    const trailing = maxTrailingPrefixLength(this.textBuffer, THINKING_TAG_VARIANTS.map((v) => v.open));
+    const safeLen = this.textBuffer.length - trailing;
+    if (safeLen > 0) {
+      this.emitText(this.textBuffer.slice(0, safeLen));
+      this.textBuffer = this.textBuffer.slice(safeLen);
+    }
+  }
+  processInsideThinking() {
+    const endPos = this.textBuffer.indexOf(this.activeEndTag);
+    if (endPos !== -1) {
+      if (log.isDebug()) {
+        log.debug("thinking.close", { tag: this.activeEndTag, at: endPos });
+      }
+      if (endPos > 0)
+        this.emitThinking(this.textBuffer.slice(0, endPos));
+      if (this.thinkingBlockIndex !== null) {
+        const block = this.output.content[this.thinkingBlockIndex];
+        if (block) {
+          this.stream.push({
+            type: "thinking_end",
+            contentIndex: this.thinkingBlockIndex,
+            content: block.thinking,
+            partial: this.output
+          });
+        }
+      }
+      this.textBuffer = this.textBuffer.slice(endPos + this.activeEndTag.length);
+      this.inThinking = false;
+      this.thinkingExtracted = true;
+      this.lastTextBlockIndex = this.textBlockIndex;
+      this.textBlockIndex = null;
+      if (this.textBuffer.startsWith(`
+
+`))
+        this.textBuffer = this.textBuffer.slice(2);
+      return;
+    }
+    const trailing = trailingPrefixLength(this.textBuffer, this.activeEndTag);
+    const safeLen = this.textBuffer.length - trailing;
+    if (safeLen > 0) {
+      this.emitThinking(this.textBuffer.slice(0, safeLen));
+      this.textBuffer = this.textBuffer.slice(safeLen);
+    }
+  }
+  processAfterThinking() {
+    this.emitText(this.textBuffer);
+    this.textBuffer = "";
+  }
+  emitText(text) {
+    if (!text)
+      return;
+    if (this.textBlockIndex === null) {
+      this.textBlockIndex = this.output.content.length;
+      this.output.content.push({ type: "text", text: "" });
+      this.stream.push({ type: "text_start", contentIndex: this.textBlockIndex, partial: this.output });
+    }
+    const block = this.output.content[this.textBlockIndex];
+    if (!block)
+      return;
+    block.text += text;
+    this.stream.push({
+      type: "text_delta",
+      contentIndex: this.textBlockIndex,
+      delta: text,
+      partial: this.output
+    });
+  }
+  emitThinking(thinking) {
+    if (!thinking)
+      return;
+    if (this.thinkingBlockIndex === null) {
+      if (this.textBlockIndex !== null) {
+        this.thinkingBlockIndex = this.textBlockIndex;
+        this.output.content.splice(this.thinkingBlockIndex, 0, { type: "thinking", thinking: "" });
+        this.textBlockIndex = this.textBlockIndex + 1;
+      } else {
+        this.thinkingBlockIndex = this.output.content.length;
+        this.output.content.push({ type: "thinking", thinking: "" });
+      }
+      this.stream.push({
+        type: "thinking_start",
+        contentIndex: this.thinkingBlockIndex,
+        partial: this.output
+      });
+    }
+    const block = this.output.content[this.thinkingBlockIndex];
+    if (!block)
+      return;
+    block.thinking += thinking;
+    this.stream.push({
+      type: "thinking_delta",
+      contentIndex: this.thinkingBlockIndex,
+      delta: thinking,
+      partial: this.output
+    });
+  }
+}
+
+// src/tokenizer.ts
+function countTokens(text) {
+  if (!text)
+    return 0;
+  return Math.ceil(text.length / 4);
+}
+
+// src/transform.ts
+import { createHash } from "node:crypto";
+
+// src/kiro-defaults.ts
+var SYSTEM_SEED_INSTRUCTION = `Follow this instruction: # Kiro CLI Default Agent
+
+` + "You are the default Kiro CLI agent, bringing the power of AI-assisted development " + "directly to the user's terminal. You help with coding tasks, system operations, " + `AWS management, and development workflows.
+
+` + `The current model is {{modelId}}.
+`;
+var SYSTEM_SEED_ACK = "I will fully incorporate this information when generating my responses, " + "and explicitly acknowledge relevant parts of the summary when answering questions.";
+function resolveOS() {
+  switch (process.platform) {
+    case "darwin":
+      return "macos";
+    case "win32":
+      return "windows";
+    default:
+      return process.platform;
+  }
+}
+var COMPACTION_THRESHOLD_PCT = 95;
+
+// src/transform.ts
+function normalizeMessages(messages) {
+  return messages.filter((msg) => msg.role !== "assistant" || msg.stopReason !== "error" && msg.stopReason !== "aborted");
+}
+var TOOL_RESULT_LIMIT = 250000;
+var MAX_KIRO_IMAGES = 4;
+var MAX_KIRO_IMAGE_BYTES = 3750000;
+function truncate(text, limit) {
+  if (text.length <= limit)
+    return text;
+  const half = Math.floor(limit / 2);
+  return `${text.substring(0, half)}
+... [TRUNCATED] ...
+${text.substring(text.length - half)}`;
+}
+function extractImages(msg) {
+  if (msg.role === "toolResult" || typeof msg.content === "string")
+    return [];
+  if (!Array.isArray(msg.content))
+    return [];
+  return msg.content.filter((c) => c.type === "image");
+}
+function getContentText(msg) {
+  if (msg.role === "toolResult") {
+    return msg.content.map((c) => c.type === "text" ? c.text : "").join("");
+  }
+  if (typeof msg.content === "string")
+    return msg.content;
+  if (!Array.isArray(msg.content))
+    return "";
+  return msg.content.map((c) => {
+    if (c.type === "text")
+      return c.text;
+    if (c.type === "thinking")
+      return c.thinking;
+    return "";
+  }).join("");
+}
+function parseToolArgs(input) {
+  if (input && typeof input === "object")
+    return input;
+  if (typeof input !== "string")
+    return {};
+  try {
+    return JSON.parse(input);
+  } catch {
+    return {};
+  }
+}
+var KIRO_TOOL_USE_ID_RE = /^tooluse_[A-Za-z0-9]+$/;
+function toKiroToolUseId(id) {
+  if (KIRO_TOOL_USE_ID_RE.test(id))
+    return id;
+  const digest = createHash("sha256").update(id).digest("hex").slice(0, 22);
+  return `tooluse_${digest}`;
+}
+function convertImagesToKiro(images) {
+  let omitted = 0;
+  const valid = [];
+  for (const img of images) {
+    const estimatedBytes = Math.ceil(img.data.length * 3 / 4);
+    if (estimatedBytes > MAX_KIRO_IMAGE_BYTES) {
+      omitted++;
+      continue;
+    }
+    if (valid.length >= MAX_KIRO_IMAGES) {
+      omitted++;
+      continue;
+    }
+    valid.push({
+      format: img.mimeType.split("/")[1] || "png",
+      source: { bytes: img.data }
+    });
+  }
+  return { images: valid, omitted };
+}
+function buildHistory(messages, _modelId, systemPrompt) {
+  const history = [];
+  let systemPrepended = false;
+  let currentMsgStartIdx = messages.length - 1;
+  while (currentMsgStartIdx > 0 && messages[currentMsgStartIdx]?.role === "toolResult") {
+    currentMsgStartIdx--;
+  }
+  const anchor = messages[currentMsgStartIdx];
+  if (anchor?.role === "assistant") {
+    const hasToolCall = Array.isArray(anchor.content) && anchor.content.some((b) => b.type === "toolCall");
+    if (!hasToolCall)
+      currentMsgStartIdx++;
+  }
+  const historyMessages = messages.slice(0, currentMsgStartIdx);
+  for (let i = 0;i < historyMessages.length; i++) {
+    const msg = historyMessages[i];
+    if (!msg)
+      continue;
+    if (msg.role === "user") {
+      let content = typeof msg.content === "string" ? msg.content : getContentText(msg);
+      if (systemPrompt && !systemPrepended) {
+        content = `${systemPrompt}
+
+${content}`;
+        systemPrepended = true;
+      }
+      const images = extractImages(msg);
+      const uim = {
+        content,
+        origin: "KIRO_CLI",
+        ...images.length > 0 ? { images: convertImagesToKiro(images).images } : {}
+      };
+      const prev2 = history[history.length - 1];
+      if (prev2?.userInputMessage) {
+        prev2.userInputMessage.content += `
+
+${uim.content}`;
+        if (uim.images) {
+          prev2.userInputMessage.images = [...prev2.userInputMessage.images ?? [], ...uim.images];
+        }
+      } else {
+        history.push({ userInputMessage: uim });
+      }
+      continue;
+    }
+    if (msg.role === "assistant") {
+      let armContent = "";
+      const armToolUses = [];
+      if (Array.isArray(msg.content)) {
+        for (const block of msg.content) {
+          if (block.type === "text") {
+            armContent += block.text;
+          } else if (block.type === "thinking") {
+            armContent = `<thinking>${block.thinking}</thinking>
+
+${armContent}`;
+          } else if (block.type === "toolCall") {
+            const tc = block;
+            armToolUses.push({
+              name: tc.name,
+              toolUseId: toKiroToolUseId(tc.id),
+              input: parseToolArgs(tc.arguments)
+            });
+          }
+        }
+      }
+      if (!armContent && armToolUses.length === 0)
+        continue;
+      history.push({
+        assistantResponseMessage: {
+          content: armContent,
+          ...armToolUses.length > 0 ? { toolUses: armToolUses } : {}
+        }
+      });
+      continue;
+    }
+    const trMsg = msg;
+    const toolResults = [
+      {
+        content: [{ text: truncate(getContentText(msg), TOOL_RESULT_LIMIT) }],
+        status: trMsg.isError ? "error" : "success",
+        toolUseId: toKiroToolUseId(trMsg.toolCallId)
+      }
+    ];
+    const trImages = [];
+    if (Array.isArray(trMsg.content)) {
+      for (const c of trMsg.content)
+        if (c.type === "image")
+          trImages.push(c);
+    }
+    let j = i + 1;
+    while (j < historyMessages.length && historyMessages[j]?.role === "toolResult") {
+      const next = historyMessages[j];
+      toolResults.push({
+        content: [{ text: truncate(getContentText(next), TOOL_RESULT_LIMIT) }],
+        status: next.isError ? "error" : "success",
+        toolUseId: toKiroToolUseId(next.toolCallId)
+      });
+      if (Array.isArray(next.content)) {
+        for (const c of next.content)
+          if (c.type === "image")
+            trImages.push(c);
+      }
+      j++;
+    }
+    i = j - 1;
+    const prev = history[history.length - 1];
+    if (prev?.userInputMessage) {
+      prev.userInputMessage.content += `
+
+Tool results provided.`;
+      if (trImages.length > 0) {
+        prev.userInputMessage.images = [
+          ...prev.userInputMessage.images ?? [],
+          ...convertImagesToKiro(trImages).images
+        ];
+      }
+      if (!prev.userInputMessage.userInputMessageContext) {
+        prev.userInputMessage.userInputMessageContext = {};
+      }
+      prev.userInputMessage.userInputMessageContext.toolResults = [
+        ...prev.userInputMessage.userInputMessageContext.toolResults ?? [],
+        ...toolResults
+      ];
+    } else {
+      history.push({
+        userInputMessage: {
+          content: "Tool results provided.",
+          origin: "KIRO_CLI",
+          ...trImages.length > 0 ? { images: convertImagesToKiro(trImages).images } : {},
+          userInputMessageContext: { toolResults }
+        }
+      });
+    }
+  }
+  return { history: collapseAgenticLoops(history), systemPrepended, currentMsgStartIdx };
+}
+function collapseAgenticLoops(history) {
+  if (history.length < 4)
+    return history;
+  const result = [];
+  let i = 0;
+  while (i < history.length) {
+    const entry = history[i];
+    if (entry?.assistantResponseMessage?.toolUses && i + 1 < history.length && history[i + 1]?.userInputMessage?.userInputMessageContext?.toolResults) {
+      let j = i;
+      while (j < history.length) {
+        const asst = history[j];
+        if (!asst?.assistantResponseMessage?.toolUses)
+          break;
+        const nextUser = j + 1 < history.length ? history[j + 1] : null;
+        if (!nextUser?.userInputMessage?.userInputMessageContext?.toolResults)
+          break;
+        j += 2;
+      }
+      const pairCount = (j - i) / 2;
+      if (pairCount > 1) {
+        for (let k = i;k < j; k += 2) {
+          const asst = history[k];
+          const user = history[k + 1];
+          if (k === i) {
+            result.push(asst);
+          } else {
+            result.push({
+              assistantResponseMessage: {
+                content: "[tool calling continues]",
+                toolUses: asst.assistantResponseMessage.toolUses
+              }
+            });
+          }
+          result.push(user);
+        }
+      } else {
+        result.push(history[i], history[i + 1]);
+      }
+      i = j;
+    } else {
+      result.push(entry);
+      i++;
+    }
+  }
+  return result;
+}
+
+// src/stream.ts
+var FIRST_TOKEN_TIMEOUT_DEFAULT_MS = 90000;
+var IDLE_TIMEOUT_MS = 60000;
+var MAX_RETRIES = 3;
+var MAX_RETRY_DELAY_MS = 1e4;
+var CAPACITY_MAX_RETRIES = 3;
+var CAPACITY_BASE_DELAY_MS = 5000;
+var CAPACITY_MAX_DELAY_MS = 30000;
+var TRANSIENT_MAX_RETRIES = 3;
+var TRANSIENT_BASE_DELAY_MS = 2000;
+var TRANSIENT_MAX_DELAY_MS = 15000;
+var CONTEXT_TRUNCATION_MAX_RETRIES = 3;
+var CONTEXT_TRUNCATION_DROP_RATIO = 0.3;
+var TOO_BIG_PATTERNS = ["CONTENT_LENGTH_EXCEEDS_THRESHOLD", "Input is too long", "Improperly formed"];
+var NON_RETRYABLE_BODY_PATTERNS = ["MONTHLY_REQUEST_COUNT"];
+var CAPACITY_PATTERN = "INSUFFICIENT_MODEL_CAPACITY";
+function exponentialBackoff(attempt, baseMs, maxMs) {
+  return Math.min(baseMs * 2 ** attempt, maxMs);
+}
+function isTooBigError(status, body) {
+  return status === 413 || status === 400 && TOO_BIG_PATTERNS.some((p) => body.includes(p));
+}
+function isNonRetryableBodyError(body) {
+  return NON_RETRYABLE_BODY_PATTERNS.some((p) => body.includes(p));
+}
+function isCapacityError(body) {
+  return body.includes(CAPACITY_PATTERN);
+}
+function isTransientError(status) {
+  return status === 429 || status >= 500;
+}
+function firstTokenTimeoutForModel(modelId) {
+  const m = kiroModels.find((x) => x.id === modelId);
+  return m?.firstTokenTimeout ?? FIRST_TOKEN_TIMEOUT_DEFAULT_MS;
+}
+var HIDDEN_REASONING_PLACEHOLDER = "Reasoning hidden by provider";
+var HIDDEN_REASONING_COUNTDOWN_MS = 2000;
+function emitHiddenReasoningLate(output, stream) {
+  const contentIndex = output.content.length;
+  const block = {
+    type: "thinking",
+    thinking: HIDDEN_REASONING_PLACEHOLDER,
+    redacted: true
+  };
+  output.content.push(block);
+  stream.push({ type: "thinking_start", contentIndex, partial: output });
+  stream.push({
+    type: "thinking_delta",
+    contentIndex,
+    delta: HIDDEN_REASONING_PLACEHOLDER,
+    partial: output
+  });
+  stream.push({
+    type: "thinking_end",
+    contentIndex,
+    content: "",
+    partial: output
+  });
+}
+function abortableDelay(ms, signal) {
+  if (signal?.aborted)
+    return Promise.reject(signal.reason);
+  return new Promise((resolve2, reject) => {
+    const timer = setTimeout(resolve2, ms);
+    signal?.addEventListener("abort", () => {
+      clearTimeout(timer);
+      reject(signal.reason);
+    }, { once: true });
+  });
+}
+var profileArnCache = new Map;
+var profileArnSkipResolution = false;
+async function resolveProfileArn(accessToken, endpoint) {
+  if (profileArnSkipResolution)
+    return;
+  const cached = profileArnCache.get(endpoint);
+  if (cached !== undefined)
+    return cached;
+  try {
+    const ep = new URL(endpoint);
+    ep.hostname = ep.hostname.replace("runtime.", "management.");
+    ep.pathname = "/";
+    ep.search = "";
+    ep.hash = "";
+    const resp = await fetch(ep.toString(), {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/x-amz-json-1.0",
+        Authorization: `Bearer ${accessToken}`,
+        "X-Amz-Target": "AmazonCodeWhispererService.ListAvailableProfiles"
+      },
+      body: "{}"
+    });
+    if (!resp.ok) {
+      log.warn(`profileArn resolution failed: ${resp.status} ${resp.statusText}`);
+      return;
+    }
+    const j = await resp.json();
+    const arn = j.profiles?.find((p) => p.arn)?.arn;
+    if (!arn) {
+      log.warn("profileArn resolution returned no profile ARN");
+      return;
+    }
+    profileArnCache.set(endpoint, arn);
+    return arn;
+  } catch (error) {
+    log.warn(`profileArn resolution threw: ${error instanceof Error ? error.message : String(error)}`);
+    return;
+  }
+}
+function uniqueSorted(values) {
+  return [...new Set(values)].sort();
+}
+function duplicateValues(values) {
+  const seen = new Set;
+  const dupes = new Set;
+  for (const value of values) {
+    if (seen.has(value))
+      dupes.add(value);
+    else
+      seen.add(value);
+  }
+  return [...dupes].sort();
+}
+function objectKeys(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    return [];
+  return Object.keys(value).sort();
+}
+function summarizeToolUse(toolUse) {
+  const input = toolUse.input;
+  return {
+    name: toolUse.name,
+    toolUseId: toolUse.toolUseId,
+    inputType: Array.isArray(input) ? "array" : typeof input,
+    inputKeys: objectKeys(input)
+  };
+}
+function summarizeToolResult(toolResult) {
+  return {
+    toolUseId: toolResult.toolUseId,
+    status: toolResult.status,
+    contentCount: toolResult.content.length,
+    textChars: toolResult.content.reduce((sum, part) => sum + part.text.length, 0)
+  };
+}
+function summarizeToolSpec(toolSpec) {
+  const spec = toolSpec.toolSpecification;
+  const schema = spec.inputSchema.json;
+  const properties = schema.properties;
+  const required = schema.required;
+  return {
+    name: spec.name,
+    descriptionChars: spec.description.length,
+    schemaKeys: objectKeys(schema),
+    propertyNames: properties && typeof properties === "object" && !Array.isArray(properties) ? Object.keys(properties).sort() : [],
+    requiredCount: Array.isArray(required) ? required.length : 0
+  };
+}
+function summarizeHistoryEntry(entry, index) {
+  if (entry.userInputMessage) {
+    const toolResults = entry.userInputMessage.userInputMessageContext?.toolResults ?? [];
+    return {
+      index,
+      role: "user",
+      contentChars: entry.userInputMessage.content.length,
+      imageCount: entry.userInputMessage.images?.length ?? 0,
+      ...toolResults.length > 0 ? { toolResults: toolResults.map(summarizeToolResult) } : {}
+    };
+  }
+  if (entry.assistantResponseMessage) {
+    const toolUses = entry.assistantResponseMessage.toolUses ?? [];
+    return {
+      index,
+      role: "assistant",
+      contentChars: entry.assistantResponseMessage.content.length,
+      ...toolUses.length > 0 ? { toolUses: toolUses.map(summarizeToolUse) } : {}
+    };
+  }
+  return { index, role: "unknown", contentChars: 0 };
+}
+function collectToolIntegrity(history, currentToolResults) {
+  const toolUseIds = [];
+  const toolResultIds = currentToolResults.map((toolResult) => toolResult.toolUseId);
+  for (const entry of history) {
+    for (const toolUse of entry.assistantResponseMessage?.toolUses ?? []) {
+      toolUseIds.push(toolUse.toolUseId);
+    }
+    for (const toolResult of entry.userInputMessage?.userInputMessageContext?.toolResults ?? []) {
+      toolResultIds.push(toolResult.toolUseId);
+    }
+  }
+  const useSet = new Set(toolUseIds);
+  const resultSet = new Set(toolResultIds);
+  return {
+    toolUseIds: uniqueSorted(toolUseIds),
+    toolResultIds: uniqueSorted(toolResultIds),
+    duplicateToolUseIds: duplicateValues(toolUseIds),
+    duplicateToolResultIds: duplicateValues(toolResultIds),
+    unmatchedToolResults: uniqueSorted(toolResultIds.filter((id) => !useSet.has(id))),
+    toolUsesWithoutResults: uniqueSorted(toolUseIds.filter((id) => !resultSet.has(id)))
+  };
+}
+function summarizeKiroRequest(request, requestBody) {
+  const current = request.conversationState.currentMessage.userInputMessage;
+  const history = request.conversationState.history ?? [];
+  const currentContext = current.userInputMessageContext;
+  const currentToolResults = currentContext?.toolResults ?? [];
+  const currentTools = currentContext?.tools ?? [];
+  const historySummary = history.map(summarizeHistoryEntry);
+  return {
+    conversationId: request.conversationState.conversationId,
+    modelId: current.modelId,
+    requestJsonChars: requestBody.length,
+    historyLen: history.length,
+    roleSequence: historySummary.map((entry) => entry.role),
+    history: historySummary,
+    current: {
+      contentChars: current.content.length,
+      imageCount: current.images?.length ?? 0,
+      toolResultCount: currentToolResults.length,
+      toolSpecCount: currentTools.length,
+      toolSpecNames: currentTools.map((toolSpec) => toolSpec.toolSpecification.name).sort(),
+      toolResults: currentToolResults.map(summarizeToolResult),
+      toolSpecs: currentTools.map(summarizeToolSpec)
+    },
+    toolIntegrity: collectToolIntegrity(history, currentToolResults),
+    additionalModelRequestFieldKeys: objectKeys(request.additionalModelRequestFields),
+    hasProfileArn: !!request.profileArn,
+    agentMode: request.agentMode
+  };
+}
+function emitToolCall(state, output, stream) {
+  if (!state.input.trim())
+    state.input = "{}";
+  let args;
+  try {
+    args = JSON.parse(state.input);
+    if (args && typeof args === "object" && "__tool_use_purpose" in args) {
+      delete args.__tool_use_purpose;
+    }
+  } catch (e) {
+    log.warn(`failed to parse tool input for "${state.name}" (${state.toolUseId}): ${e instanceof Error ? e.message : String(e)}`);
+    return false;
+  }
+  const contentIndex = output.content.length;
+  const toolCall = { type: "toolCall", id: state.toolUseId, name: state.name, arguments: args };
+  output.content.push(toolCall);
+  stream.push({ type: "toolcall_start", contentIndex, partial: output });
+  stream.push({ type: "toolcall_delta", contentIndex, delta: state.input, partial: output });
+  stream.push({ type: "toolcall_end", contentIndex, toolCall, partial: output });
+  return true;
+}
+function streamKiro(model, context, options) {
+  const stream = createAssistantMessageEventStream();
+  (async () => {
+    const output = {
+      role: "assistant",
+      content: [],
+      api: model.api,
+      provider: model.provider,
+      model: model.id,
+      usage: {
+        input: 0,
+        output: 0,
+        cacheRead: 0,
+        cacheWrite: 0,
+        totalTokens: 0,
+        cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 }
+      },
+      stopReason: "stop",
+      timestamp: Date.now()
+    };
+    let hiddenShimTimer = null;
+    try {
+      const accessToken = options?.apiKey;
+      if (!accessToken) {
+        throw new Error("Kiro credentials not set. Run /login kiro.");
+      }
+      const endpoint = model.baseUrl || "https://runtime.us-east-1.kiro.dev";
+      const profileArn = await resolveProfileArn(accessToken, endpoint);
+      const kiroModelId = resolveKiroModel(model.id);
+      const thinkingEnabled = !!options?.reasoning || model.reasoning;
+      const reasoningHidden = !!model.reasoningHidden;
+      log.debug("request.init", {
+        endpoint,
+        model: model.id,
+        kiroModelId,
+        contextWindow: model.contextWindow,
+        thinkingEnabled,
+        reasoningHidden,
+        reasoning: options?.reasoning,
+        messageCount: context.messages.length,
+        toolCount: context.tools?.length ?? 0,
+        hasSystemPrompt: !!context.systemPrompt,
+        profileArn,
+        sessionId: options?.sessionId
+      });
+      let systemPrompt = context.systemPrompt ?? "";
+      if (thinkingEnabled && !reasoningHidden) {
+        const budget = options?.reasoning === "xhigh" ? 50000 : options?.reasoning === "high" ? 30000 : options?.reasoning === "medium" ? 20000 : 1e4;
+        systemPrompt = `<thinking_mode>enabled</thinking_mode><max_thinking_length>${budget}</max_thinking_length>${systemPrompt ? `
+${systemPrompt}` : ""}`;
+      }
+      const envState = {
+        operatingSystem: resolveOS(),
+        currentWorkingDirectory: process.cwd()
+      };
+      const conversationId = options?.sessionId ?? crypto.randomUUID();
+      let retryCount = 0;
+      while (retryCount <= MAX_RETRIES) {
+        if (options?.signal?.aborted)
+          throw options.signal.reason;
+        const normalized = normalizeMessages(context.messages);
+        const {
+          history,
+          systemPrepended,
+          currentMsgStartIdx
+        } = buildHistory(normalized, kiroModelId, systemPrompt);
+        const seedInstruction = SYSTEM_SEED_INSTRUCTION.replace("{{modelId}}", kiroModelId);
+        const seedPair = [
+          { userInputMessage: { content: seedInstruction, origin: "KIRO_CLI" } },
+          { assistantResponseMessage: { content: SYSTEM_SEED_ACK } }
+        ];
+        history.unshift(...seedPair);
+        const currentMessages = normalized.slice(currentMsgStartIdx);
+        const firstMsg = currentMessages[0];
+        let currentContent = "";
+        const currentToolResults = [];
+        let currentImages;
+        if (firstMsg?.role === "assistant") {
+          const am = firstMsg;
+          let armContent = "";
+          const armToolUses = [];
+          if (Array.isArray(am.content)) {
+            for (const b of am.content) {
+              if (b.type === "text") {
+                armContent += b.text;
+              } else if (b.type === "thinking") {
+                armContent = `<thinking>${b.thinking}</thinking>
+
+${armContent}`;
+              } else if (b.type === "toolCall") {
+                const tc = b;
+                armToolUses.push({
+                  name: tc.name,
+                  toolUseId: toKiroToolUseId(tc.id),
+                  input: parseToolArgs(tc.arguments)
+                });
+              }
+            }
+          }
+          if (armContent || armToolUses.length > 0) {
+            const last = history[history.length - 1];
+            if (last && !last.userInputMessage && last.assistantResponseMessage) {
+              last.assistantResponseMessage.content += `
+
+${armContent}`;
+              if (armToolUses.length > 0) {
+                last.assistantResponseMessage.toolUses = [
+                  ...last.assistantResponseMessage.toolUses ?? [],
+                  ...armToolUses
+                ];
+              }
+            } else {
+              history.push({
+                assistantResponseMessage: {
+                  content: armContent,
+                  ...armToolUses.length > 0 ? { toolUses: armToolUses } : {}
+                }
+              });
+            }
+          }
+          const toolResultImages = [];
+          for (let i = 1;i < currentMessages.length; i++) {
+            const m = currentMessages[i];
+            if (m?.role === "toolResult") {
+              const trm = m;
+              currentToolResults.push({
+                content: [{ text: truncate(getContentText(m), TOOL_RESULT_LIMIT) }],
+                status: trm.isError ? "error" : "success",
+                toolUseId: toKiroToolUseId(trm.toolCallId)
+              });
+              if (Array.isArray(trm.content)) {
+                for (const c of trm.content) {
+                  if (c.type === "image")
+                    toolResultImages.push(c);
+                }
+              }
+            }
+          }
+          if (toolResultImages.length > 0) {
+            const { images: converted, omitted } = convertImagesToKiro(toolResultImages);
+            if (omitted > 0)
+              log.warn(`${omitted} tool-result image(s) omitted (size/count limit)`);
+            currentImages = currentImages ? [...currentImages, ...converted] : converted;
+          }
+          currentContent = currentToolResults.length > 0 ? "Tool results provided." : "Please proceed with the task.";
+        } else if (firstMsg?.role === "toolResult") {
+          const toolResultImages = [];
+          for (const m of currentMessages) {
+            if (m?.role === "toolResult") {
+              const trm = m;
+              currentToolResults.push({
+                content: [{ text: truncate(getContentText(m), TOOL_RESULT_LIMIT) }],
+                status: trm.isError ? "error" : "success",
+                toolUseId: toKiroToolUseId(trm.toolCallId)
+              });
+              if (Array.isArray(trm.content)) {
+                for (const c of trm.content) {
+                  if (c.type === "image")
+                    toolResultImages.push(c);
+                }
+              }
+            }
+          }
+          if (toolResultImages.length > 0) {
+            const { images: converted, omitted } = convertImagesToKiro(toolResultImages);
+            if (omitted > 0)
+              log.warn(`${omitted} tool-result image(s) omitted (size/count limit)`);
+            currentImages = currentImages ? [...currentImages, ...converted] : converted;
+          }
+          currentContent = "Tool results provided.";
+        } else if (firstMsg?.role === "user") {
+          currentContent = typeof firstMsg.content === "string" ? firstMsg.content : getContentText(firstMsg);
+          if (systemPrompt && !systemPrepended) {
+            currentContent = `${systemPrompt}
+
+${currentContent}`;
+          }
+        }
+        const now = new Date;
+        const tzOffset = -now.getTimezoneOffset();
+        const tzSign = tzOffset >= 0 ? "+" : "-";
+        const tzH = String(Math.floor(Math.abs(tzOffset) / 60)).padStart(2, "0");
+        const tzM = String(Math.abs(tzOffset) % 60).padStart(2, "0");
+        const isoLocal = now.getFullYear() + "-" + String(now.getMonth() + 1).padStart(2, "0") + "-" + String(now.getDate()).padStart(2, "0") + "T" + String(now.getHours()).padStart(2, "0") + ":" + String(now.getMinutes()).padStart(2, "0") + ":" + String(now.getSeconds()).padStart(2, "0") + "." + String(now.getMilliseconds()).padStart(3, "0") + tzSign + tzH + ":" + tzM;
+        const weekday = now.toLocaleDateString("en-US", { weekday: "long" });
+        currentContent = `--- CONTEXT ENTRY BEGIN ---
+` + `Current time: ${weekday}, ${isoLocal}
+` + `--- CONTEXT ENTRY END ---
+
+` + `--- USER MESSAGE BEGIN ---
+` + `${currentContent}
+` + `--- USER MESSAGE END ---`;
+        let uimc = {
+          envState
+        };
+        if (currentToolResults.length > 0)
+          uimc.toolResults = currentToolResults;
+        if (context.tools?.length) {
+          const deepCleanSchema = (obj) => {
+            if (Array.isArray(obj)) {
+              return obj.map(deepCleanSchema);
+            } else if (obj !== null && typeof obj === "object") {
+              const cleaned = {};
+              for (const [k, v] of Object.entries(obj)) {
+                if (k === "$schema")
+                  continue;
+                if (k === "required" && Array.isArray(v) && v.length === 0)
+                  continue;
+                cleaned[k] = deepCleanSchema(v);
+              }
+              return cleaned;
+            }
+            return obj;
+          };
+          uimc.tools = context.tools.map((t) => {
+            const params = deepCleanSchema(t.parameters);
+            if (params.properties) {
+              params.properties.__tool_use_purpose = {
+                type: "string",
+                description: "A brief explanation why you are making this tool use."
+              };
+            }
+            return {
+              toolSpecification: {
+                name: t.name,
+                description: t.description || `Use ${t.name}`,
+                inputSchema: { json: params }
+              }
+            };
+          });
+        }
+        if (firstMsg?.role === "user") {
+          const imgs = extractImages(firstMsg);
+          if (imgs.length > 0) {
+            const { images: converted, omitted } = convertImagesToKiro(imgs);
+            if (omitted > 0)
+              log.warn(`${omitted} user image(s) omitted (size/count limit)`);
+            currentImages = converted;
+          }
+        }
+        const request = {
+          conversationState: {
+            chatTriggerType: "MANUAL",
+            agentTaskType: "vibe",
+            conversationId,
+            currentMessage: {
+              userInputMessage: {
+                content: currentContent,
+                modelId: kiroModelId,
+                origin: "KIRO_CLI",
+                ...currentImages ? { images: currentImages } : {},
+                userInputMessageContext: uimc
+              }
+            },
+            ...history.length > 0 ? { history } : {}
+          },
+          ...profileArn ? { profileArn } : {},
+          agentMode: "vibe"
+        };
+        const EFFORT_MAP = {
+          minimal: "low",
+          low: "medium",
+          medium: "high",
+          high: "xhigh",
+          xhigh: "max"
+        };
+        const staticModel = kiroModels.find((m) => m.id === model.id);
+        const dynamicModel = getCachedDynamicModels()?.find((m) => m.id === model.id);
+        const supportedEfforts = staticModel?.supportedEfforts ?? dynamicModel?.supportedEfforts;
+        const supportsThinkingConfig = staticModel?.supportsThinkingConfig ?? dynamicModel?.supportsThinkingConfig;
+        if (supportedEfforts && supportedEfforts.length > 0 && options?.reasoning && typeof options.reasoning === "string") {
+          const kiroEffort = EFFORT_MAP[options.reasoning];
+          if (kiroEffort && supportedEfforts.includes(kiroEffort)) {
+            request.additionalModelRequestFields = request.additionalModelRequestFields || {};
+            request.additionalModelRequestFields.output_config = { effort: kiroEffort };
+            log.debug("effort.set", { piReasoning: options.reasoning, kiroEffort, model: model.id });
+          }
+        }
+        if (supportsThinkingConfig && thinkingEnabled) {
+          request.additionalModelRequestFields = request.additionalModelRequestFields || {};
+          request.additionalModelRequestFields.thinking = {
+            type: "adaptive",
+            display: "summarized"
+          };
+          log.debug("thinking.set", { type: "adaptive", display: "summarized", model: model.id });
+        }
+        stream.push({ type: "start", partial: output });
+        if (reasoningHidden && thinkingEnabled && hiddenShimTimer === null) {
+          hiddenShimTimer = setTimeout(() => {
+            hiddenShimTimer = null;
+            emitHiddenReasoningLate(output, stream);
+          }, HIDDEN_REASONING_COUNTDOWN_MS);
+        }
+        let response;
+        let capacityRetryCount = 0;
+        let transientRetryCount = 0;
+        let contextTruncationAttempt = 0;
+        while (true) {
+          const mid = crypto.randomUUID().replace(/-/g, "");
+          const ua = `aws-sdk-rust/1.0.0 ua/2.1 os/other lang/rust api/codewhispererstreaming#1.28.3 m/E app/AmazonQ-For-CLI md/appVersion-1.28.3-${mid}`;
+          const requestBody = JSON.stringify(request);
+          const requestShape = log.isDebug() ? summarizeKiroRequest(request, requestBody) : undefined;
+          if (requestShape)
+            log.debug("request.shape", requestShape);
+          log.debug("request.send", {
+            attempt: retryCount,
+            capacityAttempt: capacityRetryCount,
+            historyLen: history.length,
+            currentContentLen: currentContent.length,
+            hasImages: !!currentImages,
+            toolResultCount: currentToolResults.length,
+            requestJsonChars: requestBody.length
+          });
+          response = await fetch(endpoint, {
+            method: "POST",
+            headers: {
+              "Content-Type": "application/x-amz-json-1.0",
+              Accept: "application/json",
+              Authorization: `Bearer ${accessToken}`,
+              "X-Amz-Target": "AmazonCodeWhispererStreamingService.GenerateAssistantResponse",
+              "x-amzn-codewhisperer-optout": "true",
+              "amz-sdk-invocation-id": crypto.randomUUID(),
+              "amz-sdk-request": "attempt=1; max=1",
+              "x-amzn-kiro-agent-mode": "vibe",
+              "x-amz-user-agent": ua,
+              "user-agent": ua
+            },
+            body: requestBody,
+            signal: options?.signal
+          });
+          if (response.ok)
+            break;
+          let errText = "";
+          try {
+            errText = await response.text();
+          } catch {
+            errText = "";
+          }
+          log.debug("response.error", {
+            status: response.status,
+            body: errText,
+            ...requestShape ? { requestShape } : {}
+          });
+          if (isCapacityError(errText) && capacityRetryCount < CAPACITY_MAX_RETRIES) {
+            capacityRetryCount++;
+            const delayMs = exponentialBackoff(capacityRetryCount - 1, CAPACITY_BASE_DELAY_MS, CAPACITY_MAX_DELAY_MS);
+            log.warn(`INSUFFICIENT_MODEL_CAPACITY — retrying in ${delayMs}ms (${capacityRetryCount}/${CAPACITY_MAX_RETRIES})`);
+            await abortableDelay(delayMs, options?.signal);
+            continue;
+          }
+          if (isNonRetryableBodyError(errText) || isCapacityError(errText)) {
+            throw new Error(`Kiro API error: ${errText || response.statusText}`);
+          }
+          if (isTooBigError(response.status, errText)) {
+            if (contextTruncationAttempt < CONTEXT_TRUNCATION_MAX_RETRIES && history.length > 0) {
+              contextTruncationAttempt++;
+              const dropCount = Math.max(1, Math.floor(history.length * CONTEXT_TRUNCATION_DROP_RATIO));
+              const before = history.length;
+              history.splice(0, dropCount);
+              log.warn(`context too large — truncated history from ${before} to ${history.length} entries ` + `(attempt ${contextTruncationAttempt}/${CONTEXT_TRUNCATION_MAX_RETRIES})`);
+              request.conversationState.history = history.length > 0 ? history : undefined;
+              continue;
+            }
+            throw new Error(`Kiro API error: context_length_exceeded (${response.status} ${errText})`);
+          }
+          if (isTransientError(response.status) && transientRetryCount < TRANSIENT_MAX_RETRIES) {
+            transientRetryCount++;
+            const jitter = Math.floor(Math.random() * 1000);
+            const delayMs = exponentialBackoff(transientRetryCount - 1, TRANSIENT_BASE_DELAY_MS, TRANSIENT_MAX_DELAY_MS) + jitter;
+            log.warn(`transient error ${response.status} — retrying in ${delayMs}ms ` + `(${transientRetryCount}/${TRANSIENT_MAX_RETRIES})`);
+            await abortableDelay(delayMs, options?.signal);
+            continue;
+          }
+          if (response.status === 401) {
+            const permanent = isPermanentError(errText);
+            if (permanent) {
+              profileArnCache.delete(endpoint);
+              throw new Error(`Kiro API error: credentials permanently invalid — run /login kiro to re-authenticate. ${errText}`);
+            }
+          }
+          if (response.status === 403) {
+            profileArnCache.delete(endpoint);
+            throw new Error(`Kiro API error: access token rejected (403) — run /login kiro to re-authenticate. ${errText}`);
+          }
+          throw new Error(`Kiro API error: ${response.status} ${response.statusText} ${errText}`);
+        }
+        if (capacityRetryCount > 0) {
+          log.info(`recovered from capacity pressure after ${capacityRetryCount} retries`);
+        }
+        if (transientRetryCount > 0) {
+          log.info(`recovered from transient error after ${transientRetryCount} retries`);
+        }
+        if (contextTruncationAttempt > 0) {
+          log.info(`recovered after ${contextTruncationAttempt} context truncation(s)`);
+        }
+        const reader = response.body?.getReader();
+        if (!reader)
+          throw new Error("No response body");
+        const decoder = new TextDecoder;
+        let buffer = "";
+        let totalContent = "";
+        let lastContentData = "";
+        let usageEvent = null;
+        let receivedContextUsage = false;
+        let chunkSeq = 0;
+        let eventSeq = 0;
+        const thinkingParser = thinkingEnabled ? new ThinkingTagParser(output, stream) : null;
+        let textBlockIndex = null;
+        let emittedToolCalls = 0;
+        let sawAnyToolCalls = false;
+        let currentToolCall = null;
+        const flushToolCall = () => {
+          if (!currentToolCall)
+            return;
+          if (emitToolCall(currentToolCall, output, stream))
+            emittedToolCalls++;
+          currentToolCall = null;
+        };
+        const cancelHiddenShim = () => {
+          if (hiddenShimTimer) {
+            clearTimeout(hiddenShimTimer);
+            hiddenShimTimer = null;
+          }
+        };
+        let idleTimer = null;
+        let idleCancelled = false;
+        const resetIdle = () => {
+          if (idleTimer)
+            clearTimeout(idleTimer);
+          idleTimer = setTimeout(() => {
+            idleCancelled = true;
+            reader.cancel().catch(() => {});
+          }, IDLE_TIMEOUT_MS);
+        };
+        let gotFirstToken = false;
+        let firstTokenTimedOut = false;
+        let streamError = null;
+        const FIRST_TOKEN_SENTINEL = Symbol("firstTokenTimeout");
+        while (true) {
+          let readResult;
+          if (!gotFirstToken) {
+            const readPromise = reader.read();
+            let firstTokenTimer = null;
+            const result = await Promise.race([
+              readPromise,
+              new Promise((resolve2) => {
+                firstTokenTimer = setTimeout(() => resolve2(FIRST_TOKEN_SENTINEL), firstTokenTimeoutForModel(model.id));
+              })
+            ]);
+            if (firstTokenTimer)
+              clearTimeout(firstTokenTimer);
+            if (result === FIRST_TOKEN_SENTINEL) {
+              readPromise.catch(() => {});
+              reader.cancel().catch(() => {});
+              firstTokenTimedOut = true;
+              break;
+            }
+            readResult = result;
+            gotFirstToken = true;
+            resetIdle();
+          } else {
+            readResult = await reader.read();
+          }
+          const { done, value } = readResult;
+          if (done)
+            break;
+          const decoded = decoder.decode(value, { stream: true });
+          buffer += decoded;
+          if (log.isDebug()) {
+            log.debug("stream.chunk", {
+              seq: chunkSeq++,
+              bytes: value?.byteLength ?? 0,
+              decodedLen: decoded.length,
+              preview: previewChunk(decoded)
+            });
+          }
+          const { events, remaining } = parseKiroEvents(buffer);
+          buffer = remaining;
+          if (events.length > 0)
+            resetIdle();
+          if (log.isDebug() && events.length > 0) {
+            for (const ev of events) {
+              log.debug("stream.event", { seq: eventSeq++, event: ev });
+            }
+          }
+          for (const event of events) {
+            switch (event.type) {
+              case "contextUsage": {
+                const pct = event.data.contextUsagePercentage;
+                output.usage.input = pct >= COMPACTION_THRESHOLD_PCT ? model.contextWindow + 1 : Math.round(pct / 100 * model.contextWindow);
+                receivedContextUsage = true;
+                log.debug("contextUsage", { pct, threshold: COMPACTION_THRESHOLD_PCT, willCompact: pct >= COMPACTION_THRESHOLD_PCT });
+                break;
+              }
+              case "reasoning": {
+                cancelHiddenShim();
+                if (output.content.length === 0 || output.content[output.content.length - 1]?.type !== "thinking") {
+                  output.content.push({ type: "thinking", thinking: "" });
+                  stream.push({ type: "thinking_start", contentIndex: output.content.length - 1, partial: output });
+                }
+                const contentIndex = output.content.length - 1;
+                const tc = output.content[contentIndex];
+                if (event.data.text) {
+                  tc.thinking += event.data.text;
+                  stream.push({ type: "thinking_delta", contentIndex, delta: event.data.text, partial: output });
+                }
+                if (event.data.signature) {
+                  tc.thinkingSignature = event.data.signature;
+                }
+                break;
+              }
+              case "content": {
+                if (event.data === lastContentData)
+                  continue;
+                lastContentData = event.data;
+                totalContent += event.data;
+                cancelHiddenShim();
+                if (thinkingParser) {
+                  thinkingParser.processChunk(event.data);
+                } else {
+                  if (textBlockIndex === null) {
+                    textBlockIndex = output.content.length;
+                    output.content.push({ type: "text", text: "" });
+                    stream.push({ type: "text_start", contentIndex: textBlockIndex, partial: output });
+                  }
+                  const block = output.content[textBlockIndex];
+                  if (block) {
+                    block.text += event.data;
+                    stream.push({
+                      type: "text_delta",
+                      contentIndex: textBlockIndex,
+                      delta: event.data,
+                      partial: output
+                    });
+                  }
+                }
+                break;
+              }
+              case "toolUse": {
+                const tc = event.data;
+                cancelHiddenShim();
+                sawAnyToolCalls = true;
+                if (!currentToolCall || currentToolCall.toolUseId !== tc.toolUseId) {
+                  flushToolCall();
+                  currentToolCall = { toolUseId: tc.toolUseId, name: tc.name, input: "" };
+                }
+                currentToolCall.input += tc.input || "";
+                if (tc.input)
+                  totalContent += tc.input;
+                if (tc.stop)
+                  flushToolCall();
+                break;
+              }
+              case "toolUseInput": {
+                if (currentToolCall)
+                  currentToolCall.input += event.data.input || "";
+                if (event.data.input)
+                  totalContent += event.data.input;
+                break;
+              }
+              case "toolUseStop": {
+                if (event.data.stop)
+                  flushToolCall();
+                break;
+              }
+              case "usage": {
+                usageEvent = event.data;
+                break;
+              }
+              case "error": {
+                streamError = event.data.message ? `${event.data.error}: ${event.data.message}` : event.data.error;
+                reader.cancel().catch(() => {});
+                break;
+              }
+            }
+            if (streamError)
+              break;
+          }
+        }
+        if (idleTimer)
+          clearTimeout(idleTimer);
+        if (firstTokenTimedOut || idleCancelled || streamError) {
+          if (retryCount < MAX_RETRIES) {
+            retryCount++;
+            const delayMs = exponentialBackoff(retryCount - 1, 1000, MAX_RETRY_DELAY_MS);
+            log.warn(`stream ${firstTokenTimedOut ? "first-token timed out" : idleCancelled ? "idle timed out" : `error: ${streamError}`} — retrying (${retryCount}/${MAX_RETRIES})`);
+            cancelHiddenShim();
+            await abortableDelay(delayMs, options?.signal);
+            output.content = [];
+            textBlockIndex = null;
+            continue;
+          }
+          if (streamError)
+            throw new Error(`Kiro API stream error after max retries: ${streamError}`);
+          throw new Error(`Kiro API error: ${firstTokenTimedOut ? "first token" : "idle"} timeout after max retries`);
+        }
+        cancelHiddenShim();
+        if (currentToolCall && emitToolCall(currentToolCall, output, stream))
+          emittedToolCalls++;
+        if (thinkingParser) {
+          thinkingParser.finalize();
+          textBlockIndex = thinkingParser.getTextBlockIndex();
+        }
+        if (textBlockIndex !== null) {
+          const block = output.content[textBlockIndex];
+          if (block) {
+            stream.push({
+              type: "text_end",
+              contentIndex: textBlockIndex,
+              content: block.text,
+              partial: output
+            });
+          }
+        }
+        if (usageEvent?.inputTokens !== undefined)
+          output.usage.input = usageEvent.inputTokens;
+        output.usage.output = usageEvent?.outputTokens ?? countTokens(totalContent);
+        output.usage.totalTokens = output.usage.input + output.usage.output;
+        try {
+          calculateCost(model, output.usage);
+        } catch {
+          output.usage.cost = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 };
+        }
+        const textBlock = textBlockIndex !== null ? output.content[textBlockIndex] : undefined;
+        const hasText = !!textBlock && textBlock.text.length > 0;
+        if (!hasText && !sawAnyToolCalls) {
+          if (retryCount < MAX_RETRIES) {
+            retryCount++;
+            const delayMs = exponentialBackoff(retryCount - 1, 1000, MAX_RETRY_DELAY_MS);
+            log.warn(`empty response — retrying (${retryCount}/${MAX_RETRIES})`);
+            cancelHiddenShim();
+            output.content = [];
+            textBlockIndex = null;
+            await abortableDelay(delayMs, options?.signal);
+            continue;
+          }
+          log.warn(`empty response persisted after ${MAX_RETRIES} retries`);
+          cancelHiddenShim();
+        }
+        if (!receivedContextUsage && emittedToolCalls === 0) {
+          output.stopReason = "length";
+        } else {
+          output.stopReason = emittedToolCalls > 0 ? "toolUse" : "stop";
+        }
+        stream.push({
+          type: "done",
+          reason: output.stopReason,
+          message: output
+        });
+        log.debug("response.done", {
+          stopReason: output.stopReason,
+          emittedToolCalls,
+          sawAnyToolCalls,
+          usage: output.usage
+        });
+        stream.end();
+        return;
+      }
+    } catch (error) {
+      output.stopReason = options?.signal?.aborted ? "aborted" : "error";
+      output.errorMessage = error instanceof Error ? error.message : String(error);
+      log.debug("response.caught", { stopReason: output.stopReason, error: output.errorMessage });
+      if (hiddenShimTimer) {
+        clearTimeout(hiddenShimTimer);
+        hiddenShimTimer = null;
+      }
+      stream.push({ type: "error", reason: output.stopReason, error: output });
+      stream.end();
+    }
+  })().catch(() => {
+    try {
+      stream.end();
+    } catch {}
+  });
+  return stream;
+}
+
+// src/models.ts
+var KIRO_MODEL_IDS = new Set([
+  "claude-opus-4.8",
+  "claude-opus-4.7",
+  "claude-opus-4.6",
+  "claude-opus-4.6-1m",
+  "claude-sonnet-4.6",
+  "claude-sonnet-4.6-1m",
+  "claude-opus-4.5",
+  "claude-sonnet-4.5",
+  "claude-sonnet-4.5-1m",
+  "claude-sonnet-4",
+  "claude-haiku-4.5",
+  "deepseek-3.2",
+  "kimi-k2.5",
+  "minimax-m2.1",
+  "minimax-m2.5",
+  "glm-4.7",
+  "glm-4.7-flash",
+  "qwen3-coder-next",
+  "agi-nova-beta-1m",
+  "qwen3-coder-480b",
+  "auto"
+]);
+function dotToDash(modelId) {
+  return modelId.replace(/(\d)\.(\d)/g, "$1-$2");
+}
+function resolveKiroModel(modelId) {
+  const kiroId = modelId.replace(/(\d)-(\d)/g, "$1.$2");
+  if (!KIRO_MODEL_IDS.has(kiroId)) {
+    throw new Error(`Unknown Kiro model ID: ${modelId}`);
+  }
+  return kiroId;
+}
+var API_REGION_MAP = {
+  "us-west-1": "us-east-1",
+  "us-west-2": "us-east-1",
+  "us-east-2": "us-east-1",
+  "eu-west-1": "eu-central-1",
+  "eu-west-2": "eu-central-1",
+  "eu-west-3": "eu-central-1",
+  "eu-north-1": "eu-central-1",
+  "eu-south-1": "eu-central-1",
+  "eu-south-2": "eu-central-1",
+  "eu-central-2": "eu-central-1",
+  "ap-northeast-1": "us-east-1",
+  "ap-northeast-2": "us-east-1",
+  "ap-northeast-3": "us-east-1",
+  "ap-southeast-1": "us-east-1",
+  "ap-southeast-2": "us-east-1",
+  "ap-south-1": "us-east-1",
+  "ap-east-1": "us-east-1",
+  "ap-south-2": "us-east-1",
+  "ap-southeast-3": "us-east-1",
+  "ap-southeast-4": "us-east-1"
+};
+function resolveApiRegion(ssoRegion) {
+  if (!ssoRegion)
+    return "us-east-1";
+  return API_REGION_MAP[ssoRegion] ?? ssoRegion;
+}
+var MODELS_BY_REGION = {
+  "us-east-1": new Set([
+    "claude-opus-4-8",
+    "claude-opus-4-7",
+    "claude-opus-4-6",
+    "claude-opus-4-6-1m",
+    "claude-sonnet-4-6",
+    "claude-sonnet-4-6-1m",
+    "claude-opus-4-5",
+    "claude-sonnet-4-5",
+    "claude-sonnet-4-5-1m",
+    "claude-sonnet-4",
+    "claude-haiku-4-5",
+    "deepseek-3-2",
+    "kimi-k2-5",
+    "minimax-m2-1",
+    "minimax-m2-5",
+    "glm-4-7",
+    "glm-4-7-flash",
+    "qwen3-coder-next",
+    "qwen3-coder-480b",
+    "agi-nova-beta-1m",
+    "auto"
+  ]),
+  "eu-central-1": new Set([
+    "claude-opus-4-8",
+    "claude-opus-4-7",
+    "claude-opus-4-6",
+    "claude-sonnet-4-6",
+    "claude-opus-4-5",
+    "claude-sonnet-4-5",
+    "claude-sonnet-4",
+    "claude-haiku-4-5",
+    "minimax-m2-1",
+    "minimax-m2-5",
+    "qwen3-coder-next",
+    "auto"
+  ])
+};
+function filterModelsByRegion(models, apiRegion) {
+  const allowed = MODELS_BY_REGION[apiRegion];
+  if (!allowed) {
+    console.warn(`[pi-kiro] Unknown API region "${apiRegion}" — no models available. Update MODELS_BY_REGION in models.ts.`);
+    return [];
+  }
+  return models.filter((m) => allowed.has(m.id));
+}
+var RUNTIME_ENDPOINTS = {
+  "us-east-1": "https://runtime.us-east-1.kiro.dev",
+  "eu-central-1": "https://runtime.eu-central-1.kiro.dev"
+};
+function resolveRuntimeUrl(apiRegion) {
+  return RUNTIME_ENDPOINTS[apiRegion] ?? `https://runtime.${apiRegion}.kiro.dev`;
+}
+var BASE_URL = resolveRuntimeUrl("us-east-1");
+var ZERO_COST = Object.freeze({ input: 0, output: 0, cacheRead: 0, cacheWrite: 0 });
+var KIRO_DEFAULTS = {
+  api: "kiro-api",
+  provider: "kiro",
+  baseUrl: BASE_URL,
+  cost: ZERO_COST
+};
+var MULTIMODAL = ["text", "image"];
+var TEXT_ONLY = ["text"];
+var kiroModels = [
+  {
+    ...KIRO_DEFAULTS,
+    id: "claude-opus-4-8",
+    name: "Claude Opus 4.8",
+    reasoning: true,
+    input: MULTIMODAL,
+    contextWindow: 1e6,
+    maxTokens: 128000,
+    firstTokenTimeout: 180000,
+    supportedEfforts: ["low", "medium", "high", "xhigh", "max"]
+  },
+  {
+    ...KIRO_DEFAULTS,
+    id: "claude-opus-4-7",
+    name: "Claude Opus 4.7",
+    reasoning: true,
+    input: MULTIMODAL,
+    contextWindow: 1e6,
+    maxTokens: 128000,
+    firstTokenTimeout: 180000,
+    supportedEfforts: ["low", "medium", "high", "xhigh", "max"]
+  },
+  {
+    ...KIRO_DEFAULTS,
+    id: "claude-opus-4-6",
+    name: "Claude Opus 4.6",
+    reasoning: true,
+    input: MULTIMODAL,
+    contextWindow: 1e6,
+    maxTokens: 64000,
+    supportedEfforts: ["low", "medium", "high", "max"]
+  },
+  {
+    ...KIRO_DEFAULTS,
+    id: "claude-opus-4-6-1m",
+    name: "Claude Opus 4.6 (1M)",
+    reasoning: true,
+    input: MULTIMODAL,
+    contextWindow: 1e6,
+    maxTokens: 64000,
+    supportedEfforts: ["low", "medium", "high", "max"]
+  },
+  {
+    ...KIRO_DEFAULTS,
+    id: "claude-sonnet-4-6",
+    name: "Claude Sonnet 4.6",
+    reasoning: true,
+    input: MULTIMODAL,
+    contextWindow: 1e6,
+    maxTokens: 64000,
+    supportedEfforts: ["low", "medium", "high", "max"]
+  },
+  {
+    ...KIRO_DEFAULTS,
+    id: "claude-sonnet-4-6-1m",
+    name: "Claude Sonnet 4.6 (1M)",
+    reasoning: true,
+    input: MULTIMODAL,
+    contextWindow: 1e6,
+    maxTokens: 64000,
+    supportedEfforts: ["low", "medium", "high", "max"]
+  },
+  {
+    ...KIRO_DEFAULTS,
+    id: "claude-opus-4-5",
+    name: "Claude Opus 4.5",
+    reasoning: true,
+    input: MULTIMODAL,
+    contextWindow: 200000,
+    maxTokens: 64000
+  },
+  {
+    ...KIRO_DEFAULTS,
+    id: "claude-sonnet-4-5",
+    name: "Claude Sonnet 4.5",
+    reasoning: true,
+    input: MULTIMODAL,
+    contextWindow: 200000,
+    maxTokens: 65536
+  },
+  {
+    ...KIRO_DEFAULTS,
+    id: "claude-sonnet-4-5-1m",
+    name: "Claude Sonnet 4.5 (1M)",
+    reasoning: true,
+    input: MULTIMODAL,
+    contextWindow: 1e6,
+    maxTokens: 65536
+  },
+  {
+    ...KIRO_DEFAULTS,
+    id: "claude-sonnet-4",
+    name: "Claude Sonnet 4",
+    reasoning: true,
+    input: MULTIMODAL,
+    contextWindow: 200000,
+    maxTokens: 65536
+  },
+  {
+    ...KIRO_DEFAULTS,
+    id: "claude-haiku-4-5",
+    name: "Claude Haiku 4.5",
+    reasoning: false,
+    input: MULTIMODAL,
+    contextWindow: 200000,
+    maxTokens: 65536
+  },
+  {
+    ...KIRO_DEFAULTS,
+    id: "deepseek-3-2",
+    name: "DeepSeek 3.2",
+    reasoning: true,
+    input: TEXT_ONLY,
+    contextWindow: 128000,
+    maxTokens: 8192
+  },
+  {
+    ...KIRO_DEFAULTS,
+    id: "kimi-k2-5",
+    name: "Kimi K2.5",
+    reasoning: true,
+    input: TEXT_ONLY,
+    contextWindow: 200000,
+    maxTokens: 8192
+  },
+  {
+    ...KIRO_DEFAULTS,
+    id: "minimax-m2-5",
+    name: "MiniMax M2.5",
+    reasoning: false,
+    input: TEXT_ONLY,
+    contextWindow: 196000,
+    maxTokens: 64000
+  },
+  {
+    ...KIRO_DEFAULTS,
+    id: "minimax-m2-1",
+    name: "MiniMax M2.1",
+    reasoning: false,
+    input: MULTIMODAL,
+    contextWindow: 196000,
+    maxTokens: 64000
+  },
+  {
+    ...KIRO_DEFAULTS,
+    id: "glm-4-7",
+    name: "GLM 4.7",
+    reasoning: true,
+    input: TEXT_ONLY,
+    contextWindow: 128000,
+    maxTokens: 8192
+  },
+  {
+    ...KIRO_DEFAULTS,
+    id: "glm-4-7-flash",
+    name: "GLM 4.7 Flash",
+    reasoning: false,
+    input: TEXT_ONLY,
+    contextWindow: 128000,
+    maxTokens: 8192
+  },
+  {
+    ...KIRO_DEFAULTS,
+    id: "qwen3-coder-next",
+    name: "Qwen3 Coder Next",
+    reasoning: true,
+    input: MULTIMODAL,
+    contextWindow: 256000,
+    maxTokens: 64000
+  },
+  {
+    ...KIRO_DEFAULTS,
+    id: "qwen3-coder-480b",
+    name: "Qwen3 Coder 480B",
+    reasoning: true,
+    input: TEXT_ONLY,
+    contextWindow: 128000,
+    maxTokens: 8192
+  },
+  {
+    ...KIRO_DEFAULTS,
+    id: "agi-nova-beta-1m",
+    name: "AGI Nova Beta (1M)",
+    reasoning: true,
+    input: MULTIMODAL,
+    contextWindow: 1e6,
+    maxTokens: 65536
+  },
+  {
+    ...KIRO_DEFAULTS,
+    id: "auto",
+    name: "Auto",
+    reasoning: true,
+    input: MULTIMODAL,
+    contextWindow: 200000,
+    maxTokens: 65536
+  }
+];
+async function fetchAvailableModels(accessToken, apiRegion) {
+  const runtimeUrl = `https://runtime.${apiRegion}.kiro.dev/`;
+  const profileArn = await resolveProfileArn(accessToken, runtimeUrl);
+  if (!profileArn) {
+    throw new Error("Missing profileArn: cannot fetch available models.");
+  }
+  const url = `https://management.${apiRegion}.kiro.dev/ListAvailableModels?origin=KIRO_CLI&profileArn=${encodeURIComponent(profileArn)}`;
+  const resp = await fetch(url, {
+    method: "GET",
+    headers: {
+      Authorization: `Bearer ${accessToken}`,
+      Accept: "application/json",
+      "User-Agent": "pi-kiro"
+    }
+  });
+  if (!resp.ok) {
+    throw new Error(`ListAvailableModels failed: HTTP ${resp.status}`);
+  }
+  const data = await resp.json();
+  return (data.models ?? []).filter((m) => m.modelId !== "auto");
+}
+var REASONING_FAMILIES = new Set([
+  "claude-sonnet",
+  "claude-opus",
+  "deepseek",
+  "kimi",
+  "glm",
+  "qwen",
+  "agi-nova",
+  "minimax"
+]);
+function isReasoningModel(dotId) {
+  for (const family of REASONING_FAMILIES) {
+    if (dotId.startsWith(family))
+      return true;
+  }
+  return false;
+}
+function firstTokenTimeout(dotId) {
+  if (dotId.startsWith("claude-opus"))
+    return 180000;
+  return 90000;
+}
+function buildModelsFromApi(apiModels) {
+  return apiModels.map((m) => {
+    KIRO_MODEL_IDS.add(m.modelId);
+    const dashId = dotToDash(m.modelId);
+    const supportedTypes = m.supportedInputTypes ?? ["TEXT"];
+    const input = supportedTypes.includes("IMAGE") ? ["text", "image"] : ["text"];
+    const effortEnum = m.additionalModelRequestFieldsSchema?.properties?.output_config?.properties?.effort?.enum;
+    const supportedEfforts = Array.isArray(effortEnum) && effortEnum.length > 0 ? effortEnum : undefined;
+    const supportsThinkingConfig = !!m.additionalModelRequestFieldsSchema?.properties?.thinking;
+    return {
+      id: dashId,
+      name: m.modelName,
+      reasoning: isReasoningModel(m.modelId),
+      input,
+      contextWindow: m.tokenLimits?.maxInputTokens ?? 200000,
+      maxTokens: m.tokenLimits?.maxOutputTokens ?? 8192,
+      firstTokenTimeout: firstTokenTimeout(m.modelId),
+      ...supportedEfforts ? { supportedEfforts } : {},
+      ...supportsThinkingConfig ? { supportsThinkingConfig } : {}
+    };
+  });
+}
+var cachedDynamicModels = null;
+function getCachedDynamicModels() {
+  return cachedDynamicModels;
+}
+function setCachedDynamicModels(models) {
+  cachedDynamicModels = models;
+}
+
+// src/oauth.ts
+var BUILDER_ID_START_URL = "https://view.awsapps.com/start";
+var BUILDER_ID_REGION = "us-east-1";
+var SSO_SCOPES = [
+  "codewhisperer:completions",
+  "codewhisperer:analysis",
+  "codewhisperer:conversations",
+  "codewhisperer:transformations",
+  "codewhisperer:taskassist"
+];
+var IDC_PROBE_REGIONS = [
+  "us-east-1",
+  "eu-west-1",
+  "eu-central-1",
+  "us-east-2",
+  "eu-west-2",
+  "eu-west-3",
+  "eu-north-1",
+  "ap-southeast-1",
+  "ap-northeast-1",
+  "us-west-2"
+];
+var EXPIRES_BUFFER_MS = 5 * 60 * 1000;
+function abortableDelay2(ms, signal) {
+  if (signal?.aborted)
+    return Promise.reject(signal.reason ?? new Error("Login cancelled"));
+  return new Promise((resolve2, reject) => {
+    const timer = setTimeout(resolve2, ms);
+    signal?.addEventListener("abort", () => {
+      clearTimeout(timer);
+      reject(signal.reason ?? new Error("Login cancelled"));
+    }, { once: true });
+  });
+}
+async function tryRegisterAndAuthorize(startUrl, region) {
+  const oidcEndpoint = `https://oidc.${region}.amazonaws.com`;
+  const regResp = await fetch(`${oidcEndpoint}/client/register`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json", "User-Agent": "pi-kiro" },
+    body: JSON.stringify({
+      clientName: "pi-kiro",
+      clientType: "public",
+      scopes: SSO_SCOPES,
+      grantTypes: ["urn:ietf:params:oauth:grant-type:device_code", "refresh_token"]
+    })
+  });
+  if (!regResp.ok)
+    return null;
+  const { clientId, clientSecret } = await regResp.json();
+  const devResp = await fetch(`${oidcEndpoint}/device_authorization`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json", "User-Agent": "pi-kiro" },
+    body: JSON.stringify({ clientId, clientSecret, startUrl })
+  });
+  if (!devResp.ok)
+    return null;
+  return {
+    clientId,
+    clientSecret,
+    oidcEndpoint,
+    devAuth: await devResp.json()
+  };
+}
+async function pollForToken(oidcEndpoint, clientId, clientSecret, devAuth, signal) {
+  const deadline = Date.now() + (devAuth.expiresIn || 600) * 1000;
+  const baseInterval = (devAuth.interval || 5) * 1000;
+  let interval = baseInterval;
+  while (Date.now() < deadline) {
+    if (signal?.aborted)
+      throw new Error("Login cancelled");
+    await abortableDelay2(interval, signal);
+    let resp;
+    try {
+      resp = await fetch(`${oidcEndpoint}/token`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json", "User-Agent": "pi-kiro" },
+        body: JSON.stringify({
+          clientId,
+          clientSecret,
+          deviceCode: devAuth.deviceCode,
+          grantType: "urn:ietf:params:oauth:grant-type:device_code"
+        })
+      });
+    } catch {
+      continue;
+    }
+    if (resp.status >= 500)
+      continue;
+    let data;
+    try {
+      data = await resp.json();
+    } catch {
+      if (!resp.ok) {
+        throw new Error(`Authorization failed: HTTP ${resp.status}`);
+      }
+      continue;
+    }
+    if (!data.error && data.accessToken && data.refreshToken)
+      return data;
+    if (data.error === "authorization_pending")
+      continue;
+    if (data.error === "slow_down") {
+      interval += baseInterval;
+      continue;
+    }
+    if (data.error)
+      throw new Error(`Authorization failed: ${data.error}`);
+  }
+  throw new Error("Authorization timed out");
+}
+async function loginKiro(callbacks) {
+  const method = await callbacks.onSelect({
+    message: "Select login method:",
+    options: [
+      { id: "builder-id", label: "AWS Builder ID (personal account)" },
+      { id: "idc", label: "IAM Identity Center (enterprise SSO)" },
+      { id: "sync", label: "Import from Kiro IDE (auto-sync local DB)" },
+      { id: "desktop", label: "Desktop refresh token (manual)" }
+    ]
+  });
+  if (!method)
+    throw new Error("Login cancelled");
+  if (method === "sync") {
+    return loginCliSync(callbacks);
+  }
+  if (method === "desktop") {
+    return loginDesktopManual(callbacks);
+  }
+  if (method === "builder-id") {
+    return runDeviceCodeFlow(callbacks, BUILDER_ID_START_URL, [BUILDER_ID_REGION], "builder-id");
+  }
+  const startUrl = (await callbacks.onPrompt({
+    message: "Paste your IAM Identity Center start URL:",
+    placeholder: "https://mycompany.awsapps.com/start",
+    allowEmpty: false
+  }))?.trim();
+  if (!startUrl || !startUrl.startsWith("http")) {
+    throw new Error(`Invalid start URL "${startUrl ?? ""}" — expected https://…`);
+  }
+  const regionRaw = await callbacks.onPrompt({
+    message: `Identity Center region, or blank to auto-detect (${IDC_PROBE_REGIONS.join(", ")})`,
+    placeholder: "us-east-1",
+    allowEmpty: true
+  });
+  const region = (regionRaw ?? "").trim();
+  const regions = region ? [region] : IDC_PROBE_REGIONS;
+  callbacks.onProgress?.(region ? `Connecting to ${region}…` : "Detecting your Identity Center region…");
+  return runDeviceCodeFlow(callbacks, startUrl, regions, "idc");
+}
+async function loginCliSync(callbacks) {
+  callbacks.onProgress?.("Scanning for Kiro IDE credentials (~/.kiro/db)…");
+  const { importFromKiroCli: importFromKiroCli2 } = await Promise.resolve().then(() => (init_kiro_cli_sync(), exports_kiro_cli_sync));
+  const imported = await importFromKiroCli2();
+  if (!imported || !imported.accessToken && !imported.refreshToken) {
+    throw new Error(`No Kiro IDE credentials found.
+Make sure Kiro IDE is installed and you're logged in, then try again.
+Alternatively, use 'desktop' to paste a refresh token manually.`);
+  }
+  log.info("Successfully imported credentials from Kiro IDE");
+  callbacks.onProgress?.(`Imported from Kiro IDE (${imported.authMethod}, ${imported.region}${imported.email ? `, ${imported.email}` : ""})`);
+  try {
+    const apiRegion = resolveApiRegion(imported.region);
+    const apiModels = await fetchAvailableModels(imported.accessToken, apiRegion);
+    setCachedDynamicModels(buildModelsFromApi(apiModels));
+    log.info(`Fetched and cached ${apiModels.length} models after CLI sync`);
+  } catch (err) {
+    log.warn(`Failed to fetch models after CLI sync: ${err}`);
+  }
+  const refreshPacked = imported.clientId ? `${imported.refreshToken}|${imported.clientId}|${imported.clientSecret ?? ""}|${imported.authMethod}` : `${imported.refreshToken}|||desktop`;
+  return {
+    refresh: refreshPacked,
+    access: imported.accessToken,
+    expires: Date.now() + 3600000 - EXPIRES_BUFFER_MS,
+    clientId: imported.clientId ?? "",
+    clientSecret: imported.clientSecret ?? "",
+    region: imported.region,
+    authMethod: imported.authMethod
+  };
+}
+async function loginDesktopManual(callbacks) {
+  const refreshRaw = await callbacks.onPrompt({
+    message: `Paste your Kiro desktop refresh token
+` + "(find it in ~/.kiro/db/kiro.db → auth_kv table):",
+    placeholder: "refresh-token",
+    allowEmpty: true
+  });
+  const refreshToken = (refreshRaw ?? "").trim();
+  if (!refreshToken) {
+    throw new Error("Login cancelled — no refresh token provided");
+  }
+  const regionRaw = await callbacks.onPrompt({
+    message: "Kiro region:",
+    placeholder: "us-east-1",
+    allowEmpty: true
+  });
+  const region = (regionRaw ?? "").trim() || "us-east-1";
+  const refreshCreds = {
+    refresh: `${refreshToken}|||desktop`,
+    access: "",
+    expires: 0,
+    clientId: "",
+    clientSecret: "",
+    region,
+    authMethod: "desktop"
+  };
+  callbacks.onProgress?.("Exchanging refresh token…");
+  return refreshKiroToken(refreshCreds);
+}
+async function runDeviceCodeFlow(callbacks, startUrl, regions, authMethod) {
+  let result = null;
+  let detectedRegion = "";
+  for (const region of regions) {
+    result = await tryRegisterAndAuthorize(startUrl, region);
+    if (result) {
+      detectedRegion = region;
+      if (regions.length > 1)
+        callbacks.onProgress?.(`Region: ${region}`);
+      break;
+    }
+  }
+  if (!result || !detectedRegion) {
+    throw new Error(`Could not authorize ${startUrl} in ${regions.join(", ")}. Check your start URL${regions.length === 1 ? " and region" : ""} and try again.`);
+  }
+  callbacks.onAuth({
+    url: result.devAuth.verificationUriComplete,
+    instructions: `Code: ${result.devAuth.userCode}
+Complete authorization within 10 minutes.`
+  });
+  callbacks.onProgress?.("Waiting for browser authorization (up to 10 minutes)…");
+  const tok = await pollForToken(result.oidcEndpoint, result.clientId, result.clientSecret, result.devAuth, callbacks.signal);
+  if (!tok.accessToken || !tok.refreshToken) {
+    throw new Error("Authorization completed but no tokens returned");
+  }
+  try {
+    const apiRegion = resolveApiRegion(detectedRegion);
+    const apiModels = await fetchAvailableModels(tok.accessToken, apiRegion);
+    setCachedDynamicModels(buildModelsFromApi(apiModels));
+    log.info(`Fetched and cached ${apiModels.length} models after login`);
+  } catch (err) {
+    log.warn(`Failed to fetch models after login, falling back: ${err}`);
+  }
+  return {
+    refresh: `${tok.refreshToken}|${result.clientId}|${result.clientSecret}|${authMethod}`,
+    access: tok.accessToken,
+    expires: Date.now() + (tok.expiresIn ?? 3600) * 1000 - EXPIRES_BUFFER_MS,
+    clientId: result.clientId,
+    clientSecret: result.clientSecret,
+    region: detectedRegion,
+    authMethod
+  };
+}
+async function syncBackToKiroCli(result) {
+  try {
+    const { saveKiroCliCredentials: saveKiroCliCredentials2 } = await Promise.resolve().then(() => (init_kiro_cli_sync(), exports_kiro_cli_sync));
+    const synced = await saveKiroCliCredentials2({
+      accessToken: result.access,
+      refreshToken: result.refresh.split("|")[0] ?? "",
+      region: result.region,
+      authMethod: result.authMethod === "builder-id" ? "idc" : result.authMethod
+    });
+    if (synced)
+      log.info("Synced refreshed credentials back to Kiro CLI DB");
+  } catch (err) {
+    log.debug(`Credential sync-back skipped: ${err}`);
+  }
+}
+function kiroCredsFromCliImport(imported) {
+  const authMethod = imported.authMethod === "idc" ? "idc" : "desktop";
+  const refreshPacked = imported.clientId ? `${imported.refreshToken}|${imported.clientId}|${imported.clientSecret ?? ""}|${authMethod}` : `${imported.refreshToken}|||desktop`;
+  return {
+    refresh: refreshPacked,
+    access: imported.accessToken,
+    expires: Date.now() + 3600000 - EXPIRES_BUFFER_MS,
+    clientId: imported.clientId ?? "",
+    clientSecret: imported.clientSecret ?? "",
+    region: imported.region,
+    authMethod
+  };
+}
+async function refreshTokenInner(credentials) {
+  const parts = credentials.refresh.split("|");
+  const refreshToken = parts[0] ?? "";
+  const clientId = parts[1] ?? credentials.clientId ?? "";
+  const clientSecret = parts[2] ?? credentials.clientSecret ?? "";
+  const region = credentials.region;
+  const authMethod = credentials.authMethod;
+  if (!refreshToken || !region) {
+    throw new Error("Refresh token is missing region — re-login required");
+  }
+  if (authMethod !== "desktop" && (!clientId || !clientSecret)) {
+    throw new Error("Refresh token is missing clientId/clientSecret — re-login required");
+  }
+  if (authMethod === "desktop") {
+    const desktopEndpoint = `https://prod.${region}.auth.desktop.kiro.dev/refreshToken`;
+    const resp2 = await fetch(desktopEndpoint, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", "User-Agent": "pi-kiro" },
+      body: JSON.stringify({ refreshToken })
+    });
+    if (!resp2.ok) {
+      const body = await resp2.text().catch(() => "");
+      throw new Error(`Desktop token refresh failed: ${resp2.status} ${body}`);
+    }
+    const data2 = await resp2.json();
+    try {
+      const apiRegion = resolveApiRegion(region);
+      const apiModels = await fetchAvailableModels(data2.accessToken, apiRegion);
+      setCachedDynamicModels(buildModelsFromApi(apiModels));
+      log.info(`Fetched and cached ${apiModels.length} models after desktop token refresh`);
+    } catch (err) {
+      log.warn(`Failed to fetch models after desktop token refresh: ${err}`);
+    }
+    return {
+      refresh: `${data2.refreshToken}|||desktop`,
+      access: data2.accessToken,
+      expires: Date.now() + (data2.expiresIn ?? 3600) * 1000 - EXPIRES_BUFFER_MS,
+      clientId: "",
+      clientSecret: "",
+      region,
+      authMethod: "desktop"
+    };
+  }
+  const endpoint = `https://oidc.${region}.amazonaws.com/token`;
+  const resp = await fetch(endpoint, {
+    method: "POST",
+    headers: { "Content-Type": "application/json", "User-Agent": "pi-kiro" },
+    body: JSON.stringify({ clientId, clientSecret, refreshToken, grantType: "refresh_token" })
+  });
+  if (!resp.ok) {
+    const body = await resp.text().catch(() => "");
+    throw new Error(`Token refresh failed: ${resp.status} ${body}`);
+  }
+  const data = await resp.json();
+  try {
+    const apiRegion = resolveApiRegion(region);
+    const apiModels = await fetchAvailableModels(data.accessToken, apiRegion);
+    setCachedDynamicModels(buildModelsFromApi(apiModels));
+    log.info(`Fetched and cached ${apiModels.length} models after token refresh`);
+  } catch (err) {
+    log.warn(`Failed to fetch models after token refresh, falling back: ${err}`);
+  }
+  return {
+    refresh: `${data.refreshToken}|${clientId}|${clientSecret}|${authMethod}`,
+    access: data.accessToken,
+    expires: Date.now() + (data.expiresIn ?? 3600) * 1000 - EXPIRES_BUFFER_MS,
+    clientId,
+    clientSecret,
+    region,
+    authMethod
+  };
+}
+async function refreshKiroToken(credentials) {
+  const inputMethod = credentials.authMethod;
+  const authMethod = inputMethod === "builder-id" || inputMethod === "idc" || inputMethod === "desktop" ? inputMethod : "idc";
+  if (inputMethod !== undefined && inputMethod !== "builder-id" && inputMethod !== "idc" && inputMethod !== "desktop") {
+    log.warn(`refreshKiroToken: unrecognized authMethod "${String(inputMethod)}" — defaulting to "idc"`);
+  }
+  const baseCreds = {
+    ...credentials,
+    clientId: credentials.clientId ?? credentials.refresh.split("|")[1] ?? "",
+    clientSecret: credentials.clientSecret ?? credentials.refresh.split("|")[2] ?? "",
+    region: credentials.region,
+    authMethod
+  };
+  const errors = [];
+  try {
+    log.debug("refresh.cascade: layer 1 — normal refresh");
+    const result = await refreshTokenInner(baseCreds);
+    syncBackToKiroCli(result);
+    return result;
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    errors.push(`L1(normal): ${msg}`);
+    log.warn(`refresh.cascade: layer 1 failed — ${msg}`);
+  }
+  let freshImport = null;
+  try {
+    log.debug("refresh.cascade: layer 2 — fresh kiro-cli import");
+    const { importFromKiroCli: importFromKiroCli2 } = await Promise.resolve().then(() => (init_kiro_cli_sync(), exports_kiro_cli_sync));
+    freshImport = await importFromKiroCli2();
+    if (freshImport?.accessToken) {
+      const result = kiroCredsFromCliImport(freshImport);
+      log.info("refresh.cascade: layer 2 succeeded — using fresh kiro-cli credentials");
+      return result;
+    }
+    errors.push("L2(fresh-import): no valid credentials found");
+    log.debug("refresh.cascade: layer 2 — no fresh credentials");
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    errors.push(`L2(fresh-import): ${msg}`);
+    log.warn(`refresh.cascade: layer 2 failed — ${msg}`);
+  }
+  if (freshImport?.refreshToken) {
+    try {
+      log.debug("refresh.cascade: layer 3 — refresh fresh kiro-cli creds");
+      const freshCreds = kiroCredsFromCliImport(freshImport);
+      const result = await refreshTokenInner(freshCreds);
+      syncBackToKiroCli(result);
+      log.info("refresh.cascade: layer 3 succeeded — refreshed fresh kiro-cli credentials");
+      return result;
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      errors.push(`L3(refresh-fresh): ${msg}`);
+      log.warn(`refresh.cascade: layer 3 failed — ${msg}`);
+    }
+  }
+  let expiredImport = null;
+  try {
+    log.debug("refresh.cascade: layer 4 — expired kiro-cli import");
+    const { getKiroCliCredentialsAllowExpired: getKiroCliCredentialsAllowExpired2 } = await Promise.resolve().then(() => (init_kiro_cli_sync(), exports_kiro_cli_sync));
+    expiredImport = await getKiroCliCredentialsAllowExpired2();
+    if (expiredImport?.accessToken && expiredImport !== freshImport) {
+      const result = kiroCredsFromCliImport(expiredImport);
+      log.info("refresh.cascade: layer 4 succeeded — using expired kiro-cli credentials");
+      return result;
+    }
+    errors.push("L4(expired-import): no different expired credentials");
+    log.debug("refresh.cascade: layer 4 — no additional expired credentials");
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    errors.push(`L4(expired-import): ${msg}`);
+    log.warn(`refresh.cascade: layer 4 failed — ${msg}`);
+  }
+  if (expiredImport?.refreshToken) {
+    try {
+      log.debug("refresh.cascade: layer 5 — refresh expired kiro-cli creds");
+      const expiredCreds = kiroCredsFromCliImport(expiredImport);
+      const result = await refreshTokenInner(expiredCreds);
+      syncBackToKiroCli(result);
+      log.info("refresh.cascade: layer 5 succeeded — refreshed expired kiro-cli credentials");
+      return result;
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      errors.push(`L5(refresh-expired): ${msg}`);
+      log.warn(`refresh.cascade: layer 5 failed — ${msg}`);
+    }
+  }
+  throw new Error(`Kiro token refresh failed — all 5 cascade layers exhausted. ` + `Re-login required.
+${errors.join(`
+`)}`);
+}
+
+// src/core.ts
+init_kiro_cli_sync();
+export {
+  streamKiro,
+  saveKiroCliCredentials,
+  resolveRuntimeUrl,
+  resolveKiroModel,
+  resolveApiRegion,
+  refreshKiroToken,
+  loginKiro,
+  kiroModels,
+  isPermanentError,
+  importFromKiroCli,
+  getKiroCliCredentialsAllowExpired,
+  filterModelsByRegion,
+  collapseAgenticLoops,
+  MAX_KIRO_IMAGE_BYTES,
+  MAX_KIRO_IMAGES,
+  KIRO_MODEL_IDS,
+  BUILDER_ID_START_URL,
+  BUILDER_ID_REGION
+};