cortico 0.1.0 → 0.1.2

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,9 +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[] = [
@@ -20,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];
@@ -43,11 +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: () => ({ config: [] }),
+  console: compatConsole,
   reasoningTiers: [],
   effortSuggestions: EFFORTS,
   serviceTiers: [],
@@ -60,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) {
@@ -70,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}`);

package/src/providers/transport/responses-input.ts

@@ -1,22 +1,45 @@
 /** Stateless native Responses input: the whole context is replayed on every request. */
 import type { Request } from '../../protocol/open-responses/index.ts';
-import { inputItem } from '../../protocol/open-responses/context.ts';
+import { inputItem, itemText, type ContextRecord } from '../../protocol/open-responses/context.ts';
 import type { GenerateOptions } from '../../core/generation.ts';
 import { requestContext } from './native-input.ts';
 import type { CompatMediaOptions } from './history.ts';
 
 type Item = Record<string, unknown>;
 
+/**
+ * How past reasoning re-enters the context. `encrypted`: the signed `encrypted_content` block, only
+ * when the recorded origin matches this request. `plaintext`: the reasoning text itself, for
+ * endpoints whose thinking mode requires the text of every tool-call turn back.
+ */
+export const REASONING_REPLAYS = ['encrypted', 'plaintext'] as const;
+export type ReasoningReplay = (typeof REASONING_REPLAYS)[number];
+
+/**
+ * Default `reasoning_text` sent before a function call without a recorded origin in plaintext
+ * replay. A missing field, an empty `content`, an empty string and a summary without
+ * `reasoning_text` are each rejected, so the padding is one character; it is non-whitespace in case
+ * an endpoint trims. It carries no prose by default: what these calls are is the Persona's to say.
+ * The operator replaces it per endpoint.
+ */
+export const SYNTHETIC_REASONING_TEXT = '-';
+
 export interface ResponsesInputOptions {
   media?: CompatMediaOptions;
   /** Whether past reasoning re-enters the context; the first synthetic turn is exempt. */
   keepThinking?: () => boolean;
+  /** Default `encrypted`. */
+  reasoningReplay?: ReasoningReplay;
+  /** Plaintext replay only; defaults to `SYNTHETIC_REASONING_TEXT`. Endpoints reject an empty one. */
+  syntheticReasoningText?: string;
 }
 
 /**
- * Replay reasoning only when encrypted_content exists and the recorded instance, module,
- * compatibility domain and model match this request. These are local eligibility checks.
- * Plaintext reasoning is omitted. System and developer text is joined into instructions.
+ * Encrypted replay: a reasoning item re-enters only with `encrypted_content` and when the recorded
+ * instance, module, compatibility domain and model match this request. Plaintext replay: a reasoning
+ * item re-enters as `reasoning_text`; the turn after the last user message is always replayed, earlier
+ * turns follow `keepThinking`; a function call without an origin gets a synthetic reasoning item
+ * unless one already precedes it. System and developer text is joined into instructions.
  */
 export function responsesInput(
   request: Request,
@@ -25,20 +48,37 @@ export function responsesInput(
 ): { input: Item[]; instructions: string | undefined } {
   const input: Item[] = [];
   const systems = request.instructions ? [request.instructions] : [];
-  for (const entry of requestContext(request, options)) {
+  const plaintext = opts.reasoningReplay === 'plaintext';
+  const entries = requestContext(request, options);
+  const roundStart = plaintext ? lastUserMessage(entries) : -1;
+  entries.forEach((entry, index) => {
     const item = entry.item;
     if (item.type === 'reasoning') {
-      if (!item.encrypted_content) continue;
-      if (!entry.context.head && opts.keepThinking?.() === false) continue;
+      if (plaintext) {
+        const text = itemText(item);
+        if (!text && !item.encrypted_content) return;
+        if (!entry.context.head && index < roundStart && opts.keepThinking?.() === false) return;
+        const wire = inputItem(entry) as Item;
+        if (text) wire.content = [{ type: 'reasoning_text', text }];
+        input.push(wire);
+        return;
+      }
+      if (!item.encrypted_content) return;
+      if (!entry.context.head && opts.keepThinking?.() === false) return;
       const owner = entry.context.origin;
       const current = options.origin;
       if (!owner || !current || owner.instance !== current.instance || owner.module !== current.module
-        || owner.compatibilityDomain !== current.compatibilityDomain || owner.model !== request.model) continue;
+        || owner.compatibilityDomain !== current.compatibilityDomain || owner.model !== request.model) return;
     }
     if (item.type === 'message' && (item.role === 'system' || item.role === 'developer')) {
       systems.push(typeof item.content === 'string' ? item.content : item.content.map(part => 'text' in part ? part.text : '').join(''));
-      continue;
+      return;
     }
+    if (plaintext && item.type === 'function_call' && !entry.context.origin && input.at(-1)?.type !== 'reasoning')
+      input.push({
+        type: 'reasoning', id: `rs_${item.call_id}`, summary: [],
+        content: [{ type: 'reasoning_text', text: opts.syntheticReasoningText ?? SYNTHETIC_REASONING_TEXT }],
+      });
     const wire = inputItem(entry) as Item;
     if (opts.media?.enabled() && entry.context.blobs?.length && (item.type === 'message' || item.type === 'function_call_output')) {
       const field = item.type === 'message' ? 'content' : 'output';
@@ -51,6 +91,15 @@ export function responsesInput(
       wire[field] = parts;
     }
     input.push(wire);
-  }
+  });
   return { input, instructions: systems.length ? systems.join('\n') : undefined };
 }
+
+/** Index of the last user message, -1 when there is none. */
+function lastUserMessage(entries: readonly ContextRecord[]): number {
+  for (let index = entries.length - 1; index >= 0; index--) {
+    const item = entries[index].item;
+    if (item.type === 'message' && item.role === 'user') return index;
+  }
+  return -1;
+}

package/src/web/README.md

@@ -1,4 +1,4 @@
-<!-- Owner: src/web/server.ts, src/web/shared/console-protocol.ts, src/web/shared/client-panel.ts, src/web/client/console-pages/builtins/llm-settings/panel.ts -->
+<!-- Owner: src/web/server.ts, src/web/auth.ts, src/web/shared/console-protocol.ts, src/web/shared/client-panel.ts, src/web/client/console-pages/host.ts, src/web/client/console-pages/builtins/llm-settings/panel.ts, src/web/client/console-pages/builtins/llm-settings/pricing-panel.ts, src/web/client/features/providers/index.ts, src/web/client/features/live/index.ts -->
 
 # src/web
 
@@ -43,19 +43,24 @@ manifest 的 `CONSOLE_PROTOCOL_VERSION` 不匹配时，浏览器拒绝加载。
 
 `WebApp` 默认监听 `127.0.0.1`，支持由依赖配置指定监听地址。从首选端口起最多尝试五个端口；
 端口为 0 时仅申请一次系统分配。WebSocket 使用 `noServer` 分派 `/ws/debug`、`/ws/sessions` 和面板流。
-所有请求与 upgrade 先校验 Host 头：只接受回环名或显式绑定的地址，绑到通配地址时不校验。
-写请求与 upgrade 再按 Host 校验 Origin，拒绝不匹配或无效的 Origin；缺少 Origin 时放行。
+所有请求与 upgrade 先校验 Host 头：只接受回环名、显式绑定的地址和 `allowedHosts` 里的名字，绑到通配地址时不校验。
+写请求与 upgrade 再按 Host 校验 Origin，拒绝不匹配或无效的 Origin；缺少 Origin 时放行，Origin 是
+`allowedHosts` 里的名字时放行。监听非回环地址而没有设访问密码时启动记一条 warn。
+`auth.ts` 的 `ConsoleAuth` 在设了密码时把未登录的请求挡在各路由与 body 解析之前:`/` 给登录页,其余 401,
+upgrade 断开;登录态是 HttpOnly Cookie 里的无状态签名令牌(见 [console.md](../../docs/console.md))。
 
 `/assets` 提供 `dist/web` 资源。首页在最后一个 `</body>` 前注入带 hash 的入口。
 扩展面板通过 `/assets/extensions/<包>/<版本>/<文件>` 提供，仅允许 manifest 声明的脚本与样式文件。
 
 `createBot()` 通过 `WebAppDeps` 注入事件库、session、运行控制、配置、存储、`consolePageSources` 和扩展信息。
-调试流以 `head` 提供本次 `Persona.sessionHead()` 的合成开头；它不属于持久 session。
-`providersLamp` 汇总本地端点可用性，由状态灯接口提供给浏览器。
 
 ## 浏览器
 
-`llm-settings` 从端点状态中的 ConfigGroup 渲染连接字段与声明的请求路径,使用 `ctx.setConfig` 保存。
+`features/providers` 一次编辑一条端点,改动只进浏览器暂存,保存时整条提交。模块面板挂在所选端点
+的作用域里,面板的 `setConfig` 同样进暂存;`llm-settings` 的服务接口保留,旧的 `llm:<kind>` 路由
+转到这一页。`features/providers/drafts.ts` 的暂存按部署分 scope 存进 localStorage,不含 API Key;
+这一页自己拦切换端点,并向路由登记离开保护。端点保存、删除或设为当前之后推送状态帧,终端页顶部
+的统计行显示当前端点的名称与模型,点开进该端点。
 
 `main.ts` 的 `FEATURES` 包含 `live`、`core`、`usage`、`provider`、`world`、`extensions`、`prompts`、
 `appearance`、`settings`。贡献页由 manifest 加载，保留路由段 `provider` 交由 `ConsolePageHost` 处理。