heyhank 0.1.0

package/server/internal-ai.ts

@@ -0,0 +1,237 @@
+/**
+ * Provider-agnostic internal AI caller.
+ * Used by auto-namer and ai-validator. Supports any provider from the registry
+ * via OpenAI-compatible Chat Completions format, plus Anthropic Messages API.
+ */
+import { getSettings } from "./settings-manager.js";
+import { getProviderConfig, getEnabledProviders } from "./provider-manager.js";
+import { getProviderById } from "./provider-registry.js";
+
+interface InternalAiRequest {
+  systemPrompt?: string;
+  userPrompt: string;
+  maxTokens?: number;
+  temperature?: number;
+  timeoutMs?: number;
+}
+
+interface InternalAiResponse {
+  text: string;
+  ok: boolean;
+  error?: string;
+}
+
+/** Known provider base URLs for OpenAI-compatible endpoints */
+const PROVIDER_BASE_URLS: Record<string, string> = {
+  openai: "https://api.openai.com/v1",
+  deepseek: "https://api.deepseek.com/v1",
+  mistral: "https://api.mistral.ai/v1",
+  together: "https://api.together.xyz/v1",
+  openrouter: "https://openrouter.ai/api/v1",
+  xai: "https://api.x.ai/v1",
+  groq: "https://api.groq.com/openai/v1",
+  huggingface: "https://api-inference.huggingface.co/v1",
+  venice: "https://api.venice.ai/api/v1",
+  minimax: "https://api.minimax.chat/v1",
+  moonshot: "https://api.moonshot.cn/v1",
+  qwen: "https://dashscope.aliyuncs.com/compatible-mode/v1",
+  "qwen-alibaba": "https://dashscope.aliyuncs.com/compatible-mode/v1",
+  chutes: "https://api.chutes.ai/v1",
+  zai: "https://open.bigmodel.cn/api/paas/v4",
+};
+
+/** Default small/fast models per provider (for cheap internal tasks) */
+const PROVIDER_INTERNAL_MODELS: Record<string, string> = {
+  anthropic: "claude-haiku-4-5-20251001",
+  openai: "gpt-4o-mini",
+  google: "gemini-2.0-flash",
+  mistral: "mistral-small-latest",
+  deepseek: "deepseek-chat",
+  together: "meta-llama/Llama-3.1-8B-Instruct-Turbo",
+  openrouter: "meta-llama/llama-3.1-8b-instruct:free",
+  xai: "grok-3-mini",
+  ollama: "llama3.1",
+  qwen: "qwen-turbo",
+};
+
+/**
+ * Resolve which provider and credentials to use for internal AI calls.
+ * Priority: settings.internalAiProvider > first enabled provider > anthropic legacy key
+ */
+function resolveProvider(): { providerId: string; apiKey: string; baseUrl: string; model: string } | null {
+  const settings = getSettings();
+
+  // 1. Check explicit internalAiProvider setting
+  const explicitId = settings.internalAiProvider as string | undefined;
+  if (explicitId) {
+    const result = resolveProviderById(explicitId);
+    if (result) return result;
+  }
+
+  // 2. Legacy: check anthropicApiKey in settings
+  if (settings.anthropicApiKey?.trim()) {
+    return {
+      providerId: "anthropic",
+      apiKey: settings.anthropicApiKey.trim(),
+      baseUrl: "https://api.anthropic.com/v1/messages",
+      model: settings.anthropicModel?.trim() || "claude-haiku-4-5-20251001",
+    };
+  }
+
+  // 3. Try first enabled provider
+  const enabled = getEnabledProviders();
+  for (const cfg of enabled) {
+    const result = resolveProviderById(cfg.providerId);
+    if (result) return result;
+  }
+
+  return null;
+}
+
+function resolveProviderById(id: string): { providerId: string; apiKey: string; baseUrl: string; model: string } | null {
+  const def = getProviderById(id);
+  if (!def) return null;
+
+  const cfg = getProviderConfig(id);
+  if (!cfg) return null;
+
+  // Get API key from the first secret envField
+  const secretField = def.envFields.find((f) => f.secret && f.required);
+  const apiKey = secretField ? (cfg.envValues[secretField.key] || "") : "";
+
+  // Get base URL from non-secret URL field or known defaults
+  const urlField = def.envFields.find((f) => f.key.includes("BASE_URL"));
+  let baseUrl = urlField ? (cfg.envValues[urlField.key] || "") : "";
+
+  if (!baseUrl) {
+    baseUrl = PROVIDER_BASE_URLS[id] || "";
+  }
+
+  // Special case: Ollama defaults
+  if (id === "ollama" && !baseUrl) {
+    baseUrl = "http://localhost:11434/v1";
+  }
+
+  const model = cfg.customModel || PROVIDER_INTERNAL_MODELS[id] || def.defaultModel || "";
+
+  if (id === "anthropic" && apiKey) {
+    return { providerId: id, apiKey, baseUrl: "https://api.anthropic.com/v1/messages", model };
+  }
+
+  if (!baseUrl || (!apiKey && id !== "ollama")) return null;
+  return { providerId: id, apiKey, baseUrl, model };
+}
+
+/**
+ * Call the configured internal AI provider.
+ */
+export async function callInternalAI(req: InternalAiRequest): Promise<InternalAiResponse> {
+  const provider = resolveProvider();
+  if (!provider) {
+    return { text: "", ok: false, error: "No AI provider configured for internal features" };
+  }
+
+  const timeout = req.timeoutMs || 15_000;
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeout);
+
+  try {
+    if (provider.providerId === "anthropic") {
+      return await callAnthropic(provider, req, controller.signal);
+    }
+    return await callOpenAICompatible(provider, req, controller.signal);
+  } catch (err) {
+    const isAbort = err instanceof Error && err.name === "AbortError";
+    return {
+      text: "",
+      ok: false,
+      error: isAbort ? "AI request timed out" : `AI request failed: ${err instanceof Error ? err.message : String(err)}`,
+    };
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+async function callAnthropic(
+  provider: { apiKey: string; baseUrl: string; model: string },
+  req: InternalAiRequest,
+  signal: AbortSignal,
+): Promise<InternalAiResponse> {
+  const body: Record<string, unknown> = {
+    model: provider.model,
+    max_tokens: req.maxTokens || 256,
+    messages: [{ role: "user", content: req.userPrompt }],
+    temperature: req.temperature ?? 0.2,
+  };
+  if (req.systemPrompt) body.system = req.systemPrompt;
+
+  const res = await fetch(provider.baseUrl, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "x-api-key": provider.apiKey,
+      "anthropic-version": "2023-06-01",
+    },
+    body: JSON.stringify(body),
+    signal,
+  });
+
+  if (!res.ok) {
+    return { text: "", ok: false, error: `Anthropic API error: ${res.status}` };
+  }
+
+  const data = await res.json() as { content?: Array<{ type: string; text?: string }> };
+  const text = data.content?.[0]?.type === "text" ? (data.content[0].text ?? "") : "";
+  return { text, ok: true };
+}
+
+async function callOpenAICompatible(
+  provider: { apiKey: string; baseUrl: string; model: string },
+  req: InternalAiRequest,
+  signal: AbortSignal,
+): Promise<InternalAiResponse> {
+  const url = provider.baseUrl.replace(/\/+$/, "") + "/chat/completions";
+  const messages: Array<{ role: string; content: string }> = [];
+  if (req.systemPrompt) messages.push({ role: "system", content: req.systemPrompt });
+  messages.push({ role: "user", content: req.userPrompt });
+
+  const headers: Record<string, string> = { "Content-Type": "application/json" };
+  if (provider.apiKey) headers["Authorization"] = `Bearer ${provider.apiKey}`;
+
+  const res = await fetch(url, {
+    method: "POST",
+    headers,
+    body: JSON.stringify({
+      model: provider.model,
+      max_tokens: req.maxTokens || 256,
+      messages,
+      temperature: req.temperature ?? 0.2,
+    }),
+    signal,
+  });
+
+  if (!res.ok) {
+    return { text: "", ok: false, error: `AI API error: ${res.status}` };
+  }
+
+  const data = await res.json() as { choices?: Array<{ message?: { content?: string } }> };
+  const text = data.choices?.[0]?.message?.content ?? "";
+  return { text, ok: true };
+}
+
+/**
+ * Check if any AI provider is configured for internal features.
+ */
+export function hasInternalAI(): boolean {
+  return resolveProvider() !== null;
+}
+
+/**
+ * Get the name of the currently configured internal AI provider.
+ */
+export function getInternalAIProviderName(): string | null {
+  const provider = resolveProvider();
+  if (!provider) return null;
+  const def = getProviderById(provider.providerId);
+  return def?.name ?? provider.providerId;
+}

