cortico 0.1.1 → 0.1.3

package/src/providers/console/hub.ts

@@ -0,0 +1,307 @@
+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 { basename, 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, defaultSecretName } 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';
+import { instanceIsRunning } from '../../core/instance-lock.ts';
+import { CORE_DEFAULTS } from '../../core/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,
+      sections: this.sections(module.id, language),
+    }));
+  }
+  /** The editor's sections for one module, in order: the page's panels minus the endpoint table. */
+  private sections(kind: string, language: Language) {
+    const source = this.settings.sources().find(source => source.id === `llm:${kind}`);
+    return (source?.contribute(language).panels ?? []).filter(panel => panel.id !== 'settings')
+      .map(({ id, title, description, builtin }) => ({ id, title, ...(description ? { description } : {}), ...(builtin ? { builtin } : {}) }));
+  }
+  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),
+      usage: this.references(name).filter(file => resolve(file) !== resolve(this.file)).map(file => {
+        const config = readJsonObject(file);
+        const paths = config.paths as { data?: string } | undefined;
+        return { name: basename(dirname(file)), running: instanceIsRunning(resolve(dirname(file), paths?.data ?? CORE_DEFAULTS.paths.data)) };
+      }),
+    })) };
+  }
+  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 = withTypedSecret(name, structuredClone(input.entry), input.secretValue);
+      if (!requested.spec?.model) throw new ProviderHubError('Model is required.');
+      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 });
+    });
+  }
+  /**
+   * Probe (`test`) or list models (`models`). With `draft`, the request goes through an instance
+   * built from the browser's entry and typed key; nothing is written, and `name` may not exist yet.
+   */
+  async action(name: string, action: 'test' | 'models', language: Language, draft?: { entry: LLMProviderEntry; secretValue?: string }) {
+    this.refresh();
+    if (!draft) {
+      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 }]);
+    }
+    this.path(name);
+    if (!draft.entry || typeof draft.entry !== 'object') throw new ProviderHubError('Provider configuration is required.');
+    const module = this.modules.find(m => m.id === draft.entry.kind);
+    if (!module) throw new ProviderHubError('Provider module is unavailable.');
+    const entry = validateEntry(module, withTypedSecret(name, draft.entry, draft.secretValue), language);
+    const registry = this.registry.previewRegistry(name, entry, entry.secret && draft.secretValue ? { [entry.secret]: draft.secretValue } : {});
+    if (action === 'models') {
+      const instance = registry.resolve(name);
+      if (!instance.listModels) throw new ProviderHubError('This module does not list models.');
+      return { models: await instance.listModels() };
+    }
+    if (!entry.spec) throw new ProviderHubError('Model is required.');
+    return this.settings.probeClient(registry.bind(name), entry.spec, language);
+  }
+}
+
+/** A typed key with no variable name declared is stored under the name derived from the endpoint name. */
+function withTypedSecret(name: string, entry: LLMProviderEntry, secretValue: string | undefined): LLMProviderEntry {
+  if (secretValue !== undefined && (typeof secretValue !== 'string' || !secretValue || /\s/.test(secretValue)))
+    throw new ProviderHubError('API Key must be nonempty and contain no whitespace.');
+  return secretValue && !entry.secret ? { ...entry, secret: defaultSecretName(name) } : entry;
+}

package/src/providers/console/settings.ts

@@ -15,25 +15,23 @@ import { existsSync, mkdirSync, readdirSync, rmSync, writeFileSync } from 'node:
 import { join } from 'node:path';
 import { updateJsonObject } from '../../config-file.ts';
 import type { Language } from '../../core/language.ts';
-import type { ConsoleLamp, ConsolePageContribution } from '../../web/shared/console-protocol.ts';
+import { isConnectionEditorBlock, type ConsoleLamp, type ConsolePageContribution } from '../../web/shared/console-protocol.ts';
 import type { ConsolePageSource } from '../../web/console-pages.ts';
 import { providerModules, type ProviderRegistry } from '../registry.ts';
 import type { ProviderAvailability, ProviderModule } from '../base.ts';
 import { endpointAvailability, validateEntry } from '../configuration.ts';
 import { quotePrices, validatePrices, type PriceDefinition } from '../pricebook.ts';
-import { GenerationError } from '../../core/generation.ts';
+import { GenerationError, type ResponseClient } from '../../core/generation.ts';
 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 { connectionBlocks, 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 })),
       ),
     );
   }
