@di-code/coding-agent 0.1.6 → 0.1.8

package/dist/startup.js

@@ -1,4 +1,5 @@
-import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { randomUUID } from "node:crypto";
+import { mkdir, readFile, rename, unlink, writeFile } from "node:fs/promises";
 import { homedir } from "node:os";
 import { join } from "node:path";
 import { createAnthropicProvider, createDeepSeekProvider, createFauxProvider, createKimiProvider, createOpenAIChatCompletionsProvider, createOpenAIProvider, createZhipuProvider, findBuiltinModel, } from "@di-code/ai";
@@ -136,12 +137,23 @@ 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"`);
         }
+        const contextWindow = positiveInteger(model.contextWindow, `${modelPath}.contextWindow`, 128_000, settingsPath);
+        const maxOutputTokens = positiveInteger(model.maxTokens ?? model.maxOutputTokens, `${modelPath}.maxTokens`, 16_384, settingsPath);
+        if (maxOutputTokens >= contextWindow) {
+            throw new Error(`${settingsPath}: ${modelPath}.maxTokens must be smaller than contextWindow`);
+        }
         return {
             id,
             name: requiredString(model.name ?? id, `${modelPath}.name`, settingsPath),
@@ -151,11 +163,14 @@ 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),
-            maxOutputTokens: positiveInteger(model.maxTokens ?? model.maxOutputTokens, `${modelPath}.maxTokens`, 16_384, settingsPath),
+            contextWindow,
+            maxOutputTokens,
             cost: {
                 input: nonNegativeNumber(prices.input, `${modelPath}.cost.input`, 0, settingsPath) / 1_000_000,
                 output: nonNegativeNumber(prices.output, `${modelPath}.cost.output`, 0, settingsPath) / 1_000_000,
@@ -227,6 +242,7 @@ function serializeModel(model) {
         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 } : {}),
@@ -262,16 +278,49 @@ 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"`);
     }
+    if (record.permissionMode !== undefined &&
+        record.permissionMode !== "ask" &&
+        record.permissionMode !== "allow" &&
+        record.permissionMode !== "deny") {
+        throw new Error(`${settingsPath}: permissionMode must be "ask", "allow", or "deny"`);
+    }
     return {
         providers,
         ...(defaultProvider === undefined ? {} : { defaultProvider }),
         ...(defaultModel === undefined ? {} : { defaultModel }),
+        ...(thinkingLevels === undefined ? {} : { thinkingLevels }),
         ...(record.locale === undefined ? {} : { locale: record.locale }),
+        ...(record.permissionMode === undefined ? {} : { permissionMode: record.permissionMode }),
     };
 }
+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");
@@ -304,14 +353,45 @@ function mergeSettings(globalSettings, projectSettings) {
     const defaultProvider = projectSettings?.defaultProvider ?? globalSettings?.defaultProvider;
     const defaultModel = projectSettings?.defaultModel ??
         (projectSettings?.defaultProvider === undefined ? globalSettings?.defaultModel : undefined);
+    const thinkingLevels = mergeThinkingLevels(globalSettings?.thinkingLevels, projectSettings?.thinkingLevels);
     const locale = globalSettings?.locale;
     return {
         providers,
         ...(defaultProvider === undefined ? {} : { defaultProvider }),
         ...(defaultModel === undefined ? {} : { defaultModel }),
+        ...(thinkingLevels === undefined ? {} : { thinkingLevels }),
         ...(locale === undefined ? {} : { locale }),
+        ...(globalSettings?.permissionMode === undefined ? {} : { permissionMode: globalSettings.permissionMode }),
     };
 }
+function mergeThinkingLevels(globalPreferences, workspacePreferences) {
+    if (globalPreferences === undefined && workspacePreferences === undefined)
+        return undefined;
+    const result = {};
+    for (const [providerId, models] of Object.entries(globalPreferences ?? {}))
+        result[providerId] = { ...models };
+    for (const [providerId, models] of Object.entries(workspacePreferences ?? {})) {
+        result[providerId] = { ...result[providerId], ...models };
+    }
+    return result;
+}
+async function writeSettingsFile(agentDir, settings) {
+    const settingsFilePath = join(agentDir, SETTINGS_FILE_NAME);
+    await mkdir(agentDir, { recursive: true, mode: 0o700 });
+    const temporaryPath = `${settingsFilePath}.tmp-${randomUUID()}`;
+    try {
+        await writeFile(temporaryPath, `${JSON.stringify(settings, null, "\t")}\n`, { encoding: "utf8", mode: 0o600 });
+        await rename(temporaryPath, settingsFilePath);
+    }
+    finally {
+        try {
+            await unlink(temporaryPath);
+        }
+        catch {
+            // The temporary file was renamed or was never created.
+        }
+    }
+}
 /** Persists a user-level terminal language preference without changing project settings. */
 export async function saveGlobalLocale(agentDir, locale) {
     const settingsFilePath = join(agentDir, SETTINGS_FILE_NAME);
@@ -320,10 +400,19 @@ export async function saveGlobalLocale(agentDir, locale) {
         providers: existingSettings?.providers ?? {},
         ...(existingSettings?.defaultProvider === undefined ? {} : { defaultProvider: existingSettings.defaultProvider }),
         ...(existingSettings?.defaultModel === undefined ? {} : { defaultModel: existingSettings.defaultModel }),
+        ...(existingSettings?.thinkingLevels === undefined ? {} : { thinkingLevels: existingSettings.thinkingLevels }),
         locale,
+        ...(existingSettings?.permissionMode === undefined ? {} : { permissionMode: existingSettings.permissionMode }),
     };
-    await mkdir(agentDir, { recursive: true, mode: 0o700 });
-    await writeFile(settingsFilePath, `${JSON.stringify(settings, null, "\t")}\n`, { encoding: "utf8", mode: 0o600 });
+    await writeSettingsFile(agentDir, settings);
+}
+/** Persists the default permission mode; the active Session keeps its own runtime until next turn. */
+export async function saveGlobalPermissionMode(agentDir, permissionMode) {
+    const settingsFilePath = join(agentDir, SETTINGS_FILE_NAME);
+    const existingSettings = await readSettingsFile(settingsFilePath, settingsFilePath);
+    if (permissionMode !== "ask" && permissionMode !== "allow" && permissionMode !== "deny")
+        throw new Error(`${settingsFilePath}: permissionMode must be "ask", "allow", or "deny"`);
+    await writeSettingsFile(agentDir, { ...mergeSettings(existingSettings, undefined), permissionMode });
 }
 export async function saveGlobalProviderApiKey(agentDir, providerId, api, apiKey, modelId) {
     const settingsFilePath = join(agentDir, SETTINGS_FILE_NAME);
@@ -336,8 +425,80 @@ export async function saveGlobalProviderApiKey(agentDir, providerId, api, apiKey
         defaultProvider: providerId,
         ...(modelId === undefined ? {} : { defaultModel: modelId }),
     });