package/server/kill-switch.ts

@@ -0,0 +1,99 @@
+// ─── Kill Switch (6-Layer Safety) ────────────────────────────────────────────
+// Ported from AgentManager/src/kill-switch.ts — simplified for HeyHank
+
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  writeFileSync,
+  unlinkSync,
+} from "node:fs";
+import { join, dirname } from "node:path";
+import { HEYHANK_HOME } from "./paths.js";
+
+// ─── Types ───────────────────────────────────────────────────────────────────
+
+export interface KillSwitchState {
+  killed: boolean;
+  reason?: string;
+  activatedAt?: string;
+}
+
+// ─── Constants ───────────────────────────────────────────────────────────────
+
+const KILL_SWITCH_FILE = join(HEYHANK_HOME, "kill-switch.json");
+
+// ─── State ───────────────────────────────────────────────────────────────────
+
+let state: KillSwitchState = { killed: false };
+
+// ─── Core Functions ──────────────────────────────────────────────────────────
+
+/** Fast in-memory check (hot path). */
+export function isKilled(): boolean {
+  return state.killed;
+}
+
+/** Get full kill switch state. */
+export function getKillSwitchState(): KillSwitchState {
+  return { ...state };
+}
+
+/** Activate the kill switch. */
+export function activate(reason?: string): KillSwitchState {
+  state = {
+    killed: true,
+    reason: reason || "Manual activation",
+    activatedAt: new Date().toISOString(),
+  };
+
+  // Persist to disk
+  try {
+    mkdirSync(dirname(KILL_SWITCH_FILE), { recursive: true });
+    writeFileSync(KILL_SWITCH_FILE, JSON.stringify(state, null, 2), "utf-8");
+  } catch (err) {
+    console.error("[kill-switch] Failed to persist:", err);
+  }
+
+  console.warn(
+    `[kill-switch] ⛔ ACTIVATED: ${state.reason} at ${state.activatedAt}`,
+  );
+  return { ...state };
+}
+
+/** Deactivate the kill switch. */
+export function deactivate(): KillSwitchState {
+  state = { killed: false };
+
+  // Remove persisted file
+  try {
+    if (existsSync(KILL_SWITCH_FILE)) {
+      unlinkSync(KILL_SWITCH_FILE);
+    }
+  } catch (err) {
+    console.error("[kill-switch] Failed to remove persisted file:", err);
+  }
+
+  console.log("[kill-switch] ✅ Deactivated");
+  return { ...state };
+}
+
+/** Load persisted state on startup. */
+export function loadPersistedState(): void {
+  try {
+    if (!existsSync(KILL_SWITCH_FILE)) return;
+    const raw = readFileSync(KILL_SWITCH_FILE, "utf-8");
+    const persisted = JSON.parse(raw) as KillSwitchState;
+    if (persisted.killed) {
+      state = persisted;
+      console.warn(
+        `[kill-switch] ⛔ Restored KILLED state: ${persisted.reason} (since ${persisted.activatedAt})`,
+      );
+    }
+  } catch (err) {
+    console.error("[kill-switch] Failed to load persisted state:", err);
+  }
+}
+
+// Load on import
+loadPersistedState();

