micro-models-agent 2.10.0 → 2.12.0

package/dist/modules/session/auto-name.js

@@ -0,0 +1,63 @@
+// Автоимена сессий: детерминированное из первого сообщения + LLM-уточнение (fail-open).
+import { t } from "../../i18n/index";
+const MAX_NAME_LEN = 60;
+const MIN_CUT = 20;
+/** Детерминированное мгновенное имя сессии из первого сообщения пользователя. */
+export function deriveSessionName(input, date) {
+    const firstLine = input.split(/\r?\n/).find((l) => l.trim().length > 0) ?? "";
+    let s = firstLine
+        .replace(/```[\s\S]*?```/g, " ")
+        .replace(/`[^`]*`/g, " ")
+        .replace(/https?:\/\/\S+/gi, " ")
+        .replace(/^[#>\-*+\s]+/, "")
+        .replace(/\s+/g, " ")
+        .trim()
+        .replace(/[.,;:!?…]+$/u, "")
+        .trim();
+    if (!s) {
+        return t("session.default_name", { date: date ?? new Date().toISOString().slice(0, 10) });
+    }
+    if (s.length > MAX_NAME_LEN) {
+        const cut = s.slice(0, MAX_NAME_LEN);
+        const lastSpace = cut.lastIndexOf(" ");
+        s = `${(lastSpace > MIN_CUT ? cut.slice(0, lastSpace) : cut).trim()}…`;
+    }
+    return s;
+}
+/** Нормализовать заголовок от модели; мусор — null. */
+export function sanitizeTitle(raw) {
+    const first = raw
+        .split(/\r?\n/)
+        .map((l) => l.trim())
+        .find((l) => l.length > 0) ?? "";
+    const cleaned = first.replace(/^["'«»`]+|["'«»`.!,;:]+$/gu, "").trim();
+    if (!cleaned)
+        return null;
+    return cleaned.length > MAX_NAME_LEN ? `${cleaned.slice(0, MAX_NAME_LEN).trim()}…` : cleaned;
+}
+/** Собрать промпт заголовка из отрывка сообщения (первые 1000 символов). */
+export function buildTitlePrompt(input) {
+    const excerpt = input.slice(0, 1000);
+    return [
+        "Give a short session title for the message below.",
+        "Rules: 3-6 words, same language as the message, no quotes, no emoji, no trailing punctuation.",
+        "Reply with the title only.",
+        "",
+        excerpt,
+    ].join("\n");
+}
+/** Разовый LLM-заголовок с таймаутом. Fail-open — любая ошибка даёт null. */
+export async function generateSessionTitle(input, chat, timeoutMs = 8000) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        const raw = await chat(buildTitlePrompt(input), controller.signal);
+        return sanitizeTitle(raw);
+    }
+    catch {
+        return null;
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}

package/dist/modules/session/export.js

