tau-all-agent 0.1.0

package/extensions/usage/minimax.ts

@@ -0,0 +1,208 @@
+import type { ExtensionContext } from "@mariozechner/pi-coding-agent";
+import {
+  clampPercent,
+  formatCount,
+  formatPlan,
+  formatWindowLabel,
+  HttpError,
+  LiveUsageUnavailableError,
+  makeMeterItem,
+  parseEpochDate,
+  readArray,
+  readNumber,
+  readObject,
+  readString,
+} from "./shared.js";
+import type { LiveUsageItem, LiveUsageSnapshot, UsageProviderDefinition } from "./types.js";
+
+const PROVIDER_ID = "minimax";
+const REMAINS_URLS = [
+  "https://api.minimax.io/v1/api/openplatform/coding_plan/remains",
+  "https://api.minimaxi.com/v1/api/openplatform/coding_plan/remains",
+] as const;
+
+function readNestedObject(
+  input: Record<string, unknown> | undefined,
+  ...keys: string[]
+): Record<string, unknown> | undefined {
+  for (const key of keys) {
+    const value = readObject(input?.[key]);
+    if (value) return value;
+  }
+  return undefined;
+}
+
+function parsePlanName(data: Record<string, unknown> | undefined): string | undefined {
+  const comboCard = readObject(data?.current_combo_card);
+  return [
+    readString(data?.current_subscribe_title),
+    readString(data?.plan_name),
+    readString(data?.combo_title),
+    readString(data?.current_plan_title),
+    readString(comboCard?.title),
+  ].find(Boolean);
+}
+
+function makeUsageMeter(
+  totalPrompts: number | undefined,
+  usedPrompts: number | undefined,
+  windowMinutes: number | undefined,
+  resetsAt: Date | undefined,
+): LiveUsageItem {
+  const remainingPrompts =
+    totalPrompts !== undefined && usedPrompts !== undefined
+      ? Math.max(0, totalPrompts - usedPrompts)
+      : undefined;
+  const usedPercent =
+    totalPrompts !== undefined && totalPrompts > 0 && usedPrompts !== undefined
+      ? clampPercent((usedPrompts / totalPrompts) * 100)
+      : 0;
+
+  return makeMeterItem({
+    key: "prompts",
+    label: "Prompts",
+    usedPercent,
+    windowLabel: formatWindowLabel(windowMinutes),
+    resetsAt,
+    detail:
+      totalPrompts !== undefined && totalPrompts > 0 && remainingPrompts !== undefined
+        ? `${formatCount(remainingPrompts)} / ${formatCount(totalPrompts)} remaining`
+        : undefined,
+  });
+}
+
+async function fetchPayload(
+  url: string,
+  apiKey: string,
+  signal?: AbortSignal,
+): Promise<Record<string, unknown>> {
+  const response = await fetch(url, {
+    method: "GET",
+    headers: {
+      Authorization: `Bearer ${apiKey}`,
+      accept: "application/json",
+      "Content-Type": "application/json",
+      "MM-API-Source": "pi usage",
+    },
+    signal,
+  });
+
+  if (response.status === 401 || response.status === 403) {
+    throw new HttpError(response.status, `MiniMax usage request failed (${response.status}).`);
+  }
+
+  if (!response.ok) {
+    const bodyText = await response.text().catch(() => "");
+    throw new Error(
+      bodyText.trim()
+        ? `MiniMax usage request failed (${response.status}): ${bodyText.trim()}`
+        : `MiniMax usage request failed (${response.status}).`,
+    );
+  }
+
+  return (await response.json()) as Record<string, unknown>;
+}
+
+function parseUsageSnapshot(payload: Record<string, unknown>): {
+  planName?: string;
+  totalPrompts?: number;
+  usedPrompts?: number;
+  windowMinutes?: number;
+  resetsAt?: Date;
+} {
+  const data = readNestedObject(payload, "data") ?? payload;
+  const baseResp = readNestedObject(data, "base_resp") ?? readNestedObject(payload, "base_resp");
+  const statusCode = readNumber(baseResp?.status_code);
+  const statusMessage = readString(baseResp?.status_msg);
+
+  if (statusCode !== undefined && statusCode !== 0) {
+    throw new Error(statusMessage ?? `status_code ${statusCode}`);
+  }
+
+  const modelRemains = readArray<Record<string, unknown>>(data.model_remains ?? data.modelRemains);
+  const first = modelRemains[0];
+  if (!first) {
+    throw new Error("MiniMax did not return any coding plan quota data.");
+  }
+
+  const totalPrompts = readNumber(
+    first.current_interval_total_count ?? first.currentIntervalTotalCount,
+  );
+  const usedPrompts = readNumber(
+    first.current_interval_usage_count ?? first.currentIntervalUsageCount,
+  );
+  const startTime = parseEpochDate(readNumber(first.start_time ?? first.startTime));
+  const endTime = parseEpochDate(readNumber(first.end_time ?? first.endTime));
+  const remainsTime = readNumber(first.remains_time ?? first.remainsTime);
+
+  const windowMinutes =
+    startTime && endTime
+      ? Math.max(0, Math.round((endTime.getTime() - startTime.getTime()) / 60_000))
+      : undefined;
+  const resetsAt =
+    endTime && endTime.getTime() > Date.now()
+      ? endTime
+      : remainsTime !== undefined && remainsTime > 0
+        ? new Date(Date.now() + (remainsTime > 1_000_000_000 ? remainsTime : remainsTime * 1000))
+        : undefined;
+
+  return {
+    planName: parsePlanName(data),
+    totalPrompts,
+    usedPrompts,
+    windowMinutes: windowMinutes && windowMinutes > 0 ? windowMinutes : undefined,
+    resetsAt,
+  };
+}
+
+async function fetchUsage(ctx: ExtensionContext, signal?: AbortSignal): Promise<LiveUsageSnapshot> {
+  const apiKey = await ctx.modelRegistry.getApiKeyForProvider(PROVIDER_ID);
+  if (!apiKey) throw new LiveUsageUnavailableError("no auth configured");
+
+  let payload: Record<string, unknown> | undefined;
+  let lastError: unknown;
+
+  for (const url of REMAINS_URLS) {
+    try {
+      payload = await fetchPayload(url, apiKey, signal);
+      break;
+    } catch (error) {
+      lastError = error;
+      if (!(error instanceof HttpError) || (error.status !== 401 && error.status !== 403)) {
+        throw error;
+      }
+    }
+  }
+
+  if (!payload) {
+    if (lastError instanceof HttpError && (lastError.status === 401 || lastError.status === 403)) {
+      throw new Error("MiniMax API key is invalid or expired.");
+    }
+    throw lastError instanceof Error ? lastError : new Error(String(lastError));
+  }
+
+  const snapshot = parseUsageSnapshot(payload);
+
+  return {
+    plan: formatPlan(snapshot.planName),
+    fetchedAt: new Date(),
+    items: [
+      makeUsageMeter(
+        snapshot.totalPrompts,
+        snapshot.usedPrompts,
+        snapshot.windowMinutes,
+        snapshot.resetsAt,
+      ),
+    ],
+  };
+}
+
+const minimaxProvider: UsageProviderDefinition = {
+  id: PROVIDER_ID,
+  label: "MiniMax",
+  shortLabel: "mini",
+  color: { r: 254, g: 96, b: 60 },
+  fetchLiveUsage: fetchUsage,
+};
+
+export default minimaxProvider;

