@aliou/pi-synthetic 0.15.0 → 0.17.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aliou/pi-synthetic",
-  "version": "0.15.0",
+  "version": "0.17.0",
   "license": "MIT",
   "type": "module",
   "private": false,
@@ -32,18 +32,18 @@
     "README.md"
   ],
   "peerDependencies": {
-    "@mariozechner/pi-coding-agent": "0.72.0",
-    "@mariozechner/pi-tui": "0.72.0"
+    "@earendil-works/pi-coding-agent": "0.74.0",
+    "@earendil-works/pi-tui": "0.74.0"
   },
   "dependencies": {
-    "@aliou/pi-utils-settings": "^0.13.0",
-    "@aliou/pi-utils-ui": "^0.1.2"
+    "@aliou/pi-utils-settings": "^0.15.0",
+    "@aliou/pi-utils-ui": "^0.4.0"
   },
   "devDependencies": {
     "@aliou/biome-plugins": "^0.7.0",
     "@biomejs/biome": "^2.4.2",
     "@changesets/cli": "^2.27.11",
-    "@mariozechner/pi-coding-agent": "0.72.0",
+    "@earendil-works/pi-coding-agent": "0.74.0",
     "typebox": "^1.1.37",
     "@types/node": "^25.0.10",
     "husky": "^9.1.7",
@@ -51,10 +51,10 @@
     "vitest": "^4.0.18"
   },
   "peerDependenciesMeta": {
-    "@mariozechner/pi-coding-agent": {
+    "@earendil-works/pi-coding-agent": {
       "optional": true
     },
-    "@mariozechner/pi-tui": {
+    "@earendil-works/pi-tui": {
       "optional": true
     }
   },

package/src/config.ts

@@ -4,8 +4,8 @@ import {
   registerSettingsCommand,
   type SettingsSection,
 } from "@aliou/pi-utils-settings";
-import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
-import type { SettingItem } from "@mariozechner/pi-tui";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import type { SettingItem } from "@earendil-works/pi-tui";
 import pkg from "../package.json" with { type: "json" };
 
 export type SyntheticFeatureId =

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

@@ -1,4 +1,4 @@
-import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { configLoader } from "../../config";
 import { getSyntheticApiKey } from "../../lib/env";
 import { fetchQuotas } from "../../utils/quotas";

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

@@ -1,7 +1,7 @@
-import type { Theme } from "@mariozechner/pi-coding-agent";
-import { DynamicBorder } from "@mariozechner/pi-coding-agent";
-import type { Component, TUI } from "@mariozechner/pi-tui";
-import { Loader, matchesKey, truncateToWidth } from "@mariozechner/pi-tui";
+import type { Theme } from "@earendil-works/pi-coding-agent";
+import { DynamicBorder } from "@earendil-works/pi-coding-agent";
+import type { Component, TUI } from "@earendil-works/pi-tui";
+import { Loader, matchesKey, truncateToWidth } from "@earendil-works/pi-tui";
 import type { QuotasResponse } from "../../../types/quotas";
 import {
   assessWindow,

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

@@ -1,4 +1,4 @@
-import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import {
   configLoader,
   SYNTHETIC_EXTENSIONS_REGISTER_EVENT,

package/src/extensions/provider/index.ts

@@ -1,4 +1,7 @@
-import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import type {
+  AuthStorage,
+  ExtensionAPI,
+} from "@earendil-works/pi-coding-agent";
 import {
   configLoader,
   emitSyntheticConfigUpdated,
@@ -12,6 +15,18 @@ import {
   type SyntheticFeatureId,
   seedSyntheticConfigIfMissing,
 } from "../../config";
+import { getSyntheticApiKey } from "../../lib/env";
+import { QuotaStore } from "../../services/quota-store";
+import {
+  parseQuotaHeader,
+  type QuotasResponse,
+  SYNTHETIC_QUOTAS_READ_EVENT,
+  SYNTHETIC_QUOTAS_REQUEST_EVENT,
+  SYNTHETIC_QUOTAS_UPDATED_EVENT,
+  type SyntheticQuotasReadPayload,
+  type SyntheticQuotasRequestPayload,
+} from "../../types/quotas";
+import { fetchQuotas } from "../../utils/quotas";
 import { SYNTHETIC_MODELS } from "./models";
 
 export function buildSyntheticProviderModels(includeProxiedModels: boolean) {
@@ -71,6 +86,54 @@ export default async function (pi: ExtensionAPI) {
     getLoadedFeatures: () => loadedFeatures,
   });
 
+  const quotaStore = new QuotaStore();
+  let currentAuthStorage: AuthStorage | undefined;
+
+  async function fetchQuotasFromAuth(): Promise<QuotasResponse | undefined> {
+    if (!currentAuthStorage) return undefined;
+    const apiKey = await getSyntheticApiKey(currentAuthStorage);
+    if (!apiKey) return undefined;
+    const result = await fetchQuotas(apiKey);
+    return result.success ? result.data.quotas : undefined;
+  }
+
+  quotaStore.subscribe((snapshot) => {
+    pi.events.emit(SYNTHETIC_QUOTAS_UPDATED_EVENT, {
+      quotas: snapshot.quotas,
+      source: snapshot.source,
+      updatedAt: snapshot.updatedAt,
+    });
+  });
+
+  pi.on("after_provider_response", (event, ctx) => {
+    if (ctx.model?.provider !== "synthetic") return;
+    const quotas = parseQuotaHeader(event.headers);
+    if (quotas) quotaStore.ingest(quotas, "header");
+  });
+
+  pi.events.on(SYNTHETIC_QUOTAS_REQUEST_EVENT, async (data: unknown) => {
+    const payload = data as SyntheticQuotasRequestPayload | undefined;
+    const snapshot = await quotaStore.refreshFromApi(fetchQuotasFromAuth);
+    if (payload?.respond) {
+      payload.respond(snapshot);
+    }
+  });
+
+  pi.events.on(SYNTHETIC_QUOTAS_READ_EVENT, (data: unknown) => {
+    const { respond } = data as SyntheticQuotasReadPayload;
+    respond(quotaStore.getSnapshot());
+  });
+
+  pi.on("session_before_switch", () => {
+    quotaStore.clear();
+    currentAuthStorage = undefined;
+  });
+
+  pi.on("session_shutdown", () => {
+    quotaStore.clear();
+    currentAuthStorage = undefined;
+  });
+
   pi.on("session_start", async (_event, ctx) => {
     const messages = pendingMessages.splice(0).map((m) => `- ${m}`);
     if (messages.length > 0) {
@@ -81,7 +144,13 @@ export default async function (pi: ExtensionAPI) {
     }
 
     loadedFeatures.clear();
+    quotaStore.clear();
+    currentAuthStorage = ctx.modelRegistry.authStorage;
     pi.events.emit(SYNTHETIC_EXTENSIONS_REQUEST_EVENT, undefined);
     emitSyntheticConfigUpdated(pi);
+
+    if (ctx.model?.provider === "synthetic") {
+      await quotaStore.refreshFromApi(fetchQuotasFromAuth);
+    }
   });
 }

package/src/extensions/provider/models.ts

@@ -2,7 +2,7 @@
 // Source: https://api.synthetic.new/openai/v1/models
 // maxTokens sourced from https://models.dev/api.json (synthetic provider)
 
-import type { ProviderModelConfig } from "@mariozechner/pi-coding-agent";
+import type { ProviderModelConfig } from "@earendil-works/pi-coding-agent";
 
 export interface SyntheticModelConfig extends ProviderModelConfig {
   /** Upstream backend Synthetic proxies this model through (e.g. "fireworks", "together", "synthetic"). */

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

@@ -1,4 +1,7 @@
-import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import type {
+  ExtensionAPI,
+  ExtensionContext,
+} from "@earendil-works/pi-coding-agent";
 import {
   configLoader,
   SYNTHETIC_CONFIG_UPDATED_EVENT,
@@ -6,48 +9,100 @@ import {
   SYNTHETIC_EXTENSIONS_REQUEST_EVENT,
   type SyntheticConfigUpdatedPayload,
 } from "../../config";
-import { clearAlertState, triggerCheck } from "./notifier";
+import { QuotaWarningNotifier } from "../../services/quota-warnings";
+import {
+  SYNTHETIC_QUOTAS_READ_EVENT,
+  SYNTHETIC_QUOTAS_REQUEST_EVENT,
+  type SyntheticQuotasReadPayload,
+  type SyntheticQuotasRequestPayload,
+  type SyntheticQuotasSnapshotPayload,
+} from "../../types/quotas";
 
 export default async function (pi: ExtensionAPI) {
   await configLoader.load();
 
   let enabled = configLoader.getConfig().quotaWarnings;
-  let currentModel: { provider: string; id: string } | undefined;
-  let currentContext: Parameters<typeof triggerCheck>[0] | undefined;
+
+  const notifier = new QuotaWarningNotifier();
+
+  function requestQuotas(
+    respond?: (snapshot: SyntheticQuotasSnapshotPayload | undefined) => void,
+  ): void {
+    pi.events.emit(SYNTHETIC_QUOTAS_REQUEST_EVENT, {
+      respond,
+    } satisfies SyntheticQuotasRequestPayload);
+  }
+
+  function readQuotas(
+    respond: (snapshot: SyntheticQuotasSnapshotPayload | undefined) => void,
+  ): void {
+    pi.events.emit(SYNTHETIC_QUOTAS_READ_EVENT, {
+      respond,
+    } satisfies SyntheticQuotasReadPayload);
+  }
+
+  function evaluateFromStoreOrRefresh(ctx: ExtensionContext): void {
+    if (!enabled || ctx.model?.provider !== "synthetic") return;
+    readQuotas((snapshot) => {
+      if (snapshot) {
+        notifier.evaluate(
+          snapshot.quotas,
+          snapshot.source === "header",
+          (message, level) => {
+            ctx.ui.notify(message, level);
+          },
+        );
+      } else {
+        requestQuotas((refreshed) => {
+          if (!refreshed) return;
+          notifier.evaluate(
+            refreshed.quotas,
+            refreshed.source === "header",
+            (message, level) => {
+              ctx.ui.notify(message, level);
+            },
+          );
+        });
+      }
+    });
+  }
 
   pi.events.on(SYNTHETIC_CONFIG_UPDATED_EVENT, (data: unknown) => {
     enabled = (data as SyntheticConfigUpdatedPayload).config.quotaWarnings;
 
     if (!enabled) {
-      clearAlertState();
+      notifier.clearAlertState();
       return;
     }
 
-    if (currentContext && currentModel?.provider === "synthetic") {
-      clearAlertState();
-      triggerCheck(currentContext, currentModel, false);
-    }
+    notifier.clearAlertState();
+    // In config updates we don't have ctx, so we just clear. The next lifecycle event will refresh.
   });
 
-  pi.on("session_start", async (_event, ctx) => {
-    currentContext = ctx;
-    currentModel = ctx.model;
-    if (!enabled || ctx.model?.provider !== "synthetic") return;
-    clearAlertState();
-    triggerCheck(ctx, ctx.model, false);
+  pi.on("session_start", (_event, ctx) => {
+    notifier.clearAlertState();
+    evaluateFromStoreOrRefresh(ctx);
   });
 
-  pi.on("agent_end", async (_event, ctx) => {
-    currentContext = ctx;
-    currentModel = ctx.model;
-    if (!enabled || ctx.model?.provider !== "synthetic") return;
-    triggerCheck(ctx, ctx.model, true);
+  pi.on("model_select", (_event, ctx) => {
+    notifier.clearAlertState();
+    evaluateFromStoreOrRefresh(ctx);
+  });
+
+  pi.on("agent_end", (_event, ctx) => {
+    evaluateFromStoreOrRefresh(ctx);
+  });
+
+  pi.on("turn_end", (_event, ctx) => {
+    evaluateFromStoreOrRefresh(ctx);
+  });
+
+  pi.on("session_before_switch", () => {
+    notifier.clearAlertState();
   });
 
-  pi.on("session_shutdown", async () => {
-    currentContext = undefined;
-    currentModel = undefined;
-    clearAlertState();
+  pi.on("session_shutdown", () => {
+    notifier.clearAlertState();
   });
 
   pi.events.on(SYNTHETIC_EXTENSIONS_REQUEST_EVENT, () => {

package/src/extensions/sub-bar-integration/index.ts

@@ -1,4 +1,4 @@
-import type { AuthStorage, ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import {
   configLoader,
   SYNTHETIC_CONFIG_UPDATED_EVENT,
@@ -6,9 +6,13 @@ import {
   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 {
+  type QuotasResponse,
+  SYNTHETIC_QUOTAS_REQUEST_EVENT,
+  SYNTHETIC_QUOTAS_UPDATED_EVENT,
+  type SyntheticQuotasUpdatedPayload,
+} from "../../types/quotas";
+import { formatResetTime } from "../../utils/quotas";
 
 interface RateWindow {
   label: string;
@@ -24,14 +28,6 @@ interface UsageSnapshot {
   lastSuccessAt?: number;
 }
 
-interface SubCoreSettingsPayload {
-  settings?: {
-    behavior?: {
-      refreshInterval: number;
-    };
-  };
-}
-
 function toUsageSnapshot(quotas: QuotasResponse): UsageSnapshot {
   const windows: RateWindow[] = [];
 
@@ -105,64 +101,42 @@ function toUsageSnapshot(quotas: QuotasResponse): UsageSnapshot {
   };
 }
 
-async function emitCurrentUsage(
-  pi: ExtensionAPI,
-  authStorage: AuthStorage,
-): Promise<void> {
-  const apiKey = await getSyntheticApiKey(authStorage);
-  if (!apiKey) return;
-  const result = await fetchQuotas(apiKey);
-  if (!result.success) return;
-  pi.events.emit("sub-core:update-current", {
-    state: {
-      provider: "synthetic",
-      usage: toUsageSnapshot(result.data.quotas),
-    },
-  });
-}
-
 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 enabled && currentProvider === "synthetic";
   }
 
-  function stop(): void {
-    if (interval) {
-      clearInterval(interval);
-      interval = undefined;
-    }
+  function emitUsage(quotas: QuotasResponse): void {
+    pi.events.emit("sub-core:update-current", {
+      state: {
+        provider: "synthetic",
+        usage: toUsageSnapshot(quotas),
+      },
+    });
   }
 
-  function startPolling(authStorage: AuthStorage): void {
-    stop();
-    currentAuthStorage = authStorage;
-    void emitCurrentUsage(pi, authStorage);
-    const ms = Math.max(10000, refreshMs);
-    interval = setInterval(() => {
-      if (isSynthetic() && currentAuthStorage) {
-        void emitCurrentUsage(pi, currentAuthStorage);
-      }
-    }, ms);
-    interval.unref?.();
+  function requestQuotas(): void {
+    pi.events.emit(SYNTHETIC_QUOTAS_REQUEST_EVENT, undefined);
   }
 
+  // Receive quota updates from the provider extension
+  pi.events.on(SYNTHETIC_QUOTAS_UPDATED_EVENT, (data: unknown) => {
+    if (!isSynthetic() || !subCoreReady) return;
+    const { quotas } = data as SyntheticQuotasUpdatedPayload;
+    emitUsage(quotas);
+  });
+
   pi.events.on(SYNTHETIC_CONFIG_UPDATED_EVENT, (data: unknown) => {
     enabled = (data as SyntheticConfigUpdatedPayload).config.subBarIntegration;
 
-    if (!enabled) {
-      stop();
-      return;
-    }
+    if (!enabled) return;
 
-    if (subCoreReady && currentAuthStorage && currentProvider === "synthetic") {
-      startPolling(currentAuthStorage);
+    if (subCoreReady && currentProvider === "synthetic") {
+      requestQuotas();
     }
   });
 
@@ -170,48 +144,24 @@ export function registerSubBarIntegration(pi: ExtensionAPI): void {
     subCoreReady = true;
   });
 
-  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 && isSynthetic() && currentAuthStorage) {
-        startPolling(currentAuthStorage);
-      }
-    }
+  pi.on("session_start", async (_event, ctx) => {
+    currentProvider = ctx.model?.provider;
   });
 
-  pi.on("session_start", async (_event, ctx) => {
+  pi.on("model_select", async (_event, ctx) => {
     currentProvider = ctx.model?.provider;
-    currentAuthStorage = ctx.modelRegistry.authStorage;
 
     if (subCoreReady && isSynthetic()) {
-      const apiKey = await getSyntheticApiKey(currentAuthStorage);
-      if (apiKey) {
-        startPolling(currentAuthStorage);
-      }
+      requestQuotas();
     }
   });
 
-  pi.on("model_select", async (event, ctx) => {
-    currentProvider = event.model?.provider;
-    currentAuthStorage = ctx.modelRegistry.authStorage;
-
-    if (subCoreReady && isSynthetic()) {
-      const apiKey = await getSyntheticApiKey(currentAuthStorage);
-      if (apiKey) {
-        startPolling(currentAuthStorage);
-      } else {
-        stop();
-      }
-    } else {
-      stop();
-    }
+  pi.on("session_before_switch", (_event, ctx) => {
+    currentProvider = ctx.model?.provider;
   });
 
   pi.on("session_shutdown", () => {
     currentProvider = undefined;
-    currentAuthStorage = undefined;
-    stop();
   });
 }