cortico 0.1.1 → 0.1.2

package/src/providers/console/hub.ts

@@ -0,0 +1,270 @@
+import { coerceGroupValues, getByPath, setByPath } from '../../core/config-schema.ts';
+/** Connection configuration transactions serialize writers across deployments and roll back all touched files on failure. */
+import { createHash, randomUUID } from 'node:crypto';
+import { existsSync, mkdirSync, readFileSync, readdirSync, renameSync, rmSync, writeFileSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import type { CoreConfig, LLMProviderEntry } from '../../core/types.ts';
+import type { Language } from '../../core/language.ts';
+import { readJsonObject, updateJsonObject } from '../../config-file.ts';
+import { readTextFile } from '../../core/util.ts';
+import type { ProviderModule } from '../base.ts';
+import { validateEntry } from '../configuration.ts';
+import { validateProviderName } from '../name.ts';
+import { providerModules, type ProviderRegistry } from '../registry.ts';
+import type { ProviderSettings } from './settings.ts';
+import { quotePrices } from '../pricebook.ts';
+import { connectionGroup } from './config.ts';
+
+export class ProviderHubError extends Error {
+  constructor(message: string, readonly status = 400) { super(message); }
+}
+export interface ConnectionSave {
+  name: string;
+  copyFrom?: { name: string; revision: string };
+  entry: LLMProviderEntry;
+  expectedRevision?: string;
+  secretValue?: string;
+}
+export class ProviderHub {
+  private readonly revisions = new Map<string, string>();
+  constructor(private readonly config: CoreConfig, private readonly registry: ProviderRegistry,
+    private readonly settings: ProviderSettings, private readonly file: string,
+    private readonly root: string, private readonly modules: readonly ProviderModule[] = providerModules) {}
+
+  private path(name: string): string {
+    const path = resolve(this.root, name);
+    if (!name || dirname(path) !== resolve(this.root)) throw new ProviderHubError('Invalid provider identifier.');
+    return path;
+  }
+  private revision(name: string): string {
+    const dir = this.path(name);
+    return createHash('sha256').update(['config.json', '.env'].map(file =>
+      existsSync(join(dir, file)) ? readFileSync(join(dir, file)).toString('base64') : '').join(':')).digest('hex');
+  }
+  private refresh(): void {
+    const entries: Record<string, LLMProviderEntry> = Object.create(null);
+    if (existsSync(this.root)) for (const dir of readdirSync(this.root, { withFileTypes: true })) {
+      if (!dir.isDirectory() || (dir.name === '.write-lock' || dir.name.startsWith('.transaction-') || dir.name.startsWith('.deleted-'))) continue;
+      const file = join(this.root, dir.name, 'config.json');
+      if (existsSync(file)) entries[dir.name] = JSON.parse(readTextFile(file));
+    }
+    for (const name of new Set([...Object.keys(entries), ...Object.keys(this.config.providers)])) {
+      const revision = entries[name] ? this.revision(name) : '';
+      if (JSON.stringify(entries[name]) !== JSON.stringify(this.config.providers[name]) || this.revisions.get(name) !== revision) this.registry.invalidate(name);
+      this.revisions.set(name, revision);
+    }
+    this.config.providers = entries;
+    const disk = readJsonObject(this.file);
+    if (typeof disk.activeProvider === 'string') this.config.activeProvider = disk.activeProvider;
+  }
+  moduleList(language: Language) {
+    return this.modules.map(module => ({ id: module.id, title: module.title,
+      description: module.localize?.(language)?.description ?? module.description ?? module.title, defaultBaseUrl: module.defaultBaseUrl ?? '',
+      reasoningTiers: module.localize?.(language)?.reasoningTiers ?? module.reasoningTiers,
+      effortSuggestions: module.effortSuggestions ?? [], serviceTiers: module.localize?.(language)?.serviceTiers ?? module.serviceTiers,
+      temperatureNote: module.localize?.(language)?.temperatureNote ?? module.temperatureNote,
+    }));
+  }
+  private readiness(name: string, entry: LLMProviderEntry, language: Language) {
+    const module = this.modules.find(m => m.id === entry.kind);
+    if (!module) return { state: 'module-missing', reason: language === 'zh' ? '供应商模块不可用。' : 'Provider module is unavailable.' };
+    try { validateEntry(module, entry, language); }
+    catch (error) { return { state: 'invalid', reason: String(error) }; }
+    if (!entry.spec?.model || (entry.secret && this.settings.secretStatus(name, entry) === 'none'))
+      return { state: 'needs-setup', reason: !entry.spec?.model ? (language === 'zh' ? '请选择模型。' : 'Model is required.') : (language === 'zh' ? '请配置 API Key。' : 'API Key is required.') };
+    const available = module.availability?.(name, entry, language);
+    if (available && !available.ready) return { state: 'runtime-unavailable', reason: available.reason };
+    return { state: 'ready' };
+  }
+  current(language: Language) {
+    const name = this.config.activeProvider;
+    const entry = this.config.providers[name];
+    return entry ? { name, model: entry.spec?.model ?? null, module: entry.kind,
+      moduleTitle: this.modules.find(module => module.id === entry.kind)?.title ?? entry.kind,
+      baseUrl: entry.baseUrl, ready: this.readiness(name, entry, language).state === 'ready' } : null;
+  }
+  list(language: Language) {
+    this.refresh();
+    return { scope: createHash('sha256').update(resolve(this.file)).digest('hex'), active: this.config.activeProvider, providers: Object.entries(this.config.providers).map(([name, entry]) => ({
+      id: name, name, module: entry.kind, moduleTitle: this.modules.find(m => m.id === entry.kind)?.title ?? entry.kind,
+      model: entry.spec?.model ?? null, baseUrl: entry.baseUrl, active: name === this.config.activeProvider,
+      readiness: this.readiness(name, entry, language), revision: this.revision(name),
+    })) };
+  }
+  detail(name: string, language: Language) {
+    this.refresh();
+    const entry = this.config.providers[name];
+    if (!entry) throw new ProviderHubError('Provider does not exist.', 404);
+    return { name, entry: structuredClone(entry), revision: this.revision(name),
+      secretConfigured: this.settings.secretStatus(name, entry), readiness: this.readiness(name, entry, language),
+      references: this.references(name).map(file => dirname(file).split(/[\\/]/).at(-1)),
+      config: this.groups(name, entry, language),
+      quotes: entry.spec ? [{ model: entry.spec.model, quotes: this.quotes(entry) }] : [],
+    };
+  }
+  private quotes(entry: LLMProviderEntry) {
+    const module = this.modules.find(module => module.id === entry.kind);
+    const request = { model: entry.spec?.model };
+    const at = { startedAt: new Date().toISOString(), requestedServiceTier: entry.serviceTier ?? null };
+    return quotePrices(entry, request, at, module?.prices?.(entry, request, at) ?? []);
+  }
+  groups(name: string, entry: LLMProviderEntry, language: Language) {
+    const module = this.modules.find(m => m.id === entry.kind);
+    return [connectionGroup(name, entry, language), ...(module?.config?.(name, entry, language) ?? [])];
+  }
+  async preview(name: string, entry: LLMProviderEntry, panel: string, method: string, args: unknown[], language: Language) {
+    this.path(name);
+    const module = this.modules.find(module => module.id === entry.kind);
+    if (!module?.console) throw new ProviderHubError('Module panel unavailable.');
+    this.refresh();
+    const current = this.config.providers[name];
+    const persisted = !!current && JSON.stringify(current) === JSON.stringify(entry);
+    let draft = structuredClone(entry);
+    const contribution = module.console({ language, editing: !persisted,
+      entries: () => [{ name, entry: draft }],
+      instance: requested => {
+        if (requested !== name) throw new ProviderHubError('Foreign provider.');
+        return persisted ? this.registry.resolve(name) : this.registry.preview(name, draft);
+      },
+      save: (requested, next) => {
+        if (requested !== name || next.kind !== entry.kind) throw new ProviderHubError('Foreign provider.');
+        draft = structuredClone(next);
+      },
+    });
+    const result = await contribution.invoke?.(panel, method, args);
+    return { result, entry: draft };
+  }
+  private references(name: string): string[] {
+    const files = new Set([this.file]);
+    const parent = dirname(this.root);
+    for (const dir of readdirSync(parent, { withFileTypes: true })) {
+      if (!dir.isDirectory() || resolve(parent, dir.name) === resolve(this.root)) continue;
+      const file = join(parent, dir.name, 'config.json');
+      if (existsSync(file) && existsSync(join(parent, dir.name, 'deployment.json'))) files.add(file);
+    }
+    return [...files].filter(file => readJsonObject(file).activeProvider === name);
+  }
+  private locked<T>(work: () => T): T {
+    mkdirSync(this.root, { recursive: true });
+    const lock = join(this.root, '.write-lock');
+    try { mkdirSync(lock); } catch { throw new ProviderHubError('Another provider transaction is in progress. Retry after it completes.', 409); }
+    try { this.refresh(); return work(); } finally { rmSync(lock, { recursive: true, force: true }); }
+  }
+  private checkRevision(name: string, expected: unknown): void {
+    if (typeof expected !== 'string' || expected !== this.revision(name))
+      throw new ProviderHubError('Configuration changed in another page or bot. Reload before saving.', 409);
+  }
+  save(original: string | null, input: ConnectionSave, language: Language) {
+    return this.locked(() => {
+      const { name } = input;
+      if (typeof name !== 'string') throw new ProviderHubError('Provider name is required.');
+      const prior = original ? this.config.providers[original] : undefined;
+      if (original && !prior) throw new ProviderHubError('Provider does not exist.', 404);
+      if (original) this.checkRevision(original, input.expectedRevision);
+      if (name !== original) {
+        const problem = validateProviderName(name);
+        if (problem) throw new ProviderHubError(problem);
+        if (readdirSync(this.root).some(value => value.toLowerCase() === name.toLowerCase()))
+          throw new ProviderHubError('Provider name or directory already exists.', 409);
+      }
+      if (!input.entry || typeof input.entry !== 'object') throw new ProviderHubError('Provider configuration is required.');
+      if (prior && prior.kind !== input.entry.kind) throw new ProviderHubError('Provider module cannot be changed.');
+      const module = this.modules.find(m => m.id === input.entry.kind);
+      if (!module) throw new ProviderHubError('Provider module is unavailable.');
+      const requested = structuredClone(input.entry);
+      if (!requested.spec?.model) throw new ProviderHubError('Model is required.');
+      if (input.secretValue !== undefined && (typeof input.secretValue !== 'string' || !input.secretValue || /\s/.test(input.secretValue)))
+        throw new ProviderHubError('API Key must be nonempty and contain no whitespace.');
+      if (input.secretValue && !requested.secret) requested.secret = 'CORTICO_PROVIDER_API_KEY';
+      const entry = validateEntry(module, requested, language);
+      const prefix = `providers.${name}.`;
+      for (const group of this.groups(name, entry, language)) {
+        const values = Object.fromEntries(Object.keys(group.schema.properties).filter(path => path.startsWith(prefix))
+          .map(path => [path, getByPath(entry as unknown as Record<string, unknown>, path.slice(prefix.length))])
+          .filter(([, value]) => value !== undefined));
+        const result = coerceGroupValues(group, values, language);
+        if ('error' in result) throw new ProviderHubError(result.error);
+        for (const [path, value] of Object.entries(result.values)) setByPath(entry as unknown as Record<string, unknown>, path.slice(prefix.length), value);
+      }
+      validateEntry(module, entry, language);
+      let copiedSecret: Buffer | null = null;
+      let credentialSource = original;
+      if (!original && input.copyFrom) {
+        const source = this.config.providers[input.copyFrom.name];
+        if (!source) throw new ProviderHubError('Copy source no longer exists.', 409);
+        this.checkRevision(input.copyFrom.name, input.copyFrom.revision);
+        if (source.secret === entry.secret) {
+          credentialSource = input.copyFrom.name;
+          const file = join(this.path(input.copyFrom.name), '.env');
+          if (existsSync(file)) copiedSecret = readFileSync(file);
+        }
+      }
+      if (entry.secret && !input.secretValue && (!credentialSource || this.settings.secretStatus(credentialSource, entry) === 'none'))
+        throw new ProviderHubError('API Key is required.');
+      const target = this.path(name);
+      const source = original ? this.path(original) : null;
+      const stage = join(this.root, `.transaction-${randomUUID()}`);
+      const refs = original && name !== original ? this.references(original) : [];
+      const backups = new Map<string, Buffer | null>();
+      for (const file of [...refs, ...(source ? [join(source, 'config.json'), join(source, '.env')] : [])])
+        backups.set(file, existsSync(file) ? readFileSync(file) : null);
+      let moved = false;
+      try {
+        if (!source) mkdirSync(stage);
+        const dir = source ?? stage;
+        updateJsonObject(join(dir, 'config.json'), raw => { for (const key of Object.keys(raw)) delete raw[key]; Object.assign(raw, entry); });
+        if (copiedSecret) writeFileSync(join(dir, '.env'), copiedSecret);
+        if (input.secretValue) {
+          const file = join(dir, '.env');
+          const lines = (existsSync(file) ? readTextFile(file) : '').split(/\r?\n/).filter(line => line.split('=')[0]?.trim() !== entry.secret);
+          lines.push(`${entry.secret}=${input.secretValue}`);
+          writeFileSync(file, lines.filter(Boolean).join('\n') + '\n');
+        }
+        if (source !== target) { renameSync(dir, target); moved = true; }
+        for (const file of refs) updateJsonObject(file, raw => { raw.activeProvider = name; });
+      } catch (error) {
+        if (moved) renameSync(target, source ?? stage);
+        for (const [file, contents] of backups) {
+          if (contents === null) rmSync(file, { force: true }); else writeFileSync(file, contents);
+        }
+        throw error;
+      } finally { if (existsSync(stage)) rmSync(stage, { recursive: true, force: true }); }
+      if (original) this.registry.invalidate(original);
+      this.registry.invalidate(name);
+      this.refresh();
+      return this.detail(name, language);
+    });
+  }
+  activate(name: string, language: Language): void {
+    this.locked(() => {
+      const entry = this.config.providers[name];
+      if (!entry) throw new ProviderHubError('Provider does not exist.', 404);
+      const readiness = this.readiness(name, entry, language);
+      if (readiness.state !== 'ready') throw new ProviderHubError(readiness.reason ?? readiness.state);
+      updateJsonObject(this.file, raw => { raw.activeProvider = name; });
+      this.config.activeProvider = name;
+    });
+  }
+  delete(name: string, revision: string): void {
+    this.locked(() => {
+      if (!this.config.providers[name]) throw new ProviderHubError('Provider does not exist.', 404);
+      this.checkRevision(name, revision);
+      const refs = this.references(name);
+      if (this.config.activeProvider === name || refs.length)
+        throw new ProviderHubError(`Provider is used by: ${refs.map(file => dirname(file).split(/[\\/]/).at(-1)).join(', ') || 'current bot'}`, 409);
+      const tomb = join(this.root, `.deleted-${randomUUID()}`);
+      renameSync(this.path(name), tomb);
+      this.registry.invalidate(name);
+      delete this.config.providers[name];
+      rmSync(tomb, { recursive: true, force: true });
+    });
+  }
+  async action(name: string, action: string, language: Language) {
+    this.refresh();
+    const entry = this.config.providers[name];
+    if (!entry) throw new ProviderHubError('Provider does not exist.', 404);
+    const source = this.settings.sources().find(source => source.id === `llm:${entry.kind}`);
+    if (!source) throw new ProviderHubError('Provider module is unavailable.');
+    return source.contribute(language).invoke!('settings', action === 'test' ? 'probe' : 'models', [{ name }]);
+  }
+}

package/src/providers/console/settings.ts

@@ -26,14 +26,12 @@ import { readTextFile } from '../../core/util.ts';
 import { responseRequest } from '../../protocol/open-responses/context-helpers.ts';
 import { record } from '../../protocol/open-responses/context.ts';
 import { text } from './strings.ts';
-import type { ProviderConsoleHost } from './types.ts';
+import { PROBE_MAX_OUTPUT_TOKENS, type ProviderConsoleHost } from './types.ts';
+import { connectionGroup } from './config.ts';
 
 export type SecretStatus = 'env' | 'file' | 'none';
 
-/** Output token limit used by the connectivity probe. */
-const PROBE_MAX_OUTPUT_TOKENS = 256;
-
-/** 密钥变量名由操作员自由填写,拼进正则前按字面转义。 */
+/** 密钥变量名由操作员自由填写,也可能是直接写在磁盘上的任意名字,拼进正则前按字面转义。 */
 function escapeRegExp(s: string): string {
   return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 }
@@ -70,7 +68,8 @@ export class ProviderSettings {
   private declaredGroups(language: Language) {
     return this.modules.flatMap((module) =>
       this.entries(module).flatMap(({ name, entry }) =>
-        (module.config?.(name, entry, language) ?? []).map((group) => ({ name, group })),
+        [connectionGroup(name, entry, language), ...(module.config?.(name, entry, language) ?? [])]
+          .map((group) => ({ name, group })),
       ),
     );
   }
@@ -281,7 +280,7 @@ export class ProviderSettings {
     return { label: S.availableLamp, state: 'offline', hint: reason };
   }
 
-  /** 所有模块合起来有没有一个可用端点。控制台左栏「语言模型」那一行点的就是它。 */
+  /** 所有模块合起来有没有一个可用端点。控制台左栏「模型提供商」那一行点的就是它。 */
   providersLamp(language: Language = 'zh'): ConsoleLamp {
     return this.availableLamp(
       this.modules.flatMap((module) => this.entries(module)),
@@ -312,16 +311,7 @@ export class ProviderSettings {
       kind: 'llm',
       label: module.title,
       availability: 'active',
-      lamps: [
-        {
-          label: S.activeInstanceLamp,
-          state: entries.some((value) => value.name === this.config.activeProvider)
-            ? 'online'
-            : 'offline',
-        },
-        this.availableLamp(this.entries(module), language),
-        ...(extra.lamps ?? []),
-      ],
+      lamps: [],
       badges: [{ label: S.instancesBadge, value: String(entries.length) }, ...(extra.badges ?? [])],
       panels: [
         {
@@ -334,7 +324,7 @@ export class ProviderSettings {
         },
         ...(extra.panels ?? []),
       ],
-      config: entries.flatMap(
+      config: extra.config ?? entries.flatMap(
         ({ name, entry }) => module.config?.(name, entry, language) ?? [],
       ),
       invoke: async (panel, method, args) => {
@@ -358,6 +348,8 @@ export class ProviderSettings {
             instances: this.entries(module).map(({ name, entry }) => ({
               name,
               entry,
+              config: this.declaredGroups(language).filter((item) => item.name === name)
+                .map(({ group }) => ({ group, values: this.values(group.id, language) })),
               secretConfigured: this.secretStatus(name, entry),
               quotes: (entry.spec ? [entry.spec] : []).map((spec) => ({
                 model: spec.model,
@@ -383,7 +375,7 @@ export class ProviderSettings {
         const name = body.name;
         if (method === 'create') {
           this.assertNewName(name, language);
-          // 报价留空:用量页把这条端点的调用记成未计价,而不是零元。
+          // 报价留空:不覆盖模块价目;模块也没给价目时,这条端点的调用只记 token,不记金额。
           this.save(name, {
             kind: module.id,
             baseUrl: String(body.baseUrl || module.defaultBaseUrl || ''),

package/src/providers/console/types.ts

@@ -2,9 +2,14 @@ import type { LLMProviderEntry } from '../../core/types.ts';
 import type { Language } from '../../core/language.ts';
 import type { ProviderInstance } from '../base.ts';
 
+/** Output token limit for the connectivity probe and module probes. */
+export const PROBE_MAX_OUTPUT_TOKENS = 256;
+
 export interface ProviderConsoleHost {
   /** Console language for panel titles, receipts and error texts. */
   readonly language: Language;
+  /** Configuration edits return to the browser draft; runtime mutations require a saved connection. */
+  readonly editing?: boolean;
   entries(): Array<{ name: string; entry: LLMProviderEntry }>;
   instance(name: string): ProviderInstance;
   save(name: string, entry: LLMProviderEntry): void;

package/src/providers/hub-api.ts

@@ -0,0 +1,3 @@
+import type { ProviderHub } from './console/hub.ts';
+
+export type ProviderHubApi = Pick<ProviderHub, 'list' | 'moduleList' | 'groups' | 'preview' | 'detail' | 'save' | 'delete' | 'activate' | 'action'>;

package/src/providers/llamacpp/config.ts

@@ -0,0 +1,38 @@
+import type { ConfigGroup, ConfigProperty } from '../../core/config-schema.ts';
+import type { Language } from '../../core/language.ts';
+import type { LLMProviderEntry } from '../../core/types.ts';
+import { backendChoices, llamacppOptions } from './options.ts';
+import { panel } from './strings.ts';
+
+export function runtimeConfig(name: string, entry: LLMProviderEntry, language: Language): ConfigGroup[] {
+  if (!llamacppOptions(entry).runtime) return [];
+  const S = panel[language];
+  const group = (
+    id: string, title: string, description: string, properties: Record<string, ConfigProperty>,
+  ): ConfigGroup => ({
+    id: `llm.llamacpp.${name}.${id}`,
+    owner: 'provider:llamacpp',
+    schema: {
+      type: 'object', title, description,
+      properties: Object.fromEntries(Object.entries(properties).map(([path, property]) => [
+        `providers.${name}.options.${path}`, { ...property, 'x-hot': true },
+      ])),
+    },
+  });
+  return [
+    group('runtime', S.runtimeSection, S.runtimeSectionDesc, {
+      'runtime.release': { type: 'string', title: S.release, description: S.releaseHint },
+      'runtime.backend': { type: 'string', title: S.backend, enum: backendChoices(), description: S.backendHint },
+      'runtime.runtimeDir': {
+        type: 'string', title: S.runtimeDir, description: S.runtimeDirHint, 'x-path': { kind: 'directory' },
+      },
+    }),
+    group('launch', S.launchSection, S.launchSectionDesc, {
+      'launch.contextSize': { type: 'integer', title: S.contextSize, minimum: 1 },
+      'launch.nGpuLayers': { type: 'integer', title: S.nGpuLayers, minimum: 0 },
+      'launch.parallel': { type: 'integer', title: S.parallel, minimum: 1 },
+      'launch.extraArgs': { type: 'string', title: S.extraArgs, description: S.extraArgsHint },
+      autoStart: { type: 'boolean', title: S.autoStart },
+    }),
+  ];
+}

package/src/providers/llamacpp/console/runtime-panel.ts

@@ -3,11 +3,12 @@
  * The endpoint comes from `ctx.scope.instance`; edits are written on change.
  */
 import type { ConsolePanel, ConsolePanelContext } from '../../../web/shared/client-panel.ts';
-import type { LaunchOptions } from '../options.ts';
-import type { RuntimeState } from '../runtime.ts';
+import type { ConfigValues } from '../../../core/config-schema.ts';
+import { configField } from '../../../web/client/features/config/view.ts';
+import type { RuntimePanelState } from './server.ts';
 import { panel } from '../strings.ts';
 
-type Row = RuntimeState & { name: string };
+type Row = RuntimePanelState;
 
 const POLL_MS = 2_000;
 
@@ -42,18 +43,35 @@ export const runtimePanel: ConsolePanel = {
       await load(true);
     }
 
-    /** One launch field; empty input sends NaN so the endpoint reports the same error as a bad value. */
-    function launchNumber(row: Row, key: keyof LaunchOptions, label: string, min: number): HTMLElement {
-      const current = row.launch?.[key];
-      const input = ui.input({
-        type: 'number',
-        value: current === undefined ? '' : String(current),
-        onChange: (value) => void act('configure', { launch: { [key]: Number(value) } }),
-      });
-      input.min = String(min);
-      input.step = '1';
-      input.setAttribute('aria-label', label);
-      return ui.field(label, input);
+    async function saveConfig(groupId: string, values: ConfigValues): Promise<void> {
+      if (busy) return;
+      busy = true;
+      message.textContent = '';
+      try {
+        await ctx.setConfig(groupId, values);
+      } catch (error) {
+        message.textContent = String(error);
+      } finally {
+        busy = false;
+      }
+      await load(true);
+    }
+
+    function renderConfig(row: Row, index: number, body: HTMLElement): void {
+      const { group, values } = row.config[index];
+      body.append(ui.section(group.schema.title, group.schema.description));
+      for (const [path, property] of Object.entries(group.schema.properties)) {
+        const field = configField(ui, property, values[path], () => {
+          if (field.read) void saveConfig(group.id, { [path]: field.read() });
+        }, ctx.signal);
+        field.node.setAttribute('aria-label', property.title);
+        // 自备运行时目录时后端由目录里的二进制决定,后端那一格禁用。
+        if (path.endsWith('.runtime.backend') && row.own) {
+          (field.node as HTMLSelectElement).disabled = true;
+        }
+        body.append(ui.field(property.title, field.node));
+        if (property.description) body.append(ui.msgline(property.description));
+      }
     }
 
     function renderUnmanaged(row: Row, body: HTMLElement): void {
@@ -74,42 +92,8 @@ export const runtimePanel: ConsolePanel = {
         : install.phase === 'extracting' ? ui.pill(S.extracting, 'plain')
         : ui.pill(S.absent, 'off');
 
-      body.append(ui.section(S.runtimeSection, S.runtimeSectionDesc));
-      const release = ui.input({
-        value: row.release ?? '',
-        cls: 'mono',
-        onChange: (value) => void act('configure', { release: value }),
-      });
-      release.setAttribute('aria-label', S.release);
-      const backend = ui.select({
-        value: row.backend ?? '',
-        options: row.backendChoices,
-        onChange: (value) => void act('configure', { backend: value }),
-      });
-      backend.setAttribute('aria-label', S.backend);
-      backend.disabled = row.own;
-      const dir = ui.input({
-        value: row.own ? row.runtimeDir ?? '' : '',
-        cls: 'mono',
-        onChange: (value) => void act('configure', { runtimeDir: value }),
-      });
-      dir.setAttribute('aria-label', S.runtimeDir);
-      const dirRow = ui.rowbar();
-      dirRow.append(dir, ui.button(S.browse, {
-        size: 'sm',
-        onClick: async () => {
-          const picked = await ctx.pickPath({ kind: 'directory', title: S.runtimeDir, currentPath: dir.value });
-          if (picked) await act('configure', { runtimeDir: picked });
-        },
-      }));
-      body.append(
-        ui.field(S.release, release),
-        ui.msgline(S.releaseHint),
-        ui.field(S.backend, backend),
-        ui.field(S.runtimeDir, dirRow),
-        ui.msgline(S.runtimeDirHint),
-        ui.kv([{ k: S.installStatus, v: installPill }]),
-      );
+      renderConfig(row, 0, body);
+      body.append(ui.kv([{ k: S.installStatus, v: installPill }]));
       if (row.smartAppControl === 1) body.append(ui.msgline(S.sacWarning, true));
       if (install.phase === 'downloading' || install.phase === 'extracting') {
         const progress = ui.progress({
@@ -133,28 +117,7 @@ export const runtimePanel: ConsolePanel = {
       installBar.append(ui.h('span', 'grow'), ui.button(S.disable, { onClick: () => void act('disable') }));
       body.append(installBar);
 
-      body.append(ui.section(S.launchSection, S.launchSectionDesc));
-      const launchRow = ui.rowbar();
-      launchRow.append(
-        launchNumber(row, 'contextSize', S.contextSize, 1),
-        launchNumber(row, 'nGpuLayers', S.nGpuLayers, 0),
-        launchNumber(row, 'parallel', S.parallel, 1),
-      );
-      const extraArgs = ui.input({
-        value: row.launch?.extraArgs ?? '',
-        cls: 'mono',
-        onChange: (value) => void act('configure', { launch: { extraArgs: value } }),
-      });
-      extraArgs.setAttribute('aria-label', S.extraArgs);
-      body.append(
-        launchRow,
-        ui.field(S.extraArgs, extraArgs),
-        ui.msgline(S.extraArgsHint),
-        ui.checkbox(S.autoStart, {
-          checked: row.autoStart,
-          onChange: (checked) => void act('configure', { autoStart: checked }),
-        }).el,
-      );
+      renderConfig(row, 1, body);
 
       body.append(ui.section(S.serverSection, S.serverSectionDesc));
       const server = row.server;

package/src/providers/llamacpp/console/server.ts

@@ -8,6 +8,9 @@ import type { ProviderConsoleHost } from '../../console/types.ts';
 import type { RouterCatalog, RouterModel } from '../catalog.ts';
 import { LAUNCH_DEFAULTS, PINNED_RELEASE, backendChoices, defaultBackend, llamacppOptions, type LaunchOptions } from '../options.ts';
 import type { LlamaRuntime } from '../runtime.ts';
+import type { RuntimeState } from '../runtime.ts';
+import { runtimeConfig } from '../config.ts';
+import { getByPath, type ConfigGroup, type ConfigValues } from '../../../core/config-schema.ts';
 import { text } from '../strings.ts';
 
 interface Control {
@@ -23,6 +26,11 @@ export interface ModelsState {
   models: RouterModel[];
 }
 
+export type RuntimePanelState = RuntimeState & {
+  name: string;
+  config: Array<{ group: ConfigGroup; values: ConfigValues }>;
+};
+
 /** The launch fields the panel edits, each optional and applied over the stored values. */
 type LaunchPatch = Partial<Record<keyof LaunchOptions, unknown>>;
 
@@ -42,6 +50,7 @@ export function llamacppConsole(host: ProviderConsoleHost): Partial<ConsolePageC
     return found.entry;
   };
   return {
+    config: [],
     panels: [
       { id: 'runtime', title: S.runtimePanel, description: S.runtimePanelDescription, slot: 'instance' },
       { id: 'models', title: S.modelsPanel, description: S.modelsPanelDescription, slot: 'instance' },
@@ -50,7 +59,17 @@ export function llamacppConsole(host: ProviderConsoleHost): Partial<ConsolePageC
       if (panel === 'runtime') {
         const value = body(args);
         const name = value.name as string;
-        if (method === 'state') return { name, ...(await control(name).runtime.state(host.language)) };
+        if (method === 'state') {
+          const entry = entryOf(name);
+          const prefix = `providers.${name}.`;
+          const config = runtimeConfig(name, entry, host.language).map((group) => ({
+            group,
+            values: Object.fromEntries(Object.keys(group.schema.properties).map((path) => [
+              path, getByPath(entry as unknown as Record<string, unknown>, path.slice(prefix.length)) ?? '',
+            ])) as ConfigValues,
+          }));
+          return { name, ...(await control(name).runtime.state(host.language)), config } satisfies RuntimePanelState;
+        }
         if (method === 'enable') {
           const entry = entryOf(name);
           const options = llamacppOptions(entry);
@@ -66,7 +85,7 @@ export function llamacppConsole(host: ProviderConsoleHost): Partial<ConsolePageC
           return { ok: true };
         }
         if (method === 'disable') {
-          await control(name).runtime.stop(host.language);
+          if (!host.editing) await control(name).runtime.stop(host.language);
           const entry = entryOf(name);
           const { runtime: _runtime, launch: _launch, ...rest } = entry.options ?? {};
           host.save(name, { ...entry, options: rest });
@@ -96,6 +115,7 @@ export function llamacppConsole(host: ProviderConsoleHost): Partial<ConsolePageC
           });
           return { ok: true };
         }
+        if (host.editing) throw new Error(host.language === 'zh' ? '请先保存配置，再执行运行时操作。' : 'Save configuration before runtime operations.');
         if (method === 'install') {
           await control(name).runtime.install(host.language);
           return { ok: true };
@@ -120,6 +140,7 @@ export function llamacppConsole(host: ProviderConsoleHost): Partial<ConsolePageC
           await catalog.list(true);
           return { ok: true };
         }
+        if (host.editing) throw new Error(host.language === 'zh' ? '请先保存配置，再操作模型。' : 'Save configuration before model operations.');
         if (typeof value.model !== 'string' || !value.model.trim()) throw new Error(S.modelIdRequired);
         const model = value.model.trim();
         if (method === 'pull') await catalog.download(model);

package/src/providers/llamacpp/index.ts

@@ -4,6 +4,7 @@ import type { Language } from '../../core/language.ts';
 import { isContextOverflow } from '../transport/errors.ts';
 import { modelsRoot, runtimesRoot } from '../../paths.ts';
 import { RouterCatalog } from './catalog.ts';
+import { runtimeConfig } from './config.ts';
 import { llamacppConsole } from './console/server.ts';
 import { LlamaCppProvider } from './native.ts';
 import { backendChoices, llamacppOptions, normalizeLlamaCpp } from './options.ts';
@@ -23,12 +24,14 @@ const reasoningTiers = (language: Language): ReasoningTier[] => {
 export default {
   id: 'llamacpp',
   title: 'llama.cpp',
+  description: 'Connect to or manage local llama.cpp models.',
   defaultBaseUrl: 'http://127.0.0.1:8090/v1',
   baseUrlSuggestions: ['http://127.0.0.1:8090/v1', 'http://127.0.0.1:8080/v1'],
   normalize: normalizeLlamaCpp,
   console: llamacppConsole,
+  config: runtimeConfig,
   reasoningTiers: reasoningTiers('zh'),
-  localize: (language) => ({ reasoningTiers: reasoningTiers(language) }),
+  localize: (language) => ({ description: language === 'zh' ? '连接或托管本地 llama.cpp 模型。' : 'Connect to or manage local llama.cpp models.', reasoningTiers: reasoningTiers(language) }),
   serviceTiers: [],
   validateEntry: (entry, language) => {
     const S = text(language);
@@ -87,6 +90,7 @@ export default {
         apiKey,
         log: host.log,
         media: { enabled: () => entry.multimodal === true, read: host.readBlob },
+        keepThinking: host.keepThinking,
       }),
     };
   },