@aliou/pi-synthetic 0.4.7 → 0.5.0

package/package.json

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

package/src/commands/quotas.ts

@@ -3,7 +3,7 @@ import type { Component } from "@mariozechner/pi-tui";
 import { QuotasDisplayComponent } from "../components/quotas-display";
 import { QuotasErrorComponent } from "../components/quotas-error";
 import { QuotasLoadingComponent } from "../components/quotas-loading";
-import type { QuotasResponse } from "../types/quotas";
+import { fetchQuotas } from "../utils/quotas";
 
 export function registerQuotasCommand(pi: ExtensionAPI): void {
   pi.registerCommand("synthetic:quotas", {
@@ -20,7 +20,13 @@ export function registerQuotasCommand(pi: ExtensionAPI): void {
                 "Failed to fetch quotas",
               );
             } else {
-              currentComponent = new QuotasDisplayComponent(theme, quotas);
+              currentComponent = new QuotasDisplayComponent(
+                theme,
+                quotas,
+                () => {
+                  done(null);
+                },
+              );
             }
             tui.requestRender();
           })
@@ -35,90 +41,28 @@ export function registerQuotasCommand(pi: ExtensionAPI): void {
         return {
           render: (width: number) => currentComponent.render(width),
           invalidate: () => currentComponent.invalidate(),
-          handleInput: (_data: string) => {
+          handleInput: (data: string) => {
+            if (currentComponent.handleInput) {
+              return currentComponent.handleInput(data);
+            }
             done(null);
+            return true;
           },
         };
       });
 
-      // RPC fallback: custom() returned undefined
+      // RPC fallback: return JSON
       if (result === undefined) {
         const quotas = await fetchQuotas();
         if (!quotas) {
-          ctx.ui.notify("Failed to fetch quotas", "error");
+          ctx.ui.notify(
+            JSON.stringify({ error: "Failed to fetch quotas" }),
+            "error",
+          );
           return;
         }
-        ctx.ui.notify(formatQuotasPlain(quotas), "info");
+        ctx.ui.notify(JSON.stringify(quotas, null, 2), "info");
       }
     },
   });
 }
-
-async function fetchQuotas(): Promise<QuotasResponse | null> {
-  const apiKey = process.env.SYNTHETIC_API_KEY;
-  if (!apiKey) {
-    return null;
-  }
-
-  try {
-    const response = await fetch("https://api.synthetic.new/v2/quotas", {
-      headers: {
-        Authorization: `Bearer ${apiKey}`,
-      },
-    });
-
-    if (!response.ok) {
-      return null;
-    }
-
-    return (await response.json()) as QuotasResponse;
-  } catch {
-    return null;
-  }
-}
-
-function formatQuotasPlain(quotas: QuotasResponse): string {
-  const remaining = quotas.subscription.limit - quotas.subscription.requests;
-  const percentUsed = Math.round(
-    (quotas.subscription.requests / quotas.subscription.limit) * 100,
-  );
-
-  return [
-    "Synthetic API Quotas",
-    "",
-    `Usage: ${percentUsed}%`,
-    `Limit: ${quotas.subscription.limit.toLocaleString()} requests`,
-    `Used: ${quotas.subscription.requests.toLocaleString()} requests`,
-    `Remaining: ${remaining.toLocaleString()} requests`,
-    "",
-    `Renews: ${quotas.subscription.renewsAt} (${formatRelativeTime(new Date(quotas.subscription.renewsAt))})`,
-  ].join("\n");
-}
-
-function formatRelativeTime(date: Date): string {
-  const now = new Date();
-  const diffMs = date.getTime() - now.getTime();
-
-  if (diffMs <= 0) {
-    return "renews soon";
-  }
-
-  const rtf = new Intl.RelativeTimeFormat("en", { numeric: "auto" });
-  const diffMinutes = Math.ceil(diffMs / (1000 * 60));
-  const diffHours = Math.ceil(diffMs / (1000 * 60 * 60));
-  const diffDays = Math.ceil(diffMs / (1000 * 60 * 60 * 24));
-
-  if (diffMinutes < 60) {
-    return rtf.format(diffMinutes, "minute");
-  } else if (diffHours < 24) {
-    return rtf.format(diffHours, "hour");
-  } else if (diffDays < 30) {
-    return rtf.format(diffDays, "day");
-  } else if (diffDays < 365) {
-    const months = Math.floor(diffDays / 30);
-    return rtf.format(months, "month");
-  } else {
-    const years = Math.floor(diffDays / 365);
-    return rtf.format(years, "year");
-  }
-}