-    await mkdir(agentDir, { recursive: true, mode: 0o700 });
-    await writeFile(settingsFilePath, `${JSON.stringify(settings, null, "\t")}\n`, { encoding: "utf8", mode: 0o600 });
+    await writeSettingsFile(agentDir, settings);
+}
+/** 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 writeSettingsFile(agentDir, settings);
+}
+/**
+ * Persists a runtime preference in an existing workspace settings file, falling back to user settings when the
+ * workspace has no settings file. This keeps an explicit WebUI selection aligned with startup resolution.
+ */
+export async function saveScopedModelSelection(cwd, agentDir, providerId, modelId) {
+    const workspaceDir = join(cwd, ".di-code");
+    const workspacePath = join(cwd, SETTINGS_PATH);
+    const workspaceSettings = await readSettingsFile(workspacePath, SETTINGS_PATH);
+    if (workspaceSettings === undefined) {
+        await saveGlobalModelSelection(agentDir, providerId, modelId);
+        return;
+    }
+    const normalizedProviderId = requiredString(providerId, "providerId", SETTINGS_PATH);
+    const normalizedModelId = requiredString(modelId, "modelId", SETTINGS_PATH);
+    await writeSettingsFile(workspaceDir, {
+        ...workspaceSettings,
+        defaultProvider: normalizedProviderId,
+        defaultModel: normalizedModelId,
+    });
+}
+/** 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 writeSettingsFile(agentDir, settings);
+}
+/** Persists a thinking preference beside an existing workspace model selection, or in user settings as a fallback. */
+export async function saveScopedThinkingLevel(cwd, agentDir, providerId, modelId, level) {
+    const workspaceDir = join(cwd, ".di-code");
+    const workspacePath = join(cwd, SETTINGS_PATH);
+    const workspaceSettings = await readSettingsFile(workspacePath, SETTINGS_PATH);
+    if (workspaceSettings === undefined) {
+        await saveGlobalThinkingLevel(agentDir, providerId, modelId, level);
+        return;
+    }
+    const normalizedProviderId = requiredString(providerId, "providerId", SETTINGS_PATH);
+    const normalizedModelId = requiredString(modelId, "modelId", SETTINGS_PATH);
+    await writeSettingsFile(workspaceDir, {
+        ...workspaceSettings,
+        thinkingLevels: {
+            ...(workspaceSettings.thinkingLevels ?? {}),
+            [normalizedProviderId]: {
+                ...(workspaceSettings.thinkingLevels?.[normalizedProviderId] ?? {}),
+                [normalizedModelId]: level,
+            },
+        },
+    });
 }
 /**
  * Replaces the user-managed `custom` provider while retaining other global
@@ -361,8 +522,7 @@ export async function saveGlobalCustomProvider(agentDir, input) {
         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 });
+    await writeSettingsFile(agentDir, settings);
     return configuration;
 }
 /**
@@ -388,9 +548,11 @@ export async function removeGlobalProviderApiKey(agentDir, providerId) {
         ...(clearsDefault || existingSettings.defaultModel === undefined
             ? {}
             : { defaultModel: existingSettings.defaultModel }),
+        ...(existingSettings.thinkingLevels === undefined ? {} : { thinkingLevels: existingSettings.thinkingLevels }),
         ...(existingSettings.locale === undefined ? {} : { locale: existingSettings.locale }),
+        ...(existingSettings.permissionMode === undefined ? {} : { permissionMode: existingSettings.permissionMode }),
     };
-    await writeFile(settingsFilePath, `${JSON.stringify(settings, null, "\t")}\n`, { encoding: "utf8", mode: 0o600 });
+    await writeSettingsFile(agentDir, settings);
     return true;
 }
 function resolveConfigValue(value, env) {
@@ -561,6 +723,11 @@ 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)),
@@ -586,7 +753,9 @@ export async function loadStartupConfiguration(cwd, environment = process.env, a
     return {
         environment,
         providers,
+        ...(settings.thinkingLevels === undefined ? {} : { thinkingLevels: settings.thinkingLevels }),
         ...(locale === undefined ? {} : { locale }),
+        ...(settings.permissionMode === undefined ? {} : { permissionMode: settings.permissionMode }),
         ...(defaults === undefined ? {} : { defaults }),
     };
 }