@aliou/pi-synthetic 0.14.0 → 0.15.0

package/README.md

@@ -54,9 +54,11 @@ Once installed, select `synthetic` as your provider and choose from available mo
 
 ### Model Hosting
 
-All models are accessed through Synthetic's API. Some models are hosted by Synthetic directly; others are proxied by Synthetic to upstream backends such as Fireworks or Together.
+All models are accessed through Synthetic's API. Some models are hosted by Synthetic directly (`provider: "synthetic"` in the model config); others are proxied by Synthetic to upstream backends such as Fireworks or Together.
 
-The code tracks this in `src/extensions/provider/models.ts` with each model's `provider` field. That field is for maintenance only and is stripped before registering models with Pi, so users always select the `synthetic` provider.
+By default, new installs show only Synthetic-hosted models. You can enable proxied models in `/synthetic:settings` under **Models > Proxied Models**. Existing configurations keep proxied models enabled to preserve prior behavior.
+
+The `provider` field in `src/extensions/provider/models.ts` is for maintenance only and is stripped before registering models with Pi, so users always select the `synthetic` provider.
 
 ### Web Search Tool
 
@@ -103,6 +105,8 @@ pi config extensions.disabled add @aliou/pi-synthetic/quota-warnings
 
 This prevents the quota-warnings extension from loading while keeping the rest of pi-synthetic active. Replace `quota-warnings` with `web-search`, `command-quotas`, `sub-bar-integration`, `usage-status`, or `provider` to disable other features.
 
+The **Proxied Models** setting is not a loadable extension feature. It is a regular setting controlled through `/synthetic:settings`.
+
 ## Adding or Updating Models
 
 Models are hardcoded in `src/extensions/provider/models.ts`. To add or update models:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aliou/pi-synthetic",
-  "version": "0.14.0",
+  "version": "0.15.0",
   "license": "MIT",
   "type": "module",
   "private": false,

package/src/config.ts

@@ -25,12 +25,7 @@ export interface SyntheticExtensionsRegisterPayload {
   feature: SyntheticFeatureId;
 }
 
