@aliou/pi-synthetic 0.12.0 → 0.13.1

package/README.md

@@ -73,6 +73,28 @@ Check your API usage:
 /synthetic:quotas
 ```
 
+### Usage Status
+
+When a Synthetic model is active, the footer status bar shows live quota usage (e.g. `week:82% (↺in 3d) 5h:95%`). Colors follow the same severity assessment as quota warnings: green by default, yellow/red only when projected usage is at risk. The status auto-refreshes every 60 seconds and after each turn.
+
+### Quota Warnings
+
+The extension automatically notifies you when you approach or exceed your Synthetic API quotas. Notifications fire on severity transitions only (no repeated alerts for the same level) and use correct terminology (regen/tick/resets) with precise time formatting.
+
+- Escalation always notifies
+- `high` and `critical` levels have no cooldown
+- `warning` level has a 60-minute cooldown
+
+## Disabling Features
+
+Each feature (provider, web search, quotas command, usage status, quota warnings) is a separate Pi extension. You can disable individual features using `pi config`:
+
+```
+pi config extensions.disabled add @aliou/pi-synthetic/quota-warnings
+```
+
+This prevents the quota-warnings extension from loading while keeping the rest of pi-synthetic active. Replace `quota-warnings` with `web-search`, `command-quotas`, or `provider` to disable other features.
+
 ## Adding or Updating Models
 
 Models are hardcoded in `src/providers/models.ts`. To add or update models:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aliou/pi-synthetic",
-  "version": "0.12.0",
+  "version": "0.13.1",
   "license": "MIT",
   "type": "module",
   "private": false,
@@ -18,7 +18,9 @@
       "./src/extensions/provider/index.ts",
       "./src/extensions/web-search/index.ts",
       "./src/extensions/command-quotas/index.ts",
-      "./src/extensions/quota-warnings/index.ts"
+      "./src/extensions/sub-bar-integration/index.ts",
+      "./src/extensions/quota-warnings/index.ts",
+      "./src/extensions/usage-status/index.ts"
     ],
     "video": "https://assets.aliou.me/pi-extensions/demos/pi-synthetic.mp4"
   },
@@ -34,6 +36,7 @@
     "@mariozechner/pi-tui": "0.61.0"
   },
   "dependencies": {
+    "@aliou/pi-utils-settings": "^0.13.0",
     "@aliou/pi-utils-ui": "^0.1.2"
   },
   "devDependencies": {

package/src/config.ts

@@ -0,0 +1,277 @@
+import {
+  ConfigLoader,
+  type Migration,
+  registerSettingsCommand,
+  type SettingsSection,
+} from "@aliou/pi-utils-settings";
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import type { SettingItem } from "@mariozechner/pi-tui";
+import pkg from "../package.json" with { type: "json" };
+
+export type SyntheticFeatureId =
+  | "webSearch"
+  | "quotasCommand"
+  | "subBarIntegration"
+  | "usageStatus"
+  | "quotaWarnings";
+
+export const SYNTHETIC_EXTENSIONS_REQUEST_EVENT =
+  "synthetic:extensions:request" as const;
+
+export const SYNTHETIC_EXTENSIONS_REGISTER_EVENT =
+  "synthetic:extensions:register" as const;
+
+export interface SyntheticExtensionsRegisterPayload {
+  feature: SyntheticFeatureId;
+}
+
+/**
+ * Config schema version. Stamped on disk when the initial migration runs or
+ * when the config is seeded. Uses the package version; bumping the package
+ * does not retrigger migrations (we only run them when `configVersion` is
+ * missing), but it records which release first created the file.
+ */
+export const SYNTHETIC_CONFIG_VERSION: string = pkg.version;
+
+export interface SyntheticConfig {
+  configVersion?: string;
+  webSearch?: boolean;
+  quotasCommand?: boolean;
+  usageStatus?: boolean;
+  quotaWarnings?: boolean;
+  subBarIntegration?: boolean;
+}
+
+export interface ResolvedSyntheticConfig {
+  configVersion: string;
+  webSearch: boolean;
+  quotasCommand: boolean;
+  usageStatus: boolean;
+  quotaWarnings: boolean;
+  subBarIntegration: boolean;
+}
+
+const DEFAULT_CONFIG: ResolvedSyntheticConfig = {
+  configVersion: SYNTHETIC_CONFIG_VERSION,
+  webSearch: true,
+  quotasCommand: true,
+  usageStatus: false,
+  quotaWarnings: false,
+  subBarIntegration: true,
+};
+
+// Module-level flag set when the v1 migration runs or when the global config
+// is seeded for the first time. Consumed once by the provider extension to
+// display a one-time notice about the new settings UI.
+let pendingMigrationNotice = false;
+
+export function hasPendingMigrationNotice(): boolean {
+  return pendingMigrationNotice;
+}
+
+export function clearPendingMigrationNotice(): void {
+  pendingMigrationNotice = false;
+}
+
+function markMigrationNoticePending(): void {
+  pendingMigrationNotice = true;
+}
+
+const migrations: Migration<SyntheticConfig>[] = [
+  {
+    name: "seed-defaults",
+    shouldRun: (config) => config.configVersion === undefined,
+    run: (config) => {
+      markMigrationNoticePending();
+      return {
+        configVersion: SYNTHETIC_CONFIG_VERSION,
+        webSearch: config.webSearch ?? DEFAULT_CONFIG.webSearch,
+        quotasCommand: config.quotasCommand ?? DEFAULT_CONFIG.quotasCommand,
+        usageStatus: config.usageStatus ?? DEFAULT_CONFIG.usageStatus,
+        quotaWarnings: config.quotaWarnings ?? DEFAULT_CONFIG.quotaWarnings,
+        subBarIntegration:
+          config.subBarIntegration ?? DEFAULT_CONFIG.subBarIntegration,
+      };
+    },
+  },
+];
+
+const QUOTA_WARNING_THRESHOLDS_DESCRIPTION =
+  "Toggle warnings when your quotas reach thresholds. Thresholds: warning at 80% projected usage, high at 90%, critical at 100% for fixed windows; dynamic windows use adaptive projected thresholds based on window progress.";
+
+export const configLoader = new ConfigLoader<
+  SyntheticConfig,
+  ResolvedSyntheticConfig
+>("synthetic", DEFAULT_CONFIG, { migrations });
+
+/**
+ * Seed the global config file on first use. When no config file exists in
+ * any scope, this writes the current defaults (with configVersion) to the
+ * global scope and flags the migration notice as pending.
+ *
+ * Must be called after `configLoader.load()`.
+ */
+export async function seedSyntheticConfigIfMissing(): Promise<void> {
+  if (configLoader.hasConfig("global") || configLoader.hasConfig("local")) {
+    return;
+  }
+  markMigrationNoticePending();
+  try {
+    await configLoader.save("global", {
+      configVersion: SYNTHETIC_CONFIG_VERSION,
+      webSearch: DEFAULT_CONFIG.webSearch,
+      quotasCommand: DEFAULT_CONFIG.quotasCommand,
+      usageStatus: DEFAULT_CONFIG.usageStatus,
+      quotaWarnings: DEFAULT_CONFIG.quotaWarnings,
+      subBarIntegration: DEFAULT_CONFIG.subBarIntegration,
+    });
+  } catch {
+    // If the write fails, keep the notice pending so the user still sees it.
+  }
+}
+
+export const SYNTHETIC_CONFIG_UPDATED_EVENT =
+  "synthetic:config:updated" as const;
+
+export interface SyntheticConfigUpdatedPayload {
+  config: ResolvedSyntheticConfig;
+}
+
+export function emitSyntheticConfigUpdated(pi: ExtensionAPI): void {
+  pi.events.emit(SYNTHETIC_CONFIG_UPDATED_EVENT, {
+    config: configLoader.getConfig(),
+  });
+}
+
+export interface RegisterSyntheticSettingsOptions {
+  getLoadedFeatures: () => Set<SyntheticFeatureId>;
+}
+
+function featureRow(
+  id: SyntheticFeatureId,
+  label: string,
+  description: string,
+  configValue: boolean,
+  isLoaded: boolean,
+): SettingItem {
+  if (isLoaded) {
+    return {
+      id,
+      label,
+      description,
+      currentValue: configValue ? "enabled" : "disabled",
+      values: ["enabled", "disabled"],
+    };
+  }
+  return {
+    id,
+    label,
+    description: `${description} (Not loaded by Pi)`,
+    currentValue: "unavailable",
+    values: [],
+  };
+}
+
+export function registerSyntheticSettings(
+  pi: ExtensionAPI,
+  options: RegisterSyntheticSettingsOptions,
+): void {
+  const { getLoadedFeatures } = options;
+
+  registerSettingsCommand<SyntheticConfig, ResolvedSyntheticConfig>(pi, {
+    commandName: "synthetic:settings",
+    commandDescription: "Configure Synthetic extension settings",
+    title: "Synthetic Settings",
+    configStore: configLoader,
+    buildSections: (tabConfig, resolved): SettingsSection[] => {
+      const loaded = getLoadedFeatures();
+      const webSearch = tabConfig?.webSearch ?? resolved.webSearch;
+      const quotasCommand = tabConfig?.quotasCommand ?? resolved.quotasCommand;
+      const usageStatus = tabConfig?.usageStatus ?? resolved.usageStatus;
+      const quotaWarnings = tabConfig?.quotaWarnings ?? resolved.quotaWarnings;
+      const subBarIntegration =
+        tabConfig?.subBarIntegration ?? resolved.subBarIntegration;
+
+      const sections: SettingsSection[] = [];
+
+      sections.push(
+        {
+          label: "Tools",
+          items: [
+            featureRow(
+              "webSearch",
+              "Web Search",
+              "Toggle `synthetic_web_search`, a tool for searching online with zero data retention",
+              webSearch,
+              loaded.has("webSearch"),
+            ),
+          ],
+        },
+        {
+          label: "Quotas",
+          items: [
+            featureRow(
+              "quotasCommand",
+              "Quotas Command",
+              "Toggle the `/synthetic:quotas` command, showing your quotas at a glance",
+              quotasCommand,
+              loaded.has("quotasCommand"),
+            ),
+            featureRow(
+              "usageStatus",
+              "Usage widget",
+              "Toggle the usage widget, showing your usage at a glance",
+              usageStatus,
+              loaded.has("usageStatus"),
+            ),
+            featureRow(
+              "quotaWarnings",
+              "Quota Warnings",
+              QUOTA_WARNING_THRESHOLDS_DESCRIPTION,
+              quotaWarnings,
+              loaded.has("quotaWarnings"),
+            ),
+          ],
+        },
+        {
+          label: "Integration",
+          items: [
+            featureRow(
+              "subBarIntegration",
+              "pi-sub-bar integration",
+              "Integration with `@marckrenn/pi-sub-bar`",
+              subBarIntegration,
+              loaded.has("subBarIntegration"),
+            ),
+          ],
+        },
+      );
+
+      return sections;
+    },
+    onSettingChange: (id, newValue, config) => {
+      if (!getLoadedFeatures().has(id as SyntheticFeatureId)) {
+        return null;
+      }
+
+      const enabled = newValue === "enabled";
+      switch (id) {
+        case "webSearch":
+          return { ...config, webSearch: enabled };
+        case "quotasCommand":
+          return { ...config, quotasCommand: enabled };
+        case "usageStatus":
+          return { ...config, usageStatus: enabled };
+        case "quotaWarnings":
+          return { ...config, quotaWarnings: enabled };
+        case "subBarIntegration":
+          return { ...config, subBarIntegration: enabled };
+        default:
+          return null;
+      }
+    },
+    onSave: async () => {
+      emitSyntheticConfigUpdated(pi);
+    },
+  });
+}

package/src/extensions/command-quotas/command.ts

@@ -1,4 +1,5 @@
 import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import { configLoader } from "../../config";
 import { getSyntheticApiKey } from "../../lib/env";
 import { fetchQuotas } from "../../utils/quotas";
 import { QuotasComponent } from "./components/quotas-display";
@@ -10,6 +11,14 @@ export function registerQuotasCommand(pi: ExtensionAPI): void {
   pi.registerCommand("synthetic:quotas", {
     description: "Display Synthetic API usage quotas",
     handler: async (_args, ctx) => {
+      if (!configLoader.getConfig().quotasCommand) {
+        ctx.ui.notify(
+          "Synthetic quotas command is disabled. Restart Pi to unload the command after re-enabling or disabling it.",
+          "warning",
+        );
+        return;
+      }
+
       const apiKey = await getSyntheticApiKey(ctx.modelRegistry.authStorage);
       if (!apiKey) {
         ctx.ui.notify(MISSING_AUTH_MESSAGE, "warning");

package/src/extensions/command-quotas/components/quotas-display.ts

@@ -150,7 +150,6 @@ export class QuotasComponent implements Component {
         width,
       ),
     );
-    lines.push("");
 
     switch (this.state.type) {
       case "loading":
@@ -186,6 +185,8 @@ export class QuotasComponent implements Component {
     const windows = toWindows(quotas);
     const barWidth = Math.min(50, Math.max(20, contentWidth - 20));
 
+    lines.push("");
+
     for (const window of windows) {
       lines.push(...this.renderWindow(window, barWidth, maxWidth));
       lines.push("");

package/src/extensions/command-quotas/index.ts

@@ -1,8 +1,23 @@
 import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import {
+  configLoader,
+  SYNTHETIC_EXTENSIONS_REGISTER_EVENT,
+  SYNTHETIC_EXTENSIONS_REQUEST_EVENT,
+} from "../../config";
 import { registerQuotasCommand } from "./command";
-import { registerSubIntegration } from "./sub-integration";
 
 export default async function (pi: ExtensionAPI) {
-  registerQuotasCommand(pi);
-  registerSubIntegration(pi);
+  await configLoader.load();
+
+  const config = configLoader.getConfig();
+
+  if (config.quotasCommand) {
+    registerQuotasCommand(pi);
+  }
+
+  pi.events.on(SYNTHETIC_EXTENSIONS_REQUEST_EVENT, () => {
+    pi.events.emit(SYNTHETIC_EXTENSIONS_REGISTER_EVENT, {
+      feature: "quotasCommand",
+    });
+  });
 }

package/src/extensions/provider/index.ts

@@ -1,6 +1,59 @@
 import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import { visibleWidth, wrapTextWithAnsi } from "@mariozechner/pi-tui";
+import {
+  clearPendingMigrationNotice,
+  configLoader,
+  emitSyntheticConfigUpdated,
+  hasPendingMigrationNotice,
+  registerSyntheticSettings,
+  SYNTHETIC_EXTENSIONS_REGISTER_EVENT,
+  SYNTHETIC_EXTENSIONS_REQUEST_EVENT,
+  type SyntheticExtensionsRegisterPayload,
+  type SyntheticFeatureId,
+  seedSyntheticConfigIfMissing,
+} from "../../config";
 import { SYNTHETIC_MODELS } from "./models";
 
+const MIGRATION_NOTICE_MESSAGE_TYPE = "synthetic:migration-notice";
+const MIGRATION_NOTICE_TITLE = "pi-synthetic";
+const MIGRATION_NOTICE_CONTENT = [
+  "New optional features added to `pi-synthetic`:",
+  "- Usage widget",
+  "- Quotas warnings",
+  "",
+  "Enable them either with `pi config` or inside of `pi` with `/synthetic:settings`.",
+].join("\n");
+
+/** Wrap lines in a rounded Unicode frame with 1-char inner padding. */
+function wrapInRoundedBorder(
+  lines: string[],
+  width: number,
+  colorFn: (text: string) => string,
+): string[] {
+  const innerWidth = Math.max(1, width - 2);
+  const hBar = "\u2500".repeat(innerWidth);
+  const top = colorFn(`\u256D${hBar}\u256E`);
+  const bottom = colorFn(`\u2570${hBar}\u256F`);
+  const left = colorFn("\u2502");
+  const right = colorFn("\u2502");
+
+  const wrapped = lines.map((line) => {
+    const contentWidth = visibleWidth(line);
+    const fill = Math.max(0, innerWidth - contentWidth);
+    return `${left}${line}${" ".repeat(fill)}${right}`;
+  });
+
+  return [top, ...wrapped, bottom];
+}
+
+/** Highlight `backtick-wrapped` spans using the accent color. */
+function highlightInlineCode(
+  text: string,
+  colorFn: (text: string) => string,
+): string {
+  return text.replace(/`([^`]+)`/g, (_, code) => colorFn(code));
+}
+
 export function registerSyntheticProvider(pi: ExtensionAPI): void {
   pi.registerProvider("synthetic", {
     baseUrl: "https://api.synthetic.new/openai/v1",
@@ -10,14 +63,8 @@ export function registerSyntheticProvider(pi: ExtensionAPI): void {
       Referer: "https://pi.dev",
       "X-Title": "npm:@aliou/pi-synthetic",
     },
-    models: SYNTHETIC_MODELS.map((model) => ({
-      id: model.id,
-      name: model.name,
-      reasoning: model.reasoning,
-      input: model.input,
-      cost: model.cost,
-      contextWindow: model.contextWindow,
-      maxTokens: model.maxTokens,
+    models: SYNTHETIC_MODELS.map(({ provider: _provider, ...model }) => ({
+      ...model,
       compat: {
         supportsDeveloperRole: false,
         maxTokensField: "max_tokens",
@@ -28,5 +75,65 @@ export function registerSyntheticProvider(pi: ExtensionAPI): void {
 }
 
 export default async function (pi: ExtensionAPI) {
+  await configLoader.load();
+  await seedSyntheticConfigIfMissing();
   registerSyntheticProvider(pi);
+
+  pi.registerMessageRenderer(
+    MIGRATION_NOTICE_MESSAGE_TYPE,
+    (message, _options, theme) => {
+      const rawContent =
+        typeof message.content === "string"
+          ? message.content
+          : MIGRATION_NOTICE_CONTENT;
+      const accent = (t: string) => theme.fg("accent", t);
+      const borderColor = accent;
+      const title = theme.bold(accent(MIGRATION_NOTICE_TITLE));
+      const body = highlightInlineCode(rawContent, accent);
+
+      return {
+        render(width: number) {
+          // border (2) + inner padding (2)
+          const contentWidth = Math.max(1, width - 4);
+          const bodyLines = wrapTextWithAnsi(body, contentWidth);
+          const lines = [title, "", ...bodyLines];
+          const padded = lines.map((line) => ` ${line} `);
+          return wrapInRoundedBorder(padded, width, borderColor);
+        },
+        handleInput() {
+          return false;
+        },
+        invalidate() {},
+      };
+    },
+  );
+
+  const loadedFeatures = new Set<SyntheticFeatureId>();
+
+  pi.events.on(SYNTHETIC_EXTENSIONS_REGISTER_EVENT, (data: unknown) => {
+    const { feature } = data as SyntheticExtensionsRegisterPayload;
+    loadedFeatures.add(feature);
+  });
+
+  registerSyntheticSettings(pi, {
+    getLoadedFeatures: () => loadedFeatures,
+  });
+
+  pi.on("session_start", async () => {
+    loadedFeatures.clear();
+    pi.events.emit(SYNTHETIC_EXTENSIONS_REQUEST_EVENT, undefined);
+    emitSyntheticConfigUpdated(pi);
+
+    if (hasPendingMigrationNotice()) {
+      clearPendingMigrationNotice();
+      pi.sendMessage(
+        {
+          customType: MIGRATION_NOTICE_MESSAGE_TYPE,
+          content: MIGRATION_NOTICE_CONTENT,
+          display: true,
+        },
+        { triggerTurn: false },
+      );
+    }
+  });
 }

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

@@ -4,6 +4,7 @@ import { SYNTHETIC_MODELS } from "./models";
 interface ApiModel {
   id: string;
   name: string;
+  provider: string | null;
   input_modalities: string[];
   output_modalities: string[];
   context_length: number;
@@ -156,6 +157,19 @@ function compareModels(
         });
       }
     }
+
+    // Check provider
+    if (
+      apiModel.provider !== null &&
+      apiModel.provider !== hardcoded.provider
+    ) {
+      discrepancies.push({
+        model: hardcoded.id,
+        field: "provider",
+        hardcoded: hardcoded.provider,
+        api: apiModel.provider,
+      });
+    }
   }
 
   // Check for API models not in hardcoded list

package/src/extensions/provider/models.ts

@@ -2,29 +2,11 @@
 // Source: https://api.synthetic.new/openai/v1/models
 // maxTokens sourced from https://models.dev/api.json (synthetic provider)
 
-export interface SyntheticModelConfig {
-  id: string;
-  name: string;
-  reasoning: boolean;
-  input: ("text" | "image")[];
-  cost: {
-    input: number;
-    output: number;
-    cacheRead: number;
-    cacheWrite: number;
-  };
-  contextWindow: number;
-  maxTokens: number;
-  compat?: {
-    supportsDeveloperRole?: boolean;
-    supportsReasoningEffort?: boolean;
-    reasoningEffortMap?: Partial<
-      Record<"minimal" | "low" | "medium" | "high" | "xhigh", string>
-    >;
-    maxTokensField?: "max_completion_tokens" | "max_tokens";
-    requiresToolResultName?: boolean;
-    requiresMistralToolIds?: boolean;
-  };
+import type { ProviderModelConfig } from "@mariozechner/pi-coding-agent";
+
+export interface SyntheticModelConfig extends ProviderModelConfig {
+  /** Upstream backend Synthetic proxies this model through (e.g. "fireworks", "together", "synthetic"). */
+  provider: string;
 }
 
 const SYNTHETIC_REASONING_EFFORT_MAP = {
@@ -40,6 +22,7 @@ export const SYNTHETIC_MODELS: SyntheticModelConfig[] = [
   {
     id: "hf:zai-org/GLM-4.7",
     name: "zai-org/GLM-4.7",
+    provider: "synthetic",
     reasoning: true,
     compat: {
       supportsReasoningEffort: true,
@@ -59,6 +42,7 @@ export const SYNTHETIC_MODELS: SyntheticModelConfig[] = [
   {
     id: "hf:zai-org/GLM-5",
     name: "zai-org/GLM-5",
+    provider: "synthetic",
     reasoning: true,
     compat: {
       supportsReasoningEffort: true,
@@ -78,6 +62,7 @@ export const SYNTHETIC_MODELS: SyntheticModelConfig[] = [
   {
     id: "hf:zai-org/GLM-5.1",
     name: "zai-org/GLM-5.1",
+    provider: "synthetic",
     reasoning: true,
     compat: {
       supportsReasoningEffort: true,
@@ -98,6 +83,7 @@ export const SYNTHETIC_MODELS: SyntheticModelConfig[] = [
   {
     id: "hf:zai-org/GLM-4.7-Flash",
     name: "zai-org/GLM-4.7-Flash",
+    provider: "synthetic",
     reasoning: true,
     compat: {
       supportsReasoningEffort: true,
@@ -117,6 +103,7 @@ export const SYNTHETIC_MODELS: SyntheticModelConfig[] = [
   {
     id: "hf:MiniMaxAI/MiniMax-M2.1",
     name: "MiniMaxAI/MiniMax-M2.1",
+    provider: "fireworks",
     reasoning: true,
     compat: {
       supportsReasoningEffort: true,
@@ -136,6 +123,7 @@ export const SYNTHETIC_MODELS: SyntheticModelConfig[] = [
   {
     id: "hf:meta-llama/Llama-3.3-70B-Instruct",
     name: "meta-llama/Llama-3.3-70B-Instruct",
+    provider: "together",
     reasoning: false,
     input: ["text"],
     cost: {
@@ -151,6 +139,7 @@ export const SYNTHETIC_MODELS: SyntheticModelConfig[] = [
   {
     id: "hf:deepseek-ai/DeepSeek-R1-0528",
     name: "deepseek-ai/DeepSeek-R1-0528",
+    provider: "together",
     reasoning: true,
     compat: {
       supportsReasoningEffort: true,
@@ -170,6 +159,7 @@ export const SYNTHETIC_MODELS: SyntheticModelConfig[] = [
   {
     id: "hf:deepseek-ai/DeepSeek-V3.2",
     name: "deepseek-ai/DeepSeek-V3.2",
+    provider: "fireworks",
     reasoning: false,
     input: ["text"],
     cost: {
@@ -185,6 +175,7 @@ export const SYNTHETIC_MODELS: SyntheticModelConfig[] = [
   {
     id: "hf:moonshotai/Kimi-K2-Instruct-0905",
     name: "moonshotai/Kimi-K2-Instruct-0905",
+    provider: "fireworks",
     reasoning: false,
     input: ["text"],
     cost: {
@@ -200,6 +191,7 @@ export const SYNTHETIC_MODELS: SyntheticModelConfig[] = [
   {
     id: "hf:moonshotai/Kimi-K2-Thinking",
     name: "moonshotai/Kimi-K2-Thinking",
+    provider: "fireworks",
     reasoning: true,
     compat: {
       supportsReasoningEffort: true,
@@ -219,6 +211,7 @@ export const SYNTHETIC_MODELS: SyntheticModelConfig[] = [
   {
     id: "hf:openai/gpt-oss-120b",
     name: "openai/gpt-oss-120b",
+    provider: "fireworks",
     reasoning: false,
     input: ["text"],
     cost: {
@@ -234,6 +227,7 @@ export const SYNTHETIC_MODELS: SyntheticModelConfig[] = [
   {
     id: "hf:Qwen/Qwen3-Coder-480B-A35B-Instruct",
     name: "Qwen/Qwen3-Coder-480B-A35B-Instruct",
+    provider: "together",
     reasoning: true,
     compat: {
       supportsReasoningEffort: true,
@@ -253,6 +247,7 @@ export const SYNTHETIC_MODELS: SyntheticModelConfig[] = [
   {
     id: "hf:moonshotai/Kimi-K2.5",
     name: "moonshotai/Kimi-K2.5",
+    provider: "synthetic",
     reasoning: true,
     compat: {
       supportsReasoningEffort: true,
@@ -272,6 +267,7 @@ export const SYNTHETIC_MODELS: SyntheticModelConfig[] = [
   {
     id: "hf:nvidia/Kimi-K2.5-NVFP4",
     name: "nvidia/Kimi-K2.5-NVFP4",
+    provider: "synthetic",
     reasoning: true,
     compat: {
       supportsReasoningEffort: true,
@@ -291,6 +287,7 @@ export const SYNTHETIC_MODELS: SyntheticModelConfig[] = [
   {
     id: "hf:deepseek-ai/DeepSeek-V3",
     name: "deepseek-ai/DeepSeek-V3",
+    provider: "together",
     reasoning: false,
     input: ["text"],
     cost: {
@@ -306,6 +303,7 @@ export const SYNTHETIC_MODELS: SyntheticModelConfig[] = [
   {
     id: "hf:Qwen/Qwen3-235B-A22B-Thinking-2507",
     name: "Qwen/Qwen3-235B-A22B-Thinking-2507",
+    provider: "together",
     reasoning: true,
     compat: {
       supportsReasoningEffort: true,
@@ -325,6 +323,7 @@ export const SYNTHETIC_MODELS: SyntheticModelConfig[] = [
   {
     id: "hf:Qwen/Qwen3.5-397B-A17B",
     name: "Qwen/Qwen3.5-397B-A17B",
+    provider: "together",
     reasoning: true,
     compat: {
       supportsReasoningEffort: true,
@@ -344,6 +343,7 @@ export const SYNTHETIC_MODELS: SyntheticModelConfig[] = [
   {
     id: "hf:MiniMaxAI/MiniMax-M2.5",
     name: "MiniMaxAI/MiniMax-M2.5",
+    provider: "synthetic",
     reasoning: true,
     input: ["text"],
     cost: {
@@ -364,6 +364,7 @@ export const SYNTHETIC_MODELS: SyntheticModelConfig[] = [
   {
     id: "hf:nvidia/NVIDIA-Nemotron-3-Super-120B-A12B-NVFP4",
     name: "nvidia/NVIDIA-Nemotron-3-Super-120B-A12B-NVFP4",
+    provider: "synthetic",
     reasoning: true,
     compat: {
       supportsReasoningEffort: true,

package/src/extensions/quota-warnings/index.ts

@@ -1,22 +1,58 @@
 import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import {
+  configLoader,
+  SYNTHETIC_CONFIG_UPDATED_EVENT,
+  SYNTHETIC_EXTENSIONS_REGISTER_EVENT,
+  SYNTHETIC_EXTENSIONS_REQUEST_EVENT,
+  type SyntheticConfigUpdatedPayload,
+} from "../../config";
 import { clearAlertState, triggerCheck } from "./notifier";
 
 export default async function (pi: ExtensionAPI) {
-  // Session start: reset local warning state and run an immediate check
+  await configLoader.load();
+
+  let enabled = configLoader.getConfig().quotaWarnings;
+  let currentModel: { provider: string; id: string } | undefined;
+  let currentContext: Parameters<typeof triggerCheck>[0] | undefined;
+
+  pi.events.on(SYNTHETIC_CONFIG_UPDATED_EVENT, (data: unknown) => {
+    enabled = (data as SyntheticConfigUpdatedPayload).config.quotaWarnings;
+
+    if (!enabled) {
+      clearAlertState();
+      return;
+    }
+
+    if (currentContext && currentModel?.provider === "synthetic") {
+      clearAlertState();
+      triggerCheck(currentContext, currentModel, false);
+    }
+  });
+
   pi.on("session_start", async (_event, ctx) => {
-    if (ctx.model?.provider !== "synthetic") return;
+    currentContext = ctx;
+    currentModel = ctx.model;
+    if (!enabled || ctx.model?.provider !== "synthetic") return;
     clearAlertState();
     triggerCheck(ctx, ctx.model, false);
   });
 
-  // Check after agent turn - only warn for newly crossed thresholds
   pi.on("agent_end", async (_event, ctx) => {
-    if (ctx.model?.provider !== "synthetic") return;
+    currentContext = ctx;
+    currentModel = ctx.model;
+    if (!enabled || ctx.model?.provider !== "synthetic") return;
     triggerCheck(ctx, ctx.model, true);
   });
 
-  // Clear state on shutdown
   pi.on("session_shutdown", async () => {
+    currentContext = undefined;
+    currentModel = undefined;
     clearAlertState();
   });
+
+  pi.events.on(SYNTHETIC_EXTENSIONS_REQUEST_EVENT, () => {
+    pi.events.emit(SYNTHETIC_EXTENSIONS_REGISTER_EVENT, {
+      feature: "quotaWarnings",
+    });
+  });
 }

package/src/extensions/{command-quotas/sub-integration.ts → sub-bar-integration/index.ts}

@@ -1,4 +1,11 @@
 import type { AuthStorage, ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import {
+  configLoader,
+  SYNTHETIC_CONFIG_UPDATED_EVENT,
+  SYNTHETIC_EXTENSIONS_REGISTER_EVENT,
+  SYNTHETIC_EXTENSIONS_REQUEST_EVENT,
+  type SyntheticConfigUpdatedPayload,
+} from "../../config";
 import { getSyntheticApiKey } from "../../lib/env";
 import type { QuotasResponse } from "../../types/quotas";
 import { fetchQuotas, formatResetTime } from "../../utils/quotas";
@@ -28,7 +35,6 @@ interface SubCoreSettingsPayload {
 function toUsageSnapshot(quotas: QuotasResponse): UsageSnapshot {
   const windows: RateWindow[] = [];
 
-  // Weekly token limit (credits-based)
   if (quotas.weeklyTokenLimit) {
     const { weeklyTokenLimit } = quotas;
     windows.push({
@@ -41,7 +47,6 @@ function toUsageSnapshot(quotas: QuotasResponse): UsageSnapshot {
     });
   }
 
-  // Rolling 5-hour limit (request-based)
   if (quotas.rollingFiveHourLimit && quotas.rollingFiveHourLimit.max > 0) {
     const { rollingFiveHourLimit } = quotas;
     const used = rollingFiveHourLimit.max - rollingFiveHourLimit.remaining;
@@ -55,7 +60,6 @@ function toUsageSnapshot(quotas: QuotasResponse): UsageSnapshot {
     });
   }
 
-  // Legacy subscription (fallback if rollingFiveHourLimit not available)
   if (
     !quotas.rollingFiveHourLimit &&
     quotas.subscription?.limit &&
@@ -117,15 +121,16 @@ async function emitCurrentUsage(
   });
 }
 
-export function registerSubIntegration(pi: ExtensionAPI): void {
+export function registerSubBarIntegration(pi: ExtensionAPI): void {
   let interval: NodeJS.Timeout | undefined;
   let refreshMs = 60000;
   let subCoreReady = false;
   let currentProvider: string | undefined;
   let currentAuthStorage: AuthStorage | undefined;
+  let enabled = configLoader.getConfig().subBarIntegration;
 
   function isSynthetic(): boolean {
-    return currentProvider === "synthetic";
+    return enabled && currentProvider === "synthetic";
   }
 
   function stop(): void {
@@ -148,24 +153,33 @@ export function registerSubIntegration(pi: ExtensionAPI): void {
     interval.unref?.();
   }
 
-  // Custom events (inter-extension bus)
+  pi.events.on(SYNTHETIC_CONFIG_UPDATED_EVENT, (data: unknown) => {
+    enabled = (data as SyntheticConfigUpdatedPayload).config.subBarIntegration;
+
+    if (!enabled) {
+      stop();
+      return;
+    }
+
+    if (subCoreReady && currentAuthStorage && currentProvider === "synthetic") {
+      startPolling(currentAuthStorage);
+    }
+  });
+
   pi.events.on("sub-core:ready", () => {
     subCoreReady = true;
-    // Polling starts in session_start/model_select when provider is synthetic
   });
 
   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;
-      // Restart with new interval if currently running
       if (interval && isSynthetic() && currentAuthStorage) {
         startPolling(currentAuthStorage);
       }
     }
   });
 
-  // Lifecycle events
   pi.on("session_start", async (_event, ctx) => {
     currentProvider = ctx.model?.provider;
     currentAuthStorage = ctx.modelRegistry.authStorage;
@@ -200,3 +214,14 @@ export function registerSubIntegration(pi: ExtensionAPI): void {
     stop();
   });
 }
+
+export default async function (pi: ExtensionAPI) {
+  await configLoader.load();
+  registerSubBarIntegration(pi);
+
+  pi.events.on(SYNTHETIC_EXTENSIONS_REQUEST_EVENT, () => {
+    pi.events.emit(SYNTHETIC_EXTENSIONS_REGISTER_EVENT, {
+      feature: "subBarIntegration",
+    });
+  });
+}

package/src/extensions/usage-status/index.ts

@@ -0,0 +1,245 @@
+import type {
+  ExtensionAPI,
+  ExtensionContext,
+} from "@mariozechner/pi-coding-agent";
+import {
+  configLoader,
+  SYNTHETIC_CONFIG_UPDATED_EVENT,
+  SYNTHETIC_EXTENSIONS_REGISTER_EVENT,
+  SYNTHETIC_EXTENSIONS_REQUEST_EVENT,
+  type SyntheticConfigUpdatedPayload,
+} from "../../config";
+import { getSyntheticApiKey } from "../../lib/env";
+import type { QuotasResponse } from "../../types/quotas";
+import { fetchQuotas, formatResetTime } from "../../utils/quotas";
+import {
+  assessWindow,
+  getSeverityColor,
+  type RiskSeverity,
+  toWindows,
+} from "../../utils/quotas-severity";
+
+const EXTENSION_ID = "synthetic-usage";
+const REFRESH_INTERVAL_MS = 60_000;
+
+type WindowStatus = {
+  label: string;
+  usedPercent: number;
+  severity: RiskSeverity;
+  resetsAt: string | null;
+  limited: boolean;
+};
+
+function parseSnapshot(quotas: QuotasResponse): WindowStatus[] {
+  const windows = toWindows(quotas);
+  return windows.map((w) => {
+    const assessment = assessWindow(w);
+    return {
+      label: w.label,
+      usedPercent: w.usedPercent,
+      severity: assessment.severity,
+      resetsAt: w.resetsAt.toISOString(),
+      limited: w.limited ?? false,
+    };
+  });
+}
+
+const SHORT_LABELS: Record<string, string> = {
+  "Credits / week": "week",
+  "Requests / 5h": "5h",
+  "Search / hour": "search",
+  "Free Tool Calls / day": "tools",
+};
+
+function formatStatus(ctx: ExtensionContext, windows: WindowStatus[]): string {
+  const theme = ctx.ui.theme;
+  const parts: string[] = [];
+
+  for (const w of windows) {
+    const short = SHORT_LABELS[w.label] ?? w.label;
+    const remaining = Math.max(
+      0,
+      Math.min(100, Math.round(100 - w.usedPercent)),
+    );
+    const color = getSeverityColor(w.severity);
+    const pctText = theme.fg(color, `${remaining}%`);
+    const reset = w.resetsAt
+      ? theme.fg("dim", ` (\u21ba${formatResetTime(w.resetsAt)})`)
+      : "";
+    const limitTag = w.limited ? theme.fg("error", " [limited]") : "";
+    parts.push(`${theme.fg("dim", `${short}:`)}${pctText}${reset}${limitTag}`);
+  }
+
+  return parts.join(" ");
+}
+
+function createStatusRefresher() {
+  let refreshTimer: ReturnType<typeof setInterval> | undefined;
+  let activeContext: ExtensionContext | undefined;
+  let isRefreshInFlight = false;
+  let queuedRefresh = false;
+  let lastSnapshot: WindowStatus[] | undefined;
+
+  async function updateFooterStatus(ctx: ExtensionContext): Promise<void> {
+    if (!ctx.hasUI) return;
+    if (isRefreshInFlight) {
+      queuedRefresh = true;
+      return;
+    }
+    isRefreshInFlight = true;
+    try {
+      const apiKey = await getSyntheticApiKey(ctx.modelRegistry.authStorage);
+      if (!apiKey) {
+        lastSnapshot = undefined;
+        ctx.ui.setStatus(EXTENSION_ID, undefined);
+        return;
+      }
+      const result = await fetchQuotas(apiKey);
+      if (!result.success) {
+        ctx.ui.setStatus(
+          EXTENSION_ID,
+          ctx.ui.theme.fg("warning", "usage unavailable"),
+        );
+        return;
+      }
+      const windows = parseSnapshot(result.data.quotas);
+      lastSnapshot = windows;
+      if (windows.length === 0) {
+        ctx.ui.setStatus(EXTENSION_ID, undefined);
+        return;
+      }
+      ctx.ui.setStatus(EXTENSION_ID, formatStatus(ctx, windows));
+    } catch {
+      ctx.ui.setStatus(
+        EXTENSION_ID,
+        ctx.ui.theme.fg("warning", "usage unavailable"),
+      );
+    } finally {
+      isRefreshInFlight = false;
+      if (queuedRefresh) {
+        queuedRefresh = false;
+        void updateFooterStatus(ctx);
+      }
+    }
+  }
+
+  function refreshFor(ctx: ExtensionContext): Promise<void> {
+    activeContext = ctx;
+    return updateFooterStatus(ctx);
+  }
+
+  function startAutoRefresh(): void {
+    if (refreshTimer) clearInterval(refreshTimer);
+    refreshTimer = setInterval(() => {
+      if (!activeContext) return;
+      void updateFooterStatus(activeContext);
+    }, REFRESH_INTERVAL_MS);
+    refreshTimer.unref?.();
+  }
+
+  function stopAutoRefresh(ctx?: ExtensionContext): void {
+    if (refreshTimer) {
+      clearInterval(refreshTimer);
+      refreshTimer = undefined;
+    }
+    ctx?.ui.setStatus(EXTENSION_ID, undefined);
+  }
+
+  async function setLoadingStatus(ctx: ExtensionContext): Promise<void> {
+    if (!ctx.hasUI) return;
+    const apiKey = await getSyntheticApiKey(
+      ctx.modelRegistry.authStorage,
+    ).catch(() => undefined);
+    if (!apiKey) {
+      ctx.ui.setStatus(EXTENSION_ID, undefined);
+      return;
+    }
+    ctx.ui.setStatus(EXTENSION_ID, ctx.ui.theme.fg("dim", "loading usage..."));
+  }
+
+  function renderFromLastSnapshot(ctx: ExtensionContext): boolean {
+    if (!ctx.hasUI || !lastSnapshot) return false;
+    ctx.ui.setStatus(EXTENSION_ID, formatStatus(ctx, lastSnapshot));
+    return true;
+  }
+
+  return {
+    refreshFor,
+    startAutoRefresh,
+    stopAutoRefresh,
+    setLoadingStatus,
+    renderFromLastSnapshot,
+  };
+}
+
+export default async function (pi: ExtensionAPI) {
+  await configLoader.load();
+
+  const refresher = createStatusRefresher();
+  let enabled = configLoader.getConfig().usageStatus;
+  let currentContext: ExtensionContext | undefined;
+  let currentProvider: string | undefined;
+
+  pi.events.on(SYNTHETIC_CONFIG_UPDATED_EVENT, (data: unknown) => {
+    enabled = (data as SyntheticConfigUpdatedPayload).config.usageStatus;
+
+    if (!enabled) {
+      refresher.stopAutoRefresh(currentContext);
+      return;
+    }
+
+    if (currentContext && currentProvider === "synthetic") {
+      refresher.startAutoRefresh();
+      void refresher.refreshFor(currentContext);
+    }
+  });
+
+  pi.on("session_start", async (_event, ctx) => {
+    currentContext = ctx;
+    currentProvider = ctx.model?.provider;
+    if (!enabled || ctx.model?.provider !== "synthetic") return;
+    refresher.startAutoRefresh();
+    await refresher.setLoadingStatus(ctx);
+    await refresher.refreshFor(ctx);
+  });
+
+  pi.on("turn_end", (_event, ctx) => {
+    currentContext = ctx;
+    currentProvider = ctx.model?.provider;
+    if (!enabled || ctx.model?.provider !== "synthetic") return;
+    void refresher.refreshFor(ctx);
+  });
+
+  pi.on("session_switch", (_event, ctx) => {
+    currentContext = ctx;
+    currentProvider = ctx.model?.provider;
+    if (enabled && ctx.model?.provider === "synthetic") {
+      void refresher.refreshFor(ctx);
+    } else {
+      refresher.stopAutoRefresh(ctx);
+    }
+  });
+
+  pi.on("model_select", (_event, ctx) => {
+    currentContext = ctx;
+    currentProvider = ctx.model?.provider;
+    if (enabled && ctx.model?.provider === "synthetic") {
+      refresher.startAutoRefresh();
+      void refresher.refreshFor(ctx);
+    } else {
+      refresher.stopAutoRefresh(ctx);
+    }
+  });
+
+  pi.on("session_shutdown", (_event, ctx) => {
+    currentContext = undefined;
+    currentProvider = undefined;
+    refresher.stopAutoRefresh(ctx);
+  });
+
+  pi.events.on(SYNTHETIC_EXTENSIONS_REQUEST_EVENT, () => {
+    pi.events.emit(SYNTHETIC_EXTENSIONS_REGISTER_EVENT, {
+      feature: "usageStatus",
+    });
+  });
+}

package/src/extensions/web-search/index.ts

@@ -1,6 +1,50 @@
 import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
-import { registerSyntheticWebSearchTool } from "./tool";
+import {
+  configLoader,
+  SYNTHETIC_CONFIG_UPDATED_EVENT,
+  SYNTHETIC_EXTENSIONS_REGISTER_EVENT,
+  SYNTHETIC_EXTENSIONS_REQUEST_EVENT,
+  type SyntheticConfigUpdatedPayload,
+} from "../../config";
+import {
+  registerSyntheticWebSearchTool,
+  SYNTHETIC_WEB_SEARCH_TOOL,
+} from "./tool";
+
+function syncToolActivation(pi: ExtensionAPI, enabled: boolean): void {
+  const allToolNames = new Set(pi.getAllTools().map((tool) => tool.name));
+  const activeTools = new Set(pi.getActiveTools());
+
+  if (!allToolNames.has(SYNTHETIC_WEB_SEARCH_TOOL)) return;
+
+  if (enabled) {
+    activeTools.add(SYNTHETIC_WEB_SEARCH_TOOL);
+  } else {
+    activeTools.delete(SYNTHETIC_WEB_SEARCH_TOOL);
+  }
+
+  pi.setActiveTools([...activeTools].filter((name) => allToolNames.has(name)));
+}
 
 export default async function (pi: ExtensionAPI) {
+  await configLoader.load();
+
+  let webSearchEnabled = configLoader.getConfig().webSearch;
+
   registerSyntheticWebSearchTool(pi);
+
+  pi.on("session_start", async () => {
+    syncToolActivation(pi, webSearchEnabled);
+  });
+
+  pi.events.on(SYNTHETIC_CONFIG_UPDATED_EVENT, (data: unknown) => {
+    webSearchEnabled = (data as SyntheticConfigUpdatedPayload).config.webSearch;
+    syncToolActivation(pi, webSearchEnabled);
+  });
+
+  pi.events.on(SYNTHETIC_EXTENSIONS_REQUEST_EVENT, () => {
+    pi.events.emit(SYNTHETIC_EXTENSIONS_REGISTER_EVENT, {
+      feature: "webSearch",
+    });
+  });
 }

package/src/extensions/web-search/tool.ts

@@ -9,6 +9,7 @@ import type {
 import { getMarkdownTheme, keyHint } from "@mariozechner/pi-coding-agent";
 import { Container, Markdown, Text } from "@mariozechner/pi-tui";
 import { type Static, Type } from "@sinclair/typebox";
+import { configLoader } from "../../config";
 import { getSyntheticApiKey } from "../../lib/env";
 
 export const SYNTHETIC_WEB_SEARCH_TOOL = "synthetic_web_search" as const;
@@ -59,6 +60,12 @@ export function registerSyntheticWebSearchTool(pi: ExtensionAPI): void {
         details: { query: params.query },
       });
 
+      if (!configLoader.getConfig().webSearch) {
+        throw new Error(
+          "Synthetic web search is disabled. Re-enable it with synthetic:settings or pi config.",
+        );
+      }
+
       const apiKey = await getSyntheticApiKey(ctx.modelRegistry.authStorage);
       if (!apiKey) {
         throw new Error(