cortico 0.1.0 → 0.1.2

package/src/providers/base.ts

@@ -60,7 +60,7 @@ export interface ProviderInstance {
   contextWindow?(model: string): number | undefined;
 }
 
-/** 端点是否满足本地配置条件；不探测远端可达性或生成结果。 */
+/** 一个端点此刻能不能发起生成。判断只看本地状态,不连上游。 */
 export interface ProviderAvailability {
   ready: boolean;
   /** 不可用的原因,控制台语言;可用时不带。 */
@@ -70,6 +70,7 @@ export interface ProviderAvailability {
 export interface ProviderModule {
   id: string;
   title: string;
+  description?: string;
   defaultBaseUrl?: string;
   /** Candidate endpoint URLs offered on the URL field. Candidates only: any URL is accepted. */
   baseUrlSuggestions?: readonly string[];
@@ -83,6 +84,7 @@ export interface ProviderModule {
    * Absent (or a field left out) = the tables above are shown as written.
    */
   localize?(language: Language): {
+    description?: string;
     reasoningTiers?: readonly ReasoningTier[];
     serviceTiers?: readonly ServiceTier[];
     temperatureNote?: string;

package/src/providers/configuration.ts

@@ -47,7 +47,8 @@ export function validateSpec(
 }
 
 /**
- * 返回第一项不满足的本地条件；通用条件满足后才询问模块。
+ * 端点能不能用:选了模型、声明的密钥读得到,模块自己的条件也满足。
+ * 通用条件不满足就不问模块,第一条不满足的就是回给操作员的那句话。
  */
 export function endpointAvailability(
   module: ProviderModule,

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,15 +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, '\\$&');
 }
@@ -250,6 +247,7 @@ export class ProviderSettings {
     })) satisfies ConsolePageSource[];
   }
 
+  /** 端点能不能用:通用条件由框架查,模块自己的条件由模块答。 */
   availability(name: string, language: Language = 'zh'): ProviderAvailability {
     const entry = this.config.providers[name];
     if (!entry) return { ready: false, reason: text(language).unknownInstance };
@@ -263,7 +261,8 @@ export class ProviderSettings {
   }
 
   /**
-   * 汇总端点的本地可用性，附第一个可用端点或最后一个不可用原因。
+   * 这批端点里有没有一个能用。灯亮=有;悬停说明给出第一个可用的端点名,
+   * 或者最后一个端点的不可用原因。
    */
   private availableLamp(
     entries: ReadonlyArray<{ name: string }>,
@@ -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: [
         {
@@ -385,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

@@ -7,26 +7,28 @@ 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, properties: Record<string, ConfigProperty>): ConfigGroup => ({
+  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,
+      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, {
+    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() },
+      '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, {
-      'launch.contextSize': { type: 'integer', title: S.contextSize, minimum: 1, description: S.launchSectionDesc },
+    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 },

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

@@ -59,12 +59,16 @@ export const runtimePanel: ConsolePanel = {
 
     function renderConfig(row: Row, index: number, body: HTMLElement): void {
       const { group, values } = row.config[index];
-      body.append(ui.section(group.schema.title));
+      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));
       }

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

@@ -85,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 });
@@ -115,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 };
@@ -139,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

@@ -24,13 +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);
@@ -89,6 +90,7 @@ export default {
         apiKey,
         log: host.log,
         media: { enabled: () => entry.multimodal === true, read: host.readBlob },
+        keepThinking: host.keepThinking,
       }),
     };
   },

package/src/providers/llamacpp/native.ts

@@ -2,23 +2,26 @@
  * Chat Completions against llama-server. Thinking is the template's `enable_thinking` switch
  * sent per request through `chat_template_kwargs`; templates without that variable ignore it.
  * The server returns the chain of thought as `reasoning_content` (`--reasoning-format deepseek`),
- * which the shared Chat assembly already maps; past thinking is not replayed.
+ * which the shared Chat assembly already maps; history sends it back on every request.
+ * `keepPastThinking` off blanks every turn but the synthetic opening; thinking off sends none.
  */
 import type { NativeChatMessage } from '../transport/native-types.ts';
 import type { ModelSpec, ToolSchema, Logger } from '../../core/types.ts';
 import { nullLogger } from '../../core/util.ts';
 import { OpenAIHttpClient } from '../transport/chat.ts';
