pi-spark 0.19.2 → 0.20.0

package/README.md

@@ -120,14 +120,33 @@ All fields are optional. Each top-level feature runs with the defaults below unl
 
 | Field | Value (or `false`) | Description |
 | --- | --- | --- |
-| `credits` | `{}` | Shows the active provider's credit balance or rate-limit usage in the status line. |
+| `credits` | `CreditsConfig` | Shows the active provider's credit balance or rate-limit usage in the status line. |
 | `editor` | `EditorConfig` | Shows a working indicator and the current model on the editor's top border. |
-| `footer` | `{}` | Shows session info, extension statuses, cost, and context usage on one line. |
+| `footer` | `FooterConfig` | Shows session info, extension statuses, cost, and context usage. |
 | `fullscreen` | `{}` | Clears the screen and scrollback on start and exit, and pins the editor and footer to the bottom. |
 | `presets` | `{ [name]: Preset }` | Defines named model presets, keyed by name. |
 | `recap` | `RecapConfig` | Generates a session recap when idle or on demand. |
 | `title` | `TitleConfig` | Names the session automatically after the first exchange. |
 
+#### `CreditsConfig`
+
+All supported providers are enabled by default. Set a provider to `false` to disable its credits status, or to `true` to override a global `false` in project config.
+
+```json
+{
+  "credits": {
+    "providers": {
+      "fireworks": false,
+      "openai-codex": true
+    }
+  }
+}
+```
+
+| Field | Value | Description |
+| --- | --- | --- |
+| `providers` | partial map of provider IDs to booleans | Enables or disables credits for individual providers. Valid IDs: `deepseek`, `fireworks`, `kimi-coding`, `moonshotai`, `moonshotai-cn`, `openai-codex`, `openrouter`, and `vercel-ai-gateway`. |
+
 #### `EditorConfig`
 
 The `spinner` field is optional and defaults to `tildes`.
@@ -139,6 +158,15 @@ The `spinner` field is optional and defaults to `tildes`.
 |  | `tildes` (default) | `∼, ≈, ≋, ≈, ∼` |
 |  | `pulse` | `·, •, ●, •, ·` |
 
+#### `FooterConfig`
+
+The `statusPosition` field is optional and defaults to `inline`.
+
+| Field | Value | Description |
+| --- | --- | --- |
+| `statusPosition` | `inline` (default) | Shows extension statuses on the same line as session info, cost, and context usage. |
+|  | `below` | Moves extension statuses to a new line below. |
+
 #### `Preset`
 
 Each preset must set all three fields.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-spark",
-  "version": "0.19.2",
+  "version": "0.20.0",
   "description": "Pi package that polishes your daily experience.",
   "keywords": [
     "pi-coding-agent",

package/src/features/credits/config.ts

@@ -1,3 +1,20 @@
 import * as z from "zod";
 
-export const creditsConfigSchema = z.object({});
+const creditsProviderIdSchema = z.enum([
+  "deepseek",
+  "fireworks",
+  "kimi-coding",
+  "moonshotai",
+  "moonshotai-cn",
+  "openai-codex",
+  "openrouter",
+  "vercel-ai-gateway",
+]);
+
+export type CreditsProviderId = z.infer<typeof creditsProviderIdSchema>;
+
+export const creditsConfigSchema = z.object({
+  providers: z.partialRecord(creditsProviderIdSchema, z.boolean()).optional(),
+});
+
+export type CreditsConfig = z.infer<typeof creditsConfigSchema>;

package/src/features/credits/index.ts

@@ -1,5 +1,5 @@
 import { CreditsManager } from "./manager";
-import { registerProviderExtensions } from "./providers";
+import { getEnabledProviders, registerProviderExtensions } from "./providers";
 import { loadConfig } from "../../config";
 import { isUsage } from "../../utils/usage";
 
@@ -20,8 +20,11 @@ export function registerCredits(pi: ExtensionAPI): void {
     const config = loadConfig(ctx).credits;
     if (!ctx.hasUI || !config) return;
 
-    creditsManager = new CreditsManager();
-    registerProviderExtensions(pi, ctx, async (ctx) => await creditsManager?.refresh(ctx));
+    const providers = getEnabledProviders(config);
+    if (providers.length === 0) return;
+
+    creditsManager = new CreditsManager(providers);
+    registerProviderExtensions(pi, ctx, providers, async (ctx) => await creditsManager?.refresh(ctx));
 
     creditsManager.refresh(ctx);
   });

package/src/features/credits/manager.ts

