@aliou/pi-synthetic 0.10.0 → 0.10.2

package/package.json

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

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

@@ -15,50 +15,56 @@ export function registerQuotasCommand(pi: ExtensionAPI): void {
         ctx.ui.notify(MISSING_AUTH_MESSAGE, "warning");
         return;
       }
+      const key: string = apiKey;
 
       const result = await ctx.ui.custom<null>((tui, theme, _kb, done) => {
-        const component = new QuotasComponent(theme, () => done(null));
+        const controller = new AbortController();
+        const component = new QuotasComponent(theme, tui, () => {
+          controller.abort();
+          done(null);
+        });
 
-        fetchQuotas(apiKey)
-          .then((quotas) => {
-            if (!quotas) {
-              component.setState({
-                type: "error",
-                message:
-                  "Failed to fetch quotas. Check your Synthetic subscription status.",
-              });
-            } else {
-              component.setState({ type: "loaded", quotas });
-            }
-            tui.requestRender();
-          })
-          .catch(() => {
+        async function loadQuotas(): Promise<void> {
+          const fetchResult = await fetchQuotas(key, controller.signal);
+          if (controller.signal.aborted) return;
+          if (fetchResult.success) {
+            component.setState({
+              type: "loaded",
+              quotas: fetchResult.data.quotas,
+            });
+          } else {
             component.setState({
               type: "error",
-              message:
-                "Failed to fetch quotas. Check your Synthetic subscription status.",
+              message: fetchResult.error.message,
             });
-            tui.requestRender();
-          });
+          }
+          tui.requestRender();
+        }
+
+        void loadQuotas();
 
         return {
           render: (width: number) => component.render(width),
           invalidate: () => component.invalidate(),
           handleInput: (data: string) => component.handleInput(data),
+          dispose: () => {
+            controller.abort();
+            component.destroy();
+          },
         };
       });
 
-      // RPC fallback: return JSON
+      // Non-interactive fallback (RPC, print, JSON modes)
       if (result === undefined) {
-        const quotas = await fetchQuotas(apiKey);
-        if (!quotas) {
+        const fetchResult = await fetchQuotas(key);
+        if (!fetchResult.success) {
           ctx.ui.notify(
-            JSON.stringify({ error: "Failed to fetch quotas" }),
+            JSON.stringify({ error: fetchResult.error.message }),
             "error",
           );
           return;
         }
-        ctx.ui.notify(JSON.stringify(quotas, null, 2), "info");
+        ctx.ui.notify(JSON.stringify(fetchResult.data.quotas), "info");
       }
     },
   });

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

@@ -1,7 +1,8 @@
 import type { Theme } from "@mariozechner/pi-coding-agent";
 import { DynamicBorder } from "@mariozechner/pi-coding-agent";
