cortico 0.1.0

package/src/protocol/open-responses/stream.ts

@@ -0,0 +1,146 @@
+import type { OutputItem, Response, StreamEvent } from './index.ts';
+import { STREAM_EVENT_TYPES } from './generated.ts';
+
+export class ResponseProtocolError extends Error {
+  constructor(message: string) { super(message); this.name = 'ResponseProtocolError'; }
+}
+
+type Part = { type: string; text?: string; refusal?: string; annotations?: unknown[] };
+type MutableItem = { id: string; type: string; status?: string; call_id?: string; name?: string; arguments?: string; content?: Part[]; summary?: Part[] };
+
+function check(condition: unknown, message: string): asserts condition {
+  if (!condition) throw new ResponseProtocolError(message);
+}
+
+function canonical(value: unknown): string {
+  if (Array.isArray(value)) return `[${value.map(canonical).join(',')}]`;
+  if (value !== null && typeof value === 'object') {
+    return `{${Object.entries(value).sort(([a], [b]) => a.localeCompare(b)).map(([k, v]) => `${JSON.stringify(k)}:${canonical(v)}`).join(',')}}`;
+  }
+  return JSON.stringify(value);
+}
+
+/** One attempt's standard event stream. Transport termination is checked by finish(). */
+export class ResponseAccumulator {
+  private response: Response | null = null;
+  private readonly items = new Map<number, OutputItem>();
+  private readonly ids = new Set<string>();
+  private readonly closed = new Set<number>();
+  private readonly closedParts = new Set<string>();
+  private lastSequence = -1;
+  private terminal = false;
+
+  accept(event: StreamEvent): void {
+    check(event && STREAM_EVENT_TYPES.has(event.type), 'Unknown Open Responses event type');
+    check(!this.terminal, 'Event after terminal response');
+    check(Number.isInteger(event.sequence_number) && event.sequence_number > this.lastSequence, 'Non-increasing event sequence');
+    this.lastSequence = event.sequence_number;
+    if (event.type === 'response.created') {
+      check(this.response === null, 'Duplicate response.created');
+      this.response = structuredClone(event.response);
+      return;
+    }
+    check(this.response !== null, 'Event before response.created');
+    if ('response' in event) {
+      check(event.response.id === this.response.id, 'Response identity changed');
+      const terminal = ['response.completed', 'response.incomplete', 'response.failed'].includes(event.type);
+      if (terminal) {
+        check(event.response.status === event.type.slice('response.'.length), 'Response terminal status disagrees with event');
+        check(event.response.output.length === this.items.size, 'Terminal response contains unannounced output items');
+        for (const [index, item] of this.items) {
+          const final = event.response.output[index];
+          check(final?.id === item.id, 'Terminal response changed output order');
+          if (this.closed.has(index)) check(canonical(item) === canonical(final), 'Terminal response changed a closed item');
+        }
+        this.terminal = true;
+      }
+      this.response = structuredClone(event.response);
+      return;
+    }
+    if (event.type === 'error') return;
+    if (event.type === 'response.output_item.added') {
+      check(event.item !== null, 'Missing output item');
+      check(Number.isInteger(event.output_index) && event.output_index >= 0, 'Invalid output index');
+      check(!this.items.has(event.output_index) && !this.ids.has(event.item.id), 'Duplicate output item');
+      this.items.set(event.output_index, structuredClone(event.item));
+      this.ids.add(event.item.id);
+      return;
+    }
+    const item = this.items.get(event.output_index) as MutableItem | undefined;
+    check(item, 'Event refers to an unknown output item');
+    check(!this.closed.has(event.output_index), 'Update after output_item.done');
+    if (event.type === 'response.output_item.done') {
+      check(event.item !== null, 'Missing output item');
+      check(event.item.id === item.id && event.item.type === item.type, 'Item identity changed');
+      if (item.type === 'function_call') {
+        check(event.item.type === 'function_call' && event.item.arguments === item.arguments, 'Final function arguments disagree with deltas');
+        check(event.item.call_id === item.call_id && event.item.name === item.name, 'Final function identity changed');
+      }
+      for (const field of ['content', 'summary'] as const) {
+        if (item[field]?.length) check(canonical(item[field]) === canonical((event.item as MutableItem)[field]), `Final ${field} disagrees with deltas`);
+      }
+      check(!('status' in event.item) || event.item.status !== 'in_progress', 'Done item is still in progress');
+      this.items.set(event.output_index, structuredClone(event.item));
+      this.closed.add(event.output_index);
+      return;
+    }
+    check(event.item_id === item.id, 'Item ID disagrees with output index');
+    if (event.type === 'response.function_call_arguments.delta') {
+      check(item.type === 'function_call', 'Arguments on a non-function item');
+      check(!this.closedParts.has(`${item.id}/arguments`), 'Arguments after arguments.done');
+      item.arguments = (item.arguments ?? '') + event.delta;
+      return;
+    }
+    if (event.type === 'response.function_call_arguments.done') {
+      check(item.type === 'function_call' && item.arguments === event.arguments, 'Final function arguments disagree with deltas');
+      const key = `${item.id}/arguments`;
+      check(!this.closedParts.has(key), 'Duplicate arguments.done');
+      this.closedParts.add(key);
+      return;
+    }
+    const summary = 'summary_index' in event;
+    const index = summary ? event.summary_index : 'content_index' in event ? event.content_index : -1;
+    check(Number.isInteger(index) && index >= 0, 'Invalid content index');
+    const parts = summary ? (item.summary ??= []) : (item.content ??= []);
+    const key = `${item.id}/${summary ? 'summary' : 'content'}/${index}`;
+    check(!this.closedParts.has(key), 'Update after content part completion');
+    if (event.type === 'response.content_part.added' || event.type === 'response.reasoning_summary_part.added') {
+      check(parts[index] === undefined, 'Duplicate content part');
+      parts[index] = structuredClone(event.part) as Part;
+      return;
+    }
+    const part = parts[index];
+    check(part, 'Delta before content part');
+    if (event.type === 'response.content_part.done' || event.type === 'response.reasoning_summary_part.done') {
+      check(canonical(part) === canonical(event.part), 'Final content part disagrees with deltas');
+      this.closedParts.add(key);
+      return;
+    }
+    if (event.type === 'response.output_text.annotation.added') {
+      (part.annotations ??= []).push(structuredClone(event.annotation));
+      return;
+    }
+    const field = event.type.startsWith('response.refusal.') ? 'refusal' : 'text';
+    const textKey = `${key}/${field}`;
+    if ('delta' in event) {
+      check(!this.closedParts.has(textKey), 'Text delta after text.done');
+      part[field] = (part[field] ?? '') + event.delta;
+    } else {
+      const final = 'text' in event ? event.text : 'refusal' in event ? event.refusal : undefined;
+      check(final !== undefined && part[field] === final, 'Final text disagrees with deltas');
+      check(!this.closedParts.has(textKey), 'Duplicate text.done');
+      this.closedParts.add(textKey);
+    }
+  }
+
+  snapshot(): Response | null {
+    if (!this.response) return null;
+    if (this.terminal) return structuredClone(this.response);
+    return { ...structuredClone(this.response), output: [...this.items.entries()].sort(([a], [b]) => a - b).map(([, item]) => structuredClone(item)) };
+  }
+
+  finish(): Response {
+    check(this.terminal, 'Transport ended before a terminal response');
+    return this.snapshot()!;
+  }
+}

