cortico 0.1.1 → 0.1.2

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/options.ts

@@ -42,6 +42,8 @@ export function normalizeLlamaCpp(entry: LLMProviderEntry): LLMProviderEntry {
   if (options.runtime && typeof options.runtime === 'object') {
     const runtime = options.runtime as Partial<RuntimeOptions>;
     options.runtime = { ...runtime, release: runtime.release ?? PINNED_RELEASE, backend: runtime.backend ?? defaultBackend() };
+    if (typeof options.runtime.release === 'string') options.runtime.release = options.runtime.release.trim();
+    if (typeof options.runtime.runtimeDir === 'string') options.runtime.runtimeDir = options.runtime.runtimeDir.trim();
     if (options.runtime.runtimeDir === '') delete options.runtime.runtimeDir;
     options.launch = { ...LAUNCH_DEFAULTS, ...(options.launch ?? {}) };
   }

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

@@ -0,0 +1,33 @@
+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[] {
+  const S = text(language);
+  return [{
+    id: `llm.${entry.kind}.${name}.protocol`,
+    owner: `provider:${entry.kind}`,
+    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;

package/src/providers/openai-responses-compat/console/reasoning-panel.ts

@@ -0,0 +1,84 @@
+/**
+ * Reasoning section of one endpoint: the replay form, written on change, and the probe that
+ * determines it. The endpoint comes from `ctx.scope.instance`.
+ */
+import type { ConsolePanel, ConsolePanelContext } from '../../../web/shared/client-panel.ts';
+import { configField } from '../../../web/client/features/config/view.ts';
+import type { DetectResult, ProbeOutcome, ReasoningPanelState } from './server.ts';
+import { panel } from '../strings.ts';
+
+export const reasoningPanel: ConsolePanel = {
+  mount: async (ctx: ConsolePanelContext) => {
+    const { ui, root } = ctx;
+    const S = ctx.language === 'en' ? panel.en : panel.zh;
+    const name = ctx.scope.instance;
+    const path = `providers.${name}.options.reasoningReplay`;
+    const textPath = `providers.${name}.options.syntheticReasoningText`;
+    const labels: Record<string, string> = { encrypted: S.encrypted, plaintext: S.plaintext };
+    const card = ui.sheet({ title: S.title });
+    const message = ui.msgline();
+    root.append(card.el, message);
+
+    const outcome = (probe: ProbeOutcome | undefined): string =>
+      !probe ? S.skipped : probe.ok ? S.accepted : S.rejected(probe.status, probe.error);
+    const describe = (result: DetectResult): string =>
+      `${S.outcome(outcome(result.bare), outcome(result.withReasoning))}。${result.verdict ? S.applied(labels[result.verdict]) : S.undetermined}`;
+
+    async function save(groupId: string, key: string, value: string): Promise<void> {
+      try {
+        await ctx.setConfig(groupId, { [key]: value });
+        message.textContent = S.saved;
+      } catch (error) {
+        message.textContent = String(error);
+      }
+    }
+
+    async function detect(button: HTMLButtonElement): Promise<void> {
+      const release = ui.disable(button);
+      message.textContent = S.detecting;
+      try {
+        message.textContent = describe(await ctx.invoke<DetectResult>('detect', [{ name }]));
+      } catch (error) {
+        message.textContent = String(error);
+      } finally {
+        release.dispose();
+      }
+      await load();
+    }
+
+    async function load(): Promise<void> {
+      let state: ReasoningPanelState;
+      try {
+        state = await ctx.invoke<ReasoningPanelState>('state', [{ name }]);
+      } catch (error) {
+        message.textContent = String(error);
+        return;
+      }
+      if (ctx.signal.aborted) return;
+      const { group, values } = state.config[0];
+      const property = group.schema.properties[path];
+      const current = values[path];
+      const select = ui.select({
+        value: typeof current === 'string' && current ? current : 'encrypted',
+        options: Object.entries(labels).map(([value, label]) => ({ value, label })),
+        onChange: (value) => void save(group.id, path, value),
+      });
+      select.setAttribute('aria-label', property.title);
+      const button = ui.button(S.detect, { onClick: () => void detect(button) });
+      const row = ui.rowbar();
+      row.append(select, button);
+      card.body.replaceChildren(ui.field(property.title, row));
+      if (property.description) card.body.append(ui.msgline(property.description));
+
+      const textProperty = group.schema.properties[textPath];
+      const text = configField(ui, textProperty, values[textPath], () => {
+        if (text.read) void save(group.id, textPath, String(text.read()).trim());
+      }, ctx.signal);
+      text.node.setAttribute('aria-label', textProperty.title);
+      card.body.append(ui.field(textProperty.title, text.node));
+      if (textProperty.description) card.body.append(ui.msgline(textProperty.description));
+    }
+
+    await load();
+  },
+};

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

@@ -0,0 +1,127 @@
+/**
+ * Reasoning section of the endpoint page: the replay form and its probe. The probe sends the
+ * shape production sends after an event delivery, a function call the model never made followed by
+ * its output, once without reasoning and once with plaintext reasoning, and stores the form the
+ * endpoint accepts.
+ */
+import type { ConsolePageContribution } from '../../../web/shared/console-protocol.ts';
+import { PROBE_MAX_OUTPUT_TOKENS, type ProviderConsoleHost } from '../../console/types.ts';
+import { getByPath, type ConfigGroup, type ConfigValues } from '../../../core/config-schema.ts';
+import type { LLMProviderEntry, ModelSpec } from '../../../core/types.ts';
+import { GenerationError, type Generation, type ResponseClient } from '../../../core/generation.ts';
+import { functionCall, functionResult, message } from '../../../protocol/open-responses/context.ts';
+import { responseRequest } from '../../../protocol/open-responses/context-helpers.ts';
+import type { ReasoningReplay } from '../../transport/responses-input.ts';
+import { protocolConfig } from '../config.ts';
+import type { CompatControl } from '../index.ts';
+import { text } from '../strings.ts';
+
+/** The function the probe's synthetic call names; the endpoint sees a call the model never made. */
+const PROBE_TOOL = 'probe_event_frame';
+
+export type ProbeOutcome =
+  | { ok: true; status: number | null; reasoning: 'encrypted' | 'plaintext' | 'none' }
+  | { ok: false; status: number | null; error: string };
+
+export interface DetectResult {
+  /** The form written to the entry; null leaves the entry unchanged. */
+  verdict: ReasoningReplay | null;
+  bare: ProbeOutcome;
+  /** Absent when the bare probe failed for a reason other than a rejected request. */
+  withReasoning?: ProbeOutcome;
+}
+
+export interface ReasoningPanelState {
+  name: string;
+  config: Array<{ group: ConfigGroup; values: ConfigValues }>;
+}
+
+/**
+ * Both accepted: the form the endpoint returned, with a reasoning-free response counted as
+ * encrypted since nothing is replayed either way. One rejected with 400: the other form.
+ * Anything else is undetermined.
+ */
+export function replayVerdict(bare: ProbeOutcome, withReasoning: ProbeOutcome): ReasoningReplay | null {
+  if (bare.ok && withReasoning.ok) return bare.reasoning === 'plaintext' ? 'plaintext' : 'encrypted';
+  if (withReasoning.ok && bare.status === 400) return 'plaintext';
+  if (bare.ok && withReasoning.status === 400) return 'encrypted';
+  return null;
+}
+
+function probeRequest(spec: ModelSpec) {
+  const context = [
+    message('user', 'Reply with one word.'),
+    functionCall('probe_1', PROBE_TOOL, '{}'),
+    functionResult('probe_1', 'delivered'),
+  ];
+  const tools = [{ name: PROBE_TOOL, description: 'Delivers external events.', parameters: { type: 'object', properties: {} } }];
+  return {
+    ...responseRequest(spec, context, tools),
+    max_output_tokens: Math.min(spec.maxTokens ?? PROBE_MAX_OUTPUT_TOKENS, PROBE_MAX_OUTPUT_TOKENS),
+  };
+}
+
+function reasoningForm(generation: Generation): 'encrypted' | 'plaintext' | 'none' {
+  const items = generation.response.output.filter((item) => item.type === 'reasoning');
+  if (!items.length) return 'none';
+  return items.some((item) => item.encrypted_content) ? 'encrypted' : 'plaintext';
+}
+
+async function probe(client: ResponseClient, spec: ModelSpec): Promise<ProbeOutcome> {
+  try {
+    const generation = await client.respond(probeRequest(spec), { diagnostic: true, nativeSpec: spec, role: 'probe' });
+    return { ok: true, status: generation.attempts.at(-1)?.status ?? null, reasoning: reasoningForm(generation) };
+  } catch (error) {
+    if (error instanceof GenerationError) return { ok: false, status: error.status, error: error.body || error.message };
+    return { ok: false, status: null, error: error instanceof Error ? error.message : String(error) };
+  }
+}
+
+export function compatConsole(host: ProviderConsoleHost): Partial<ConsolePageContribution> {
+  const S = text(host.language);
+  const body = (args: unknown[]): string => {
+    const [raw] = args;
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw)) throw new Error(S.bodyRequired);
+    const name = (raw as Record<string, unknown>).name;
+    if (typeof name !== 'string') throw new Error(S.instanceNameRequired);
+    return name;
+  };
+  const entryOf = (name: string): LLMProviderEntry => {
+    const found = host.entries().find((entry) => entry.name === name);
+    if (!found) throw new Error(S.instanceNameRequired);
+    return found.entry;
+  };
+  const detect = async (name: string): Promise<DetectResult> => {
+    const entry = entryOf(name);
+    if (!entry.spec) throw new Error(S.modelRequired);
+    if (!entry.spec.thinking) throw new Error(S.thinkingOff);
+    const control = host.instance(name).control as CompatControl;
+    const bare = await probe(control.probeClient('encrypted'), entry.spec);
+    if (!bare.ok && bare.status !== 400) return { verdict: null, bare };
+    const withReasoning = await probe(control.probeClient('plaintext'), entry.spec);
+    const verdict = replayVerdict(bare, withReasoning);
+    if (verdict) host.save(name, { ...entry, options: { ...entry.options, reasoningReplay: verdict } });
+    return { verdict, bare, withReasoning };
+  };
+  return {
+    config: [],
+    panels: [{ id: 'reasoning', title: S.reasoningPanel, description: S.reasoningPanelDescription, slot: 'instance' }],
+    invoke: async (panel, method, args) => {
+      if (panel !== 'reasoning') throw new Error(S.unknownPanel);
+      const name = body(args);
+      if (method === 'state') {
+        const entry = entryOf(name);
+        const prefix = `providers.${name}.`;
+        const config = protocolConfig(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, config } satisfies ReasoningPanelState;
+      }
+      if (method === 'detect') return detect(name);
+      throw new Error(S.unknownMethod);
+    },
+  };
+}

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

@@ -1,8 +1,12 @@
 import type { ProviderModule } from '../base.ts';
 import type { LLMProviderEntry } from '../../core/types.ts';
+import type { ResponseClient } from '../../core/generation.ts';
 import { isContextOverflow } from '../transport/errors.ts';
-import { ModelCatalog, ResponsesProvider } from './native.ts';
+import { REASONING_REPLAYS, type ReasoningReplay } from '../transport/responses-input.ts';
+import { ModelCatalog, ResponsesProvider, type ResponsesProviderOptions } from './native.ts';
 import { text } from './strings.ts';
+import { protocolConfig } from './config.ts';
+import { compatConsole } from './console/server.ts';
 
 /** Suggested base URLs for the console field; operators may enter other URLs. */
 const BASE_URLS: readonly string[] = [
@@ -19,15 +23,25 @@ export interface CompatOptions {
   endpointPath?: string;
   extraHeaders?: Record<string, string>;
   extraBody?: Record<string, unknown>;
+  /** Default `encrypted`. */
+  reasoningReplay?: ReasoningReplay;
+  /** Plaintext replay only; defaults to `SYNTHETIC_REASONING_TEXT`. */
+  syntheticReasoningText?: string;
 }
 export function compatOptions(entry: LLMProviderEntry): CompatOptions {
   return (entry.options ?? {}) as CompatOptions;
 }
 
+/** Module-owned control object, used by the endpoint page's reasoning section. */
+export interface CompatControl {
+  /** A client for this endpoint with the given replay form; the stored entry is unchanged. */
+  probeClient(replay: ReasoningReplay): ResponseClient;
+}
+
 /** Empty strings and empty objects are the console's "unset"; they do not reach the wire. */
 function normalizeCompat(entry: LLMProviderEntry): LLMProviderEntry {
   const options: Record<string, unknown> = { ...entry.options };
-  if (options.endpointPath === '') delete options.endpointPath;
+  for (const key of ['endpointPath', 'reasoningReplay', 'syntheticReasoningText'] as const) if (options[key] === '') delete options[key];
   for (const key of ['extraHeaders', 'extraBody'] as const) {
     const value = options[key];
     if (value && typeof value === 'object' && !Array.isArray(value) && !Object.keys(value).length) delete options[key];
@@ -42,9 +56,13 @@ function isPlainObject(value: unknown): value is Record<string, unknown> {
 export default {
   id: 'openai-responses-compat',
   title: 'OpenAI Responses Compatible',
+  description: 'Connect to Responses-compatible model services.',
+  localize: (language) => ({ description: language === 'zh' ? '连接兼容 Responses API 的模型服务。' : 'Connect to Responses-compatible model services.' }),
   defaultBaseUrl: BASE_URLS[0],
   baseUrlSuggestions: BASE_URLS,
   normalize: normalizeCompat,
+  config: protocolConfig,
+  console: compatConsole,
   reasoningTiers: [],
   effortSuggestions: EFFORTS,
   serviceTiers: [],
@@ -57,6 +75,12 @@ export default {
       || Object.values(options.extraHeaders).some((value) => typeof value !== 'string')))
       throw new Error(S.extraHeadersObject);
     if (options.extraBody !== undefined && !isPlainObject(options.extraBody)) throw new Error(S.extraBodyObject);
+    if (options.reasoningReplay !== undefined && !REASONING_REPLAYS.includes(options.reasoningReplay))
+      throw new Error(S.reasoningReplayValue);
+    // 端点拒收空的 reasoning_text:全空白与空串一样会让明文形态整条请求 400。
+    if (options.syntheticReasoningText !== undefined
+      && (typeof options.syntheticReasoningText !== 'string' || !options.syntheticReasoningText.trim()))
+      throw new Error(S.syntheticReasoningTextValue);
   },
   contextOverflow: isContextOverflow,
   create(name, entry, host) {
@@ -67,20 +91,24 @@ export default {
       ...(apiKey ? { Authorization: `Bearer ${apiKey}` } : {}),
     });
     const catalog = new ModelCatalog(() => ({ baseUrl: entry.baseUrl, headers: headers() }));
+    const clientOptions = (reasoningReplay: ReasoningReplay | undefined): ResponsesProviderOptions => ({
+      baseUrl: entry.baseUrl,
+      apiKey,
+      endpointPath: options.endpointPath,
+      extraHeaders: options.extraHeaders,
+      extraBody: options.extraBody,
+      log: host.log,
+      media: { enabled: () => entry.multimodal === true, read: host.readBlob },
+      keepThinking: host.keepThinking,
+      reasoningReplay,
+      syntheticReasoningText: options.syntheticReasoningText,
+    });
     return {
       listModels: () => catalog.list(),
       contextWindow: (model) => catalog.contextWindow(model),
       compatibilityKey: () => [options.endpointPath ?? '/responses', name],
-      client: new ResponsesProvider({
-        baseUrl: entry.baseUrl,
-        apiKey,
-        endpointPath: options.endpointPath,
-        extraHeaders: options.extraHeaders,
-        extraBody: options.extraBody,
-        log: host.log,
-        media: { enabled: () => entry.multimodal === true, read: host.readBlob },
-        keepThinking: host.keepThinking,
-      }),
+      control: { probeClient: (replay) => new ResponsesProvider(clientOptions(replay)) } satisfies CompatControl,
+      client: new ResponsesProvider(clientOptions(options.reasoningReplay)),
     };
   },
 } satisfies ProviderModule;

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

@@ -7,7 +7,7 @@ import { createResponse, type Request } from '../../protocol/open-responses/inde
 import { standardUsage, type GenerateOptions } from '../../core/generation.ts';
 import { NativeResponseAssembly, type ResponseAssembly, type parseChatResponse } from '../transport/response-assembly.ts';
 import { responseMeters } from '../transport/response-meters.ts';
-import { responsesInput, type ResponsesInputOptions } from '../transport/responses-input.ts';
+import { responsesInput, type ReasoningReplay, type ResponsesInputOptions } from '../transport/responses-input.ts';
 
 type Item = Record<string, unknown>;
 
@@ -21,13 +21,15 @@ export interface ResponsesProviderOptions {
   extraBody?: Record<string, unknown>;
   media?: ResponsesInputOptions['media'];
   keepThinking?: () => boolean;
+  reasoningReplay?: ReasoningReplay;
+  syntheticReasoningText?: string;
   log?: Logger;
 }
 
 /**
  * Send reasoning only when an effort is supplied; otherwise leave it to the endpoint.
- * Requests set store=false and request encrypted reasoning content for local stateless replay.
- * Endpoint extraBody fields are merged last.
+ * Requests set store=false and request encrypted reasoning content for local stateless replay;
+ * how recorded reasoning is replayed follows `reasoningReplay`. Endpoint extraBody fields are merged last.
  */
 export function buildResponsesBody(
   request: Request,
@@ -61,7 +63,10 @@ export class ResponsesProvider extends OpenAIHttpClient {
   }
 
   protected override buildResponseBody(request: Request, options: GenerateOptions): Record<string, unknown> {
-    return buildResponsesBody(request, options, { media: this.opts.media, keepThinking: this.opts.keepThinking }, this.opts.extraBody);
+    return buildResponsesBody(request, options, {
+      media: this.opts.media, keepThinking: this.opts.keepThinking, reasoningReplay: this.opts.reasoningReplay,
+      syntheticReasoningText: this.opts.syntheticReasoningText,
+    }, this.opts.extraBody);
   }
 
   /** The Chat body builder is unreachable here: `buildResponseBody` is overridden whole. */

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

@@ -1,12 +1,27 @@
 import { pick, type Language } from '../../core/language.ts';
 
-/** Server side: ConfigGroup titles and validation errors. */
+/** Server side: ConfigGroup titles, panel titles and validation errors. */
 const zh = {
   endpointPath: 'Responses 端点路径',
   endpointPathDescription: '相对供应地址;默认 /responses。',
   endpointPathSlash: '端点路径必须以 / 开头',
   extraHeadersObject: '附加请求头必须是字符串到字符串的对象',
   extraBodyObject: '附加请求体字段必须是对象',
+  reasoningReplay: '思维链回传形态',
+  reasoningReplayDescription: '加密回签名块,明文回推理文字;上游接受哪种由端点决定,不确定就探测。',
+  reasoningReplayValue: '思维链回传形态只能是 encrypted 或 plaintext',
+  syntheticReasoningText: '合成推理填充',
+  syntheticReasoningTextDescription: (fallback: string) =>
+    `明文回传时,没有记录来源的工具调用前补的那一段推理,模型会读到。留空用默认「${fallback}」;端点拒收空串与全空白。`,
+  syntheticReasoningTextValue: '合成推理填充不能是空串或全空白:端点会拒收整条请求',
+  reasoningPanel: '思维链',
+  reasoningPanelDescription: '思维链回传给上游的形态。',
+  bodyRequired: '需要请求体',
+  instanceNameRequired: '需要端点名',
+  unknownPanel: '未知面板',
+  unknownMethod: '未知操作',
+  modelRequired: '先选模型',
+  thinkingOff: '这条端点关着思维链,回传形态无关',
 };
 const en: typeof zh = {
   endpointPath: 'Responses endpoint path',
@@ -14,6 +29,52 @@ const en: typeof zh = {
   endpointPathSlash: 'The endpoint path must start with /',
   extraHeadersObject: 'Extra headers must be an object of strings',
   extraBodyObject: 'Extra body fields must be an object',
+  reasoningReplay: 'Reasoning replay',
+  reasoningReplayDescription: 'Encrypted sends the signed block back, plaintext the reasoning text; which one the endpoint accepts is the endpoint\'s, probe when unsure.',
+  reasoningReplayValue: 'Reasoning replay must be encrypted or plaintext',
+  syntheticReasoningText: 'Synthetic reasoning text',
+  syntheticReasoningTextDescription: (fallback: string) =>
+    `In plaintext replay, the reasoning sent before a tool call with no recorded origin; the model reads it. Empty uses the default "${fallback}"; endpoints reject an empty or blank string.`,
+  syntheticReasoningTextValue: 'Synthetic reasoning text cannot be empty or blank: the endpoint rejects the whole request',
+  reasoningPanel: 'Reasoning',
+  reasoningPanelDescription: 'The form in which reasoning is sent back to the endpoint.',
+  bodyRequired: 'Request body required',
+  instanceNameRequired: 'Endpoint name required',
+  unknownPanel: 'Unknown panel',
+  unknownMethod: 'Unknown method',
+  modelRequired: 'Choose a model first',
+  thinkingOff: 'Reasoning is off on this endpoint; the replay form does not apply',
 };
 export type Text = typeof zh;
 export const text = (language: Language) => pick(language, { zh, en });
+
+/** Client side: the reasoning section of the endpoint page. */
+const panelZh = {
+  title: '思维链',
+  encrypted: '加密',
+  plaintext: '明文',
+  detect: '我不知道,测一下',
+  detecting: '探测中',
+  saved: '已保存',
+  accepted: '通过',
+  rejected: (status: number | null, error: string) => `被拒${status ? ` ${status}` : ''}:${error}`,
+  skipped: '未测',
+  outcome: (bare: string, withReasoning: string) => `不带思维链的合成调用:${bare};带明文思维链:${withReasoning}`,
+  applied: (label: string) => `已设为${label}`,
+  undetermined: '判断不出,设置未改',
+};
+const panelEn: typeof panelZh = {
+  title: 'Reasoning',
+  encrypted: 'Encrypted',
+  plaintext: 'Plaintext',
+  detect: 'Not sure, test it',
+  detecting: 'Testing',
+  saved: 'Saved',
+  accepted: 'accepted',
+  rejected: (status: number | null, error: string) => `rejected${status ? ` ${status}` : ''}: ${error}`,
+  skipped: 'not tested',
+  outcome: (bare: string, withReasoning: string) => `Synthetic call without reasoning: ${bare}; with plaintext reasoning: ${withReasoning}`,
+  applied: (label: string) => `Set to ${label}`,
+  undetermined: 'Undetermined; the setting is unchanged',
+};
+export const panel = { zh: panelZh, en: panelEn };

package/src/providers/registry.ts

@@ -64,6 +64,11 @@ export class ProviderRegistry {
     return module;
   }
 
+  /** Preview instances use a detached entry and never enter the live instance cache. */
+  preview(name: string, entry: LLMProviderEntry): ProviderInstance {
+    return new ProviderRegistry(() => ({ [name]: entry }), this.host, this.modules).resolve(name);
+  }
+
   resolve(name: string): ProviderInstance {
     const raw = this.entries()[name];
     if (!raw) throw new Error(`没有这个 LLM provider: ${name}`);