-import type { Component } from "@mariozechner/pi-tui";
+import type { Component, TUI } from "@mariozechner/pi-tui";
 import {
+  Loader,
   matchesKey,
   truncateToWidth,
   visibleWidth,
@@ -251,14 +252,36 @@ function renderSimpleIndicatorBar(
 export class QuotasComponent implements Component {
   private state: QuotasState = { type: "loading" };
   private theme: Theme;
+  private tui: TUI;
   private onClose: () => void;
+  private loader: Loader | null = null;
 
-  constructor(theme: Theme, onClose: () => void) {
+  constructor(theme: Theme, tui: TUI, onClose: () => void) {
     this.theme = theme;
+    this.tui = tui;
     this.onClose = onClose;
+    this.startLoader();
+  }
+
+  private startLoader(): void {
+    this.loader = new Loader(
+      this.tui,
+      (s: string) => this.theme.fg("accent", s),
+      (s: string) => this.theme.fg("muted", s),
+      "Fetching quotas...",
+    );
+  }
+
+  destroy(): void {
+    this.loader?.stop();
+    this.loader = null;
   }
 
   setState(state: QuotasState): void {
+    if (this.state.type === "loading" && state.type !== "loading") {
+      this.loader?.stop();
+      this.loader = null;
+    }
     this.state = state;
   }
 
@@ -286,7 +309,11 @@ export class QuotasComponent implements Component {
 
     switch (this.state.type) {
       case "loading":
-        lines.push(this.theme.fg("muted", "  Loading..."));
+        if (this.loader) {
+          lines.push(...this.loader.render(width));
+        } else {
+          lines.push(this.theme.fg("muted", "  Fetching quotas..."));
+        }
         break;
       case "error":
         lines.push(this.theme.fg("error", `  ${this.state.message}`));

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

@@ -107,10 +107,13 @@ async function emitCurrentUsage(
 ): Promise<void> {
   const apiKey = await getSyntheticApiKey(authStorage);
   if (!apiKey) return;
-  const quotas = await fetchQuotas(apiKey);
-  if (!quotas) return;
+  const result = await fetchQuotas(apiKey);
+  if (!result.success) return;
   pi.events.emit("sub-core:update-current", {
-    state: { provider: "synthetic", usage: toUsageSnapshot(quotas) },
+    state: {
+      provider: "synthetic",
+      usage: toUsageSnapshot(result.data.quotas),
+    },
   });
 }
 

package/src/extensions/provider/models.ts

@@ -36,7 +36,7 @@ const SYNTHETIC_REASONING_EFFORT_MAP = {
 } as const;
 
 export const SYNTHETIC_MODELS: SyntheticModelConfig[] = [
-  // API: hf:zai-org/GLM-4.7 → ctx=202752, out=65536
+  // API: hf:zai-org/GLM-4.7 → ctx=202752, multimodal
   {
     id: "hf:zai-org/GLM-4.7",
     name: "zai-org/GLM-4.7",
@@ -45,11 +45,11 @@ export const SYNTHETIC_MODELS: SyntheticModelConfig[] = [
       supportsReasoningEffort: true,
       reasoningEffortMap: SYNTHETIC_REASONING_EFFORT_MAP,
     },
-    input: ["text"],
+    input: ["text", "image"],
     cost: {
-      input: 0.45,
+      input: 2.19,
       output: 2.19,
-      cacheRead: 0.45,
+      cacheRead: 2.19,
       cacheWrite: 0,
     },
     contextWindow: 202752,
@@ -74,6 +74,26 @@ export const SYNTHETIC_MODELS: SyntheticModelConfig[] = [
     contextWindow: 196608,
     maxTokens: 65536,
   },
+  // API: hf:zai-org/GLM-5.1 → ctx=196608, out=65536
+  {
+    id: "hf:zai-org/GLM-5.1",
+    name: "zai-org/GLM-5.1",
+    reasoning: true,
+    compat: {
+      supportsReasoningEffort: true,
+      reasoningEffortMap: SYNTHETIC_REASONING_EFFORT_MAP,
+      supportsDeveloperRole: false,
+    },
+    input: ["text"],
+    cost: {
+      input: 1,
+      output: 3,
+      cacheRead: 1,
+      cacheWrite: 0,
+    },
+    contextWindow: 196608,
+    maxTokens: 65536,
+  },
   // API: hf:zai-org/GLM-4.7-Flash → ctx=196608
   {
     id: "hf:zai-org/GLM-4.7-Flash",

package/src/types/quotas.ts

@@ -1,3 +1,14 @@
+export type QuotasErrorKind =
+  | "cancelled"
+  | "timeout"
+  | "config"
+  | "http"
+  | "network";
+
+export type QuotasResult =
+  | { success: true; data: { quotas: QuotasResponse } }
+  | { success: false; error: { message: string; kind: QuotasErrorKind } };
+
 export interface QuotasResponse {
   subscription?: {
     limit: number;

package/src/utils/quotas.ts

@@ -1,20 +1,73 @@
-import type { QuotasResponse } from "../types/quotas";
+import type { QuotasResponse, QuotasResult } from "../types/quotas";
+
+const FETCH_TIMEOUT_MS = 15_000;
+
+function isTimeoutReason(reason: unknown): boolean {
+  return (
+    (reason instanceof DOMException && reason.name === "TimeoutError") ||
+    (reason instanceof Error && reason.name === "TimeoutError")
+  );
+}
 
 export async function fetchQuotas(
   apiKey: string,
-): Promise<QuotasResponse | null> {
-  if (!apiKey) return null;
+  signal?: AbortSignal,
+): Promise<QuotasResult> {
+  if (!apiKey) {
+    return {
+      success: false,
+      error: { message: "No API key provided", kind: "config" },
+    };
+  }
+
+  const signals: AbortSignal[] = [AbortSignal.timeout(FETCH_TIMEOUT_MS)];
+  if (signal) signals.push(signal);
+  const combined = AbortSignal.any(signals);
 
   try {
     const response = await fetch("https://api.synthetic.new/v2/quotas", {
       headers: { Authorization: `Bearer ${apiKey}` },
+      signal: combined,
     });
 
-    if (!response.ok) return null;
+    if (!response.ok) {
+      let message = response.statusText;
+      try {
+        const body = await response.text();
+        if (body) {
+          try {
+            const parsed = JSON.parse(body) as { error?: string };
+            if (parsed.error) message = parsed.error;
+          } catch {
+            message = body;
+          }
+        }
+      } catch {
+        return { success: false, error: { message, kind: "http" } };
+      }
+      return { success: false, error: { message, kind: "http" } };
+    }
+
     const data: QuotasResponse = await response.json();
-    return data;
-  } catch {
-    return null;
+    return { success: true, data: { quotas: data } };
+  } catch (err: unknown) {
+    const isAbort =
+      combined.aborted ||
+      (err instanceof DOMException && err.name === "AbortError");
+    if (isAbort) {
+      if (isTimeoutReason(combined.reason)) {
+        return {
+          success: false,
+          error: { message: "Request timed out", kind: "timeout" },
+        };
+      }
+      return {
+        success: false,
+        error: { message: "Request cancelled", kind: "cancelled" },
+      };
+    }
+    const message = err instanceof Error ? err.message : "Unknown error";
+    return { success: false, error: { message, kind: "network" } };
   }
 }