package/extensions/usage/openai-codex.ts

@@ -0,0 +1,180 @@
+import type { ExtensionContext } from "@mariozechner/pi-coding-agent";
+import {
+  clampPercent,
+  formatCurrency,
+  formatPlan,
+  formatWindowLabel,
+  makeMeterItem,
+  makeStatItem,
+  parseEpochDate,
+  readNumber,
+  readString,
+} from "./shared.js";
+import type { LiveUsageItem, LiveUsageSnapshot, UsageProviderDefinition } from "./types.js";
+
+const PROVIDER_ID = "openai-codex";
+const USAGE_URL = "https://chatgpt.com/backend-api/wham/usage";
+const SESSION_WINDOW_MINUTES = 5 * 60;
+const WEEK_WINDOW_MINUTES = 7 * 24 * 60;
+
+interface UsageWindow {
+  usedPercent: number;
+  windowMinutes: number;
+  resetsAt?: Date;
+}
+
+function decodeWindow(value: unknown): UsageWindow | undefined {
+  const input = value as Record<string, unknown> | null | undefined;
+  const usedPercent = readNumber(input?.used_percent);
+  const resetAt = readNumber(input?.reset_at);
+  const windowSeconds = readNumber(input?.limit_window_seconds);
+  if (usedPercent === undefined || windowSeconds === undefined) return undefined;
+
+  return {
+    usedPercent: clampPercent(usedPercent),
+    windowMinutes: Math.round(windowSeconds / 60),
+    resetsAt: parseEpochDate(resetAt),
+  };
+}
+
+function windowRole(window: UsageWindow): "session" | "week" | "unknown" {
+  if (window.windowMinutes === SESSION_WINDOW_MINUTES) return "session";
+  if (window.windowMinutes === WEEK_WINDOW_MINUTES) return "week";
+  return "unknown";
+}
+
+function normalizeWindows(
+  primary?: UsageWindow,
+  secondary?: UsageWindow,
+): { session?: UsageWindow; week?: UsageWindow } {
+  const windows = [primary, secondary];
+  const normalized: { session?: UsageWindow; week?: UsageWindow } = {};
+
+  for (const window of windows) {
+    if (!window) continue;
+
+    const role = windowRole(window);
+    if (role === "session" && !normalized.session) {
+      normalized.session = window;
+      continue;
+    }
+    if (role === "week" && !normalized.week) {
+      normalized.week = window;
+    }
+  }
+
+  return normalized;
+}
+
+function makeWindowMeter(key: string, label: string, window: UsageWindow): LiveUsageItem {
+  return makeMeterItem({
+    key,
+    label,
+    usedPercent: window.usedPercent,
+    windowLabel: formatWindowLabel(window.windowMinutes),
+    resetsAt: window.resetsAt,
+  });
+}
+
+function extractErrorMessage(status: number, bodyText: string): string {
+  const defaultMessage = `OpenAI Codex usage request failed (${status}).`;
+  if (status === 401 || status === 403) {
+    return "OpenAI Codex login expired. Re-run /login.";
+  }
+  if (!bodyText.trim()) return defaultMessage;
+
+  try {
+    const parsed = JSON.parse(bodyText) as Record<string, unknown>;
+    const error = parsed.error as Record<string, unknown> | undefined;
+    const errorMessage = readString(error?.message) ?? readString(parsed.message);
+    const errorCode = readString(error?.code) ?? readString(error?.type);
+    const resetsAt = readNumber(error?.resets_at);
+
+    if (
+      status === 429 ||
+      errorCode === "usage_limit_reached" ||
+      errorCode === "rate_limit_exceeded"
+    ) {
+      if (resetsAt !== undefined) {
+        const mins = Math.max(0, Math.round((resetsAt * 1000 - Date.now()) / 60_000));
+        return `OpenAI Codex usage limit reached. Try again in ~${mins}m.`;
+      }
+      return "OpenAI Codex usage limit reached.";
+    }
+
+    return errorMessage ? `${defaultMessage} ${errorMessage}` : defaultMessage;
+  } catch {
+    return `${defaultMessage} ${bodyText.trim()}`;
+  }
+}
+
+async function fetchUsage(ctx: ExtensionContext, signal?: AbortSignal): Promise<LiveUsageSnapshot> {
+  const apiKey = await ctx.modelRegistry.getApiKeyForProvider(PROVIDER_ID);
+  if (!apiKey) throw new Error("Not logged in to OpenAI Codex.");
+
+  const credential = ctx.modelRegistry.authStorage.get(PROVIDER_ID);
+  const accountId =
+    credential?.type === "oauth" && typeof credential.accountId === "string"
+      ? credential.accountId
+      : undefined;
+
+  const headers = new Headers({
+    Authorization: `Bearer ${apiKey}`,
+    Accept: "application/json",
+    "User-Agent": "pi usage",
+  });
+  if (accountId) headers.set("ChatGPT-Account-Id", accountId);
+
+  const response = await fetch(USAGE_URL, { headers, signal });
+  if (!response.ok) {
+    const bodyText = await response.text().catch(() => "");
+    throw new Error(extractErrorMessage(response.status, bodyText));
+  }
+
+  const payload = (await response.json()) as Record<string, unknown>;
+  const rateLimit = payload.rate_limit as Record<string, unknown> | undefined;
+  const credits = payload.credits as Record<string, unknown> | undefined;
+  const { session, week } = normalizeWindows(
+    decodeWindow(rateLimit?.primary_window),
+    decodeWindow(rateLimit?.secondary_window),
+  );
+
+  const items: LiveUsageItem[] = [];
+  if (session) items.push(makeWindowMeter("session", "Session", session));
+  if (week) items.push(makeWindowMeter("week", "Week", week));
+
+  const unlimitedCredits = credits?.unlimited === true;
+  const creditBalance = readNumber(credits?.balance);
+  if (unlimitedCredits) {
+    items.push(makeStatItem({ key: "credits", label: "Credits", value: "Unlimited" }));
+  } else if (creditBalance !== undefined) {
+    items.push(
+      makeStatItem({
+        key: "credits",
+        label: "Credits",
+        value: formatCurrency(creditBalance),
+        detail: credits?.has_credits === false ? "remaining" : undefined,
+      }),
+    );
+  }
+
+  if (items.length === 0) {
+    throw new Error("OpenAI Codex did not return any session, weekly, or credit usage data.");
+  }
+
+  return {
+    plan: formatPlan(readString(payload.plan_type)),
+    fetchedAt: new Date(),
+    items,
+  };
+}
+
+const openAICodexProvider: UsageProviderDefinition = {
+  id: PROVIDER_ID,
+  label: "OpenAI Codex",
+  shortLabel: "codex",
+  color: { r: 73, g: 163, b: 176 },
+  fetchLiveUsage: fetchUsage,
+};
+
+export default openAICodexProvider;

