ns-omp-provider-kiro 0.3.9 → 0.4.0

package/dist/index.js

@@ -238,11 +238,18 @@ function resolveApiRegion(ssoRegion) {
     return "us-east-1";
   return API_REGION_MAP[ssoRegion] ?? ssoRegion;
 }
+function endpointOverride(name, region) {
+  const value = process.env[name]?.trim();
+  if (!value)
+    return void 0;
+  const url = value.replaceAll("{region}", region);
+  return url.endsWith("/") ? url : `${url}/`;
+}
 function getKiroEndpoints(region) {
   return {
     region,
-    management: `https://management.${region}.kiro.dev/`,
-    runtime: `https://runtime.${region}.kiro.dev/`
+    management: endpointOverride(KIRO_MANAGEMENT_ENDPOINT_ENV, region) ?? `https://management.${region}.kiro.dev/`,
+    runtime: endpointOverride(KIRO_RUNTIME_ENDPOINT_ENV, region) ?? `https://runtime.${region}.kiro.dev/`
   };
 }
 function getKiroRegionFromProfileArn(profileArn) {
@@ -262,7 +269,7 @@ function getKiroRegionFromEndpoint(endpoint) {
     return void 0;
   }
 }
-var API_REGION_MAP;
+var API_REGION_MAP, KIRO_RUNTIME_ENDPOINT_ENV, KIRO_MANAGEMENT_ENDPOINT_ENV;
 var init_endpoints = __esm({
   "../kiro-core/dist/endpoints.js"() {
     "use strict";
@@ -284,6 +291,441 @@ var init_endpoints = __esm({
       "eu-south-2": "eu-central-1",
       "eu-central-2": "eu-central-1"
     };
+    KIRO_RUNTIME_ENDPOINT_ENV = "KIRO_RUNTIME_ENDPOINT";
+    KIRO_MANAGEMENT_ENDPOINT_ENV = "KIRO_MANAGEMENT_ENDPOINT";
+  }
+});
+
+// ../bridge-core/dist/sidecar/binary.js
+import { createRequire } from "node:module";
+function findPackagedSidecarBinary() {
+  let bin;
+  try {
+    bin = localRequire(SIDECAR_BIN_PACKAGE);
+  } catch {
+    return { error: `${SIDECAR_BIN_PACKAGE} is not installed` };
+  }
+  try {
+    return { path: bin.binaryPath() };
+  } catch (error2) {
+    return { error: error2 instanceof Error ? error2.message : String(error2) };
+  }
+}
+function resolveSidecarBinary(explicit, env = process.env, options = {}) {
+  const fromEnv = env[NS_BRIDGE_BIN_ENV]?.trim();
+  if (fromEnv)
+    return fromEnv;
+  if (explicit?.trim())
+    return explicit.trim();
+  const packaged = (options.packaged ?? findPackagedSidecarBinary)();
+  if ("path" in packaged)
+    return packaged.path;
+  return DEFAULT_SIDECAR_COMMAND;
+}
+var NS_BRIDGE_BIN_ENV, DEFAULT_SIDECAR_COMMAND, SIDECAR_BIN_PACKAGE, localRequire;
+var init_binary = __esm({
+  "../bridge-core/dist/sidecar/binary.js"() {
+    "use strict";
+    NS_BRIDGE_BIN_ENV = "NS_BRIDGE_BIN";
+    DEFAULT_SIDECAR_COMMAND = "ns-bridge";
+    SIDECAR_BIN_PACKAGE = "ns-bridge-bin";
+    localRequire = createRequire(import.meta.url);
+  }
+});
+
+// ../bridge-core/dist/sidecar/errors.js
+var SidecarError;
+var init_errors = __esm({
+  "../bridge-core/dist/sidecar/errors.js"() {
+    "use strict";
+    SidecarError = class _SidecarError extends Error {
+      name = "SidecarError";
+      kind;
+      vendor;
+      status;
+      retryAfterMs;
+      reasonCode;
+      vendorError;
+      providerAttempts;
+      exitCode;
+      exitSignal;
+      stderr;
+      constructor(kind, message, details = {}) {
+        super(message, details.cause === void 0 ? void 0 : { cause: details.cause });
+        this.kind = kind;
+        this.vendor = details.vendor;
+        this.status = details.status;
+        this.retryAfterMs = details.retryAfterMs;
+        this.reasonCode = details.reasonCode;
+        this.vendorError = details.vendorError;
+        this.providerAttempts = details.providerAttempts;
+        this.exitCode = details.exitCode;
+        this.exitSignal = details.exitSignal;
+        this.stderr = details.stderr;
+      }
+      /** Rebuild the error a binary reported on its terminal line. */
+      static fromPayload(payload, details = {}) {
+        const kind = typeof payload.kind === "string" ? payload.kind : "internal";
+        const message = typeof payload.message === "string" && payload.message ? payload.message : `sidecar ${kind} error`;
+        return new _SidecarError(kind, message, {
+          ...details,
+          vendor: payload.vendor ?? details.vendor,
+          status: payload.status,
+          retryAfterMs: payload.retryAfterMs,
+          reasonCode: payload.reasonCode,
+          vendorError: payload.vendorError,
+          providerAttempts: payload.providerAttempts
+        });
+      }
+    };
+  }
+});
+
+// ../bridge-core/dist/sidecar/stream.js
+import { spawn } from "node:child_process";
+async function* sidecarStream(vendor, request, options = {}) {
+  let sawDone = false;
+  for await (const message of sidecarLines(vendor, ["stream", "--vendor", vendor], request, options, "done")) {
+    if (!EVENT_TYPES.has(message.type))
+      continue;
+    if (sawDone)
+      continue;
+    if (message.type === "done")
+      sawDone = true;
+    yield message;
+  }
+}
+async function sidecarCall(vendor, op, request, options = {}) {
+  let result;
+  for await (const message of sidecarLines(vendor, ["call", "--vendor", vendor, "--op", op], request, options, "result")) {
+    if (message.type === "result")
+      result = message.result;
+  }
+  return result;
+}
+async function* sidecarLines(vendor, args, request, options, terminal) {
+  const { signal } = options;
+  signal?.throwIfAborted();
+  const env = options.env ?? process.env;
+  const binary = resolveSidecarBinary(options.binary, env);
+  const graceMs = options.killGraceMs ?? DEFAULT_KILL_GRACE_MS;
+  let child;
+  try {
+    child = spawn(binary, args, { env, stdio: "pipe", windowsHide: true });
+  } catch (cause) {
+    throw unavailable(binary, vendor, cause);
+  }
+  const lines = [];
+  let partial = "";
+  let stderr = "";
+  let spawnError;
+  let exited = false;
+  let closed = false;
+  let exitCode = null;
+  let exitSignal = null;
+  let aborted = false;
+  let wake;
+  const notify = () => {
+    const resolve = wake;
+    wake = void 0;
+    resolve?.();
+  };
+  child.stdout.setEncoding("utf8");
+  child.stdout.on("data", (chunk) => {
+    const parts = (partial + chunk).split("\n");
+    partial = parts.pop() ?? "";
+    for (const part of parts)
+      if (part.trim())
+        lines.push(part);
+    notify();
+  });
+  child.stderr.setEncoding("utf8");
+  const stderrSink = options.stderr === void 0 ? process.stderr : options.stderr;
+  child.stderr.on("data", (chunk) => {
+    if (stderrSink)
+      stderrSink.write(chunk);
+    stderr = (stderr + chunk).slice(-STDERR_TAIL_BYTES);
+  });
+  child.stdin.on("error", () => {
+  });
+  child.on("error", (error2) => {
+    spawnError = error2;
+    notify();
+  });
+  child.on("exit", (code, sig) => {
+    exited = true;
+    exitCode = code;
+    exitSignal = sig;
+  });
+  child.on("close", (code, sig) => {
+    exited = true;
+    closed = true;
+    exitCode ??= code;
+    exitSignal ??= sig;
+    if (partial.trim())
+      lines.push(partial);
+    partial = "";
+    notify();
+  });
+  const timers = [];
+  const cancel = () => {
+    if (!child.stdin.destroyed)
+      child.stdin.end();
+    if (exited)
+      return;
+    const escalate = (delay, sig) => {
+      const timer = setTimeout(() => {
+        if (!exited)
+          child.kill(sig);
+      }, delay);
+      timer.unref();
+      timers.push(timer);
+    };
+    escalate(graceMs, "SIGTERM");
+    escalate(graceMs * 2, "SIGKILL");
+  };
+  const onAbort = () => {
+    aborted = true;
+    cancel();
+    notify();
+  };
+  signal?.addEventListener("abort", onAbort, { once: true });
+  child.stdin.write(`${JSON.stringify({ protocol: SIDECAR_PROTOCOL_VERSION, request })}
+`);
+  const details = () => ({ vendor, exitCode, exitSignal, stderr: stderr.trim() || void 0 });
+  let sawTerminal = false;
+  let finished = false;
+  try {
+    while (true) {
+      if (aborted)
+        throw abortReason(signal);
+      if (spawnError !== void 0)
+        throw unavailable(binary, vendor, spawnError);
+      const line = lines.shift();
+      if (line !== void 0) {
+        const message = parseLine(line, details);
+        if (message.type === "error") {
+          throw SidecarError.fromPayload(message.error ?? { kind: "protocol", message: "ns-bridge wrote an error line without a payload" }, details());
+        }
+        if (message.type === terminal)
+          sawTerminal = true;
+        yield message;
+        continue;
+      }
+      if (closed)
+        break;
+      await new Promise((resolve) => {
+        wake = resolve;
+      });
+    }
+    if (exitCode !== 0) {
+      const how = exitSignal ? `was killed by ${exitSignal}` : `exited with code ${exitCode}`;
+      throw new SidecarError("crashed", `ns-bridge (${vendor}) ${how} without reporting an error`, details());
+    }
+    if (!sawTerminal) {
+      throw new SidecarError("protocol", `ns-bridge (${vendor}) exited without a ${terminal} ${terminal === "done" ? "event" : "line"}`, details());
+    }
+    finished = true;
+  } finally {
+    signal?.removeEventListener("abort", onAbort);
+    if (finished) {
+      for (const timer of timers)
+        clearTimeout(timer);
+    } else {
+      cancel();
+    }
+  }
+}
+function parseLine(line, details) {
+  let value;
+  try {
+    value = JSON.parse(line);
+  } catch (cause) {
+    throw new SidecarError("protocol", `ns-bridge wrote a line that is not JSON: ${line.slice(0, 200)}`, {
+      ...details(),
+      cause
+    });
+  }
+  if (!value || typeof value !== "object" || typeof value.type !== "string") {
+    throw new SidecarError("protocol", `ns-bridge wrote a line without a type: ${line.slice(0, 200)}`, details());
+  }
+  return value;
+}
+function unavailable(binary, vendor, cause) {
+  const code = cause?.code;
+  const reason = code === "ENOENT" ? "not found" : code === "EACCES" ? "not executable" : String(cause);
+  const packaged = binary === DEFAULT_SIDECAR_COMMAND ? findPackagedSidecarBinary() : void 0;
+  const why = packaged && "error" in packaged ? ` ${packaged.error}.` : "";
+  return new SidecarError("unavailable", `Cannot start the ns-bridge binary "${binary}" (${reason}).${why} Install ns-bridge-bin or point NS_BRIDGE_BIN at a binary.`, { vendor, cause });
+}
+function abortReason(signal) {
+  const reason = signal?.reason;
+  if (reason instanceof Error)
+    return reason;
+  return new DOMException(typeof reason === "string" ? reason : "This operation was aborted", "AbortError");
+}
+var SIDECAR_PROTOCOL_VERSION, DEFAULT_KILL_GRACE_MS, STDERR_TAIL_BYTES, EVENT_TYPES;
+var init_stream = __esm({
+  "../bridge-core/dist/sidecar/stream.js"() {
+    "use strict";
+    init_binary();
+    init_errors();
+    SIDECAR_PROTOCOL_VERSION = 1;
+    DEFAULT_KILL_GRACE_MS = 2e3;
+    STDERR_TAIL_BYTES = 8 * 1024;
+    EVENT_TYPES = /* @__PURE__ */ new Set([
+      "start",
+      "text_start",
+      "text_delta",
+      "text_end",
+      "thinking_start",
+      "thinking_delta",
+      "thinking_end",
+      "tool_call_start",
+      "tool_call_delta",
+      "tool_call_end",
+      "reset",
+      "usage",
+      "done"
+    ]);
+  }
+});
+
+// ../bridge-core/dist/sidecar/engine.js
+import { existsSync, statSync } from "node:fs";
+import { delimiter, isAbsolute, join as join2 } from "node:path";
+function parseSetting(value) {
+  switch (value?.trim().toLowerCase()) {
+    case "go":
+    case "sidecar":
+    case "native":
+      return "go";
+    case "ts":
+    case "typescript":
+    case "js":
+    case "node":
+    case "in-process":
+      return "ts";
+    case "auto":
+      return "auto";
+    default:
+      return void 0;
+  }
+}
+function bridgeEngineSetting(vendor, env = process.env) {
+  const perVendor = vendor ? parseSetting(env[`${NS_BRIDGE_ENGINE_ENV}_${vendor.toUpperCase()}`]) : void 0;
+  return perVendor ?? parseSetting(env[NS_BRIDGE_ENGINE_ENV]) ?? DEFAULT_BRIDGE_ENGINE;
+}
+function isFile(path) {
+  try {
+    return statSync(path).isFile();
+  } catch {
+    return false;
+  }
+}
+function onPath(command, env) {
+  if (isAbsolute(command))
+    return isFile(command);
+  const extensions = process.platform === "win32" ? (env.PATHEXT ?? ".EXE;.CMD;.BAT").split(";") : [""];
+  for (const dir of (env.PATH ?? "").split(delimiter)) {
+    if (!dir)
+      continue;
+    for (const ext of extensions)
+      if (isFile(join2(dir, command + ext.toLowerCase())) || isFile(join2(dir, command + ext)))
+        return true;
+  }
+  return false;
+}
+function sidecarBinaryAvailable(env = process.env) {
+  const fromEnv = env[NS_BRIDGE_BIN_ENV]?.trim();
+  if (fromEnv)
+    return existsSync(fromEnv) || onPath(fromEnv, env);
+  if ("path" in findPackagedSidecarBinary())
+    return true;
+  return onPath(DEFAULT_SIDECAR_COMMAND, env);
+}
+function selectBridgeEngine(vendor, env = process.env) {
+  const setting = bridgeEngineSetting(vendor, env);
+  if (setting !== "auto")
+    return setting;
+  return sidecarBinaryAvailable(env) ? "go" : "ts";
+}
+function isAutoFallback(error2) {
+  return error2.kind === "unavailable" || error2.kind === "unsupported" || error2.kind === "crashed" && error2.exitCode === 2;
+}
+async function* engineStream(options) {
+  const env = options.env ?? process.env;
+  const engine = options.engine ?? selectBridgeEngine(options.vendor, env);
+  if (engine === "ts") {
+    yield* options.inProcess();
+    return;
+  }
+  let delivered = false;
+  try {
+    const raw = sidecarStream(options.vendor, options.request(), {
+      ...options.sidecar,
+      ...options.signal ? { signal: options.signal } : {},
+      env
+    });
+    for await (const event of options.transform ? options.transform(raw) : raw) {
+      delivered = true;
+      yield event;
+    }
+  } catch (error2) {
+    if (error2 instanceof SidecarError && isAutoFallback(error2) && !delivered && options.engine === void 0 && bridgeEngineSetting(options.vendor, env) === "auto") {
+      if (!warnedFallback) {
+        warnedFallback = true;
+        console.warn(`[ns-bridge] ${error2.message} Falling back to the in-process TypeScript core.`);
+      }
+      yield* options.inProcess();
+      return;
+    }
+    throw error2 instanceof SidecarError && options.mapError ? options.mapError(error2) : error2;
+  }
+}
+async function engineCall(options) {
+  const env = options.env ?? process.env;
+  const engine = options.engine ?? selectBridgeEngine(options.vendor, env);
+  if (engine === "ts")
+    return options.inProcess();
+  try {
+    return await sidecarCall(options.vendor, options.op, options.request(), {
+      ...options.sidecar,
+      ...options.signal ? { signal: options.signal } : {},
+      env
+    });
+  } catch (error2) {
+    if (error2 instanceof SidecarError && isAutoFallback(error2) && options.engine === void 0 && bridgeEngineSetting(options.vendor, env) === "auto") {
+      if (!warnedFallback) {
+        warnedFallback = true;
+        console.warn(`[ns-bridge] ${error2.message} Falling back to the in-process TypeScript core.`);
+      }
+      return options.inProcess();
+    }
+    throw error2 instanceof SidecarError && options.mapError ? options.mapError(error2) : error2;
+  }
+}
+var NS_BRIDGE_ENGINE_ENV, DEFAULT_BRIDGE_ENGINE, warnedFallback;
+var init_engine = __esm({
+  "../bridge-core/dist/sidecar/engine.js"() {
+    "use strict";
+    init_binary();
+    init_errors();
+    init_stream();
+    NS_BRIDGE_ENGINE_ENV = "NS_BRIDGE_ENGINE";
+    DEFAULT_BRIDGE_ENGINE = "auto";
+    warnedFallback = false;
+  }
+});
+
+// ../bridge-core/dist/sidecar/index.js
+var init_sidecar = __esm({
+  "../bridge-core/dist/sidecar/index.js"() {
+    "use strict";
+    init_binary();
+    init_engine();
+    init_errors();
+    init_stream();
   }
 });
 
@@ -302,16 +744,16 @@ __export(kiro_cli_exports, {
   tryKiroCliToken: () => tryKiroCliToken
 });
 import { execFileSync, execSync } from "node:child_process";
-import { existsSync } from "node:fs";
-import { createRequire } from "node:module";
+import { existsSync as existsSync2 } from "node:fs";
+import { createRequire as createRequire2 } from "node:module";
 import { homedir as homedir2, platform } from "node:os";
-import { join as join2 } from "node:path";
+import { join as join3 } from "node:path";
 function getKiroCliDbPath() {
   const p = platform();
-  const localAppData = process.env.LOCALAPPDATA || join2(homedir2(), "AppData", "Local");
-  const roamingAppData = process.env.APPDATA || join2(homedir2(), "AppData", "Roaming");
-  const candidates = p === "win32" ? [join2(localAppData, "Kiro-Cli", "data.sqlite3"), join2(roamingAppData, "kiro-cli", "data.sqlite3")] : p === "darwin" ? [join2(homedir2(), "Library", "Application Support", "kiro-cli", "data.sqlite3")] : [join2(homedir2(), ".local", "share", "kiro-cli", "data.sqlite3")];
-  return candidates.find((candidate) => existsSync(candidate));
+  const localAppData = process.env.LOCALAPPDATA || join3(homedir2(), "AppData", "Local");
+  const roamingAppData = process.env.APPDATA || join3(homedir2(), "AppData", "Roaming");
+  const candidates = p === "win32" ? [join3(localAppData, "Kiro-Cli", "data.sqlite3"), join3(roamingAppData, "kiro-cli", "data.sqlite3")] : p === "darwin" ? [join3(homedir2(), "Library", "Application Support", "kiro-cli", "data.sqlite3")] : [join3(homedir2(), ".local", "share", "kiro-cli", "data.sqlite3")];
+  return candidates.find((candidate) => existsSync2(candidate));
 }
 function getKiroCliExternalIdpCredentials() {
   const dbPath = getKiroCliDbPath();
@@ -591,7 +1033,7 @@ var init_kiro_cli = __esm({
   "../kiro-core/dist/kiro-cli.js"() {
     "use strict";
     init_debug();
-    require2 = createRequire(import.meta.url);
+    require2 = createRequire2(import.meta.url);
     EXTERNAL_IDP_TOKEN_KEY = "kirocli:external-idp:token";
     TOKEN_KEY_BY_AUTH_METHOD = {
       idc: ["kirocli:odic:token", "codewhisperer:odic:token"],
@@ -603,12 +1045,12 @@ var init_kiro_cli = __esm({
 });
 
 // ../kiro-core/dist/kiro-ide.js
-import { existsSync as existsSync2, readFileSync } from "node:fs";
+import { existsSync as existsSync3, readFileSync } from "node:fs";
 import { homedir as homedir3 } from "node:os";
-import { join as join3 } from "node:path";
+import { join as join4 } from "node:path";
 function readKiroIdeToken(allowExpired) {
   try {
-    if (!existsSync2(KIRO_IDE_TOKEN_PATH))
+    if (!existsSync3(KIRO_IDE_TOKEN_PATH))
       return void 0;
     const tokenData = JSON.parse(readFileSync(KIRO_IDE_TOKEN_PATH, "utf-8"));
     if (!tokenData.accessToken || !tokenData.refreshToken)
@@ -620,8 +1062,8 @@ function readKiroIdeToken(allowExpired) {
     let clientId = "";
     let clientSecret = "";
     if (tokenData.clientIdHash) {
-      const regPath = join3(SSO_CACHE_DIR, `${tokenData.clientIdHash}.json`);
-      if (existsSync2(regPath)) {
+      const regPath = join4(SSO_CACHE_DIR, `${tokenData.clientIdHash}.json`);
+      if (existsSync3(regPath)) {
         try {
           const reg = JSON.parse(readFileSync(regPath, "utf-8"));
           clientId = reg.clientId ?? "";
@@ -655,8 +1097,8 @@ var SSO_CACHE_DIR, KIRO_IDE_TOKEN_PATH;
 var init_kiro_ide = __esm({
   "../kiro-core/dist/kiro-ide.js"() {
     "use strict";
-    SSO_CACHE_DIR = join3(homedir3(), ".aws", "sso", "cache");
-    KIRO_IDE_TOKEN_PATH = join3(SSO_CACHE_DIR, "kiro-auth-token.json");
+    SSO_CACHE_DIR = join4(homedir3(), ".aws", "sso", "cache");
+    KIRO_IDE_TOKEN_PATH = join4(SSO_CACHE_DIR, "kiro-auth-token.json");
   }
 });
 
@@ -794,6 +1236,13 @@ async function refreshKiroTokenInternal(credentials) {
   }
 }
 async function refreshKiroTokenDirect(credentials) {
+  const { runKiroOp: runKiroOp2 } = await Promise.resolve().then(() => (init_engine_ops(), engine_ops_exports));
+  return runKiroOp2("refreshToken", () => ({ credentials }), () => refreshKiroTokenDirectInProcess(credentials));
+}
+function endpointFromEnv(name, fallback, region) {
+  return (process.env[name]?.trim() || fallback).replaceAll("{region}", region);
+}
+async function refreshKiroTokenDirectInProcess(credentials) {
   const parts = credentials.refresh.split("|");
   const refreshToken = parts[0] ?? "";
   const authMethod = parts[parts.length - 1] ?? "idc";
@@ -801,7 +1250,7 @@ async function refreshKiroTokenDirect(credentials) {
   if (authMethod === "apikey")
     return credentials;
   if (authMethod === "desktop") {
-    const url = KIRO_DESKTOP_REFRESH_URL.replace("{region}", region);
+    const url = endpointFromEnv(KIRO_DESKTOP_REFRESH_ENDPOINT_ENV, KIRO_DESKTOP_REFRESH_URL, region);
     const response2 = await fetch(url, {
       method: "POST",
       headers: { "Content-Type": "application/json", "User-Agent": KIRO_DESKTOP_USER_AGENT },
@@ -861,7 +1310,7 @@ async function refreshKiroTokenDirect(credentials) {
   }
   const clientId = parts[1] ?? "";
   const clientSecret = parts[2] ?? "";
-  const ssoEndpoint = `https://oidc.${region}.amazonaws.com`;
+  const ssoEndpoint = endpointFromEnv(KIRO_OIDC_ENDPOINT_ENV, "https://oidc.{region}.amazonaws.com", region);
   const response = await fetch(`${ssoEndpoint}/token`, {
     method: "POST",
     headers: { "Content-Type": "application/json", ...kiroUserAgent("ssooidc", "E") },
@@ -909,7 +1358,7 @@ async function resolveKiroCredentials() {
     throw lastFailure;
   return void 0;
 }
-var KIRO_DESKTOP_REFRESH_URL, EXPIRES_BUFFER_MS, KIRO_DESKTOP_USER_AGENT, AUTH_SOURCE_ENV;
+var KIRO_DESKTOP_REFRESH_URL, EXPIRES_BUFFER_MS, KIRO_DESKTOP_USER_AGENT, AUTH_SOURCE_ENV, KIRO_DESKTOP_REFRESH_ENDPOINT_ENV, KIRO_OIDC_ENDPOINT_ENV;
 var init_oauth = __esm({
   "../kiro-core/dist/oauth.js"() {
     "use strict";
@@ -920,6 +1369,8 @@ var init_oauth = __esm({
     EXPIRES_BUFFER_MS = 5 * 60 * 1e3;
     KIRO_DESKTOP_USER_AGENT = "Kiro-Desktop/0.2.13 (darwin; arm64)";
     AUTH_SOURCE_ENV = "KIRO_AUTH_SOURCE";
+    KIRO_DESKTOP_REFRESH_ENDPOINT_ENV = "KIRO_DESKTOP_REFRESH_ENDPOINT";
+    KIRO_OIDC_ENDPOINT_ENV = "KIRO_OIDC_ENDPOINT";
   }
 });
 
@@ -1035,6 +1486,32 @@ async function parseManagementResponse(response, operation, region) {
     throw new Error(`Kiro management ${operation} returned invalid JSON in ${region}`, { cause: error2 });
   }
 }
+function snapshotKiroProfileArnCache() {
+  return Object.fromEntries(profileArnCache);
+}
+function snapshotKiroProfileRegionCache() {
+  return Object.fromEntries(profileRegionCache);
+}
+function applyKiroProfileRegionChanges(regions) {
+  if (!regions)
+    return;
+  for (const [key, region] of Object.entries(regions))
+    if (typeof region === "string" && region)
+      profileRegionCache.set(key, region);
+}
+function applyKiroProfileArnCacheChanges(changes) {
+  if (!changes)
+    return;
+  for (const [key, arn] of Object.entries(changes)) {
+    if (typeof arn === "string" && arn) {
+      profileArnCache.set(key, arn);
+    } else {
+      profileArnCache.delete(key);
+      profileRegionCache.delete(key);
+      pendingProfileRequests.delete(key);
+    }
+  }
+}
 function invalidateKiroProfileArn(auth) {
   const key = profileCacheKey(auth);
   profileArnCache.delete(key);
@@ -1188,12 +1665,13 @@ __export(models_exports, {
   mapKiroCatalogModels: () => mapKiroCatalogModels,
   resolveApiRegion: () => resolveApiRegion,
   resolveKiroModel: () => resolveKiroModel,
-  updateKiroModelsCache: () => updateKiroModelsCache
+  updateKiroModelsCache: () => updateKiroModelsCache,
+  updateKiroModelsCacheInProcess: () => updateKiroModelsCacheInProcess
 });
 import { randomUUID } from "node:crypto";
-import { existsSync as existsSync3, readFileSync as readFileSync2, renameSync, rmSync, writeFileSync } from "node:fs";
+import { existsSync as existsSync4, readFileSync as readFileSync2, renameSync, rmSync, writeFileSync } from "node:fs";
 import { homedir as homedir4 } from "node:os";
-import { join as join4 } from "node:path";
+import { join as join5 } from "node:path";
 function isRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -1245,7 +1723,7 @@ function parseManagementCache(raw) {
   };
 }
 function readManagementCache() {
-  if (!existsSync3(KIRO_MANAGEMENT_CACHE_PATH))
+  if (!existsSync4(KIRO_MANAGEMENT_CACHE_PATH))
     return void 0;
   try {
     return parseManagementCache(readFileSync2(KIRO_MANAGEMENT_CACHE_PATH, "utf-8"));
@@ -1380,6 +1858,25 @@ function isCacheStale(region) {
   return !entry || Date.now() - entry.fetchedAt > CACHE_MAX_AGE_MS;
 }
 async function updateKiroModelsCache(accessToken, region, profileArn) {
+  const { runKiroOp: runKiroOp2 } = await Promise.resolve().then(() => (init_engine_ops(), engine_ops_exports));
+  await runKiroOp2("refreshModels", () => ({
+    accessToken,
+    region,
+    ...profileArn ? { profileArn } : {},
+    known: kiroModels.map((model) => ({
+      id: model.id,
+      name: model.name,
+      input: model.input,
+      ...model.firstTokenTimeout ? { firstTokenTimeout: model.firstTokenTimeout } : {}
+    })),
+    cachePath: KIRO_MANAGEMENT_CACHE_PATH
+  }), async () => {
+    await updateKiroModelsCacheInProcess(accessToken, region, profileArn);
+    return {};
+  });
+  refreshKnownModelIds(readManagementCache());
+}
+async function updateKiroModelsCacheInProcess(accessToken, region, profileArn) {
   const response = await fetchKiroModelCatalog({ accessToken, region }, profileArn);
   const models = mapKiroCatalogModels(response.models, region, getKiroCliModelRates());
   const cache = readManagementCache() ?? {
@@ -1420,7 +1917,7 @@ var init_models = __esm({
     init_endpoints();
     KIRO_MANAGEMENT_CACHE_VERSION = 1;
     KIRO_MANAGEMENT_CACHE_SOURCE = "ns-kiro-provider-management";
-    KIRO_MANAGEMENT_CACHE_PATH = join4(homedir4(), ".ns-kiro-provider-models-cache.json");
+    KIRO_MANAGEMENT_CACHE_PATH = join5(homedir4(), ".ns-kiro-provider-models-cache.json");
     CACHE_MAX_AGE_MS = 36e5;
     DEFAULT_CONTEXT_WINDOW = 2e5;
     DEFAULT_MAX_TOKENS = 8192;
@@ -1642,85 +2139,305 @@ var init_models = __esm({
   }
 });
 
-// ../../node_modules/.pnpm/base64-js@1.5.1/node_modules/base64-js/index.js
-var require_base64_js = __commonJS({
-  "../../node_modules/.pnpm/base64-js@1.5.1/node_modules/base64-js/index.js"(exports) {
-    "use strict";
-    exports.byteLength = byteLength;
-    exports.toByteArray = toByteArray;
-    exports.fromByteArray = fromByteArray;
-    var lookup = [];
-    var revLookup = [];
-    var Arr = typeof Uint8Array !== "undefined" ? Uint8Array : Array;
-    var code = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
-    for (i = 0, len = code.length; i < len; ++i) {
-      lookup[i] = code[i];
-      revLookup[code.charCodeAt(i)] = i;
-    }
-    var i;
-    var len;
-    revLookup["-".charCodeAt(0)] = 62;
-    revLookup["_".charCodeAt(0)] = 63;
-    function getLens(b64) {
-      var len2 = b64.length;
-      if (len2 % 4 > 0) {
-        throw new Error("Invalid string. Length must be a multiple of 4");
-      }
-      var validLen = b64.indexOf("=");
-      if (validLen === -1) validLen = len2;
-      var placeHoldersLen = validLen === len2 ? 0 : 4 - validLen % 4;
-      return [validLen, placeHoldersLen];
-    }
-    function byteLength(b64) {
-      var lens = getLens(b64);
-      var validLen = lens[0];
-      var placeHoldersLen = lens[1];
-      return (validLen + placeHoldersLen) * 3 / 4 - placeHoldersLen;
-    }
-    function _byteLength(b64, validLen, placeHoldersLen) {
-      return (validLen + placeHoldersLen) * 3 / 4 - placeHoldersLen;
-    }
-    function toByteArray(b64) {
-      var tmp;
-      var lens = getLens(b64);
-      var validLen = lens[0];
-      var placeHoldersLen = lens[1];
-      var arr = new Arr(_byteLength(b64, validLen, placeHoldersLen));
-      var curByte = 0;
-      var len2 = placeHoldersLen > 0 ? validLen - 4 : validLen;
-      var i2;
-      for (i2 = 0; i2 < len2; i2 += 4) {
-        tmp = revLookup[b64.charCodeAt(i2)] << 18 | revLookup[b64.charCodeAt(i2 + 1)] << 12 | revLookup[b64.charCodeAt(i2 + 2)] << 6 | revLookup[b64.charCodeAt(i2 + 3)];
-        arr[curByte++] = tmp >> 16 & 255;
-        arr[curByte++] = tmp >> 8 & 255;
-        arr[curByte++] = tmp & 255;
-      }
-      if (placeHoldersLen === 2) {
-        tmp = revLookup[b64.charCodeAt(i2)] << 2 | revLookup[b64.charCodeAt(i2 + 1)] >> 4;
-        arr[curByte++] = tmp & 255;
-      }
-      if (placeHoldersLen === 1) {
-        tmp = revLookup[b64.charCodeAt(i2)] << 10 | revLookup[b64.charCodeAt(i2 + 1)] << 4 | revLookup[b64.charCodeAt(i2 + 2)] >> 2;
-        arr[curByte++] = tmp >> 8 & 255;
-        arr[curByte++] = tmp & 255;
-      }
-      return arr;
-    }
-    function tripletToBase64(num2) {
-      return lookup[num2 >> 18 & 63] + lookup[num2 >> 12 & 63] + lookup[num2 >> 6 & 63] + lookup[num2 & 63];
-    }
-    function encodeChunk(uint8, start, end) {
-      var tmp;
-      var output = [];
-      for (var i2 = start; i2 < end; i2 += 3) {
-        tmp = (uint8[i2] << 16 & 16711680) + (uint8[i2 + 1] << 8 & 65280) + (uint8[i2 + 2] & 255);
-        output.push(tripletToBase64(tmp));
+// ../kiro-core/dist/retry.js
+function firstTokenTimeoutForModel(modelId) {
+  if (retryConfig.firstTokenTimeoutMs !== FIRST_TOKEN_TIMEOUT) {
+    return retryConfig.firstTokenTimeoutMs;
+  }
+  const model = kiroModels.find((m) => m.id === modelId);
+  return model?.firstTokenTimeout ?? FIRST_TOKEN_TIMEOUT;
+}
+function exponentialBackoff(attempt, baseMs, maxMs) {
+  return Math.min(baseMs * 2 ** attempt, maxMs);
+}
+function extractKiroReason(errorText) {
+  if (!errorText)
+    return void 0;
+  try {
+    const parsed = JSON.parse(errorText);
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+      return void 0;
+    const reason = parsed.reason;
+    return typeof reason === "string" && reason.length > 0 ? reason : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function parseRetryAfterMs(headers, nowMs = Date.now()) {
+  const get = headers?.get?.bind(headers);
+  if (!get)
+    return void 0;
+  const milliseconds = nonNegativeNumber(get("retry-after-ms"));
+  if (milliseconds !== void 0)
+    return Math.round(milliseconds);
+  const retryAfter = get("retry-after");
+  if (retryAfter !== null && retryAfter.trim() !== "") {
+    const seconds = Number(retryAfter);
+    if (Number.isFinite(seconds)) {
+      if (seconds >= 0) {
+        const delayMs = seconds * 1e3;
+        if (Number.isFinite(delayMs))
+          return Math.round(delayMs);
       }
-      return output.join("");
+    } else {
+      const dateMs = Date.parse(retryAfter);
+      if (!Number.isNaN(dateMs))
+        return Math.max(0, dateMs - nowMs);
     }
-    function fromByteArray(uint8) {
-      var tmp;
-      var len2 = uint8.length;
+  }
+  const resetAfterSeconds = nonNegativeNumber(get("x-ratelimit-reset-after"));
+  if (resetAfterSeconds !== void 0) {
+    const delayMs = resetAfterSeconds * 1e3;
+    if (Number.isFinite(delayMs))
+      return Math.round(delayMs);
+  }
+  return void 0;
+}
+function resolveRequestRateRetryDelay(headers, nowMs = Date.now()) {
+  const advertisedDelayMs = parseRetryAfterMs(headers, nowMs);
+  const requestedDelayMs = advertisedDelayMs ?? REQUEST_RATE_FALLBACK_DELAY_MS;
+  return {
+    delayMs: Math.min(requestedDelayMs, MAX_RETRY_DELAY),
+    ...advertisedDelayMs !== void 0 ? { advertisedDelayMs } : {},
+    capped: requestedDelayMs > MAX_RETRY_DELAY
+  };
+}
+function nonNegativeNumber(value) {
+  if (value === null || value.trim() === "")
+    return void 0;
+  const parsed = Number(value);
+  return Number.isFinite(parsed) && parsed >= 0 ? parsed : void 0;
+}
+function isTooBigError(status, errorText) {
+  return status === 413 || status === 400 && TOO_BIG_PATTERNS.some((p) => errorText.includes(p));
+}
+function isNonRetryableBodyError(errorText) {
+  return NON_RETRYABLE_BODY_PATTERNS.some((p) => errorText.includes(p));
+}
+function isCapacityError(errorText) {
+  return errorText.includes(CAPACITY_PATTERN);
+}
+var FIRST_TOKEN_TIMEOUT, REQUEST_HEADER_TIMEOUT, retryConfig, MAX_RETRY_DELAY, REQUEST_RATE_FALLBACK_DELAY_MS, KIRO_REASON_CODES, TOO_BIG_PATTERNS, NON_RETRYABLE_BODY_PATTERNS, CAPACITY_PATTERN, CAPACITY_MAX_RETRIES, CAPACITY_BASE_DELAY_MS, capacityRetryConfig;
+var init_retry = __esm({
+  "../kiro-core/dist/retry.js"() {
+    "use strict";
+    init_models();
+    FIRST_TOKEN_TIMEOUT = 9e4;
+    REQUEST_HEADER_TIMEOUT = 9e4;
+    retryConfig = {
+      firstTokenTimeoutMs: FIRST_TOKEN_TIMEOUT,
+      requestHeaderTimeoutMs: REQUEST_HEADER_TIMEOUT
+    };
+    MAX_RETRY_DELAY = 1e4;
+    REQUEST_RATE_FALLBACK_DELAY_MS = 1e4;
+    KIRO_REASON_CODES = Object.freeze({
+      /** Request body exceeded the service's size threshold. */
+      CONTENT_LENGTH_EXCEEDS_THRESHOLD: "CONTENT_LENGTH_EXCEEDS_THRESHOLD",
+      /** Prose-only size rejection; the service sends no reason code for this one. */
+      INPUT_TOO_LONG: "Input is too long",
+      /** Monthly request quota exhausted — hard limit, not transient. */
+      MONTHLY_REQUEST_COUNT: "MONTHLY_REQUEST_COUNT",
+      /** Model capacity temporarily unavailable — transient, worth retrying. */
+      INSUFFICIENT_MODEL_CAPACITY: "INSUFFICIENT_MODEL_CAPACITY",
+      /** Short-window request throttle — retry only within the provider budget. */
+      USER_REQUEST_RATE_EXCEEDED: "USER_REQUEST_RATE_EXCEEDED",
+      /**
+       * Generic request-validation rejection, returned for a malformed body of any
+       * size (empty `content`, history referencing tools absent from the catalog).
+       * Not a size signal: classifying it as "too big" makes the caller compact a
+       * history that was never the problem, a loop it can never satisfy.
+       */
+      REQUEST_BODY_INVALID: "REQUEST_BODY_INVALID"
+    });
+    TOO_BIG_PATTERNS = Object.freeze([
+      KIRO_REASON_CODES.CONTENT_LENGTH_EXCEEDS_THRESHOLD,
+      KIRO_REASON_CODES.INPUT_TOO_LONG
+    ]);
+    NON_RETRYABLE_BODY_PATTERNS = Object.freeze([KIRO_REASON_CODES.MONTHLY_REQUEST_COUNT]);
+    CAPACITY_PATTERN = KIRO_REASON_CODES.INSUFFICIENT_MODEL_CAPACITY;
+    CAPACITY_MAX_RETRIES = 3;
+    CAPACITY_BASE_DELAY_MS = 5e3;
+    capacityRetryConfig = {
+      maxRetries: CAPACITY_MAX_RETRIES,
+      baseDelayMs: CAPACITY_BASE_DELAY_MS
+    };
+  }
+});
+
+// ../kiro-core/dist/errors.js
+function extractKiroReasonCode(errorText) {
+  if (!errorText)
+    return void 0;
+  const trimmed = errorText.trim();
+  if (trimmed.startsWith("{")) {
+    try {
+      const parsed = JSON.parse(trimmed);
+      const reason = parsed.reason ?? parsed.reasonCode;
+      if (typeof reason === "string" && reason.length > 0)
+        return reason;
+    } catch {
+    }
+  }
+  return REASON_CODE_MARKERS.find((code) => errorText.includes(code));
+}
+var REASON_CODE_MARKERS, KiroApiError;
+var init_errors2 = __esm({
+  "../kiro-core/dist/errors.js"() {
+    "use strict";
+    init_retry();
+    init_retry();
+    REASON_CODE_MARKERS = [
+      KIRO_REASON_CODES.CONTENT_LENGTH_EXCEEDS_THRESHOLD,
+      KIRO_REASON_CODES.MONTHLY_REQUEST_COUNT,
+      KIRO_REASON_CODES.INSUFFICIENT_MODEL_CAPACITY,
+      KIRO_REASON_CODES.REQUEST_BODY_INVALID
+    ];
+    KiroApiError = class extends Error {
+      status;
+      reasonCode;
+      retryAfterMs;
+      providerAttempts;
+      constructor(message, status, reasonCode, retryAfterMs, providerAttempts) {
+        super(message);
+        this.status = status;
+        this.reasonCode = reasonCode;
+        this.retryAfterMs = retryAfterMs;
+        this.providerAttempts = providerAttempts;
+        this.name = "KiroApiError";
+      }
+    };
+  }
+});
+
+// ../kiro-core/dist/engine-ops.js
+var engine_ops_exports = {};
+__export(engine_ops_exports, {
+  kiroErrorFromSidecar: () => kiroErrorFromSidecar,
+  runKiroOp: () => runKiroOp
+});
+function kiroErrorFromSidecar(error2) {
+  switch (error2.vendorError) {
+    case "KiroApiError":
+      return new KiroApiError(error2.message, error2.status ?? 0, error2.reasonCode, error2.retryAfterMs, error2.providerAttempts);
+    case "KiroManagementHttpError":
+      return new KiroManagementHttpError(error2.message, error2.status ?? 0);
+    case "Error":
+      return new Error(error2.message);
+    default:
+      return error2;
+  }
+}
+async function runKiroOp(op, request, inProcess) {
+  let ranInProcess = false;
+  const result = await engineCall({
+    vendor: "kiro",
+    op,
+    request: () => ({
+      ...request(),
+      profileArnCache: snapshotKiroProfileArnCache(),
+      profileRegions: snapshotKiroProfileRegionCache()
+    }),
+    inProcess: async () => {
+      ranInProcess = true;
+      return await inProcess();
+    },
+    mapError: kiroErrorFromSidecar
+  });
+  if (ranInProcess || !result || typeof result !== "object")
+    return result;
+  const { kiroProfileArns, kiroProfileRegions, ...rest } = result;
+  applyKiroProfileArnCacheChanges(kiroProfileArns);
+  applyKiroProfileRegionChanges(kiroProfileRegions);
+  return rest;
+}
+var init_engine_ops = __esm({
+  "../kiro-core/dist/engine-ops.js"() {
+    "use strict";
+    init_sidecar();
+    init_errors2();
+    init_management();
+  }
+});
+
+// ../../node_modules/.pnpm/base64-js@1.5.1/node_modules/base64-js/index.js
+var require_base64_js = __commonJS({
+  "../../node_modules/.pnpm/base64-js@1.5.1/node_modules/base64-js/index.js"(exports) {
+    "use strict";
+    exports.byteLength = byteLength;
+    exports.toByteArray = toByteArray;
+    exports.fromByteArray = fromByteArray;
+    var lookup = [];
+    var revLookup = [];
+    var Arr = typeof Uint8Array !== "undefined" ? Uint8Array : Array;
+    var code = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+    for (i = 0, len = code.length; i < len; ++i) {
+      lookup[i] = code[i];
+      revLookup[code.charCodeAt(i)] = i;
+    }
+    var i;
+    var len;
+    revLookup["-".charCodeAt(0)] = 62;
+    revLookup["_".charCodeAt(0)] = 63;
+    function getLens(b64) {
+      var len2 = b64.length;
+      if (len2 % 4 > 0) {
+        throw new Error("Invalid string. Length must be a multiple of 4");
+      }
+      var validLen = b64.indexOf("=");
+      if (validLen === -1) validLen = len2;
+      var placeHoldersLen = validLen === len2 ? 0 : 4 - validLen % 4;
+      return [validLen, placeHoldersLen];
+    }
+    function byteLength(b64) {
+      var lens = getLens(b64);
+      var validLen = lens[0];
+      var placeHoldersLen = lens[1];
+      return (validLen + placeHoldersLen) * 3 / 4 - placeHoldersLen;
+    }
+    function _byteLength(b64, validLen, placeHoldersLen) {
+      return (validLen + placeHoldersLen) * 3 / 4 - placeHoldersLen;
+    }
+    function toByteArray(b64) {
+      var tmp;
+      var lens = getLens(b64);
+      var validLen = lens[0];
+      var placeHoldersLen = lens[1];
+      var arr = new Arr(_byteLength(b64, validLen, placeHoldersLen));
+      var curByte = 0;
+      var len2 = placeHoldersLen > 0 ? validLen - 4 : validLen;
+      var i2;
+      for (i2 = 0; i2 < len2; i2 += 4) {
+        tmp = revLookup[b64.charCodeAt(i2)] << 18 | revLookup[b64.charCodeAt(i2 + 1)] << 12 | revLookup[b64.charCodeAt(i2 + 2)] << 6 | revLookup[b64.charCodeAt(i2 + 3)];
+        arr[curByte++] = tmp >> 16 & 255;
+        arr[curByte++] = tmp >> 8 & 255;
+        arr[curByte++] = tmp & 255;
+      }
+      if (placeHoldersLen === 2) {
+        tmp = revLookup[b64.charCodeAt(i2)] << 2 | revLookup[b64.charCodeAt(i2 + 1)] >> 4;
+        arr[curByte++] = tmp & 255;
+      }
+      if (placeHoldersLen === 1) {
+        tmp = revLookup[b64.charCodeAt(i2)] << 10 | revLookup[b64.charCodeAt(i2 + 1)] << 4 | revLookup[b64.charCodeAt(i2 + 2)] >> 2;
+        arr[curByte++] = tmp >> 8 & 255;
+        arr[curByte++] = tmp & 255;
+      }
+      return arr;
+    }
+    function tripletToBase64(num2) {
+      return lookup[num2 >> 18 & 63] + lookup[num2 >> 12 & 63] + lookup[num2 >> 6 & 63] + lookup[num2 & 63];
+    }
+    function encodeChunk(uint8, start, end) {
+      var tmp;
+      var output = [];
+      for (var i2 = start; i2 < end; i2 += 3) {
+        tmp = (uint8[i2] << 16 & 16711680) + (uint8[i2 + 1] << 8 & 65280) + (uint8[i2 + 2] & 255);
+        output.push(tripletToBase64(tmp));
+      }
+      return output.join("");
+    }
+    function fromByteArray(uint8) {
+      var tmp;
+      var len2 = uint8.length;
       var extraBytes = len2 % 3;
       var parts = [];
       var maxChunkLength = 16383;
@@ -1958,365 +2675,139 @@ init_debug();
 init_effort();
 init_endpoints();
 
-// ../kiro-core/dist/retry.js
+// ../kiro-core/dist/engine.js
+init_sidecar();
+init_debug();
+init_endpoints();
+init_engine_ops();
+init_management();
 init_models();
-var FIRST_TOKEN_TIMEOUT = 9e4;
-var REQUEST_HEADER_TIMEOUT = 9e4;
-function firstTokenTimeoutForModel(modelId) {
-  if (retryConfig.firstTokenTimeoutMs !== FIRST_TOKEN_TIMEOUT) {
-    return retryConfig.firstTokenTimeoutMs;
-  }
-  const model = kiroModels.find((m) => m.id === modelId);
-  return model?.firstTokenTimeout ?? FIRST_TOKEN_TIMEOUT;
-}
-var retryConfig = {
-  firstTokenTimeoutMs: FIRST_TOKEN_TIMEOUT,
-  requestHeaderTimeoutMs: REQUEST_HEADER_TIMEOUT
-};
-function exponentialBackoff(attempt, baseMs, maxMs) {
-  return Math.min(baseMs * 2 ** attempt, maxMs);
-}
-var MAX_RETRY_DELAY = 1e4;
-var REQUEST_RATE_FALLBACK_DELAY_MS = 1e4;
-function extractKiroReason(errorText) {
-  if (!errorText)
-    return void 0;
-  try {
-    const parsed = JSON.parse(errorText);
-    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
-      return void 0;
-    const reason = parsed.reason;
-    return typeof reason === "string" && reason.length > 0 ? reason : void 0;
-  } catch {
-    return void 0;
+init_retry();
+
+// ../kiro-core/dist/stream.js
+import { createHash as createHash3 } from "node:crypto";
+init_debug();
+init_effort();
+init_endpoints();
+init_errors2();
+init_kiro_cli();
+init_management();
+init_models();
+init_oauth();
+
+// ../kiro-core/dist/request-builder.js
+init_debug();
+
+// ../kiro-core/dist/history.js
+var HISTORY_LIMIT = 85e4;
+var HISTORY_LIMIT_CONTEXT_WINDOW = 2e5;
+var HISTORY_IMAGE_BASE64_LIMIT = 512 * 1024;
+function stripHistoryImages(history, keepNewestBounded = true) {
+  let newestImageIndex = -1;
+  for (let index = history.length - 1; index >= 0; index--) {
+    if ((history[index]?.userInputMessage?.images?.length ?? 0) > 0) {
+      newestImageIndex = index;
+      break;
+    }
   }
+  const newestImages = newestImageIndex >= 0 ? history[newestImageIndex]?.userInputMessage?.images : void 0;
+  const keepNewest = keepNewestBounded && newestImages !== void 0 && newestImages.reduce((size, image) => size + image.source.bytes.length, 0) <= HISTORY_IMAGE_BASE64_LIMIT;
+  return history.map((entry, index) => {
+    if (!entry.userInputMessage?.images || index === newestImageIndex && keepNewest)
+      return entry;
+    const { images: _images, ...rest } = entry.userInputMessage;
+    return { ...entry, userInputMessage: { ...rest } };
+  });
 }
-function parseRetryAfterMs(headers, nowMs = Date.now()) {
-  const get = headers?.get?.bind(headers);
-  if (!get)
-    return void 0;
-  const milliseconds = nonNegativeNumber(get("retry-after-ms"));
-  if (milliseconds !== void 0)
-    return Math.round(milliseconds);
-  const retryAfter = get("retry-after");
-  if (retryAfter !== null && retryAfter.trim() !== "") {
-    const seconds = Number(retryAfter);
-    if (Number.isFinite(seconds)) {
-      if (seconds >= 0) {
-        const delayMs = seconds * 1e3;
-        if (Number.isFinite(delayMs))
-          return Math.round(delayMs);
-      }
+function sanitizeHistory(history) {
+  while (history.length > 0 && (!history[0]?.userInputMessage || history[0].userInputMessage.userInputMessageContext?.toolResults))
+    history = history.slice(1);
+  const result = [];
+  for (let i = 0; i < history.length; i++) {
+    const m = history[i];
+    if (!m)
+      continue;
+    if (m.assistantResponseMessage && !m.assistantResponseMessage.toolUses && !m.assistantResponseMessage.content)
+      continue;
+    if (m.assistantResponseMessage?.toolUses) {
+      const next = history[i + 1];
+      if (next?.userInputMessage?.userInputMessageContext?.toolResults)
+        result.push(m);
+    } else if (m.userInputMessage?.userInputMessageContext?.toolResults) {
+      const prev = result[result.length - 1];
+      if (prev?.assistantResponseMessage?.toolUses)
+        result.push(m);
     } else {
-      const dateMs = Date.parse(retryAfter);
-      if (!Number.isNaN(dateMs))
-        return Math.max(0, dateMs - nowMs);
+      result.push(m);
     }
   }
-  const resetAfterSeconds = nonNegativeNumber(get("x-ratelimit-reset-after"));
-  if (resetAfterSeconds !== void 0) {
-    const delayMs = resetAfterSeconds * 1e3;
-    if (Number.isFinite(delayMs))
-      return Math.round(delayMs);
-  }
-  return void 0;
-}
-function resolveRequestRateRetryDelay(headers, nowMs = Date.now()) {
-  const advertisedDelayMs = parseRetryAfterMs(headers, nowMs);
-  const requestedDelayMs = advertisedDelayMs ?? REQUEST_RATE_FALLBACK_DELAY_MS;
-  return {
-    delayMs: Math.min(requestedDelayMs, MAX_RETRY_DELAY),
-    ...advertisedDelayMs !== void 0 ? { advertisedDelayMs } : {},
-    capped: requestedDelayMs > MAX_RETRY_DELAY
-  };
-}
-function nonNegativeNumber(value) {
-  if (value === null || value.trim() === "")
-    return void 0;
-  const parsed = Number(value);
-  return Number.isFinite(parsed) && parsed >= 0 ? parsed : void 0;
-}
-var KIRO_REASON_CODES = Object.freeze({
-  /** Request body exceeded the service's size threshold. */
-  CONTENT_LENGTH_EXCEEDS_THRESHOLD: "CONTENT_LENGTH_EXCEEDS_THRESHOLD",
-  /** Prose-only size rejection; the service sends no reason code for this one. */
-  INPUT_TOO_LONG: "Input is too long",
-  /** Monthly request quota exhausted — hard limit, not transient. */
-  MONTHLY_REQUEST_COUNT: "MONTHLY_REQUEST_COUNT",
-  /** Model capacity temporarily unavailable — transient, worth retrying. */
-  INSUFFICIENT_MODEL_CAPACITY: "INSUFFICIENT_MODEL_CAPACITY",
-  /** Short-window request throttle — retry only within the provider budget. */
-  USER_REQUEST_RATE_EXCEEDED: "USER_REQUEST_RATE_EXCEEDED",
-  /**
-   * Generic request-validation rejection, returned for a malformed body of any
-   * size (empty `content`, history referencing tools absent from the catalog).
-   * Not a size signal: classifying it as "too big" makes the caller compact a
-   * history that was never the problem, a loop it can never satisfy.
-   */
-  REQUEST_BODY_INVALID: "REQUEST_BODY_INVALID"
-});
-var TOO_BIG_PATTERNS = Object.freeze([
-  KIRO_REASON_CODES.CONTENT_LENGTH_EXCEEDS_THRESHOLD,
-  KIRO_REASON_CODES.INPUT_TOO_LONG
-]);
-var NON_RETRYABLE_BODY_PATTERNS = Object.freeze([KIRO_REASON_CODES.MONTHLY_REQUEST_COUNT]);
-var CAPACITY_PATTERN = KIRO_REASON_CODES.INSUFFICIENT_MODEL_CAPACITY;
-var CAPACITY_MAX_RETRIES = 3;
-var CAPACITY_BASE_DELAY_MS = 5e3;
-var capacityRetryConfig = {
-  maxRetries: CAPACITY_MAX_RETRIES,
-  baseDelayMs: CAPACITY_BASE_DELAY_MS
-};
-function isTooBigError(status, errorText) {
-  return status === 413 || status === 400 && TOO_BIG_PATTERNS.some((p) => errorText.includes(p));
-}
-function isNonRetryableBodyError(errorText) {
-  return NON_RETRYABLE_BODY_PATTERNS.some((p) => errorText.includes(p));
-}
-function isCapacityError(errorText) {
-  return errorText.includes(CAPACITY_PATTERN);
+  return result;
 }
-
-// ../kiro-core/dist/errors.js
-var REASON_CODE_MARKERS = [
-  KIRO_REASON_CODES.CONTENT_LENGTH_EXCEEDS_THRESHOLD,
-  KIRO_REASON_CODES.MONTHLY_REQUEST_COUNT,
-  KIRO_REASON_CODES.INSUFFICIENT_MODEL_CAPACITY,
-  KIRO_REASON_CODES.REQUEST_BODY_INVALID
-];
-var KiroApiError = class extends Error {
-  status;
-  reasonCode;
-  retryAfterMs;
-  providerAttempts;
-  constructor(message, status, reasonCode, retryAfterMs, providerAttempts) {
-    super(message);
-    this.status = status;
-    this.reasonCode = reasonCode;
-    this.retryAfterMs = retryAfterMs;
-    this.providerAttempts = providerAttempts;
-    this.name = "KiroApiError";
-  }
-};
-function extractKiroReasonCode(errorText) {
-  if (!errorText)
-    return void 0;
-  const trimmed = errorText.trim();
-  if (trimmed.startsWith("{")) {
-    try {
-      const parsed = JSON.parse(trimmed);
-      const reason = parsed.reason ?? parsed.reasonCode;
-      if (typeof reason === "string" && reason.length > 0)
-        return reason;
-    } catch {
+function injectSyntheticToolCalls(history) {
+  const validIds = /* @__PURE__ */ new Set();
+  for (const entry of history) {
+    for (const tu of entry.assistantResponseMessage?.toolUses ?? []) {
+      if (tu.toolUseId)
+        validIds.add(tu.toolUseId);
     }
   }
-  return REASON_CODE_MARKERS.find((code) => errorText.includes(code));
-}
-
-// ../kiro-core/dist/event-parser.js
-var KIRO_EVENT_KEYS = [
-  "assistantResponseEvent",
-  "codeReferenceEvent",
-  "contextUsageEvent",
-  "documentCitationEvent",
-  "error",
-  "metadataEvent",
-  "meteringEvent",
-  "reasoningContentEvent",
-  "serviceUnavailableError",
-  "throttlingError",
-  "toolResultEvent",
-  "toolUseEvent",
-  "validationError"
-];
-var KIRO_EVENT_KEY_SET = new Set(KIRO_EVENT_KEYS);
-var KIRO_ERROR_MEMBERS = {
-  error: { kind: "internalServer", exception: "InternalServerException" },
-  throttlingError: { kind: "throttling", exception: "ThrottlingException" },
-  validationError: { kind: "validation", exception: "ValidationException" },
-  serviceUnavailableError: { kind: "serviceUnavailable", exception: "ServiceUnavailableException" }
-};
-var KIRO_ERROR_TOKENS = {
-  ...KIRO_ERROR_MEMBERS,
-  InternalServerException: KIRO_ERROR_MEMBERS.error,
-  ThrottlingException: KIRO_ERROR_MEMBERS.throttlingError,
-  ValidationException: KIRO_ERROR_MEMBERS.validationError,
-  ServiceUnavailableException: KIRO_ERROR_MEMBERS.serviceUnavailableError
-};
-function lookupKiroErrorMember(key) {
-  return Object.hasOwn(KIRO_ERROR_TOKENS, key) ? KIRO_ERROR_TOKENS[key] : void 0;
-}
-var num = (v) => typeof v === "number" ? v : void 0;
-var str = (v) => typeof v === "string" ? v : void 0;
-function tokenCount(value) {
-  return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : void 0;
-}
-function firstTokenCount(source, keys) {
-  for (const key of keys) {
-    const count = tokenCount(source[key]);
-    if (count !== void 0)
-      return count;
-  }
-  return void 0;
-}
-var CACHE_READ_KEYS = ["cacheReadInputTokens", "cache_read_input_tokens", "cacheReadTokens"];
-var CACHE_WRITE_KEYS = [
-  "cacheWriteInputTokens",
-  "cache_creation_input_tokens",
-  "cacheCreationInputTokens",
-  "cacheWriteTokens"
-];
-function toolInput(raw) {
-  if (typeof raw === "string")
-    return raw;
-  if (raw && typeof raw === "object" && Object.keys(raw).length > 0) {
-    return JSON.stringify(raw);
-  }
-  return "";
-}
-function parseToolUse(parsed) {
-  if (parsed.name && parsed.toolUseId) {
-    return {
-      type: "toolUse",
-      data: {
-        name: parsed.name,
-        toolUseId: parsed.toolUseId,
-        input: toolInput(parsed.input),
-        stop: parsed.stop
+  const result = [];
+  for (const entry of history) {
+    const toolResults = entry.userInputMessage?.userInputMessageContext?.toolResults;
+    if (toolResults) {
+      const orphaned = toolResults.filter((tr) => !validIds.has(tr.toolUseId));
+      if (orphaned.length > 0) {
+        result.push({
+          assistantResponseMessage: {
+            content: "Tool calls were made.",
+            toolUses: orphaned.map((tr) => ({ name: "unknown_tool", toolUseId: tr.toolUseId, input: {} }))
+          }
+        });
+        for (const tr of orphaned)
+          validIds.add(tr.toolUseId);
       }
-    };
-  }
-  if (parsed.input !== void 0) {
-    return { type: "toolUseInput", data: { input: toolInput(parsed.input) } };
+    }
+    result.push(entry);
   }
-  if (parsed.stop !== void 0)
-    return { type: "toolUseStop", data: { stop: parsed.stop } };
-  return null;
+  return result;
 }
-function parseMetadata(parsed) {
-  const tu = parsed.tokenUsage ?? {};
-  const data = {
-    inputTokens: tokenCount(tu.uncachedInputTokens) ?? tokenCount(tu.inputTokens),
-    outputTokens: tokenCount(tu.outputTokens),
-    totalTokens: tokenCount(tu.totalTokens),
-    cacheReadInputTokens: firstTokenCount(tu, CACHE_READ_KEYS),
-    cacheWriteInputTokens: firstTokenCount(tu, CACHE_WRITE_KEYS),
-    contextUsagePercentage: num(tu.contextUsagePercentage),
-    normalizedTokenUsage: num(tu.normalizedTokenUsage),
-    rawStopReason: str(parsed.stopReason),
-    stopDetails: parsed.stopDetails && typeof parsed.stopDetails === "object" ? parsed.stopDetails : void 0
-  };
-  for (const k of Object.keys(data)) {
-    if (data[k] === void 0)
-      delete data[k];
-  }
-  return Object.keys(data).length > 0 ? { type: "usage", data } : null;
+function prepareHistory(history, keepNewestBoundedImage = true) {
+  return injectSyntheticToolCalls(sanitizeHistory(stripHistoryImages(history, keepNewestBoundedImage)));
 }
-function parseError(parsed, kind, fallbackName) {
-  const rawError = parsed.error ?? parsed.Error;
-  const error2 = typeof rawError === "string" ? rawError : rawError !== void 0 ? JSON.stringify(rawError) : str(parsed.name) ?? fallbackName;
-  const message = parsed.message ?? parsed.Message ?? parsed.reason;
-  const data = { error: error2, kind };
-  if (typeof message === "string")
-    data.message = message;
-  const reason = str(parsed.reason);
-  if (reason !== void 0)
-    data.reason = reason;
-  const retryAfterMilliseconds = num(parsed.retryAfterMilliseconds);
-  if (retryAfterMilliseconds !== void 0)
-    data.retryAfterMilliseconds = retryAfterMilliseconds;
-  return { type: "error", data };
+function assertHistoryWithinLimit(history, limit) {
+  const size = JSON.stringify(history).length;
+  if (size > limit) {
+    throw new Error(`Kiro API error: context_length_exceeded (local history ${size} chars / ${history.length} entries exceeds ${limit}-char limit)`);
+  }
 }
-function parseKiroEvent(key, parsed) {
-  switch (key) {
-    case "assistantResponseEvent": {
-      const content = str(parsed.content);
-      return content !== void 0 ? { type: "content", data: content } : null;
-    }
-    case "reasoningContentEvent": {
-      const text = str(parsed.text);
-      if (text !== void 0)
-        return { type: "thinkingText", data: text };
-      const signature = str(parsed.signature);
-      if (signature !== void 0)
-        return { type: "thinkingSignature", data: signature };
-      return { type: "ignored", data: { key } };
-    }
-    case "toolUseEvent":
-      return parseToolUse(parsed);
-    case "contextUsageEvent": {
-      const pct = num(parsed.contextUsagePercentage);
-      return pct !== void 0 ? { type: "contextUsage", data: { contextUsagePercentage: pct } } : null;
-    }
-    case "metadataEvent":
-      return parseMetadata(parsed);
-    case "meteringEvent":
-      return {
-        type: "metering",
-        data: { credits: tokenCount(parsed.usage), unit: str(parsed.unit), unitPlural: str(parsed.unitPlural) }
-      };
-    // Reachable when a member that models an exception is delivered as an
-    // ordinary event frame. The real wire uses exception framing, handled by
-    // parseKiroExceptionFrame, but both routes must agree.
-    case "error":
-    case "throttlingError":
-    case "validationError":
-    case "serviceUnavailableError": {
-      const member = lookupKiroErrorMember(key);
-      return parseError(parsed, member.kind, member.exception);
-    }
-    // Known members with no consumer yet: explicitly ignored, not unparseable.
-    case "codeReferenceEvent":
-    case "documentCitationEvent":
-    case "toolResultEvent":
-      return { type: "ignored", data: { key } };
-    default: {
-      const member = lookupKiroErrorMember(key);
-      if (member)
-        return parseError(parsed, member.kind, member.exception);
-      return parseKiroEventByShape(parsed);
+function extractToolNamesFromHistory(history) {
+  const names = /* @__PURE__ */ new Set();
+  for (const entry of history) {
+    for (const tu of entry.assistantResponseMessage?.toolUses ?? []) {
+      if (tu.name)
+        names.add(tu.name);
     }
   }
+  return names;
 }
-function parseKiroExceptionFrame(key, parsed) {
-  const member = lookupKiroErrorMember(key);
-  if (!member)
-    return null;
-  const event = parseError(parsed, member.kind, member.exception);
-  return event.data;
-}
-function parseKiroEventByShape(parsed) {
-  if (parsed.content !== void 0)
-    return { type: "content", data: parsed.content };
-  if (typeof parsed.text === "string")
-    return { type: "thinkingText", data: parsed.text };
-  if (typeof parsed.signature === "string")
-    return { type: "thinkingSignature", data: parsed.signature };
-  if (parsed.name && parsed.toolUseId)
-    return parseToolUse(parsed);
-  if (parsed.input !== void 0 && !parsed.name) {
-    return { type: "toolUseInput", data: { input: toolInput(parsed.input) } };
-  }
-  if (parsed.stop !== void 0 && parsed.contextUsagePercentage === void 0)
-    return { type: "toolUseStop", data: { stop: parsed.stop } };
-  if (parsed.contextUsagePercentage !== void 0)
-    return { type: "contextUsage", data: { contextUsagePercentage: parsed.contextUsagePercentage } };
-  if (parsed.followupPrompt !== void 0)
-    return { type: "followupPrompt", data: parsed.followupPrompt };
-  if (parsed.tokenUsage !== void 0 || parsed.stopReason !== void 0 || parsed.stopDetails !== void 0) {
-    return parseMetadata(parsed);
-  }
-  if (parsed.error !== void 0 || parsed.Error !== void 0) {
-    return parseError(parsed, "unknown", "unknown");
-  }
-  if (typeof parsed.usage === "number") {
-    return {
-      type: "metering",
-      data: { credits: tokenCount(parsed.usage), unit: str(parsed.unit), unitPlural: str(parsed.unitPlural) }
-    };
-  }
-  return null;
+function addPlaceholderTools(tools, history) {
+  const historyNames = extractToolNamesFromHistory(history);
+  if (historyNames.size === 0)
+    return tools;
+  const existing = new Set(tools.map((t) => t.toolSpecification?.name).filter(Boolean));
+  const missing = Array.from(historyNames).filter((n) => !existing.has(n));
+  if (missing.length === 0)
+    return tools;
+  return [
+    ...tools,
+    ...missing.map((name) => ({
+      toolSpecification: {
+        name,
+        description: "Tool",
+        inputSchema: { json: { type: "object", properties: {} } }
+      }
+    }))
+  ];
 }
 
 // ../kiro-core/dist/transform.js
@@ -2628,526 +3119,238 @@ function hasToolResults(entry) {
 function toolUseIdsOf(entry) {
   return (entry?.assistantResponseMessage?.toolUses ?? []).map((tu) => tu.toolUseId).filter(Boolean);
 }
-function hasToolUses(entry) {
-  return toolUseIdsOf(entry).length > 0;
-}
-function hasText(entry) {
-  return (entry?.userInputMessage?.content ?? "").trim() !== "";
-}
-function toolResultsMatch(toolUseIds, toolResults) {
-  if (toolUseIds.length === 0)
-    return true;
-  if (toolResults.length === 0)
-    return false;
-  const resultIds = new Set(toolResults.map((tr) => tr.toolUseId));
-  const useIds = new Set(toolUseIds);
-  return toolUseIds.every((id) => resultIds.has(id)) && toolResults.every((tr) => useIds.has(tr.toolUseId));
-}
-function validateStartsWithUserMessage(entries) {
-  if (entries.length === 0 || !isUserEntry(entries[0])) {
-    return error(KiroValidationRule.STARTS_WITH_USER_MESSAGE, 0);
-  }
-  return null;
-}
-function validateEndsWithUserMessage(entries) {
-  if (entries.length === 0 || !isUserEntry(entries[entries.length - 1])) {
-    return error(KiroValidationRule.ENDS_WITH_USER_MESSAGE, entries.length - 1);
-  }
-  return null;
-}
-function validateAlternatingMessages(entries) {
-  for (let i = 1; i < entries.length; i++) {
-    if (isUserEntry(entries[i - 1]) && isUserEntry(entries[i])) {
-      return error(KiroValidationRule.ALTERNATING_MESSAGES, i, "Between every two user messages there must be an assistant message");
-    }
-    if (isAssistantEntry(entries[i - 1]) && isAssistantEntry(entries[i])) {
-      return error(KiroValidationRule.ALTERNATING_MESSAGES, i, "Between every two assistant messages there must be a user message");
-    }
-  }
-  return null;
-}
-function validateToolUsesAndResults(entries) {
-  for (let i = 0; i < entries.length - 1; i++) {
-    const current = entries[i];
-    const next = entries[i + 1];
-    if (isAssistantEntry(current) && hasToolUses(current) && (!isUserEntry(next) || !toolResultsMatch(toolUseIdsOf(current), toolResultsOf(next)))) {
-      return error(KiroValidationRule.TOOL_USES_AND_RESULTS, i + 1);
-    }
-    if (isAssistantEntry(current) && !hasToolUses(current) && isUserEntry(next) && hasToolResults(next)) {
-      return error(KiroValidationRule.TOOL_RESULTS_AND_NO_USES, i);
-    }
-  }
-  for (let i = 0; i < entries.length; i++) {
-    const entry = entries[i];
-    if (!isUserEntry(entry) || !hasToolResults(entry))
-      continue;
-    const prev = i > 0 ? entries[i - 1] : void 0;
-    if (!isAssistantEntry(prev))
-      return error(KiroValidationRule.TOOL_RESULTS_AND_NO_USES, i);
-  }
-  return null;
-}
-function validateToolResultOrphanIds(entries) {
-  for (let i = 1; i < entries.length; i++) {
-    const prev = entries[i - 1];
-    const current = entries[i];
-    if (!isAssistantEntry(prev) || !hasToolUses(prev) || !isUserEntry(current) || !hasToolResults(current))
-      continue;
-    const validIds = new Set(toolUseIdsOf(prev));
-    const toolResults = toolResultsOf(current);
-    const hasOrphan = toolResults.some((tr) => !tr.toolUseId || !validIds.has(tr.toolUseId));
-    const seen = /* @__PURE__ */ new Set();
-    const hasDuplicate = toolResults.some((tr) => {
-      if (!tr.toolUseId)
-        return false;
-      if (seen.has(tr.toolUseId))
-        return true;
-      seen.add(tr.toolUseId);
-      return false;
-    });
-    if (hasOrphan || hasDuplicate)
-      return error(KiroValidationRule.TOOL_RESULTS_ORPHAN_IDS, i);
-  }
-  return null;
-}
-function validateNonEmptyUserMessages(entries) {
-  for (let i = 0; i < entries.length; i++) {
-    const entry = entries[i];
-    if (!isUserEntry(entry))
-      continue;
-    if (!hasText(entry) && !hasToolResults(entry)) {
-      return error(KiroValidationRule.NON_EMPTY_USER_MESSAGE, i);
-    }
-  }
-  return null;
-}
-function validateKiroToolStructure(entries) {
-  const errors = [validateToolUsesAndResults(entries), validateToolResultOrphanIds(entries)].filter((e) => e !== null);
-  return { valid: errors.length === 0, errors };
-}
-function validateKiroConversation(entries) {
-  const errors = [
-    validateStartsWithUserMessage(entries),
-    validateEndsWithUserMessage(entries),
-    validateAlternatingMessages(entries),
-    ...validateKiroToolStructure(entries).errors,
-    validateNonEmptyUserMessages(entries)
-  ].filter((e) => e !== null);
-  return { valid: errors.length === 0, errors };
-}
-function kiroConversationEntries(history, currentUserMessage) {
-  return currentUserMessage ? [...history, { userInputMessage: currentUserMessage }] : [...history];
-}
-function repairKiroConversation(entries) {
-  const diagnostics = validateKiroConversation(entries).errors;
-  if (diagnostics.length === 0)
-    return { entries, diagnostics, remaining: [] };
-  const modelId = entries.find((e) => e.userInputMessage?.modelId)?.userInputMessage?.modelId ?? "";
-  let working = [...entries];
-  while (working.length > 0 && (!isUserEntry(working[0]) || hasToolResults(working[0])))
-    working = working.slice(1);
-  const consolidated = [];
-  for (let i = 0; i < working.length; i++) {
-    const entry = working[i];
-    const isToolOnly = isUserEntry(entry) && hasToolResults(entry) && !hasText(entry);
-    if (!isToolOnly) {
-      consolidated.push(entry);
-      continue;
-    }
-    let j = i;
-    const merged = [];
-    const seen = /* @__PURE__ */ new Set();
-    while (j < working.length) {
-      const candidate = working[j];
-      if (!(isUserEntry(candidate) && hasToolResults(candidate) && !hasText(candidate)))
-        break;
-      for (const tr of toolResultsOf(candidate)) {
-        if (tr.toolUseId && seen.has(tr.toolUseId))
-          continue;
-        if (tr.toolUseId)
-          seen.add(tr.toolUseId);
-        merged.push(tr);
-      }
-      j++;
-    }
-    if (j - i === 1) {
-      consolidated.push(entry);
-    } else {
-      const uim = entry.userInputMessage;
-      consolidated.push({
-        userInputMessage: {
-          ...uim,
-          userInputMessageContext: { ...uim.userInputMessageContext, toolResults: merged }
-        }
-      });
-    }
-    i = j - 1;
-  }
-  working = consolidated;
-  const repaired = [];
-  for (let i = 0; i < working.length; i++) {
-    const entry = working[i];
-    if (isUserEntry(entry) && hasToolResults(entry)) {
-      const prev = repaired[repaired.length - 1];
-      const validIds = new Set(toolUseIdsOf(prev));
-      const seen = /* @__PURE__ */ new Set();
-      const kept = toolResultsOf(entry).filter((tr) => {
-        if (!tr.toolUseId || !validIds.has(tr.toolUseId) || seen.has(tr.toolUseId))
-          return false;
-        seen.add(tr.toolUseId);
-        return true;
-      });
-      const uim = { ...entry.userInputMessage };
-      if (kept.length === 0) {
-        const { userInputMessageContext, ...rest } = uim;
-        const tools = userInputMessageContext?.tools;
-        repaired.push({
-          userInputMessage: { ...rest, ...tools ? { userInputMessageContext: { tools } } : {} }
-        });
-      } else {
-        repaired.push({
-          userInputMessage: {
-            ...uim,
-            userInputMessageContext: { ...uim.userInputMessageContext, toolResults: kept }
-          }
-        });
-      }
-      continue;
-    }
-    repaired.push(entry);
-    if (isAssistantEntry(entry) && hasToolUses(entry)) {
-      const next = working[i + 1];
-      const answered = new Set(isUserEntry(next) ? toolResultsOf(next).map((tr) => tr.toolUseId) : (
-        /* c8 ignore next */
-        []
-      ));
-      const unanswered = toolUseIdsOf(entry).filter((id) => !answered.has(id));
-      if (unanswered.length > 0 && !isUserEntry(next)) {
-        repaired.push(syntheticToolResultEntry(unanswered, modelId));
-      } else if (unanswered.length > 0 && isUserEntry(next)) {
-        const uim = { ...next.userInputMessage };
-        working[i + 1] = {
-          userInputMessage: {
-            ...uim,
-            userInputMessageContext: {
-              ...uim.userInputMessageContext,
-              toolResults: [...toolResultsOf(next), ...unanswered.map(syntheticFailedToolResult)]
-            }
-          }
-        };
-      }
-    }
-  }
-  const final = repaired.map((entry) => {
-    if (!isUserEntry(entry) || hasText(entry) || hasToolResults(entry))
-      return entry;
-    const uim = entry.userInputMessage;
-    return { userInputMessage: { ...uim, content: EMPTY_CONTENT_PLACEHOLDER } };
-  });
-  return { entries: final, diagnostics, remaining: validateKiroConversation(final).errors };
-}
-function syntheticFailedToolResult(toolUseId) {
-  return { toolUseId, content: [{ text: SYNTHETIC_FAILED_TOOL_RESULT_TEXT }], status: "error" };
-}
-function syntheticToolResultEntry(toolUseIds, modelId) {
-  return {
-    userInputMessage: {
-      // Empty by design: `toolResults` is the payload. Matches kiro-agent's
-      // `FAILED_TOOL_USE_MESSAGE`, which also ships `content: ''`.
-      content: "",
-      modelId,
-      origin: "KIRO_CLI",
-      userInputMessageContext: { toolResults: toolUseIds.map(syntheticFailedToolResult) }
-    }
-  };
-}
-
-// ../kiro-core/dist/host-auth.js
-init_endpoints();
-init_oauth();
-var KIRO_NO_SESSION_MESSAGE = "No Kiro session found. Sign in with `kiro-cli login` (Builder ID, IAM Identity Center, Google, or GitHub), then run /login kiro again \u2014 or paste a Kiro API key below.";
-async function loginKiroFromSession(callbacks) {
-  callbacks.onProgress?.("Looking for an existing Kiro session\u2026");
-  const existing = await resolveKiroCredentials();
-  if (existing) {
-    callbacks.onProgress?.(`Using the ${existing.authMethod} session from kiro-cli.`);
-    return existing;
-  }
-  if (!callbacks.onPrompt)
-    throw new Error(KIRO_NO_SESSION_MESSAGE);
-  const apiKey = (await callbacks.onPrompt({
-    message: KIRO_NO_SESSION_MESSAGE,
-    placeholder: "ksk_\u2026",
-    allowEmpty: true,
-    secret: true
-  })).trim();
-  if (!apiKey)
-    throw new Error(KIRO_NO_SESSION_MESSAGE);
-  return loginKiroWithApiKey(apiKey, callbacks.onProgress);
+function hasToolUses(entry) {
+  return toolUseIdsOf(entry).length > 0;
 }
-async function resolveKiroRequestCredentials(hostKey) {
-  const stored = await resolveKiroCredentials();
-  const region = resolveApiRegion(stored?.region);
-  if (hostKey && (isApiKey(hostKey) || hostKey === stored?.access)) {
-    return { accessToken: hostKey, region, ...stored?.profileArn ? { profileArn: stored.profileArn } : {} };
-  }
-  if (stored) {
-    return {
-      accessToken: stored.access,
-      region,
-      ...stored.profileArn ? { profileArn: stored.profileArn } : {}
-    };
-  }
-  if (hostKey)
-    return { accessToken: hostKey, region };
-  throw new Error("Kiro credentials not set. Run `kiro-cli login`, or set KIRO_API_KEY to a `ksk_` API key.");
+function hasText(entry) {
+  return (entry?.userInputMessage?.content ?? "").trim() !== "";
 }
-
-// ../kiro-core/dist/host-model.js
-init_models();
-function toKiroModelForHost(model, region) {
-  const known = getCachedModels(region).find((candidate) => candidate.id === model.id);
-  return {
-    ...known ?? {
-      id: model.id,
-      // No fallback to `model.id`: that dash-spelled local id is not a valid
-      // Kiro wire id. `""` is falsy, so `resolveKiroModel` runs its own
-      // cache/bootstrap/dot-normalize resolution instead of being
-      // short-circuited by a value that is really just `model.id` again.
-      kiroModelId: model.kiroModelId ?? "",
-      name: model.name,
-      reasoning: model.reasoning,
-      input: [...model.input],
-      cost: { ...model.cost },
-      contextWindow: model.contextWindow ?? 2e5,
-      maxTokens: model.maxTokens ?? 8192
-    },
-    region,
-    ...model.kiroProfileArn ? { profileArn: model.kiroProfileArn } : {},
-    ...model.additionalModelRequestFieldsSchema ? { additionalModelRequestFieldsSchema: model.additionalModelRequestFieldsSchema } : {}
-  };
+function toolResultsMatch(toolUseIds, toolResults) {
+  if (toolUseIds.length === 0)
+    return true;
+  if (toolResults.length === 0)
+    return false;
+  const resultIds = new Set(toolResults.map((tr) => tr.toolUseId));
+  const useIds = new Set(toolUseIds);
+  return toolUseIds.every((id) => resultIds.has(id)) && toolResults.every((tr) => useIds.has(tr.toolUseId));
 }
-
-// ../kiro-core/dist/invoke-tool-parser.js
-var INVOKE_OPEN_ANCHORED = /^<invoke name="([\w-]+)">/;
-var INVOKE_OPEN_SEARCH = "<invoke name=";
-var INVOKE_OPEN_ANYWHERE = /<invoke name="[\w-]+">/;
-var PARAM_OPEN_ANCHORED = /^<parameter name="([^"]*)">/;
-var INVOKE_CLOSE = "</invoke>";
-var PARAM_CLOSE = "</parameter>";
-var FENCE = "```";
-function fencedRanges(text) {
-  const ranges = [];
-  let searchFrom = 0;
-  while (true) {
-    const open = text.indexOf(FENCE, searchFrom);
-    if (open < 0)
-      break;
-    const close = text.indexOf(FENCE, open + FENCE.length);
-    if (close < 0) {
-      ranges.push({ start: open, end: text.length });
-      break;
-    }
-    ranges.push({ start: open, end: close + FENCE.length });
-    searchFrom = close + FENCE.length;
+function validateStartsWithUserMessage(entries) {
+  if (entries.length === 0 || !isUserEntry(entries[0])) {
+    return error(KiroValidationRule.STARTS_WITH_USER_MESSAGE, 0);
   }
-  return ranges;
+  return null;
 }
-var AmbiguousDialectError = class extends Error {
-};
-function parseBlockAt(text, start) {
-  const openMatch = INVOKE_OPEN_ANCHORED.exec(text.substring(start));
-  if (!openMatch)
-    return null;
-  const args = {};
-  let cursor = start + openMatch[0].length;
-  while (true) {
-    const remainder = text.substring(cursor);
-    const leadingWhitespace = remainder.length - remainder.trimStart().length;
-    if (leadingWhitespace > 0)
-      cursor += leadingWhitespace;
-    if (text.startsWith(INVOKE_CLOSE, cursor)) {
-      const end = cursor + INVOKE_CLOSE.length;
-      if (end < text.length && !/\s/.test(text[end]))
-        return null;
-      return { name: openMatch[1], arguments: args, end };
+function validateEndsWithUserMessage(entries) {
+  if (entries.length === 0 || !isUserEntry(entries[entries.length - 1])) {
+    return error(KiroValidationRule.ENDS_WITH_USER_MESSAGE, entries.length - 1);
+  }
+  return null;
+}
+function validateAlternatingMessages(entries) {
+  for (let i = 1; i < entries.length; i++) {
+    if (isUserEntry(entries[i - 1]) && isUserEntry(entries[i])) {
+      return error(KiroValidationRule.ALTERNATING_MESSAGES, i, "Between every two user messages there must be an assistant message");
+    }
+    if (isAssistantEntry(entries[i - 1]) && isAssistantEntry(entries[i])) {
+      return error(KiroValidationRule.ALTERNATING_MESSAGES, i, "Between every two assistant messages there must be a user message");
     }
-    const paramMatch = PARAM_OPEN_ANCHORED.exec(text.substring(cursor));
-    if (!paramMatch)
-      return null;
-    const valueStart = cursor + paramMatch[0].length;
-    const valueEnd = text.indexOf(PARAM_CLOSE, valueStart);
-    if (valueEnd < 0)
-      return null;
-    const value = text.substring(valueStart, valueEnd);
-    if (INVOKE_OPEN_ANYWHERE.test(value))
-      throw new AmbiguousDialectError();
-    args[paramMatch[1]] = value;
-    cursor = valueEnd + PARAM_CLOSE.length;
   }
+  return null;
 }
-function parseInvokeToolCalls(text) {
-  const toolCalls = [];
-  const removals = [];
-  const fences = fencedRanges(text);
-  const untouched = { toolCalls: [], cleanedText: text };
-  let cursor = 0;
-  while (cursor < text.length) {
-    const openStart = text.indexOf(INVOKE_OPEN_SEARCH, cursor);
-    if (openStart < 0)
-      break;
-    const containingFence = fences.find((range) => openStart >= range.start && openStart < range.end);
-    if (containingFence) {
-      cursor = containingFence.end;
-      continue;
+function validateToolUsesAndResults(entries) {
+  for (let i = 0; i < entries.length - 1; i++) {
+    const current = entries[i];
+    const next = entries[i + 1];
+    if (isAssistantEntry(current) && hasToolUses(current) && (!isUserEntry(next) || !toolResultsMatch(toolUseIdsOf(current), toolResultsOf(next)))) {
+      return error(KiroValidationRule.TOOL_USES_AND_RESULTS, i + 1);
     }
-    let block;
-    try {
-      block = parseBlockAt(text, openStart);
-    } catch (e) {
-      if (e instanceof AmbiguousDialectError)
-        return untouched;
-      throw e;
+    if (isAssistantEntry(current) && !hasToolUses(current) && isUserEntry(next) && hasToolResults(next)) {
+      return error(KiroValidationRule.TOOL_RESULTS_AND_NO_USES, i);
     }
-    if (block === null)
-      return untouched;
-    const nextOpen = text.indexOf(INVOKE_OPEN_SEARCH, block.end);
-    const interstitialEnd = nextOpen < 0 ? text.length : nextOpen;
-    const interstitial = text.substring(block.end, interstitialEnd);
-    if (interstitial.includes(PARAM_CLOSE) || interstitial.includes(INVOKE_CLOSE))
-      return untouched;
-    toolCalls.push({ toolUseId: crypto.randomUUID(), name: block.name, arguments: block.arguments });
-    removals.push({ start: openStart, end: block.end });
-    cursor = block.end;
   }
-  let cleanedText = text;
-  for (let i = removals.length - 1; i >= 0; i--) {
-    const { start, end } = removals[i];
-    cleanedText = cleanedText.substring(0, start) + cleanedText.substring(end);
+  for (let i = 0; i < entries.length; i++) {
+    const entry = entries[i];
+    if (!isUserEntry(entry) || !hasToolResults(entry))
+      continue;
+    const prev = i > 0 ? entries[i - 1] : void 0;
+    if (!isAssistantEntry(prev))
+      return error(KiroValidationRule.TOOL_RESULTS_AND_NO_USES, i);
   }
-  return { toolCalls, cleanedText };
+  return null;
 }
-
-// ../kiro-core/dist/index.js
-init_kiro_cli();
-init_kiro_ide();
-init_management();
-init_models();
-init_oauth();
-
-// ../kiro-core/dist/request-builder.js
-init_debug();
-
-// ../kiro-core/dist/history.js
-var HISTORY_LIMIT = 85e4;
-var HISTORY_LIMIT_CONTEXT_WINDOW = 2e5;
-var HISTORY_IMAGE_BASE64_LIMIT = 512 * 1024;
-function stripHistoryImages(history, keepNewestBounded = true) {
-  let newestImageIndex = -1;
-  for (let index = history.length - 1; index >= 0; index--) {
-    if ((history[index]?.userInputMessage?.images?.length ?? 0) > 0) {
-      newestImageIndex = index;
-      break;
-    }
+function validateToolResultOrphanIds(entries) {
+  for (let i = 1; i < entries.length; i++) {
+    const prev = entries[i - 1];
+    const current = entries[i];
+    if (!isAssistantEntry(prev) || !hasToolUses(prev) || !isUserEntry(current) || !hasToolResults(current))
+      continue;
+    const validIds = new Set(toolUseIdsOf(prev));
+    const toolResults = toolResultsOf(current);
+    const hasOrphan = toolResults.some((tr) => !tr.toolUseId || !validIds.has(tr.toolUseId));
+    const seen = /* @__PURE__ */ new Set();
+    const hasDuplicate = toolResults.some((tr) => {
+      if (!tr.toolUseId)
+        return false;
+      if (seen.has(tr.toolUseId))
+        return true;
+      seen.add(tr.toolUseId);
+      return false;
+    });
+    if (hasOrphan || hasDuplicate)
+      return error(KiroValidationRule.TOOL_RESULTS_ORPHAN_IDS, i);
   }
-  const newestImages = newestImageIndex >= 0 ? history[newestImageIndex]?.userInputMessage?.images : void 0;
-  const keepNewest = keepNewestBounded && newestImages !== void 0 && newestImages.reduce((size, image) => size + image.source.bytes.length, 0) <= HISTORY_IMAGE_BASE64_LIMIT;
-  return history.map((entry, index) => {
-    if (!entry.userInputMessage?.images || index === newestImageIndex && keepNewest)
-      return entry;
-    const { images: _images, ...rest } = entry.userInputMessage;
-    return { ...entry, userInputMessage: { ...rest } };
-  });
+  return null;
 }
-function sanitizeHistory(history) {
-  while (history.length > 0 && (!history[0]?.userInputMessage || history[0].userInputMessage.userInputMessageContext?.toolResults))
-    history = history.slice(1);
-  const result = [];
-  for (let i = 0; i < history.length; i++) {
-    const m = history[i];
-    if (!m)
+function validateNonEmptyUserMessages(entries) {
+  for (let i = 0; i < entries.length; i++) {
+    const entry = entries[i];
+    if (!isUserEntry(entry))
       continue;
-    if (m.assistantResponseMessage && !m.assistantResponseMessage.toolUses && !m.assistantResponseMessage.content)
+    if (!hasText(entry) && !hasToolResults(entry)) {
+      return error(KiroValidationRule.NON_EMPTY_USER_MESSAGE, i);
+    }
+  }
+  return null;
+}
+function validateKiroToolStructure(entries) {
+  const errors = [validateToolUsesAndResults(entries), validateToolResultOrphanIds(entries)].filter((e) => e !== null);
+  return { valid: errors.length === 0, errors };
+}
+function validateKiroConversation(entries) {
+  const errors = [
+    validateStartsWithUserMessage(entries),
+    validateEndsWithUserMessage(entries),
+    validateAlternatingMessages(entries),
+    ...validateKiroToolStructure(entries).errors,
+    validateNonEmptyUserMessages(entries)
+  ].filter((e) => e !== null);
+  return { valid: errors.length === 0, errors };
+}
+function kiroConversationEntries(history, currentUserMessage) {
+  return currentUserMessage ? [...history, { userInputMessage: currentUserMessage }] : [...history];
+}
+function repairKiroConversation(entries) {
+  const diagnostics = validateKiroConversation(entries).errors;
+  if (diagnostics.length === 0)
+    return { entries, diagnostics, remaining: [] };
+  const modelId = entries.find((e) => e.userInputMessage?.modelId)?.userInputMessage?.modelId ?? "";
+  let working = [...entries];
+  while (working.length > 0 && (!isUserEntry(working[0]) || hasToolResults(working[0])))
+    working = working.slice(1);
+  const consolidated = [];
+  for (let i = 0; i < working.length; i++) {
+    const entry = working[i];
+    const isToolOnly = isUserEntry(entry) && hasToolResults(entry) && !hasText(entry);
+    if (!isToolOnly) {
+      consolidated.push(entry);
       continue;
-    if (m.assistantResponseMessage?.toolUses) {
-      const next = history[i + 1];
-      if (next?.userInputMessage?.userInputMessageContext?.toolResults)
-        result.push(m);
-    } else if (m.userInputMessage?.userInputMessageContext?.toolResults) {
-      const prev = result[result.length - 1];
-      if (prev?.assistantResponseMessage?.toolUses)
-        result.push(m);
-    } else {
-      result.push(m);
     }
-  }
-  return result;
-}
-function injectSyntheticToolCalls(history) {
-  const validIds = /* @__PURE__ */ new Set();
-  for (const entry of history) {
-    for (const tu of entry.assistantResponseMessage?.toolUses ?? []) {
-      if (tu.toolUseId)
-        validIds.add(tu.toolUseId);
+    let j = i;
+    const merged = [];
+    const seen = /* @__PURE__ */ new Set();
+    while (j < working.length) {
+      const candidate = working[j];
+      if (!(isUserEntry(candidate) && hasToolResults(candidate) && !hasText(candidate)))
+        break;
+      for (const tr of toolResultsOf(candidate)) {
+        if (tr.toolUseId && seen.has(tr.toolUseId))
+          continue;
+        if (tr.toolUseId)
+          seen.add(tr.toolUseId);
+        merged.push(tr);
+      }
+      j++;
+    }
+    if (j - i === 1) {
+      consolidated.push(entry);
+    } else {
+      const uim = entry.userInputMessage;
+      consolidated.push({
+        userInputMessage: {
+          ...uim,
+          userInputMessageContext: { ...uim.userInputMessageContext, toolResults: merged }
+        }
+      });
     }
+    i = j - 1;
   }
-  const result = [];
-  for (const entry of history) {
-    const toolResults = entry.userInputMessage?.userInputMessageContext?.toolResults;
-    if (toolResults) {
-      const orphaned = toolResults.filter((tr) => !validIds.has(tr.toolUseId));
-      if (orphaned.length > 0) {
-        result.push({
-          assistantResponseMessage: {
-            content: "Tool calls were made.",
-            toolUses: orphaned.map((tr) => ({ name: "unknown_tool", toolUseId: tr.toolUseId, input: {} }))
+  working = consolidated;
+  const repaired = [];
+  for (let i = 0; i < working.length; i++) {
+    const entry = working[i];
+    if (isUserEntry(entry) && hasToolResults(entry)) {
+      const prev = repaired[repaired.length - 1];
+      const validIds = new Set(toolUseIdsOf(prev));
+      const seen = /* @__PURE__ */ new Set();
+      const kept = toolResultsOf(entry).filter((tr) => {
+        if (!tr.toolUseId || !validIds.has(tr.toolUseId) || seen.has(tr.toolUseId))
+          return false;
+        seen.add(tr.toolUseId);
+        return true;
+      });
+      const uim = { ...entry.userInputMessage };
+      if (kept.length === 0) {
+        const { userInputMessageContext, ...rest } = uim;
+        const tools = userInputMessageContext?.tools;
+        repaired.push({
+          userInputMessage: { ...rest, ...tools ? { userInputMessageContext: { tools } } : {} }
+        });
+      } else {
+        repaired.push({
+          userInputMessage: {
+            ...uim,
+            userInputMessageContext: { ...uim.userInputMessageContext, toolResults: kept }
           }
         });
-        for (const tr of orphaned)
-          validIds.add(tr.toolUseId);
+      }
+      continue;
+    }
+    repaired.push(entry);
+    if (isAssistantEntry(entry) && hasToolUses(entry)) {
+      const next = working[i + 1];
+      const answered = new Set(isUserEntry(next) ? toolResultsOf(next).map((tr) => tr.toolUseId) : (
+        /* c8 ignore next */
+        []
+      ));
+      const unanswered = toolUseIdsOf(entry).filter((id) => !answered.has(id));
+      if (unanswered.length > 0 && !isUserEntry(next)) {
+        repaired.push(syntheticToolResultEntry(unanswered, modelId));
+      } else if (unanswered.length > 0 && isUserEntry(next)) {
+        const uim = { ...next.userInputMessage };
+        working[i + 1] = {
+          userInputMessage: {
+            ...uim,
+            userInputMessageContext: {
+              ...uim.userInputMessageContext,
+              toolResults: [...toolResultsOf(next), ...unanswered.map(syntheticFailedToolResult)]
+            }
+          }
+        };
       }
     }
-    result.push(entry);
   }
-  return result;
-}
-function prepareHistory(history, keepNewestBoundedImage = true) {
-  return injectSyntheticToolCalls(sanitizeHistory(stripHistoryImages(history, keepNewestBoundedImage)));
+  const final = repaired.map((entry) => {
+    if (!isUserEntry(entry) || hasText(entry) || hasToolResults(entry))
+      return entry;
+    const uim = entry.userInputMessage;
+    return { userInputMessage: { ...uim, content: EMPTY_CONTENT_PLACEHOLDER } };
+  });
+  return { entries: final, diagnostics, remaining: validateKiroConversation(final).errors };
 }
-function assertHistoryWithinLimit(history, limit) {
-  const size = JSON.stringify(history).length;
-  if (size > limit) {
-    throw new Error(`Kiro API error: context_length_exceeded (local history ${size} chars / ${history.length} entries exceeds ${limit}-char limit)`);
-  }
+function syntheticFailedToolResult(toolUseId) {
+  return { toolUseId, content: [{ text: SYNTHETIC_FAILED_TOOL_RESULT_TEXT }], status: "error" };
 }
-function extractToolNamesFromHistory(history) {
-  const names = /* @__PURE__ */ new Set();
-  for (const entry of history) {
-    for (const tu of entry.assistantResponseMessage?.toolUses ?? []) {
-      if (tu.name)
-        names.add(tu.name);
+function syntheticToolResultEntry(toolUseIds, modelId) {
+  return {
+    userInputMessage: {
+      // Empty by design: `toolResults` is the payload. Matches kiro-agent's
+      // `FAILED_TOOL_USE_MESSAGE`, which also ships `content: ''`.
+      content: "",
+      modelId,
+      origin: "KIRO_CLI",
+      userInputMessageContext: { toolResults: toolUseIds.map(syntheticFailedToolResult) }
     }
-  }
-  return names;
-}
-function addPlaceholderTools(tools, history) {
-  const historyNames = extractToolNamesFromHistory(history);
-  if (historyNames.size === 0)
-    return tools;
-  const existing = new Set(tools.map((t) => t.toolSpecification?.name).filter(Boolean));
-  const missing = Array.from(historyNames).filter((n) => !existing.has(n));
-  if (missing.length === 0)
-    return tools;
-  return [
-    ...tools,
-    ...missing.map((name) => ({
-      toolSpecification: {
-        name,
-        description: "Tool",
-        inputSchema: { json: { type: "object", properties: {} } }
-      }
-    }))
-  ];
+  };
 }
 
 // ../kiro-core/dist/truncation.js
@@ -3288,43 +3491,143 @@ ${currentContent}`;
     wireContent = currentContent || EMPTY_CONTENT_PLACEHOLDER;
     wireUimc = uimc?.tools?.length ? { tools: uimc.tools } : void 0;
   }
-  if (repair.remaining.length > 0) {
-    const structural = repair.remaining.filter((e) => isKiroToolStructureRule(e.rule));
-    if (structural.length > 0) {
-      console.warn(`[kiro-core] outbound history still violates ${structural.map((e) => `${e.rule}@${e.index}`).join(", ")} after repair \u2014 Kiro may reject this request`);
+  if (repair.remaining.length > 0) {
+    const structural = repair.remaining.filter((e) => isKiroToolStructureRule(e.rule));
+    if (structural.length > 0) {
+      console.warn(`[kiro-core] outbound history still violates ${structural.map((e) => `${e.rule}@${e.index}`).join(", ")} after repair \u2014 Kiro may reject this request`);
+    }
+  }
+  return {
+    request: {
+      conversationState: {
+        chatTriggerType: "MANUAL",
+        agentTaskType: "vibe",
+        conversationId,
+        currentMessage: {
+          userInputMessage: {
+            content: sanitizeSurrogates(wireContent),
+            modelId: kiroModelId,
+            origin: "KIRO_CLI",
+            ...currentImages ? { images: currentImages } : {},
+            ...wireUimc ? { userInputMessageContext: wireUimc } : {}
+          }
+        },
+        ...wireHistory.length > 0 ? { history: wireHistory } : {}
+      },
+      ...params.additionalModelRequestFields ? { additionalModelRequestFields: params.additionalModelRequestFields } : {},
+      profileArn,
+      agentMode: "vibe"
+    },
+    wireHistoryLength: wireHistory.length,
+    wireContentLength: wireContent.length,
+    hasImages: !!currentImages,
+    toolResultCount: wireUimc?.toolResults?.length ?? 0
+  };
+}
+
+// ../kiro-core/dist/response-assembler.js
+init_debug();
+
+// ../kiro-core/dist/invoke-tool-parser.js
+var INVOKE_OPEN_ANCHORED = /^<invoke name="([\w-]+)">/;
+var INVOKE_OPEN_SEARCH = "<invoke name=";
+var INVOKE_OPEN_ANYWHERE = /<invoke name="[\w-]+">/;
+var PARAM_OPEN_ANCHORED = /^<parameter name="([^"]*)">/;
+var INVOKE_CLOSE = "</invoke>";
+var PARAM_CLOSE = "</parameter>";
+var FENCE = "```";
+function fencedRanges(text) {
+  const ranges = [];
+  let searchFrom = 0;
+  while (true) {
+    const open = text.indexOf(FENCE, searchFrom);
+    if (open < 0)
+      break;
+    const close = text.indexOf(FENCE, open + FENCE.length);
+    if (close < 0) {
+      ranges.push({ start: open, end: text.length });
+      break;
+    }
+    ranges.push({ start: open, end: close + FENCE.length });
+    searchFrom = close + FENCE.length;
+  }
+  return ranges;
+}
+var AmbiguousDialectError = class extends Error {
+};
+function parseBlockAt(text, start) {
+  const openMatch = INVOKE_OPEN_ANCHORED.exec(text.substring(start));
+  if (!openMatch)
+    return null;
+  const args = {};
+  let cursor = start + openMatch[0].length;
+  while (true) {
+    const remainder = text.substring(cursor);
+    const leadingWhitespace = remainder.length - remainder.trimStart().length;
+    if (leadingWhitespace > 0)
+      cursor += leadingWhitespace;
+    if (text.startsWith(INVOKE_CLOSE, cursor)) {
+      const end = cursor + INVOKE_CLOSE.length;
+      if (end < text.length && !/\s/.test(text[end]))
+        return null;
+      return { name: openMatch[1], arguments: args, end };
+    }
+    const paramMatch = PARAM_OPEN_ANCHORED.exec(text.substring(cursor));
+    if (!paramMatch)
+      return null;
+    const valueStart = cursor + paramMatch[0].length;
+    const valueEnd = text.indexOf(PARAM_CLOSE, valueStart);
+    if (valueEnd < 0)
+      return null;
+    const value = text.substring(valueStart, valueEnd);
+    if (INVOKE_OPEN_ANYWHERE.test(value))
+      throw new AmbiguousDialectError();
+    args[paramMatch[1]] = value;
+    cursor = valueEnd + PARAM_CLOSE.length;
+  }
+}
+function parseInvokeToolCalls(text) {
+  const toolCalls = [];
+  const removals = [];
+  const fences = fencedRanges(text);
+  const untouched = { toolCalls: [], cleanedText: text };
+  let cursor = 0;
+  while (cursor < text.length) {
+    const openStart = text.indexOf(INVOKE_OPEN_SEARCH, cursor);
+    if (openStart < 0)
+      break;
+    const containingFence = fences.find((range) => openStart >= range.start && openStart < range.end);
+    if (containingFence) {
+      cursor = containingFence.end;
+      continue;
+    }
+    let block;
+    try {
+      block = parseBlockAt(text, openStart);
+    } catch (e) {
+      if (e instanceof AmbiguousDialectError)
+        return untouched;
+      throw e;
     }
+    if (block === null)
+      return untouched;
+    const nextOpen = text.indexOf(INVOKE_OPEN_SEARCH, block.end);
+    const interstitialEnd = nextOpen < 0 ? text.length : nextOpen;
+    const interstitial = text.substring(block.end, interstitialEnd);
+    if (interstitial.includes(PARAM_CLOSE) || interstitial.includes(INVOKE_CLOSE))
+      return untouched;
+    toolCalls.push({ toolUseId: crypto.randomUUID(), name: block.name, arguments: block.arguments });
+    removals.push({ start: openStart, end: block.end });
+    cursor = block.end;
   }
-  return {
-    request: {
-      conversationState: {
-        chatTriggerType: "MANUAL",
-        agentTaskType: "vibe",
-        conversationId,
-        currentMessage: {
-          userInputMessage: {
-            content: sanitizeSurrogates(wireContent),
-            modelId: kiroModelId,
-            origin: "KIRO_CLI",
-            ...currentImages ? { images: currentImages } : {},
-            ...wireUimc ? { userInputMessageContext: wireUimc } : {}
-          }
-        },
-        ...wireHistory.length > 0 ? { history: wireHistory } : {}
-      },
-      ...params.additionalModelRequestFields ? { additionalModelRequestFields: params.additionalModelRequestFields } : {},
-      profileArn,
-      agentMode: "vibe"
-    },
-    wireHistoryLength: wireHistory.length,
-    wireContentLength: wireContent.length,
-    hasImages: !!currentImages,
-    toolResultCount: wireUimc?.toolResults?.length ?? 0
-  };
+  let cleanedText = text;
+  for (let i = removals.length - 1; i >= 0; i--) {
+    const { start, end } = removals[i];
+    cleanedText = cleanedText.substring(0, start) + cleanedText.substring(end);
+  }
+  return { toolCalls, cleanedText };
 }
 
-// ../kiro-core/dist/response-assembler.js
-init_debug();
-
 // ../kiro-core/dist/thinking-parser.js
 var THINKING_END_TAG = "</thinking>";
 var THINKING_TAG_VARIANTS = [
@@ -4823,65 +5126,272 @@ function getChunkedStream(source) {
     [Symbol.asyncIterator]: iterator
   };
 }
-
-// ../../node_modules/.pnpm/@smithy+core@3.34.1/node_modules/@smithy/core/dist-es/submodules/event-streams/eventstream-serde-universal/getUnmarshalledStream.js
-function getMessageUnmarshaller(deserializer, toUtf82) {
-  return async function(message) {
-    const { value: messageType } = message.headers[":message-type"];
-    if (messageType === "error") {
-      const unmodeledError = new Error(message.headers[":error-message"].value || "UnknownError");
-      unmodeledError.name = message.headers[":error-code"].value;
-      throw unmodeledError;
-    } else if (messageType === "exception") {
-      const code = message.headers[":exception-type"].value;
-      const exception = { [code]: message };
-      const deserializedException = await deserializer(exception);
-      if (deserializedException.$unknown) {
-        const error2 = new Error(toUtf82(message.body));
-        error2.name = code;
-        throw error2;
-      }
-      throw deserializedException[code];
-    } else if (messageType === "event") {
-      const event = {
-        [message.headers[":event-type"].value]: message
+
+// ../../node_modules/.pnpm/@smithy+core@3.34.1/node_modules/@smithy/core/dist-es/submodules/event-streams/eventstream-serde-universal/getUnmarshalledStream.js
+function getMessageUnmarshaller(deserializer, toUtf82) {
+  return async function(message) {
+    const { value: messageType } = message.headers[":message-type"];
+    if (messageType === "error") {
+      const unmodeledError = new Error(message.headers[":error-message"].value || "UnknownError");
+      unmodeledError.name = message.headers[":error-code"].value;
+      throw unmodeledError;
+    } else if (messageType === "exception") {
+      const code = message.headers[":exception-type"].value;
+      const exception = { [code]: message };
+      const deserializedException = await deserializer(exception);
+      if (deserializedException.$unknown) {
+        const error2 = new Error(toUtf82(message.body));
+        error2.name = code;
+        throw error2;
+      }
+      throw deserializedException[code];
+    } else if (messageType === "event") {
+      const event = {
+        [message.headers[":event-type"].value]: message
+      };
+      const deserialized = await deserializer(event);
+      if (deserialized.$unknown)
+        return;
+      return deserialized;
+    } else {
+      throw Error(`Unrecognizable event type: ${message.headers[":event-type"].value}`);
+    }
+  };
+}
+
+// ../../node_modules/.pnpm/@smithy+core@3.34.1/node_modules/@smithy/core/dist-es/submodules/event-streams/eventstream-serde-universal/EventStreamMarshaller.js
+var EventStreamMarshaller = class {
+  eventStreamCodec;
+  utfEncoder;
+  constructor({ utf8Encoder, utf8Decoder }) {
+    this.eventStreamCodec = new EventStreamCodec(utf8Encoder, utf8Decoder);
+    this.utfEncoder = utf8Encoder;
+  }
+  deserialize(body, deserializer) {
+    const inputStream = getChunkedStream(body);
+    return new SmithyMessageDecoderStream({
+      messageStream: new MessageDecoderStream({ inputStream, decoder: this.eventStreamCodec }),
+      deserializer: getMessageUnmarshaller(deserializer, this.utfEncoder)
+    });
+  }
+  serialize(inputStream, serializer) {
+    return new MessageEncoderStream({
+      messageStream: new SmithyMessageEncoderStream({ inputStream, serializer }),
+      encoder: this.eventStreamCodec,
+      includeEndFrame: true
+    });
+  }
+};
+
+// ../kiro-core/dist/response-stream.js
+init_debug();
+
+// ../kiro-core/dist/event-parser.js
+var KIRO_EVENT_KEYS = [
+  "assistantResponseEvent",
+  "codeReferenceEvent",
+  "contextUsageEvent",
+  "documentCitationEvent",
+  "error",
+  "metadataEvent",
+  "meteringEvent",
+  "reasoningContentEvent",
+  "serviceUnavailableError",
+  "throttlingError",
+  "toolResultEvent",
+  "toolUseEvent",
+  "validationError"
+];
+var KIRO_EVENT_KEY_SET = new Set(KIRO_EVENT_KEYS);
+var KIRO_ERROR_MEMBERS = {
+  error: { kind: "internalServer", exception: "InternalServerException" },
+  throttlingError: { kind: "throttling", exception: "ThrottlingException" },
+  validationError: { kind: "validation", exception: "ValidationException" },
+  serviceUnavailableError: { kind: "serviceUnavailable", exception: "ServiceUnavailableException" }
+};
+var KIRO_ERROR_TOKENS = {
+  ...KIRO_ERROR_MEMBERS,
+  InternalServerException: KIRO_ERROR_MEMBERS.error,
+  ThrottlingException: KIRO_ERROR_MEMBERS.throttlingError,
+  ValidationException: KIRO_ERROR_MEMBERS.validationError,
+  ServiceUnavailableException: KIRO_ERROR_MEMBERS.serviceUnavailableError
+};
+function lookupKiroErrorMember(key) {
+  return Object.hasOwn(KIRO_ERROR_TOKENS, key) ? KIRO_ERROR_TOKENS[key] : void 0;
+}
+var num = (v) => typeof v === "number" ? v : void 0;
+var str = (v) => typeof v === "string" ? v : void 0;
+function tokenCount(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : void 0;
+}
+function firstTokenCount(source, keys) {
+  for (const key of keys) {
+    const count = tokenCount(source[key]);
+    if (count !== void 0)
+      return count;
+  }
+  return void 0;
+}
+var CACHE_READ_KEYS = ["cacheReadInputTokens", "cache_read_input_tokens", "cacheReadTokens"];
+var CACHE_WRITE_KEYS = [
+  "cacheWriteInputTokens",
+  "cache_creation_input_tokens",
+  "cacheCreationInputTokens",
+  "cacheWriteTokens"
+];
+function toolInput(raw) {
+  if (typeof raw === "string")
+    return raw;
+  if (raw && typeof raw === "object" && Object.keys(raw).length > 0) {
+    return JSON.stringify(raw);
+  }
+  return "";
+}
+function parseToolUse(parsed) {
+  if (parsed.name && parsed.toolUseId) {
+    return {
+      type: "toolUse",
+      data: {
+        name: parsed.name,
+        toolUseId: parsed.toolUseId,
+        input: toolInput(parsed.input),
+        stop: parsed.stop
+      }
+    };
+  }
+  if (parsed.input !== void 0) {
+    return { type: "toolUseInput", data: { input: toolInput(parsed.input) } };
+  }
+  if (parsed.stop !== void 0)
+    return { type: "toolUseStop", data: { stop: parsed.stop } };
+  return null;
+}
+function parseMetadata(parsed) {
+  const tu = parsed.tokenUsage ?? {};
+  const data = {
+    inputTokens: tokenCount(tu.uncachedInputTokens) ?? tokenCount(tu.inputTokens),
+    outputTokens: tokenCount(tu.outputTokens),
+    totalTokens: tokenCount(tu.totalTokens),
+    cacheReadInputTokens: firstTokenCount(tu, CACHE_READ_KEYS),
+    cacheWriteInputTokens: firstTokenCount(tu, CACHE_WRITE_KEYS),
+    contextUsagePercentage: num(tu.contextUsagePercentage),
+    normalizedTokenUsage: num(tu.normalizedTokenUsage),
+    rawStopReason: str(parsed.stopReason),
+    stopDetails: parsed.stopDetails && typeof parsed.stopDetails === "object" ? parsed.stopDetails : void 0
+  };
+  for (const k of Object.keys(data)) {
+    if (data[k] === void 0)
+      delete data[k];
+  }
+  return Object.keys(data).length > 0 ? { type: "usage", data } : null;
+}
+function parseError(parsed, kind, fallbackName) {
+  const rawError = parsed.error ?? parsed.Error;
+  const error2 = typeof rawError === "string" ? rawError : rawError !== void 0 ? JSON.stringify(rawError) : str(parsed.name) ?? fallbackName;
+  const message = parsed.message ?? parsed.Message ?? parsed.reason;
+  const data = { error: error2, kind };
+  if (typeof message === "string")
+    data.message = message;
+  const reason = str(parsed.reason);
+  if (reason !== void 0)
+    data.reason = reason;
+  const retryAfterMilliseconds = num(parsed.retryAfterMilliseconds);
+  if (retryAfterMilliseconds !== void 0)
+    data.retryAfterMilliseconds = retryAfterMilliseconds;
+  return { type: "error", data };
+}
+function parseKiroEvent(key, parsed) {
+  switch (key) {
+    case "assistantResponseEvent": {
+      const content = str(parsed.content);
+      return content !== void 0 ? { type: "content", data: content } : null;
+    }
+    case "reasoningContentEvent": {
+      const text = str(parsed.text);
+      if (text !== void 0)
+        return { type: "thinkingText", data: text };
+      const signature = str(parsed.signature);
+      if (signature !== void 0)
+        return { type: "thinkingSignature", data: signature };
+      return { type: "ignored", data: { key } };
+    }
+    case "toolUseEvent":
+      return parseToolUse(parsed);
+    case "contextUsageEvent": {
+      const pct = num(parsed.contextUsagePercentage);
+      return pct !== void 0 ? { type: "contextUsage", data: { contextUsagePercentage: pct } } : null;
+    }
+    case "metadataEvent":
+      return parseMetadata(parsed);
+    case "meteringEvent":
+      return {
+        type: "metering",
+        data: { credits: tokenCount(parsed.usage), unit: str(parsed.unit), unitPlural: str(parsed.unitPlural) }
       };
-      const deserialized = await deserializer(event);
-      if (deserialized.$unknown)
-        return;
-      return deserialized;
-    } else {
-      throw Error(`Unrecognizable event type: ${message.headers[":event-type"].value}`);
+    // Reachable when a member that models an exception is delivered as an
+    // ordinary event frame. The real wire uses exception framing, handled by
+    // parseKiroExceptionFrame, but both routes must agree.
+    case "error":
+    case "throttlingError":
+    case "validationError":
+    case "serviceUnavailableError": {
+      const member = lookupKiroErrorMember(key);
+      return parseError(parsed, member.kind, member.exception);
     }
-  };
+    // Known members with no consumer yet: explicitly ignored, not unparseable.
+    case "codeReferenceEvent":
+    case "documentCitationEvent":
+    case "toolResultEvent":
+      return { type: "ignored", data: { key } };
+    default: {
+      const member = lookupKiroErrorMember(key);
+      if (member)
+        return parseError(parsed, member.kind, member.exception);
+      return parseKiroEventByShape(parsed);
+    }
+  }
 }
-
-// ../../node_modules/.pnpm/@smithy+core@3.34.1/node_modules/@smithy/core/dist-es/submodules/event-streams/eventstream-serde-universal/EventStreamMarshaller.js
-var EventStreamMarshaller = class {
-  eventStreamCodec;
-  utfEncoder;
-  constructor({ utf8Encoder, utf8Decoder }) {
-    this.eventStreamCodec = new EventStreamCodec(utf8Encoder, utf8Decoder);
-    this.utfEncoder = utf8Encoder;
+function parseKiroExceptionFrame(key, parsed) {
+  const member = lookupKiroErrorMember(key);
+  if (!member)
+    return null;
+  const event = parseError(parsed, member.kind, member.exception);
+  return event.data;
+}
+function parseKiroEventByShape(parsed) {
+  if (parsed.content !== void 0)
+    return { type: "content", data: parsed.content };
+  if (typeof parsed.text === "string")
+    return { type: "thinkingText", data: parsed.text };
+  if (typeof parsed.signature === "string")
+    return { type: "thinkingSignature", data: parsed.signature };
+  if (parsed.name && parsed.toolUseId)
+    return parseToolUse(parsed);
+  if (parsed.input !== void 0 && !parsed.name) {
+    return { type: "toolUseInput", data: { input: toolInput(parsed.input) } };
   }
-  deserialize(body, deserializer) {
-    const inputStream = getChunkedStream(body);
-    return new SmithyMessageDecoderStream({
-      messageStream: new MessageDecoderStream({ inputStream, decoder: this.eventStreamCodec }),
-      deserializer: getMessageUnmarshaller(deserializer, this.utfEncoder)
-    });
+  if (parsed.stop !== void 0 && parsed.contextUsagePercentage === void 0)
+    return { type: "toolUseStop", data: { stop: parsed.stop } };
+  if (parsed.contextUsagePercentage !== void 0)
+    return { type: "contextUsage", data: { contextUsagePercentage: parsed.contextUsagePercentage } };
+  if (parsed.followupPrompt !== void 0)
+    return { type: "followupPrompt", data: parsed.followupPrompt };
+  if (parsed.tokenUsage !== void 0 || parsed.stopReason !== void 0 || parsed.stopDetails !== void 0) {
+    return parseMetadata(parsed);
   }
-  serialize(inputStream, serializer) {
-    return new MessageEncoderStream({
-      messageStream: new SmithyMessageEncoderStream({ inputStream, serializer }),
-      encoder: this.eventStreamCodec,
-      includeEndFrame: true
-    });
+  if (parsed.error !== void 0 || parsed.Error !== void 0) {
+    return parseError(parsed, "unknown", "unknown");
   }
-};
+  if (typeof parsed.usage === "number") {
+    return {
+      type: "metering",
+      data: { credits: tokenCount(parsed.usage), unit: str(parsed.unit), unitPlural: str(parsed.unitPlural) }
+    };
+  }
+  return null;
+}
 
 // ../kiro-core/dist/response-stream.js
-init_debug();
 var IDLE_TIMEOUT = 3e5;
 var eventStreamMarshaller = new EventStreamMarshaller({
   utf8Encoder: (input) => new TextDecoder().decode(input),
@@ -5036,22 +5546,15 @@ function readKiroEventStream(body, options) {
 }
 
 // ../kiro-core/dist/stream.js
-import { createHash as createHash3 } from "node:crypto";
-init_debug();
-init_effort();
-init_endpoints();
-init_kiro_cli();
-init_management();
-init_models();
-init_oauth();
+init_retry();
 init_token_type();
 
 // ../kiro-core/dist/transport.js
 import { appendFile, mkdir } from "node:fs/promises";
 import { homedir as homedir5 } from "node:os";
-import { join as join5 } from "node:path";
-var CAPACITY_LOG_DIR = join5(homedir5(), ".ns-kiro-provider", "logs");
-var CAPACITY_LOG_FILE = join5(CAPACITY_LOG_DIR, "capacity-retries.log");
+import { join as join6 } from "node:path";
+var CAPACITY_LOG_DIR = join6(homedir5(), ".ns-kiro-provider", "logs");
+var CAPACITY_LOG_FILE = join6(CAPACITY_LOG_DIR, "capacity-retries.log");
 var capacityLogDirCreated = false;
 function logCapacityEvent(message) {
   (async () => {
@@ -5169,6 +5672,9 @@ function describeReturnedContent(kinds) {
 }
 var skipProfileResolutionForTests = false;
 var TEST_PROFILE_ARN = "arn:aws:codewhisperer:us-east-1:000000000000:profile/test";
+function testProfileArnOverride() {
+  return skipProfileResolutionForTests ? TEST_PROFILE_ARN : void 0;
+}
 function throwOnTerminalWireStop(wireStopReason, stopDetails) {
   switch (wireStopReason) {
     case "MODEL_CONTEXT_WINDOW_EXCEEDED":
@@ -5180,6 +5686,9 @@ function throwOnTerminalWireStop(wireStopReason, stopDetails) {
   }
 }
 async function* streamKiro(request) {
+  yield* streamKiroOnEngine(request, streamKiroInProcess);
+}
+async function* streamKiroInProcess(request) {
   const { model, signal } = request;
   const initialAccessToken = request.accessToken;
   if (!initialAccessToken) {
@@ -5478,7 +5987,167 @@ ${systemPrompt}` : ""}`;
   }
 }
 
+// ../kiro-core/dist/engine.js
+var KIRO_SIDECAR_VENDOR = "kiro";
+function selectKiroEngine() {
+  return selectBridgeEngine(KIRO_SIDECAR_VENDOR);
+}
+function toKiroSidecarRequest(request, conversationId) {
+  const { signal: _signal, ...wire } = request;
+  const kiroModelId = resolveKiroModel(request.model.id, request.model.kiroModelId);
+  const testProfileArn = testProfileArnOverride();
+  return {
+    ...wire,
+    model: { ...request.model, kiroModelId },
+    conversationId,
+    profileArnCache: snapshotKiroProfileArnCache(),
+    timeouts: {
+      firstTokenMs: request.model.firstTokenTimeout ?? firstTokenTimeoutForModel(request.model.id),
+      requestHeaderMs: retryConfig.requestHeaderTimeoutMs
+    },
+    capacityRetry: { ...capacityRetryConfig },
+    ...testProfileArn ? { testProfileArn } : {}
+  };
+}
+async function* postProcess(events, request, conversationId) {
+  let pendingUsage;
+  for await (const event of events) {
+    if (event.type === "usage") {
+      pendingUsage = event;
+      continue;
+    }
+    if (event.type !== "done") {
+      yield event;
+      continue;
+    }
+    const { kiroProfileArns, kiroRuntimeRegion, kiroProfileArn, ...done } = event;
+    applyKiroProfileArnCacheChanges(kiroProfileArns);
+    const region = kiroRuntimeRegion ?? getKiroRegionFromProfileArn(kiroProfileArn) ?? request.model.region;
+    if (!process.env.VITEST && region && kiroProfileArn && isCacheStale(region)) {
+      updateKiroModelsCache(request.accessToken, region, kiroProfileArn).catch((error2) => {
+        console.warn(`[kiro-core] Failed to refresh Kiro model catalog in ${region}: ${formatSafeError(error2)}`);
+      });
+    }
+    if (pendingUsage) {
+      const { kiroWireCache, ...usageEvent } = pendingUsage;
+      if (!done.errorMessage) {
+        const estimatedRead = applyCacheEstimate(conversationId, usageEvent.usage, kiroWireCache ? { cacheReadInputTokens: 0 } : null, request.usageTracking ?? KIRO_USAGE_TRACKING_DISABLED);
+        if (estimatedRead > 0) {
+          debugLog("usage.estimate", {
+            conversationId,
+            estimatedRead,
+            input: usageEvent.usage.input,
+            cacheRead: usageEvent.usage.cacheRead
+          });
+        }
+      }
+      pendingUsage = void 0;
+      yield usageEvent;
+    }
+    yield done;
+  }
+  if (pendingUsage) {
+    const { kiroWireCache: _wire, ...usageEvent } = pendingUsage;
+    yield usageEvent;
+  }
+}
+function streamKiroOnEngine(request, inProcess) {
+  if (selectKiroEngine() === "ts" || !request.accessToken)
+    return inProcess(request);
+  const conversationId = request.sessionId ?? crypto.randomUUID();
+  let sidecarRequest;
+  try {
+    sidecarRequest = toKiroSidecarRequest(request, conversationId);
+  } catch {
+    return inProcess(request);
+  }
+  return engineStream({
+    vendor: KIRO_SIDECAR_VENDOR,
+    request: () => sidecarRequest,
+    inProcess: () => inProcess(request),
+    mapError: kiroErrorFromSidecar,
+    transform: (events) => postProcess(events, request, conversationId),
+    ...request.signal ? { signal: request.signal } : {}
+  });
+}
+
+// ../kiro-core/dist/index.js
+init_engine_ops();
+init_errors2();
+
+// ../kiro-core/dist/host-auth.js
+init_endpoints();
+init_oauth();
+var KIRO_NO_SESSION_MESSAGE = "No Kiro session found. Sign in with `kiro-cli login` (Builder ID, IAM Identity Center, Google, or GitHub), then run /login kiro again \u2014 or paste a Kiro API key below.";
+async function loginKiroFromSession(callbacks) {
+  callbacks.onProgress?.("Looking for an existing Kiro session\u2026");
+  const existing = await resolveKiroCredentials();
+  if (existing) {
+    callbacks.onProgress?.(`Using the ${existing.authMethod} session from kiro-cli.`);
+    return existing;
+  }
+  if (!callbacks.onPrompt)
+    throw new Error(KIRO_NO_SESSION_MESSAGE);
+  const apiKey = (await callbacks.onPrompt({
+    message: KIRO_NO_SESSION_MESSAGE,
+    placeholder: "ksk_\u2026",
+    allowEmpty: true,
+    secret: true
+  })).trim();
+  if (!apiKey)
+    throw new Error(KIRO_NO_SESSION_MESSAGE);
+  return loginKiroWithApiKey(apiKey, callbacks.onProgress);
+}
+async function resolveKiroRequestCredentials(hostKey) {
+  const stored = await resolveKiroCredentials();
+  const region = resolveApiRegion(stored?.region);
+  if (hostKey && (isApiKey(hostKey) || hostKey === stored?.access)) {
+    return { accessToken: hostKey, region, ...stored?.profileArn ? { profileArn: stored.profileArn } : {} };
+  }
+  if (stored) {
+    return {
+      accessToken: stored.access,
+      region,
+      ...stored.profileArn ? { profileArn: stored.profileArn } : {}
+    };
+  }
+  if (hostKey)
+    return { accessToken: hostKey, region };
+  throw new Error("Kiro credentials not set. Run `kiro-cli login`, or set KIRO_API_KEY to a `ksk_` API key.");
+}
+
+// ../kiro-core/dist/host-model.js
+init_models();
+function toKiroModelForHost(model, region) {
+  const known = getCachedModels(region).find((candidate) => candidate.id === model.id);
+  return {
+    ...known ?? {
+      id: model.id,
+      // No fallback to `model.id`: that dash-spelled local id is not a valid
+      // Kiro wire id. `""` is falsy, so `resolveKiroModel` runs its own
+      // cache/bootstrap/dot-normalize resolution instead of being
+      // short-circuited by a value that is really just `model.id` again.
+      kiroModelId: model.kiroModelId ?? "",
+      name: model.name,
+      reasoning: model.reasoning,
+      input: [...model.input],
+      cost: { ...model.cost },
+      contextWindow: model.contextWindow ?? 2e5,
+      maxTokens: model.maxTokens ?? 8192
+    },
+    region,
+    ...model.kiroProfileArn ? { profileArn: model.kiroProfileArn } : {},
+    ...model.additionalModelRequestFieldsSchema ? { additionalModelRequestFieldsSchema: model.additionalModelRequestFieldsSchema } : {}
+  };
+}
+
 // ../kiro-core/dist/index.js
+init_kiro_cli();
+init_kiro_ide();
+init_management();
+init_models();
+init_oauth();
+init_retry();
 init_types();
 
 // ../kiro-core/dist/usage.js
@@ -5543,6 +6212,10 @@ async function fetchRawUsage(auth, profileArn) {
   });
 }
 async function fetchKiroUsage(credentials) {
+  const { runKiroOp: runKiroOp2 } = await Promise.resolve().then(() => (init_engine_ops(), engine_ops_exports));
+  return runKiroOp2("usage", () => ({ credentials }), () => fetchKiroUsageInProcess(credentials));
+}
+async function fetchKiroUsageInProcess(credentials) {
   const auth = { accessToken: credentials.access, region: resolveApiRegion(credentials.region) };
   const raw = await fetchRawUsage(auth, credentials.profileArn);
   const usageBuckets = raw.usageBreakdownList?.length ? raw.usageBreakdownList.map(mapBucket) : raw.usageBreakdown ? [mapBucket(raw.usageBreakdown, 0)] : [];