-/**
- * Config schema version. Stamped on disk when the initial migration runs or
- * when the config is seeded. Uses the package version; bumping the package
- * does not retrigger migrations (we only run them when `configVersion` is
- * missing), but it records which release first created the file.
- */
+/** Config schema version. Stamped on disk when config is seeded or migrated. */
 export const SYNTHETIC_CONFIG_VERSION: string = pkg.version;
 
 export interface SyntheticConfig {
@@ -40,6 +35,7 @@ export interface SyntheticConfig {
   usageStatus?: boolean;
   quotaWarnings?: boolean;
   subBarIntegration?: boolean;
+  proxiedModels?: boolean;
 }
 
 export interface ResolvedSyntheticConfig {
@@ -49,6 +45,7 @@ export interface ResolvedSyntheticConfig {
   usageStatus: boolean;
   quotaWarnings: boolean;
   subBarIntegration: boolean;
+  proxiedModels: boolean;
 }
 
 const DEFAULT_CONFIG: ResolvedSyntheticConfig = {
@@ -58,39 +55,33 @@ const DEFAULT_CONFIG: ResolvedSyntheticConfig = {
   usageStatus: false,
   quotaWarnings: false,
   subBarIntegration: true,
+  proxiedModels: false,
 };
 
-// Module-level flag set when the v1 migration runs or when the global config
-// is seeded for the first time. Consumed once by the provider extension to
-// display a one-time notice about the new settings UI.
-let pendingMigrationNotice = false;
-
-export function hasPendingMigrationNotice(): boolean {
-  return pendingMigrationNotice;
-}
-
-export function clearPendingMigrationNotice(): void {
-  pendingMigrationNotice = false;
-}
+export const pendingMessages: string[] = [];
 
-function markMigrationNoticePending(): void {
-  pendingMigrationNotice = true;
+function needsProxiedModelsMigration(config: SyntheticConfig): boolean {
+  if (config.proxiedModels !== undefined) return false;
+  if (config.configVersion === undefined) return true;
+  return (
+    config.configVersion.localeCompare("0.13.5", undefined, {
+      numeric: true,
+    }) <= 0
+  );
 }
 
 const migrations: Migration<SyntheticConfig>[] = [
   {
-    name: "seed-defaults",
-    shouldRun: (config) => config.configVersion === undefined,
+    name: "seed-proxied-models",
+    shouldRun: needsProxiedModelsMigration,
     run: (config) => {
-      markMigrationNoticePending();
+      pendingMessages.push(
+        "This provider now differentiates hosted models from proxied models and allows disabling them. Use `/synthetic:settings` to disable them.",
+      );
       return {
+        ...config,
         configVersion: SYNTHETIC_CONFIG_VERSION,
-        webSearch: config.webSearch ?? DEFAULT_CONFIG.webSearch,
-        quotasCommand: config.quotasCommand ?? DEFAULT_CONFIG.quotasCommand,
-        usageStatus: config.usageStatus ?? DEFAULT_CONFIG.usageStatus,
-        quotaWarnings: config.quotaWarnings ?? DEFAULT_CONFIG.quotaWarnings,
-        subBarIntegration:
-          config.subBarIntegration ?? DEFAULT_CONFIG.subBarIntegration,
+        proxiedModels: true,
       };
     },
   },
@@ -106,8 +97,7 @@ export const configLoader = new ConfigLoader<
 
 /**
  * Seed the global config file on first use. When no config file exists in
- * any scope, this writes the current defaults (with configVersion) to the
- * global scope and flags the migration notice as pending.
+ * any scope, this writes the current defaults with configVersion.
  *
  * Must be called after `configLoader.load()`.
  */
@@ -115,18 +105,10 @@ export async function seedSyntheticConfigIfMissing(): Promise<void> {
   if (configLoader.hasConfig("global") || configLoader.hasConfig("local")) {
     return;
   }
-  markMigrationNoticePending();
   try {
-    await configLoader.save("global", {
-      configVersion: SYNTHETIC_CONFIG_VERSION,
-      webSearch: DEFAULT_CONFIG.webSearch,
-      quotasCommand: DEFAULT_CONFIG.quotasCommand,
-      usageStatus: DEFAULT_CONFIG.usageStatus,
-      quotaWarnings: DEFAULT_CONFIG.quotaWarnings,
-      subBarIntegration: DEFAULT_CONFIG.subBarIntegration,
-    });
+    await configLoader.save("global", DEFAULT_CONFIG);
   } catch {
-    // If the write fails, keep the notice pending so the user still sees it.
+    // Ignore seed failures. Defaults still resolve in memory.
   }
 }
 
@@ -191,10 +173,24 @@ export function registerSyntheticSettings(
       const quotaWarnings = tabConfig?.quotaWarnings ?? resolved.quotaWarnings;
       const subBarIntegration =
         tabConfig?.subBarIntegration ?? resolved.subBarIntegration;
+      const proxiedModels = tabConfig?.proxiedModels ?? resolved.proxiedModels;
 
       const sections: SettingsSection[] = [];
 
       sections.push(
+        {
+          label: "Models",
+          items: [
+            {
+              id: "proxiedModels",
+              label: "Proxied Models",
+              description:
+                "Allow models that Synthetic proxies to upstream backends such as Fireworks or Together. Disable to show only models hosted directly by Synthetic.",
+              currentValue: proxiedModels ? "enabled" : "disabled",
+              values: ["enabled", "disabled"],
+            },
+          ],
+        },
         {
           label: "Tools",
           items: [
@@ -250,12 +246,25 @@ export function registerSyntheticSettings(
       return sections;
     },
     onSettingChange: (id, newValue, config) => {
-      if (!getLoadedFeatures().has(id as SyntheticFeatureId)) {
+      const featureIds = new Set<string>([
+        "webSearch",
+        "quotasCommand",
+        "usageStatus",
+        "quotaWarnings",
+        "subBarIntegration",
+      ]);
+
+      if (
+        featureIds.has(id) &&
+        !getLoadedFeatures().has(id as SyntheticFeatureId)
+      ) {
         return null;
       }
 
       const enabled = newValue === "enabled";
       switch (id) {
+        case "proxiedModels":
+          return { ...config, proxiedModels: enabled };
         case "webSearch":
           return { ...config, webSearch: enabled };
         case "quotasCommand":

package/src/extensions/provider/index.test.ts

@@ -0,0 +1,46 @@
+import { describe, expect, it } from "vitest";
+import { buildSyntheticProviderModels } from "./index";
+import { SYNTHETIC_MODELS } from "./models";
+
+describe("buildSyntheticProviderModels", () => {
+  it("excludes proxied models when includeProxiedModels is false", () => {
+    const models = buildSyntheticProviderModels(false);
+    for (const model of models) {
+      const source = SYNTHETIC_MODELS.find((m) => m.id === model.id);
+      expect(source).toBeDefined();
+      expect(source?.provider).toBe("synthetic");
+    }
+  });
+
+  it("includes all models when includeProxiedModels is true", () => {
+    const models = buildSyntheticProviderModels(true);
+    expect(models).toHaveLength(SYNTHETIC_MODELS.length);
+  });
+
+  it("does not expose the internal provider field", () => {
+    const models = buildSyntheticProviderModels(true);
+    for (const model of models) {
+      expect(model).not.toHaveProperty("provider");
+    }
+  });
+
+  it("sets default compat fields on every model", () => {
+    const models = buildSyntheticProviderModels(true);
+    for (const model of models) {
+      expect(model.compat).toMatchObject({
+        supportsDeveloperRole: false,
+      });
+      expect(model.compat).toHaveProperty("maxTokensField");
+    }
+  });
+
+  it("preserves model-specific compat overrides", () => {
+    const models = buildSyntheticProviderModels(true);
+    const miniMax = models.find((m) => m.id === "hf:MiniMaxAI/MiniMax-M2.5");
+    expect(miniMax).toBeDefined();
+    expect(miniMax?.compat).toMatchObject({
+      supportsDeveloperRole: false,
+      maxTokensField: "max_completion_tokens",
+    });
+  });
+});

package/src/extensions/provider/index.ts

@@ -1,60 +1,40 @@
 import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
-import { visibleWidth, wrapTextWithAnsi } from "@mariozechner/pi-tui";
 import {
-  clearPendingMigrationNotice,
   configLoader,
   emitSyntheticConfigUpdated,
-  hasPendingMigrationNotice,
+  pendingMessages,
   registerSyntheticSettings,
+  SYNTHETIC_CONFIG_UPDATED_EVENT,
   SYNTHETIC_EXTENSIONS_REGISTER_EVENT,
   SYNTHETIC_EXTENSIONS_REQUEST_EVENT,
+  type SyntheticConfigUpdatedPayload,
   type SyntheticExtensionsRegisterPayload,
   type SyntheticFeatureId,
   seedSyntheticConfigIfMissing,
 } from "../../config";
 import { SYNTHETIC_MODELS } from "./models";
 
-const MIGRATION_NOTICE_MESSAGE_TYPE = "synthetic:migration-notice";
-const MIGRATION_NOTICE_TITLE = "pi-synthetic";
-const MIGRATION_NOTICE_CONTENT = [
-  "New optional features added to `pi-synthetic`:",
-  "- Usage widget",
-  "- Quotas warnings",
-  "",
-  "Enable them either with `pi config` or inside of `pi` with `/synthetic:settings`.",
-].join("\n");
-
-/** Wrap lines in a rounded Unicode frame with 1-char inner padding. */
-function wrapInRoundedBorder(
-  lines: string[],
-  width: number,
-  colorFn: (text: string) => string,
-): string[] {
-  const innerWidth = Math.max(1, width - 2);
-  const hBar = "\u2500".repeat(innerWidth);
-  const top = colorFn(`\u256D${hBar}\u256E`);
-  const bottom = colorFn(`\u2570${hBar}\u256F`);
-  const left = colorFn("\u2502");
-  const right = colorFn("\u2502");
-
-  const wrapped = lines.map((line) => {
-    const contentWidth = visibleWidth(line);
-    const fill = Math.max(0, innerWidth - contentWidth);
-    return `${left}${line}${" ".repeat(fill)}${right}`;
-  });
-
-  return [top, ...wrapped, bottom];
+export function buildSyntheticProviderModels(includeProxiedModels: boolean) {
+  return SYNTHETIC_MODELS.filter(
+    (model) => includeProxiedModels || model.provider === "synthetic",
+  ).map(({ provider: _provider, ...model }) => ({
+    ...model,
+    compat: {
+      supportsDeveloperRole: false,
+      maxTokensField: "max_tokens" as const,
+      ...model.compat,
+    },
+  }));
 }
 
-/** Highlight `backtick-wrapped` spans using the accent color. */
-function highlightInlineCode(
-  text: string,
-  colorFn: (text: string) => string,
-): string {
-  return text.replace(/`([^`]+)`/g, (_, code) => colorFn(code));
+interface RegisterSyntheticProviderOptions {
+  includeProxiedModels: boolean;
 }
 
-export function registerSyntheticProvider(pi: ExtensionAPI): void {
+export function registerSyntheticProvider(
+  pi: ExtensionAPI,
+  options: RegisterSyntheticProviderOptions,
+): void {
   pi.registerProvider("synthetic", {
     baseUrl: "https://api.synthetic.new/openai/v1",
     apiKey: "SYNTHETIC_API_KEY",
@@ -63,50 +43,22 @@ export function registerSyntheticProvider(pi: ExtensionAPI): void {
       Referer: "https://pi.dev",
       "X-Title": "npm:@aliou/pi-synthetic",
     },
-    models: SYNTHETIC_MODELS.map(({ provider: _provider, ...model }) => ({
-      ...model,
-      compat: {
-        supportsDeveloperRole: false,
-        maxTokensField: "max_tokens",
-        ...model.compat,
-      },
-    })),
+    models: buildSyntheticProviderModels(options.includeProxiedModels),
   });
 }
 
 export default async function (pi: ExtensionAPI) {
   await configLoader.load();
   await seedSyntheticConfigIfMissing();
-  registerSyntheticProvider(pi);
 
-  pi.registerMessageRenderer(
-    MIGRATION_NOTICE_MESSAGE_TYPE,
-    (message, _options, theme) => {
-      const rawContent =
-        typeof message.content === "string"
-          ? message.content
-          : MIGRATION_NOTICE_CONTENT;
-      const accent = (t: string) => theme.fg("accent", t);
-      const borderColor = accent;
-      const title = theme.bold(accent(MIGRATION_NOTICE_TITLE));
-      const body = highlightInlineCode(rawContent, accent);
+  const includeProxiedModels = configLoader.getConfig().proxiedModels;
+  registerSyntheticProvider(pi, { includeProxiedModels });
 
-      return {
-        render(width: number) {
-          // border (2) + inner padding (2)
-          const contentWidth = Math.max(1, width - 4);
-          const bodyLines = wrapTextWithAnsi(body, contentWidth);
-          const lines = [title, "", ...bodyLines];
-          const padded = lines.map((line) => ` ${line} `);
-          return wrapInRoundedBorder(padded, width, borderColor);
-        },
-        handleInput() {
-          return false;
-        },
-        invalidate() {},
-      };
-    },
-  );
+  pi.events.on(SYNTHETIC_CONFIG_UPDATED_EVENT, (data: unknown) => {
+    const includeProxiedModels = (data as SyntheticConfigUpdatedPayload).config
+      .proxiedModels;
+    registerSyntheticProvider(pi, { includeProxiedModels });
+  });
 
   const loadedFeatures = new Set<SyntheticFeatureId>();
 
@@ -119,21 +71,17 @@ export default async function (pi: ExtensionAPI) {
     getLoadedFeatures: () => loadedFeatures,
   });
 
-  pi.on("session_start", async () => {
+  pi.on("session_start", async (_event, ctx) => {
+    const messages = pendingMessages.splice(0).map((m) => `- ${m}`);
+    if (messages.length > 0) {
+      ctx.ui.notify(
+        `[synthetic] Migration messages: \n ${messages.join("\n")}`,
+        "info",
+      );
+    }
+
     loadedFeatures.clear();
     pi.events.emit(SYNTHETIC_EXTENSIONS_REQUEST_EVENT, undefined);
     emitSyntheticConfigUpdated(pi);
-
-    if (hasPendingMigrationNotice()) {
-      clearPendingMigrationNotice();
-      pi.sendMessage(
-        {
-          customType: MIGRATION_NOTICE_MESSAGE_TYPE,
-          content: MIGRATION_NOTICE_CONTENT,
-          display: true,
-        },
-        { triggerTurn: false },
-      );
-    }
   });
 }