package/src/protocol/open-responses/tokens.ts

@@ -0,0 +1,31 @@
+import { itemText, type ContextRecord } from './context.ts';
+
+/** Approximate context occupancy shared by runtime and console; excludes native wire overhead. */
+export function estimateTokens(text: string): number {
+  let cjk = 0;
+  let other = 0;
+  for (const ch of text) {
+    const code = ch.codePointAt(0)!;
+    if (
+      (code >= 0x4e00 && code <= 0x9fff) ||
+      (code >= 0x3000 && code <= 0x30ff) ||
+      (code >= 0xff00 && code <= 0xffef)
+    )
+      cjk++;
+    else other++;
+  }
+  return Math.ceil(cjk * 0.6 + other * 0.3);
+}
+
+export function estimateMessagesTokens(messages: readonly ContextRecord[]): number {
+  return messages.reduce(
+    (total, { item }) =>
+      total +
+      8 +
+      estimateTokens(item.type === 'function_call' ? item.name + item.arguments : itemText(item)) +
+      (item.type === 'reasoning' && item.encrypted_content
+        ? estimateTokens(item.encrypted_content)
+        : 0),
+    0,
+  );
+}

package/src/providers/README.md

@@ -0,0 +1,86 @@
+<!-- Owner: src/providers/base.ts, src/providers/registry.ts, src/providers/console/settings.ts, src/providers/console/config.ts, src/providers/openai-responses-compat/config.ts -->
+
+# src/providers
+
+`ProviderModule` 实现一种模型通信协议,`ProviderInstance` 对应一个端点,
+`ProviderHost` 提供实例所需的配置、密钥、资源与日志接口。Core 通过 `ProviderRegistry.bind(name)`
+获取带报价与来源信息的客户端,Persona 通过 Core 调用模型。
+
+## 文件
+
+| 文件 | 管什么 |
+|---|---|
+| `base.ts` | 三个接口与 `BaseProvider`(抽象 `respond`) |
+| `registry.ts` | 目录扫描发现内建模块、`registerProviderModules()` 收扩展、实例缓存与 `bind()` |
+| `configuration.ts` | `validateSpec` / `validateEntry`:外部配置校验 |
+| `pricebook.ts` | 价目定义、快照、报价合并 |
+| `console/` | provider 页的服务端:`ProviderSettings`(落盘、密钥、探活) |
+| `openai-responses-compat/` | 内建模块:Responses 协议客户端与模型目录 |
+| `llamacpp/` | 内建模块:llama-server 的 Chat 客户端、router 目录、官方 release 的下载安装与进程托管 |
+| `transport/` | HTTP/SSE 引擎、Chat 与 Responses 请求转换、事件装配、计量、错误 |
+
+## ProviderModule
+
+`id` 必须等于目录名(扩展包里则是包声明的 id)。必填:`title`、`reasoningTiers`(空表 = 开放,
+effort 收任意非空串)、`serviceTiers`、`create(name, entry, host)`。可选:`defaultBaseUrl` 与
+`baseUrlSuggestions`、`effortSuggestions`、`temperatureNote`、`localize()`、`normalize()`、
+`validateEntry()`、`validateModel()`、`accepts()`(多模态判定)、`config()` 与 `console()`
+(附加配置组与面板)、`prices()`、`estimateTokens()`、`contextOverflow()`。
+
+地址、密钥变量名与图像开关由 `console/config.ts` 声明为 ConfigGroup。模块自己的
+配置通过 `config()` 声明。模块可在 `instance` 插槽中渲染这些 schema,
+通过 `ctx.setConfig` 保存;`console().config` 显式为空时省略独立配置页签,
+配置组仍参与服务端校验。运行时启停和模型操作由面板 invoke 提供。
+
+`create()` 返回 `ProviderInstance`:`client`(实现 `respond`)、`listModels?`、`control?`、
+`compatibilityKey?`、`start?` / `stop?`、`contextWindow?(model)`。
+
+`ProviderHost` 给实例:`stateDir`(`<部署根>/providers/<端点名>/`,归实例独占)、`repoRoot`、
+`resource()`、`currentEntry()`、`secret(name)`(进程环境优先,否则读 `stateDir/.env` 一次)、
+`readBlob()`、`keepThinking()`、`log`。
+
+## 注册与解析
+
+内建模块由 `providers/<module>/index.ts` 的默认导出自动发现。扩展模块由启动器在 `createBot`
+之前通过 `registerProviderModules()` 注册,id 重复时抛错。
+
+`ProviderRegistry.resolve(name)`:按 `entry.kind` 找模块,`normalize`,以去掉 `pricing` 与
+`spec` 的条目 JSON 为缓存键(改模型或价格不重建实例),填 `stateDir` 与 `secret`。
+`bind(name)` 在实例外包一层:注入 `quote`(报价快照)与 `origin`(实例、模块、模型、
+`compatibilityDomain` = sha256(kind + baseUrl + `compatibilityKey()`))。Responses 历史推理仅在实例、
+模块、兼容域与模型均匹配时回传。`invalidate()` 清除缓存;写入 `.env` 后必须调用,每个实例仅缓存一次文件内容。
+
+## 配置形状
+
+`LLMProviderEntry`:`kind`、`baseUrl`、`secret?`、`multimodal?`、`serviceTier?`、`pricing?`、
+`options?`、`spec?: ModelSpec`。`ModelSpec`:`model`、`thinking`、`reasoningEffort?`、
+`temperature?`、`maxTokens?`、`contextWindow?`。`providerSchemaVersion` 现在是 3。
+
+Core 侧:`activeProviderEntry()` / `activeSpec()` 每次现读;`contextWindowOf()` 取上游探到值与
+手填 `contextWindow` 的较小者;`contextFacts()` 优先用模块的 `estimateTokens` /
+`contextOverflow`,没有则回落到 Core 的字符比估算。
+
+## transport
+
+`response-http.ts` 处理 HTTP/SSE:一次生成可包含多次请求尝试,重试间隔为 `[1s, 4s, 10s]`;超时
+四档(流式首包 300s、非流式 120s、帧空闲 120s、内容空闲 300s);只对状态 0 / 429 / 5xx 重试,
+401 / 403 先 `transport.refresh()` 一次;已提交不可逆增量后不再重试;输出字符超过
+`max_output_tokens × 12` 时终止请求并报告超限;终态只接受 `completed` / `incomplete`,`failed` 抛
+`LLMError`;每次请求尝试记录 `meters` 与 `charges`。
+
+`responses-input.ts` 是原生 Responses 的无状态重放(system / developer 上提为
+`instructions`);`chat.ts` + `native-input.ts` / `history.ts` 转换 Chat Completions 请求(历史
+思维链不回传);`response-assembly.ts` 把两种流归一成 Open Responses 的 Item 流,
+`finish_reason` 的 `length` / `content_filter` 落成 `incomplete_details.reason`;
+`response-meters.ts` 把两种 usage 归一成 `TokenMeters`,缺项保持 null。
+
+线协议类型在 `src/protocol/open-responses/`(规范 2026-04-24 生成),`ResponseAccumulator`
+逐事件强校验:序号递增、终态自洽、已关闭的 Item 不得再变。
+
+## pricebook
+
+`PriceDefinition`:`models`、`currency`、`basis`(`marginal` | `equivalent`)、`rules`、
+`inputBands`、`serviceTiers`、`source`。`quotePrices()` 在同一 basis 下让实例的 `pricing` 覆盖
+模块默认,快照带 sha256 id 与 `capturedAt`。计量键:`input` / `output` / `total` /
+`cachedInput` / `uncachedInput` / `reasoning` 与 `detail:*`,单价按每百万 token。实际扣费在
+`src/core/generation.ts` 的 `priceUsage()`,缺计量记 `amount: null`。

