pi-fireworks-provider 1.1.0 → 1.2.0

package/README.md

@@ -15,9 +15,11 @@ _Kimi, MiniMax, GLM, DeepSeek, GPT-OSS — via Fireworks AI's Anthropic Messages
 
 ## Features
 
-- **35+ AI Models** including Kimi K2.5, MiniMax M2.5, GLM 4.5/4.7/5, DeepSeek V3.1/V3.2, DeepSeek V4 Flash, and GPT-OSS
+- **39+ AI Models** including Kimi K2.5, MiniMax M2.5, GLM 4.5/4.7/5, DeepSeek V3.1/V3.2, DeepSeek V4 Flash, and GPT-OSS
 - **Dual API support** via Fireworks AI's Anthropic Messages and OpenAI-compatible completions endpoints (per-model routing, matching pi core's Fireworks provider)
 - **Service tiers** — toggle Fireworks `priority` vs `standard` per request on supported models (with priority pricing reflected in cost tracking), via a keybinding, `/fireworks-tier`, and a footer status area
+- **Preserved thinking** — toggle Fireworks' `reasoning_history: "preserved"` so prior assistant reasoning is retained across turns (better multi-turn recall; uses more tokens), via the `/fireworks-settings` panel, with a model-select notification. Matches neuralwatt/makora's settings-only UX, adapted to Fireworks' single global `reasoning_history` knob
+- **Settings panel** — `/fireworks-settings` (TUI) to configure preserved thinking, service tier, and display preferences; persisted to `~/.pi/agent/extensions/fireworks.json`
 - **Cost Tracking** with per-model pricing for budget management
 - **Reasoning Models** support for advanced reasoning capabilities
 - **Vision Support** for image-capable models
@@ -71,8 +73,8 @@ pi
 |-------|------|---------|------------|------------|-------------|
 | DeepSeek V3.1 | Text | 164K | 164K | $0.56 | $1.68 |
 | DeepSeek V3.2 | Text | 164K | 160K | $0.56 | $1.68 |
-| DeepSeek V4 Flash | Text | 1.0M | 1.0M | $0.14 | $0.28 |
-| DeepSeek V4 Pro | Text | 1.0M | 1.0M | Free | Free |
+| DeepSeek V4 Flash | Text | 1.0M | 384K | $0.14 | $0.28 |
+| DeepSeek V4 Pro | Text | 1.0M | 384K | $1.74 | $3.48 |
 | DeepSeek V4 Pro (router) | Text | 1.0M | 1.0M | $1.74 | $3.48 |
 | Gemma 4 26B A4B IT | Text + Image | 262K | 0 | Free | Free |
 | Gemma 4 31B IT | Text + Image | 262K | 0 | Free | Free |
@@ -80,27 +82,31 @@ pi
 | GLM 4.5 Air | Text | 131K | 131K | $0.22 | $0.88 |
 | GLM 4.7 | Text | 203K | 198K | $0.60 | $2.20 |
 | GLM 5 | Text | 203K | 131K | $1.00 | $3.20 |
-| GLM 5 Fast (router) | Text | 203K | 131K | $1.00 | $3.20 |
+| GLM 5 Fast | Text | 203K | 131K | $1.00 | $3.20 |
 | GLM 5.1 | Text | 203K | 131K | $1.40 | $4.40 |
-| GLM 5.1 Fast (router) | Text | 203K | 131K | $1.40 | $4.40 |
-| GLM 5.2 | Text | 1.0M | 0 | Free | Free |
+| GLM 5.1 Fast | Text | 203K | 131K | $2.80 | $8.80 |
+| GLM 5.2 | Text | 1.0M | 131K | $1.40 | $4.40 |
+| GLM 5.2 Fast | Text | 1.0M | 131K | $2.10 | $6.60 |
 | GPT OSS 120B | Text | 131K | 33K | $0.15 | $0.60 |
-| GPT OSS 20B | Text | 131K | 33K | $0.05 | $0.20 |
+| GPT OSS 20B | Text | 131K | 33K | $0.07 | $0.30 |
 | Kimi K2 Instruct | Text | 131K | 16K | $1.00 | $3.00 |
 | Kimi K2 Thinking | Text | 262K | 256K | $0.60 | $2.50 |
 | Kimi K2.5 | Text + Image | 262K | 256K | $0.60 | $3.00 |
 | Kimi K2.5 Fast (router) | Text + Image | 262K | 256K | $0.60 | $3.00 |
 | Kimi K2.6 | Text + Image | 262K | 262K | $0.95 | $4.00 |
 | Kimi K2.6 (router) | Text + Image | 262K | 262K | $0.95 | $4.00 |
-| Kimi K2.6 Turbo (router) | Text + Image | 262K | 262K | $0.95 | $4.00 |
-| Kimi K2.7 Code | Text + Image | 262K | 0 | Free | Free |
+| Kimi K2.6 Fast | Text + Image | 262K | 262K | $2.00 | $8.00 |
+| Kimi K2.6 Turbo | Text + Image | 262K | 262K | $2.00 | $8.00 |
+| Kimi K2.7 Code | Text + Image | 262K | 262K | $0.95 | $4.00 |
+| Kimi K2.7 Code Fast | Text + Image | 262K | 262K | $1.90 | $8.00 |
 | Llama 3.3 70B Instruct | Text | 131K | 0 | Free | Free |
 | MiniMax M2.7 (router) | Text | 204K | 0 | $0.30 | $1.20 |
-| Minimax M3 | Text + Image | 512K | 0 | Free | Free |
 | MiniMax-M2.1 | Text | 197K | 200K | $0.30 | $1.20 |
 | MiniMax-M2.5 | Text | 197K | 197K | $0.30 | $1.20 |
 | MiniMax-M2.7 | Text | 197K | 197K | $0.30 | $1.20 |