@@ -9,12 +9,17 @@ const REQUEST_TIMEOUT_MS = 30_000;
 
 export class CreditsManager {
   private inflight: AbortController | undefined = undefined;
+  private providers: CreditsProvider[];
   private currentProvider: string | undefined = undefined;
 
+  constructor(providers: CreditsProvider[]) {
+    this.providers = providers;
+  }
+
   async refresh(ctx: ExtensionContext): Promise<void> {
     this.inflight?.abort();
 
-    const provider = findProvider(ctx.model?.provider);
+    const provider = findProvider(this.providers, ctx.model?.provider);
     if (!provider) {
       this.inflight = undefined;
       this.currentProvider = undefined;

package/src/features/credits/providers/index.ts

@@ -7,6 +7,7 @@ import { openrouterProvider } from "./openrouter";
 import { vercelAiGatewayProvider } from "./vercel-ai-gateway";
 
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type { CreditsConfig } from "../config";
 import type { CreditsProvider, RefreshCredits } from "../types";
 
 const PROVIDERS: CreditsProvider[] = [
@@ -20,10 +21,15 @@ const PROVIDERS: CreditsProvider[] = [
   vercelAiGatewayProvider,
 ];
 
-export function findProvider(provider?: string): CreditsProvider | undefined {
-  return PROVIDERS.find((entry) => entry.id === provider);
+export function getEnabledProviders(config: CreditsConfig): CreditsProvider[] {
+  const settings = config.providers as Partial<Record<string, boolean>> | undefined;
+  return PROVIDERS.filter((provider) => settings?.[provider.id] !== false);
 }
 
-export function registerProviderExtensions(pi: ExtensionAPI, ctx: ExtensionContext, refresh: RefreshCredits): void {
-  for (const provider of PROVIDERS) provider.register?.(pi, ctx, refresh);
+export function findProvider(providers: CreditsProvider[], provider?: string): CreditsProvider | undefined {
+  return providers.find((entry) => entry.id === provider);
+}
+
+export function registerProviderExtensions(pi: ExtensionAPI, ctx: ExtensionContext, providers: CreditsProvider[], refresh: RefreshCredits): void {
+  for (const provider of providers) provider.register?.(pi, ctx, refresh);
 }

package/src/features/credits/providers/kimi-code.ts

@@ -4,18 +4,45 @@ import type { Credits, CreditsLane, CreditsProvider } from "../types";
 
 const PROVIDER = "kimi-coding";
 const URL = "https://api.kimi.com/coding/v1/usages";
+const BOOSTER_FIXED_POINT_CENTS = 1_000_000;
+
+interface KimiCodeUsage {
+  limit?: string | number;
+  used?: string | number;
+  remaining?: string | number;
+}
+
+interface KimiCodeLimit {
+  window?: { duration?: number; timeUnit?: string } | null;
+  detail?: KimiCodeUsage | null;
+}
+
+interface KimiCodeBoosterWallet {
+  balance?: {
+    type?: string;
+    amount?: string | number;
+    amountLeft?: string | number;
+  } | null;
+}
 
 interface KimiCodeUsageResponse {
-  usage?: { used?: string | number } | null;
-  limits?: {
-    window?: { duration?: number; timeUnit?: string } | null;
-    detail?: { used?: string | number } | null;
-  }[] | null;
+  usage?: KimiCodeUsage | null;
+  limits?: KimiCodeLimit[] | null;
+  boosterWallet?: KimiCodeBoosterWallet | null;
 }
 
-function toPercent(used: number | undefined): number | undefined {
-  if (used === undefined) return undefined;
-  return Math.min(100, Math.max(0, used));
+function toPercent(detail: KimiCodeUsage): number | undefined {
+  const limit = toNumber(detail.limit);
+  let used = toNumber(detail.used);
+
+  if (used === undefined && limit !== undefined) {
+    const remaining = toNumber(detail.remaining);
+    if (remaining !== undefined) used = limit - remaining;
+  }
+
+  if (used === undefined || limit === undefined || limit <= 0) return undefined;
+
+  return Math.min(100, Math.max(0, (used / limit) * 100));
 }
 
 function formatWindowLabel(window?: { duration?: number; timeUnit?: string } | null): string {
@@ -34,8 +61,20 @@ function formatWindowLabel(window?: { duration?: number; timeUnit?: string } | n
   return `${duration}${unit.replace("TIME_UNIT_", "").toLowerCase()}`;
 }
 
-function buildLane(label: string, detail?: KimiCodeUsageResponse["usage"]): CreditsLane {
-  return { label, percent: toPercent(toNumber(detail?.used)) };
+function buildLane(label: string, detail: KimiCodeUsage): CreditsLane | undefined {
+  const percent = toPercent(detail);
+  return percent === undefined ? undefined : { label, percent };
+}
+
+function formatSuffix(wallet?: KimiCodeBoosterWallet | null): string | undefined {
+  if (wallet?.balance?.type !== "BOOSTER") return undefined;
+
+  const amount = toNumber(wallet.balance.amount);
+  if (amount === undefined || amount <= 0) return undefined;
+
+  const amountLeft = Math.max(0, toNumber(wallet.balance.amountLeft) ?? 0);
+  const remaining = Math.round(amountLeft / BOOSTER_FIXED_POINT_CENTS) / 100;
+  return `(Extra Usage $${remaining.toFixed(2)})`;
 }
 
 export const kimiCodeProvider: CreditsProvider = {
@@ -55,15 +94,19 @@ export const kimiCodeProvider: CreditsProvider = {
     const lanes: CreditsLane[] = [];
 
     payload.limits?.forEach((item) => {
-      if (!item) return;
+      if (!item.detail) return;
 
-      const label = formatWindowLabel(item.window);
-      lanes.push(buildLane(label, item.detail));
+      const lane = buildLane(formatWindowLabel(item.window), item.detail);
+      if (lane) lanes.push(lane);
     });
 
-    const weeklyLane = buildLane("7d", payload.usage);
-    lanes.push(weeklyLane);
+    if (payload.usage) {
+      const weeklyLane = buildLane("7d", payload.usage);
+      if (weeklyLane) lanes.push(weeklyLane);
+    }
+
+    if (lanes.length === 0) throw new Error("no usage data");
 
-    return { type: "windows", lanes };
+    return { type: "windows", lanes, suffix: formatSuffix(payload.boosterWallet) };
   },
 };

package/src/features/credits/providers/moonshot.ts

@@ -13,7 +13,7 @@ interface MoonshotBalanceResponse {
  * different currencies (USD vs CNY), which the endpoint does not report, so each Pi provider ID
  * fixes both host and currency.
  */
-function createMoonshotProvider(id: string, host: string, currency: string): CreditsProvider {
+function createMoonshotProvider(id: "moonshotai" | "moonshotai-cn", host: string, currency: string): CreditsProvider {
   return {
     id,
     label: "Moonshot",

package/src/features/credits/types.ts

@@ -1,5 +1,5 @@
-import type { ProviderId } from "@earendil-works/pi-ai";
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type { CreditsProviderId } from "./config";
 
 /**
  * Normalized credits/usage for a provider.
@@ -21,7 +21,7 @@ export type RefreshCredits = (ctx: ExtensionContext) => Promise<void>;
 
 /** A credits source for a Pi provider, shown in the status line while that provider is active. */
 export interface CreditsProvider {
-  readonly id: ProviderId;
+  readonly id: CreditsProviderId;
   readonly label: string;
   fetch(apiKey: string, signal: AbortSignal): Promise<Credits>;
   register?(pi: ExtensionAPI, ctx: ExtensionContext, refresh: RefreshCredits): void;

package/src/features/editor/config.ts

@@ -1,6 +1,8 @@
 import * as z from "zod";
 
-import { spinnerPresetSchema } from "./spinner";
+const spinnerPresetSchema = z.enum(["dots", "lights", "tildes", "pulse"]);
+
+export type SpinnerPreset = z.infer<typeof spinnerPresetSchema>;
 
 export const editorConfigSchema = z.object({
   spinner: spinnerPresetSchema.optional(),

package/src/features/editor/spinner.ts

@@ -1,10 +1,5 @@
-import * as z from "zod";
-
 import type { TUI } from "@earendil-works/pi-tui";
-
-export const spinnerPresetSchema = z.enum(["dots", "lights", "tildes", "pulse"]);
-
-type SpinnerPreset = z.infer<typeof spinnerPresetSchema>;
+import type { SpinnerPreset } from "./config";
 
 interface SpinnerParams {
   frames: string[];
@@ -35,7 +30,7 @@ const SPINNER_PRESETS: Record<SpinnerPreset, SpinnerParams> = {
   },
 };
 
-const DEFAULT_SPINNER_PRESET = "tildes";
+const DEFAULT_SPINNER_PRESET: SpinnerPreset = "tildes";
 
 export class Spinner {
   private tui: TUI | undefined;

package/src/features/footer/config.ts

@@ -1,3 +1,9 @@
 import * as z from "zod";
 
-export const footerConfigSchema = z.object({});
+const statusPositionSchema = z.enum(["inline", "below"]);
+
+export type StatusPosition = z.infer<typeof statusPositionSchema>;
+
+export const footerConfigSchema = z.object({
+  statusPosition: statusPositionSchema.optional(),
+});

package/src/features/footer/index.ts

@@ -1,27 +1,30 @@
 import { homedir } from "node:os";
 import { resolve } from "node:path";
 import { pathToFileURL } from "node:url";
+import { hyperlink, Text } from "@earendil-works/pi-tui";
 
 import { SplitLine } from "../../components/split-line";
 import { loadConfig } from "../../config";
 import { formatContextUsage, formatCost, formatCwd, sanitizeText } from "../../utils/format";
-import { isFreeModel } from "../../utils/model";
 import { getEntryUsage } from "../../utils/usage";
 
-import { hyperlink } from "@earendil-works/pi-tui";
-
 import type { ExtensionContext, ExtensionAPI, ReadonlyFooterDataProvider, Theme } from "@earendil-works/pi-coding-agent";
 import type { Component } from "@earendil-works/pi-tui";
+import type { StatusPosition } from "./config";
+
+const DEFAULT_STATUS_POSITION: StatusPosition = "inline";
 
 class FooterComponent implements Component {
   private ctx: ExtensionContext;
   private theme: Theme;
   private footerData: ReadonlyFooterDataProvider;
+  private statusPosition: StatusPosition;
 
-  constructor(ctx: ExtensionContext, theme: Theme, footerData: ReadonlyFooterDataProvider) {
+  constructor(ctx: ExtensionContext, theme: Theme, footerData: ReadonlyFooterDataProvider, statusPosition: StatusPosition = DEFAULT_STATUS_POSITION) {
     this.ctx = ctx;
     this.theme = theme;
     this.footerData = footerData;
+    this.statusPosition = statusPosition;
   }
 
   invalidate(): void {
@@ -32,7 +35,14 @@ class FooterComponent implements Component {
     const left = this.getLeft();
     const right = this.getRight();
 
-    return new SplitLine(left, right, { primarySide: "right", ellipsis: this.theme.fg("dim", "…") }).render(width);
+    const lines = new SplitLine(left, right, { primarySide: "right", ellipsis: this.theme.fg("dim", "…") }).render(width);
+
+    if (this.statusPosition === "below") {
+      const statusesText = this.getStatusesText();
+      if (statusesText) lines.push(...new Text(statusesText, 0, 0).render(width));
+    }
+
+    return lines;
   }
 
   private getLeft(): string {
@@ -46,7 +56,7 @@ class FooterComponent implements Component {
   }
 
   private getRight(): string {
-    const statusesText = this.getStatusesText();
+    const statusesText = this.statusPosition === "inline" ? this.getStatusesText() : "";
     const styledCostText = this.getStyledCostText();
     const styledContextUsageText = this.getStyledContextUsageText();
 
@@ -67,8 +77,8 @@ class FooterComponent implements Component {
   private getStyledCostText(): string {
     const totalCost = this.ctx.sessionManager.getBranch().reduce((acc, entry) => acc + (getEntryUsage(entry)?.cost.total ?? 0), 0);
 
-    // Hide cost when it's zero and the current model is free.
-    if (totalCost === 0 && this.ctx.model && isFreeModel(this.ctx.model)) return "";
+    // Hide cost below half a cent, since it would render as $0.00.
+    if (totalCost < 0.005) return "";
 
     const costText = formatCost(totalCost);
 
@@ -92,6 +102,6 @@ export function registerFooter(pi: ExtensionAPI): void {
     const config = loadConfig(ctx).footer;
     if (!ctx.hasUI || !config) return;
 
-    ctx.ui.setFooter((_tui, theme, footerData) => new FooterComponent(ctx, theme, footerData));
+    ctx.ui.setFooter((_tui, theme, footerData) => new FooterComponent(ctx, theme, footerData, config.statusPosition));
   });
 }

package/src/features/fullscreen/filler.ts

@@ -7,11 +7,53 @@ import type { Component, TUI } from "@earendil-works/pi-tui";
 export class BottomFiller implements Component {
   private tui: TUI;
   private measuring = false;
+  private statusContainer?: Component;
+  private originalStatusRender?: Component["render"];
+  private patchedStatusRender?: Component["render"];
 
   constructor(tui: TUI) {
     this.tui = tui;
   }
 
+  /**
+   * Suppress Pi's two-line idle status placeholder while leaving active status
+   * indicators and `clearOnShrink` unchanged.
+   *
+   * Pi added the placeholder to prevent status indicators from shrinking the TUI in
+   * [#6026](https://github.com/earendil-works/pi/pull/6026). Fullscreen already stabilizes short
+   * layouts with this filler, while in long layouts the placeholder surfaces as blank space above
+   * the editor. This render wrapper specifically counteracts that placeholder without hiding real
+   * statuses.
+   */
+  suppressIdleStatus(): void {
+    if (this.patchedStatusRender) return;
+
+    const widgetIndex = this.tui.children.findIndex((child) => "children" in child && Array.isArray(child.children) && child.children.includes(this));
+    if (widgetIndex <= 0) return;
+
+    const statusContainer = this.tui.children[widgetIndex - 1];
+    if (!statusContainer) return;
+
+    const originalRender = statusContainer.render;
+    const patchedRender = (width: number): string[] => {
+      const lines = originalRender.call(statusContainer, width);
+      return lines.length === 2 && lines.every((line) => line === " ".repeat(width)) ? [] : lines;
+    };
+
+    statusContainer.render = patchedRender;
+    this.statusContainer = statusContainer;
+    this.originalStatusRender = originalRender;
+    this.patchedStatusRender = patchedRender;
+  }
+
+  dispose(): void {
+    const statusContainer = this.statusContainer;
+    const originalStatusRender = this.originalStatusRender;
+    if (statusContainer && originalStatusRender && statusContainer.render === this.patchedStatusRender) {
+      statusContainer.render = originalStatusRender;
+    }
+  }
+
   invalidate(): void {
     // No-op
   }

package/src/features/fullscreen/index.ts

@@ -50,14 +50,17 @@ export function registerFullscreen(pi: ExtensionAPI): void {
     ctx.ui.setWidget(WIDGET_KEY, (capturedTui) => {
       tui = capturedTui;
 
-      // Defer the entry clear to a microtask: the filler isn't in the render tree until
-      // `setWidget` returns, and `session_start` has no TUI to repaint with yet.
-      if (pendingClear) {
-        pendingClear = false;
-        queueMicrotask(() => capturedTui.requestRender(true));
-      }
-
-      return new BottomFiller(capturedTui);
+      const filler = new BottomFiller(capturedTui);
+      const shouldClear = pendingClear;
+      pendingClear = false;
+
+      // Defer setup until `setWidget` has mounted the filler in the render tree.
+      queueMicrotask(() => {
+        filler.suppressIdleStatus();
+        if (shouldClear) capturedTui.requestRender(true);
+      });
+
+      return filler;
     });
   });
 
@@ -76,6 +79,7 @@ export function registerFullscreen(pi: ExtensionAPI): void {
       tui.terminal.write(`${line}\r\n`);
     }
 
+    ctx.ui.setWidget(WIDGET_KEY, undefined);
     tui = undefined;
     enabled = false;
     pendingClear = false;

package/src/features/presets/config.ts

@@ -2,7 +2,8 @@ import * as z from "zod";
 
 import { modelSchema } from "../../config/model";
 
+export type PresetConfig = z.infer<typeof modelSchema>;
+
 export const presetsConfigSchema = z.record(z.string().min(1), modelSchema);
 
 export type PresetsConfig = z.infer<typeof presetsConfigSchema>;
-export type PresetConfig = PresetsConfig[string];

package/src/features/presets/manager.ts

@@ -2,7 +2,7 @@ import { PRESET_CHANGE } from "../../events";
 import { formatModel } from "../../utils/format";
 
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
-import type { PresetsConfig, PresetConfig } from "./config";
+import type { PresetConfig, PresetsConfig } from "./config";
 
 export class PresetManager {
   private pi: ExtensionAPI;

package/src/utils/model.ts

@@ -26,11 +26,6 @@ type ThinkingLevelSelection = {
   warning: string | undefined;
 };
 
-/** Check if a model has zero costs for all categories. */
-export function isFreeModel(model: Model<Api>): boolean {
-  return model.cost.input === 0 && model.cost.output === 0 && model.cost.cacheRead === 0 && model.cost.cacheWrite === 0;
-}
-
 /**
  * Complete a one-shot background request, using an isolated session for OpenAI Codex models.
  * See [the investigation](../../docs/background-model-calls-and-openai-codex-sessions.md).