package/src/providers/base.ts

@@ -0,0 +1,111 @@
+import type {
+  LLMProviderEntry,
+  Logger,
+  ReasoningTier,
+  ServiceTier,
+  ModelSpec,
+  ConfigGroup,
+} from '../core/types.ts';
+import type { ConsolePageContribution } from '../web/shared/console-protocol.ts';
+import type { Language } from '../core/language.ts';
+import type { ProviderConsoleHost } from './console/types.ts';
+import type { PriceDefinition, QuoteTime } from './pricebook.ts';
+import type { Request } from '../protocol/open-responses/index.ts';
+import type { ContextRecord } from '../protocol/open-responses/context.ts';
+import type { GenerateOptions, Generation, GenerationError, ResponseClient } from '../core/generation.ts';
+
+/** Providers expose standard Responses and own their native transport semantics. */
+export abstract class BaseProvider implements ResponseClient {
+  abstract respond(request: Request, options?: GenerateOptions): Promise<Generation>;
+}
+
+export interface ProviderHost {
+  /**
+   * 端点数据目录 <部署根>/providers/<端点名>/，内部结构由 provider 管理。
+   * 不同端点使用不同目录；同一部署根下共享该端点的部署共用目录。
+   */
+  stateDir: string;
+  repoRoot?: string;
+  resource?<T>(key: string, create: () => T): T;
+  currentEntry?(): LLMProviderEntry;
+  /** 按名字取密钥:进程环境 > 这个端点的 `.env`。 */
+  secret(name: string): string;
+  /** 按句柄取回附件字节(渲染层把附件升格成内容分片时用);读不到 → null */
+  readBlob(handle: string): Buffer | null;
+  keepThinking(): boolean;
+  log: Logger;
+}
+
+/** 传给 ProviderRegistry 的宿主；registry 按端点补充 stateDir 和对应目录的 secret 读取器。 */
+export type ProviderHostBase = Omit<ProviderHost, 'stateDir' | 'secret' | 'currentEntry' | 'resource'> & {
+  /** 同一部署根下共享的端点目录。 */
+  stateRoot: string;
+};
+
+export interface ProviderInstance {
+  client: BaseProvider;
+  /** Model ids the endpoint advertises (`GET /models`), with the context window when the catalog states one. */
+  listModels?(): Promise<Array<{ id: string; contextWindow?: number }>>;
+  /** Module-owned control object; interpreted by that module's console contribution. */
+  control?: unknown;
+  compatibilityKey?(): unknown;
+  start?(): Promise<unknown>;
+  stop?(): Promise<unknown>;
+  /**
+   * Context window the upstream reports for this model, in tokens. How it is detected
+   * belongs to the module (a model catalog, a server properties endpoint, a launch
+   * parameter); `undefined` until known. The core takes the minimum of this and the
+   * profile's hand-filled `contextWindow`.
+   */
+  contextWindow?(model: string): number | undefined;
+}
+
+/** 端点是否满足本地配置条件；不探测远端可达性或生成结果。 */
+export interface ProviderAvailability {
+  ready: boolean;
+  /** 不可用的原因,控制台语言;可用时不带。 */
+  reason?: string;
+}
+
+export interface ProviderModule {
+  id: string;
+  title: string;
+  defaultBaseUrl?: string;
+  /** Candidate endpoint URLs offered on the URL field. Candidates only: any URL is accepted. */
+  baseUrlSuggestions?: readonly string[];
+  /** Empty = open: `reasoningEffort` accepts any non-empty string; `effortSuggestions` supplies the candidates. */
+  reasoningTiers: readonly ReasoningTier[];
+  effortSuggestions?: readonly string[];
+  serviceTiers: readonly ServiceTier[];
+  temperatureNote?: string;
+  /**
+   * Console copies of the tier tables and temperature note in the console language.
+   * Absent (or a field left out) = the tables above are shown as written.
+   */
+  localize?(language: Language): {
+    reasoningTiers?: readonly ReasoningTier[];
+    serviceTiers?: readonly ServiceTier[];
+    temperatureNote?: string;
+  };
+  /**
+   * 这个端点还缺什么本地条件。框架先查通用条件——模型、密钥——都齐了才问模块;
+   * 除此之外没有条件的模块不实现它。
+   */
+  availability?(name: string, entry: LLMProviderEntry, language: Language): ProviderAvailability;
+  normalize?(entry: LLMProviderEntry): LLMProviderEntry;
+  /** `language` is the console language for the thrown message; validation itself is fixed. */
+  validateEntry?(entry: LLMProviderEntry, language: Language): void;
+  validateModel?(entry: LLMProviderEntry, spec: ModelSpec): void;
+  accepts?(entry: LLMProviderEntry, spec: ModelSpec, mime: string): boolean;
+  config?(name: string, entry: LLMProviderEntry, language: Language): ConfigGroup[];
+  console?(host: ProviderConsoleHost): Partial<ConsolePageContribution>;
+  prices?(entry: LLMProviderEntry, request: Request, at: QuoteTime): readonly PriceDefinition[];
+  /**
+   * Estimate tokens for records not yet covered by upstream usage.
+   * Absent: Core uses its character-ratio estimate.
+   */
+  estimateTokens?(records: readonly ContextRecord[], spec: ModelSpec): number;
+  /** The upstream rejected a request because its input exceeded the model's context. */
+  contextOverflow?(error: GenerationError): boolean;
+  create(name: string, entry: LLMProviderEntry, host: ProviderHost): ProviderInstance;
+}

