@di-code/coding-agent 0.1.4 → 0.1.7

package/dist/startup.js

@@ -1,7 +1,8 @@
 import { mkdir, readFile, writeFile } from "node:fs/promises";
 import { homedir } from "node:os";
 import { join } from "node:path";
-import { createAnthropicProvider, createDeepSeekProvider, createFauxProvider, createOpenAIChatCompletionsProvider, createOpenAIProvider, createZhipuProvider, } from "@di-code/ai";
+import { createAnthropicProvider, createDeepSeekProvider, createFauxProvider, createKimiProvider, createOpenAIChatCompletionsProvider, createOpenAIProvider, createZhipuProvider, findBuiltinModel, } from "@di-code/ai";
+import { isLocale } from "./i18n.js";
 const FAUX_RESPONSES = [
     {
         type: "success",
@@ -46,6 +47,43 @@ function nonNegativeNumber(value, path, fallback, settingsPath) {
     }
     return result;
 }
+function parseChatCompletionsCompat(value, path, settingsPath) {
+    if (value === undefined)
+        return undefined;
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        throw new Error(`${settingsPath}: ${path} must be an object`);
+    }
+    const compat = value;
+    const optionalBoolean = (field) => {
+        const candidate = compat[field];
+        if (candidate === undefined)
+            return undefined;
+        if (typeof candidate !== "boolean")
+            throw new Error(`${settingsPath}: ${path}.${field} must be a boolean`);
+        return candidate;
+    };
+    const maxTokensField = compat.maxTokensField;
+    if (maxTokensField !== undefined && maxTokensField !== "max_tokens" && maxTokensField !== "max_completion_tokens") {
+        throw new Error(`${settingsPath}: ${path}.maxTokensField is invalid`);
+    }
+    const thinkingFormat = compat.thinkingFormat;
+    if (thinkingFormat !== undefined &&
+        thinkingFormat !== "zai" &&
+        thinkingFormat !== "deepseek" &&
+        thinkingFormat !== "kimi") {
+        throw new Error(`${settingsPath}: ${path}.thinkingFormat is invalid`);
+    }
+    const supportsUsageInStreaming = optionalBoolean("supportsUsageInStreaming");
+    const supportsReasoningEffort = optionalBoolean("supportsReasoningEffort");
+    const zaiToolStream = optionalBoolean("zaiToolStream");
+    return {
+        ...(maxTokensField === undefined ? {} : { maxTokensField }),
+        ...(thinkingFormat === undefined ? {} : { thinkingFormat }),
+        ...(supportsUsageInStreaming === undefined ? {} : { supportsUsageInStreaming }),
+        ...(supportsReasoningEffort === undefined ? {} : { supportsReasoningEffort }),
+        ...(zaiToolStream === undefined ? {} : { zaiToolStream }),
+    };
+}
 function parseModels(value, path, providerId, providerApi, providerBaseUrl, settingsPath) {
     if (value === undefined)
         return undefined;
@@ -75,9 +113,9 @@ function parseModels(value, path, providerId, providerApi, providerBaseUrl, sett
                 throw new Error(`${settingsPath}: ${modelPath}.reasoningEfforts must be a non-empty array`);
             }
             if (model.reasoning !== true ||
-                configuredReasoningEfforts.some((effort) => effort !== "low" && effort !== "medium" && effort !== "high") ||
+                configuredReasoningEfforts.some((effort) => effort !== "low" && effort !== "medium" && effort !== "high" && effort !== "max") ||
                 new Set(configuredReasoningEfforts).size !== configuredReasoningEfforts.length) {
-                throw new Error(`${settingsPath}: ${modelPath}.reasoningEfforts requires reasoning=true and unique low, medium, or high values`);
+                throw new Error(`${settingsPath}: ${modelPath}.reasoningEfforts requires reasoning=true and unique low, medium, high, or max values`);
             }
         }
         if (model.cacheRetention !== undefined && model.cacheRetention !== "long") {
@@ -98,8 +136,18 @@ function parseModels(value, path, providerId, providerApi, providerBaseUrl, sett
             : configuredReasoningEfforts === undefined
                 ? undefined
                 : [...configuredReasoningEfforts];
+        const defaultReasoningEffort = model.defaultReasoningEffort;
+        if (defaultReasoningEffort !== undefined &&
+            (typeof defaultReasoningEffort !== "string" ||
+                !reasoningEfforts?.includes(defaultReasoningEffort))) {
+            throw new Error(`${settingsPath}: ${modelPath}.defaultReasoningEffort must be included in reasoningEfforts`);
+        }
         const baseUrl = optionalString(model.baseUrl, `${modelPath}.baseUrl`, settingsPath) ?? providerBaseUrl;
         const id = requiredString(model.id, `${modelPath}.id`, settingsPath);
+        const chatCompletionsCompat = parseChatCompletionsCompat(model.chatCompletionsCompat, `${modelPath}.chatCompletionsCompat`, settingsPath);
+        if (chatCompletionsCompat !== undefined && typedApi !== "openai-chat-completions") {
+            throw new Error(`${settingsPath}: ${modelPath}.chatCompletionsCompat requires api "openai-chat-completions"`);
+        }
         return {
             id,
             name: requiredString(model.name ?? id, `${modelPath}.name`, settingsPath),
@@ -109,6 +157,10 @@ function parseModels(value, path, providerId, providerApi, providerBaseUrl, sett
             input: [...input],
             reasoning: model.reasoning ?? false,
             ...(reasoningEfforts ? { reasoningEfforts } : {}),
+            ...(defaultReasoningEffort
+                ? { defaultReasoningEffort: defaultReasoningEffort }
+                : {}),
+            ...(chatCompletionsCompat ? { chatCompletionsCompat } : {}),
             ...(model.cacheRetention === "long" ? { cacheRetention: "long" } : {}),
             ...(model.sessionAffinity === "codex" ? { sessionAffinity: "codex" } : {}),
             contextWindow: positiveInteger(model.contextWindow, `${modelPath}.contextWindow`, 128_000, settingsPath),
@@ -122,6 +174,77 @@ function parseModels(value, path, providerId, providerApi, providerBaseUrl, sett
         };
     });
 }
+/** Validates a Custom onboarding endpoint without issuing a network request. */
+export function validateCustomBaseUrl(value) {
+    const baseUrl = value.trim();
+    if (!baseUrl)
+        throw new Error("Base URL cannot be empty.");
+    let url;
+    try {
+        url = new URL(baseUrl);
+    }
+    catch {
+        throw new Error("Base URL must be an absolute http or https URL.");
+    }
+    if (url.protocol !== "http:" && url.protocol !== "https:")
+        throw new Error("Base URL must use http or https.");
+    if (url.username || url.password || url.search || url.hash) {
+        throw new Error("Base URL must not contain credentials, query, or hash.");
+    }
+    if (baseUrl.endsWith("/"))
+        throw new Error("Base URL must not end with /.");
+    return baseUrl;
+}
+function requireCustomValue(value, field) {
+    const trimmed = value.trim();
+    if (!trimmed)
+        throw new Error(`${field === "apiKey" ? "API key" : "Model ID"} cannot be empty.`);
+    return trimmed;
+}
+/** Builds the single user-managed Custom provider from validated onboarding input. */
+export function createCustomProviderConfiguration(input) {
+    const baseUrl = validateCustomBaseUrl(input.baseUrl);
+    const modelId = requireCustomValue(input.modelId, "modelId");
+    const apiKey = requireCustomValue(input.apiKey, "apiKey");
+    const known = findBuiltinModel(input.api, modelId);
+    const model = known
+        ? {
+            ...known,
+            id: modelId,
+            provider: "custom",
+            api: input.api,
+            baseUrl,
+        }
+        : {
+            id: modelId,
+            name: modelId,
+            provider: "custom",
+            api: input.api,
+            baseUrl,
+            input: ["text"],
+            reasoning: false,
+            contextWindow: 128_000,
+            maxOutputTokens: 16_384,
+            cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+        };
+    return { id: "custom", name: "Custom", api: input.api, apiKey, baseUrl, models: [model] };
+}
+function serializeModel(model) {
+    return {
+        id: model.id,
+        name: model.name,
+        input: model.input,
+        reasoning: model.reasoning,
+        ...(model.reasoningEfforts ? { reasoningEfforts: model.reasoningEfforts } : {}),
+        ...(model.defaultReasoningEffort ? { defaultReasoningEffort: model.defaultReasoningEffort } : {}),
+        ...(model.chatCompletionsCompat ? { chatCompletionsCompat: model.chatCompletionsCompat } : {}),
+        ...(model.cacheRetention ? { cacheRetention: model.cacheRetention } : {}),
+        ...(model.sessionAffinity ? { sessionAffinity: model.sessionAffinity } : {}),
+        contextWindow: model.contextWindow,
+        maxTokens: model.maxOutputTokens,
+        cost: Object.fromEntries(Object.entries(model.cost).map(([key, value]) => [key, value * 1_000_000])),
+    };
+}
 function parseSettings(value, settingsPath) {
     if (typeof value !== "object" || value === null || Array.isArray(value)) {
         throw new Error(`${settingsPath}: root value must be an object`);
@@ -149,12 +272,42 @@ function parseSettings(value, settingsPath) {
         ? undefined
         : requiredString(record.defaultProvider, "defaultProvider", settingsPath);
     const defaultModel = record.defaultModel === undefined ? undefined : requiredString(record.defaultModel, "defaultModel", settingsPath);
+    const thinkingLevels = parseThinkingLevels(record.thinkingLevels, settingsPath);
+    if (record.locale !== undefined && !isLocale(record.locale)) {
+        throw new Error(`${settingsPath}: locale must be "en" or "zh-CN"`);
+    }
     return {
         providers,
         ...(defaultProvider === undefined ? {} : { defaultProvider }),
         ...(defaultModel === undefined ? {} : { defaultModel }),
+        ...(thinkingLevels === undefined ? {} : { thinkingLevels }),
+        ...(record.locale === undefined ? {} : { locale: record.locale }),
     };
 }
+function parseThinkingLevels(value, settingsPath) {
+    if (value === undefined)
+        return undefined;
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        throw new Error(`${settingsPath}: thinkingLevels must be an object`);
+    }
+    const preferences = {};
+    for (const [providerId, models] of Object.entries(value)) {
+        requiredString(providerId, "thinkingLevels provider ID", settingsPath);
+        if (typeof models !== "object" || models === null || Array.isArray(models)) {
+            throw new Error(`${settingsPath}: thinkingLevels.${providerId} must be an object`);
+        }
+        const modelPreferences = {};
+        for (const [modelId, level] of Object.entries(models)) {
+            requiredString(modelId, `thinkingLevels.${providerId} model ID`, settingsPath);
+            if (level !== "low" && level !== "medium" && level !== "high" && level !== "max") {
+                throw new Error(`${settingsPath}: thinkingLevels.${providerId}.${modelId} must be a valid thinking level`);
+            }
+            modelPreferences[modelId] = level;
+        }
+        preferences[providerId] = modelPreferences;
+    }
+    return preferences;
+}
 async function readSettingsFile(path, displayPath) {
     try {
         const source = await readFile(path, "utf8");
@@ -187,12 +340,29 @@ function mergeSettings(globalSettings, projectSettings) {
     const defaultProvider = projectSettings?.defaultProvider ?? globalSettings?.defaultProvider;
     const defaultModel = projectSettings?.defaultModel ??
         (projectSettings?.defaultProvider === undefined ? globalSettings?.defaultModel : undefined);
+    const locale = globalSettings?.locale;
     return {
         providers,
         ...(defaultProvider === undefined ? {} : { defaultProvider }),
         ...(defaultModel === undefined ? {} : { defaultModel }),
+        ...(globalSettings?.thinkingLevels === undefined ? {} : { thinkingLevels: globalSettings.thinkingLevels }),
+        ...(locale === undefined ? {} : { locale }),
     };
 }
+/** Persists a user-level terminal language preference without changing project settings. */
+export async function saveGlobalLocale(agentDir, locale) {
+    const settingsFilePath = join(agentDir, SETTINGS_FILE_NAME);
+    const existingSettings = await readSettingsFile(settingsFilePath, settingsFilePath);
+    const settings = {
+        providers: existingSettings?.providers ?? {},
+        ...(existingSettings?.defaultProvider === undefined ? {} : { defaultProvider: existingSettings.defaultProvider }),
+        ...(existingSettings?.defaultModel === undefined ? {} : { defaultModel: existingSettings.defaultModel }),
+        ...(existingSettings?.thinkingLevels === undefined ? {} : { thinkingLevels: existingSettings.thinkingLevels }),
+        locale,
+    };
+    await mkdir(agentDir, { recursive: true, mode: 0o700 });
+    await writeFile(settingsFilePath, `${JSON.stringify(settings, null, "\t")}\n`, { encoding: "utf8", mode: 0o600 });
+}
 export async function saveGlobalProviderApiKey(agentDir, providerId, api, apiKey, modelId) {
     const settingsFilePath = join(agentDir, SETTINGS_FILE_NAME);
     const trimmedApiKey = apiKey.trim();
@@ -207,7 +377,69 @@ export async function saveGlobalProviderApiKey(agentDir, providerId, api, apiKey
     await mkdir(agentDir, { recursive: true, mode: 0o700 });
     await writeFile(settingsFilePath, `${JSON.stringify(settings, null, "\t")}\n`, { encoding: "utf8", mode: 0o600 });
 }
-/** Removes only the persisted credential for one provider; environment variables remain untouched. */
+/** Persists the interactive model selection without changing credentials or Provider configuration. */
+export async function saveGlobalModelSelection(agentDir, providerId, modelId) {
+    const settingsFilePath = join(agentDir, SETTINGS_FILE_NAME);
+    const normalizedProviderId = requiredString(providerId, "providerId", settingsFilePath);
+    const normalizedModelId = requiredString(modelId, "modelId", settingsFilePath);
+    const existingSettings = await readSettingsFile(settingsFilePath, settingsFilePath);
+    const settings = mergeSettings(existingSettings, {
+        providers: {},
+        defaultProvider: normalizedProviderId,
+        defaultModel: normalizedModelId,
+    });
+    await mkdir(agentDir, { recursive: true, mode: 0o700 });
+    await writeFile(settingsFilePath, `${JSON.stringify(settings, null, "\t")}\n`, { encoding: "utf8", mode: 0o600 });
+}
+/** Persists a per-provider/model thinking preference in user settings. */
+export async function saveGlobalThinkingLevel(agentDir, providerId, modelId, level) {
+    const settingsFilePath = join(agentDir, SETTINGS_FILE_NAME);
+    const normalizedProviderId = requiredString(providerId, "providerId", settingsFilePath);
+    const normalizedModelId = requiredString(modelId, "modelId", settingsFilePath);
+    const existingSettings = await readSettingsFile(settingsFilePath, settingsFilePath);
+    const settings = {
+        ...mergeSettings(existingSettings, undefined),
+        thinkingLevels: {
+            ...(existingSettings?.thinkingLevels ?? {}),
+            [normalizedProviderId]: {
+                ...(existingSettings?.thinkingLevels?.[normalizedProviderId] ?? {}),
+                [normalizedModelId]: level,
+            },
+        },
+    };
+    await mkdir(agentDir, { recursive: true, mode: 0o700 });
+    await writeFile(settingsFilePath, `${JSON.stringify(settings, null, "\t")}\n`, { encoding: "utf8", mode: 0o600 });
+}
+/**
+ * Replaces the user-managed `custom` provider while retaining other global
+ * providers and preferences. The key is intentionally stored only here, never
+ * in project settings or process environment.
+ */
+export async function saveGlobalCustomProvider(agentDir, input) {
+    const configuration = createCustomProviderConfiguration(input);
+    const settingsFilePath = join(agentDir, SETTINGS_FILE_NAME);
+    const existingSettings = await readSettingsFile(settingsFilePath, settingsFilePath);
+    const settings = mergeSettings(existingSettings, {
+        providers: {
+            custom: {
+                name: configuration.name,
+                api: configuration.api,
+                baseUrl: configuration.baseUrl,
+                apiKey: configuration.apiKey,
+                models: configuration.models?.map(serializeModel),
+            },
+        },
+        defaultProvider: "custom",
+        defaultModel: configuration.models?.[0]?.id,
+    });
+    await mkdir(agentDir, { recursive: true, mode: 0o700 });
+    await writeFile(settingsFilePath, `${JSON.stringify(settings, null, "\t")}\n`, { encoding: "utf8", mode: 0o600 });
+    return configuration;
+}
+/**
+ * Removes one persisted credential and clears it as the default when applicable.
+ * Environment variables and other Provider configuration remain untouched.
+ */
 export async function removeGlobalProviderApiKey(agentDir, providerId) {
     const settingsFilePath = join(agentDir, SETTINGS_FILE_NAME);
     const existingSettings = await readSettingsFile(settingsFilePath, settingsFilePath);
@@ -215,12 +447,20 @@ export async function removeGlobalProviderApiKey(agentDir, providerId) {
     if (!provider || provider.apiKey === undefined)
         return false;
     const { apiKey: _apiKey, ...providerWithoutApiKey } = provider;
+    const clearsDefault = existingSettings.defaultProvider === providerId;
     const settings = {
-        ...existingSettings,
         providers: {
             ...existingSettings.providers,
             [providerId]: providerWithoutApiKey,
         },
+        ...(clearsDefault || existingSettings.defaultProvider === undefined
+            ? {}
+            : { defaultProvider: existingSettings.defaultProvider }),
+        ...(clearsDefault || existingSettings.defaultModel === undefined
+            ? {}
+            : { defaultModel: existingSettings.defaultModel }),
+        ...(existingSettings.thinkingLevels === undefined ? {} : { thinkingLevels: existingSettings.thinkingLevels }),
+        ...(existingSettings.locale === undefined ? {} : { locale: existingSettings.locale }),
     };
     await writeFile(settingsFilePath, `${JSON.stringify(settings, null, "\t")}\n`, { encoding: "utf8", mode: 0o600 });
     return true;
@@ -254,7 +494,9 @@ function selectProviderModel(provider, providerId, env) {
                 ? provider.models.find((candidate) => candidate.id === "gpt-4o")?.id
                 : providerId === "zhipu"
                     ? provider.models.find((candidate) => candidate.id === "glm-5.3")?.id
-                    : undefined) ||
+                    : providerId === "kimi"
+                        ? provider.models.find((candidate) => candidate.id === "k3")?.id
+                        : undefined) ||
         provider.models[0]?.id;
     if (!modelId)
         throw new Error("DI_CODE_MODEL is required when the selected provider has no models");
@@ -282,6 +524,10 @@ function createBuiltInRuntime(env, providerId) {
         const provider = createZhipuProvider({ env });
         return { provider, model: selectProviderModel(provider, providerId, env) };
     }
+    if (providerId === "kimi") {
+        const provider = createKimiProvider({ env });
+        return { provider, model: selectProviderModel(provider, providerId, env) };
+    }
     return undefined;
 }
 function createConfiguredRuntime(env, configuration) {
@@ -293,13 +539,14 @@ function createConfiguredRuntime(env, configuration) {
     if (configuration.id !== "openai" &&
         configuration.id !== "deepseek" &&
         configuration.id !== "zhipu" &&
+        configuration.id !== "kimi" &&
         configuration.id !== "anthropic" &&
         !configuration.models) {
         throw new Error(`${SETTINGS_PATH}: providers.${configuration.id}.models is required for a custom provider`);
     }
     const provider = configuration.api === "openai-chat-completions"
         ? createOpenAIChatCompletionsProvider({
-            env: configuration.id === "zhipu" || configuration.id === "deepseek"
+            env: configuration.id === "zhipu" || configuration.id === "deepseek" || configuration.id === "kimi"
                 ? env
                 : Object.fromEntries(Object.entries(env).filter(([name]) => name !== "OPENAI_API_KEY" && name !== "OPENAI_BASE_URL")),
             models: configuration.models,
@@ -319,7 +566,13 @@ function createConfiguredRuntime(env, configuration) {
                         baseUrlEnvironmentVariable: "DEEPSEEK_BASE_URL",
                         defaultBaseUrl: "https://api.deepseek.com",
                     }
-                    : {}),
+                    : configuration.id === "kimi"
+                        ? {
+                            apiKeyEnvironmentVariable: "KIMI_API_KEY",
+                            baseUrlEnvironmentVariable: "KIMI_BASE_URL",
+                            defaultBaseUrl: "https://api.kimi.com/coding/v1",
+                        }
+                        : {}),
         })
         : configuration.api === "anthropic-messages"
             ? createAnthropicProvider({
@@ -380,12 +633,21 @@ export function resolveStartupRuntime(env, providers, defaults = {}) {
         return builtInRuntime;
     throw new Error(`Unknown configured provider "${selectedProviderId}". Available providers: ${providers.map((provider) => provider.id).join(", ")}.`);
 }
+/** Returns a stored preference only when the selected model still supports it. */
+export function resolveThinkingLevelPreference(configuration, runtime) {
+    const preference = configuration?.thinkingLevels?.[runtime.provider.id]?.[runtime.model.id];
+    return preference !== undefined && runtime.model.reasoningEfforts?.includes(preference) ? preference : undefined;
+}
 export async function loadStartupConfiguration(cwd, environment = process.env, agentDir = join(homedir(), ".di-code")) {
     const [globalSettings, projectSettings] = await Promise.all([
         readSettingsFile(join(agentDir, SETTINGS_FILE_NAME), join(agentDir, SETTINGS_FILE_NAME)),
         readSettingsFile(join(cwd, SETTINGS_PATH), SETTINGS_PATH),
     ]);
     const settings = mergeSettings(globalSettings, projectSettings);
+    const requestedLocale = environment.DI_CODE_LOCALE?.trim();
+    if (requestedLocale !== undefined && requestedLocale !== "" && !isLocale(requestedLocale)) {
+        throw new Error('DI_CODE_LOCALE must be "en" or "zh-CN".');
+    }
     const providers = Object.entries(settings.providers).map(([id, provider]) => ({
         id: requiredString(id, `providers.${id}`),
         name: provider.name,
@@ -397,7 +659,14 @@ export async function loadStartupConfiguration(cwd, environment = process.env, a
     const defaults = settings.defaultProvider === undefined && settings.defaultModel === undefined
         ? undefined
         : { providerId: settings.defaultProvider, modelId: settings.defaultModel };
-    return { environment, providers, ...(defaults === undefined ? {} : { defaults }) };
+    const locale = requestedLocale && isLocale(requestedLocale) ? requestedLocale : settings.locale;
+    return {
+        environment,
+        providers,
+        ...(settings.thinkingLevels === undefined ? {} : { thinkingLevels: settings.thinkingLevels }),
+        ...(locale === undefined ? {} : { locale }),
+        ...(defaults === undefined ? {} : { defaults }),
+    };
 }
 export async function loadStartupEnvironment(cwd, environment = process.env) {
     return (await loadStartupConfiguration(cwd, environment)).environment;