hatz-provider 1.0.0 → 1.0.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 GodSpoon
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,16 +1,15 @@
-# @hatz-ai/provider
+# hatz-provider
 
-**One command, five agents.** Install Hatz AI as a provider for any coding agent.
+Install Hatz AI as a provider for any coding agent — one command.
 
 ```bash
-export HATZ_API_KEY="your-key"
-npx @hatz-ai/provider install
+npx hatz-provider install
 ```
 
 ## Supported Agents
 
-| Agent | Config | API surface |
-|-------|--------|-------------|
+| Agent | Config location | 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 |
@@ -20,59 +19,45 @@ npx @hatz-ai/provider install
 ## Quick Start
 
 ```bash
-# One-time: set your Hatz API key
+# Set your Hatz API key (get one at https://ai.hatz.ai → Workspace → API Keys)
 export HATZ_API_KEY="hzat-..."
 
 # Install for all detected agents
-npx @hatz-ai/provider install
+npx hatz-provider install
 
-# Or target one
-npx @hatz-ai/provider install omp
-npx @hatz-ai/provider install claude-code
+# Or pick one
+npx hatz-provider install omp
+npx hatz-provider install claude-code
 ```
 
 ## Commands
 
 ```
-hatz-provider install [agent]     Install for one or all agents
+hatz-provider install [agent]     Install provider (fetches live catalog)
 hatz-provider update [agent]      Refresh models from live catalog
-hatz-provider uninstall [agent]   Remove from one or all agents
+hatz-provider uninstall [agent]   Remove provider
 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
+hatz-provider list                List all 80+ available models
 ```
 
-## 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
-```
+Agents: `omp`, `pi`, `hermes`, `claude-code`, `openclaw`, `all` (default).
 
 ## How It Works
 
-Each agent gets the appropriate config format and API surface:
+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:
+
+- **omp, pi, Claude Code** use the Anthropic Messages gateway at `https://ai.hatz.ai/v1/anthropic` — proper SSE streaming with full event payloads.
+- **Hermes, OpenClaw** use the standard OpenAI-compatible endpoint at `https://ai.hatz.ai/v1`.
 
-- **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
+## Requirements
 
-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.
+- [Bun](https://bun.sh) runtime (the CLI is TypeScript)
+- A [Hatz AI](https://ai.hatz.ai) API key
 
-## Publishing
+## Model Updates
 
-This package is published to npm from a private source repository:
+Re-run `install` or `update` anytime. Only the Hatz block in each agent's config is touched — other providers are safe.
 
-```bash
-# From the private repo
-cd providers/hatz
-npm version patch   # bump version
-npm publish --access public
-```
+## License
 
-The published tarball contains only the files listed in `package.json#files`. No secrets, tokens, or private-repo internals are included.
+MIT

package/cli.js

@@ -1,12 +1,23 @@
 #!/usr/bin/env node
-import { spawn } from "node:child_process";
+import { execSync, spawn } from "node:child_process";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
+
+// Verify bun is available before spawning (Node v24+ blocks direct .cmd execution)
+try {
+  execSync(process.platform === "win32" ? "where bun" : "which bun", { stdio: "ignore" });
+} catch {
+  console.error("❌  bun is required but not found.");
+  console.error("    Install it: npm install -g bun");
+  process.exit(1);
+}
+
 const cli = join(__dirname, "src", "cli.ts");
 const child = spawn("bun", ["run", cli, ...process.argv.slice(2)], {
   stdio: "inherit",
   env: process.env,
+  shell: process.platform === "win32",
 });
 child.on("exit", (code) => process.exit(code ?? 1));

package/package.json

@@ -1,7 +1,10 @@
 {
   "name": "hatz-provider",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "Hatz AI provider installer for coding agents — omp, pi, hermes, claude-code, openclaw",
+  "dependencies": {
+    "bun": "^1.3.0"
+  },
   "type": "module",
   "bin": {
     "hatz-provider": "./cli.js"
@@ -12,6 +15,10 @@
     "README.md",
     "CHANGELOG.md"
   ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/GodSpoon/hatz-provider.git"
+  },
   "keywords": [
     "hatz",
     "hatz-ai",
@@ -26,10 +33,5 @@
     "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

@@ -1,65 +0,0 @@
-/**
- * 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

@@ -1,91 +0,0 @@
-/**
- * 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

@@ -1,77 +0,0 @@
-/**
- * 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

@@ -1,84 +0,0 @@
-/**
- * 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

@@ -1,74 +0,0 @@
-/**
- * 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

@@ -1,47 +0,0 @@
-/**
- * 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

@@ -1,153 +0,0 @@
-#!/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();
-}