@wuyaos/pi-model-config 0.0.0-stage → 0.1.2

package/src/types.ts

@@ -0,0 +1,150 @@
+import type { AnyModel } from "@earendil-works/pi-ai";
+
+export const MODEL_TYPES = ["chat", "classifier", "image"] as const;
+export type ManagedModelType = (typeof MODEL_TYPES)[number];
+export type ModelIdentity = `${string}\u0000${ManagedModelType}\u0000${string}`;
+
+export type AuthMode = "models-json" | "reuse-pi" | "anonymous";
+export type DiscoveryAuthMode = AuthMode | "temporary";
+export type ThinkingMetadataSource = "existing" | "remote" | "catalog" | "protocol" | "user" | "probed";
+export type ThinkingLevelMap = Partial<Record<"off" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max", string | null>>;
+export type ModelMetadataSource = "existing" | "remote" | "catalog" | "user" | "compat" | "probed";
+
+export interface ModelMetadataEntry {
+  type: ManagedModelType;
+  id: string;
+  contextSource?: ModelMetadataSource;
+  maxTokensSource?: ModelMetadataSource;
+  verifiedAt?: string;
+  probeLower?: number;
+  probeUpper?: number;
+  probeEstimated?: boolean;
+  thinkingSource?: ThinkingMetadataSource;
+}
+
+export type DiscoveryAuthHeader = "auto" | "bearer" | "x-api-key" | "api-key" | "x-goog-api-key" | "anthropic" | "none";
+
+export interface ManagedModelBase {
+  id: string;
+  name: string;
+  api: string;
+  baseUrl?: string;
+  input: ("text" | "image")[];
+  cost: { input: number; output: number; cacheRead: number; cacheWrite: number };
+  headers?: Record<string, string>;
+}
+
+export interface ManagedChatModel extends ManagedModelBase {
+  type: "chat";
+  reasoning: boolean;
+  thinkingLevelMap?: ThinkingLevelMap;
+  contextWindow: number;
+  maxTokens: number;
+}
+
+export interface ManagedClassifierModel extends ManagedModelBase {
+  type: "classifier";
+  contextWindow: number;
+}
+
+export interface ManagedImageModel extends ManagedModelBase {
+  type: "image";
+  output: ("text" | "image")[];
+}
+
+export type ManagedModel = ManagedChatModel | ManagedClassifierModel | ManagedImageModel;
+
+export interface ProviderConnectionConfig {
+  name?: string;
+  owned?: boolean;
+  enabled?: boolean;
+  discoveryUrl?: string;
+  authMode: AuthMode;
+  discoveryAuthHeader?: DiscoveryAuthHeader;
+  proxyUrl?: string;
+  chatApi?: string;
+  classifierApi?: string;
+  imageApi?: string;
+  defaultType?: ManagedModelType;
+  defaultContextWindow?: number;
+  defaultMaxTokens?: number;
+  managedChatIds?: string[];
+  models?: Array<ManagedClassifierModel | ManagedImageModel>;
+  modelMetadata?: ModelMetadataEntry[];
+}
+
+export interface ModelConfigFile {
+  $schema?: string;
+  version: 1;
+  providers: Record<string, ProviderConnectionConfig>;
+  [key: string]: unknown;
+}
+
+export interface ModelsJsonProvider {
+  name?: string;
+  baseUrl?: string;
+  apiKey?: string;
+  api?: string;
+  authHeader?: boolean;
+  headers?: Record<string, string>;
+  models?: Array<Record<string, unknown>>;
+  [key: string]: unknown;
+}
+
+export interface ModelsJsonFile {
+  $schema?: string;
+  providers: Record<string, ModelsJsonProvider>;
+  [key: string]: unknown;
+}
+
+export interface ProviderDraft {
+  id: string;
+  name: string;
+  owned: boolean;
+  enabled: boolean;
+  baseUrl?: string;
+  discoveryUrl?: string;
+  authMode: DiscoveryAuthMode;
+  authHeader: DiscoveryAuthHeader;
+  apiKeyRaw?: string;
+  temporaryKey?: string;
+  proxyUrl?: string;
+  chatApi: string;
+  classifierApi: string;
+  imageApi: string;
+  defaultType: ManagedModelType;
+}
+
+export type CandidateModel = ManagedModel & {
+  source: "managed" | "external" | "installed" | "remote";
+  mutableType: boolean;
+  /** Read-only entries are visible but cannot be toggled until an explicit supported ownership action. */
+  readOnly?: boolean;
+  readOnlyReason?: "external-config" | "runtime-catalog";
+  contextSource?: ModelMetadataSource;
+  maxTokensSource?: ModelMetadataSource;
+  thinkingSource?: ThinkingMetadataSource;
+};
+
+export interface SelectionResult {
+  action: "preview" | "fetch" | "edit" | "probe" | "probeThinking" | "back" | "language";
+  cancelled: boolean;
+  selected: ManagedModel[];
+  metadata: ModelMetadataEntry[];
+  target?: Pick<CandidateModel, "id" | "type" | "source" | "readOnlyReason">;
+}
+
+export interface ConfigSnapshot {
+  path: string;
+  exists: boolean;
+  text?: string;
+}
+
+export function identityOf(model: Pick<ManagedModel, "id" | "type"> & { provider?: string }, provider?: string): ModelIdentity {
+  const p = provider ?? model.provider ?? "";
+  return `${p}\u0000${model.type}\u0000${model.id}`;
+}
+
+export function modelTypeOf(model: AnyModel | Record<string, unknown>): ManagedModelType {
+  return model.type === "classifier" || model.type === "image" ? model.type : "chat";
+}

