hatz-provider 1.0.0

package/CHANGELOG.md

@@ -0,0 +1,18 @@
+# Changelog
+
+## [1.0.0] — 2026-07-21
+
+### Added
+- Initial release: Hatz AI provider installer for coding agents
+- Multi-agent support: omp, pi, Claude Code, Hermes, OpenClaw
+- Live model catalog fetch from Hatz API (80+ models)
+- `install` / `update` / `uninstall` / `status` / `list` / `catalog` commands
+- Auto-detection of installed agents
+- Per-agent API surface selection (anthropic-messages vs openai-completions)
+- Guard-commented config blocks — safe to merge with existing configs
+- Zero hardcoded secrets — API key always from environment
+
+### Design decisions
+- **Anthropic Messages** for omp/pi/claude-code: proper SSE streaming, full event payloads
+- **OpenAI Completions** for hermes/openclaw: only OpenAI-compatible surfaces supported
+- **Literal API keys** in config files: agents that don't resolve `$VAR` env references get the key directly; pi resolves `$HATZ_API_KEY` natively

package/README.md

@@ -0,0 +1,78 @@
+# @hatz-ai/provider
+
+**One command, five agents.** Install Hatz AI as a provider for any coding agent.
+
+```bash
+export HATZ_API_KEY="your-key"
+npx @hatz-ai/provider install
+```
+
+## Supported Agents
+
+| Agent | Config | API surface |
+|-------|--------|-------------|
+| [omp](https://omp.sh) | `~/.omp/agent/models.yml` | anthropic-messages |
+| [pi](https://pi.dev) | `~/.pi/extensions/hatz/` | anthropic-messages |
+| [Claude Code](https://claude.ai) | `~/.claude/.env` | anthropic-messages |
+| [Hermes](https://hermesagent.com) | `~/.hermes/config.yaml` + `.env` | openai-completions |
+| [OpenClaw](https://openclaw.ai) | `~/.openclaw/openclaw.json` | openai-completions |
+
+## Quick Start
+
+```bash
+# One-time: set your Hatz API key
+export HATZ_API_KEY="hzat-..."
+
+# Install for all detected agents
+npx @hatz-ai/provider install
+
+# Or target one
+npx @hatz-ai/provider install omp
+npx @hatz-ai/provider install claude-code
+```
+
+## Commands
+
+```
+hatz-provider install [agent]     Install for one or all agents
+hatz-provider update [agent]      Refresh models from live catalog
+hatz-provider uninstall [agent]   Remove from one or all agents
+hatz-provider status              Show install status across agents
+hatz-provider list                List all 80+ available Hatz models
+hatz-provider catalog             Print omp models.yml block
+```
+
+## Model Updates
+
+Re-run `install` or `update` anytime to refresh from Hatz's live catalog. Only the Hatz block in each agent's config is touched — other providers are safe.
+
+## API Key
+
+Generate from **Workspace > API Keys** in your [Hatz dashboard](https://ai.hatz.ai).
+
+```bash
+export HATZ_API_KEY="hzat-..."
+# or add to ~/.bashrc / ~/.zshrc
+```
+
+## How It Works
+
+Each agent gets the appropriate config format and API surface:
+
+- **omp, pi, Claude Code** → Anthropic Messages gateway (`https://ai.hatz.ai/v1/anthropic`) — proper SSE streaming, full event payloads
+- **Hermes, OpenClaw** → OpenAI Chat Completions (`https://ai.hatz.ai/v1`) — standard OpenAI-compatible endpoint
+
+The installer fetches Hatz's live model catalog (80+ models across Anthropic, OpenAI, Google, xAI, DeepSeek, Meta, Mistral, and more) and writes the appropriate config for each agent.
+
+## Publishing
+
+This package is published to npm from a private source repository:
+
+```bash
+# From the private repo
+cd providers/hatz
+npm version patch   # bump version
+npm publish --access public
+```
+
+The published tarball contains only the files listed in `package.json#files`. No secrets, tokens, or private-repo internals are included.

package/cli.js

@@ -0,0 +1,12 @@
+#!/usr/bin/env node
+import { spawn } from "node:child_process";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const cli = join(__dirname, "src", "cli.ts");
+const child = spawn("bun", ["run", cli, ...process.argv.slice(2)], {
+  stdio: "inherit",
+  env: process.env,
+});
+child.on("exit", (code) => process.exit(code ?? 1));

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "hatz-provider",
+  "version": "1.0.0",
+  "description": "Hatz AI provider installer for coding agents — omp, pi, hermes, claude-code, openclaw",
+  "type": "module",
+  "bin": {
+    "hatz-provider": "./cli.js"
+  },
+  "files": [
+    "src",
+    "cli.js",
+    "README.md",
+    "CHANGELOG.md"
+  ],
+  "keywords": [
+    "hatz",
+    "hatz-ai",
+    "provider",
+    "llm",
+    "ai",
+    "omp",
+    "oh-my-pi",
+    "pi",
+    "hermes",
+    "claude-code",
+    "openclaw",
+    "gateway"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/GodSpoon/ai-tooling.git",
+    "directory": "providers/hatz"
+  },
+  "license": "MIT"
+}

package/src/agents/claude-code.ts

@@ -0,0 +1,65 @@
+/**
+ * Claude Code config generator.
+ *
+ * Sets ANTHROPIC_BASE_URL + ANTHROPIC_API_KEY env vars.
+ * Writes to ~/.claude/.env (shell-sourced) and offers shell profile option.
+ */
+import { writeFile, mkdir, readFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import type { HatzModel } from "../catalog";
+
+const ENV_FILE = join(homedir(), ".claude", ".env");
+const BASE_URL = "https://ai.hatz.ai/v1/anthropic";
+
+export function agentName(): string {
+  return "Claude Code";
+}
+
+export async function isInstalled(): Promise<boolean> {
+  try {
+    const content = await readFile(ENV_FILE, "utf-8");
+    return content.includes("# === Hatz AI ===");
+  } catch {
+    return false;
+  }
+}
+
+export async function install(models: HatzModel[], apiKey: string): Promise<void> {
+  await mkdir(join(homedir(), ".claude"), { recursive: true });
+
+  const block = [
+    "# === Hatz AI ===",
+    `ANTHROPIC_BASE_URL=${BASE_URL}`,
+    `ANTHROPIC_API_KEY=${apiKey}`,
+    "# Model aliases: sonnet, opus, haiku resolve to latest Claude family models",
+    `# Available: ${models.filter(m => m.developer === "Anthropic").map(m => m.name).slice(0, 5).join(", ")}...`,
+    "# === end Hatz AI ===",
+  ].join("\n") + "\n";
+
+  let existing = "";
+  try { existing = await readFile(ENV_FILE, "utf-8"); } catch { /* new file */ }
+
+  const guard = "# === Hatz AI ===";
+  const guardEnd = "# === end Hatz AI ===";
+  const start = existing.indexOf(guard);
+  const end = existing.indexOf(guardEnd);
+  if (start !== -1 && end !== -1) {
+    existing = existing.slice(0, start) + existing.slice(end + guardEnd.length);
+  }
+
+  await writeFile(ENV_FILE, [existing.trimEnd(), block].filter(Boolean).join("\n\n") + "\n", "utf-8");
+}
+
+export async function uninstall(): Promise<void> {
+  let content = "";
+  try { content = await readFile(ENV_FILE, "utf-8"); } catch { return; }
+  const guard = "# === Hatz AI ===";
+  const guardEnd = "# === end Hatz AI ===";
+  const start = content.indexOf(guard);
+  const end = content.indexOf(guardEnd);
+  if (start !== -1 && end !== -1) {
+    content = content.slice(0, start) + content.slice(end + guardEnd.length);
+    await writeFile(ENV_FILE, content.trimEnd() + "\n", "utf-8");
+  }
+}

package/src/agents/hermes.ts

@@ -0,0 +1,91 @@
+/**
+ * Hermes agent config generator.
+ *
+ * Writes to ~/.hermes/config.yaml + ~/.hermes/.env
+ * Uses openai-completions API (Hermes is OpenAI-compatible only).
+ */
+import { writeFile, mkdir, readFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import type { HatzModel } from "../catalog";
+
+const HERMES_DIR = join(homedir(), ".hermes");
+const CONFIG_PATH = join(HERMES_DIR, "config.yaml");
+const ENV_PATH = join(HERMES_DIR, ".env");
+const BASE_URL = "https://ai.hatz.ai/v1";
+const API = "openai-completions";
+const GUARD = "# === Hatz AI ===";
+const GUARD_END = "# === end Hatz AI ===";
+
+export function agentName(): string {
+  return "Hermes Agent";
+}
+
+export async function isInstalled(): Promise<boolean> {
+  try {
+    const content = await readFile(CONFIG_PATH, "utf-8");
+    return content.includes(GUARD);
+  } catch {
+    return false;
+  }
+}
+
+export async function install(models: HatzModel[], apiKey: string): Promise<void> {
+  await mkdir(HERMES_DIR, { recursive: true });
+
+  // Write .env with API key
+  const envBlock = [
+    GUARD,
+    `HATZ_API_KEY=${apiKey}`,
+    GUARD_END,
+  ].join("\n") + "\n";
+
+  let existingEnv = "";
+  try { existingEnv = await readFile(ENV_PATH, "utf-8"); } catch { /* new */ }
+  const envStart = existingEnv.indexOf(GUARD);
+  const envEnd = existingEnv.indexOf(GUARD_END);
+  if (envStart !== -1 && envEnd !== -1) {
+    existingEnv = existingEnv.slice(0, envStart) + existingEnv.slice(envEnd + GUARD_END.length);
+  }
+  await writeFile(ENV_PATH, [existingEnv.trimEnd(), envBlock].filter(Boolean).join("\n\n") + "\n", "utf-8");
+
+  // Write config.yaml with provider definition
+  const modelIds = models.map(m => `hatz/${m.name}`).join("\n");
+  const configBlock = [
+    GUARD,
+    "# Hermes uses the standard OpenAI chat completions endpoint.",
+    `# Base URL: ${BASE_URL}`,
+    "# API key: $HATZ_API_KEY (from ~/.hermes/.env)",
+    "#",
+    "# Add models to your defaults:",
+    "#   models:",
+    "#     - hatz/gpt-5.2",
+    "#     - hatz/anthropic.claude-sonnet-4-5",
+    "#",
+    "# Run `hermes doctor` to verify after setup.",
+    GUARD_END,
+  ].join("\n") + "\n";
+
+  let existingConfig = "";
+  try { existingConfig = await readFile(CONFIG_PATH, "utf-8"); } catch { /* new */ }
+  const cfgStart = existingConfig.indexOf(GUARD);
+  const cfgEnd = existingConfig.indexOf(GUARD_END);
+  if (cfgStart !== -1 && cfgEnd !== -1) {
+    existingConfig = existingConfig.slice(0, cfgStart) + existingConfig.slice(cfgEnd + GUARD_END.length);
+  }
+  await writeFile(CONFIG_PATH, [existingConfig.trimEnd(), configBlock].filter(Boolean).join("\n\n") + "\n", "utf-8");
+}
+
+export async function uninstall(): Promise<void> {
+  for (const path of [CONFIG_PATH, ENV_PATH]) {
+    try {
+      let content = await readFile(path, "utf-8");
+      const start = content.indexOf(GUARD);
+      const end = content.indexOf(GUARD_END);
+      if (start !== -1 && end !== -1) {
+        content = content.slice(0, start) + content.slice(end + GUARD_END.length);
+        await writeFile(path, content.trimEnd() + "\n", "utf-8");
+      }
+    } catch { /* didn't exist */ }
+  }
+}

package/src/agents/omp.ts

@@ -0,0 +1,77 @@
+/**
+ * omp (Oh My Pi) config generator.
+ *
+ * Writes to ~/.omp/agent/models.yml using anthropic-messages API.
+ * Guard-commented block, safe to merge with existing config.
+ */
+import { readFile, writeFile, mkdir, stat } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import type { HatzModel } from "../catalog";
+import { estimateContextWindow, clampMaxTokens, inputCapabilities } from "../catalog";
+
+const OMP_DIR = join(homedir(), ".omp", "agent");
+const CONFIG_PATH = join(OMP_DIR, "models.yml");
+const GUARD = "# === Hatz AI ===";
+const GUARD_END = "# === end Hatz AI ===";
+
+const BASE_URL = "https://ai.hatz.ai/v1/anthropic";
+const API = "anthropic-messages";
+
+export function agentName(): string {
+  return "omp (Oh My Pi)";
+}
+
+export async function isInstalled(): Promise<boolean> {
+  try { await stat(CONFIG_PATH); return true; } catch { return false; }
+}
+
+export function generateBlock(models: HatzModel[], apiKey: string): string {
+  const lines = [GUARD];
+  lines.push("  hatz:");
+  lines.push(`    baseUrl: ${BASE_URL}`);
+  lines.push(`    api: ${API}`);
+  lines.push(`    apiKey: "${apiKey}"`);
+  lines.push("    models:");
+
+  for (const m of models) {
+    lines.push(`      - id: ${m.name}`);
+    lines.push(`        name: ${m.display_name} (Hatz)`);
+    lines.push(`        contextWindow: ${estimateContextWindow(m)}`);
+    lines.push(`        maxTokens: ${clampMaxTokens(m.max_tokens)}`);
+    lines.push("        reasoning: true");
+    lines.push(`        input: ${inputCapabilities(m)}`);
+  }
+
+  lines.push(GUARD_END);
+  return lines.join("\n");
+}
+
+export async function install(models: HatzModel[], apiKey: string): Promise<void> {
+  await mkdir(OMP_DIR, { recursive: true });
+
+  let existing = "";
+  try { existing = await readFile(CONFIG_PATH, "utf-8"); } catch { /* new file */ }
+
+  const start = existing.indexOf(GUARD);
+  const end = existing.indexOf(GUARD_END);
+  if (start !== -1 && end !== -1) {
+    existing = existing.slice(0, start) + existing.slice(end + GUARD_END.length);
+  }
+
+  const block = generateBlock(models, apiKey);
+  const merged = [existing.trimEnd(), block].filter(Boolean).join("\n\n") + "\n";
+  await writeFile(CONFIG_PATH, merged, "utf-8");
+}
+
+export async function uninstall(): Promise<void> {
+  let content = "";
+  try { content = await readFile(CONFIG_PATH, "utf-8"); } catch { return; }
+
+  const start = content.indexOf(GUARD);
+  const end = content.indexOf(GUARD_END);
+  if (start !== -1 && end !== -1) {
+    content = content.slice(0, start) + content.slice(end + GUARD_END.length);
+    await writeFile(CONFIG_PATH, content.trimEnd() + "\n", "utf-8");
+  }
+}

package/src/agents/openclaw.ts

@@ -0,0 +1,84 @@
+/**
+ * OpenClaw config generator.
+ *
+ * Writes to ~/.openclaw/openclaw.json — merges into existing config.
+ * Uses openai-completions API.
+ */
+import { readFile, writeFile, mkdir } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import type { HatzModel } from "../catalog";
+import { estimateContextWindow, clampMaxTokens, inputCapabilities } from "../catalog";
+
+const CONFIG_PATH = join(homedir(), ".openclaw", "openclaw.json");
+const BASE_URL = "https://ai.hatz.ai/v1";
+const API = "openai-completions";
+const PROVIDER_ID = "hatz";
+
+export function agentName(): string {
+  return "OpenClaw";
+}
+
+export async function isInstalled(): Promise<boolean> {
+  try {
+    const raw = await readFile(CONFIG_PATH, "utf-8");
+    const cfg = JSON.parse(raw);
+    return cfg?.models?.providers?.[PROVIDER_ID] != null;
+  } catch {
+    return false;
+  }
+}
+
+export function generateConfig(models: HatzModel[], apiKey: string): Record<string, unknown> {
+  return {
+    models: {
+      providers: {
+        [PROVIDER_ID]: {
+          baseUrl: BASE_URL,
+          apiKey: apiKey,
+          api: API,
+          models: models.map((m) => ({
+            id: m.name,
+            name: `${m.display_name} (Hatz)`,
+          })),
+        },
+      },
+    },
+  };
+}
+
+export async function install(models: HatzModel[], apiKey: string): Promise<void> {
+  await mkdir(join(homedir(), ".openclaw"), { recursive: true });
+
+  let cfg: Record<string, unknown> = {};
+  try {
+    const raw = await readFile(CONFIG_PATH, "utf-8");
+    cfg = JSON.parse(raw);
+  } catch { /* new file */ }
+
+  // Deep merge the provider config
+  const modelsCfg = (cfg.models as Record<string, unknown>) ?? {};
+  const providers = (modelsCfg.providers as Record<string, unknown>) ?? {};
+  const newCfg = generateConfig(models, apiKey);
+  const newProviders = (newCfg.models as Record<string, unknown>).providers as Record<string, unknown>;
+
+  cfg.models = { ...modelsCfg, providers: { ...providers, ...newProviders } };
+
+  await writeFile(CONFIG_PATH, JSON.stringify(cfg, null, 2) + "\n", "utf-8");
+}
+
+export async function uninstall(): Promise<void> {
+  let cfg: Record<string, unknown> = {};
+  try {
+    const raw = await readFile(CONFIG_PATH, "utf-8");
+    cfg = JSON.parse(raw);
+  } catch { return; }
+
+  const modelsCfg = cfg.models as Record<string, unknown> | undefined;
+  if (!modelsCfg) return;
+  const providers = modelsCfg.providers as Record<string, unknown> | undefined;
+  if (!providers) return;
+
+  delete providers[PROVIDER_ID];
+  await writeFile(CONFIG_PATH, JSON.stringify(cfg, null, 2) + "\n", "utf-8");
+}

package/src/agents/pi.ts

@@ -0,0 +1,74 @@
+/**
+ * Pi (pi.dev) extension generator.
+ *
+ * Creates ~/.pi/extensions/hatz/ with package.json + index.ts.
+ * Pi resolves $VAR env references in apiKey — no literal key needed.
+ */
+import { writeFile, mkdir } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import type { HatzModel } from "../catalog";
+import { estimateContextWindow, clampMaxTokens, inputCapabilities } from "../catalog";
+
+const EXT_DIR = join(homedir(), ".pi", "extensions", "hatz");
+const BASE_URL = "https://ai.hatz.ai/v1/anthropic";
+const API = "anthropic-messages";
+
+export function agentName(): string {
+  return "pi (pi.dev)";
+}
+
+export async function isInstalled(): Promise<boolean> {
+  try { await (await import("node:fs/promises")).stat(join(EXT_DIR, "index.ts")); return true; } catch { return false; }
+}
+
+function generateIndex(models: HatzModel[]): string {
+  const modelDefs = models.map((m) => {
+    return `      {
+        id: "${m.name}",
+        name: "${m.display_name} (Hatz)",
+        reasoning: true,
+        input: [${m.vision ? '"text", "image"' : '"text"'}],
+        cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+        contextWindow: ${estimateContextWindow(m)},
+        maxTokens: ${clampMaxTokens(m.max_tokens)},
+      }`;
+  }).join(",\n");
+
+  return `import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+
+export default function (pi: ExtensionAPI) {
+  pi.registerProvider("hatz", {
+    name: "Hatz AI",
+    baseUrl: "${BASE_URL}",
+    apiKey: "$HATZ_API_KEY",
+    api: "${API}",
+    models: [
+${modelDefs}
+    ],
+  });
+}
+`;
+}
+
+export async function install(models: HatzModel[], _apiKey: string): Promise<void> {
+  await mkdir(EXT_DIR, { recursive: true });
+
+  await writeFile(join(EXT_DIR, "package.json"), JSON.stringify({
+    name: "pi-extension-hatz",
+    version: "1.0.0",
+    private: true,
+    type: "module",
+    main: "index.ts",
+    dependencies: {
+      "@earendil-works/pi-coding-agent": "*",
+    },
+  }, null, 2) + "\n", "utf-8");
+
+  await writeFile(join(EXT_DIR, "index.ts"), generateIndex(models), "utf-8");
+}
+
+export async function uninstall(): Promise<void> {
+  const { rm } = await import("node:fs/promises");
+  try { await rm(EXT_DIR, { recursive: true }); } catch { /* didn't exist */ }
+}

package/src/catalog.ts

@@ -0,0 +1,47 @@
+/**
+ * Hatz AI model catalog — fetches and normalizes the full model list.
+ */
+
+export interface HatzModel {
+  name: string;
+  developer: string;
+  display_name: string;
+  max_tokens: number;
+  vision: boolean;
+}
+
+const CATALOG_URL = "https://ai.hatz.ai/v1/chat/models";
+
+export async function fetchCatalog(apiKey: string): Promise<HatzModel[]> {
+  const resp = await fetch(CATALOG_URL, {
+    headers: { "X-API-Key": apiKey, Accept: "application/json" },
+  });
+  if (!resp.ok) throw new Error(`Hatz catalog fetch failed: ${resp.status}`);
+  const data = (await resp.json()) as { data?: HatzModel[]; models?: HatzModel[] };
+  const models = data.data ?? data.models ?? [];
+  return models.filter((m) => m.name !== "auto");
+}
+
+/** Estimate context window for a model based on its name/developer. */
+export function estimateContextWindow(model: HatzModel): number {
+  const n = model.name;
+  if (/gpt.*(5\.[12456]|5-nano|5-mini|5-chat|[o]3|[o]4|4o)/.test(n)) return 128_000;
+  if (/gpt-4\.1/.test(n)) return 1_048_576;
+  if (/gemini-3|gemini-2\.5/.test(n)) return 1_048_576;
+  if (/llama/.test(n)) return 128_000;
+  if (/deepseek/.test(n)) return 128_000;
+  if (/claude/.test(n)) return 200_000;
+  if (/grok/.test(n)) return 131_072;
+  if (/kimi|moonshot/.test(n)) return 131_072;
+  return 200_000;
+}
+
+/** Cap max tokens to a reasonable value. */
+export function clampMaxTokens(raw: number): number {
+  return Math.min(raw, 128_000) || 16_384;
+}
+
+/** Resolve input modalities. */
+export function inputCapabilities(model: HatzModel): string {
+  return model.vision ? "[text, image]" : "[text]";
+}

package/src/cli.ts

@@ -0,0 +1,153 @@
+#!/usr/bin/env bun
+/**
+ * hatz-provider — Hatz AI provider installer for coding agents.
+ *
+ * Commands:
+ *   hatz-provider install [agent]    Install for one or all agents
+ *   hatz-provider update [agent]     Refresh models (same as install)
+ *   hatz-provider uninstall [agent]  Remove from one or all agents
+ *   hatz-provider list               List available models from Hatz
+ *   hatz-provider status             Show install status across agents
+ *   hatz-provider catalog            Print models.yml block (for omp)
+ *
+ * Agents: omp, pi, hermes, claude-code, openclaw, all
+ *
+ * Auto-detects installed agents. Uses anthropic-messages gateway
+ * for omp/pi/claude-code and openai-completions for hermes/openclaw.
+ */
+import { fetchCatalog, type HatzModel } from "./catalog";
+
+// Lazy-load agent modules to avoid importing fs for agents not being used.
+type AgentModule = {
+  agentName: () => string;
+  isInstalled: () => Promise<boolean>;
+  install: (models: HatzModel[], apiKey: string) => Promise<void>;
+  uninstall: () => Promise<void>;
+};
+
+const AGENT_IDS = ["omp", "pi", "hermes", "claude-code", "openclaw"] as const;
+type AgentId = (typeof AGENT_IDS)[number];
+
+async function loadAgent(id: AgentId): Promise<AgentModule> {
+  return import(`./agents/${id}.ts`);
+}
+
+function getApiKey(): string {
+  return process.env.HATZ_API_KEY || "";
+}
+
+function bail(msg: string): never {
+  console.error(`❌  ${msg}`);
+  process.exit(1);
+}
+
+// ── Commands ───────────────────────────────────────────────────────────
+
+async function cmdInstall(agentId?: string): Promise<void> {
+  const apiKey = getApiKey();
+  if (!apiKey) bail("HATZ_API_KEY is not set.\n    export HATZ_API_KEY=\"your-key\"");
+
+  console.log("📡  Fetching Hatz model catalog...");
+  let models: HatzModel[];
+  try {
+    models = await fetchCatalog(apiKey);
+    console.log(`    Found ${models.length} models`);
+  } catch (err: unknown) {
+    bail(`Failed to fetch catalog: ${err instanceof Error ? err.message : err}`);
+  }
+
+  const targets = agentId ? [agentId as AgentId] : [...AGENT_IDS];
+  for (const id of targets) {
+    try {
+      const agent = await loadAgent(id);
+      console.log(`\n🔧  ${agent.agentName()}...`);
+      await agent.install(models, apiKey);
+      console.log(`    ✅  Installed`);
+    } catch (err: unknown) {
+      console.log(`    ⚠   Skipped: ${err instanceof Error ? err.message : err}`);
+    }
+  }
+  console.log(`\n🎉  Done!`);
+}
+
+async function cmdUninstall(agentId?: string): Promise<void> {
+  const targets = agentId ? [agentId as AgentId] : [...AGENT_IDS];
+  for (const id of targets) {
+    try {
+      const agent = await loadAgent(id);
+      console.log(`🗑   ${agent.agentName()}...`);
+      await agent.uninstall();
+      console.log(`    ✅  Removed`);
+    } catch {
+      console.log(`    ⚠   Skipped (not found)`);
+    }
+  }
+  console.log(`\n✅  Done.`);
+}
+
+async function cmdStatus(): Promise<void> {
+  console.log("Hatz AI provider status:\n");
+  for (const id of AGENT_IDS) {
+    try {
+      const agent = await loadAgent(id);
+      const installed = await agent.isInstalled();
+      console.log(`  ${installed ? "✅" : "⬜"}  ${agent.agentName()}`);
+    } catch {
+      console.log(`  ❓  ${id}`);
+    }
+  }
+}
+
+async function cmdList(): Promise<void> {
+  const apiKey = getApiKey();
+  if (!apiKey) bail("HATZ_API_KEY is not set.");
+
+  console.log("📡  Fetching Hatz model catalog...\n");
+  const models = await fetchCatalog(apiKey);
+  for (const m of models) {
+    console.log(`  ${m.name.padEnd(48)} ${m.developer.padEnd(14)} ${m.vision ? "👁  " : "📝"}  ${(m.max_tokens / 1000).toFixed(0)}K max`);
+  }
+  console.log(`\n  ${models.length} models total`);
+}
+
+async function cmdHelp(): Promise<void> {
+  console.log("hatz-provider — Hatz AI provider for coding agents\n");
+  console.log("Usage:");
+  console.log("  hatz-provider install [agent]     Install Hatz provider");
+  console.log("  hatz-provider update [agent]      Refresh models from live catalog");
+  console.log("  hatz-provider uninstall [agent]   Remove Hatz provider");
+  console.log("  hatz-provider status              Show install status");
+  console.log("  hatz-provider list                List available Hatz models");
+  console.log("  hatz-provider catalog             Print omp models.yml block\n");
+  console.log("Agents: omp, pi, hermes, claude-code, openclaw, all (default)");
+  console.log("Auto-detects installed agents. Uses appropriate API per agent.");
+  console.log("\nAPI surfaces used:");
+  console.log("  omp, pi, claude-code    → anthropic-messages");
+  console.log("  hermes, openclaw        → openai-completions");
+  console.log("\nEnvironment:");
+  console.log("  HATZ_API_KEY            Your Hatz API key (required)");
+}
+
+// ── Main ───────────────────────────────────────────────────────────────
+
+const cmd = process.argv[2];
+const target = process.argv[3];
+
+if (cmd === "install" || cmd === "i" || cmd === "update" || cmd === "up") {
+  await cmdInstall(target);
+} else if (cmd === "uninstall" || cmd === "u" || cmd === "remove" || cmd === "rm") {
+  await cmdUninstall(target);
+} else if (cmd === "status" || cmd === "st") {
+  await cmdStatus();
+} else if (cmd === "list" || cmd === "ls") {
+  await cmdList();
+} else if (cmd === "catalog" || cmd === "cat") {
+  // Just the omp block for backward compat
+  const apiKey = getApiKey();
+  if (!apiKey) bail("HATZ_API_KEY is not set.");
+  const models = await fetchCatalog(apiKey);
+  const { generateBlock } = await import("./agents/omp.ts");
+  console.log(generateBlock(models, apiKey));
+} else {
+  await cmdHelp();
+}