@@ -200,18 +199,24 @@ export class ProviderSettings {
     return readdirSync(dir).filter((file) => file !== 'config.json');
   }
 
-  private async probe(name: string, language: Language) {
+  private probe(name: string, language: Language) {
     const S = text(language);
     const entry = this.config.providers[name];
     if (!entry) throw new Error(S.unknownInstance);
     if (!entry.spec) throw new Error(S.specRequired);
+    return this.probeClient(this.registry.bind(name), entry.spec, language);
+  }
+
+  /** One diagnostic request through `client`; the receipt carries status, latency, usage and charges, or the failure and a hint. */
+  async probeClient(client: ResponseClient, spec: ModelSpec, language: Language) {
+    const S = text(language);
     const request = {
-      ...responseRequest(entry.spec, [record({ type: 'message', role: 'user', content: 'ping' })]),
-      max_output_tokens: Math.min(entry.spec.maxTokens ?? PROBE_MAX_OUTPUT_TOKENS, PROBE_MAX_OUTPUT_TOKENS),
+      ...responseRequest(spec, [record({ type: 'message', role: 'user', content: 'ping' })]),
+      max_output_tokens: Math.min(spec.maxTokens ?? PROBE_MAX_OUTPUT_TOKENS, PROBE_MAX_OUTPUT_TOKENS),
     };
     const started = Date.now();
     try {
-      const generation = await this.registry.bind(name).respond(request, { diagnostic: true, nativeSpec: entry.spec, role: 'probe' });
+      const generation = await client.respond(request, { diagnostic: true, nativeSpec: spec, role: 'probe' });
       const attempt = generation.attempts.at(-1);
       return {
         ok: true,
@@ -281,7 +286,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)),
@@ -306,22 +311,19 @@ export class ProviderSettings {
       },
     };
     const extra = module.console?.(host) ?? {};
+    // A module that places none of the editor's blocks gets the default order, its own sections between model and pricing.
+    const declared = extra.panels ?? [];
+    const blocks = connectionBlocks(language);
+    const sections = declared.some((panel) => isConnectionEditorBlock(panel.builtin))
+      ? declared
+      : [blocks.endpoint, blocks.model, ...declared, blocks.pricing, blocks.protocol];
     return {
       ...extra,
       id: `llm:${module.id}`,
       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: [
         {
@@ -332,9 +334,9 @@ export class ProviderSettings {
           // 使用控制台内建端点面板，操作由下方 invoke 提供。
           builtin: 'llm-settings',
         },
-        ...(extra.panels ?? []),
+        ...sections,
       ],
-      config: entries.flatMap(
+      config: extra.config ?? entries.flatMap(
         ({ name, entry }) => module.config?.(name, entry, language) ?? [],
       ),
       invoke: async (panel, method, args) => {
@@ -358,6 +360,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 +387,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/strings.ts

@@ -14,6 +14,13 @@ const zh = {
   instancesBadge: '实例',
   settingsPanel: '实例与模型',
   settingsPanelDescription: "保存端点模型、价目及当前部署使用的端点。",
+  endpointBlock: '连接',
+  endpointBlockDescription: '模型服务的地址与 API Key。',
+  modelBlock: '模型与生成',
+  modelBlockDescription: '模型名与生成参数;模型列表从端点拉取。',
+  pricingBlock: '成本与计价',
+  protocolBlock: '高级协议',
+  protocolBlockDescription: '仅在使用自定义 API 网关或兼容服务时调整。',
   saved: '参数已保存；下一次请求生效。',
   unknownGroup: '未知 Provider 参数组',
   groupOutOfScope: 'Provider 参数组只能修改所属实例',
@@ -49,6 +56,13 @@ const en: typeof zh = {
   instancesBadge: 'Instances',
   settingsPanel: 'Instances and models',
   settingsPanelDescription: "Save the endpoint model, pricing and the active endpoint for this deployment.",
+  endpointBlock: 'Connection',
+  endpointBlockDescription: 'Provider URL and API Key.',
+  modelBlock: 'Model and generation',
+  modelBlockDescription: 'Model name and generation parameters; the model list comes from the endpoint.',
+  pricingBlock: 'Pricing',
+  protocolBlock: 'Advanced protocol',
+  protocolBlockDescription: 'Adjust only for custom API gateways or compatible services.',
   saved: 'Parameters saved; they apply from the next request.',
   unknownGroup: 'Unknown provider parameter group',
   groupOutOfScope: 'A provider parameter group can only modify its own instance',

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 },
+    }),
+  ];
+}