package/src/ui-config.ts

@@ -0,0 +1,44 @@
+import { closeSync, mkdirSync, openSync, readFileSync, renameSync, rmSync, writeFileSync, fsyncSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { normalizeUiLanguage, type UiLanguage } from "./i18n.ts";
+
+export interface ModelConfigUiPreferences {
+  version: 1;
+  language: UiLanguage;
+}
+
+export function uiPreferencesPath(agentDir: string): string {
+  return join(agentDir, "model-config-ui.json");
+}
+
+export function loadUiLanguage(agentDir: string): UiLanguage {
+  try {
+    const value: unknown = JSON.parse(readFileSync(uiPreferencesPath(agentDir), "utf8"));
+    if (typeof value === "object" && value !== null && (value as { version?: unknown }).version === 1) {
+      return normalizeUiLanguage((value as { language?: unknown }).language);
+    }
+  } catch {
+    // Missing or invalid UI preferences never block model configuration.
+  }
+  return "zh-CN";
+}
+
+/** Only call after an explicit user language selection. */
+export function saveUiLanguage(agentDir: string, language: UiLanguage): void {
+  const path = uiPreferencesPath(agentDir);
+  mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
+  const temp = `${path}.${process.pid}.${Date.now()}.tmp`;
+  let fd: number | undefined;
+  try {
+    fd = openSync(temp, "wx", 0o600);
+    const value: ModelConfigUiPreferences = { version: 1, language };
+    writeFileSync(fd, `${JSON.stringify(value, null, 2)}\n`, "utf8");
+    fsyncSync(fd);
+    closeSync(fd);
+    fd = undefined;
+    renameSync(temp, path);
+  } finally {
+    if (fd !== undefined) closeSync(fd);
+    rmSync(temp, { force: true });
+  }
+}

package/src/ui.ts

@@ -0,0 +1,179 @@
+import type { ExtensionCommandContext, Theme } from "@earendil-works/pi-coding-agent";
+import {
+  CancellableLoader,
+  CURSOR_MARKER,
+  Key,
+  decodeKittyPrintable,
+  matchesKey,
+  renderFakeCursor,
+  truncateToWidth,
+  visibleWidth,
+  type Component,
+  type Focusable,
+  type TUI,
+} from "@earendil-works/pi-tui";
+import { t, type UiLanguage } from "./i18n.ts";
+
+const PASTE_START = "\x1b[200~";
+const PASTE_END = "\x1b[201~";
+
+function stripPastedControls(value: string): string {
+  return value
+    .replace(/\x1b\][^\x07]*(?:\x07|\x1b\\)/gu, "")
+    .replace(/\x1b[P_X^][\s\S]*?\x1b\\/gu, "")
+    .replace(/\x1b(?:\]|[P_X^])[\s\S]*$/gu, "")
+    .replace(/\x1b\[[0-?]*[ -/]*[@-~]/gu, "")
+    .replace(/\x1bO./gu, "")
+    .replace(/[\u0000-\u001f\u007f-\u009f]/gu, "");
+}
+
+function trailingMarkerPrefixLength(value: string, marker: string): number {
+  const max = Math.min(value.length, marker.length - 1);
+  for (let length = max; length > 0; length--) if (marker.startsWith(value.slice(-length))) return length;
+  return 0;
+}
+
+class MaskedInput implements Component, Focusable {
+  private value = "";
+  private inputBuffer = "";
+  private isInPaste = false;
+  private pasteBuffer = "";
+  private _focused = false;
+  private finished = false;
+
+  constructor(
+    private readonly tui: TUI,
+    private readonly theme: Theme,
+    private readonly language: UiLanguage,
+    private readonly title: string,
+    private readonly done: (value: string | undefined) => void,
+  ) {}
+
+  get focused(): boolean { return this._focused; }
+  set focused(value: boolean) { this._focused = value; }
+
+  private finish(value: string | undefined): void {
+    if (this.finished) return;
+    this.finished = true;
+    this.done(value);
+  }
+
+  private append(value: string): void {
+    if (value) this.value += value;
+  }
+
+  private handleOrdinaryInput(data: string): void {
+    if (!data) return;
+    if (matchesKey(data, Key.enter)) { this.finish(this.value); return; }
+    if (matchesKey(data, Key.escape) || matchesKey(data, Key.ctrl("c"))) { this.finish(undefined); return; }
+    if (matchesKey(data, Key.backspace)) {
+      this.value = [...this.value].slice(0, -1).join("");
+      return;
+    }
+    if (matchesKey(data, Key.ctrl("u"))) {
+      this.value = "";
+      return;
+    }
+    const kittyPrintable = decodeKittyPrintable(data);
+    if (kittyPrintable !== undefined) {
+      this.append(kittyPrintable);
+      return;
+    }
+    const hasControl = [...data].some((char) => {
+      const code = char.charCodeAt(0);
+      return code < 32 || code === 0x7f || (code >= 0x80 && code <= 0x9f);
+    });
+    if (!hasControl) this.append(data);
+  }
+
+  private drainInputBuffer(): void {
+    while (this.inputBuffer) {
+      if (this.isInPaste) {
+        const end = this.inputBuffer.indexOf(PASTE_END);
+        if (end < 0) {
+          const keep = trailingMarkerPrefixLength(this.inputBuffer, PASTE_END);
+          this.pasteBuffer += this.inputBuffer.slice(0, this.inputBuffer.length - keep);
+          this.inputBuffer = this.inputBuffer.slice(this.inputBuffer.length - keep);
+          return;
+        }
+        this.pasteBuffer += this.inputBuffer.slice(0, end);
+        this.append(stripPastedControls(this.pasteBuffer));
+        this.pasteBuffer = "";
+        this.isInPaste = false;
+        this.inputBuffer = this.inputBuffer.slice(end + PASTE_END.length);
+        continue;
+      }
+
+      const start = this.inputBuffer.indexOf(PASTE_START);
+      if (start >= 0) {
+        this.handleOrdinaryInput(this.inputBuffer.slice(0, start));
+        if (this.finished) return;
+        this.inputBuffer = this.inputBuffer.slice(start + PASTE_START.length);
+        this.isInPaste = true;
+        continue;
+      }
+      const keep = trailingMarkerPrefixLength(this.inputBuffer, PASTE_START);
+      const ordinary = this.inputBuffer.slice(0, this.inputBuffer.length - keep);
+      this.inputBuffer = this.inputBuffer.slice(this.inputBuffer.length - keep);
+      this.handleOrdinaryInput(ordinary);
+      return;
+    }
+  }
+
+  handleInput(data: string): void {
+    // A standalone Esc is an actual cancel key, not a fragmented paste marker.
+    if (!this.isInPaste && !this.inputBuffer && (matchesKey(data, Key.escape) || matchesKey(data, Key.ctrl("c")))) {
+      this.finish(undefined);
+      return;
+    }
+    this.inputBuffer += data;
+    this.drainInputBuffer();
+    this.tui.requestRender();
+  }
+
+  render(width: number): string[] {
+    const safeWidth = Math.max(1, width);
+    const label = safeWidth >= 8 ? this.theme.fg("muted", t(this.language, "maskedLabel")) : "";
+    const cursor = this._focused ? `${CURSOR_MARKER}${renderFakeCursor(" ")}` : "";
+    const available = Math.max(0, safeWidth - visibleWidth(label) - 1);
+    const count = [...this.value].length;
+    const hidden = count > available;
+    const showEllipsis = hidden && available > 0;
+    const visibleCount = Math.max(0, available - (showEllipsis ? 1 : 0));
+    const mask = `${showEllipsis ? "…" : ""}${"•".repeat(Math.min(count, visibleCount))}`;
+    return [
+      truncateToWidth(this.theme.fg("accent", this.theme.bold(this.title)), safeWidth, ""),
+      truncateToWidth(`${label}${mask}${cursor}`, safeWidth, ""),
+      truncateToWidth(this.theme.fg("muted", t(this.language, "maskedHelp")), safeWidth, ""),
+    ];
+  }
+
+  invalidate(): void {}
+}
+
+/** Secret input never delegates to ordinary ctx.ui.input, so plaintext is never rendered. */
+export async function secretInput(ctx: ExtensionCommandContext, language: UiLanguage, title: string): Promise<string | undefined> {
+  return ctx.ui.custom<string | undefined>((tui, theme, _keybindings, done) => new MaskedInput(tui, theme, language, title, done));
+}
+
+export async function withCancellableLoader<T>(
+  ctx: ExtensionCommandContext,
+  message: string,
+  work: (signal: AbortSignal) => Promise<T>,
+): Promise<{ cancelled: true } | { cancelled: false; value?: T; error?: unknown }> {
+  return ctx.ui.custom((tui, theme, _keybindings, done) => {
+    const loader = new CancellableLoader(tui, (text) => theme.fg("accent", text), (text) => theme.fg("muted", text), message);
+    let settled = false;
+    const finish = (result: { cancelled: true } | { cancelled: false; value?: T; error?: unknown }) => {
+      if (settled) return;
+      settled = true;
+      done(result);
+    };
+    loader.onAbort = () => finish({ cancelled: true });
+    void work(loader.signal).then((value) => finish({ cancelled: false, value })).catch((error) => {
+      if (loader.signal.aborted) finish({ cancelled: true });
+      else finish({ cancelled: false, error });
+    });
+    return loader;
+  });
+}