+| MiniMax-M3 | Text | 512K | 512K | $0.30 | $1.20 |
 | NVIDIA Nemotron 3 Ultra NVFP4 | Text | 262K | 0 | Free | Free |
+| Qwen 3.7 Plus | Text + Image | 262K | 66K | $0.40 | $1.60 |
 | Qwen3 8B | Text | 41K | 0 | Free | Free |
 | Qwen3 VL 30B A3B Instruct | Text + Image | 262K | 0 | Free | Free |
 | Qwen3 VL 30B A3B Thinking | Text + Image | 262K | 0 | Free | Free |
@@ -140,16 +146,35 @@ The selection is persisted per session (survives `/reload` and resume). When `pr
     "default": "standard",
     "keybinding": "ctrl+shift+l",
     "display": "statusbar"
+  },
+  "preserveThinking": {
+    "default": false
   }
 }
 ```
 
-- `default` — tier used until you toggle (`standard` | `priority`).
-- `keybinding` — any [pi key format](https://github.com/earendil-works/pi-coding-agent/blob/main/docs/keybindings.md) (e.g. `ctrl+shift+l`, `ctrl+shift+k`). Requires `/reload` after changing. On macOS browser terminals (localterm), avoid `alt`/`ctrl+alt` (Option produces special chars) and `ctrl+shift+t/w/n/c/v` (browser/localterm tab + copy/paste shortcuts).
-- `display` — `statusbar` (footer status area) or `off` (hide the tier indicator).
+- `serviceTier.default` — tier used until you toggle (`standard` | `priority`).
+- `serviceTier.keybinding` — any [pi key format](https://github.com/earendil-works/pi-coding-agent/blob/main/docs/keybindings.md) (e.g. `ctrl+shift+l`, `ctrl+shift+k`). Requires `/reload` after changing. On macOS browser terminals (localterm), avoid `alt`/`ctrl+alt` (Option produces special chars) and `ctrl+shift+t/w/n/c/v` (browser/localterm tab + copy/paste shortcuts).
+- `serviceTier.display` — `statusbar` (footer status area) or `off` (hide the tier indicator).
+- `preserveThinking.default` — whether `reasoning_history: "preserved"` is injected (`true` | `false`, default `false`). Also settable via `/fireworks-settings`.
 
 > **Note:** The OpenAI completions endpoint accepts `service_tier` directly (per Fireworks' API). The Anthropic Messages endpoint passes the top-level field through as an extra. If a supported Anthropic-routed model rejects it, file an issue so we can gate injection by API.
 
+## Preserved Thinking
+
+Fireworks exposes a top-level `reasoning_history` request parameter. The only accepted value is `"preserved"`; omitting it (the default) means prior assistant reasoning is **stripped** from the model's context each turn. Setting `reasoning_history: "preserved"` makes Fireworks render prior assistant reasoning into the model's context, improving multi-turn recall at the cost of extra tokens. See [the Fireworks reasoning guide](https://docs.fireworks.ai/guides/reasoning#preserved-thinking).
+
+This works on **both** transports — the OpenAI completions endpoint (assistant `reasoning_content` field) and the Anthropic Messages endpoint (assistant `thinking` content blocks, for which Fireworks returns a `signature` so pi-ai replays them). pi-ai already replays the reasoning field/block on prior assistant turns; this extension's only job is injecting the top-level `reasoning_history: "preserved"` flag that makes Fireworks honor it.
+
+Unlike neuralwatt/makora (which use per-model vLLM `chat_template_kwargs` flags like `preserve_thinking`/`clear_thinking`), Fireworks' knob is a single global parameter that applies to every reasoning model, so we expose it as one on/off toggle rather than a per-model submenu.
+
+**Toggle it:**
+
+- **`/fireworks-settings`** (TUI) → *Preserved thinking* → `on` / `off`. Takes effect immediately and persists as the default for future sessions.
+- A dim **model-select notification** tells you the current state when you switch to a Fireworks reasoning model (`Preserved thinking ON for …` / `… OFF for …`).
+
+Preserved thinking is **off by default** to match pi core and Fireworks' default (stripped). There is intentionally no `/fireworks-preserve` command or keybinding — it's settings-panel-only, mirroring neuralwatt/makora.
+
 ## Usage
 
 After loading the extension, use the `/model` command in pi to select your preferred model:
@@ -190,6 +215,18 @@ Add to your pi configuration for automatic loading:
 }
 ```
 
+## Development
+
+```bash
+pnpm install          # install dev tooling (vitest, knip, typescript)
+pnpm test             # run the test suite (vitest)
+pnpm run test:watch   # watch mode
+pnpm run lint:dead    # dead-code / unused-export scan (knip)
+pnpm run check        # typecheck (tsc) + tests + knip, all green or exit non-zero
+```
+
+Tests live in `tests/` and stub the `@earendil-works/pi-coding-agent` / `@earendil-works/pi-tui` peer dependencies (see `tests/__mocks__/`) so they run without the real pi packages installed. A per-run temp dir is used for `~/.pi/agent` (via `PI_CODING_AGENT_DIR` in `tests/vitest.setup.ts`) so config/cache reads and writes never touch your real environment.
+
 ## License
 
 MIT

package/index.ts

@@ -366,14 +366,21 @@ const PRIORITY_PRICING: Record<string, { input: number; output: number; cacheRea
 
 type ServiceTier = "standard" | "priority";
 
+type PreserveMode = boolean; // true = inject reasoning_history:"preserved"; false = default (stripped)
+
 interface ServiceTierConfig {
   default: ServiceTier;
   keybinding: string;
   display: "statusbar" | "off";
 }
 
+interface PreserveThinkingConfig {
+  default: PreserveMode;
+}
+
 interface FireworksConfig {
   serviceTier: ServiceTierConfig;
+  preserveThinking: PreserveThinkingConfig;
 }
 
 const FIREWORKS_CONFIG_PATH = path.join(getAgentDir(), "extensions", "fireworks.json");
@@ -384,22 +391,40 @@ const DEFAULT_SERVICE_TIER_CONFIG: ServiceTierConfig = {
   keybinding: "ctrl+shift+l",
   display: "statusbar",
 };
-const DEFAULT_FIREWORKS_CONFIG: FireworksConfig = { serviceTier: DEFAULT_SERVICE_TIER_CONFIG };
+// Preserved thinking is OFF by default to match pi core and Fireworks' default
+// (`reasoning_history` omitted = prior reasoning stripped). Opt in via the
+// /fireworks-settings panel (mirrors neuralwatt/makora: settings-only, no
+// command or keybinding).
+const DEFAULT_PRESERVE_CONFIG: PreserveThinkingConfig = {
+  default: false,
+};
+const DEFAULT_FIREWORKS_CONFIG: FireworksConfig = {
+  serviceTier: DEFAULT_SERVICE_TIER_CONFIG,
+  preserveThinking: DEFAULT_PRESERVE_CONFIG,
+};
 
 function isValidTier(v: unknown): v is ServiceTier {
   return v === "standard" || v === "priority";
 }
 
+function isValidKeybinding(v: unknown): v is string {
+  return typeof v === "string" && v.length > 0;
+}
+
 function loadFireworksConfig(): FireworksConfig {
   try {
     const raw = JSON.parse(fs.readFileSync(FIREWORKS_CONFIG_PATH, "utf8"));
     const st = raw?.serviceTier ?? {};
+    const pt = raw?.preserveThinking ?? {};
     return {
       serviceTier: {
         default: isValidTier(st.default) ? st.default : DEFAULT_SERVICE_TIER_CONFIG.default,
-        keybinding: typeof st.keybinding === "string" && st.keybinding.length > 0 ? st.keybinding : DEFAULT_SERVICE_TIER_CONFIG.keybinding,
+        keybinding: isValidKeybinding(st.keybinding) ? st.keybinding : DEFAULT_SERVICE_TIER_CONFIG.keybinding,
         display: st.display === "off" ? "off" : "statusbar",
       },
+      preserveThinking: {
+        default: typeof pt.default === "boolean" ? pt.default : DEFAULT_PRESERVE_CONFIG.default,
+      },
     };
   } catch {
     // Config missing or invalid — write defaults so the user can discover it.
@@ -409,7 +434,27 @@ function loadFireworksConfig(): FireworksConfig {
     } catch {
       // Write failure is non-fatal — defaults still work in memory.
     }
-    return { serviceTier: { ...DEFAULT_SERVICE_TIER_CONFIG } };
+    return { serviceTier: { ...DEFAULT_SERVICE_TIER_CONFIG }, preserveThinking: { ...DEFAULT_PRESERVE_CONFIG } };
+  }
+}
+
+// Read-modify-write the raw config JSON without re-validating, so unrelated
+// fields a user added survive a settings-UI write. `loadFireworksConfig()`
+// (validated) is still called after writing to refresh the in-memory config.
+function readRawFireworksConfig(): Record<string, any> {
+  try {
+    return JSON.parse(fs.readFileSync(FIREWORKS_CONFIG_PATH, "utf8"));
+  } catch {
+    return JSON.parse(JSON.stringify(DEFAULT_FIREWORKS_CONFIG));
+  }
+}
+
+function writeRawFireworksConfig(raw: Record<string, any>): void {
+  try {
+    fs.mkdirSync(path.dirname(FIREWORKS_CONFIG_PATH), { recursive: true });
+    fs.writeFileSync(FIREWORKS_CONFIG_PATH, JSON.stringify(raw, null, 2) + "\n");
+  } catch {
+    // Write failure is non-fatal — the in-memory refresh still applies.
   }
 }
 
@@ -508,14 +553,108 @@ function recomputePriorityCost(message: any): any {
   return { ...message, usage: { ...usage, cost } };
 }
 
+// ─── Preserved Thinking (reasoning_history) ──────────────────────────────────
+
+// Fireworks exposes a top-level `reasoning_history` request parameter. The
+// only accepted value is `"preserved"`; omitting it (or any other value)
+// means prior assistant reasoning is STRIPPED from the model's context
+// (verified by e2e: reasoning_content on an assistant message yields 0%
+// multi-turn recall without the flag, 100% with it). This works on BOTH
+// transports — the OpenAI completions endpoint (assistant `reasoning_content`
+// field) and the Anthropic Messages endpoint (assistant `thinking` content
+// block, which Firebooks returns a `signature` for so pi-ai replays it).
+//
+// Unlike neuralwatt/makora (which use per-model vLLM `chat_template_kwargs`
+// flags like preserve_thinking/clear_thinking), Fireworks' knob is a single
+// global top-level param that applies to every reasoning model. We expose it
+// as one on/off toggle. See https://docs.fireworks.ai/guides/reasoning#preserved-thinking.
+
+// A Fireworks model is preserve-eligible if it's a reasoning model. We read
+// `reasoning` off the registered model when available, but also accept a
+// truthy `reasoning` flag on ctx.model (pi-ai attaches it).
+function isPreserveEligible(model: any): boolean {
+  if (!model || model.provider !== "fireworks") return false;
+  return model.reasoning === true;
+}
+
+// Runtime state: whether preserved thinking is active. Initialized from the
+// config-file default at session_start (mirrors neuralwatt/makora, which drive
+// preserve state from the config file, not session entries) and updated by the
+// /fireworks-settings panel, which also persists the new default.
+let preserveOn: boolean = fireworksConfig.preserveThinking.default;
+
+function setPreserve(on: boolean): void {
+  preserveOn = on;
+}
+
 // ─── Extension Entry Point ────────────────────────────────────────────────────
 
+export {
+  applyPatch,
+  buildModels,
+  isChatModel,
+  transformApiModel,
+  mergeWithEmbedded,
+  loadStaleModels,
+  isFireworksKimiModel,
+  sanitizePattern,
+  sanitizeSchemaForKimi,
+  stripAnchorBleedInPlace,
+  isValidTier,
+  isValidKeybinding,
+  loadFireworksConfig,
+  readRawFireworksConfig,
+  writeRawFireworksConfig,
+  isPriorityApplicable,
+  PRIORITY_PRICING,
+  recomputePriorityCost,
+  replayTierState,
+  setTier,
+  updateTierStatus,
+  isPreserveEligible,
+  setPreserve,
+};
+
+export type {
+  JsonModel,
+  PatchEntry,
+  PatchData,
+  FireworksApi,
+  ServiceTier,
+  ServiceTierConfig,
+  PreserveThinkingConfig,
+  FireworksConfig,
+};
+
 export default function (pi: ExtensionAPI) {
   piRef = pi;
   const embeddedModels = modelsData as JsonModel[];
   const customModels = customModelsData as JsonModel[];
   const patches = patchData as PatchData;
 
+  // Deferred model_select notify timer — cleared on rapid re-switch and on
+  // session_shutdown so only the latest switch notifies. Mirrors neuralwatt's
+  // pattern so pi core's (and other extensions') notifications land first.
+  let modelSelectNotifyTimer: ReturnType<typeof setTimeout> | null = null;
+  const MODEL_SELECT_NOTIFY_DELAY_MS = 250;
+
+  // Notify preserved-thinking state for a Fireworks reasoning model. Deferred
+  // so pi core's notifications land first; cancelled on re-switch/shutdown so
+  // only the latest shows. Always level "info" — the text conveys the
+  // preserve/strip tradeoff, not a warning.
+  function notifyPreserveOnSelect(model: any, ctx: any): void {
+    if (!model || model.provider !== "fireworks") return;
+    if (!isPreserveEligible(model)) return;
+    const msg = preserveOn
+      ? `Preserved thinking ON for ${model.name || model.id} — full reasoning history retained across turns (better multi-turn recall; uses more tokens). Open /fireworks-settings to change.`
+      : `Preserved thinking OFF for ${model.name || model.id} — reasoning stripped each turn (Fireworks default; lighter, weaker multi-turn recall). Open /fireworks-settings to change.`;
+    if (modelSelectNotifyTimer) clearTimeout(modelSelectNotifyTimer);
+    modelSelectNotifyTimer = setTimeout(() => {
+      modelSelectNotifyTimer = null;
+      try { ctx.ui.notify(msg, "info"); } catch { /* notify is a no-op without a UI runner */ }
+    }, MODEL_SELECT_NOTIFY_DELAY_MS);
+  }
+
   const staleBase = loadStaleModels(embeddedModels);
   const staleModels = buildModels(staleBase, customModels, patches);
 
@@ -532,7 +671,9 @@ export default function (pi: ExtensionAPI) {
     const signal = revalidateAbort.signal;
     fireworksConfig = loadFireworksConfig();
     replayTierState(ctx, fireworksConfig.serviceTier.default);
+    preserveOn = fireworksConfig.preserveThinking.default;
     updateTierStatus(ctx);
+    notifyPreserveOnSelect(ctx.model, ctx);
     resolveApiKey(ctx.modelRegistry).then(() => {
       revalidateModels(cachedApiKey, embeddedModels, signal).then((freshBase) => {
         if (freshBase && !signal.aborted) {
@@ -550,6 +691,7 @@ export default function (pi: ExtensionAPI) {
   pi.on("session_shutdown", (_event, ctx) => {
     revalidateAbort?.abort();
     try { ctx.ui.setStatus(TIER_STATUS_KEY, undefined); } catch {}
+    if (modelSelectNotifyTimer) { clearTimeout(modelSelectNotifyTimer); modelSelectNotifyTimer = null; }
   });
 
   // Sanitize JSON Schema patterns for Kimi models before sending to Fireworks.
@@ -576,6 +718,19 @@ export default function (pi: ExtensionAPI) {
       modified = true;
     }
 
+    // Preserved thinking: inject top-level `reasoning_history: "preserved"`
+    // so Fireworks renders prior assistant reasoning (reasoning_content on the
+    // OpenAI endpoint, thinking blocks on the Anthropic endpoint) into the
+    // model's context instead of stripping it. The only accepted value is
+    // "preserved"; omitted = stripped (Fireworks default / pi core). Applies to
+    // any Fireworks reasoning model on both transports. pi-ai already replays
+    // the reasoning field/block on prior assistant turns; this flag is what
+    // makes Fireworks honor it. See https://docs.fireworks.ai/guides/reasoning.
+    if (preserveOn && isPreserveEligible(model)) {
+      payload.reasoning_history = "preserved";
+      modified = true;
+    }
+
     // Kimi anchor-bleed sanitization (Kimi K2.x pattern bug). Only applies to
     // Kimi models, but a single request can be both Kimi and priority-tiered.
     if (isFireworksKimiModel(model)) {
@@ -623,9 +778,12 @@ export default function (pi: ExtensionAPI) {
     }
   });
 
-  // Refresh the tier status area when the active model changes.
-  pi.on("model_select", async (_event, ctx) => {
+  // Refresh the tier status area when the active model changes, and notify
+  // preserved-thinking state for the selected reasoning model (mirrors
+  // neuralwatt/makora: notification only, no preserve status area).
+  pi.on("model_select", async (event, ctx) => {
     updateTierStatus(ctx);
+    notifyPreserveOnSelect(event.model ?? ctx.model, ctx);
   });
 
   // Recompute finalized assistant-message cost against priority pricing so
@@ -672,4 +830,107 @@ export default function (pi: ExtensionAPI) {
       }
     },
   });
+
+  // /fireworks-settings: TUI settings panel (mirrors /neuralwatt-settings &
+  // /makora-settings). Opens a SettingsList via ctx.ui.custom(). Toggles write
+  // to ~/.pi/agent/extensions/fireworks.json (raw read-modify-write so unknown
+  // fields survive) and refresh the in-memory config. Preserved thinking is
+  // settings-only (no command/keybinding), exactly like the siblings; the
+  // service-tier keybinding is load-time only, so keybinding changes need /reload.
+  pi.registerCommand("fireworks-settings", {
+    description: "Configure Fireworks: preserved thinking + service tier + display",
+    async handler(_args, ctx) {
+      if (ctx.mode !== "tui") {
+        ctx.ui.notify("/fireworks-settings requires TUI mode.", "error");
+        return;
+      }
+      const { SettingsList, Container } = await import("@earendil-works/pi-tui");
+      const { getSettingsListTheme, DynamicBorder } = await import("@earendil-works/pi-coding-agent");
+
+      await ctx.ui.custom((_tui, theme, _kb, done) => {
+        const border = () => new DynamicBorder((s: string) => theme.fg("border", s));
+
+        const items: any[] = [
+          {
+            id: "preserveThinking",
+            label: "Preserved thinking",
+            description: "Inject reasoning_history:\"preserved\" so Fireworks retains prior assistant reasoning across turns (better multi-turn recall; uses more tokens). Off = Fireworks default (stripped). Applies to every Fireworks reasoning model on both endpoints.",
+            currentValue: preserveOn ? "on" : "off",
+            values: ["on", "off"],
+          },
+          {
+            id: "serviceTier",
+            label: "Service tier",
+            description: "Fireworks service tier for supported models. priority = higher throughput / latency at ~1.2\u20131.5\u00d7 cost (priority pricing reflected in cost tracking). standard = default.",
+            currentValue: currentTier,
+            values: ["standard", "priority"],
+          },
+          {
+            id: "serviceTier.display",
+            label: "Service tier display",
+            description: "Where the \u201ctier: standard / \u26a1priority\u201d indicator is shown: footer status area or hidden",
+            currentValue: fireworksConfig.serviceTier.display,
+            values: ["statusbar", "off"],
+          },
+        ];
+
+        const container = new Container();
+        container.addChild(border());
+
+        const settingsList = new SettingsList(
+          items,
+          Math.min(items.length + 2, 15),
+          getSettingsListTheme(),
+          (id: string, newValue: string) => {
+            if (id === "preserveThinking") {
+              const on = newValue === "on";
+              setPreserve(on);
+              // Persist as the default too, so it survives new sessions.
+              const raw = readRawFireworksConfig();
+              raw.preserveThinking = { ...(raw.preserveThinking ?? {}), default: on };
+              writeRawFireworksConfig(raw);
+              fireworksConfig = loadFireworksConfig();
+              ctx.ui.notify(`Preserved thinking ${on ? "on" : "off"} \u2014 takes effect now.`, "info");
+            } else if (id === "serviceTier") {
+              let model: any;
+              try { model = ctx.model; } catch { model = undefined; }
+              if (!model || model.provider !== "fireworks" || !isPriorityApplicable(model.id)) {
+                ctx.ui.notify("Service tier only applies to supported Fireworks models.", "info");
+                return;
+              }
+              const tier = newValue as ServiceTier;
+              setTier(ctx, tier);
+              const raw = readRawFireworksConfig();
+              raw.serviceTier = { ...(raw.serviceTier ?? {}), default: tier };
+              writeRawFireworksConfig(raw);
+              fireworksConfig = loadFireworksConfig();
+              ctx.ui.notify(`Fireworks service tier: ${tier}`, "info");
+            } else if (id === "serviceTier.display") {
+              const raw = readRawFireworksConfig();
+              raw.serviceTier = { ...(raw.serviceTier ?? {}), display: newValue };
+              writeRawFireworksConfig(raw);
+              fireworksConfig = loadFireworksConfig();
+              updateTierStatus(ctx);
+            }
+          },
+          () => done(undefined),
+          { enableSearch: true },
+        );
+        container.addChild(settingsList);
+        container.addChild(border());
+
+        return {
+          render(width: number) {
+            return container.render(width);
+          },
+          invalidate() {
+            container.invalidate();
+          },
+          handleInput(data: string) {
+            settingsList.handleInput?.(data);
+          },
+        };
+      });
+    },
+  });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-fireworks-provider",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "description": "Fireworks AI provider extension for pi - Access Kimi, MiniMax, GLM, DeepSeek, and GPT-OSS models through the Fireworks AI API",
   "type": "module",
   "main": "index.ts",
@@ -19,6 +19,20 @@
   ],
   "author": "",
   "license": "MIT",
+  "files": [
+    "index.ts",
+    "models.json",
+    "custom-models.json",
+    "patch.json",
+    "README.md",
+    "LICENSE"
+  ],
+  "devDependencies": {
+    "@types/node": "^22.20.0",
+    "knip": "6.14.1",
+    "typescript": "6.0.3",
+    "vitest": "4.1.7"
+  },
   "pi": {
     "extensions": [
       "./index.ts"
@@ -27,7 +41,10 @@
   "scripts": {
     "clean": "echo 'nothing to clean'",
     "build": "echo 'nothing to build'",
-    "check": "echo 'nothing to check'",
+    "check": "tsc --noEmit && vitest run && knip --no-gitignore",
+    "lint:dead": "knip --no-gitignore",
+    "test": "vitest run",
+    "test:watch": "vitest",
     "update-models": "node scripts/update-models.js"
   }
 }

package/patch.json

@@ -417,22 +417,6 @@
       "supportsLongCacheRetention": false
     }
   },
-  "accounts/fireworks/models/qwen3p6-plus": {
-    "name": "Qwen 3.6 Plus",
-    "reasoning": true,
-    "input": ["text", "image"],
-    "cost": {
-      "input": 0.5,
-      "output": 3,
-      "cacheRead": 0.1,
-      "cacheWrite": 0
-    },
-    "contextWindow": 262144,
-    "maxTokens": 8192,
-    "compat": {
-      "supportsReasoningEffort": true
-    }
-  },
   "accounts/fireworks/models/qwen3p7-plus": {
     "name": "Qwen 3.7 Plus",
     "api": "anthropic-messages",
@@ -544,20 +528,6 @@
       "supportsReasoningEffort": true
     }
   },
-  "accounts/fireworks/routers/kimi-k2p5-turbo": {
-    "name": "Kimi K2.5 Turbo (router)",
-    "reasoning": true,
-    "cost": {
-      "input": 0.6,
-      "output": 3,
-      "cacheRead": 0.1,
-      "cacheWrite": 0
-    },
-    "maxTokens": 256000,
-    "compat": {
-      "supportsReasoningEffort": true
-    }
-  },
   "accounts/fireworks/routers/kimi-k2p6": {
     "name": "Kimi K2.6 (router)",
     "reasoning": true,

package/.github/FUNDING.yml

@@ -1,4 +0,0 @@
-github: monotykamary
-ko_fi: monotykamary
-buy_me_a_coffee: monotykamary
-polar: monotykamary

package/.pi/messenger/channels/memory.jsonl

@@ -1 +0,0 @@
-{"_meta":true,"v":1,"id":"memory","type":"named","createdAt":"2026-05-25T08:03:16.155Z","description":"Cross-session knowledge and insights"}

package/.pi/messenger/session-id

@@ -1 +0,0 @@
-019e98a1-b474-7d6d-b80e-b1dedf22aa71

package/AGENTS.md

@@ -1,56 +0,0 @@
-# AGENTS.md
-
-## DO NOT EDIT — Auto-generated Files
-
-The following files are **idempotent** and regenerated by `scripts/update-models.js`. Never edit them directly — your changes will be overwritten on the next model sync.
-
-| File | Why it's auto-generated |
-|------|------------------------|
-| `models.json` | Built from the provider API. `update-models.js` fetches models, preserves curated data for known IDs, and writes this file. |
-| `README.md` (model table) | The table under `## Available Models` is replaced in-place by `update-models.js` after merging base models → patch → custom models. |
-
-## Correct Files to Edit
-
-When a model needs overrides, new properties, or corrections, edit the appropriate source file below. These are the **source of truth** that the update script reads but never writes.
-
-| File | Purpose |
-|------|---------|
-| `patch.json` | Per-model overrides keyed by model ID. Add reasoning flags, compat settings, pricing corrections, thinking level maps, etc. Applied on top of `models.json` at runtime and for README generation. |
-| `custom-models.json` | Models that don't exist in the provider API (hidden models, router endpoints, cross-provider aliases). Merged after patch. Format: array of full model objects (same schema as `models.json` entries). |
-| `index.ts` | Provider extension code. |
-| `scripts/update-models.js` | The sync script itself (edit only if changing how models are fetched/transformed). |
-
-## Data Flow
-
-```
-Provider API  ──fetch──►  models.json  ──apply──►  patch.json  ──merge──►  custom-models.json
-                                    │                            │                      │
-                                    └────────────────────────────┴──────────────────────┘
-                                                      │
-                                              README model table
-```
-
-1. `models.json` — base data from the provider API (auto-generated, DO NOT EDIT)
-2. `patch.json` — overrides applied on top (EDIT THIS for corrections/enrichments)
-3. `custom-models.json` — additional models not in the API (EDIT THIS for new models)
-4. README table — rendered from the merged result of all three (auto-generated, DO NOT EDIT)
-
-## Common Tasks
-
-### Add a compat setting or override pricing for an existing model
-→ Edit `patch.json`. Add an entry keyed by the model's `id`.
-
-### Add a model not available in the provider API
-→ Edit `custom-models.json`. Add a full model object to the array.
-
-### Update models from the provider API
-→ Run `node scripts/update-models.js` (may require an API key env var).
-
-### Regenerate the README model table
-→ Run `node scripts/update-models.js` — it updates both `models.json` and the README table.
-
-## TL;DR
-
-- **Never edit `models.json`** — edit `patch.json` instead.
-- **Never edit the README model table** — run the update script instead.
-- `patch.json` and `custom-models.json` are the source files you should modify.

package/scripts/update-models.js

@@ -1,349 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * Script to update fireworks models from the Fireworks API
- *
- * Uses the official Fireworks Gateway REST API to discover available models:
- *   GET /v1/accounts/fireworks/models
- *
- * Requires FIREWORKS_API_KEY environment variable.
- * Usage: FIREWORKS_API_KEY=your-key node scripts/update-models.js
- *
- * Data flow:
- *   models.json       → auto-generated from Fireworks API (model discovery)
- *   patch.json        → manual overrides (pricing, reasoning, limits, etc.)
- *   custom-models.json → hidden/router models not in the API
- *
- * The API provides: id, displayName, contextLength, supportsImageInput,
- * supportsTools, supportsServerless, state, kind, moe, parameterCount, etc.
- *
- * It does NOT provide: pricing, max output tokens, reasoning mode, or
- * interleaved thinking details. Those come from patch.json.
- *
- * Merge order for README: models.json → apply patch.json → merge custom-models.json
- */
-
-import https from 'https';
-import fs from 'fs';
-import path from 'path';
-import { fileURLToPath } from 'url';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-
-const FIREWORKS_API_BASE = 'https://api.fireworks.ai';
-const ACCOUNT_ID = 'fireworks';
-const MODELS_PATH = path.join(process.cwd(), 'models.json');
-const CUSTOM_MODELS_PATH = path.join(process.cwd(), 'custom-models.json');
-const PATCH_PATH = path.join(process.cwd(), 'patch.json');
-
-// ─── HTTP helpers ───────────────────────────────────────────────────────────
-
-function fetchJSON(url, headers = {}) {
-  return new Promise((resolve, reject) => {
-    const req = https.get(url, { headers }, (res) => {
-      let data = '';
-      res.on('data', (chunk) => (data += chunk));
-      res.on('end', () => {
-        try {
-          resolve(JSON.parse(data));
-        } catch (e) {
-          reject(new Error(`Failed to parse JSON from ${url}: ${e.message}`));
-        }
-      });
-    });
-    req.on('error', reject);
-  });
-}
-
-/**
- * Paginate through the Fireworks account models API.
- * Returns all models across all pages.
- */
-async function fetchAllFireworksModels(apiKey) {
-  const headers = {};
-  if (apiKey) headers.Authorization = `Bearer ${apiKey}`;
-
-  const allModels = [];
-  let pageToken = undefined;
-  let page = 0;
-
-  do {
-    let url = `${FIREWORKS_API_BASE}/v1/accounts/${ACCOUNT_ID}/models?pageSize=200`;
-    if (pageToken) url += `&pageToken=${pageToken}`;
-
-    const data = await fetchJSON(url, headers);
-    const models = data.models || [];
-    allModels.push(...models);
-
-    pageToken = data.nextPageToken || undefined;
-    page++;
-    console.log(`  Page ${page}: fetched ${models.length} models (total so far: ${allModels.length})`);
-  } while (pageToken);
-
-  return allModels;
-}
-
-// ─── File I/O ───────────────────────────────────────────────────────────────
-
-function loadJSON(filePath) {
-  try {
-    if (!fs.existsSync(filePath)) return [];
-    const data = fs.readFileSync(filePath, 'utf8');
-    const parsed = JSON.parse(data);
-    console.log(`✓ Loaded ${Array.isArray(parsed) ? parsed.length : Object.keys(parsed).length} entries from ${path.basename(filePath)}`);
-    return parsed;
-  } catch (e) {
-    console.warn(`Warning: Could not load ${path.basename(filePath)}: ${e.message}`);
-    return {};
-  }
-}
-
-function saveJSON(filePath, data) {
-  fs.writeFileSync(filePath, JSON.stringify(data, null, 2) + '\n');
-  const count = Array.isArray(data) ? data.length : Object.keys(data).length;
-  console.log(`✓ Saved ${count} entries to ${path.basename(filePath)}`);
-}
-
-// ─── Model filtering & mapping ──────────────────────────────────────────────
-
-/**
- * Filter: only serverless chat-capable LLM base models that are READY.
- *
- * We only include models that are serverless (pay-per-token) because those
- * are the ones relevant for the pi provider. Non-serverless models can only
- * be used via on-demand deployments, which isn't what this provider targets.
- *
- * Exceptions: models present in the existing models.json are kept even if
- * they lose serverless status (they may still work via routers/firepass).
- */
-function isRelevantModel(m, existingIds = new Set()) {
-  const kind = m.kind || '';
-  // Only HuggingFace base models
-  if (kind !== 'HF_BASE_MODEL') return false;
-  // Must be READY
-  if (m.state !== 'READY') return false;
-  // Must have a context length
-  if (!m.contextLength || m.contextLength === 0) return false;
-  // Must be serverless, OR already exist in our curated list
-  if (!m.supportsServerless && !existingIds.has(m.name)) return false;
-  return true;
-}
-
-/**
- * Build a display name from the API displayName, falling back to the model id.
- */
-function buildDisplayName(m) {
-  let name = m.displayName || m.name || '';
-  if (!name || name === m.name) {
-    name = m.name.split('/').pop() || m.name;
-  }
-  return name;
-}
-
-/**
- * Convert a Fireworks API model to Pi-native models.json format.
- * Only includes data the API provides — no pricing, reasoning, or output limits.
- * Those come from patch.json.
- */
-function convertModel(apiModel) {
-  const id = apiModel.name;
-  const name = buildDisplayName(apiModel);
-  const input = ['text'];
-  if (apiModel.supportsImageInput) input.push('image');
-
-  return {
-    id,
-    name,
-    reasoning: false,
-    input,
-    cost: {
-      input: 0,
-      output: 0,
-      cacheRead: 0,
-      cacheWrite: 0,
-    },
-    contextWindow: apiModel.contextLength || 0,
-    maxTokens: 0,
-  };
-}
-
-/**
- * Deep merge a patch into a model. Nested objects (cost) are merged
- * field-by-field; scalar fields are replaced.
- */
-function applyPatch(model, patch) {
-  const result = { ...model };
-
-  if (patch.name !== undefined) result.name = patch.name;
-  if (patch.family !== undefined) result.family = patch.family;
-  if (patch.reasoning !== undefined) result.reasoning = patch.reasoning;
-  if (patch.interleaved !== undefined) result.interleaved = patch.interleaved;
-
-  if (patch.input !== undefined) result.input = patch.input;
-  if (patch.contextWindow !== undefined) result.contextWindow = patch.contextWindow;
-  if (patch.maxTokens !== undefined) result.maxTokens = patch.maxTokens;
-
-  if (patch.cost) {
-    result.cost = {
-      input: patch.cost.input ?? result.cost?.input ?? 0,
-      output: patch.cost.output ?? result.cost?.output ?? 0,
-      cacheRead: patch.cost.cacheRead ?? result.cost?.cacheRead ?? 0,
-      cacheWrite: patch.cost.cacheWrite ?? result.cost?.cacheWrite ?? 0,
-    };
-  }
-
-  return result;
-}
-
-// ─── README generation ──────────────────────────────────────────────────────
-
-function formatCost(cost) {
-  if (cost === null || cost === undefined) return '-';
-  if (cost === 0) return 'Free';
-  return `$${cost.toFixed(2)}`;
-}
-
-function formatNumber(num) {
-  if (num === null || num === undefined) return '-';
-  if (num >= 1000000) return `${(num / 1000000).toFixed(1)}M`;
-  if (num >= 1000) return `${(num / 1000).toFixed(0)}K`;
-  return num.toString();
-}
-
-function getInputTypes(inputTypes) {
-  const types = inputTypes || ['text'];
-  const hasImage = types.includes('image');
-  const hasText = types.includes('text');
-  if (hasImage && hasText) return 'Text + Image';
-  if (hasImage) return 'Image';
-  return 'Text';
-}
-
-function generateReadmeRow(model) {
-  const cost = model.cost || {};
-  return `| ${model.name} | ${getInputTypes(model.input)} | ${formatNumber(model.contextWindow)} | ${formatNumber(model.maxTokens)} | ${formatCost(cost.input)} | ${formatCost(cost.output)} |`;
-}
-
-function updateReadme(models) {
-  const readmePath = path.join(process.cwd(), 'README.md');
-  let readme = fs.readFileSync(readmePath, 'utf8');
-
-  const sortedModels = [...models].sort((a, b) => {
-    const familyA = a.family || '';
-    const familyB = b.family || '';
-    if (familyA !== familyB) return familyA.localeCompare(familyB);
-    return a.name.localeCompare(b.name);
-  });
-
-  const tableRows = sortedModels.map(generateReadmeRow).join('\n');
-  const newTable = `| Model | Type | Context | Max Tokens | Input Cost | Output Cost |
-|-------|------|---------|------------|------------|-------------|
-${tableRows}`;
-
-  const tableRegex = /\| Model \| Type \| Context \| Max Tokens \| Input Cost \| Output Cost \|[\s\S]*?(?=\n\*Costs are per million)/;
-  readme = readme.replace(tableRegex, newTable);
-
-  readme = readme.replace(/\*\*\d+\+ AI Models\*\*/, `**${models.length}+ AI Models**`);
-
-  fs.writeFileSync(readmePath, readme);
-  console.log(`✓ Updated README.md with ${models.length} models`);
-}
-
-// ─── Main ────────────────────────────────────────────────────────────────────
-
-async function main() {
-  const apiKey = process.env.FIREWORKS_API_KEY;
-  if (!apiKey) {
-    console.error('Error: FIREWORKS_API_KEY environment variable is required');
-    console.error('Usage: FIREWORKS_API_KEY=your-key node scripts/update-models.js');
-    process.exit(1);
-  }
-
-  console.log('Fetching models from Fireworks API...\n');
-
-  try {
-    // 1. Fetch all models from Fireworks API
-    const apiModels = await fetchAllFireworksModels(apiKey);
-    console.log(`\nTotal models from API: ${apiModels.length}`);
-
-    // 2. Load existing models.json and patch.json
-    const existingModels = Array.isArray(loadJSON(MODELS_PATH)) ? loadJSON(MODELS_PATH) : [];
-    const patchData = loadJSON(PATCH_PATH);
-    const existingIds = new Set(existingModels.map((m) => m.id));
-
-    // 3. Filter to relevant LLMs (serverless + previously curated)
-    const relevantApiModels = apiModels.filter((m) => isRelevantModel(m, existingIds));
-    console.log(`Relevant LLM models: ${relevantApiModels.length}`);
-
-    // 4. Convert API models to models.json format (no pricing — that comes from patch.json)
-    const newModels = relevantApiModels.map((apiModel) => convertModel(apiModel));
-
-    // Log new models (not in patch.json)
-    for (const m of newModels) {
-      if (!patchData[m.id]) {
-        console.log(`  🆕 New model: ${m.id} (${m.name}) — add to patch.json for pricing/output limits`);
-      }
-    }
-
-    // Live API is authoritative — models absent from API are removed
-    const allUpstreamModels = [...newModels];
-
-    // 5. Save upstream models (API-derived, no pricing)
-    saveJSON(MODELS_PATH, allUpstreamModels);
-
-    // 6. Load and process custom models
-    const customModels = Array.isArray(loadJSON(CUSTOM_MODELS_PATH)) ? loadJSON(CUSTOM_MODELS_PATH) : [];
-
-    // Find custom models that now appear in upstream (remove from custom)
-    const upstreamIds = new Set(allUpstreamModels.map((m) => m.id));
-    const duplicates = customModels.filter((m) => upstreamIds.has(m.id));
-    if (duplicates.length > 0) {
-      console.log(`\nFound ${duplicates.length} custom model(s) now available upstream:`);
-      for (const dup of duplicates) {
-        console.log(`  - ${dup.id} (${dup.name})`);
-      }
-      const cleaned = customModels.filter((m) => !upstreamIds.has(m.id));
-      saveJSON(CUSTOM_MODELS_PATH, cleaned);
-      console.log(`✓ Removed ${duplicates.length} duplicate(s) from custom-models.json`);
-      customModels.length = 0;
-      customModels.push(...cleaned);
-    }
-
-    // 7. Build merged models with patches applied (for README)
-    const mergedMap = new Map();
-
-    // Start with upstream models
-    for (const m of allUpstreamModels) mergedMap.set(m.id, m);
-
-    // Apply patches (enrichment: pricing, reasoning, limits, etc.)
-    for (const [id, patch] of Object.entries(patchData)) {
-      const existing = mergedMap.get(id);
-      if (existing) {
-        mergedMap.set(id, applyPatch(existing, patch));
-      }
-    }
-
-    // Add/override with custom models, also applying their patches
-    for (const m of customModels) {
-      const patch = patchData[m.id];
-      mergedMap.set(m.id, patch ? applyPatch(m, patch) : m);
-    }
-
-    const allModels = Array.from(mergedMap.values());
-
-    console.log(
-      `\nTotal: ${allModels.length} models (${allUpstreamModels.length} upstream + ${customModels.length} custom, ${Object.keys(patchData).length} patches)`
-    );
-
-    // 8. Update README
-    updateReadme(allModels);
-
-    console.log('\nDone!');
-  } catch (error) {
-    console.error('Error:', error.message);
-    process.exit(1);
-  }
-}
-
-main();