@@ -0,0 +1,98 @@
+import { getMessageText } from "../../llm/provider";
+import { redactContextSecrets } from "../../core/agent/context-log";
+function roleHeading(role) {
+    switch (role) {
+        case "user":
+            return "User";
+        case "assistant":
+            return "Assistant";
+        case "tool":
+            return "Tool";
+        case "system":
+            return "System";
+        default:
+            return role;
+    }
+}
+/** Отрендерить сессию в Markdown. */
+export function renderSessionMarkdown(meta, messages, opts) {
+    const lines = [];
+    const name = meta?.name ?? "session";
+    const id = meta?.id ?? "unknown";
+    lines.push(`# ${name} (${id})`);
+    lines.push("");
+    if (meta) {
+        lines.push(`- Model: ${meta.model}`);
+        lines.push(`- Created: ${meta.createdAt}`);
+        lines.push(`- Updated: ${meta.updatedAt}`);
+        lines.push(`- Messages: ${meta.messageCount}`);
+        if (meta.projectDir)
+            lines.push(`- Project: ${meta.projectDir}`);
+    }
+    lines.push("");
+    lines.push("---");
+    lines.push("");
+    for (const msg of messages) {
+        appendMessageLines(lines, msg, opts);
+    }
+    return lines.join("\n");
+}
+function appendMessageLines(lines, msg, opts) {
+    // Compact режет тела tool-результатов (основной объём длинных сессий);
+    // однострочники `- tool_call:` на ходах ассистента показывают, что запускалось.
+    if (opts?.compact && msg.role === "tool")
+        return;
+    const heading = roleHeading(msg.role);
+    const nameSuffix = msg.name ? ` (${msg.name})` : "";
+    lines.push(`## ${heading}${nameSuffix}`);
+    lines.push("");
+    const text = getMessageText(msg.content);
+    lines.push(text.length > 0 ? text : "_(empty)_");
+    lines.push("");
+    if (Array.isArray(msg.tool_calls)) {
+        for (const tc of msg.tool_calls) {
+            lines.push(`- tool_call: \`${tc.function.name}\` ${tc.function.arguments}`);
+        }
+        lines.push("");
+    }
+}
+/** Собрать JSON-экспорт сессии. */
+export function buildSessionJson(meta, messages, opts) {
+    const list = opts?.compact ? messages.filter((m) => m.role !== "tool") : messages;
+    return JSON.stringify({ meta, messages: list }, null, 2);
+}
+/** Объёмные снапшот-записи, выкидываемые --compact (для чтения человеком). */
+const COMPACT_JSONL_DROP = new Set(["context", "tool_defs", "tool_result", "llm_usage"]);
+/** Собрать JSONL-экспорт из журнала. */
+export function buildSessionJsonl(log, opts) {
+    const list = opts?.compact ? log.filter((e) => !COMPACT_JSONL_DROP.has(e.type)) : log;
+    return list.map((e) => JSON.stringify(e)).join("\n");
+}
+/** Отформатировать пакет в заданном формате. */
+export function formatExport(bundle, format, opts) {
+    switch (format) {
+        case "md":
+            return renderSessionMarkdown(bundle.meta, bundle.messages, opts);
+        case "json":
+            return buildSessionJson(bundle.meta, bundle.messages, opts);
+        case "jsonl":
+            return buildSessionJsonl(bundle.log, opts);
+    }
+}
+/** Вычистить секреты из экспорта, если не отключено. */
+export function redactExport(text, redact) {
+    return redact ? redactContextSecrets(text) : text;
+}
+/** Санитизировать имя сессии под имя файла. */
+export function sanitizeFileName(name) {
+    const cleaned = name
+        .replace(/[<>:"/\\|?*\u0000-\u001f]/g, "-")
+        .replace(/\s+/g, "-")
+        .replace(/-+/g, "-")
+        .replace(/^[-.]+|[-.]+$/g, "");
+    return cleaned.length > 0 ? cleaned.slice(0, 60) : "session";
+}
+/** Расширение файла под формат. */
+export function extensionFor(format) {
+    return format === "jsonl" ? "jsonl" : format;
+}

package/dist/modules/session/index.js

@@ -1,3 +1,4 @@
+// Публичный фасад модуля сессий: стор, менеджер, модуль, типы.
 export { SessionStore } from "./store";
 export { SessionManager } from "./manager";
 export { SessionModule } from "./module";

package/dist/modules/session/manager.js

@@ -1,34 +1,31 @@
 import { t } from "../../i18n/index";
+import { getMessageText } from "../../llm/provider";
 import { createSessionContext, DEFAULT_SESSION_ISOLATION, } from "../../modules/security/session-isolation";
+/** Менеджер: активная сессия, контексты изоляции, maxSessions, prune пустых. */
 export class SessionManager {
     store;
     activeId = null;
     options;
-    /**
-     * Map of session ID to session context (for isolation)
-     */
+    /** Контексты сессий (для изоляции) по id */
     sessionContexts = new Map();
     constructor(store, options) {
         this.store = store;
         this.options = options;
-        // Initialize encryption if configured
+        // Шифрование — если настроено
         if (options.encryption) {
             this.store.updateEncryption(options.encryption);
         }
     }
-    /**
-     * Check if session file encryption is enabled
-     */
+    /** Включено ли шифрование файлов сессий. */
     isEncryptionEnabled() {
         return this.store.isEncryptionEnabled();
     }
-    /**
-     * Update encryption configuration
-     */
+    /** Обновить конфиг шифрования. */
     updateEncryption(config) {
         this.store.updateEncryption(config);
         this.options.encryption = config;
     }
+    /** Создать сессию (имя/оверрайды опциональны), сделать активной. */
     create(name, securityOverrides) {
         const now = new Date().toISOString();
         const id = `ses_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
@@ -36,6 +33,7 @@ export class SessionManager {
         const meta = {
             id,
             name: sessionName,
+            nameSource: name ? "manual" : "default",
             createdAt: now,
             updatedAt: now,
             messageCount: 0,
@@ -47,22 +45,31 @@ export class SessionManager {
         this.store.saveMeta(id, meta);
         this.activeId = id;
         this.enforceMaxSessions();
-        // Create session context
+        try {
+            this.pruneEmpty(id);
+        }
+        catch {
+            // fail-open: автопрунинг не должен ломать создание сессии
+        }
+        // Контекст сессии
         const context = createSessionContext(id, this.options.projectDir, this.options.isolation, this.normalizeSecurityOverrides(securityOverrides));
         this.sessionContexts.set(id, context);
         return meta;
     }
+    /** Список сессий. */
     list() {
         return this.store.listSessions();
     }
+    /** Мета по id (null — нет). */
     get(id) {
         return this.store.loadMeta(id);
     }
+    /** Удалить сессию (+ контекст, сброс активной). */
     delete(id) {
-        // Clean up session context
+        // Чистим контекст сессии
         const context = this.sessionContexts.get(id);
         if (context) {
-            // In a real implementation, we would clean up temp files here
+            // Реально temp-файлы тут не чистятся (нет реализации)
             this.sessionContexts.delete(id);
         }
         this.store.deleteSession(id);
@@ -70,38 +77,79 @@ export class SessionManager {
             this.activeId = null;
         }
     }
-    rename(id, name) {
+    /** Переименовать сессию (источник имени: auto/manual). */
+    rename(id, name, source = "manual") {
         const meta = this.store.loadMeta(id);
         if (!meta)
             throw new Error(t("session.not_found", { id }));
         meta.name = name;
+        meta.nameSource = source;
         this.store.saveMeta(id, meta);
     }
+    /** Пустая ли сессия (нет user-сообщения с текстом). Fail-open: ошибки чтения — непустая. */
+    isEmptySession(id) {
+        const meta = this.store.loadMeta(id);
+        if (!meta)
+            return false;
+        if ((meta.messageCount ?? 0) === 0)
+            return true;
+        let history;
+        try {
+            history = this.getHistory(id);
+        }
+        catch {
+            return false;
+        }
+        return !history.some((m) => m.role === "user" && getMessageText(m.content).trim().length > 0);
+    }
+    /** Удалить все пустые сессии, кроме `excludeId`. Вернуть удалённые id. Не бросает. */
+    pruneEmpty(excludeId) {
+        const deleted = [];
+        for (const s of this.store.listSessions()) {
+            if (s.id === excludeId)
+                continue;
+            try {
+                if (this.isEmptySession(s.id)) {
+                    this.delete(s.id);
+                    deleted.push(s.id);
+                }
+            }
+            catch {
+                // fail-open: нечитаемые пропускаем
+            }
+        }
+        return deleted;
+    }
+    /** Id активной сессии (null — нет). */
     getActive() {
         return this.activeId;
     }
+    /** Мета активной сессии (null — нет). */
     getActiveMeta() {
         if (!this.activeId)
             return null;
         return this.store.loadMeta(this.activeId);
     }
+    /** Сделать сессию активной (нет такой — ошибка). */
     setActive(id) {
         if (!this.store.sessionExists(id)) {
             throw new Error(t("session.not_found", { id }));
         }
         this.activeId = id;
     }
+    /** Добавить сообщение в активную сессию (нет активной — ошибка). */
     appendMessage(msg) {
         if (!this.activeId)
             throw new Error(t("session.no_active"));
         this.store.appendMessage(this.activeId, msg);
     }
+    /** Добавить запись в лог активной сессии (без активной — молча пропуск). */
     appendLog(entry) {
         if (!this.activeId)
             return;
         this.store.appendSessionLog(this.activeId, entry);
     }
-    /** Read the full session.jsonl of any session (used by `session show`). */
+    /** Прочитать полный session.jsonl любой сессии (для `session show`). */
     loadSessionLog(id) {
         try {
             return this.store.loadSessionLog(id);
@@ -110,25 +158,34 @@ export class SessionManager {
             return [];
         }
     }
+    /** История активной сессии ([] — нет активной). */
     loadHistory() {
         if (!this.activeId)
             return [];
         return this.store.loadHistory(this.activeId);
     }
     /**
-     * Get the session context for the active session
+     * История любой сессии, включая ротированные (фолбэк на архив
+     * `<id>.jsonl.gz`, если живого history-файла нет). Для
+     * `session export` / `/export`.
      */
+    getHistory(id) {
+        const live = this.store.loadHistory(id);
+        if (live.length > 0)
+            return live;
+        return this.store.loadRotatedHistory(id);
+    }
+    /** Контекст активной сессии (для изоляции). */
     getSessionContext() {
         if (!this.activeId)
             return undefined;
         return this.getSessionContextById(this.activeId);
     }
-    /**
-     * Get the session context for a specific session
-     */
+    /** Каталог указанной сессии. */
     getSessionDirectory(id) {
         return this.store.getSessionDir(id);
     }
+    /** Контекст сессии по id (лениво создаётся из меты). */
     getSessionContextById(sessionId) {
         if (!this.sessionContexts.has(sessionId)) {
             const meta = this.store.loadMeta(sessionId);
@@ -139,21 +196,15 @@ export class SessionManager {
         }
         return this.sessionContexts.get(sessionId);
     }
-    /**
-     * Get session isolation configuration
-     */
+    /** Конфиг изоляции сессий. */
     getIsolationConfig() {
         return this.options.isolation ?? DEFAULT_SESSION_ISOLATION;
     }
-    /**
-     * Check if session isolation is enabled
-     */
+    /** Включена ли изоляция сессий. */
     isIsolationEnabled() {
         return this.getIsolationConfig().enabled;
     }
-    /**
-     * Normalize security overrides to match SecurityConfig structure
-     */
+    /** Нормализовать оверрайды под структуру SecurityConfig. */
     normalizeSecurityOverrides(overrides) {
         if (!overrides)
             return undefined;

package/dist/modules/session/module.js

@@ -1,4 +1,5 @@
 import { t } from "../../i18n/index";
+/** Модуль сессии: системный блок со стабильными полями + пустой плагин. */
 export class SessionModule {
     name = "session";
     manager;
@@ -9,9 +10,9 @@ export class SessionModule {
         const meta = this.manager.getActiveMeta();
         if (!meta)
             return null;
-        // Stable per session: id/name/model/contextWindow do not change between
-        // turns, so the system prompt is not mutated (KV-cache, rule #10). Live
-        // values (message count) are exposed through the session_info tool.
+        // Стабильно на сессию: id/имя/модель/окно между ходами не меняются,
+        // так что системный промпт не мутирует (KV-кеш). Живое (счётчик сообщений)
+        // отдаётся через тул session_info.
         return {
             content: t("session.info_full", {
                 name: meta.name,

package/dist/modules/session/store.js

@@ -1,11 +1,13 @@
+// Хранилище сессий: meta/history/session-лог на диске, шифрование, ротация в .gz.
 import { existsSync, mkdirSync, readdirSync, readFileSync, rmSync, writeFileSync, appendFileSync, } from "fs";
 import { join } from "path";
-import { gzipSync } from "zlib";
+import { gzipSync, gunzipSync } from "zlib";
 import { SessionFileEncryptor } from "../security/session-encryption";
+/** Файловое хранилище сессий: meta.json, history.jsonl, session.jsonl. */
 export class SessionStore {
     baseDir;
     encryptor = null;
-    // In-memory meta cache to avoid O(N²) disk reads on appendMessage.
+    // In-memory кеш меты — иначе O(N²) чтений диска на appendMessage.
     _metaCache = new Map();
     constructor(baseDir, encryptionConfig) {
         this.baseDir = baseDir;
@@ -13,12 +15,11 @@ export class SessionStore {
             this.encryptor = new SessionFileEncryptor(encryptionConfig);
         }
     }
+    /** Каталог сессии по id. */
     getSessionDir(id) {
         return join(this.baseDir, id);
     }
-    /**
-     * Update encryption configuration
-     */
+    /** Обновить конфиг шифрования. */
     updateEncryption(config) {
         if (config?.enabled) {
             this.encryptor = new SessionFileEncryptor(config);
@@ -27,12 +28,11 @@ export class SessionStore {
             this.encryptor = null;
         }
     }
-    /**
-     * Check if encryption is enabled
-     */
+    /** Включено ли шифрование. */
     isEncryptionEnabled() {
         return this.encryptor?.isEnabled() ?? false;
     }
+    /** Создать базовый каталог (0700). */
     init() {
         mkdirSync(this.baseDir, { recursive: true, mode: 0o700 });
     }
@@ -48,9 +48,11 @@ export class SessionStore {
     sessionLogPath(id) {
         return join(this.sessionDir(id), "session.jsonl");
     }
+    /** Есть ли сессия (по meta.json). */
     sessionExists(id) {
         return existsSync(this.metaPath(id));
     }
+    /** Сохранить мету (кеш + диск 0600, опционально шифр). */
     saveMeta(id, meta) {
         this._metaCache.set(id, meta);
         const dir = this.sessionDir(id);
@@ -66,6 +68,7 @@ export class SessionStore {
             writeFileSync(this.metaPath(id), content, { encoding: "utf-8", mode: 0o600 });
         }
     }
+    /** Загрузить мету (кеш, иначе диск); нет/битая — null. */
     loadMeta(id) {
         const cached = this._metaCache.get(id);
         if (cached)
@@ -84,8 +87,8 @@ export class SessionStore {
             return null;
         }
     }
-    /** Read meta straight from disk, bypassing _metaCache — used where counter
-     *  accuracy matters more than read speed (see appendMessage). */
+    /** Мета строго с диска, мимо _metaCache — там, где точность счётчика
+     *  важнее скорости чтения (см. appendMessage). */
     readMetaFromDisk(id) {
         const path = this.metaPath(id);
         if (!existsSync(path))
@@ -99,23 +102,24 @@ export class SessionStore {
             return null;
         }
     }
+    /** Добавить сообщение в историю; мету инкрементить с диска (защита от гонки процессов). */
     appendMessage(id, msg) {
         const dir = this.sessionDir(id);
         mkdirSync(dir, { recursive: true, mode: 0o700 });
         const line = JSON.stringify(msg);
         if (this.encryptor?.isEnabled()) {
-            appendFileSync(this.historyPath(id), this.encryptor.encryptFileContent(line) + "\n", {
+            appendFileSync(this.historyPath(id), `${this.encryptor.encryptFileContent(line)}\n`, {
                 encoding: "utf-8",
                 mode: 0o600,
             });
         }
         else {
-            appendFileSync(this.historyPath(id), line + "\n", { encoding: "utf-8", mode: 0o600 });
+            appendFileSync(this.historyPath(id), `${line}\n`, { encoding: "utf-8", mode: 0o600 });
         }
-        // Re-read meta from disk (not the cache) right before the increment so
-        // counters appended by ANOTHER process are not clobbered by a stale
-        // in-memory snapshot (last-write-wins). Full cross-process locking is out
-        // of scope; this narrows the race window.
+        // Мету перечитываем с диска прямо перед инкрементом, чтобы счётчики
+        // ДРУГОГО процесса не затирались протухшим in-memory снапшотом
+        // (last-write-wins). Полноценные кросс-процессные локи вне скоупа;
+        // это сужает окно гонки.
         const meta = this.readMetaFromDisk(id) ?? this._metaCache.get(id) ?? null;
         if (meta) {
             meta.messageCount = (meta.messageCount || 0) + 1;
@@ -123,6 +127,7 @@ export class SessionStore {
             this.saveMeta(id, meta);
         }
     }
+    /** Загрузить историю (битые строки пропускаются); нет файла — []. */
     loadHistory(id) {
         const path = this.historyPath(id);
         if (!existsSync(path))
@@ -158,20 +163,49 @@ export class SessionStore {
             return [];
         }
     }
+    /**
+     * История ротированной сессии из `<baseDir>/<id>.jsonl.gz`.
+     * Нет gz или не читается — [].
+     */
+    loadRotatedHistory(id) {
+        const gzPath = join(this.baseDir, `${id}.jsonl.gz`);
+        if (!existsSync(gzPath))
+            return [];
+        try {
+            const content = gunzipSync(readFileSync(gzPath)).toString("utf-8");
+            return content
+                .split("\n")
+                .filter(Boolean)
+                .map((line) => {
+                try {
+                    return JSON.parse(line);
+                }
+                catch {
+                    return null;
+                }
+            })
+                .filter((m) => m !== null);
+        }
+        catch {
+            return [];
+        }
+    }
+    /** Добавить запись в session-лог. */
     appendSessionLog(id, entry) {
         const dir = this.sessionDir(id);
         mkdirSync(dir, { recursive: true, mode: 0o700 });
         const line = JSON.stringify(entry);
         if (this.encryptor?.isEnabled()) {
-            appendFileSync(this.sessionLogPath(id), this.encryptor.encryptFileContent(line) + "\n", {
+            appendFileSync(this.sessionLogPath(id), `${this.encryptor.encryptFileContent(line)}\n`, {
                 encoding: "utf-8",
                 mode: 0o600,
             });
         }
         else {
-            appendFileSync(this.sessionLogPath(id), line + "\n", { encoding: "utf-8", mode: 0o600 });
+            appendFileSync(this.sessionLogPath(id), `${line}\n`, { encoding: "utf-8", mode: 0o600 });
         }
     }
+    /** Загрузить session-лог (битые строки пропускаются); нет файла — []. */
     loadSessionLog(id) {
         const path = this.sessionLogPath(id);
         if (!existsSync(path))
@@ -207,6 +241,7 @@ export class SessionStore {
             return [];
         }
     }
+    /** Список сессий по убыванию updatedAt. */
     listSessions() {
         if (!existsSync(this.baseDir))
             return [];
@@ -222,6 +257,7 @@ export class SessionStore {
         sessions.sort((a, b) => new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime());
         return sessions;
     }
+    /** Удалить сессию (кеш + каталог). */
     deleteSession(id) {
         this._metaCache.delete(id);
         const dir = this.sessionDir(id);
@@ -229,6 +265,7 @@ export class SessionStore {
             rmSync(dir, { recursive: true, force: true });
         }
     }
+    /** Ротация: истории старше 30 дней — в .jsonl.gz, мета помечается rotated. */
     rotateOldSessions() {
         const thirtyDaysAgo = new Date();
         thirtyDaysAgo.setDate(thirtyDaysAgo.getDate() - 30);
@@ -243,8 +280,8 @@ export class SessionStore {
                     const gzPath = join(this.baseDir, `${session.id}.jsonl.gz`);
                     writeFileSync(gzPath, compressed);
                     rmSync(historyPath);
-                    // Mark the meta so the session stops looking "live" in lists —
-                    // otherwise a gzipped session still advertises messageCount > 0.
+                    // Пометить мету, чтобы сессия не выглядела «живой» в списках —
+                    // иначе gz-сессия рекламирует messageCount > 0.
                     const meta = this.loadMeta(session.id);
                     if (meta) {
                         meta.messageCount = 0;

package/dist/modules/setup/answers.js

@@ -0,0 +1,35 @@
+// Модель данных first-run визарда: ответы, языки, дефолты, провайдеры для UI.
+/**
+ * Общая модель данных first-run визарда.
+ * Едят оба фронтенда (терминальный `src/cli/setup.ts` и браузерный визард
+ * `mma web`), чтобы форма и дефолты не расходились. Без терминальных/UI
+ * зависимостей — безопасно импортить с веб-сервера.
+ */
+import { BUILTIN_PROVIDERS } from "../providers/presets";
+/** Языки UI визарда (подписи — на своём языке). */
+export const SETUP_LANGUAGES = [
+    { value: "en", label: "English" },
+    { value: "ru", label: "Русский" },
+];
+/** Числовые дефолты шага настроек агента. */
+export const SETUP_DEFAULTS = {
+    contextWindow: 32768,
+    maxToolIterations: 1000,
+};
+/** Статические display-данные, общие для веб-визарда и его тестов. */
+export function buildSetupDisplay() {
+    const providers = BUILTIN_PROVIDERS.map((spec) => {
+        const option = { type: spec.type, label: spec.label };
+        if (spec.baseUrl)
+            option.baseUrl = spec.baseUrl;
+        return option;
+    });
+    return {
+        languages: SETUP_LANGUAGES.map((l) => ({ value: l.value, label: l.label })),
+        providers,
+        defaults: {
+            contextWindow: SETUP_DEFAULTS.contextWindow,
+            maxToolIterations: SETUP_DEFAULTS.maxToolIterations,
+        },
+    };
+}