@shareai-lab/kode 2.0.1 → 2.0.3

package/dist/chunks/chunk-XR2W3MAM.js

@@ -0,0 +1,1533 @@
+import {
+  BunShell
+} from "./chunk-B3MW3YGY.js";
+
+// packages/config/src/schema.ts
+import { homedir } from "node:os";
+var DEFAULT_PROJECT_CONFIG = {
+  allowedTools: [],
+  deniedTools: [],
+  askedTools: [],
+  context: {},
+  history: [],
+  dontCrawlDirectory: false,
+  enableArchitectTool: false,
+  mcpContextUris: [],
+  mcpServers: {},
+  approvedMcprcServers: [],
+  rejectedMcprcServers: [],
+  hasTrustDialogAccepted: false
+};
+function defaultConfigForProject(projectPath) {
+  const config = { ...DEFAULT_PROJECT_CONFIG };
+  if (projectPath === homedir()) {
+    config.dontCrawlDirectory = true;
+  }
+  return config;
+}
+function isAutoUpdaterStatus(value) {
+  return ["disabled", "enabled", "no_permissions", "not_configured"].includes(
+    value
+  );
+}
+var DEFAULT_GLOBAL_CONFIG = {
+  numStartups: 0,
+  autoUpdaterStatus: "not_configured",
+  theme: "dark",
+  preferredNotifChannel: "iterm2",
+  verbose: false,
+  primaryProvider: "anthropic",
+  customApiKeyResponses: {
+    approved: [],
+    rejected: []
+  },
+  stream: true,
+  modelProfiles: [],
+  modelPointers: {
+    main: "",
+    task: "",
+    compact: "",
+    quick: ""
+  },
+  lastDismissedUpdateVersion: void 0
+};
+var GLOBAL_CONFIG_KEYS = [
+  "autoUpdaterStatus",
+  "theme",
+  "hasCompletedOnboarding",
+  "lastOnboardingVersion",
+  "lastReleaseNotesSeen",
+  "verbose",
+  "customApiKeyResponses",
+  "primaryProvider",
+  "preferredNotifChannel",
+  "maxTokens"
+];
+function isGlobalConfigKey(key) {
+  return GLOBAL_CONFIG_KEYS.includes(key);
+}
+var PROJECT_CONFIG_KEYS = [
+  "dontCrawlDirectory",
+  "enableArchitectTool",
+  "hasTrustDialogAccepted",
+  "hasCompletedProjectOnboarding"
+];
+function isProjectConfigKey(key) {
+  return PROJECT_CONFIG_KEYS.includes(key);
+}
+
+// packages/config/src/paths.ts
+import { join } from "node:path";
+import { homedir as homedir2 } from "node:os";
+var CONFIG_BASE_DIR = ".kode";
+var CONFIG_FILE = ".kode.json";
+function getKodeBaseDir() {
+  return process.env.KODE_CONFIG_DIR ?? process.env.CLAUDE_CONFIG_DIR ?? join(homedir2(), CONFIG_BASE_DIR);
+}
+function getGlobalConfigFilePath() {
+  return process.env.KODE_CONFIG_DIR || process.env.CLAUDE_CONFIG_DIR ? join(getKodeBaseDir(), "config.json") : join(homedir2(), CONFIG_FILE);
+}
+
+// packages/config/src/errors.ts
+var ConfigParseError = class extends Error {
+  filePath;
+  defaultConfig;
+  constructor(message, filePath, defaultConfig) {
+    super(message);
+    this.name = "ConfigParseError";
+    this.filePath = filePath;
+    this.defaultConfig = defaultConfig;
+  }
+};
+
+// packages/config/src/loader.ts
+import { randomBytes } from "node:crypto";
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { cloneDeep } from "lodash-es";
+
+// packages/config/src/json.ts
+function safeParseJSON(value) {
+  try {
+    return JSON.parse(value);
+  } catch {
+    return null;
+  }
+}
+
+// packages/config/src/debugLogger.ts
+function shouldLog() {
+  const enabled = process.env.KODE_DEBUG_CONFIG ?? process.env.KODE_DEBUG ?? process.env.DEBUG ?? "";
+  return ["1", "true", "yes", "on"].includes(
+    String(enabled).trim().toLowerCase()
+  );
+}
+function write(level, event, data) {
+  if (!shouldLog()) return;
+  const suffix = data ? ` ${JSON.stringify(data)}` : "";
+  console.log(`[config:${level}] ${event}${suffix}`);
+}
+var debug = {
+  state(event, data) {
+    write("state", event, data);
+  },
+  info(event, data) {
+    write("info", event, data);
+  },
+  api(event, data) {
+    write("api", event, data);
+  },
+  warn(event, data) {
+    write("warn", event, data);
+  },
+  error(event, data) {
+    write("error", event, data);
+  }
+};
+
+// packages/config/src/cwd.ts
+function getCwd() {
+  return BunShell.getInstance().pwd();
+}
+
+// packages/config/src/models/migrations.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function readString(record, key) {
+  if (!record) return "";
+  const value = record[key];
+  return typeof value === "string" ? value : "";
+}
+function migrateModelProfilesRemoveId(config) {
+  if (!config.modelProfiles || config.modelProfiles.length === 0) return config;
+  const idToModelNameMap = /* @__PURE__ */ new Map();
+  const migratedProfiles = config.modelProfiles.map((profile) => {
+    const raw = profile;
+    if (!isRecord(raw)) return profile;
+    const maybeId = raw["id"];
+    if (typeof maybeId === "string" && profile.modelName) {
+      idToModelNameMap.set(maybeId, profile.modelName);
+    }
+    const { id: _ignored, ...rest } = raw;
+    return rest;
+  });
+  const migratedPointers = {
+    main: "",
+    task: "",
+    compact: "",
+    quick: ""
+  };
+  const pointersRaw = config.modelPointers;
+  const pointers = isRecord(pointersRaw) ? pointersRaw : null;
+  const rawMain = readString(pointers, "main");
+  const rawTask = readString(pointers, "task");
+  const rawQuick = readString(pointers, "quick");
+  const rawCompact = readString(pointers, "compact") || readString(pointers, "reasoning");
+  if (rawMain) migratedPointers.main = idToModelNameMap.get(rawMain) ?? rawMain;
+  if (rawTask) migratedPointers.task = idToModelNameMap.get(rawTask) ?? rawTask;
+  if (rawCompact)
+    migratedPointers.compact = idToModelNameMap.get(rawCompact) ?? rawCompact;
+  if (rawQuick)
+    migratedPointers.quick = idToModelNameMap.get(rawQuick) ?? rawQuick;
+  const configRaw = config;
+  const configRecord = isRecord(configRaw) ? configRaw : null;
+  const legacyDefaultModelId = readString(configRecord, "defaultModelId");
+  const legacyDefaultModelName = readString(configRecord, "defaultModelName");
+  let defaultModelName = config.defaultModelName;
+  if (legacyDefaultModelId) {
+    defaultModelName = idToModelNameMap.get(legacyDefaultModelId) ?? legacyDefaultModelId;
+  } else if (legacyDefaultModelName) {
+    defaultModelName = legacyDefaultModelName;
+  }
+  if (!configRecord) {
+    return {
+      ...config,
+      modelProfiles: migratedProfiles,
+      modelPointers: migratedPointers,
+      defaultModelName
+    };
+  }
+  const migratedConfig = { ...configRecord };
+  delete migratedConfig["defaultModelId"];
+  delete migratedConfig["currentSelectedModelId"];
+  delete migratedConfig["mainAgentModelId"];
+  delete migratedConfig["taskToolModelId"];
+  return {
+    ...migratedConfig,
+    modelProfiles: migratedProfiles,
+    modelPointers: migratedPointers,
+    defaultModelName
+  };
+}
+
+// packages/config/src/loader.ts
+function isRecord2(value) {
+  return typeof value === "object" && value !== null;
+}
+function isStringArray(value) {
+  return Array.isArray(value) && value.every((v) => typeof v === "string");
+}
+function normalizeStringArray(value) {
+  if (isStringArray(value)) return value;
+  if (typeof value === "string") {
+    const parsed = safeParseJSON(value);
+    if (isStringArray(parsed)) return parsed;
+  }
+  return void 0;
+}
+function normalizeLegacyProjectConfig(projectConfig) {
+  const raw = projectConfig;
+  if (!isRecord2(raw)) return projectConfig;
+  const allowedTools = normalizeStringArray(raw["allowedTools"]) ?? projectConfig.allowedTools;
+  const deniedTools = normalizeStringArray(raw["deniedTools"]) ?? projectConfig.deniedTools;
+  const askedTools = normalizeStringArray(raw["askedTools"]) ?? projectConfig.askedTools;
+  return { ...projectConfig, allowedTools, deniedTools, askedTools };
+}
+function saveConfig(file, config, defaultConfig) {
+  const filteredConfig = Object.fromEntries(
+    Object.entries(config).filter(
+      ([key, value]) => JSON.stringify(value) !== JSON.stringify(defaultConfig[key])
+    )
+  );
+  try {
+    writeFileSync(file, JSON.stringify(filteredConfig, null, 2), "utf-8");
+  } catch (error) {
+    const err = error;
+    if (err.code === "EACCES" || err.code === "EPERM" || err.code === "EROFS") {
+      debug.state("CONFIG_SAVE_SKIPPED", {
+        file,
+        reason: String(err.code)
+      });
+      return;
+    }
+    throw error;
+  }
+}
+function getConfig(file, defaultConfig, throwOnInvalid) {
+  debug.state("CONFIG_LOAD_START", {
+    file,
+    fileExists: String(existsSync(file)),
+    throwOnInvalid: String(Boolean(throwOnInvalid))
+  });
+  if (!existsSync(file)) {
+    debug.state("CONFIG_LOAD_DEFAULT", {
+      file,
+      reason: "file_not_exists",
+      defaultConfigKeys: Object.keys(defaultConfig).join(", ")
+    });
+    return cloneDeep(defaultConfig);
+  }
+  try {
+    const fileContent = readFileSync(file, "utf-8");
+    debug.state("CONFIG_FILE_READ", {
+      file,
+      contentLength: String(fileContent.length),
+      contentPreview: fileContent.substring(0, 100) + (fileContent.length > 100 ? "..." : "")
+    });
+    try {
+      const parsedConfig = JSON.parse(fileContent);
+      debug.state("CONFIG_JSON_PARSED", {
+        file,
+        parsedKeys: isRecord2(parsedConfig) ? Object.keys(parsedConfig).join(", ") : ""
+      });
+      const finalConfig = {
+        ...cloneDeep(defaultConfig),
+        ...isRecord2(parsedConfig) ? parsedConfig : {}
+      };
+      debug.state("CONFIG_LOAD_SUCCESS", {
+        file,
+        finalConfigKeys: Object.keys(finalConfig).join(", ")
+      });
+      return finalConfig;
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      debug.error("CONFIG_JSON_PARSE_ERROR", {
+        file,
+        errorMessage: message,
+        errorType: error instanceof Error ? error.constructor.name : typeof error,
+        contentLength: String(fileContent.length)
+      });
+      throw new ConfigParseError(message, file, defaultConfig);
+    }
+  } catch (error) {
+    if (error instanceof ConfigParseError && throwOnInvalid) {
+      debug.error("CONFIG_PARSE_ERROR_RETHROWN", {
+        file,
+        throwOnInvalid: String(Boolean(throwOnInvalid)),
+        errorMessage: error.message
+      });
+      throw error;
+    }
+    debug.warn("CONFIG_FALLBACK_TO_DEFAULT", {
+      file,
+      errorType: error instanceof Error ? error.constructor.name : typeof error,
+      errorMessage: error instanceof Error ? error.message : String(error),
+      action: "using_default_config"
+    });
+    return cloneDeep(defaultConfig);
+  }
+}
+var TEST_GLOBAL_CONFIG_FOR_TESTING = {
+  ...DEFAULT_GLOBAL_CONFIG,
+  autoUpdaterStatus: "disabled"
+};
+var TEST_PROJECT_CONFIG_FOR_TESTING = {
+  ...defaultConfigForProject(getCwd())
+};
+function enableConfigs() {
+  getConfig(getGlobalConfigFilePath(), DEFAULT_GLOBAL_CONFIG, true);
+}
+function saveGlobalConfig(config) {
+  if (process.env.NODE_ENV === "test") {
+    Object.assign(TEST_GLOBAL_CONFIG_FOR_TESTING, config);
+    return;
+  }
+  saveConfig(
+    getGlobalConfigFilePath(),
+    {
+      ...config,
+      projects: getConfig(getGlobalConfigFilePath(), DEFAULT_GLOBAL_CONFIG).projects
+    },
+    DEFAULT_GLOBAL_CONFIG
+  );
+}
+function getGlobalConfig() {
+  if (process.env.NODE_ENV === "test") return TEST_GLOBAL_CONFIG_FOR_TESTING;
+  const config = getConfig(getGlobalConfigFilePath(), DEFAULT_GLOBAL_CONFIG);
+  return migrateModelProfilesRemoveId(config);
+}
+function checkHasTrustDialogAccepted() {
+  let currentPath = getCwd();
+  const config = getConfig(getGlobalConfigFilePath(), DEFAULT_GLOBAL_CONFIG);
+  while (true) {
+    const projectConfig = config.projects?.[currentPath];
+    if (projectConfig?.hasTrustDialogAccepted) return true;
+    const parentPath = resolve(currentPath, "..");
+    if (parentPath === currentPath) break;
+    currentPath = parentPath;
+  }
+  return false;
+}
+function getCurrentProjectConfig() {
+  if (process.env.NODE_ENV === "test") return TEST_PROJECT_CONFIG_FOR_TESTING;
+  const absolutePath = resolve(getCwd());
+  const config = getConfig(getGlobalConfigFilePath(), DEFAULT_GLOBAL_CONFIG);
+  if (!config.projects) return defaultConfigForProject(absolutePath);
+  const projectConfig = config.projects[absolutePath] ?? defaultConfigForProject(absolutePath);
+  return normalizeLegacyProjectConfig(projectConfig);
+}
+function saveCurrentProjectConfig(projectConfig) {
+  if (process.env.NODE_ENV === "test") {
+    Object.assign(TEST_PROJECT_CONFIG_FOR_TESTING, projectConfig);
+    return;
+  }
+  const config = getConfig(getGlobalConfigFilePath(), DEFAULT_GLOBAL_CONFIG);
+  saveConfig(
+    getGlobalConfigFilePath(),
+    {
+      ...config,
+      projects: {
+        ...config.projects,
+        [resolve(getCwd())]: projectConfig
+      }
+    },
+    DEFAULT_GLOBAL_CONFIG
+  );
+}
+async function isAutoUpdaterDisabled() {
+  const status = getGlobalConfig().autoUpdaterStatus;
+  return status !== "enabled";
+}
+function getOrCreateUserID() {
+  const config = getGlobalConfig();
+  if (config.userID) return config.userID;
+  const userID = randomBytes(32).toString("hex");
+  saveGlobalConfig({ ...config, userID });
+  return userID;
+}
+function normalizeApiKeyForConfig(apiKey) {
+  return apiKey.slice(-20);
+}
+function getCustomApiKeyStatus(truncatedApiKey) {
+  const config = getGlobalConfig();
+  if (config.customApiKeyResponses?.approved?.includes(truncatedApiKey)) {
+    return "approved";
+  }
+  if (config.customApiKeyResponses?.rejected?.includes(truncatedApiKey)) {
+    return "rejected";
+  }
+  return "new";
+}
+
+// packages/config/src/mcp.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "node:fs";
+import { join as join2 } from "node:path";
+import { memoize } from "lodash-es";
+var TEST_MCPRC_CONFIG_FOR_TESTING = {};
+function clearMcprcConfigForTesting() {
+  if (process.env.NODE_ENV !== "test") return;
+  for (const key of Object.keys(TEST_MCPRC_CONFIG_FOR_TESTING)) {
+    delete TEST_MCPRC_CONFIG_FOR_TESTING[key];
+  }
+}
+function addMcprcServerForTesting(name, server) {
+  if (process.env.NODE_ENV === "test") {
+    TEST_MCPRC_CONFIG_FOR_TESTING[name] = server;
+  }
+}
+function removeMcprcServerForTesting(name) {
+  if (process.env.NODE_ENV !== "test") return;
+  if (!TEST_MCPRC_CONFIG_FOR_TESTING[name]) {
+    throw new Error(`No MCP server found with name: ${name} in .mcprc`);
+  }
+  delete TEST_MCPRC_CONFIG_FOR_TESTING[name];
+}
+function isRecord3(value) {
+  return typeof value === "object" && value !== null;
+}
+var getMcprcConfig = memoize(
+  () => {
+    if (process.env.NODE_ENV === "test") return TEST_MCPRC_CONFIG_FOR_TESTING;
+    const mcprcPath = join2(getCwd(), ".mcprc");
+    if (!existsSync2(mcprcPath)) return {};
+    try {
+      const mcprcContent = readFileSync2(mcprcPath, "utf-8");
+      const parsed = safeParseJSON(mcprcContent);
+      if (isRecord3(parsed)) return parsed;
+    } catch {
+    }
+    return {};
+  },
+  () => {
+    const cwd = getCwd();
+    const mcprcPath = join2(cwd, ".mcprc");
+    if (!existsSync2(mcprcPath)) return cwd;
+    try {
+      return `${cwd}:${readFileSync2(mcprcPath, "utf-8")}`;
+    } catch {
+      return cwd;
+    }
+  }
+);
+function parseMcpServersFromMcpJson(value) {
+  if (!isRecord3(value)) return {};
+  const raw = value["mcpServers"];
+  if (!isRecord3(raw)) return {};
+  return raw;
+}
+function parseMcpServersFromMcprc(value) {
+  if (!isRecord3(value)) return {};
+  const maybeNested = value["mcpServers"];
+  if (isRecord3(maybeNested))
+    return maybeNested;
+  return value;
+}
+var getProjectMcpServerDefinitions = memoize(
+  () => {
+    if (process.env.NODE_ENV === "test") {
+      return {
+        servers: {},
+        sources: {},
+        mcpJsonPath: join2(getCwd(), ".mcp.json"),
+        mcprcPath: join2(getCwd(), ".mcprc")
+      };
+    }
+    const cwd = getCwd();
+    const mcpJsonPath = join2(cwd, ".mcp.json");
+    const mcprcPath = join2(cwd, ".mcprc");
+    let mcpJsonServers = {};
+    let mcprcServers = {};
+    if (existsSync2(mcpJsonPath)) {
+      try {
+        const parsed = safeParseJSON(readFileSync2(mcpJsonPath, "utf-8"));
+        mcpJsonServers = parseMcpServersFromMcpJson(parsed);
+      } catch {
+      }
+    }
+    if (existsSync2(mcprcPath)) {
+      try {
+        const parsed = safeParseJSON(readFileSync2(mcprcPath, "utf-8"));
+        mcprcServers = parseMcpServersFromMcprc(parsed);
+      } catch {
+      }
+    }
+    const sources = {};
+    for (const name of Object.keys(mcpJsonServers)) sources[name] = ".mcp.json";
+    for (const name of Object.keys(mcprcServers)) sources[name] = ".mcprc";
+    return {
+      servers: { ...mcpJsonServers, ...mcprcServers },
+      sources,
+      mcpJsonPath,
+      mcprcPath
+    };
+  },
+  () => {
+    const cwd = getCwd();
+    const mcpJsonPath = join2(cwd, ".mcp.json");
+    const mcprcPath = join2(cwd, ".mcprc");
+    const parts = [cwd];
+    if (existsSync2(mcpJsonPath)) {
+      try {
+        parts.push("mcp.json", readFileSync2(mcpJsonPath, "utf-8"));
+      } catch {
+      }
+    }
+    if (existsSync2(mcprcPath)) {
+      try {
+        parts.push("mcprc", readFileSync2(mcprcPath, "utf-8"));
+      } catch {
+      }
+    }
+    return parts.join(":");
+  }
+);
+
+// packages/config/src/cli.ts
+import { pick } from "lodash-es";
+function getConfigForCLI(key, global) {
+  if (global) {
+    if (!isGlobalConfigKey(key)) {
+      console.error(
+        `Error: '${key}' is not a valid config key. Valid keys are: ${GLOBAL_CONFIG_KEYS.join(", ")}`
+      );
+      process.exit(1);
+    }
+    return getGlobalConfig()[key];
+  }
+  if (!isProjectConfigKey(key)) {
+    console.error(
+      `Error: '${key}' is not a valid config key. Valid keys are: ${PROJECT_CONFIG_KEYS.join(", ")}`
+    );
+    process.exit(1);
+  }
+  return getCurrentProjectConfig()[key];
+}
+function setConfigForCLI(key, value, global) {
+  if (global) {
+    if (!isGlobalConfigKey(key)) {
+      console.error(
+        `Error: Cannot set '${key}'. Only these keys can be modified: ${GLOBAL_CONFIG_KEYS.join(", ")}`
+      );
+      process.exit(1);
+    }
+    if (key === "autoUpdaterStatus" && !isAutoUpdaterStatus(String(value))) {
+      console.error(
+        `Error: Invalid value for autoUpdaterStatus. Must be one of: disabled, enabled, no_permissions, not_configured`
+      );
+      process.exit(1);
+    }
+    const currentConfig = getGlobalConfig();
+    saveGlobalConfig({
+      ...currentConfig,
+      [key]: value
+    });
+  } else {
+    if (!isProjectConfigKey(key)) {
+      console.error(
+        `Error: Cannot set '${key}'. Only these keys can be modified: ${PROJECT_CONFIG_KEYS.join(", ")}. Did you mean --global?`
+      );
+      process.exit(1);
+    }
+    const currentConfig = getCurrentProjectConfig();
+    saveCurrentProjectConfig({
+      ...currentConfig,
+      [key]: value
+    });
+  }
+  setTimeout(() => process.exit(0), 100);
+}
+function deleteConfigForCLI(key, global) {
+  if (global) {
+    if (!isGlobalConfigKey(key)) {
+      console.error(
+        `Error: Cannot delete '${key}'. Only these keys can be modified: ${GLOBAL_CONFIG_KEYS.join(", ")}`
+      );
+      process.exit(1);
+    }
+    const currentConfig2 = getGlobalConfig();
+    const next2 = { ...currentConfig2 };
+    delete next2[key];
+    saveGlobalConfig(next2);
+    return;
+  }
+  if (!isProjectConfigKey(key)) {
+    console.error(
+      `Error: Cannot delete '${key}'. Only these keys can be modified: ${PROJECT_CONFIG_KEYS.join(", ")}. Did you mean --global?`
+    );
+    process.exit(1);
+  }
+  const currentConfig = getCurrentProjectConfig();
+  const next = { ...currentConfig };
+  delete next[key];
+  saveCurrentProjectConfig(next);
+}
+function listConfigForCLI(global) {
+  if (global) return pick(getGlobalConfig(), GLOBAL_CONFIG_KEYS);
+  return pick(getCurrentProjectConfig(), PROJECT_CONFIG_KEYS);
+}
+function getOpenAIApiKey() {
+  return process.env.OPENAI_API_KEY;
+}
+function getAnthropicApiKey() {
+  return process.env.ANTHROPIC_API_KEY || "";
+}
+
+// packages/config/src/connectionTest/responsesAPI.ts
+async function testResponsesAPI(config, baseURL, startTime) {
+  const testURL = `${baseURL.replace(/\/+$/, "")}/responses`;
+  const testPayload = {
+    model: config.model,
+    input: [
+      {
+        role: "user",
+        content: 'Please respond with exactly "YES" (in capital letters) to confirm this connection is working.'
+      }
+    ],
+    max_completion_tokens: Math.max(config.maxTokens || 8192, 8192),
+    temperature: 1,
+    // GPT-5 requirement
+    reasoning: {
+      effort: "low"
+      // Fast response for connection test
+    }
+  };
+  const headers = {
+    "Content-Type": "application/json",
+    Authorization: `Bearer ${config.apiKey}`
+  };
+  debug.api("GPT5_CONNECTION_TEST_RESPONSES_REQUEST", {
+    model: config.model,
+    url: testURL
+  });
+  try {
+    const response = await fetch(testURL, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(testPayload)
+    });
+    const responseTime = Date.now() - startTime;
+    if (response.ok) {
+      const data = await response.json();
+      debug.api("GPT5_CONNECTION_TEST_RESPONSES_RESPONSE", {
+        model: config.model,
+        status: response.status
+      });
+      let responseContent = "";
+      if (data.output_text) {
+        responseContent = data.output_text;
+      } else if (data.output && Array.isArray(data.output)) {
+        const messageOutput = data.output.find(
+          (item) => item.type === "message"
+        );
+        if (messageOutput && messageOutput.content) {
+          const textContent = messageOutput.content.find(
+            (c) => c.type === "output_text"
+          );
+          responseContent = textContent?.text || "";
+        }
+      }
+      const containsYes = responseContent.toLowerCase().includes("yes");
+      if (containsYes) {
+        return {
+          success: true,
+          message: "\u2705 GPT-5 Responses API connection successful",
+          endpoint: "/responses",
+          details: `Model responded correctly: "${responseContent.trim()}"`,
+          apiUsed: "responses",
+          responseTime
+        };
+      }
+      return {
+        success: false,
+        message: "\u26A0\uFE0F Responses API connected but unexpected response",
+        endpoint: "/responses",
+        details: `Expected "YES" but got: "${responseContent.trim() || "(empty response)"}"`,
+        apiUsed: "responses",
+        responseTime
+      };
+    }
+    const errorData = await response.json().catch(() => null);
+    const errorMessage = errorData?.error?.message || errorData?.message || response.statusText;
+    debug.warn("GPT5_CONNECTION_TEST_RESPONSES_ERROR", {
+      model: config.model,
+      status: response.status,
+      error: errorMessage
+    });
+    return {
+      success: false,
+      message: `\u274C Responses API failed (${response.status})`,
+      endpoint: "/responses",
+      details: `Error: ${errorMessage}`,
+      apiUsed: "responses",
+      responseTime: Date.now() - startTime
+    };
+  } catch (error) {
+    debug.warn("GPT5_CONNECTION_TEST_RESPONSES_NETWORK_ERROR", {
+      model: config.model,
+      error: error instanceof Error ? error.message : String(error)
+    });
+    return {
+      success: false,
+      message: "\u274C Responses API connection failed",
+      endpoint: "/responses",
+      details: error instanceof Error ? error.message : String(error),
+      apiUsed: "responses",
+      responseTime: Date.now() - startTime
+    };
+  }
+}
+
+// packages/config/src/connectionTest/chatCompletions.ts
+async function testChatCompletionsAPI(config, baseURL, startTime) {
+  const testURL = `${baseURL.replace(/\/+$/, "")}/chat/completions`;
+  const isGPT5 = config.model.toLowerCase().includes("gpt-5");
+  const testPayload = {
+    model: config.model,
+    messages: [
+      {
+        role: "user",
+        content: 'Please respond with exactly "YES" (in capital letters) to confirm this connection is working.'
+      }
+    ],
+    temperature: isGPT5 ? 1 : 0,
+    // GPT-5 requires temperature=1
+    stream: false
+  };
+  if (isGPT5) {
+    testPayload.max_completion_tokens = Math.max(config.maxTokens || 8192, 8192);
+    delete testPayload.max_tokens;
+    debug.api("GPT5_CONNECTION_TEST_MAX_COMPLETION_TOKENS", {
+      model: config.model,
+      max_completion_tokens: testPayload.max_completion_tokens
+    });
+  } else {
+    testPayload.max_tokens = Math.max(config.maxTokens || 8192, 8192);
+  }
+  const headers = {
+    "Content-Type": "application/json"
+  };
+  if (config.provider === "azure") {
+    headers["api-key"] = config.apiKey;
+  } else {
+    headers["Authorization"] = `Bearer ${config.apiKey}`;
+  }
+  debug.api("GPT5_CONNECTION_TEST_CHAT_COMPLETIONS_REQUEST", {
+    model: config.model,
+    url: testURL
+  });
+  try {
+    const response = await fetch(testURL, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(testPayload)
+    });
+    const responseTime = Date.now() - startTime;
+    if (response.ok) {
+      const data = await response.json();
+      debug.api("GPT5_CONNECTION_TEST_CHAT_COMPLETIONS_RESPONSE", {
+        model: config.model,
+        status: response.status
+      });
+      const responseContent = data.choices?.[0]?.message?.content || "";
+      const containsYes = responseContent.toLowerCase().includes("yes");
+      if (containsYes) {
+        return {
+          success: true,
+          message: `\u2705 ${isGPT5 ? "GPT-5" : "Model"} Chat Completions connection successful`,
+          endpoint: "/chat/completions",
+          details: `Model responded correctly: "${responseContent.trim()}"`,
+          apiUsed: "chat_completions",
+          responseTime
+        };
+      }
+      return {
+        success: false,
+        message: "\u26A0\uFE0F Chat Completions connected but unexpected response",
+        endpoint: "/chat/completions",
+        details: `Expected "YES" but got: "${responseContent.trim() || "(empty response)"}"`,
+        apiUsed: "chat_completions",
+        responseTime
+      };
+    }
+    const errorData = await response.json().catch(() => null);
+    const errorMessage = errorData?.error?.message || errorData?.message || response.statusText;
+    debug.warn("GPT5_CONNECTION_TEST_CHAT_COMPLETIONS_ERROR", {
+      model: config.model,
+      status: response.status,
+      error: errorMessage
+    });
+    let details = `Error: ${errorMessage}`;
+    if (response.status === 400 && errorMessage.includes("max_tokens") && isGPT5) {
+      details += "\n\n\u{1F527} GPT-5 Fix Applied: This error suggests a parameter compatibility issue. Please check if the provider supports GPT-5 with max_completion_tokens.";
+    }
+    return {
+      success: false,
+      message: `\u274C Chat Completions failed (${response.status})`,
+      endpoint: "/chat/completions",
+      details,
+      apiUsed: "chat_completions",
+      responseTime: Date.now() - startTime
+    };
+  } catch (error) {
+    debug.warn("GPT5_CONNECTION_TEST_CHAT_COMPLETIONS_NETWORK_ERROR", {
+      model: config.model,
+      error: error instanceof Error ? error.message : String(error)
+    });
+    return {
+      success: false,
+      message: "\u274C Chat Completions connection failed",
+      endpoint: "/chat/completions",
+      details: error instanceof Error ? error.message : String(error),
+      apiUsed: "chat_completions",
+      responseTime: Date.now() - startTime
+    };
+  }
+}
+
+// packages/config/src/connectionTest.ts
+function getModelFeaturesForConnectionTest(modelName) {
+  const normalized = modelName.toLowerCase();
+  if (normalized.includes("gpt-5-chat-latest")) {
+    return { supportsResponsesAPI: false };
+  }
+  if (normalized.includes("gpt-5")) {
+    return { supportsResponsesAPI: true };
+  }
+  return { supportsResponsesAPI: false };
+}
+async function testGPT5Connection(config) {
+  const startTime = Date.now();
+  if (!config.model || !config.apiKey) {
+    return {
+      success: false,
+      message: "Invalid configuration",
+      details: "Model name and API key are required"
+    };
+  }
+  const isGPT5 = config.model.toLowerCase().includes("gpt-5");
+  const modelFeatures = getModelFeaturesForConnectionTest(config.model);
+  const baseURL = config.baseURL || "https://api.openai.com/v1";
+  const isOfficialOpenAI = !config.baseURL || config.baseURL.includes("api.openai.com");
+  debug.api("GPT5_CONNECTION_TEST_START", {
+    model: config.model,
+    baseURL,
+    isOfficialOpenAI,
+    supportsResponsesAPI: modelFeatures.supportsResponsesAPI
+  });
+  if (isGPT5 && modelFeatures.supportsResponsesAPI && isOfficialOpenAI) {
+    debug.api("GPT5_CONNECTION_TEST_TRY_RESPONSES", {
+      model: config.model
+    });
+    const responsesResult = await testResponsesAPI(config, baseURL, startTime);
+    if (responsesResult.success) {
+      debug.api("GPT5_CONNECTION_TEST_RESPONSES_OK", {
+        model: config.model
+      });
+      return responsesResult;
+    }
+    debug.warn("GPT5_CONNECTION_TEST_RESPONSES_FAILED", {
+      model: config.model,
+      details: responsesResult.details
+    });
+  }
+  debug.api("GPT5_CONNECTION_TEST_FALLBACK_CHAT_COMPLETIONS", {
+    model: config.model
+  });
+  return await testChatCompletionsAPI(config, baseURL, startTime);
+}
+function validateGPT5Config(config) {
+  debug.state("GPT5_VALIDATE_CONFIG_CALLED", {
+    model: config.model,
+    hasApiKey: !!config.apiKey,
+    baseURL: config.baseURL,
+    provider: config.provider
+  });
+  const errors = [];
+  if (!config.model) {
+    errors.push("Model name is required");
+  }
+  if (!config.apiKey) {
+    errors.push("API key is required");
+  }
+  const isGPT5 = config.model?.toLowerCase().includes("gpt-5");
+  if (isGPT5) {
+    debug.state("GPT5_VALIDATE_CONFIG", {
+      model: config.model,
+      maxTokens: config.maxTokens
+    });
+    if (config.maxTokens && config.maxTokens < 1e3) {
+      errors.push("GPT-5 models typically require at least 1000 max tokens");
+    }
+    debug.state("GPT5_VALIDATE_CONFIG_NO_PROVIDER_RESTRICTIONS", {
+      model: config.model
+    });
+  }
+  debug.state("GPT5_VALIDATE_CONFIG_RESULT", {
+    valid: errors.length === 0,
+    errors
+  });
+  return {
+    valid: errors.length === 0,
+    errors
+  };
+}
+
+// packages/config/src/models/gpt5.ts
+function isGPT5ModelName(modelName) {
+  if (!modelName || typeof modelName !== "string") return false;
+  const lowerName = modelName.toLowerCase();
+  return lowerName.startsWith("gpt-5") || lowerName.includes("gpt-5");
+}
+function validateAndRepairGPT5Profile(profile) {
+  const isGPT5 = isGPT5ModelName(profile.modelName);
+  const now = Date.now();
+  const repairedProfile = { ...profile };
+  let wasRepaired = false;
+  if (isGPT5 !== profile.isGPT5) {
+    repairedProfile.isGPT5 = isGPT5;
+    wasRepaired = true;
+  }
+  if (isGPT5) {
+    const validReasoningEfforts = ["minimal", "low", "medium", "high"];
+    if (!profile.reasoningEffort || !validReasoningEfforts.includes(profile.reasoningEffort)) {
+      repairedProfile.reasoningEffort = "medium";
+      wasRepaired = true;
+      debug.state("GPT5_CONFIG_AUTO_REPAIR", {
+        model: profile.modelName,
+        field: "reasoningEffort",
+        value: "medium"
+      });
+    }
+    if (profile.contextLength < 128e3) {
+      repairedProfile.contextLength = 128e3;
+      wasRepaired = true;
+      debug.state("GPT5_CONFIG_AUTO_REPAIR", {
+        model: profile.modelName,
+        field: "contextLength",
+        value: 128e3
+      });
+    }
+    if (profile.maxTokens < 4e3) {
+      repairedProfile.maxTokens = 8192;
+      wasRepaired = true;
+      debug.state("GPT5_CONFIG_AUTO_REPAIR", {
+        model: profile.modelName,
+        field: "maxTokens",
+        value: 8192
+      });
+    }
+    if (profile.provider !== "openai" && profile.provider !== "custom-openai" && profile.provider !== "azure") {
+      debug.warn("GPT5_CONFIG_UNEXPECTED_PROVIDER", {
+        model: profile.modelName,
+        provider: profile.provider,
+        expectedProviders: ["openai", "custom-openai", "azure"]
+      });
+    }
+    if (profile.modelName.includes("gpt-5") && !profile.baseURL) {
+      repairedProfile.baseURL = "https://api.openai.com/v1";
+      wasRepaired = true;
+      debug.state("GPT5_CONFIG_AUTO_REPAIR", {
+        model: profile.modelName,
+        field: "baseURL",
+        value: "https://api.openai.com/v1"
+      });
+    }
+  }
+  repairedProfile.validationStatus = wasRepaired ? "auto_repaired" : "valid";
+  repairedProfile.lastValidation = now;
+  if (wasRepaired) {
+    debug.info("GPT5_CONFIG_AUTO_REPAIRED", { model: profile.modelName });
+  }
+  return repairedProfile;
+}
+function getGPT5ConfigRecommendations(modelName) {
+  if (!isGPT5ModelName(modelName)) return {};
+  const recommendations = {
+    contextLength: 128e3,
+    maxTokens: 8192,
+    reasoningEffort: "medium",
+    isGPT5: true
+  };
+  if (modelName.includes("gpt-5-mini")) {
+    recommendations.maxTokens = 4096;
+    recommendations.reasoningEffort = "low";
+  } else if (modelName.includes("gpt-5-nano")) {
+    recommendations.maxTokens = 2048;
+    recommendations.reasoningEffort = "minimal";
+  }
+  return recommendations;
+}
+function createGPT5ModelProfile(name, modelName, apiKey, baseURL, provider = "openai") {
+  const recommendations = getGPT5ConfigRecommendations(modelName);
+  return {
+    name,
+    provider,
+    modelName,
+    baseURL: baseURL || "https://api.openai.com/v1",
+    apiKey,
+    maxTokens: recommendations.maxTokens || 8192,
+    contextLength: recommendations.contextLength || 128e3,
+    reasoningEffort: recommendations.reasoningEffort || "medium",
+    isActive: true,
+    createdAt: Date.now(),
+    isGPT5: true,
+    validationStatus: "valid",
+    lastValidation: Date.now()
+  };
+}
+
+// packages/config/src/models/pointers.ts
+function setAllPointersToModel(modelName) {
+  const config = getGlobalConfig();
+  const updatedConfig = {
+    ...config,
+    modelPointers: {
+      main: modelName,
+      task: modelName,
+      compact: modelName,
+      quick: modelName
+    },
+    defaultModelName: modelName
+  };
+  saveGlobalConfig(updatedConfig);
+}
+function setModelPointer(pointer, modelName) {
+  const config = getGlobalConfig();
+  const updatedConfig = {
+    ...config,
+    modelPointers: {
+      ...config.modelPointers,
+      [pointer]: modelName
+    }
+  };
+  saveGlobalConfig(updatedConfig);
+}
+function validateAndRepairAllGPT5Profiles() {
+  const config = getGlobalConfig();
+  if (!config.modelProfiles) return { repaired: 0, total: 0 };
+  let repairCount = 0;
+  const repairedProfiles = config.modelProfiles.map((profile) => {
+    const repaired = validateAndRepairGPT5Profile(profile);
+    if (repaired.validationStatus === "auto_repaired") repairCount++;
+    return repaired;
+  });
+  if (repairCount > 0) {
+    saveGlobalConfig({ ...config, modelProfiles: repairedProfiles });
+  }
+  return { repaired: repairCount, total: config.modelProfiles.length };
+}
+
+// packages/config/src/sources.ts
+var CLI_TO_SETTING_SOURCE = {
+  user: "userSettings",
+  project: "projectSettings",
+  local: "localSettings"
+};
+var enabledSettingSources = new Set(
+  Object.values(CLI_TO_SETTING_SOURCE)
+);
+function setEnabledSettingSourcesFromCli(sources) {
+  if (sources === void 0) return;
+  const trimmed = sources.trim();
+  if (!trimmed) {
+    throw new Error(
+      `Invalid --setting-sources value: ${JSON.stringify(sources)}. Expected a comma-separated list of: user, project, local.`
+    );
+  }
+  const parts = trimmed.split(",").map((p) => p.trim()).filter(Boolean);
+  const next = /* @__PURE__ */ new Set();
+  const unknown = [];
+  for (const part of parts) {
+    const key = part.toLowerCase();
+    const mapped = CLI_TO_SETTING_SOURCE[key];
+    if (!mapped) {
+      unknown.push(part);
+      continue;
+    }
+    next.add(mapped);
+  }
+  if (unknown.length > 0) {
+    throw new Error(
+      `Unknown setting source(s): ${unknown.join(", ")}. Expected: user, project, local.`
+    );
+  }
+  enabledSettingSources = next;
+}
+function isSettingSourceEnabled(source) {
+  return enabledSettingSources.has(source);
+}
+function __resetSettingSourcesForTests() {
+  enabledSettingSources = new Set(Object.values(CLI_TO_SETTING_SOURCE));
+}
+
+// packages/config/src/files.ts
+import { existsSync as existsSync3, mkdirSync, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "node:fs";
+import { homedir as homedir3 } from "node:os";
+import { dirname, join as join3, resolve as resolve2 } from "node:path";
+function logError(error) {
+  if (process.env.NODE_ENV === "test") {
+    console.error(error);
+  }
+}
+function normalizeOverride(value) {
+  if (typeof value !== "string") return null;
+  const trimmed = value.trim();
+  return trimmed ? resolve2(trimmed) : null;
+}
+function dedupeStrings(values) {
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const value of values) {
+    if (!value) continue;
+    if (seen.has(value)) continue;
+    seen.add(value);
+    out.push(value);
+  }
+  return out;
+}
+function getDefaultHomeDir() {
+  const envHome = typeof process.env.HOME === "string" ? process.env.HOME : typeof process.env.USERPROFILE === "string" ? process.env.USERPROFILE : "";
+  const trimmed = envHome.trim();
+  if (trimmed) return trimmed;
+  return homedir3();
+}
+function getUserKodeBaseDir(options) {
+  const respectEnvOverride = options?.respectEnvOverride ?? true;
+  if (respectEnvOverride) {
+    const override = normalizeOverride(
+      process.env.KODE_CONFIG_DIR ?? process.env.CLAUDE_CONFIG_DIR
+    );
+    if (override) return override;
+  }
+  const home = options?.homeDir ?? getDefaultHomeDir();
+  return join3(home, ".kode");
+}
+function getUserLegacyBaseDir(options) {
+  const respectEnvOverride = options?.respectEnvOverride ?? true;
+  if (respectEnvOverride) {
+    const override = normalizeOverride(process.env.CLAUDE_CONFIG_DIR);
+    if (override) return override;
+  }
+  const home = options?.homeDir ?? getDefaultHomeDir();
+  return join3(home, ".claude");
+}
+function getSettingsFileCandidates(options) {
+  const projectDir = options.projectDir ?? getCwd();
+  const homeDir = options.homeDir ?? getDefaultHomeDir();
+  const respectEnvOverride = options.homeDir === void 0;
+  switch (options.destination) {
+    case "localSettings": {
+      const primary = join3(projectDir, ".kode", "settings.local.json");
+      const legacy = [join3(projectDir, ".claude", "settings.local.json")];
+      return { primary, legacy };
+    }
+    case "projectSettings": {
+      const primary = join3(projectDir, ".kode", "settings.json");
+      const legacy = [join3(projectDir, ".claude", "settings.json")];
+      return { primary, legacy };
+    }
+    case "userSettings": {
+      const primary = join3(
+        getUserKodeBaseDir({ homeDir, respectEnvOverride }),
+        "settings.json"
+      );
+      const legacy = dedupeStrings([
+        join3(
+          getUserLegacyBaseDir({ homeDir, respectEnvOverride }),
+          "settings.json"
+        ),
+        join3(homeDir, ".claude", "settings.json")
+      ]);
+      return { primary, legacy };
+    }
+    default:
+      return null;
+  }
+}
+function readSettingsFile(filePath) {
+  if (!existsSync3(filePath)) return null;
+  try {
+    const raw = readFileSync3(filePath, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object") return null;
+    return parsed;
+  } catch (error) {
+    logError(error);
+    return null;
+  }
+}
+function writeSettingsFile(filePath, settings) {
+  mkdirSync(dirname(filePath), { recursive: true });
+  writeFileSync2(filePath, JSON.stringify(settings, null, 2) + "\n", "utf-8");
+}
+function loadSettingsWithLegacyFallback(options) {
+  const candidates = getSettingsFileCandidates(options);
+  if (!candidates) return { settings: null, usedPath: null };
+  const primarySettings = readSettingsFile(candidates.primary);
+  if (primarySettings)
+    return { settings: primarySettings, usedPath: candidates.primary };
+  for (const legacyPath of candidates.legacy) {
+    const legacySettings = readSettingsFile(legacyPath);
+    if (!legacySettings) continue;
+    if (options.migrateToPrimary && legacyPath !== candidates.primary) {
+      try {
+        if (!existsSync3(candidates.primary)) {
+          writeSettingsFile(candidates.primary, legacySettings);
+        }
+      } catch (error) {
+        logError(error);
+      }
+    }
+    return { settings: legacySettings, usedPath: legacyPath };
+  }
+  return { settings: null, usedPath: null };
+}
+function saveSettingsToPrimaryAndSyncLegacy(options) {
+  const candidates = getSettingsFileCandidates(options);
+  if (!candidates) return;
+  writeSettingsFile(candidates.primary, options.settings);
+  if (!options.syncLegacyIfExists) return;
+  for (const legacyPath of candidates.legacy) {
+    if (legacyPath === candidates.primary) continue;
+    if (!existsSync3(legacyPath)) continue;
+    try {
+      writeSettingsFile(legacyPath, options.settings);
+    } catch (error) {
+      logError(error);
+    }
+  }
+}
+
+// packages/config/src/local.ts
+import { join as join4 } from "node:path";
+function getLocalSettingsPath(options) {
+  const projectDir = options?.projectDir ?? getCwd();
+  return join4(projectDir, ".kode", "settings.local.json");
+}
+function readLocalSettings(options) {
+  const projectDir = options?.projectDir ?? getCwd();
+  const loaded = loadSettingsWithLegacyFallback({
+    destination: "localSettings",
+    projectDir,
+    migrateToPrimary: true
+  });
+  return loaded.settings ?? {};
+}
+function updateLocalSettings(patch, options) {
+  const projectDir = options?.projectDir ?? getCwd();
+  const candidates = getSettingsFileCandidates({
+    destination: "localSettings",
+    projectDir
+  });
+  const existing = (candidates ? loadSettingsWithLegacyFallback({
+    destination: "localSettings",
+    projectDir,
+    migrateToPrimary: true
+  }).settings : null) ?? {};
+  const next = { ...existing, ...patch };
+  if (candidates) {
+    saveSettingsToPrimaryAndSyncLegacy({
+      destination: "localSettings",
+      projectDir,
+      settings: next,
+      syncLegacyIfExists: true
+    });
+  }
+  return next;
+}
+
+// packages/config/src/modelYaml.ts
+import yaml from "js-yaml";
+import { z } from "zod";
+var ApiKeySpecSchema = z.union([
+  z.object({
+    fromEnv: z.string().min(1)
+  }).strict(),
+  z.object({
+    value: z.string()
+  }).strict()
+]);
+var ModelProfileYamlSchema = z.object({
+  name: z.string().min(1),
+  provider: z.string().min(1),
+  modelName: z.string().min(1),
+  baseURL: z.string().min(1).optional(),
+  maxTokens: z.number().int().positive(),
+  contextLength: z.number().int().positive(),
+  reasoningEffort: z.string().optional(),
+  isActive: z.boolean().optional(),
+  apiKey: ApiKeySpecSchema.optional(),
+  apiKeyEnv: z.string().min(1).optional(),
+  createdAt: z.number().int().positive().optional(),
+  lastUsed: z.number().int().positive().optional()
+}).strict();
+var ModelPointersYamlSchema = z.object({
+  main: z.string().min(1).optional(),
+  task: z.string().min(1).optional(),
+  compact: z.string().min(1).optional(),
+  quick: z.string().min(1).optional()
+}).strict().optional();
+var ModelConfigYamlSchema = z.object({
+  version: z.number().int().positive().default(1),
+  profiles: z.array(ModelProfileYamlSchema).default([]),
+  pointers: ModelPointersYamlSchema
+}).strict();
+function suggestedApiKeyEnvForProvider(provider) {
+  switch (provider) {
+    case "anthropic":
+      return "ANTHROPIC_API_KEY";
+    case "openai":
+    case "custom-openai":
+      return "OPENAI_API_KEY";
+    case "azure":
+      return "AZURE_OPENAI_API_KEY";
+    case "gemini":
+      return "GEMINI_API_KEY";
+    default:
+      return void 0;
+  }
+}
+function resolveApiKeyFromYaml(input, existingApiKey) {
+  const warnings = [];
+  if (input.apiKeyEnv) {
+    const envValue = process.env[input.apiKeyEnv];
+    if (envValue) return { apiKey: envValue, warnings };
+    if (existingApiKey) return { apiKey: existingApiKey, warnings };
+    warnings.push(`Missing env var '${input.apiKeyEnv}' for apiKey`);
+    return { apiKey: "", warnings };
+  }
+  if (input.apiKey && "fromEnv" in input.apiKey) {
+    const envValue = process.env[input.apiKey.fromEnv];
+    if (envValue) return { apiKey: envValue, warnings };
+    if (existingApiKey) return { apiKey: existingApiKey, warnings };
+    warnings.push(`Missing env var '${input.apiKey.fromEnv}' for apiKey`);
+    return { apiKey: "", warnings };
+  }
+  if (input.apiKey && "value" in input.apiKey) {
+    return { apiKey: input.apiKey.value, warnings };
+  }
+  if (existingApiKey) return { apiKey: existingApiKey, warnings };
+  warnings.push(
+    "Missing apiKey (set apiKey.fromEnv, apiKeyEnv, or apiKey.value)"
+  );
+  return { apiKey: "", warnings };
+}
+function resolvePointerTarget(pointerValue, profiles) {
+  if (profiles.some((p) => p.modelName === pointerValue)) return pointerValue;
+  const byName = profiles.find((p) => p.name === pointerValue);
+  return byName?.modelName ?? null;
+}
+function parseModelConfigYaml(yamlText) {
+  const parsed = yaml.load(yamlText);
+  return ModelConfigYamlSchema.parse(parsed);
+}
+function formatModelConfigYamlForSharing(config) {
+  const modelProfiles = config.modelProfiles ?? [];
+  const pointers = config.modelPointers;
+  const exported = {
+    version: 1,
+    profiles: modelProfiles.map((p) => {
+      const suggestedEnv = suggestedApiKeyEnvForProvider(p.provider);
+      return {
+        name: p.name,
+        provider: p.provider,
+        modelName: p.modelName,
+        ...p.baseURL ? { baseURL: p.baseURL } : {},
+        maxTokens: p.maxTokens,
+        contextLength: p.contextLength,
+        ...p.reasoningEffort ? { reasoningEffort: p.reasoningEffort } : {},
+        isActive: p.isActive,
+        createdAt: p.createdAt,
+        ...typeof p.lastUsed === "number" ? { lastUsed: p.lastUsed } : {},
+        apiKey: { fromEnv: suggestedEnv ?? "API_KEY" }
+      };
+    }),
+    ...pointers ? { pointers } : {}
+  };
+  return yaml.dump(exported, {
+    noRefs: true,
+    lineWidth: 120
+  });
+}
+function applyModelConfigYamlImport(existingConfig, yamlText, options = {}) {
+  const parsed = parseModelConfigYaml(yamlText);
+  const warnings = [];
+  const existingProfiles = existingConfig.modelProfiles ?? [];
+  const existingByModelName = new Map(
+    existingProfiles.map((p) => [p.modelName, p])
+  );
+  const now = Date.now();
+  const importedProfiles = parsed.profiles.map((profile) => {
+    const existing = existingByModelName.get(profile.modelName);
+    const resolved = resolveApiKeyFromYaml(
+      { apiKey: profile.apiKey, apiKeyEnv: profile.apiKeyEnv },
+      existing?.apiKey
+    );
+    warnings.push(...resolved.warnings.map((w) => `[${profile.modelName}] ${w}`));
+    return {
+      name: profile.name,
+      provider: profile.provider,
+      modelName: profile.modelName,
+      ...profile.baseURL ? { baseURL: profile.baseURL } : {},
+      apiKey: resolved.apiKey,
+      maxTokens: profile.maxTokens,
+      contextLength: profile.contextLength,
+      ...profile.reasoningEffort ? { reasoningEffort: profile.reasoningEffort } : {},
+      isActive: profile.isActive ?? true,
+      createdAt: profile.createdAt ?? existing?.createdAt ?? now,
+      ...profile.lastUsed ? { lastUsed: profile.lastUsed } : existing?.lastUsed ? { lastUsed: existing.lastUsed } : {},
+      ...existing?.isGPT5 ? { isGPT5: existing.isGPT5 } : {},
+      ...existing?.validationStatus ? { validationStatus: existing.validationStatus } : {},
+      ...existing?.lastValidation ? { lastValidation: existing.lastValidation } : {}
+    };
+  });
+  const mergedProfiles = options.replace ? importedProfiles : [...existingProfiles, ...importedProfiles].reduce((acc, p) => {
+    const i = acc.findIndex((x) => x.modelName === p.modelName);
+    if (i >= 0) acc[i] = p;
+    else acc.push(p);
+    return acc;
+  }, []);
+  let nextPointers = existingConfig.modelPointers;
+  if (parsed.pointers) {
+    const mapped = {
+      main: parsed.pointers.main,
+      task: parsed.pointers.task,
+      compact: parsed.pointers.compact,
+      quick: parsed.pointers.quick
+    };
+    nextPointers = {
+      main: (mapped.main ? resolvePointerTarget(mapped.main, mergedProfiles) : null) ?? existingConfig.modelPointers?.main ?? "",
+      task: (mapped.task ? resolvePointerTarget(mapped.task, mergedProfiles) : null) ?? existingConfig.modelPointers?.task ?? "",
+      compact: (mapped.compact ? resolvePointerTarget(mapped.compact, mergedProfiles) : null) ?? existingConfig.modelPointers?.compact ?? "",
+      quick: (mapped.quick ? resolvePointerTarget(mapped.quick, mergedProfiles) : null) ?? existingConfig.modelPointers?.quick ?? ""
+    };
+  }
+  return {
+    nextConfig: {
+      ...existingConfig,
+      modelProfiles: mergedProfiles,
+      modelPointers: nextPointers
+    },
+    warnings
+  };
+}
+
+export {
+  DEFAULT_PROJECT_CONFIG,
+  defaultConfigForProject,
+  isAutoUpdaterStatus,
+  DEFAULT_GLOBAL_CONFIG,
+  GLOBAL_CONFIG_KEYS,
+  isGlobalConfigKey,
+  PROJECT_CONFIG_KEYS,
+  isProjectConfigKey,
+  getKodeBaseDir,
+  getGlobalConfigFilePath,
+  ConfigParseError,
+  enableConfigs,
+  saveGlobalConfig,
+  getGlobalConfig,
+  checkHasTrustDialogAccepted,
+  getCurrentProjectConfig,
+  saveCurrentProjectConfig,
+  isAutoUpdaterDisabled,
+  getOrCreateUserID,
+  normalizeApiKeyForConfig,
+  getCustomApiKeyStatus,
+  TEST_MCPRC_CONFIG_FOR_TESTING,
+  clearMcprcConfigForTesting,
+  addMcprcServerForTesting,
+  removeMcprcServerForTesting,
+  getMcprcConfig,
+  getProjectMcpServerDefinitions,
+  getConfigForCLI,
+  setConfigForCLI,
+  deleteConfigForCLI,
+  listConfigForCLI,
+  getOpenAIApiKey,
+  getAnthropicApiKey,
+  testGPT5Connection,
+  validateGPT5Config,
+  isGPT5ModelName,
+  validateAndRepairGPT5Profile,
+  getGPT5ConfigRecommendations,
+  createGPT5ModelProfile,
+  setAllPointersToModel,
+  setModelPointer,
+  validateAndRepairAllGPT5Profiles,
+  setEnabledSettingSourcesFromCli,
+  isSettingSourceEnabled,
+  __resetSettingSourcesForTests,
+  getSettingsFileCandidates,
+  readSettingsFile,
+  writeSettingsFile,
+  loadSettingsWithLegacyFallback,
+  saveSettingsToPrimaryAndSyncLegacy,
+  getLocalSettingsPath,
+  readLocalSettings,
+  updateLocalSettings,
+  parseModelConfigYaml,
+  formatModelConfigYamlForSharing,
+  applyModelConfigYamlImport
+};