tau-all-agent 0.1.0

package/extensions/usage/shared.ts

@@ -0,0 +1,156 @@
+import type { LiveUsageMeter, LiveUsageStat } from "./types.js";
+
+export class LiveUsageUnavailableError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "LiveUsageUnavailableError";
+  }
+}
+
+export class HttpError extends Error {
+  constructor(
+    readonly status: number,
+    message: string,
+  ) {
+    super(message);
+    this.name = "HttpError";
+  }
+}
+
+export function isLiveUsageUnavailableError(error: unknown): error is LiveUsageUnavailableError {
+  return error instanceof LiveUsageUnavailableError;
+}
+
+export function readObject(value: unknown): Record<string, unknown> | undefined {
+  return value && typeof value === "object" ? (value as Record<string, unknown>) : undefined;
+}
+
+export function readNumber(value: unknown): number | undefined {
+  if (typeof value === "number") return Number.isFinite(value) ? value : undefined;
+  if (typeof value === "string" && value.trim()) {
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : undefined;
+  }
+  return undefined;
+}
+
+export function readString(value: unknown): string | undefined {
+  return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+
+export function readArray<T>(value: unknown): T[] {
+  return Array.isArray(value) ? (value as T[]) : [];
+}
+
+export function clampPercent(value: number): number {
+  return Math.max(0, Math.min(100, value));
+}
+
+export function formatPlan(plan?: string): string | undefined {
+  if (!plan) return undefined;
+  return plan
+    .split(/[_\s-]+/)
+    .filter(Boolean)
+    .map((part) => part[0]?.toUpperCase() + part.slice(1))
+    .join(" ");
+}
+
+export function formatCount(value: number): string {
+  if (!Number.isFinite(value)) return "0";
+  if (Math.abs(value) >= 1_000_000_000) return `${(value / 1_000_000_000).toFixed(1)}B`;
+  if (Math.abs(value) >= 1_000_000) return `${(value / 1_000_000).toFixed(1)}M`;
+  if (Math.abs(value) >= 10_000) return `${(value / 1_000).toFixed(1)}K`;
+  return Math.round(value).toLocaleString("en-US");
+}
+
+export function formatCurrency(value: number, currency = "USD"): string {
+  if (!Number.isFinite(value)) value = 0;
+
+  const minimumFractionDigits = Math.abs(value) >= 1 ? 2 : 4;
+  const maximumFractionDigits = Math.abs(value) >= 1_000 ? 2 : minimumFractionDigits;
+
+  return value.toLocaleString("en-US", {
+    style: "currency",
+    currency,
+    minimumFractionDigits,
+    maximumFractionDigits,
+  });
+}
+
+export function parseISODate(value: string | undefined): Date | undefined {
+  if (!value) return undefined;
+
+  const parsed = new Date(value);
+  return Number.isFinite(parsed.getTime()) ? parsed : undefined;
+}
+
+export function parseEpochDate(value: number | undefined): Date | undefined {
+  if (value === undefined) return undefined;
+
+  const epoch = value > 1_000_000_000_000 ? value : value * 1000;
+  const parsed = new Date(epoch);
+  return Number.isFinite(parsed.getTime()) ? parsed : undefined;
+}
+
+export function formatRelativeResetDescription(resetsAt?: Date): string | undefined {
+  if (!resetsAt) return undefined;
+
+  const deltaMs = resetsAt.getTime() - Date.now();
+  if (deltaMs <= 0) return "reset imminent";
+
+  const minutes = Math.round(deltaMs / 60_000);
+  if (minutes < 60) return `resets in ~${minutes}m`;
+
+  const hours = Math.round(deltaMs / 3_600_000);
+  if (hours < 48) return `resets in ~${hours}h`;
+
+  const days = Math.round(deltaMs / 86_400_000);
+  return `resets in ~${days}d`;
+}
+
+export function formatWindowLabel(windowMinutes?: number): string | undefined {
+  if (!windowMinutes || windowMinutes <= 0) return undefined;
+  if (windowMinutes % (24 * 60) === 0) return `${windowMinutes / (24 * 60)}d`;
+  if (windowMinutes % 60 === 0) return `${windowMinutes / 60}h`;
+  return `${windowMinutes}m`;
+}
+
+export function formatUsedPercent(usedPercent: number): string {
+  return `${Math.round(clampPercent(usedPercent))}% used`;
+}
+
+export function makeMeterItem(options: {
+  key: string;
+  label: string;
+  usedPercent: number;
+  windowLabel?: string;
+  resetsAt?: Date;
+  resetDescription?: string;
+  detail?: string;
+}): LiveUsageMeter {
+  const usedPercent = clampPercent(options.usedPercent);
+  return {
+    kind: "meter",
+    key: options.key,
+    label: options.label,
+    usedPercent,
+    windowLabel: options.windowLabel,
+    resetDescription: options.resetDescription ?? formatRelativeResetDescription(options.resetsAt),
+    detail: options.detail,
+  };
+}
+
+export function makeStatItem(options: {
+  key: string;
+  label: string;
+  value: string;
+  detail?: string;
+}): LiveUsageStat {
+  return {
+    kind: "stat",
+    key: options.key,
+    label: options.label,
+    value: options.value,
+    detail: options.detail,
+  };
+}

package/extensions/usage/types.ts

@@ -0,0 +1,53 @@
+import type { ExtensionContext } from "@mariozechner/pi-coding-agent";
+
+export interface RGB {
+  r: number;
+  g: number;
+  b: number;
+}
+
+export type SupportedProviderId =
+  | "openai-codex"
+  | "anthropic"
+  | "github-copilot"
+  | "google-gemini-cli"
+  | "openrouter"
+  | "zai"
+  | "minimax";
+
+export interface LiveUsageMeter {
+  kind: "meter";
+  key: string;
+  label: string;
+  usedPercent: number;
+  windowLabel?: string;
+  resetDescription?: string;
+  detail?: string;
+}
+
+export interface LiveUsageStat {
+  kind: "stat";
+  key: string;
+  label: string;
+  value: string;
+  detail?: string;
+}
+
+export type LiveUsageItem = LiveUsageMeter | LiveUsageStat;
+
+export interface LiveUsageSnapshot {
+  plan?: string;
+  fetchedAt: Date;
+  items: LiveUsageItem[];
+}
+
+export type LiveUsageAvailability = { available: true } | { available: false; reason: string };
+
+export interface UsageProviderDefinition {
+  id: SupportedProviderId;
+  label: string;
+  shortLabel: string;
+  color: RGB;
+  getLiveUsageAvailability?(ctx: ExtensionContext): Promise<LiveUsageAvailability>;
+  fetchLiveUsage(ctx: ExtensionContext, signal?: AbortSignal): Promise<LiveUsageSnapshot>;
+}

package/extensions/usage/zai.ts

@@ -0,0 +1,186 @@
+import type { ExtensionContext } from "@mariozechner/pi-coding-agent";
+import {
+  clampPercent,
+  formatCount,
+  formatPlan,
+  formatWindowLabel,
+  LiveUsageUnavailableError,
+  makeMeterItem,
+  parseEpochDate,
+  readArray,
+  readNumber,
+  readObject,
+  readString,
+} from "./shared.js";
+import type { LiveUsageItem, LiveUsageSnapshot, UsageProviderDefinition } from "./types.js";
+
+const PROVIDER_ID = "zai";
+const QUOTA_URL = "https://api.z.ai/api/monitor/usage/quota/limit";
+
+type LimitType = "TIME_LIMIT" | "TOKENS_LIMIT";
+
+interface LimitEntry {
+  type: LimitType;
+  windowMinutes?: number;
+  usage?: number;
+  currentValue?: number;
+  remaining?: number;
+  usedPercent: number;
+  nextResetTime?: Date;
+}
+
+function windowMinutes(unit: number | undefined, count: number | undefined): number | undefined {
+  if (!unit || !count || count <= 0) return undefined;
+  switch (unit) {
+    case 5:
+      return count;
+    case 3:
+      return count * 60;
+    case 1:
+      return count * 24 * 60;
+    case 6:
+      return count * 7 * 24 * 60;
+    default:
+      return undefined;
+  }
+}
+
+function parseLimitEntry(value: unknown): LimitEntry | undefined {
+  const input = readObject(value);
+  const rawType = readString(input?.type);
+  if (rawType !== "TIME_LIMIT" && rawType !== "TOKENS_LIMIT") return undefined;
+
+  const usage = readNumber(input?.usage);
+  const currentValue = readNumber(input?.currentValue);
+  const remaining = readNumber(input?.remaining);
+  const explicitPercent = readNumber(input?.percentage);
+  const resolvedWindowMinutes = windowMinutes(readNumber(input?.unit), readNumber(input?.number));
+  const nextResetTime = parseEpochDate(readNumber(input?.nextResetTime));
+
+  let usedPercent = explicitPercent;
+  if ((usedPercent === undefined || usedPercent <= 0) && usage !== undefined && usage > 0) {
+    if (remaining !== undefined) {
+      usedPercent = ((usage - remaining) / usage) * 100;
+    } else if (currentValue !== undefined) {
+      usedPercent = (currentValue / usage) * 100;
+    }
+  }
+
+  if (usedPercent === undefined) return undefined;
+
+  return {
+    type: rawType,
+    windowMinutes: resolvedWindowMinutes,
+    usage,
+    currentValue,
+    remaining,
+    usedPercent: clampPercent(usedPercent),
+    nextResetTime:
+      nextResetTime && Number.isFinite(nextResetTime.getTime()) ? nextResetTime : undefined,
+  };
+}
+
+function makeLimitMeter(key: string, label: string, entry: LimitEntry): LiveUsageItem {
+  let detail: string | undefined;
+  if (entry.usage !== undefined && entry.usage > 0 && entry.remaining !== undefined) {
+    detail = `${formatCount(entry.remaining)} / ${formatCount(entry.usage)} remaining`;
+  } else if (entry.usage !== undefined && entry.usage > 0 && entry.currentValue !== undefined) {
+    detail = `${formatCount(entry.currentValue)} / ${formatCount(entry.usage)} used`;
+  }
+
+  if (!detail && entry.type === "TIME_LIMIT" && entry.windowMinutes) {
+    const windowLabel = formatWindowLabel(entry.windowMinutes);
+    if (windowLabel) detail = `${windowLabel} window`;
+  }
+
+  return makeMeterItem({
+    key,
+    label,
+    usedPercent: entry.usedPercent,
+    windowLabel: entry.type === "TOKENS_LIMIT" ? formatWindowLabel(entry.windowMinutes) : undefined,
+    resetsAt: entry.nextResetTime,
+    detail,
+  });
+}
+
+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 response = await fetch(QUOTA_URL, {
+    method: "GET",
+    headers: {
+      authorization: `Bearer ${apiKey}`,
+      accept: "application/json",
+    },
+    signal,
+  });
+
+  if (response.status === 401 || response.status === 403) {
+    throw new Error("z.ai API key is invalid or expired.");
+  }
+
+  if (!response.ok) {
+    const bodyText = await response.text().catch(() => "");
+    throw new Error(
+      bodyText.trim()
+        ? `z.ai usage request failed (${response.status}): ${bodyText.trim()}`
+        : `z.ai usage request failed (${response.status}).`,
+    );
+  }
+
+  const payload = (await response.json()) as Record<string, unknown>;
+  if (payload.success !== true || readNumber(payload.code) !== 200) {
+    throw new Error(readString(payload.msg) ?? "z.ai usage request failed.");
+  }
+
+  const data = readObject(payload.data);
+  const rawLimits = readArray<unknown>(data?.limits);
+  const limits = rawLimits
+    .map(parseLimitEntry)
+    .filter((entry): entry is LimitEntry => Boolean(entry));
+
+  const tokenLimits = limits
+    .filter((entry) => entry.type === "TOKENS_LIMIT")
+    .sort(
+      (left, right) =>
+        (left.windowMinutes ?? Number.MAX_SAFE_INTEGER) -
+        (right.windowMinutes ?? Number.MAX_SAFE_INTEGER),
+    );
+  const timeLimit = limits.find((entry) => entry.type === "TIME_LIMIT");
+
+  const items: LiveUsageItem[] = [];
+  const sessionTokenLimit = tokenLimits[0];
+  const longTokenLimit = tokenLimits.length > 1 ? tokenLimits[tokenLimits.length - 1] : undefined;
+
+  if (sessionTokenLimit) items.push(makeLimitMeter("session-tokens", "Tokens", sessionTokenLimit));
+  if (longTokenLimit && longTokenLimit !== sessionTokenLimit) {
+    items.push(makeLimitMeter("tokens", "Tokens", longTokenLimit));
+  }
+  if (timeLimit) items.push(makeLimitMeter("time", "Time", timeLimit));
+
+  if (items.length === 0) {
+    throw new Error("z.ai did not return any live quota data.");
+  }
+
+  return {
+    plan: formatPlan(
+      readString(data?.planName) ??
+        readString(data?.plan) ??
+        readString(data?.plan_type) ??
+        readString(data?.packageName),
+    ),
+    fetchedAt: new Date(),
+    items,
+  };
+}
+
+const zaiProvider: UsageProviderDefinition = {
+  id: PROVIDER_ID,
+  label: "z.ai",
+  shortLabel: "zai",
+  color: { r: 232, g: 90, b: 106 },
+  fetchLiveUsage: fetchUsage,
+};
+
+export default zaiProvider;