-import { mapTools, renderMessagesWithMedia, type CompatMediaOptions } from '../transport/history.ts';
+import { dropPastThinking, mapTools, renderMessagesWithMedia, type CompatMediaOptions } from '../transport/history.ts';
 
 export function buildLlamaCppRequestBody(
   spec: ModelSpec,
   messages: NativeChatMessage[],
   tools?: ToolSchema[],
   media?: CompatMediaOptions,
+  opts?: { keepThinking?: boolean },
 ): Record<string, unknown> {
+  const history = opts?.keepThinking === false ? dropPastThinking(messages) : messages;
   const body: Record<string, unknown> = {
     model: spec.model,
-    messages: renderMessagesWithMedia(messages, media),
+    messages: renderMessagesWithMedia(history, media, { keepReasoning: spec.thinking }),
     chat_template_kwargs: { enable_thinking: spec.thinking },
   };
   if (spec.thinking && spec.reasoningEffort) body.reasoning_effort = spec.reasoningEffort;
@@ -32,15 +35,17 @@ export function buildLlamaCppRequestBody(
 export class LlamaCppProvider extends OpenAIHttpClient {
   private readonly apiKey?: string;
   private readonly media?: CompatMediaOptions;
+  private readonly keepThinking?: () => boolean;
 
-  constructor(opts: { baseUrl: string; apiKey?: string; log?: Logger; media?: CompatMediaOptions }) {
+  constructor(opts: { baseUrl: string; apiKey?: string; log?: Logger; media?: CompatMediaOptions; keepThinking?: () => boolean }) {
     super(opts.baseUrl, opts.log ?? nullLogger());
     this.apiKey = opts.apiKey;
     this.media = opts.media;
+    this.keepThinking = opts.keepThinking;
   }
 
   protected buildBody(spec: ModelSpec, messages: NativeChatMessage[], tools?: ToolSchema[]): Record<string, unknown> {
-    return buildLlamaCppRequestBody(spec, messages, tools, this.media);
+    return buildLlamaCppRequestBody(spec, messages, tools, this.media, { keepThinking: this.keepThinking?.() });
   }
 
   protected headers(): Record<string, string> {

package/src/providers/llamacpp/strings.ts

@@ -101,9 +101,9 @@ const panelZh = {
     '启动失败时可在 Windows 安全中心核对拦截记录；若确认被拦截，请使用符合信任要求的运行时。',
   server: '服务进程',
   serverSection: '服务进程与端点',
-  serverSectionDesc: '',
+  serverSectionDesc: 'llama-server 本地服务管理与监听状态。',
   runtimeSection: '二进制运行环境',
-  runtimeSectionDesc: '',
+  runtimeSectionDesc: '官方 llama.cpp 二进制包与运行依赖管理。',
   releaseHint: '上游 release tag，如 b10930；换了要重新下载。',
   backendHint: '按本机平台给出的官方构建;CUDA 版自动搭配上游的 cudart 包。',
   runtimeDirHint: '填了就不下载:目录里要有 llama-server 及其动态库(自编译、Linux CUDA、签过名的构建)。',
@@ -141,7 +141,7 @@ const panelZh = {
   pullPlaceholder: 'HuggingFace 仓库,如 ggml-org/Qwen2.5-Coder-7B-Instruct-GGUF',
   localDir: '本机 GGUF 目录',
   cacheDir: '缓存目录',
-  noModels: '暂无 GGUF 模型。可下载模型，或将 .gguf 文件放入本机目录后重新扫描。',
+  noModels: '暂无可用的 GGUF 模型：可通过上方输入拉取，或将 .gguf 文件放入本机目录后点击重扫。',
   modelStatusLabel: {
     loaded: '已加载',
     loading: '加载中',
@@ -175,9 +175,9 @@ const panelEn: typeof panelZh = {
     'If startup fails, check Windows Security for a block record. If a block is confirmed, use a runtime that meets the trust requirements.',
   server: 'Server',
   serverSection: 'Server Process & Endpoint',
-  serverSectionDesc: '',
+  serverSectionDesc: 'llama-server local process and listening status.',
   runtimeSection: 'Binary Runtime Environment',
-  runtimeSectionDesc: '',
+  runtimeSectionDesc: 'Official llama.cpp binary and dependencies.',
   releaseHint: 'Upstream release tag, such as b10930; changing it downloads another build.',
   backendHint: 'Official builds for this platform; CUDA builds are paired with the upstream cudart package.',
   runtimeDirHint: 'When set nothing is downloaded: the directory holds llama-server and its shared libraries (self-built, Linux CUDA, signed builds).',
@@ -215,7 +215,7 @@ const panelEn: typeof panelZh = {
   pullPlaceholder: 'HuggingFace repo, e.g. ggml-org/Qwen2.5-Coder-7B-Instruct-GGUF',
   localDir: 'Local GGUF directory',
   cacheDir: 'Cache directory',
-  noModels: 'No GGUF models. Download a model, or place GGUF files in the local directory and rescan.',
+  noModels: 'No models yet: pull one above, or drop GGUF files into the local directory and rescan.',
   modelStatusLabel: {
     loaded: 'loaded',
     loading: 'loading',

package/src/providers/name.ts

@@ -0,0 +1,8 @@
+/** New connection names are portable directory names; unchanged historical keys are exempt. */
+export function validateProviderName(name: string): string | null {
+  if (!/^[A-Za-z0-9][A-Za-z0-9_-]*$/.test(name))
+    return 'Use English letters, digits, - or _; start with a letter or digit. Spaces are not allowed.';
+  if (/^(con|prn|aux|nul|com[0-9]|lpt[0-9])$/i.test(name))
+    return 'This name is reserved by Windows.';
+  return null;
+}

package/src/providers/openai-responses-compat/config.ts

@@ -1,6 +1,7 @@
 import type { ConfigGroup } from '../../core/config-schema.ts';
 import type { LLMProviderEntry } from '../../core/types.ts';
 import type { Language } from '../../core/language.ts';
+import { REASONING_REPLAYS, SYNTHETIC_REASONING_TEXT } from '../transport/responses-input.ts';
 import { text } from './strings.ts';
 
 export function protocolConfig(name: string, entry: LLMProviderEntry, language: Language): ConfigGroup[] {
@@ -11,9 +12,21 @@ export function protocolConfig(name: string, entry: LLMProviderEntry, language:
     schema: {
       type: 'object', title: name,
       properties: {
+        [`providers.${name}.options.extraHeaders`]: {
+          type: 'object', title: language === 'zh' ? '附加请求头（JSON object）' : 'Extra headers (JSON object)',
+        },
+        [`providers.${name}.options.extraBody`]: {
+          type: 'object', title: language === 'zh' ? '附加请求体（JSON object）' : 'Extra request body (JSON object)',
+        },
         [`providers.${name}.options.endpointPath`]: {
           type: 'string', title: S.endpointPath, description: S.endpointPathDescription, 'x-hot': true,
         },
+        [`providers.${name}.options.reasoningReplay`]: {
+          type: 'string', enum: [...REASONING_REPLAYS], title: S.reasoningReplay, description: S.reasoningReplayDescription, 'x-hot': true,
+        },
+        [`providers.${name}.options.syntheticReasoningText`]: {
+          type: 'string', title: S.syntheticReasoningText, description: S.syntheticReasoningTextDescription(SYNTHETIC_REASONING_TEXT), 'x-hot': true,
+        },
       },
     },
   }];

package/src/providers/openai-responses-compat/console/client.ts

@@ -0,0 +1,5 @@
+import type { ConsoleClientBundle } from '../../../web/shared/client-panel.ts';
+import { reasoningPanel } from './reasoning-panel.ts';
+
+// The endpoint table (`builtin: 'llm-settings'`) is the console's own; only the reasoning section ships here.
+export default { panels: { reasoning: reasoningPanel } } satisfies ConsoleClientBundle;