@javargasm/opencode-kiro-auth 0.1.0

package/dist/index.js

@@ -0,0 +1,3647 @@
+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(`[opencode-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 = `[opencode-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, {
+  importFromKiroCli: () => importFromKiroCli
+});
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { existsSync, readFileSync } from "node:fs";
+function getKiroDbPath() {
+  const home = homedir();
+  if (process.platform === "darwin") {
+    return join(home, "Library", "Application Support", "kiro-cli", "data.sqlite3");
+  }
+  if (process.platform === "win32") {
+    return join(process.env.APPDATA || join(home, "AppData", "Roaming"), "kiro-cli", "data.sqlite3");
+  }
+  const xdgData = process.env.XDG_DATA_HOME;
+  if (xdgData && xdgData.length > 0) {
+    return join(xdgData, "kiro-cli", "data.sqlite3");
+  }
+  return join(home, ".local", "share", "kiro-cli", "data.sqlite3");
+}
+function getKiroSsoCachePath() {
+  const home = homedir();
+  if (process.platform === "win32") {
+    return join(process.env.USERPROFILE || home, ".aws", "sso", "cache", "kiro-auth-token.json");
+  }
+  return join(home, ".aws", "sso", "cache", "kiro-auth-token.json");
+}
+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 {};
+  const id = obj.clientId ?? obj.client_id;
+  const secret = obj.clientSecret ?? obj.client_secret;
+  if (typeof id === "string" && typeof secret === "string") {
+    return { clientId: id, clientSecret: secret };
+  }
+  for (const key of Object.keys(obj)) {
+    const result = findClientCreds(obj[key]);
+    if (result.clientId)
+      return result;
+  }
+  return {};
+}
+function isIdcTokenKey(key) {
+  return key.includes("odic") || key.includes("oidc") || key.includes("idc");
+}
+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 importFromKiroDb() {
+  const dbPath = getKiroDbPath();
+  if (!existsSync(dbPath)) {
+    log.debug(`Kiro CLI DB not found at ${dbPath}`);
+    return null;
+  }
+  try {
+    const { Database } = await import("bun:sqlite");
+    const db = new Database(dbPath, { readonly: true });
+    try {
+      db.exec("PRAGMA busy_timeout = 5000");
+    } catch {}
+    let rows;
+    try {
+      rows = db.prepare("SELECT key, value FROM auth_kv").all();
+    } catch {
+      log.debug("Failed to read auth_kv table from Kiro DB");
+      try {
+        db.close();
+      } catch {}
+      return null;
+    }
+    let activeProfileArn;
+    try {
+      const stateRow = db.prepare("SELECT value FROM state WHERE key = ?").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 {}
+    try {
+      db.close();
+    } 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) : {};
+    const tokenRows = rows.filter((r) => r.key.includes(":token")).sort((a, b) => (isIdcTokenKey(a.key) ? 0 : 1) - (isIdcTokenKey(b.key) ? 0 : 1));
+    for (const row of tokenRows) {
+      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 = isIdcTokenKey(row.key);
+      const authMethod = isIdc ? "idc" : "desktop";
+      const oidcRegion = data.region || "us-east-1";
+      let profileArn = data.profile_arn || data.profileArn;
+      if (!profileArn)
+        profileArn = activeProfileArn;
+      const serviceRegion = extractRegionFromArn(profileArn) || oidcRegion;
+      const result = {
+        accessToken: accessToken || "",
+        refreshToken: refreshToken || "",
+        region: serviceRegion,
+        authMethod,
+        email: data.email || data.emailAddress,
+        profileArn
+      };
+      if (isIdc && regCreds.clientId) {
+        result.clientId = regCreds.clientId;
+        result.clientSecret = regCreds.clientSecret;
+      }
+      log.info(`Imported Kiro CLI credentials (method=${authMethod}, region=${serviceRegion}${result.email ? `, email=${result.email}` : ""})`);
+      return result;
+    }
+    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 importFromKiroSsoCache() {
+  const cachePath = getKiroSsoCachePath();
+  if (!existsSync(cachePath)) {
+    log.debug(`Kiro SSO cache not found at ${cachePath}`);
+    return null;
+  }
+  let raw;
+  try {
+    raw = readFileSync(cachePath, "utf8");
+  } catch (err) {
+    log.warn(`Failed to read Kiro SSO cache at ${cachePath}: ${err}`);
+    return null;
+  }
+  const token = safeJsonParse(raw);
+  if (!token || typeof token !== "object")
+    return null;
+  const accessToken = typeof token.accessToken === "string" ? token.accessToken : "";
+  const refreshToken = typeof token.refreshToken === "string" ? token.refreshToken : "";
+  if (!accessToken && !refreshToken)
+    return null;
+  const region = typeof token.region === "string" && token.region.length > 0 ? token.region : "us-east-1";
+  const authMethod = "desktop";
+  log.info(`Imported Kiro SSO cache credentials (region=${region})`);
+  return { accessToken, refreshToken, region, authMethod };
+}
+async function importFromKiroCli() {
+  const dbResult = await importFromKiroDb();
+  if (dbResult)
+    return dbResult;
+  return importFromKiroSsoCache();
+}
+var init_kiro_cli_sync = __esm(() => {
+  init_debug();
+});
+
+// src/types.ts
+class EventStream {
+  queue = [];
+  waiting = [];
+  done = false;
+  finalResultPromise;
+  resolveFinalResult;
+  isComplete;
+  extractResult;
+  constructor(isComplete, extractResult) {
+    this.isComplete = isComplete;
+    this.extractResult = extractResult;
+    this.finalResultPromise = new Promise((resolve) => {
+      this.resolveFinalResult = resolve;
+    });
+  }
+  push(event) {
+    if (this.done)
+      return;
+    if (this.isComplete(event)) {
+      this.done = true;
+      this.resolveFinalResult(this.extractResult(event));
+    }
+    const waiter = this.waiting.shift();
+    if (waiter) {
+      waiter({ value: event, done: false });
+    } else {
+      this.queue.push(event);
+    }
+  }
+  end(result) {
+    this.done = true;
+    if (result !== undefined) {
+      this.resolveFinalResult(result);
+    }
+    while (this.waiting.length > 0) {
+      const waiter = this.waiting.shift();
+      waiter({ value: undefined, done: true });
+    }
+  }
+  async* [Symbol.asyncIterator]() {
+    while (true) {
+      if (this.queue.length > 0) {
+        yield this.queue.shift();
+      } else if (this.done) {
+        return;
+      } else {
+        const result = await new Promise((resolve) => this.waiting.push(resolve));
+        if (result.done)
+          return;
+        yield result.value;
+      }
+    }
+  }
+  result() {
+    return this.finalResultPromise;
+  }
+}
+
+class AssistantMessageEventStream extends EventStream {
+  constructor() {
+    super((event) => event.type === "done" || event.type === "error", (event) => {
+      if (event.type === "done")
+        return event.message;
+      if (event.type === "error")
+        return event.error;
+      throw new Error("Unexpected event type for final result");
+    });
+  }
+}
+function calculateCost(model, usage) {
+  usage.cost.input = model.cost.input / 1e6 * usage.input;
+  usage.cost.output = model.cost.output / 1e6 * usage.output;
+  usage.cost.cacheRead = model.cost.cacheRead / 1e6 * usage.cacheRead;
+  usage.cost.cacheWrite = model.cost.cacheWrite / 1e6 * usage.cacheWrite;
+  usage.cost.total = usage.cost.input + usage.cost.output + usage.cost.cacheRead + usage.cost.cacheWrite;
+  return usage.cost;
+}
+
+// src/stream.ts
+init_debug();
+
+// 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 parseKiroEventMulti(parsed) {
+  const events = [];
+  if (parsed.content !== undefined) {
+    events.push({ type: "content", data: parsed.content });
+  }
+  if (parsed.reasoningContent !== undefined || parsed.reasoningText !== undefined || parsed.signature !== undefined || parsed.text !== undefined && !parsed.content && !parsed.name && !parsed.message) {
+    let text = "";
+    let signature;
+    if (parsed.reasoningContent !== undefined) {
+      text = parsed.reasoningContent;
+    } else if (parsed.reasoningText) {
+      const rt = parsed.reasoningText;
+      text = (rt.text ?? rt.Text) || "";
+      signature = rt.signature ?? rt.Signature;
+    } else {
+      text = parsed.text || "";
+      signature = parsed.signature;
+    }
+    events.push({
+      type: "reasoning",
+      data: { text, signature }
+    });
+  }
+  const toolUseBlock = parsed.toolUse;
+  if (toolUseBlock && toolUseBlock.name && toolUseBlock.toolUseId) {
+    const rawInput = toolUseBlock.input;
+    const input = typeof rawInput === "string" ? rawInput : rawInput && typeof rawInput === "object" && Object.keys(rawInput).length > 0 ? JSON.stringify(rawInput) : "";
+    events.push({
+      type: "toolUse",
+      data: {
+        name: toolUseBlock.name,
+        toolUseId: toolUseBlock.toolUseId,
+        input,
+        stop: toolUseBlock.stop
+      }
+    });
+  } else 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) : "";
+    events.push({
+      type: "toolUse",
+      data: {
+        name: parsed.name,
+        toolUseId: parsed.toolUseId,
+        input,
+        stop: parsed.stop
+      }
+    });
+  }
+  if (parsed.input !== undefined && !parsed.name && !toolUseBlock) {
+    events.push({
+      type: "toolUseInput",
+      data: {
+        input: typeof parsed.input === "string" ? parsed.input : JSON.stringify(parsed.input)
+      }
+    });
+  }
+  if (parsed.stop !== undefined && parsed.contextUsagePercentage === undefined && !toolUseBlock) {
+    events.push({ type: "toolUseStop", data: { stop: parsed.stop } });
+  }
+  if (parsed.followupPrompt !== undefined) {
+    events.push({ 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;
+    events.push({
+      type: "error",
+      data: {
+        error: typeof err === "string" ? err : JSON.stringify(err),
+        message
+      }
+    });
+  }
+  if (parsed.usage !== undefined) {
+    const u = parsed.usage;
+    events.push({
+      type: "usage",
+      data: {
+        inputTokens: u.inputTokens,
+        outputTokens: u.outputTokens
+      }
+    });
+  }
+  const metadata = parsed.metadata;
+  if (metadata) {
+    if (metadata.contextUsagePercentage !== undefined) {
+      events.push({
+        type: "contextUsage",
+        data: { contextUsagePercentage: metadata.contextUsagePercentage }
+      });
+    }
+    if (metadata.metering && metadata.metering.unit === "credit" && metadata.metering.usage !== undefined) {
+      events.push({
+        type: "metering",
+        data: { usage: metadata.metering.usage }
+      });
+    }
+  }
+  if (parsed.contextUsagePercentage !== undefined && !metadata) {
+    events.push({
+      type: "contextUsage",
+      data: { contextUsagePercentage: parsed.contextUsagePercentage }
+    });
+  }
+  if (parsed.unit === "credit" && parsed.usage !== undefined && typeof parsed.usage === "number") {
+    events.push({ type: "metering", data: { usage: parsed.usage } });
+  }
+  return events;
+}
+var EVENT_PATTERNS = [
+  '{"content":',
+  '{"reasoningText":',
+  '{"reasoningContent":',
+  '{"metadata":',
+  '{"metering":',
+  '{"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 newEvents = parseKiroEventMulti(parsed);
+      if (newEvents.length > 0) {
+        events.push(...newEvents);
+      } 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/models.ts
+var KIRO_MODEL_IDS = new Set([
+  "claude-fable-5",
+  "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 BASE_URL = "https://runtime.us-east-1.kiro.dev";
+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-fable-5",
+    name: "Claude Fable 5",
+    reasoning: true,
+    input: MULTIMODAL,
+    contextWindow: 1e6,
+    maxTokens: 128000,
+    firstTokenTimeout: 180000,
+    supportedEfforts: ["low", "medium", "high", "xhigh", "max"],
+    supportsThinkingConfig: true
+  },
+  {
+    ...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"],
+    supportsThinkingConfig: true
+  },
+  {
+    ...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"],
+    supportsThinkingConfig: true
+  },
+  {
+    ...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"],
+    supportsThinkingConfig: true
+  },
+  {
+    ...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"],
+    supportsThinkingConfig: true
+  },
+  {
+    ...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"],
+    supportsThinkingConfig: true
+  },
+  {
+    ...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"],
+    supportsThinkingConfig: true
+  },
+  {
+    ...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, fallbackProfileArn) {
+  const runtimeUrl = `https://runtime.${apiRegion}.kiro.dev/`;
+  let profileArn = await resolveProfileArn(accessToken, runtimeUrl);
+  if (!profileArn && fallbackProfileArn) {
+    profileArn = fallbackProfileArn;
+  }
+  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": "opencode-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-fable",
+  "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-fable") || 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 {
+      ...KIRO_DEFAULTS,
+      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/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>" },
+  { open: "<internal_thinking>", close: "</internal_thinking>" }
+];
+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/oauth.ts
+init_debug();
+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 abortableDelay(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`;
+  try {
+    const regResp = await fetch(`${oidcEndpoint}/client/register`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", "User-Agent": "opencode-kiro" },
+      body: JSON.stringify({
+        clientName: "opencode-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": "opencode-kiro" },
+      body: JSON.stringify({ clientId, clientSecret, startUrl })
+    });
+    if (!devResp.ok)
+      return null;
+    return {
+      clientId,
+      clientSecret,
+      oidcEndpoint,
+      devAuth: await devResp.json()
+    };
+  } catch (e) {
+    log.error(`tryRegisterAndAuthorize failed in region ${region}: ${e}`);
+    return null;
+  }
+}
+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 abortableDelay(interval, signal);
+    let resp;
+    try {
+      resp = await fetch(`${oidcEndpoint}/token`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json", "User-Agent": "opencode-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 refreshKiroToken(refreshTokenPacked, region, authMethod) {
+  const parts = refreshTokenPacked.split("|");
+  const refreshToken = parts[0] ?? "";
+  const clientId = parts[1] ?? "";
+  const clientSecret = parts[2] ?? "";
+  if (!refreshToken || !region) {
+    throw new Error("Refresh token or region is missing — 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": "opencode-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();
+    return {
+      access: data2.accessToken,
+      refresh: `${data2.refreshToken}|||desktop`,
+      expires: Date.now() + (data2.expiresIn ?? 3600) * 1000 - EXPIRES_BUFFER_MS
+    };
+  }
+  if (!clientId || !clientSecret) {
+    throw new Error("OIDC clientId or clientSecret missing — re-login required");
+  }
+  const endpoint = `https://oidc.${region}.amazonaws.com/token`;
+  const resp = await fetch(endpoint, {
+    method: "POST",
+    headers: { "Content-Type": "application/json", "User-Agent": "opencode-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();
+  return {
+    access: data.accessToken,
+    refresh: `${data.refreshToken}|${clientId}|${clientSecret}|${authMethod}`,
+    expires: Date.now() + (data.expiresIn ?? 3600) * 1000 - EXPIRES_BUFFER_MS
+  };
+}
+
+// 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.";
+var TOOL_PURPOSE_FIELD = {
+  type: "string",
+  description: "A brief explanation why you are making this tool use."
+};
+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") {
+    if (typeof msg.content === "string")
+      return msg.content;
+    if (!Array.isArray(msg.content))
+      return "";
+    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}`;
+}
+var ALLOWED_SCHEMA_KEYS = new Set([
+  "type",
+  "properties",
+  "required",
+  "description",
+  "enum",
+  "items",
+  "default",
+  "oneOf",
+  "anyOf",
+  "allOf",
+  "minimum",
+  "maximum",
+  "minLength",
+  "maxLength",
+  "minItems",
+  "maxItems",
+  "pattern",
+  "const",
+  "title",
+  "additionalProperties"
+]);
+function sanitizeSchema(obj) {
+  if (obj === null || obj === undefined)
+    return obj;
+  if (Array.isArray(obj))
+    return obj.map(sanitizeSchema);
+  if (typeof obj !== "object")
+    return obj;
+  const result = {};
+  for (const [key, value] of Object.entries(obj)) {
+    if (!ALLOWED_SCHEMA_KEYS.has(key) && key !== "__tool_use_purpose")
+      continue;
+    if (key === "required" && Array.isArray(value) && value.length === 0)
+      continue;
+    if ((key === "minimum" || key === "maximum") && typeof value === "number") {
+      if (Math.abs(value) > 1e9)
+        continue;
+    }
+    result[key] = sanitizeSchema(value);
+  }
+  return result;
+}
+function convertToolsToKiro(tools) {
+  return tools.map((tool) => {
+    const schema = tool.parameters;
+    const sanitized = sanitizeSchema(schema);
+    const props = sanitized.properties ?? {};
+    return {
+      toolSpecification: {
+        name: tool.name,
+        description: tool.description || `Use ${tool.name}`,
+        inputSchema: {
+          json: {
+            ...sanitized,
+            properties: {
+              ...props,
+              __tool_use_purpose: TOOL_PURPOSE_FIELD
+            }
+          }
+        }
+      }
+    };
+  });
+}
+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"];
+var NON_RETRYABLE_BODY_PATTERNS = ["MONTHLY_REQUEST_COUNT", "Improperly formed"];
+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
+  });
+}
+var profileArnCache = new Map;
+var profileArnSkipResolution = false;
+function seedProfileArn(endpoint, arn) {
+  profileArnCache.set(endpoint, arn);
+}
+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.debug(`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.debug("profileArn resolution returned no profile ARN");
+      return;
+    }
+    profileArnCache.set(endpoint, arn);
+    return arn;
+  } catch (error) {
+    log.debug(`profileArn resolution threw: ${error instanceof Error ? error.message : String(error)}`);
+    return;
+  }
+}
+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.info(`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 = new AssistantMessageEventStream;
+  (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 reasoningLevel = String(options?.reasoning ?? "");
+        const budget = reasoningLevel === "xhigh" || reasoningLevel === "max" ? 50000 : reasoningLevel === "high" ? 30000 : reasoningLevel === "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 = "";
+          let armReasoningText = "";
+          let armReasoningSignature = "";
+          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") {
+                const tb = b;
+                armReasoningText += tb.thinking;
+                if (tb.thinkingSignature)
+                  armReasoningSignature = tb.thinkingSignature;
+              } else if (b.type === "toolCall") {
+                const tc = b;
+                armToolUses.push({
+                  name: tc.name,
+                  toolUseId: toKiroToolUseId(tc.id),
+                  input: parseToolArgs(tc.arguments)
+                });
+              }
+            }
+          }
+          const hasReasoning = armReasoningText.length > 0;
+          if (armContent || armToolUses.length > 0 || hasReasoning) {
+            const last = history[history.length - 1];
+            const reasoningContent = hasReasoning ? { reasoningText: { text: armReasoningText, signature: armReasoningSignature } } : undefined;
+            if (last && !last.userInputMessage && last.assistantResponseMessage) {
+              last.assistantResponseMessage.content += `
+
+${armContent}`;
+              if (armToolUses.length > 0) {
+                last.assistantResponseMessage.toolUses = [
+                  ...last.assistantResponseMessage.toolUses ?? [],
+                  ...armToolUses
+                ];
+              }
+              if (reasoningContent) {
+                last.assistantResponseMessage.reasoningContent = reasoningContent;
+              }
+            } else {
+              history.push({
+                assistantResponseMessage: {
+                  content: armContent,
+                  ...armToolUses.length > 0 ? { toolUses: armToolUses } : {},
+                  ...reasoningContent ? { reasoningContent } : {}
+                }
+              });
+            }
+          }
+          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.info(`${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.info(`${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) {
+          uimc.tools = convertToolsToKiro(context.tools);
+        }
+        if (firstMsg?.role === "user") {
+          const imgs = extractImages(firstMsg);
+          if (imgs.length > 0) {
+            const { images: converted, omitted } = convertImagesToKiro(imgs);
+            if (omitted > 0)
+              log.info(`${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 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") {
+          if (supportedEfforts.includes(options.reasoning)) {
+            request.additionalModelRequestFields = request.additionalModelRequestFields || {};
+            request.additionalModelRequestFields.output_config = { effort: options.reasoning };
+            log.debug("effort.set", { effort: options.reasoning, 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);
+          log.debug("request.send", {
+            attempt: retryCount,
+            capacityAttempt: capacityRetryCount,
+            historyLen: history.length,
+            currentContentLen: currentContent.length,
+            hasImages: !!currentImages,
+            toolResultCount: currentToolResults.length,
+            requestJsonChars: requestBody.length
+          });
+          log.debug(`[stream] req=${requestBody.length}c hist=${history.length} content=${currentContent.length}c profileArn=${!!profileArn}`);
+          if (log.isDebug()) {
+            try {
+              __require("fs").writeFileSync("/tmp/kiro-last-request.json", requestBody);
+            } catch {}
+          }
+          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
+          });
+          if (isCapacityError(errText) && capacityRetryCount < CAPACITY_MAX_RETRIES) {
+            capacityRetryCount++;
+            const delayMs = exponentialBackoff(capacityRetryCount - 1, CAPACITY_BASE_DELAY_MS, CAPACITY_MAX_DELAY_MS);
+            log.info(`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.info(`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.info(`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 meteringCredits;
+        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 "metering": {
+                meteringCredits = event.data.usage;
+                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.info(`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 };
+        }
+        if (meteringCredits !== undefined) {
+          if (!output.usage.cost)
+            output.usage.cost = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 };
+          output.usage.cost.total = meteringCredits;
+        }
+        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.info(`empty response — retrying (${retryCount}/${MAX_RETRIES})`);
+            cancelHiddenShim();
+            output.content = [];
+            textBlockIndex = null;
+            await abortableDelay(delayMs, options?.signal);
+            continue;
+          }
+          log.info(`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/server.ts
+init_debug();
+
+// src/dashboard-stats.ts
+var MAX_HISTORY = 100;
+
+class DashboardStats {
+  requests = [];
+  recordRequest(metrics) {
+    this.requests.unshift({ ...metrics, timestamp: Date.now() });
+    if (this.requests.length > MAX_HISTORY) {
+      this.requests.pop();
+    }
+  }
+  getStats() {
+    const totalRequests = this.requests.length;
+    const totalTokens = this.requests.reduce((acc, r) => acc + r.inputTokens + r.outputTokens, 0);
+    const totalCredits = this.requests.reduce((acc, r) => acc + r.credits, 0);
+    return {
+      totalRequests,
+      totalTokens,
+      totalCredits,
+      requests: this.requests
+    };
+  }
+}
+var stats = new DashboardStats;
+
+// src/dashboard-ui.ts
+function getDashboardHtml() {
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>KIRO_GATEWAY // TELEMETRY</title>
+  <style>
+    :root {
+      --bg-color: #000501;
+      --panel-bg: rgba(0, 20, 5, 0.4);
+      --primary: #00ff41;
+      --secondary: #00ffff;
+      --text: #c0c0c0;
+      --border: rgba(0, 255, 65, 0.3);
+      --font-mono: "Fira Code", "JetBrains Mono", "Space Mono", Consolas, monospace;
+    }
+
+    * {
+      box-sizing: border-box;
+      margin: 0;
+      padding: 0;
+    }
+
+    body {
+      background-color: var(--bg-color);
+      color: var(--primary);
+      font-family: var(--font-mono);
+      min-height: 100vh;
+      display: flex;
+      flex-direction: column;
+      padding: 2rem;
+      background-image: 
+        linear-gradient(rgba(0, 255, 65, 0.03) 1px, transparent 1px),
+        linear-gradient(90deg, rgba(0, 255, 65, 0.03) 1px, transparent 1px);
+      background-size: 20px 20px;
+      overflow-x: hidden;
+    }
+
+    /* CRT Scanline Effect */
+    body::after {
+      content: " ";
+      display: block;
+      position: fixed;
+      top: 0;
+      left: 0;
+      bottom: 0;
+      right: 0;
+      background: linear-gradient(rgba(18, 16, 16, 0) 50%, rgba(0, 0, 0, 0.25) 50%), linear-gradient(90deg, rgba(255, 0, 0, 0.06), rgba(0, 255, 0, 0.02), rgba(0, 0, 255, 0.06));
+      z-index: 2;
+      background-size: 100% 2px, 3px 100%;
+      pointer-events: none;
+    }
+
+    header {
+      border-bottom: 2px solid var(--primary);
+      padding-bottom: 1rem;
+      margin-bottom: 2rem;
+      display: flex;
+      justify-content: space-between;
+      align-items: flex-end;
+      text-transform: uppercase;
+      box-shadow: 0 4px 15px -10px var(--primary);
+    }
+
+    h1 {
+      font-size: 2rem;
+      letter-spacing: 2px;
+      text-shadow: 0 0 10px rgba(0, 255, 65, 0.6);
+      margin: 0;
+    }
+
+    .status-badge {
+      font-size: 0.8rem;
+      padding: 0.3rem 0.6rem;
+      border: 1px solid var(--primary);
+      background: rgba(0, 255, 65, 0.1);
+      display: inline-flex;
+      align-items: center;
+      gap: 8px;
+    }
+
+    .pulse {
+      width: 8px;
+      height: 8px;
+      background-color: var(--primary);
+      border-radius: 50%;
+      box-shadow: 0 0 10px var(--primary);
+      animation: blink 1.5s infinite alternate;
+    }
+
+    @keyframes blink {
+      0% { opacity: 0.3; }
+      100% { opacity: 1; box-shadow: 0 0 15px var(--primary); }
+    }
+
+    .metrics-grid {
+      display: grid;
+      grid-template-columns: repeat(auto-fit, minmax(200px, 1fr));
+      gap: 1.5rem;
+      margin-bottom: 3rem;
+    }
+
+    .metric-card {
+      background: var(--panel-bg);
+      border: 1px solid var(--border);
+      padding: 1.5rem;
+      position: relative;
+      overflow: hidden;
+      transition: all 0.2s ease;
+    }
+
+    .metric-card:hover {
+      border-color: var(--primary);
+      box-shadow: inset 0 0 20px rgba(0, 255, 65, 0.1);
+    }
+
+    /* Cyberpunk corner cuts */
+    .metric-card::before {
+      content: '';
+      position: absolute;
+      top: 0;
+      right: 0;
+      border-width: 0 15px 15px 0;
+      border-style: solid;
+      border-color: transparent var(--bg-color) transparent transparent;
+    }
+
+    .metric-label {
+      font-size: 0.8rem;
+      color: var(--secondary);
+      text-transform: uppercase;
+      letter-spacing: 1px;
+      margin-bottom: 0.5rem;
+    }
+
+    .metric-value {
+      font-size: 2.5rem;
+      font-weight: bold;
+      text-shadow: 0 0 10px rgba(0, 255, 65, 0.4);
+    }
+
+    .table-container {
+      background: var(--panel-bg);
+      border: 1px solid var(--border);
+      flex: 1;
+      overflow: auto;
+      position: relative;
+    }
+
+    table {
+      width: 100%;
+      border-collapse: collapse;
+      text-align: left;
+    }
+
+    th {
+      position: sticky;
+      top: 0;
+      background: rgba(0, 15, 5, 0.95);
+      padding: 1rem;
+      font-size: 0.8rem;
+      text-transform: uppercase;
+      color: var(--secondary);
+      border-bottom: 1px solid var(--primary);
+      z-index: 1;
+    }
+
+    td {
+      padding: 0.8rem 1rem;
+      border-bottom: 1px solid rgba(0, 255, 65, 0.1);
+      font-size: 0.9rem;
+      color: var(--text);
+    }
+
+    tbody tr {
+      transition: background 0.1s;
+    }
+
+    tbody tr:hover {
+      background: rgba(0, 255, 65, 0.05);
+      cursor: crosshair;
+    }
+
+    .tag {
+      padding: 0.2rem 0.5rem;
+      border: 1px solid var(--border);
+      font-size: 0.75rem;
+      background: rgba(0, 255, 65, 0.05);
+      color: var(--primary);
+    }
+
+    .model-name { color: var(--secondary); }
+
+    /* Glitch effect on incoming rows */
+    @keyframes glitch {
+      0% { transform: translate(0) }
+      20% { transform: translate(-2px, 1px) }
+      40% { transform: translate(-1px, -1px) }
+      60% { transform: translate(2px, 1px) }
+      80% { transform: translate(1px, -1px) }
+      100% { transform: translate(0) }
+    }
+
+    .new-row {
+      animation: glitch 0.3s cubic-bezier(.25, .46, .45, .94) both;
+      background: rgba(0, 255, 65, 0.15);
+    }
+
+  </style>
+</head>
+<body>
+
+  <header>
+    <div>
+      <h1>KIRO_GATEWAY</h1>
+      <div style="font-size: 0.8rem; color: var(--text); margin-top: 5px;">LOCAL PROXY // TELEMETRY NODE</div>
+    </div>
+    <div class="status-badge">
+      <div class="pulse"></div>
+      SYS.ONLINE
+    </div>
+  </header>
+
+  <div class="metrics-grid">
+    <div class="metric-card">
+      <div class="metric-label">TOTAL.REQUESTS</div>
+      <div class="metric-value" id="val-requests">0</div>
+    </div>
+    <div class="metric-card">
+      <div class="metric-label">TOTAL.TOKENS</div>
+      <div class="metric-value" id="val-tokens">0</div>
+    </div>
+    <div class="metric-card">
+      <div class="metric-label">EST.CREDITS</div>
+      <div class="metric-value" id="val-credits">0.000</div>
+    </div>
+  </div>
+
+  <div class="table-container">
+    <table>
+      <thead>
+        <tr>
+          <th>TIME</th>
+          <th>ID</th>
+          <th>MODEL</th>
+          <th>TYPE</th>
+          <th>IN.TOKENS</th>
+          <th>OUT.TOKENS</th>
+          <th>CREDITS</th>
+        </tr>
+      </thead>
+      <tbody id="table-body">
+        <!-- Rows injected here -->
+      </tbody>
+    </table>
+  </div>
+
+  <script>
+    let lastRenderedIds = new Set();
+
+    function formatTime(timestamp) {
+      const d = new Date(timestamp);
+      return d.toLocaleTimeString('en-US', { hour12: false, hour: '2-digit', minute: '2-digit', second: '2-digit' }) + '.' + d.getMilliseconds().toString().padStart(3, '0');
+    }
+
+    async function fetchStats() {
+      try {
+        const res = await fetch('/dashboard/api/stats');
+        const data = await res.json();
+        
+        document.getElementById('val-requests').innerText = data.totalRequests;
+        document.getElementById('val-tokens').innerText = data.totalTokens.toLocaleString();
+        document.getElementById('val-credits').innerText = data.totalCredits.toFixed(4);
+
+        const tbody = document.getElementById('table-body');
+        
+        // Rebuild table to keep things simple but add animation class to new ones
+        let html = '';
+        const currentIds = new Set();
+        
+        data.requests.forEach(req => {
+          currentIds.add(req.id);
+          const isNew = !lastRenderedIds.has(req.id) && lastRenderedIds.size > 0;
+          
+          html += \`
+            <tr class="\${isNew ? 'new-row' : ''}">
+              <td style="color: var(--secondary)">\${formatTime(req.timestamp)}</td>
+              <td><span style="opacity: 0.5">msg_</span>\${req.id.split('_').pop().substring(0,8)}</td>
+              <td class="model-name">\${req.model}</td>
+              <td><span class="tag">\${req.stream ? 'STREAM' : 'SYNC'}</span></td>
+              <td>\${req.inputTokens.toLocaleString()}</td>
+              <td>\${req.outputTokens.toLocaleString()}</td>
+              <td>\${req.credits.toFixed(5)}</td>
+            </tr>
+          \`;
+        });
+        
+        tbody.innerHTML = html;
+        lastRenderedIds = currentIds;
+
+        // Remove new-row class after animation
+        setTimeout(() => {
+          document.querySelectorAll('.new-row').forEach(el => el.classList.remove('new-row'));
+        }, 500);
+
+      } catch (err) {
+        console.error("Telemetry connection lost", err);
+      }
+    }
+
+    // Initial fetch
+    fetchStats();
+    // Poll every 1.5s
+    setInterval(fetchStats, 1500);
+  </script>
+</body>
+</html>`;
+}
+
+// src/server.ts
+var _creds = null;
+async function initGatewayAuth() {
+  try {
+    const { importFromKiroCli: importFromKiroCli2 } = await Promise.resolve().then(() => (init_kiro_cli_sync(), exports_kiro_cli_sync));
+    const imported = await importFromKiroCli2();
+    if (!imported) {
+      log.warn("[gateway-auth] No Kiro CLI credentials found");
+      return;
+    }
+    const packParts = [
+      imported.refreshToken,
+      imported.clientId || "",
+      imported.clientSecret || "",
+      imported.authMethod
+    ];
+    _creds = {
+      accessToken: imported.accessToken,
+      refreshPacked: packParts.join("|"),
+      region: imported.region,
+      authMethod: imported.authMethod,
+      profileArn: imported.profileArn,
+      expiresAt: Date.now() + 3500000
+    };
+    log.info(`[gateway-auth] Initialized (method=${imported.authMethod}, region=${imported.region})`);
+    try {
+      const apiModels = await fetchAvailableModels(imported.accessToken, imported.region, imported.profileArn);
+      const built = buildModelsFromApi(apiModels);
+      setCachedDynamicModels(built);
+      log.info(`[kiro-models.fetched] Found ${built.length} available models`);
+    } catch (err) {
+      log.warn("[gateway-auth] Failed to fetch dynamic models (will fallback to static list)", err);
+    }
+  } catch (err) {
+    log.error("[gateway-auth] Init failed", err);
+  }
+}
+async function getAccessToken() {
+  if (!_creds)
+    throw new Error("Kiro credentials not initialized — run /login kiro");
+  if (Date.now() >= _creds.expiresAt) {
+    log.info("[gateway-auth] Token expired, refreshing...");
+    const refreshed = await refreshKiroToken(_creds.refreshPacked, _creds.region, _creds.authMethod);
+    _creds.accessToken = refreshed.access;
+    _creds.refreshPacked = refreshed.refresh;
+    _creds.expiresAt = refreshed.expires;
+    log.info("[gateway-auth] Token refreshed successfully");
+  }
+  return _creds.accessToken;
+}
+function anthropicError(status, type, message) {
+  return new Response(JSON.stringify({ type: "error", error: { type, message } }), {
+    status,
+    headers: {
+      "Content-Type": "application/json",
+      "Access-Control-Allow-Origin": "*"
+    }
+  });
+}
+function startGatewayServer(port = 0) {
+  return new Promise((resolve2) => {
+    const server = Bun.serve({
+      port,
+      idleTimeout: 255,
+      async fetch(req) {
+        if (req.method === "OPTIONS") {
+          return new Response(null, {
+            headers: {
+              "Access-Control-Allow-Origin": "*",
+              "Access-Control-Allow-Methods": "POST, GET, OPTIONS",
+              "Access-Control-Allow-Headers": "Content-Type, Authorization"
+            }
+          });
+        }
+        const url = new URL(req.url);
+        if (url.pathname === "/dashboard") {
+          return new Response(getDashboardHtml(), {
+            headers: { "Content-Type": "text/html" }
+          });
+        }
+        if (url.pathname === "/dashboard/api/stats") {
+          return new Response(JSON.stringify(stats.getStats()), {
+            headers: { "Content-Type": "application/json" }
+          });
+        }
+        if (url.pathname === "/health" || url.pathname === "/") {
+          return new Response(JSON.stringify({ status: "healthy", service: "opencode-kiro-gateway" }), {
+            headers: { "Content-Type": "application/json" }
+          });
+        }
+        if ((url.pathname === "/v1/messages" || url.pathname === "/messages") && req.method === "POST") {
+          let accessToken;
+          try {
+            accessToken = await getAccessToken();
+          } catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            return anthropicError(401, "authentication_error", `Kiro: ${msg}`);
+          }
+          let body;
+          try {
+            body = await req.json();
+          } catch (e) {
+            return anthropicError(400, "invalid_request_error", "Bad Request: Invalid JSON body");
+          }
+          const anthropicModelId = body.model;
+          const anthropicMessages = body.messages || [];
+          let systemPrompt = "";
+          if (typeof body.system === "string") {
+            systemPrompt = body.system;
+          } else if (Array.isArray(body.system)) {
+            systemPrompt = body.system.map((b) => typeof b === "string" ? b : b.text || "").join(`
+`);
+          }
+          const streamRequested = !!body.stream;
+          const temperature = body.temperature ?? 0.5;
+          log.debug(`[gateway] sys=${systemPrompt.length}c msgs=${anthropicMessages.length} tools=${body.tools?.length ?? 0}`);
+          try {
+            const piMessages = translateAnthropicToPi(anthropicMessages);
+            const context = {
+              messages: piMessages,
+              systemPrompt: "",
+              tools: body.tools ? translateAnthropicToolsToPi(body.tools) : undefined
+            };
+            const apiRegion = resolveApiRegion(_creds.region);
+            const kiroEndpoint = `https://runtime.${apiRegion}.kiro.dev`;
+            const piModel = {
+              id: anthropicModelId,
+              name: anthropicModelId,
+              provider: "kiro",
+              api: "kiro-api",
+              baseUrl: kiroEndpoint,
+              reasoning: true,
+              input: ["text", "image"],
+              cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+              contextWindow: 1e6,
+              maxTokens: 128000
+            };
+            log.debug("[gateway] body-keys", Object.keys(body));
+            const reasoningEffort = body.output_config?.effort ?? body.reasoning_effort ?? undefined;
+            log.info(`[gateway] → ${kiroEndpoint} model=${anthropicModelId} region=${apiRegion} stream=${streamRequested}`);
+            if (_creds.profileArn) {
+              seedProfileArn(kiroEndpoint, _creds.profileArn);
+            }
+            const kiroStream = streamKiro(piModel, context, {
+              apiKey: accessToken,
+              reasoning: reasoningEffort,
+              temperature
+            });
+            if (streamRequested) {
+              const iter = kiroStream[Symbol.asyncIterator]();
+              let firstResult;
+              try {
+                firstResult = await iter.next();
+              } catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                log.error("[gateway] Stream failed before first event:", msg);
+                return anthropicError(502, "api_error", `Kiro: ${msg}`);
+              }
+              if (firstResult.done) {
+                return anthropicError(502, "api_error", "Kiro: stream ended without producing events");
+              }
+              const bufferedEvents = [firstResult.value];
+              while (bufferedEvents[bufferedEvents.length - 1]?.type === "start") {
+                try {
+                  const next = await iter.next();
+                  if (next.done)
+                    break;
+                  bufferedEvents.push(next.value);
+                } catch (err) {
+                  const msg = err instanceof Error ? err.message : String(err);
+                  log.error("[gateway] Stream failed during buffering:", msg);
+                  return anthropicError(502, "api_error", `Kiro: ${msg}`);
+                }
+              }
+              const errorEvent = bufferedEvents.find((e) => e.type === "error");
+              if (errorEvent) {
+                const errMsg = errorEvent.error?.errorMessage || errorEvent.reason || "Unknown Kiro error";
+                log.error("[gateway] Kiro stream error:", errMsg);
+                return anthropicError(502, "api_error", `Kiro: ${errMsg}`);
+              }
+              const streamResponse = new ReadableStream({
+                async start(controller) {
+                  try {
+                    const msgId = `msg_${crypto.randomUUID()}`;
+                    controller.enqueue(`event: message_start
+data: ` + JSON.stringify({
+                      type: "message_start",
+                      message: {
+                        id: msgId,
+                        type: "message",
+                        role: "assistant",
+                        content: [],
+                        model: anthropicModelId,
+                        stop_reason: null,
+                        stop_sequence: null,
+                        usage: { input_tokens: 0, output_tokens: 0 }
+                      }
+                    }) + `
+
+`);
+                    let contentBlockIndex = 0;
+                    let activeBlockType = null;
+                    const closeActiveBlock = () => {
+                      if (activeBlockType !== null) {
+                        controller.enqueue(`event: content_block_stop
+data: ` + JSON.stringify({
+                          type: "content_block_stop",
+                          index: contentBlockIndex - 1
+                        }) + `
+
+`);
+                        activeBlockType = null;
+                      }
+                    };
+                    const ensureBlockStarted = (type) => {
+                      if (activeBlockType === type)
+                        return;
+                      closeActiveBlock();
+                      activeBlockType = type;
+                      controller.enqueue(`event: content_block_start
+data: ` + JSON.stringify({
+                        type: "content_block_start",
+                        index: contentBlockIndex++,
+                        content_block: {
+                          type,
+                          [type]: ""
+                        }
+                      }) + `
+
+`);
+                    };
+                    const processEvent = (event) => {
+                      if (event.type === "thinking_delta") {
+                        ensureBlockStarted("thinking");
+                        controller.enqueue(`event: content_block_delta
+data: ` + JSON.stringify({
+                          type: "content_block_delta",
+                          index: contentBlockIndex - 1,
+                          delta: {
+                            type: "thinking_delta",
+                            thinking: event.delta
+                          }
+                        }) + `
+
+`);
+                      } else if (event.type === "text_delta") {
+                        ensureBlockStarted("text");
+                        controller.enqueue(`event: content_block_delta
+data: ` + JSON.stringify({
+                          type: "content_block_delta",
+                          index: contentBlockIndex - 1,
+                          delta: {
+                            type: "text_delta",
+                            text: event.delta
+                          }
+                        }) + `
+
+`);
+                      } else if (event.type === "toolcall_start") {
+                        closeActiveBlock();
+                        const tc = event.partial.content[event.contentIndex];
+                        if (tc && tc.type === "toolCall") {
+                          activeBlockType = "tool_use";
+                          controller.enqueue(`event: content_block_start
+data: ` + JSON.stringify({
+                            type: "content_block_start",
+                            index: contentBlockIndex++,
+                            content_block: {
+                              type: "tool_use",
+                              id: tc.id,
+                              name: tc.name,
+                              input: {}
+                            }
+                          }) + `
+
+`);
+                        }
+                      } else if (event.type === "toolcall_delta") {
+                        controller.enqueue(`event: content_block_delta
+data: ` + JSON.stringify({
+                          type: "content_block_delta",
+                          index: contentBlockIndex - 1,
+                          delta: {
+                            type: "input_json_delta",
+                            partial_json: event.delta
+                          }
+                        }) + `
+
+`);
+                      }
+                    };
+                    for (const ev of bufferedEvents) {
+                      processEvent(ev);
+                    }
+                    for await (const event of { [Symbol.asyncIterator]: () => iter }) {
+                      processEvent(event);
+                    }
+                    closeActiveBlock();
+                    let finishReason = "end_turn";
+                    const finalMsg = await kiroStream.result();
+                    if (finalMsg.content.some((b) => b.type === "toolCall")) {
+                      finishReason = "tool_use";
+                    }
+                    const inputTokens = finalMsg.usage?.input ?? 0;
+                    const outputTokens = finalMsg.usage?.output ?? 0;
+                    const credits = finalMsg.usage?.cost?.total ?? 0;
+                    stats.recordRequest({
+                      id: msgId,
+                      model: anthropicModelId,
+                      inputTokens,
+                      outputTokens,
+                      credits,
+                      stream: true
+                    });
+                    controller.enqueue(`event: message_delta
+data: ` + JSON.stringify({
+                      type: "message_delta",
+                      delta: {
+                        stop_reason: finishReason,
+                        stop_sequence: null
+                      },
+                      usage: {
+                        output_tokens: outputTokens
+                      }
+                    }) + `
+
+`);
+                    controller.enqueue(`event: message_stop
+data: {"type":"message_stop"}
+
+`);
+                    controller.close();
+                  } catch (err) {
+                    log.error("[gateway] Stream error:", err);
+                    controller.enqueue(`event: error
+data: ` + JSON.stringify({
+                      type: "error",
+                      error: {
+                        type: "api_error",
+                        message: err instanceof Error ? err.message : String(err)
+                      }
+                    }) + `
+
+`);
+                    controller.close();
+                  }
+                }
+              });
+              return new Response(streamResponse, {
+                headers: {
+                  "Content-Type": "text/event-stream",
+                  "Cache-Control": "no-cache",
+                  Connection: "keep-alive",
+                  "Access-Control-Allow-Origin": "*"
+                }
+              });
+            } else {
+              const finalMsg = await kiroStream.result();
+              const contentParts = finalMsg.content;
+              const anthropicContent = [];
+              for (const part of contentParts) {
+                if (part.type === "text") {
+                  anthropicContent.push({
+                    type: "text",
+                    text: part.text
+                  });
+                } else if (part.type === "thinking") {
+                  anthropicContent.push({
+                    type: "thinking",
+                    thinking: part.thinking
+                  });
+                } else if (part.type === "toolCall") {
+                  anthropicContent.push({
+                    type: "tool_use",
+                    id: part.id,
+                    name: part.name,
+                    input: typeof part.arguments === "string" ? JSON.parse(part.arguments) : part.arguments
+                  });
+                }
+              }
+              let finishReason = "end_turn";
+              if (finalMsg.content.some((b) => b.type === "toolCall")) {
+                finishReason = "tool_use";
+              }
+              const msgId = `msg_${crypto.randomUUID()}`;
+              const inputTokens = finalMsg.usage?.input ?? 0;
+              const outputTokens = finalMsg.usage?.output ?? 0;
+              const credits = finalMsg.usage?.cost?.total ?? 0;
+              stats.recordRequest({
+                id: msgId,
+                model: anthropicModelId,
+                inputTokens,
+                outputTokens,
+                credits,
+                stream: false
+              });
+              const responseBody = {
+                id: msgId,
+                type: "message",
+                role: "assistant",
+                content: anthropicContent,
+                model: anthropicModelId,
+                stop_reason: finishReason,
+                stop_sequence: null,
+                usage: {
+                  input_tokens: inputTokens,
+                  output_tokens: outputTokens
+                }
+              };
+              return new Response(JSON.stringify(responseBody), {
+                headers: {
+                  "Content-Type": "application/json",
+                  "Access-Control-Allow-Origin": "*"
+                }
+              });
+            }
+          } catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            log.error("[gateway] Completions error:", msg);
+            return anthropicError(500, "api_error", `Kiro gateway: ${msg}`);
+          }
+        }
+        return anthropicError(404, "not_found_error", `Not Found: ${url.pathname}`);
+      }
+    });
+    log.info(`Gateway server started on port ${server.port}`);
+    resolve2(server);
+  });
+}
+function translateAnthropicToPi(messages) {
+  const piMessages = [];
+  for (const msg of messages) {
+    if (msg.role === "user") {
+      if (typeof msg.content === "string") {
+        piMessages.push({
+          role: "user",
+          content: msg.content,
+          timestamp: Date.now()
+        });
+      } else if (Array.isArray(msg.content)) {
+        const toolResultParts = msg.content.filter((part) => part.type === "tool_result");
+        if (toolResultParts.length > 0) {
+          for (const part of toolResultParts) {
+            piMessages.push({
+              role: "toolResult",
+              toolCallId: part.tool_use_id,
+              content: typeof part.content === "string" ? part.content : Array.isArray(part.content) ? part.content.map((c) => c.text ?? "").join(`
+`) : "",
+              isError: part.is_error || false,
+              timestamp: Date.now()
+            });
+          }
+        }
+        const otherParts = msg.content.map((part) => {
+          if (part.type === "text") {
+            return { type: "text", text: part.text };
+          }
+          if (part.type === "image" && part.source?.type === "base64") {
+            return { type: "image", mimeType: part.source.media_type, data: part.source.data };
+          }
+          return null;
+        }).filter(Boolean);
+        if (otherParts.length > 0) {
+          piMessages.push({
+            role: "user",
+            content: otherParts,
+            timestamp: Date.now()
+          });
+        }
+      }
+    } else if (msg.role === "assistant") {
+      const contentParts = [];
+      if (typeof msg.content === "string") {
+        contentParts.push({ type: "text", text: msg.content });
+      } else if (Array.isArray(msg.content)) {
+        for (const part of msg.content) {
+          if (part.type === "text") {
+            contentParts.push({ type: "text", text: part.text });
+          } else if (part.type === "thinking") {
+            contentParts.push({ type: "thinking", thinking: part.thinking });
+          } else if (part.type === "tool_use") {
+            contentParts.push({
+              type: "toolCall",
+              id: part.id,
+              name: part.name,
+              arguments: part.input
+            });
+          }
+        }
+      }
+      piMessages.push({
+        role: "assistant",
+        content: contentParts,
+        stopReason: contentParts.some((p) => p.type === "toolCall") ? "toolCalls" : "stop",
+        timestamp: Date.now()
+      });
+    }
+  }
+  return piMessages;
+}
+function translateAnthropicToolsToPi(tools) {
+  return tools.map((t) => {
+    return {
+      name: t.name,
+      description: t.description,
+      parameters: t.input_schema
+    };
+  });
+}
+
+// src/index.ts
+init_debug();
+process.env.KIRO_LOG = process.env.KIRO_LOG || "debug";
+process.env.KIRO_LOG_FILE = process.env.KIRO_LOG_FILE || "/tmp/opencode-kiro.log";
+var gatewayServer = null;
+var KiroPlugin = async (input) => {
+  const client = input.client;
+  const GATEWAY_PORT = 7438;
+  try {
+    if (gatewayServer) {
+      log.info("[opencode-kiro] Stopping existing gateway server...");
+      await gatewayServer.stop(true);
+    }
+    gatewayServer = await startGatewayServer(GATEWAY_PORT);
+    log.info(`[opencode-kiro] Gateway server active on http://127.0.0.1:${gatewayServer.port}`);
+  } catch (err) {
+    log.error("[opencode-kiro] Failed to start local gateway server", err);
+  }
+  await initGatewayAuth();
+  const localPort = gatewayServer ? gatewayServer.port : GATEWAY_PORT;
+  const hooks = {
+    dispose: async () => {
+      if (gatewayServer) {
+        log.info("[opencode-kiro] Shutting down gateway server...");
+        await gatewayServer.stop(true);
+        gatewayServer = null;
+      }
+    },
+    auth: {
+      provider: "kiro",
+      loader: async (getAuth, provider) => {
+        try {
+          const auth = await getAuth();
+          if (auth && auth.type === "oauth" && auth.access) {
+            return {
+              headers: { Authorization: `Bearer ${auth.access}` },
+              apiKey: auth.access
+            };
+          }
+        } catch (e) {
+          log.error("[opencode-kiro] Error in auth loader", e);
+        }
+        return {};
+      },
+      methods: [
+        {
+          type: "oauth",
+          label: "AWS Builder ID (personal account)",
+          prompts: [],
+          authorize: async () => {
+            const result = await tryRegisterAndAuthorize(BUILDER_ID_START_URL, BUILDER_ID_REGION);
+            if (!result) {
+              throw new Error("Could not authorize with AWS Builder ID.");
+            }
+            return {
+              url: result.devAuth.verificationUriComplete,
+              instructions: `AWS Verification Code: ${result.devAuth.userCode}
+Complete authorization in your browser, then OpenCode will continue automatically.`,
+              method: "auto",
+              callback: async () => {
+                const tok = await pollForToken(result.oidcEndpoint, result.clientId, result.clientSecret, result.devAuth, undefined);
+                if (!tok.accessToken || !tok.refreshToken) {
+                  return { type: "failed" };
+                }
+                return {
+                  type: "success",
+                  access: tok.accessToken,
+                  refresh: `${tok.refreshToken}|${result.clientId}|${result.clientSecret}|builder-id`,
+                  expires: Date.now() + (tok.expiresIn ?? 3600) * 1000 - EXPIRES_BUFFER_MS,
+                  metadata: {
+                    region: BUILDER_ID_REGION,
+                    authMethod: "builder-id"
+                  }
+                };
+              }
+            };
+          }
+        },
+        {
+          type: "oauth",
+          label: "IAM Identity Center (enterprise SSO)",
+          prompts: [
+            {
+              type: "text",
+              key: "sso_url",
+              message: "Paste your IAM Identity Center start URL:",
+              placeholder: "https://mycompany.awsapps.com/start"
+            },
+            {
+              type: "text",
+              key: "sso_region",
+              message: "Identity Center region (optional, blank to auto-detect):",
+              placeholder: "us-east-1"
+            }
+          ],
+          authorize: async (inputs = {}) => {
+            const ssoUrl = inputs.sso_url?.trim();
+            if (!ssoUrl || !ssoUrl.startsWith("http")) {
+              throw new Error(`Invalid start URL "${ssoUrl ?? ""}" — expected https://…`);
+            }
+            const ssoRegion = inputs.sso_region?.trim();
+            const regions = ssoRegion ? [ssoRegion] : IDC_PROBE_REGIONS;
+            let result = null;
+            let detectedRegion = "";
+            for (const region of regions) {
+              result = await tryRegisterAndAuthorize(ssoUrl, region);
+              if (result) {
+                detectedRegion = region;
+                break;
+              }
+            }
+            if (!result || !detectedRegion) {
+              throw new Error(`Could not authorize ${ssoUrl} in ${regions.join(", ")}.`);
+            }
+            return {
+              url: result.devAuth.verificationUriComplete,
+              instructions: `AWS Verification Code: ${result.devAuth.userCode}
+Complete authorization in your browser, then OpenCode will continue automatically.`,
+              method: "auto",
+              callback: async () => {
+                const tok = await pollForToken(result.oidcEndpoint, result.clientId, result.clientSecret, result.devAuth, undefined);
+                if (!tok.accessToken || !tok.refreshToken) {
+                  return { type: "failed" };
+                }
+                return {
+                  type: "success",
+                  access: tok.accessToken,
+                  refresh: `${tok.refreshToken}|${result.clientId}|${result.clientSecret}|idc`,
+                  expires: Date.now() + (tok.expiresIn ?? 3600) * 1000 - EXPIRES_BUFFER_MS,
+                  metadata: {
+                    region: detectedRegion,
+                    authMethod: "idc"
+                  }
+                };
+              }
+            };
+          }
+        },
+        {
+          type: "oauth",
+          label: "Import from Kiro CLI/IDE (auto-sync)",
+          prompts: [],
+          authorize: async () => {
+            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 CLI/IDE credentials found.
+Make sure Kiro CLI or IDE is installed and you're logged in, then try again.`);
+            }
+            const authMethod = imported.authMethod || "desktop";
+            const region = imported.region || "us-east-1";
+            const packParts = [
+              imported.refreshToken,
+              imported.clientId || "",
+              imported.clientSecret || "",
+              authMethod
+            ];
+            return {
+              url: "",
+              method: "auto",
+              instructions: `Imported from Kiro ${imported.email ? `(${imported.email}, ` : "("}${authMethod}, ${region})`,
+              callback: async () => {
+                if (imported.accessToken) {
+                  return {
+                    type: "success",
+                    access: imported.accessToken,
+                    refresh: packParts.join("|"),
+                    expires: Date.now() + 3600000 - EXPIRES_BUFFER_MS,
+                    metadata: { region, authMethod, profileArn: imported.profileArn }
+                  };
+                }
+                try {
+                  const refreshed = await refreshKiroToken(packParts.join("|"), region, authMethod);
+                  return {
+                    type: "success",
+                    access: refreshed.access,
+                    refresh: refreshed.refresh,
+                    expires: refreshed.expires,
+                    metadata: { region, authMethod, profileArn: imported.profileArn }
+                  };
+                } catch {
+                  return { type: "failed" };
+                }
+              }
+            };
+          }
+        },
+        {
+          type: "oauth",
+          label: "Desktop refresh token (manual)",
+          prompts: [
+            {
+              type: "text",
+              key: "refresh_token",
+              message: `Paste your Kiro desktop refresh token
+(find it in ~/.kiro/db or ~/.aws/sso/cache/):`,
+              placeholder: "refresh-token"
+            },
+            {
+              type: "text",
+              key: "region",
+              message: "Kiro region:",
+              placeholder: "us-east-1"
+            }
+          ],
+          authorize: async (inputs = {}) => {
+            const refreshToken = inputs.refresh_token?.trim();
+            if (!refreshToken) {
+              throw new Error("No refresh token provided.");
+            }
+            const region = inputs.region?.trim() || "us-east-1";
+            const packed = `${refreshToken}|||desktop`;
+            return {
+              url: "",
+              method: "auto",
+              instructions: "Exchanging refresh token…",
+              callback: async () => {
+                try {
+                  const refreshed = await refreshKiroToken(packed, region, "desktop");
+                  return {
+                    type: "success",
+                    access: refreshed.access,
+                    refresh: refreshed.refresh,
+                    expires: refreshed.expires,
+                    metadata: { region, authMethod: "desktop" }
+                  };
+                } catch (err) {
+                  throw new Error(`Desktop token refresh failed: ${err}`);
+                }
+              }
+            };
+          }
+        }
+      ]
+    },
+    config: async (cfg) => {
+      cfg.provider = cfg.provider ?? {};
+      cfg.provider.kiro = cfg.provider.kiro ?? {};
+      const kiro = cfg.provider.kiro;
+      kiro.name = kiro.name ?? "Kiro";
+      kiro.npm = kiro.npm ?? "@ai-sdk/anthropic";
+      kiro.api = kiro.api ?? `http://127.0.0.1:${localPort}/v1`;
+      kiro.models = kiro.models ?? {};
+      const allModels = getCachedDynamicModels() || kiroModels;
+      for (const m of allModels) {
+        if (kiro.models[m.id])
+          continue;
+        kiro.models[m.id] = {
+          id: m.id,
+          name: m.name,
+          reasoning: m.reasoning,
+          temperature: true,
+          tool_call: true,
+          attachment: m.input.includes("image"),
+          modalities: {
+            input: m.input.includes("image") ? ["text", "image"] : ["text"],
+            output: ["text"]
+          },
+          cost: { input: 0, output: 0, cache_read: 0, cache_write: 0 },
+          limit: { context: m.contextWindow, output: m.maxTokens },
+          status: "active",
+          release_date: "2026-06-15",
+          provider: {
+            npm: "@ai-sdk/anthropic",
+            api: `http://127.0.0.1:${localPort}/v1`
+          }
+        };
+      }
+    }
+  };
+  return hooks;
+};
+var src_default = {
+  id: "opencode-kiro",
+  server: KiroPlugin
+};
+export {
+  src_default as default,
+  KiroPlugin
+};