package/extensions/websearch/README.md

@@ -0,0 +1,68 @@
+# websearch
+
+Web search via Gemini, OpenAI, or Claude, leveraging Pi or browser sessions.
+
+Current routes:
+
+- `pi:openai-codex`
+- `pi:anthropic`
+- `pi:gemini`
+- `firefox:gemini`
+- `firefox:openai-codex`
+- `chromium:gemini`
+- `chromium:openai-codex`
+
+## Config
+
+Optional config file:
+
+- `~/.pi/websearch.json`
+
+Example:
+
+```json
+{
+  "routes": [
+    "pi:openai-codex",
+    "pi:anthropic",
+    "pi:gemini",
+    "firefox:gemini",
+    "firefox:openai-codex",
+    "chromium:gemini",
+    "chromium:openai-codex"
+  ],
+  "profiles": {
+    "firefox": "default-release",
+    "chromium": "Default"
+  }
+}
+```
+
+Defaults:
+
+- default routes match the example above
+- if `routes` is set, only those routes are tried, in that order
+- Pi routes try the current Pi model first within the matching provider family, then fall back to another available model from that family
+
+`profiles` only applies to browser-backed routes. It pins which local Firefox or Chromium profile to read cookies from.
+
+## Usage
+
+In Pi, the extension exposes:
+
+- tool: `websearch`
+
+Examples:
+
+- `websearch({ query: "latest Todoist release notes" })`
+- `websearch({ query: "how does Pi compaction work" })`
+
+## Notes
+
+- Pi-backed API routes are preferred, with browser fallbacks after that.
+- Browser routes use existing local browser sessions.
+- Browser profiles are auto-discovered unless pinned in config.
+- Supported Chromium-family browsers are Chromium, Chrome, Brave, and Edge.
+- Browser discovery currently supports macOS and Linux, not Windows.
+- On macOS, Chromium-based browsers may prompt for Keychain access so cookies can be decrypted.
+- If one route fails, the extension falls through to the next one.