package/extensions/usage/openrouter.ts

@@ -0,0 +1,168 @@
+import type { ExtensionContext } from "@mariozechner/pi-coding-agent";
+import {
+  formatCurrency,
+  HttpError,
+  LiveUsageUnavailableError,
+  makeMeterItem,
+  makeStatItem,
+  readNumber,
+  readString,
+} from "./shared.js";
+import type { LiveUsageItem, LiveUsageSnapshot, UsageProviderDefinition } from "./types.js";
+
+const PROVIDER_ID = "openrouter";
+const API_BASE_URL = "https://openrouter.ai/api/v1";
+
+interface CreditsPayload {
+  data?: {
+    total_credits?: unknown;
+    total_usage?: unknown;
+  };
+}
+
+interface KeyPayload {
+  data?: {
+    limit?: unknown;
+    usage?: unknown;
+    rate_limit?: {
+      requests?: unknown;
+      interval?: unknown;
+    };
+  };
+}
+
+function isAbortError(error: unknown): boolean {
+  return error instanceof Error && error.name === "AbortError";
+}
+
+async function fetchJson(
+  url: string,
+  apiKey: string,
+  signal?: AbortSignal,
+): Promise<Record<string, unknown>> {
+  const response = await fetch(url, {
+    method: "GET",
+    headers: {
+      Authorization: `Bearer ${apiKey}`,
+      Accept: "application/json",
+      "X-Title": "pi usage",
+    },
+    signal,
+  });
+
+  if (response.status === 401 || response.status === 403) {
+    throw new HttpError(response.status, "OpenRouter API key is invalid or expired.");
+  }
+
+  if (!response.ok) {
+    const bodyText = await response.text().catch(() => "");
+    throw new HttpError(
+      response.status,
+      bodyText.trim()
+        ? `OpenRouter usage request failed (${response.status}): ${bodyText.trim()}`
+        : `OpenRouter usage request failed (${response.status}).`,
+    );
+  }
+
+  return (await response.json()) as Record<string, unknown>;
+}
+
+async function fetchUsage(ctx: ExtensionContext, signal?: AbortSignal): Promise<LiveUsageSnapshot> {
+  const apiKey = await ctx.modelRegistry.getApiKeyForProvider(PROVIDER_ID);
+  if (!apiKey) throw new LiveUsageUnavailableError("no auth configured");
+
+  const [creditsResult, keyResult] = await Promise.allSettled([
+    fetchJson(`${API_BASE_URL}/credits`, apiKey, signal),
+    fetchJson(`${API_BASE_URL}/key`, apiKey, signal),
+  ]);
+
+  if (creditsResult.status === "rejected") {
+    throw creditsResult.reason;
+  }
+
+  const creditsPayload = creditsResult.value as CreditsPayload;
+  let keyPayload: KeyPayload | undefined;
+  if (keyResult.status === "fulfilled") {
+    keyPayload = keyResult.value as KeyPayload;
+  } else if (isAbortError(keyResult.reason)) {
+    throw keyResult.reason;
+  } else if (
+    !(keyResult.reason instanceof HttpError) ||
+    (keyResult.reason.status !== 403 &&
+      keyResult.reason.status !== 404 &&
+      keyResult.reason.status !== 405)
+  ) {
+    throw keyResult.reason;
+  }
+
+  const totalCredits = readNumber(creditsPayload.data?.total_credits) ?? 0;
+  const totalUsage = readNumber(creditsPayload.data?.total_usage) ?? 0;
+  const balance = Math.max(0, totalCredits - totalUsage);
+
+  const keyLimit = readNumber(keyPayload?.data?.limit);
+  const keyUsage = readNumber(keyPayload?.data?.usage);
+  const rateLimitRequests = readNumber(keyPayload?.data?.rate_limit?.requests);
+  const rateLimitInterval = readString(keyPayload?.data?.rate_limit?.interval);
+
+  const items: LiveUsageItem[] = [];
+  if (totalCredits > 0) {
+    items.push(
+      makeMeterItem({
+        key: "credits",
+        label: "Credits",
+        usedPercent: totalCredits > 0 ? (totalUsage / totalCredits) * 100 : 0,
+        detail: `${formatCurrency(balance)} / ${formatCurrency(totalCredits)} remaining`,
+      }),
+    );
+  } else {
+    items.push(
+      makeStatItem({
+        key: "balance",
+        label: "Balance",
+        value: formatCurrency(balance),
+        detail: totalUsage > 0 ? `${formatCurrency(totalUsage)} used` : undefined,
+      }),
+    );
+  }
+
+  if (keyLimit !== undefined && keyLimit > 0 && keyUsage !== undefined && keyUsage >= 0) {
+    const keyRemaining = Math.max(0, keyLimit - keyUsage);
+    items.push(
+      makeMeterItem({
+        key: "key-quota",
+        label: "Key quota",
+        usedPercent: keyLimit > 0 ? (keyUsage / keyLimit) * 100 : 0,
+        detail: `${formatCurrency(keyRemaining)} / ${formatCurrency(keyLimit)} remaining`,
+      }),
+    );
+  }
+
+  if (rateLimitRequests !== undefined && rateLimitInterval) {
+    items.push(
+      makeStatItem({
+        key: "rate-limit",
+        label: "Rate limit",
+        value: `${Math.round(rateLimitRequests)} / ${rateLimitInterval}`,
+      }),
+    );
+  }
+
+  if (items.length === 0) {
+    throw new Error("OpenRouter did not return any live usage data.");
+  }
+
+  return {
+    fetchedAt: new Date(),
+    items,
+  };
+}
+
+const openRouterProvider: UsageProviderDefinition = {
+  id: PROVIDER_ID,
+  label: "OpenRouter",
+  shortLabel: "router",
+  color: { r: 100, g: 103, b: 242 },
+  fetchLiveUsage: fetchUsage,
+};
+
+export default openRouterProvider;

package/extensions/usage/providers.ts

@@ -0,0 +1,26 @@
+import anthropicProvider from "./anthropic.js";
+import githubCopilotProvider from "./github-copilot.js";
+import googleGeminiCliProvider from "./google-gemini-cli.js";
+import minimaxProvider from "./minimax.js";
+import openAICodexProvider from "./openai-codex.js";
+import openRouterProvider from "./openrouter.js";
+import type { UsageProviderDefinition } from "./types.js";
+import zaiProvider from "./zai.js";
+
+export const SUPPORTED_PROVIDERS: readonly UsageProviderDefinition[] = [
+  openAICodexProvider,
+  anthropicProvider,
+  githubCopilotProvider,
+  googleGeminiCliProvider,
+  openRouterProvider,
+  zaiProvider,
+  minimaxProvider,
+];
+
+const SUPPORTED_PROVIDER_BY_ID = new Map<string, UsageProviderDefinition>(
+  SUPPORTED_PROVIDERS.map((provider) => [provider.id, provider]),
+);
+
+export function getSupportedProvider(providerId: string): UsageProviderDefinition | undefined {
+  return SUPPORTED_PROVIDER_BY_ID.get(providerId);
+}