pi-spark 0.11.1 → 0.12.0

package/README.md

@@ -1,9 +1,12 @@
+![Cover](./assets/cover.png)
+
 # pi-spark
 
-A collection of [pi](https://pi.dev/) extensions that polish the daily pi experience.
+[Pi](https://pi.dev/) extensions that polish the daily experience.
 
 ## Extensions
 
+- **Credits:** shows the active provider's credit balance or rate-limit usage in the status line.
 - **Editor:** replaces the default editor with a compact working indicator (inspired by [Amp](https://ampcode.com/)) and current model info.
 - **Footer:** shows session information, extension statuses, cost, and context usage on one line.
 - **Fullscreen:** clears the screen and scrollback on session start, pins the editor and footer to the bottom for a full-screen session, and clears again on exit.
@@ -22,10 +25,10 @@ Install from npm:
 pi install npm:pi-spark
 ```
 
-For local development from this monorepo:
+For local development from this repo:
 
 ```bash
-pi install /path/to/pi-packages/packages/pi-spark
+pi install /path/to/pi-spark
 ```
 
 ## Configure
@@ -38,6 +41,7 @@ Example:
 
 ```json
 {
+  "credits": false,
   "editor": {
     "spinner": "dots"
   },
@@ -63,6 +67,12 @@ Example:
 }
 ```
 
+### Credits
+
+- pi-spark shows the active provider's credit balance or rate-limit usage in the status line.
+- Supported providers: DeepSeek, Fireworks, Moonshot, OpenAI Codex, OpenRouter, and Vercel AI Gateway.
+- Most provider-specific fetching approaches reference [CodexBar](https://github.com/steipete/codexbar). Fireworks is an exception: its balance lives behind an internal gRPC API, so the approach was reverse-engineered from the `firectl` binary — see [docs/fireworks.md](./docs/fireworks.md).
+
 ### Editor
 
 - `editor.spinner` controls the working indicator style and can be `dots`, `lights`, `tildes`, or `pulse`.
@@ -112,7 +122,3 @@ Use presets in these ways:
 ```
 
 Project trust is an [input-loading guard](https://pi.dev/docs/latest/security#project-trust), so use `"always"` only if you trust the projects you open.
-
-## Other pi packages
-
-See my [pi-packages](https://github.com/zlliang/pi-packages) repo for the full list.

package/extensions/credits/config.ts

@@ -0,0 +1,3 @@
+import * as z from "zod";
+
+export const creditsConfigSchema = z.object({});

package/extensions/credits/index.ts

@@ -0,0 +1,51 @@
+import { CreditsManager } from "./manager";
+import { isUsage } from "./utils";
+import { loadConfig } from "../shared/config";
+
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import type { AgentMessage } from "@earendil-works/pi-agent-core";
+
+function hasCost(message: AgentMessage): boolean {
+  const usage = (message as { usage?: unknown }).usage;
+  if (!isUsage(usage)) return false;
+
+  return usage.cost.total > 0 || usage.input > 0 || usage.output > 0;
+}
+
+export default function (pi: ExtensionAPI) {
+  let creditsManager: CreditsManager | undefined = undefined;
+
+  pi.on("session_start", (_event, ctx) => {
+    if (!ctx.hasUI) return;
+
+    const config = loadConfig(ctx, "credits");
+    if (!config) return;
+
+    creditsManager = new CreditsManager();
+    creditsManager.refresh(ctx);
+  });
+
+  pi.on("model_select", (_event, ctx) => {
+    creditsManager?.refresh(ctx);
+  });
+
+  pi.on("turn_end", (event, ctx) => {
+    if (!hasCost(event.message)) return;
+
+    creditsManager?.refresh(ctx);
+  });
+
+  pi.on("session_compact", (_event, ctx) => {
+    creditsManager?.refresh(ctx);
+  });
+
+  pi.on("session_tree", (event, ctx) => {
+    if (!event.summaryEntry) return;
+
+    creditsManager?.refresh(ctx);
+  });
+
+  pi.on("session_shutdown", () => {
+    creditsManager = undefined;
+  });
+}

package/extensions/credits/manager.ts

@@ -0,0 +1,64 @@
+import { findProvider } from "./providers";
+import { renderCredits, renderError } from "./status";
+
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type { CreditsProvider } from "./types";
+
+const STATUS_KEY = "credits";
+const REQUEST_TIMEOUT_MS = 30_000;
+
+export class CreditsManager {
+  private inflight: AbortController | undefined = undefined;
+  private currentProvider: string | undefined = undefined;
+
+  async refresh(ctx: ExtensionContext): Promise<void> {
+    this.inflight?.abort();
+
+    const provider = findProvider(ctx.model?.provider);
+    if (!provider) {
+      this.inflight = undefined;
+      this.currentProvider = undefined;
+      ctx.ui.setStatus(STATUS_KEY, undefined);
+      return;
+    }
+
+    // Clear stale credits from another provider while the new fetch is in flight.
+    if (this.currentProvider !== provider.id) {
+      this.currentProvider = provider.id;
+      ctx.ui.setStatus(STATUS_KEY, undefined);
+    }
+
+    const controller = new AbortController();
+    this.inflight = controller;
+
+    await this.fetch(ctx, provider, controller.signal).finally(() => {
+      if (this.inflight === controller) this.inflight = undefined;
+    });
+  }
+
+  private async fetch(ctx: ExtensionContext, provider: CreditsProvider, signal: AbortSignal): Promise<void> {
+    try {
+      const apiKey = await ctx.modelRegistry.getApiKeyForProvider(provider.id);
+      if (!apiKey) {
+        ctx.ui.setStatus(STATUS_KEY, undefined);
+        return;
+      }
+
+      const signals = [AbortSignal.timeout(REQUEST_TIMEOUT_MS), signal];
+      if (ctx.signal) signals.push(ctx.signal);
+
+      const credits = await provider.fetch(ctx, apiKey, AbortSignal.any(signals));
+
+      // The active model may have changed while the request was in flight.
+      if (ctx.model?.provider !== provider.id) return;
+
+      ctx.ui.setStatus(STATUS_KEY, renderCredits(ctx.ui.theme, provider.label, credits));
+    } catch (error) {
+      if (signal.aborted || ctx.signal?.aborted) return;
+      if (ctx.model?.provider !== provider.id) return;
+
+      const message = error instanceof Error ? error.message : String(error);
+      ctx.ui.setStatus(STATUS_KEY, renderError(ctx.ui.theme, provider.label, message));
+    }
+  }
+}

package/extensions/credits/providers/deepseek.ts

@@ -0,0 +1,36 @@
+import { convertToUSD, toNumber } from "../utils";
+
+import type { Credits, CreditsProvider } from "../types";
+
+const PROVIDER = "deepseek";
+const URL = "https://api.deepseek.com/user/balance";
+
+interface DeepSeekBalanceResponse {
+  balance_infos?: DeepSeekBalanceInfo[] | null;
+}
+
+interface DeepSeekBalanceInfo {
+  currency?: string;
+  total_balance?: string | number;
+}
+
+export const deepseekProvider: CreditsProvider = {
+  id: PROVIDER,
+  label: "DeepSeek",
+
+  async fetch(_ctx, apiKey, signal): Promise<Credits> {
+    const headers: Record<string, string> = {
+      Accept: "application/json",
+      Authorization: `Bearer ${apiKey}`,
+    };
+
+    const response = await fetch(URL, { headers, signal });
+    if (!response.ok) throw new Error("request failed");
+
+    const payload = (await response.json()) as DeepSeekBalanceResponse;
+    const balance = payload.balance_infos?.find((entry) => entry.currency === "USD") ?? payload.balance_infos?.[0];
+    const remaining = await convertToUSD(toNumber(balance?.total_balance), balance?.currency, signal);
+
+    return { type: "balance", remaining };
+  },
+};

package/extensions/credits/providers/fireworks.proto

@@ -0,0 +1,42 @@
+syntax = "proto3";
+
+// Minimal slice of the Fireworks control-plane gateway API (`gateway.Gateway`), reconstructed from
+// the `firectl` binary. Only the messages and RPCs needed to read an account's credit balance are
+// declared here.
+package gateway;
+
+// Mirrors google.type.Money.
+message Money {
+  string currency_code = 1;
+  int64 units = 2;
+  int32 nanos = 3;
+}
+
+message Balance {
+  Money money = 1;
+}
+
+message GetBalanceRequest {
+  string name = 1; // resource name, e.g., "accounts/<account_id>"
+}
+
+message Account {
+  string name = 1; // resource name, e.g., "accounts/<account_id>"
+  string display_name = 2;
+}
+
+message ListAccountsRequest {
+  int32 page_size = 1;
+  string page_token = 2;
+}
+
+message ListAccountsResponse {
+  repeated Account accounts = 1;
+  string next_page_token = 2;
+  int32 total_size = 3;
+}
+
+service Gateway {
+  rpc ListAccounts(ListAccountsRequest) returns (ListAccountsResponse);
+  rpc GetBalance(GetBalanceRequest) returns (Balance);
+}

package/extensions/credits/providers/fireworks.ts

@@ -0,0 +1,111 @@
+import { fileURLToPath } from "node:url";
+
+import { credentials, loadPackageDefinition, Metadata } from "@grpc/grpc-js";
+import { loadSync } from "@grpc/proto-loader";
+
+import { toNumber } from "../utils";
+
+import type { ClientUnaryCall, ServiceClientConstructor, ServiceError } from "@grpc/grpc-js";
+import type { Credits, CreditsProvider } from "../types";
+
+type GatewayClient = InstanceType<ServiceClientConstructor>;
+
+const PROVIDER = "fireworks";
+
+/**
+ * The control-plane gateway is a gRPC service, distinct from the inference API at
+ * `api.fireworks.ai`. Credit balance lives here, behind the `x-api-key` header.
+ */
+const TARGET = "gateway.fireworks.ai:443";
+const DEADLINE_MS = 20_000;
+
+interface Money {
+  currency_code?: string;
+  units?: string | number;
+  nanos?: string | number;
+}
+
+interface Balance {
+  money?: Money | null;
+}
+
+interface Account {
+  name?: string;
+}
+
+interface ListAccountsResponse {
+  accounts?: Account[] | null;
+}
+
+/** gRPC clients are reusable and multiplex over one connection, so build once. */
+let client: GatewayClient | undefined;
+
+/** The API key maps to a fixed account, so cache the resolved resource name. */
+const accountByKey = new Map<string, string>();
+
+function getClient(): GatewayClient {
+  if (client) return client;
+
+  const protoPath = fileURLToPath(new URL("./fireworks.proto", import.meta.url));
+  const definition = loadSync(protoPath, { keepCase: true, longs: String, defaults: true });
+  const proto = loadPackageDefinition(definition) as unknown as { gateway: { Gateway: ServiceClientConstructor } };
+  client = new proto.gateway.Gateway(TARGET, credentials.createSsl());
+
+  return client;
+}
+
+async function unary<T>(method: string, request: object, apiKey: string, signal: AbortSignal): Promise<T> {
+  return new Promise<T>((resolve, reject) => {
+    const metadata = new Metadata();
+    metadata.set("x-api-key", apiKey);
+
+    const deadline = new Date(Date.now() + DEADLINE_MS);
+    const gateway = getClient();
+    const invoke = gateway[method] as (
+      request: object,
+      metadata: Metadata,
+      options: { deadline: Date },
+      callback: (error: ServiceError | null, response: T) => void,
+    ) => ClientUnaryCall;
+
+    const call = invoke.call(gateway, request, metadata, { deadline }, (error, response) => {
+      if (error) reject(new Error(error.details || error.message));
+      else resolve(response);
+    });
+
+    if (signal.aborted) call.cancel();
+    else signal.addEventListener("abort", () => call.cancel(), { once: true });
+  });
+}
+
+async function resolveAccount(apiKey: string, signal: AbortSignal): Promise<string> {
+  const cached = accountByKey.get(apiKey);
+  if (cached) return cached;
+
+  const response = await unary<ListAccountsResponse>("ListAccounts", {}, apiKey, signal);
+  const name = response.accounts?.[0]?.name;
+  if (!name) throw new Error("no account found");
+
+  accountByKey.set(apiKey, name);
+  return name;
+}
+
+function moneyToNumber(money: Money | null | undefined): number | undefined {
+  if (!money) return undefined;
+
+  const units = toNumber(money.units) ?? 0;
+  const nanos = toNumber(money.nanos) ?? 0;
+  return units + nanos / 1e9;
+}
+
+export const fireworksProvider: CreditsProvider = {
+  id: PROVIDER,
+  label: "Fireworks",
+
+  async fetch(_ctx, apiKey, signal): Promise<Credits> {
+    const name = await resolveAccount(apiKey, signal);
+    const balance = await unary<Balance>("GetBalance", { name }, apiKey, signal);
+
+    return { type: "balance", remaining: moneyToNumber(balance.money) };
+  },
+};

package/extensions/credits/providers/index.ts

@@ -0,0 +1,22 @@
+import { deepseekProvider } from "./deepseek";
+import { fireworksProvider } from "./fireworks";
+import { moonshotProvider, moonshotCnProvider } from "./moonshot";
+import { openaiCodexProvider } from "./openai-codex";
+import { openrouterProvider } from "./openrouter";
+import { vercelAiGatewayProvider } from "./vercel-ai-gateway";
+
+import type { CreditsProvider } from "../types";
+
+const PROVIDERS: CreditsProvider[] = [
+  deepseekProvider,
+  fireworksProvider,
+  moonshotProvider,
+  moonshotCnProvider,
+  openaiCodexProvider,
+  openrouterProvider,
+  vercelAiGatewayProvider,
+];
+
+export function findProvider(provider?: string): CreditsProvider | undefined {
+  return PROVIDERS.find((entry) => entry.id === provider);
+}

package/extensions/credits/providers/moonshot.ts

@@ -0,0 +1,39 @@
+import { convertToUSD, toNumber } from "../utils";
+
+import type { Credits, CreditsProvider } from "../types";
+
+interface MoonshotBalanceResponse {
+  data?: {
+    available_balance?: string | number;
+  } | null;
+}
+
+/**
+ * For Moonshot, the international and China-mainland accounts live on separate hosts and bill in
+ * 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 {
+  return {
+    id,
+    label: "Moonshot",
+
+    async fetch(_ctx, apiKey, signal): Promise<Credits> {
+      const headers: Record<string, string> = {
+        Accept: "application/json",
+        Authorization: `Bearer ${apiKey}`,
+      };
+
+      const response = await fetch(`https://${host}/v1/users/me/balance`, { headers, signal });
+      if (!response.ok) throw new Error("request failed");
+
+      const payload = (await response.json()) as MoonshotBalanceResponse;
+      const remaining = await convertToUSD(toNumber(payload.data?.available_balance), currency, signal);
+
+      return { type: "balance", remaining };
+    },
+  };
+}
+
+export const moonshotProvider = createMoonshotProvider("moonshotai", "api.moonshot.ai", "USD");
+export const moonshotCnProvider = createMoonshotProvider("moonshotai-cn", "api.moonshot.cn", "CNY");

package/extensions/credits/providers/openai-codex.ts

@@ -0,0 +1,62 @@
+import { toNumber } from "../utils";
+
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type { Credits, CreditsProvider } from "../types";
+
+const PROVIDER = "openai-codex";
+const URL = "https://chatgpt.com/backend-api/wham/usage";
+
+interface CodexUsageResponse {
+  rate_limit?: {
+    primary_window?: CodexRateWindow | null;
+    secondary_window?: CodexRateWindow | null;
+  } | null;
+  credits?: {
+    unlimited?: boolean;
+  } | null;
+}
+
+interface CodexRateWindow {
+  used_percent?: number | string;
+}
+
+export function getAccountId(ctx: ExtensionContext): string | undefined {
+  const credential = ctx.modelRegistry.authStorage.get(PROVIDER) as { accountId?: string } | undefined;
+  const accountId = credential?.accountId;
+
+  return typeof accountId === "string" && accountId.trim() ? accountId.trim() : undefined;
+}
+
+function parseUsedPercent(window?: CodexRateWindow | null): number | undefined {
+  const value = toNumber(window?.used_percent);
+  return typeof value === "number" ? Math.min(100, Math.max(0, value)) : undefined;
+}
+
+export const openaiCodexProvider: CreditsProvider = {
+  id: PROVIDER,
+  label: "Codex",
+
+  async fetch(ctx, apiKey, signal): Promise<Credits> {
+    const headers: Record<string, string> = {
+      Accept: "application/json",
+      Authorization: `Bearer ${apiKey}`,
+    };
+
+    const accountId = getAccountId(ctx);
+    if (accountId) headers["ChatGPT-Account-Id"] = accountId;
+
+    const response = await fetch(URL, { headers, signal });
+    if (!response.ok) throw new Error("request failed");
+
+    const payload = (await response.json()) as CodexUsageResponse;
+
+    return {
+      type: "windows",
+      unlimited: payload.credits?.unlimited === true,
+      lanes: [
+        { label: "5h", percent: parseUsedPercent(payload.rate_limit?.primary_window) },
+        { label: "7d", percent: parseUsedPercent(payload.rate_limit?.secondary_window) },
+      ],
+    };
+  },
+};

package/extensions/credits/providers/openrouter.ts

@@ -0,0 +1,35 @@
+import { toNumber } from "../utils";
+
+import type { Credits, CreditsProvider } from "../types";
+
+const PROVIDER = "openrouter";
+const URL = "https://openrouter.ai/api/v1/credits";
+
+interface OpenRouterCreditsResponse {
+  data?: {
+    total_credits?: number | null;
+    total_usage?: number | null;
+  } | null;
+}
+
+export const openrouterProvider: CreditsProvider = {
+  id: PROVIDER,
+  label: "OpenRouter",
+
+  async fetch(_ctx, apiKey, signal): Promise<Credits> {
+    const headers: Record<string, string> = {
+      Accept: "application/json",
+      Authorization: `Bearer ${apiKey}`,
+    };
+
+    const response = await fetch(URL, { headers, signal });
+    if (!response.ok) throw new Error("request failed");
+
+    const payload = (await response.json()) as OpenRouterCreditsResponse;
+    const totalCredits = toNumber(payload.data?.total_credits);
+    const totalUsage = toNumber(payload.data?.total_usage);
+    const remaining = typeof totalCredits === "number" && typeof totalUsage === "number" ? totalCredits - totalUsage : undefined;
+
+    return { type: "balance", remaining };
+  },
+};

package/extensions/credits/providers/vercel-ai-gateway.ts

@@ -0,0 +1,30 @@
+import { toNumber } from "../utils";
+
+import type { Credits, CreditsProvider } from "../types";
+
+const PROVIDER = "vercel-ai-gateway";
+const URL = "https://ai-gateway.vercel.sh/v1/credits";
+
+interface VercelCreditsResponse {
+  balance?: string | number;
+}
+
+export const vercelAiGatewayProvider: CreditsProvider = {
+  id: PROVIDER,
+  label: "Vercel",
+
+  async fetch(_ctx, apiKey, signal): Promise<Credits> {
+    const headers: Record<string, string> = {
+      Accept: "application/json",
+      Authorization: `Bearer ${apiKey}`,
+    };
+
+    const response = await fetch(URL, { headers, signal });
+    if (!response.ok) throw new Error("request failed");
+
+    const payload = (await response.json()) as VercelCreditsResponse;
+    const remaining = toNumber(payload.balance);
+
+    return { type: "balance", remaining };
+  },
+};

package/extensions/credits/status.ts

@@ -0,0 +1,43 @@
+import type { Theme } from "@earendil-works/pi-coding-agent";
+import type { Credits, CreditsLane } from "./types";
+
+const WINDOWS_WARNING = 70;
+const WINDOWS_ERROR = 90;
+const BALANCE_WARNING = 10;
+const BALANCE_ERROR = 5;
+
+export function renderCredits(theme: Theme, label: string, credits: Credits): string {
+  const styledLabel = theme.fg("dim", label);
+
+  if (credits.type === "windows") return `${styledLabel} ${renderWindows(theme, credits)}`;
+  return `${styledLabel} ${renderBalance(theme, credits)}`;
+}
+
+export function renderError(theme: Theme, label: string, message: string): string {
+  return theme.fg("error", `${label} credits unavailable: ${message}`);
+}
+
+function renderWindows(theme: Theme, credits: Extract<Credits, { type: "windows" }>): string {
+  const unlimited = credits.unlimited || credits.lanes.every((lane) => lane.percent === undefined);
+  if (unlimited) return theme.fg("success", "unlimited");
+
+  return credits.lanes.map((lane) => renderLane(theme, lane)).join(" ");
+}
+
+function renderLane(theme: Theme, lane: CreditsLane): string {
+  const text = `${lane.label} ${lane.percent === undefined ? "?" : lane.percent.toFixed(0)}%`;
+
+  if (lane.percent && lane.percent > WINDOWS_ERROR) return theme.fg("error", text);
+  if (lane.percent && lane.percent > WINDOWS_WARNING) return theme.fg("warning", text);
+  return theme.fg("success", text);
+}
+
+function renderBalance(theme: Theme, credits: Extract<Credits, { type: "balance" }>): string {
+  if (credits.remaining === undefined) return theme.fg("dim", "$?");
+
+  const text = `$${credits.remaining.toFixed(2)}`;
+
+  if (credits.remaining < BALANCE_ERROR) return theme.fg("error", text);
+  if (credits.remaining < BALANCE_WARNING) return theme.fg("warning", text);
+  return theme.fg("success", text);
+}

package/extensions/credits/types.ts

@@ -0,0 +1,24 @@
+import type { Provider } from "@earendil-works/pi-ai";
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+
+/**
+ * Normalized credits/usage for a provider.
+ *
+ * - `balance` providers (e.g., OpenRouter, Vercel AI Gateway) report a remaining dollar balance.
+ * - `windows` providers (e.g., OpenAI Codex) report rate-limit windows as used percentages.
+ */
+export type Credits =
+  | { type: "balance"; remaining?: number | undefined }
+  | { type: "windows"; lanes: CreditsLane[]; unlimited?: boolean | undefined };
+
+export interface CreditsLane {
+  label: string;
+  percent: number | undefined;
+}
+
+/** A credits source for a pi provider, shown in the status line while that provider is active. */
+export interface CreditsProvider {
+  readonly id: Provider;
+  readonly label: string;
+  fetch(ctx: ExtensionContext, apiKey: string, signal: AbortSignal): Promise<Credits>;
+}

package/extensions/credits/utils.ts

@@ -0,0 +1,52 @@
+import type { Usage } from "@earendil-works/pi-ai";
+
+/** Structural type guard for the pi `Usage` shape. */
+export function isUsage(value: unknown): value is Usage {
+  if (typeof value !== "object" || value === null) return false;
+
+  const usage = value as Record<string, unknown>;
+  const hasTokenFields =
+    typeof usage.input === "number" &&
+    typeof usage.output === "number" &&
+    typeof usage.cacheRead === "number" &&
+    typeof usage.cacheWrite === "number" &&
+    typeof usage.totalTokens === "number";
+  if (!hasTokenFields) return false;
+
+  if (typeof usage.cost !== "object" || usage.cost === null) return false;
+  const cost = usage.cost as Record<string, unknown>;
+  return (
+    typeof cost.input === "number" &&
+    typeof cost.output === "number" &&
+    typeof cost.cacheRead === "number" &&
+    typeof cost.cacheWrite === "number" &&
+    typeof cost.total === "number"
+  );
+}
+
+export function toNumber(value?: string | number | null): number | undefined {
+  if (value === undefined || value === null) return undefined;
+  const parsed = typeof value === "number" ? value : Number(value);
+  return Number.isFinite(parsed) ? parsed : undefined;
+}
+
+const FRANKFURTER_API = "https://api.frankfurter.dev/v2/rate";
+
+interface FrankfurterRateResponse {
+  rate?: string | number;
+}
+
+export async function convertToUSD(amount: number | undefined, currency: string | undefined, signal: AbortSignal): Promise<number | undefined> {
+  if (amount === undefined) return undefined;
+  if (!currency || currency === "USD") return amount;
+
+  const url = `${FRANKFURTER_API}/${encodeURIComponent(currency)}/USD`;
+  const response = await fetch(url, { headers: { Accept: "application/json" }, signal });
+  if (!response.ok) throw new Error("currency conversion failed");
+
+  const payload = (await response.json()) as FrankfurterRateResponse;
+  const rate = toNumber(payload.rate);
+  if (rate === undefined) throw new Error("currency conversion failed");
+
+  return amount * rate;
+}

package/extensions/shared/config/schema.ts

@@ -1,5 +1,6 @@
 import * as z from "zod";
 
+import { creditsConfigSchema } from "../../credits/config";
 import { editorConfigSchema } from "../../editor/config";
 import { footerConfigSchema } from "../../footer/config";
 import { fullscreenConfigSchema } from "../../fullscreen/config";
@@ -9,6 +10,7 @@ import { presetsConfigSchema } from "../../presets/config";
 import { recapConfigSchema } from "../../recap/config";
 
 export const configSchemas = {
+  credits: creditsConfigSchema,
   editor: editorConfigSchema,
   footer: footerConfigSchema,
   fullscreen: fullscreenConfigSchema,

package/package.json

@@ -1,30 +1,35 @@
 {
   "name": "pi-spark",
-  "version": "0.11.1",
-  "description": "A collection of pi extensions that polish the daily pi experience.",
+  "version": "0.12.0",
+  "description": "Pi extensions that polish the daily experience.",
   "keywords": [
     "pi-coding-agent",
     "pi-package"
   ],
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/zlliang/pi-packages.git",
-    "directory": "packages/pi-spark"
+    "url": "git+https://github.com/zlliang/pi-spark.git"
   },
   "license": "MIT",
   "type": "module",
   "files": [
     "extensions",
     "assets",
-    "README.md"
+    "README.md",
+    "LICENSE"
   ],
   "pi": {
     "extensions": [
       "./extensions"
     ],
-    "image": "https://raw.githubusercontent.com/zlliang/pi-packages/main/assets/cover.png"
+    "image": "https://raw.githubusercontent.com/zlliang/pi-spark/main/assets/cover.png"
+  },
+  "scripts": {
+    "typecheck": "tsc --noEmit"
   },
   "dependencies": {
+    "@grpc/grpc-js": "^1.14.4",
+    "@grpc/proto-loader": "^0.8.1",
     "liqe": "^3.8.7",
     "ms": "4.0.0-nightly.202508271359",
     "zod": "^4.4.3"
@@ -35,5 +40,14 @@
     "@earendil-works/pi-coding-agent": "*",
     "@earendil-works/pi-tui": "*",
     "typebox": "*"
+  },
+  "devDependencies": {
+    "@earendil-works/pi-agent-core": "*",
+    "@earendil-works/pi-ai": "*",
+    "@earendil-works/pi-coding-agent": "*",
+    "@earendil-works/pi-tui": "*",
+    "@types/node": "*",
+    "typebox": "*",
+    "typescript": "^6.0.3"
   }
-}
+}