package/src/providers/configuration.ts

@@ -0,0 +1,97 @@
+import type { LLMProviderEntry, ModelSpec } from '../core/types.ts';
+import type { Language } from '../core/language.ts';
+import type { ProviderAvailability, ProviderModule } from './base.ts';
+import { validatePrices } from './pricebook.ts';
+import { text } from './strings.ts';
+
+/** `language` only picks the wording of the thrown message; the console passes its own. */
+export function validateSpec(
+  module: ProviderModule,
+  entry: LLMProviderEntry,
+  value: unknown,
+  language: Language = 'zh',
+): ModelSpec {
+  const S = text(language);
+  if (!value || typeof value !== 'object' || Array.isArray(value))
+    throw new Error(S.profileObject);
+  const spec = value as ModelSpec;
+  if (typeof spec.model !== 'string' || !spec.model.trim()) throw new Error(S.modelRequired);
+  if (typeof spec.thinking !== 'boolean') throw new Error(S.thinkingBoolean);
+  if (module.reasoningTiers.length) {
+    if (
+      !module.reasoningTiers.some(
+        (tier) => tier.thinking === spec.thinking && tier.effort === spec.reasoningEffort,
+      )
+    )
+      throw new Error(S.tierUnsupported(module.title));
+  } else if (spec.reasoningEffort !== undefined) {
+    if (typeof spec.reasoningEffort !== 'string' || !spec.reasoningEffort.trim())
+      throw new Error(S.effortString);
+    if (!spec.thinking) throw new Error(S.effortWithoutThinking);
+  }
+  if (
+    spec.temperature !== undefined &&
+    (!Number.isFinite(spec.temperature) || spec.temperature < 0 || spec.temperature > 2)
+  )
+    throw new Error(S.temperatureRange);
+  for (const field of ['maxTokens', 'contextWindow'] as const) {
+    if (spec[field] !== undefined && (!Number.isInteger(spec[field]) || spec[field]! <= 0))
+      throw new Error(S.positiveInteger(field));
+  }
+  module.validateModel?.(entry, spec);
+  return structuredClone({
+    ...spec,
+    model: spec.model.trim(),
+    ...(spec.reasoningEffort !== undefined ? { reasoningEffort: spec.reasoningEffort.trim() } : {}),
+  });
+}
+
+/**
+ * 返回第一项不满足的本地条件；通用条件满足后才询问模块。
+ */
+export function endpointAvailability(
+  module: ProviderModule,
+  name: string,
+  entry: LLMProviderEntry,
+  secretConfigured: boolean,
+  language: Language = 'zh',
+): ProviderAvailability {
+  const S = text(language);
+  if (!entry.spec?.model) return { ready: false, reason: S.noModel };
+  if (entry.secret && !secretConfigured) return { ready: false, reason: S.noSecret(entry.secret) };
+  return module.availability?.(name, entry, language) ?? { ready: true };
+}
+
+export function validateEntry(
+  module: ProviderModule,
+  value: LLMProviderEntry,
+  language: Language = 'zh',
+): LLMProviderEntry {
+  const S = text(language);
+  if (
+    value.options !== undefined &&
+    (!value.options || typeof value.options !== 'object' || Array.isArray(value.options))
+  )
+    throw new Error(S.optionsObject);
+  const entry = module.normalize?.(structuredClone(value)) ?? structuredClone(value);
+  if (entry.kind !== module.id) throw new Error(S.kindChange);
+  const url = new URL(entry.baseUrl);
+  if (!['http:', 'https:'].includes(url.protocol) || url.username || url.password)
+    throw new Error(S.baseUrlFormat);
+  if (
+    entry.secret !== undefined &&
+    entry.secret !== '' &&
+    !/^[A-Za-z_][A-Za-z0-9_]*$/.test(entry.secret)
+  )
+    throw new Error(S.secretName);
+  if (entry.multimodal !== undefined && typeof entry.multimodal !== 'boolean')
+    throw new Error(S.multimodalBoolean);
+  if (entry.serviceTier !== undefined && typeof entry.serviceTier !== 'string')
+    throw new Error(S.serviceTierString);
+  if (entry.serviceTier && !module.serviceTiers.some((tier) => tier.id === entry.serviceTier))
+    throw new Error(S.serviceTierUnsupported(module.title, entry.serviceTier));
+  if (entry.pricing !== undefined) entry.pricing = validatePrices(entry.pricing, language);
+  if (entry.spec !== undefined) entry.spec = validateSpec(module, entry, entry.spec, language);
+  module.validateEntry?.(entry, language);
+  return entry;
+}

package/src/providers/console/config.ts

@@ -0,0 +1,21 @@
+import type { ConfigGroup } from '../../core/config-schema.ts';
+import type { LLMProviderEntry } from '../../core/types.ts';
+import type { Language } from '../../core/language.ts';
+import { text } from './strings.ts';
+
+export function connectionGroup(name: string, entry: LLMProviderEntry, language: Language): ConfigGroup {
+  const S = text(language);
+  const prefix = `providers.${name}.`;
+  return {
+    id: `llm.${entry.kind}.${name}.connection`,
+    owner: `provider:${entry.kind}`,
+    schema: {
+      type: 'object', title: name, description: S.connectionDescription,
+      properties: {
+        [`${prefix}baseUrl`]: { type: 'string', title: S.baseUrl, 'x-hot': true },
+        [`${prefix}secret`]: { type: 'string', title: S.secret, description: S.secretDescription, 'x-hot': true },
+        [`${prefix}multimodal`]: { type: 'boolean', title: S.multimodal, 'x-hot': true },
+      },
+    },
+  };
+}