package/src/components/quotas-display.ts

@@ -1,139 +1,240 @@
 import type { Theme } from "@mariozechner/pi-coding-agent";
-import { DynamicBorder } from "@mariozechner/pi-coding-agent";
-import { type Component, Container, Text } from "@mariozechner/pi-tui";
+import type { Component, TUI } from "@mariozechner/pi-tui";
+import { matchesKey } from "@mariozechner/pi-tui";
 import type { QuotasResponse } from "../types/quotas";
+import { TabbedScrollablePanel } from "./tabbed-panel";
 
 export class QuotasDisplayComponent implements Component {
-  private container: Container;
-
-  constructor(theme: Theme, quotas: QuotasResponse) {
-    this.container = new Container();
-    const border = new DynamicBorder((s: string) => theme.fg("accent", s));
-
-    this.container.addChild(border);
-    this.container.addChild(
-      new Text(theme.fg("accent", theme.bold(" Synthetic API Quotas ")), 1, 0),
-    );
-    this.container.addChild(new Text("", 0, 0));
-
-    const remaining = quotas.subscription.limit - quotas.subscription.requests;
-    const percentUsed = Math.round(
-      (quotas.subscription.requests / quotas.subscription.limit) * 100,
+  private panel: TabbedScrollablePanel;
+  private onClose: () => void;
+
+  constructor(theme: Theme, quotas: QuotasResponse, onClose: () => void) {
+    this.onClose = onClose;
+
+    this.panel = new TabbedScrollablePanel(
+      {
+        title: "Synthetic API Quotas",
+        tabs: [
+          {
+            label: "Completions",
+            buildContent: () =>
+              buildHybridLayout(theme, quotas.subscription, 5), // 5-hour window
+          },
+          {
+            label: "Search",
+            buildContent: () =>
+              buildHybridLayout(theme, quotas.search.hourly, 1), // 1 hour
+          },
+          {
+            label: "Free tool call",
+            buildContent: () =>
+              buildToolCallsLayout(theme, quotas.freeToolCalls, 24), // 24 hours (daily)
+          },
+        ],
+        onClose: onClose,
+      },
+      null as unknown as TUI,
+      theme,
     );
+  }
 
-    // Usage bar: left side = used (colored by severity), right side = remaining (neutral)
-    const barWidth = 40;
-    const usedWidth = Math.round((percentUsed / 100) * barWidth);
-    const remainingWidth = barWidth - usedWidth;
-
-    let bar: string;
-    if (usedWidth >= barWidth) {
-      bar = theme.fg("error", "█".repeat(barWidth));
-    } else if (percentUsed > 75) {
-      // High usage: used is warning, remaining is dim
-      bar =
-        theme.fg("warning", "█".repeat(usedWidth)) +
-        theme.fg("dim", "█".repeat(remainingWidth));
-    } else {
-      // Normal usage: used is success, remaining is dim
-      bar =
-        theme.fg("success", "█".repeat(usedWidth)) +
-        theme.fg("dim", "█".repeat(remainingWidth));
+  handleInput(data: string): boolean {
+    if (matchesKey(data, "escape") || data === "q") {
+      this.onClose();
+      return true;
     }
+    return this.panel.handleInput(data);
+  }
 
-    this.container.addChild(new Text(`  ${theme.bold("Usage")}`, 1, 0));
-    this.container.addChild(new Text(`  ${bar} ${percentUsed}%`, 1, 0));
-    this.container.addChild(new Text("", 0, 0));
-
-    // Numbers - aligned columns
-    const limitStr = quotas.subscription.limit.toLocaleString();
-    const usedStr = quotas.subscription.requests.toLocaleString();
-    const remainingStr = remaining.toLocaleString();
-    const maxValueWidth = Math.max(
-      limitStr.length,
-      usedStr.length,
-      remainingStr.length,
-    );
+  render(width: number): string[] {
+    return this.panel.render(width);
+  }
 
-    this.container.addChild(
-      new Text(
-        `  ${theme.fg("muted", "Limit:")}     ${limitStr.padStart(maxValueWidth, " ")} requests`,
-        1,
-        0,
-      ),
-    );
-    this.container.addChild(
-      new Text(
-        `  ${theme.fg("muted", "Used:")}      ${usedStr.padStart(maxValueWidth, " ")} requests`,
-        1,
-        0,
-      ),
-    );
-    this.container.addChild(
-      new Text(
-        `  ${theme.fg("muted", "Remaining:")} ${theme.fg(
-          remaining > 0 ? "success" : "error",
-          remainingStr.padStart(maxValueWidth, " "),
-        )} requests`,
-        1,
-        0,
-      ),
-    );
-    this.container.addChild(new Text("", 0, 0));
-
-    // Renewal date - ISO8601 with relative time
-    const renewsAt = new Date(quotas.subscription.renewsAt);
-    const isoStr = quotas.subscription.renewsAt;
-    const relativeStr = formatRelativeTime(renewsAt);
-
-    this.container.addChild(
-      new Text(
-        `  ${theme.fg("muted", "Renews:")}    ${isoStr} (${relativeStr})`,
-        1,
-        0,
-      ),
-    );
+  invalidate(): void {
+    this.panel.invalidate();
+  }
+}
 
-    this.container.addChild(new Text("", 0, 0));
-    this.container.addChild(
-      new Text(theme.fg("dim", "  Press any key to close"), 1, 0),
-    );
-    this.container.addChild(border);
+// Layout: bar + pct/cur-total + pace/reset
+function buildHybridLayout(
+  theme: Theme,
+  quota: { limit: number; requests: number; renewsAt: string },
+  periodHours: number,
+): string[] {
+  const percentUsed = Math.round((quota.requests / quota.limit) * 100);
+  const renewsAt = new Date(quota.renewsAt);
+  const now = new Date();
+
+  const lines: string[] = [];
+  const barWidth = 50;
+
+  const usedStr = quota.requests.toLocaleString();
+  const limitStr = quota.limit.toLocaleString();
+
+  // Color based on usage
+  const usedColor =
+    percentUsed >= 100 ? "error" : percentUsed > 75 ? "warning" : "success";
+
+  // Calculate pace with known period
+  const totalPeriod = periodHours * 60 * 60 * 1000;
+  const timeUntilReset = Math.max(0, renewsAt.getTime() - now.getTime());
+  const timeElapsed = totalPeriod - timeUntilReset;
+  const percentTimeElapsed = (timeElapsed / totalPeriod) * 100;
+  const paceDiff = percentUsed - percentTimeElapsed;
+
+  let paceStr: string;
+  let paceColor: "success" | "dim" | "error";
+  if (paceDiff < -10) {
+    paceStr = `${Math.round(Math.abs(paceDiff))}% behind pace`;
+    paceColor = "success";
+  } else if (paceDiff > 10) {
+    paceStr = `${Math.round(paceDiff)}% ahead of pace`;
+    paceColor = "error";
+  } else {
+    paceStr = "within pace";
+    paceColor = "dim";
   }
 
-  render(width: number): string[] {
-    return this.container.render(width);
+  // Row above bar: pct left, cur/total right
+  const pctStr = `${percentUsed}% used`;
+  const totalDisplay = `${usedStr}/${limitStr}`;
+  const spacing = " ".repeat(
+    Math.max(1, barWidth - pctStr.length - totalDisplay.length),
+  );
+  lines.push(
+    `  ${theme.fg(usedColor, pctStr)}${spacing}${theme.fg("dim", totalDisplay)}`,
+  );
+
+  // Bar
+  const usedWidth = Math.round((percentUsed / 100) * barWidth);
+  let bar: string;
+  if (usedWidth >= barWidth) {
+    bar = theme.fg("error", "█".repeat(barWidth));
+  } else if (percentUsed > 75) {
+    bar =
+      theme.fg("warning", "█".repeat(usedWidth)) +
+      theme.fg("dim", "█".repeat(barWidth - usedWidth));
+  } else {
+    bar =
+      theme.fg("success", "█".repeat(usedWidth)) +
+      theme.fg("dim", "█".repeat(barWidth - usedWidth));
   }
+  lines.push(`  ${bar}`);
+
+  // Row below bar: pace left, reset right
+  const resetStr = formatShortTime(renewsAt);
+  const paceSpacing = " ".repeat(
+    Math.max(1, barWidth - paceStr.length - resetStr.length),
+  );
+  lines.push(
+    `  ${theme.fg(paceColor, paceStr)}${paceSpacing}${theme.fg("dim", resetStr)}`,
+  );
+
+  return lines;
+}
 
-  invalidate(): void {
-    this.container.invalidate();
+// Layout for free tool calls - shows remaining, not usage
+function buildToolCallsLayout(
+  theme: Theme,
+  quota: { limit: number; requests: number; renewsAt: string },
+  periodHours: number,
+): string[] {
+  const remaining = quota.limit - quota.requests;
+  const percentRemaining = Math.round((remaining / quota.limit) * 100);
+  const renewsAt = new Date(quota.renewsAt);
+  const now = new Date();
+
+  const lines: string[] = [];
+  const barWidth = 50;
+
+  const remainingStr = remaining.toLocaleString();
+
+  // Color based on remaining (inverse of usage)
+  const remainingColor =
+    remaining <= 0 ? "error" : percentRemaining < 25 ? "warning" : "success";
+
+  // Calculate pace (how fast you're consuming free calls)
+  const totalPeriod = periodHours * 60 * 60 * 1000;
+  const timeUntilReset = Math.max(0, renewsAt.getTime() - now.getTime());
+  const timeElapsed = totalPeriod - timeUntilReset;
+  const percentTimeElapsed = (timeElapsed / totalPeriod) * 100;
+  const expectedRemaining = Math.round(
+    quota.limit * (1 - percentTimeElapsed / 100),
+  );
+  const remainingDiff = remaining - expectedRemaining;
+
+  let paceStr: string;
+  let paceColor: "success" | "dim" | "error";
+  if (remainingDiff > quota.limit * 0.1) {
+    paceStr = `${remainingDiff.toLocaleString()} more than expected`;
+    paceColor = "success";
+  } else if (remainingDiff < -quota.limit * 0.1) {
+    paceStr = `${Math.abs(remainingDiff).toLocaleString()} fewer than expected`;
+    paceColor = "error";
+  } else {
+    paceStr = "on track";
+    paceColor = "dim";
+  }
+
+  // Row above bar: pct remaining left, ratio right (like other tabs)
+  const pctStr = `${percentRemaining}% remaining`;
+  const ratioStr = `${remainingStr}/${quota.limit.toLocaleString()}`;
+  const spacing = " ".repeat(
+    Math.max(1, barWidth - pctStr.length - ratioStr.length),
+  );
+  lines.push(
+    `  ${theme.fg(remainingColor, pctStr)}${spacing}${theme.fg("dim", ratioStr)}`,
+  );
+
+  // Bar (shows remaining, not used - so full bar = all remaining)
+  const remainingWidth = Math.round((percentRemaining / 100) * barWidth);
+  let bar: string;
+  if (remaining <= 0) {
+    bar = theme.fg("dim", "█".repeat(barWidth));
+  } else if (percentRemaining < 25) {
+    bar =
+      theme.fg("warning", "█".repeat(remainingWidth)) +
+      theme.fg("dim", "█".repeat(barWidth - remainingWidth));
+  } else {
+    bar =
+      theme.fg("success", "█".repeat(remainingWidth)) +
+      theme.fg("dim", "█".repeat(barWidth - remainingWidth));
   }
+  lines.push(`  ${bar}`);
+
+  // Row below bar: pace left, reset right
+  const resetStr = formatShortTime(renewsAt);
+  const paceSpacing = " ".repeat(
+    Math.max(1, barWidth - paceStr.length - resetStr.length),
+  );
+  lines.push(
+    `  ${theme.fg(paceColor, paceStr)}${paceSpacing}${theme.fg("dim", resetStr)}`,
+  );
+
+  // If depleted, show note about paid calls
+  if (remaining <= 0) {
+    lines.push(`  ${theme.fg("dim", "Additional calls will be charged")}`);
+  }
+
+  return lines;
 }
 
-function formatRelativeTime(date: Date): string {
+function formatShortTime(date: Date): string {
   const now = new Date();
   const diffMs = date.getTime() - now.getTime();
 
   if (diffMs <= 0) {
-    return "renews soon";
+    return "soon";
   }
 
-  const rtf = new Intl.RelativeTimeFormat("en", { numeric: "auto" });
-  const diffMinutes = Math.ceil(diffMs / (1000 * 60));
   const diffHours = Math.ceil(diffMs / (1000 * 60 * 60));
   const diffDays = Math.ceil(diffMs / (1000 * 60 * 60 * 24));
 
-  if (diffMinutes < 60) {
-    return rtf.format(diffMinutes, "minute");
-  } else if (diffHours < 24) {
-    return rtf.format(diffHours, "hour");
-  } else if (diffDays < 30) {
-    return rtf.format(diffDays, "day");
-  } else if (diffDays < 365) {
-    const months = Math.floor(diffDays / 30);
-    return rtf.format(months, "month");
+  if (diffHours < 24) {
+    return `in ${diffHours}h`;
+  } else if (diffDays < 7) {
+    return `in ${diffDays}d`;
   } else {
-    const years = Math.floor(diffDays / 365);
-    return rtf.format(years, "year");
+    return date.toLocaleDateString("en-US", { month: "short", day: "numeric" });
   }
 }

package/src/components/tabbed-panel.ts

@@ -0,0 +1,161 @@
+import type { Theme } from "@mariozechner/pi-coding-agent";
+import { DynamicBorder } from "@mariozechner/pi-coding-agent";
+import type { Component, TUI } from "@mariozechner/pi-tui";
+import { matchesKey, truncateToWidth } from "@mariozechner/pi-tui";
+
+export interface PanelTab {
+  label: string;
+  buildContent: () => string[];
+}
+
+export interface TabbedScrollablePanelOptions {
+  title: string;
+  tabs: PanelTab[];
+  onClose: () => void;
+  maxVisible?: number;
+  keymap?: "vim" | "default";
+}
+
+export class TabbedScrollablePanel implements Component {
+  private activeTab = 0;
+  private scrollOffset = 0;
+  private cachedLines: string[] | null = null;
+  private cachedWidth = 0;
+  private border: DynamicBorder;
+  private options: TabbedScrollablePanelOptions;
+  private theme: Theme;
+
+  constructor(options: TabbedScrollablePanelOptions, _tui: TUI, theme: Theme) {
+    this.options = options;
+    this.theme = theme;
+    this.border = new DynamicBorder((segment) => theme.fg("border", segment));
+  }
+
+  handleInput(data: string): boolean {
+    if (matchesKey(data, "escape") || data === "q") {
+      this.options.onClose();
+      return true;
+    }
+
+    if (matchesKey(data, "tab")) {
+      this.activeTab = (this.activeTab + 1) % this.options.tabs.length;
+      this.scrollOffset = 0;
+      this.invalidate();
+      return true;
+    }
+
+    if (matchesKey(data, "shift+tab")) {
+      this.activeTab =
+        (this.activeTab - 1 + this.options.tabs.length) %
+        this.options.tabs.length;
+      this.scrollOffset = 0;
+      this.invalidate();
+      return true;
+    }
+
+    const maxVisible = this.options.maxVisible ?? 16;
+    const totalLines = this.cachedLines?.length ?? 0;
+    const maxScroll = Math.max(0, totalLines - maxVisible);
+
+    if (data === "j" || matchesKey(data, "down")) {
+      if (this.scrollOffset < maxScroll) {
+        this.scrollOffset++;
+      }
+      return true;
+    }
+
+    if (data === "k" || matchesKey(data, "up")) {
+      if (this.scrollOffset > 0) {
+        this.scrollOffset--;
+      }
+      return true;
+    }
+
+    if (data === " " || matchesKey(data, "pageDown")) {
+      this.scrollOffset = Math.min(this.scrollOffset + maxVisible, maxScroll);
+      return true;
+    }
+
+    if (matchesKey(data, "pageUp")) {
+      this.scrollOffset = Math.max(0, this.scrollOffset - maxVisible);
+      return true;
+    }
+
+    if (matchesKey(data, "home")) {
+      this.scrollOffset = 0;
+      return true;
+    }
+
+    if (matchesKey(data, "end")) {
+      this.scrollOffset = maxScroll;
+      return true;
+    }
+
+    return false;
+  }
+
+  invalidate(): void {
+    this.cachedLines = null;
+    this.cachedWidth = 0;
+  }
+
+  render(width: number): string[] {
+    const tab = this.options.tabs[this.activeTab];
+
+    if (!this.cachedLines || this.cachedWidth !== width) {
+      this.cachedLines = tab ? tab.buildContent() : [];
+      this.cachedWidth = width;
+    }
+
+    const lines: string[] = [];
+
+    lines.push(...this.border.render(width));
+    lines.push(
+      truncateToWidth(
+        ` ${this.theme.fg("accent", this.theme.bold(this.options.title))}`,
+        width,
+      ),
+    );
+    lines.push(this.renderTabBar(width));
+    lines.push("");
+
+    // Content - no forced padding, just render what we have
+    for (const line of this.cachedLines) {
+      lines.push(truncateToWidth(`  ${line}`, width));
+    }
+
+    // Footer directly after content
+    lines.push("");
+    lines.push(
+      truncateToWidth(
+        this.theme.fg("dim", "  Tab/S-Tab switch tabs  q/Esc close"),
+        width,
+      ),
+    );
+    lines.push(...this.border.render(width));
+
+    return lines;
+  }
+
+  private renderTabBar(width: number): string {
+    const parts: string[] = [];
+
+    for (let i = 0; i < this.options.tabs.length; i++) {
+      const tab = this.options.tabs[i];
+      if (!tab) continue;
+      const active = i === this.activeTab;
+
+      if (active) {
+        parts.push(this.theme.fg("accent", this.theme.bold(` ${tab.label} `)));
+      } else {
+        parts.push(this.theme.fg("dim", ` ${tab.label} `));
+      }
+
+      if (i < this.options.tabs.length - 1) {
+        parts.push(this.theme.fg("borderMuted", "│"));
+      }
+    }
+
+    return truncateToWidth(`  ${parts.join("")}`, width);
+  }
+}

package/src/hooks/sub-integration.ts

@@ -0,0 +1,145 @@
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import type { QuotasResponse } from "../types/quotas";
+import { fetchQuotas, formatResetTime } from "../utils/quotas";
+
+interface RateWindow {
+  label: string;
+  usedPercent: number;
+  resetDescription?: string;
+  resetAt?: string;
+}
+
+interface UsageSnapshot {
+  provider: string;
+  displayName: string;
+  windows: RateWindow[];
+  lastSuccessAt?: number;
+}
+
+interface SubCoreSettingsPayload {
+  settings?: {
+    behavior?: {
+      refreshInterval: number;
+    };
+  };
+}
+
+function toUsageSnapshot(quotas: QuotasResponse): UsageSnapshot {
+  const windows: RateWindow[] = [];
+
+  if (quotas.subscription) {
+    const pct =
+      (quotas.subscription.requests / quotas.subscription.limit) * 100;
+    windows.push({
+      label: "5h",
+      usedPercent: Math.round(pct),
+      resetDescription: formatResetTime(quotas.subscription.renewsAt),
+      resetAt: quotas.subscription.renewsAt,
+    });
+  }
+
+  if (quotas.search?.hourly) {
+    const pct =
+      (quotas.search.hourly.requests / quotas.search.hourly.limit) * 100;
+    windows.push({
+      label: "Search",
+      usedPercent: Math.round(pct),
+      resetDescription: formatResetTime(quotas.search.hourly.renewsAt),
+      resetAt: quotas.search.hourly.renewsAt,
+    });
+  }
+
+  if (quotas.freeToolCalls) {
+    const pct =
+      (quotas.freeToolCalls.requests / quotas.freeToolCalls.limit) * 100;
+    windows.push({
+      label: "Free",
+      usedPercent: Math.round(pct),
+      resetDescription: formatResetTime(quotas.freeToolCalls.renewsAt),
+      resetAt: quotas.freeToolCalls.renewsAt,
+    });
+  }
+
+  return {
+    provider: "synthetic",
+    displayName: "Synthetic",
+    windows,
+    lastSuccessAt: Date.now(),
+  };
+}
+
+async function emitCurrentUsage(pi: ExtensionAPI): Promise<void> {
+  const quotas = await fetchQuotas();
+  if (!quotas) return;
+  pi.events.emit("sub-core:update-current", {
+    state: { provider: "synthetic", usage: toUsageSnapshot(quotas) },
+  });
+}
+
+export function registerSubIntegration(pi: ExtensionAPI): void {
+  if (!process.env.SYNTHETIC_API_KEY) return;
+
+  let interval: NodeJS.Timeout | undefined;
+  let refreshMs = 60000;
+  let subCoreReady = false;
+  let currentProvider: string | undefined;
+
+  function isSynthetic(): boolean {
+    return currentProvider === "synthetic";
+  }
+
+  function stop(): void {
+    if (interval) {
+      clearInterval(interval);
+      interval = undefined;
+    }
+  }
+
+  function start(): void {
+    stop();
+    if (!subCoreReady || !isSynthetic()) {
+      return;
+    }
+    emitCurrentUsage(pi);
+    const ms = Math.max(10000, refreshMs);
+    interval = setInterval(() => {
+      if (isSynthetic()) emitCurrentUsage(pi);
+    }, ms);
+    interval.unref?.();
+  }
+
+  // Custom events (inter-extension bus)
+  pi.events.on("sub-core:ready", () => {
+    subCoreReady = true;
+    start();
+  });
+
+  pi.events.on("sub-core:settings:updated", (data: unknown) => {
+    const payload = data as SubCoreSettingsPayload;
+    if (payload.settings?.behavior?.refreshInterval) {
+      refreshMs = payload.settings.behavior.refreshInterval * 1000;
+      if (interval) start();
+    }
+  });
+
+  // Lifecycle events (pi.on, not pi.events.on)
+  pi.on("session_start", (_event, ctx) => {
+    currentProvider = ctx.model?.provider;
+    start();
+  });
+
+  pi.on("model_select", (event, _ctx) => {
+    currentProvider = event.model?.provider;
+    if (isSynthetic()) {
+      emitCurrentUsage(pi);
+      start();
+    } else {
+      stop();
+    }
+  });
+
+  pi.on("session_shutdown", () => {
+    currentProvider = undefined;
+    stop();
+  });
+}

package/src/index.ts

@@ -1,6 +1,7 @@
 import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
 import { registerQuotasCommand } from "./commands/quotas";
 import { registerSyntheticWebSearchHooks } from "./hooks/search-tool-availability";
+import { registerSubIntegration } from "./hooks/sub-integration";
 import { registerSyntheticProvider } from "./providers/index";
 import { registerSyntheticWebSearchTool } from "./tools/search";
 
@@ -11,5 +12,6 @@ export default async function (pi: ExtensionAPI) {
 
   if (process.env.SYNTHETIC_API_KEY) {
     registerQuotasCommand(pi);
+    registerSubIntegration(pi);
   }
 }

package/src/providers/models.ts

@@ -235,4 +235,19 @@ export const SYNTHETIC_MODELS: SyntheticModelConfig[] = [
     contextWindow: 262144,
     maxTokens: 32000,
   },
+  // API: hf:Qwen/Qwen3.5-397B-A17B → ctx=262144, out=32000
+  {
+    id: "hf:Qwen/Qwen3.5-397B-A17B",
+    name: "Qwen/Qwen3.5-397B-A17B",
+    reasoning: false,
+    input: ["text"],
+    cost: {
+      input: 0.6,
+      output: 3,
+      cacheRead: 0.6,
+      cacheWrite: 0,
+    },
+    contextWindow: 262144,
+    maxTokens: 32000,
+  },
 ];

package/src/types/quotas.ts

@@ -4,4 +4,16 @@ export interface QuotasResponse {
     requests: number;
     renewsAt: string;
   };
+  search: {
+    hourly: {
+      limit: number;
+      requests: number;
+      renewsAt: string;
+    };
+  };
+  freeToolCalls: {
+    limit: number;
+    requests: number;
+    renewsAt: string;
+  };
 }

package/src/utils/quotas.ts

@@ -0,0 +1,33 @@
+import type { QuotasResponse } from "../types/quotas";
+
+const API_KEY = process.env.SYNTHETIC_API_KEY;
+
+export async function fetchQuotas(): Promise<QuotasResponse | null> {
+  if (!API_KEY) return null;
+
+  try {
+    const response = await fetch("https://api.synthetic.new/v2/quotas", {
+      headers: { Authorization: `Bearer ${API_KEY}` },
+    });
+
+    if (!response.ok) return null;
+    return (await response.json()) as QuotasResponse;
+  } catch {
+    return null;
+  }
+}
+
+export function formatResetTime(renewsAt: string): string {
+  const date = new Date(renewsAt);
+  const now = new Date();
+  const diffMs = date.getTime() - now.getTime();
+
+  if (diffMs <= 0) return "soon";
+
+  const diffHours = Math.ceil(diffMs / (1000 * 60 * 60));
+  const diffDays = Math.ceil(diffMs / (1000 * 60 * 60 * 24));
+
+  if (diffHours < 24) return `in ${diffHours}h`;
+  if (diffDays < 7) return `in ${diffDays}d`;
+  return date.toLocaleDateString("en-US", { month: "short", day: "numeric" });
+}