package/server/llm-providers.ts

@@ -0,0 +1,342 @@
+// ─── Multi-LLM Provider System ───────────────────────────────────────────────
+// Unified interface for calling different LLM backends
+// Used by agents that don't need the full CLI WebSocket bridge
+
+// ─── Types ───────────────────────────────────────────────────────────────────
+
+export interface LLMMessage {
+  role: "system" | "user" | "assistant";
+  content: string;
+}
+
+export interface LLMResponse {
+  content: string;
+  model: string;
+  provider: string;
+  tokensIn?: number;
+  tokensOut?: number;
+  estimatedCost?: number;
+}
+
+export interface LLMStreamChunk {
+  content: string;
+  done: boolean;
+}
+
+export interface LLMProviderConfig {
+  provider: "ollama" | "openrouter" | "gemini";
+  model: string;
+  apiKey?: string;
+  baseUrl?: string;
+  temperature?: number;
+  maxTokens?: number;
+}
+
+// ─── Cost Estimates (USD per 1M tokens) ──────────────────────────────────────
+
+const COST_TABLE: Record<string, { input: number; output: number }> = {
+  // OpenRouter pricing (approximate)
+  "gpt-4o": { input: 2.5, output: 10 },
+  "gpt-4o-mini": { input: 0.15, output: 0.6 },
+  "claude-3-5-sonnet": { input: 3, output: 15 },
+  "deepseek-chat": { input: 0.14, output: 0.28 },
+  "deepseek-coder": { input: 0.14, output: 0.28 },
+  // Ollama is free (local)
+  default: { input: 0, output: 0 },
+};
+
+function estimateCost(
+  model: string,
+  tokensIn: number,
+  tokensOut: number,
+): number {
+  const pricing = COST_TABLE[model] ?? COST_TABLE["default"];
+  return (
+    (tokensIn / 1_000_000) * pricing.input +
+    (tokensOut / 1_000_000) * pricing.output
+  );
+}
+
+// ─── Ollama Provider ─────────────────────────────────────────────────────────
+
+async function callOllama(
+  messages: LLMMessage[],
+  config: LLMProviderConfig,
+): Promise<LLMResponse> {
+  const baseUrl = config.baseUrl || "http://localhost:11434";
+  const response = await fetch(`${baseUrl}/api/chat`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      model: config.model,
+      messages: messages.map((m) => ({
+        role: m.role,
+        content: m.content,
+      })),
+      stream: false,
+      options: {
+        temperature: config.temperature ?? 0.7,
+        num_predict: config.maxTokens ?? 4096,
+      },
+    }),
+  });
+
+  if (!response.ok) {
+    const text = await response.text();
+    throw new Error(`Ollama error ${response.status}: ${text}`);
+  }
+
+  const data = (await response.json()) as {
+    message: { content: string };
+    model: string;
+    eval_count?: number;
+    prompt_eval_count?: number;
+  };
+
+  const tokensIn = data.prompt_eval_count ?? 0;
+  const tokensOut = data.eval_count ?? 0;
+
+  return {
+    content: data.message.content,
+    model: data.model,
+    provider: "ollama",
+    tokensIn,
+    tokensOut,
+    estimatedCost: 0, // Local = free
+  };
+}
+
+/** Stream from Ollama. Yields chunks. */
+export async function* streamOllama(
+  messages: LLMMessage[],
+  config: LLMProviderConfig,
+): AsyncGenerator<LLMStreamChunk> {
+  const baseUrl = config.baseUrl || "http://localhost:11434";
+  const response = await fetch(`${baseUrl}/api/chat`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      model: config.model,
+      messages: messages.map((m) => ({
+        role: m.role,
+        content: m.content,
+      })),
+      stream: true,
+      options: {
+        temperature: config.temperature ?? 0.7,
+        num_predict: config.maxTokens ?? 4096,
+      },
+    }),
+  });
+
+  if (!response.ok) {
+    throw new Error(`Ollama stream error ${response.status}`);
+  }
+
+  const reader = response.body?.getReader();
+  if (!reader) throw new Error("No response body");
+
+  const decoder = new TextDecoder();
+  let buffer = "";
+
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+
+    buffer += decoder.decode(value, { stream: true });
+    const lines = buffer.split("\n");
+    buffer = lines.pop() || "";
+
+    for (const line of lines) {
+      if (!line.trim()) continue;
+      try {
+        const data = JSON.parse(line) as {
+          message?: { content: string };
+          done: boolean;
+        };
+        yield {
+          content: data.message?.content || "",
+          done: data.done,
+        };
+      } catch {
+        // Skip malformed lines
+      }
+    }
+  }
+}
+
+// ─── OpenRouter Provider ─────────────────────────────────────────────────────
+
+async function callOpenRouter(
+  messages: LLMMessage[],
+  config: LLMProviderConfig,
+): Promise<LLMResponse> {
+  const apiKey = config.apiKey || process.env.OPENROUTER_API_KEY;
+  if (!apiKey) {
+    throw new Error("OpenRouter API key required (set OPENROUTER_API_KEY)");
+  }
+
+  const response = await fetch("https://openrouter.ai/api/v1/chat/completions", {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${apiKey}`,
+      "HTTP-Referer": "https://github.com/maxx-agent/platform",
+      "X-Title": "Agent Platform",
+    },
+    body: JSON.stringify({
+      model: config.model,
+      messages,
+      temperature: config.temperature ?? 0.7,
+      max_tokens: config.maxTokens ?? 4096,
+    }),
+  });
+
+  if (!response.ok) {
+    const text = await response.text();
+    throw new Error(`OpenRouter error ${response.status}: ${text}`);
+  }
+
+  const data = (await response.json()) as {
+    choices: Array<{ message: { content: string } }>;
+    model: string;
+    usage?: { prompt_tokens: number; completion_tokens: number };
+  };
+
+  const tokensIn = data.usage?.prompt_tokens ?? 0;
+  const tokensOut = data.usage?.completion_tokens ?? 0;
+
+  return {
+    content: data.choices[0]?.message?.content || "",
+    model: data.model,
+    provider: "openrouter",
+    tokensIn,
+    tokensOut,
+    estimatedCost: estimateCost(config.model, tokensIn, tokensOut),
+  };
+}
+
+// ─── Gemini Provider ─────────────────────────────────────────────────────────
+
+async function callGemini(
+  messages: LLMMessage[],
+  config: LLMProviderConfig,
+): Promise<LLMResponse> {
+  const apiKey = config.apiKey || process.env.GEMINI_API_KEY;
+  if (!apiKey) {
+    throw new Error("Gemini API key required (set GEMINI_API_KEY)");
+  }
+
+  const model = config.model || "gemini-2.5-flash";
+
+  // Convert messages to Gemini format
+  const systemInstruction = messages
+    .filter((m) => m.role === "system")
+    .map((m) => m.content)
+    .join("\n");
+
+  const contents = messages
+    .filter((m) => m.role !== "system")
+    .map((m) => ({
+      role: m.role === "assistant" ? "model" : "user",
+      parts: [{ text: m.content }],
+    }));
+
+  const response = await fetch(
+    `https://generativelanguage.googleapis.com/v1beta/models/${model}:generateContent?key=${apiKey}`,
+    {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        contents,
+        systemInstruction: systemInstruction
+          ? { parts: [{ text: systemInstruction }] }
+          : undefined,
+        generationConfig: {
+          temperature: config.temperature ?? 0.7,
+          maxOutputTokens: config.maxTokens ?? 4096,
+        },
+      }),
+    },
+  );
+
+  if (!response.ok) {
+    const text = await response.text();
+    throw new Error(`Gemini error ${response.status}: ${text}`);
+  }
+
+  const data = (await response.json()) as {
+    candidates: Array<{
+      content: { parts: Array<{ text: string }> };
+    }>;
+    usageMetadata?: {
+      promptTokenCount: number;
+      candidatesTokenCount: number;
+    };
+  };
+
+  const tokensIn = data.usageMetadata?.promptTokenCount ?? 0;
+  const tokensOut = data.usageMetadata?.candidatesTokenCount ?? 0;
+  const content =
+    data.candidates?.[0]?.content?.parts?.map((p) => p.text).join("") || "";
+
+  return {
+    content,
+    model,
+    provider: "gemini",
+    tokensIn,
+    tokensOut,
+    estimatedCost: estimateCost(model, tokensIn, tokensOut),
+  };
+}
+
+// ─── Unified Call Function ───────────────────────────────────────────────────
+
+/** Call any LLM provider with a unified interface. */
+export async function callLLM(
+  messages: LLMMessage[],
+  config: LLMProviderConfig,
+): Promise<LLMResponse> {
+  switch (config.provider) {
+    case "ollama":
+      return callOllama(messages, config);
+    case "openrouter":
+      return callOpenRouter(messages, config);
+    case "gemini":
+      return callGemini(messages, config);
+    default:
+      throw new Error(`Unknown provider: ${config.provider}`);
+  }
+}
+
+/** List available Ollama models. */
+export async function listOllamaModels(
+  baseUrl = "http://localhost:11434",
+): Promise<Array<{ name: string; size: number; modified_at: string }>> {
+  try {
+    const response = await fetch(`${baseUrl}/api/tags`);
+    if (!response.ok) return [];
+    const data = (await response.json()) as {
+      models: Array<{ name: string; size: number; modified_at: string }>;
+    };
+    return data.models || [];
+  } catch {
+    return [];
+  }
+}
+
+/** Pull an Ollama model (non-blocking). */
+export async function pullOllamaModel(
+  model: string,
+  baseUrl = "http://localhost:11434",
+): Promise<void> {
+  const response = await fetch(`${baseUrl}/api/pull`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ name: model, stream: false }),
+  });
+  if (!response.ok) {
+    const text = await response.text();
+    throw new Error(`Failed to pull model ${model}: ${text}`);
+  }
+}