@imisbahk/hive 0.1.0

package/src/providers/anthropic.ts

@@ -0,0 +1,146 @@
+import fetch from "node-fetch";
+
+import { resolveProviderApiKey } from "./api-key.js";
+import {
+  ProviderConfigurationError,
+  ProviderRequestError,
+  iterateSseData,
+  type Provider,
+  type ProviderMessage,
+  type StreamChatRequest,
+} from "./base.js";
+
+const ANTHROPIC_API_URL = "https://api.anthropic.com/v1/messages";
+const DEFAULT_ANTHROPIC_MODEL = "claude-3-5-haiku-latest";
+
+interface AnthropicMessage {
+  role: "user" | "assistant";
+  content: string;
+}
+
+export class AnthropicProvider implements Provider {
+  readonly name = "anthropic" as const;
+  readonly defaultModel: string;
+
+  private readonly apiKey?: string;
+
+  constructor(apiKey?: string) {
+    this.apiKey = apiKey;
+    this.defaultModel = process.env.ANTHROPIC_MODEL ?? DEFAULT_ANTHROPIC_MODEL;
+  }
+
+  async *streamChat(request: StreamChatRequest): AsyncGenerator<string> {
+    if (!this.apiKey) {
+      throw new ProviderConfigurationError(
+        'Provider "anthropic" is missing ANTHROPIC_API_KEY.',
+      );
+    }
+
+    const system = request.messages
+      .filter((message) => message.role === "system")
+      .map((message) => message.content)
+      .join("\n\n");
+
+    const messages = toAnthropicMessages(request.messages);
+
+    const response = await fetch(ANTHROPIC_API_URL, {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        "x-api-key": this.apiKey,
+        "anthropic-version": "2023-06-01",
+      },
+      body: JSON.stringify({
+        model: request.model ?? this.defaultModel,
+        stream: true,
+        max_tokens: request.maxTokens ?? 1024,
+        temperature: request.temperature,
+        system: system.length > 0 ? system : undefined,
+        messages,
+      }),
+    });
+
+    if (!response.ok) {
+      const bodyText = await response.text();
+      throw new ProviderRequestError(
+        `anthropic request failed: HTTP ${response.status} ${response.statusText} ${bodyText}`,
+      );
+    }
+
+    for await (const data of iterateSseData(response)) {
+      if (data === "[DONE]") {
+        return;
+      }
+
+      const payload = parseJson<Record<string, unknown>>(data);
+      if (!payload) {
+        continue;
+      }
+
+      if (payload.type === "error") {
+        const error = payload.error as Record<string, unknown> | undefined;
+        const message =
+          typeof error?.message === "string"
+            ? error.message
+            : "anthropic stream error";
+
+        throw new ProviderRequestError(message);
+      }
+
+      const text = pickAnthropicDelta(payload);
+      if (text.length > 0) {
+        yield text;
+      }
+    }
+  }
+}
+
+export async function createAnthropicProvider(): Promise<AnthropicProvider> {
+  const apiKey = await resolveProviderApiKey("anthropic", "ANTHROPIC_API_KEY");
+  return new AnthropicProvider(apiKey);
+}
+
+function toAnthropicMessages(messages: ProviderMessage[]): AnthropicMessage[] {
+  const filtered = messages.filter((message) => message.role !== "system");
+  if (filtered.length === 0) {
+    return [{ role: "user", content: "Hello." }];
+  }
+
+  return filtered.map((message) => ({
+    role: message.role === "assistant" ? "assistant" : "user",
+    content: message.content,
+  }));
+}
+
+function pickAnthropicDelta(payload: Record<string, unknown>): string {
+  if (payload.type === "content_block_start") {
+    const contentBlock = payload.content_block as Record<string, unknown> | undefined;
+    if (contentBlock?.type === "text" && typeof contentBlock.text === "string") {
+      return contentBlock.text;
+    }
+  }
+
+  if (payload.type === "content_block_delta") {
+    const delta = payload.delta as Record<string, unknown> | undefined;
+    if (delta?.type === "text_delta" && typeof delta.text === "string") {
+      return delta.text;
+    }
+  }
+
+  if (payload.type === "message_delta") {
+    const delta = payload.delta as Record<string, unknown> | undefined;
+    if (typeof delta?.text === "string") {
+      return delta.text;
+    }
+  }
+
+  return "";
+}
+
+function parseJson<T>(value: string): T | null {
+  try {
+    return JSON.parse(value) as T;
+  } catch {
+    return null;
+  }
+}

package/src/providers/api-key.ts

@@ -0,0 +1,23 @@
+import keytar from "keytar";
+
+import type { ProviderName } from "./base.js";
+
+const KEYCHAIN_SERVICE = "hive";
+
+export async function resolveProviderApiKey(
+  providerName: ProviderName,
+  envVarName: string,
+): Promise<string | undefined> {
+  let keychainValue: string | null = null;
+  try {
+    keychainValue = await keytar.getPassword(KEYCHAIN_SERVICE, providerName);
+  } catch {
+    keychainValue = null;
+  }
+
+  return (
+    keychainValue ??
+    process.env[envVarName] ??
+    undefined
+  );
+}

package/src/providers/base.ts

@@ -0,0 +1,234 @@
+import fetch, { type Response } from "node-fetch";
+
+export const SUPPORTED_PROVIDER_NAMES = [
+  "openai",
+  "anthropic",
+  "ollama",
+  "groq",
+  "mistral",
+  "google",
+  "openrouter",
+  "together",
+] as const;
+
+export type ProviderName = (typeof SUPPORTED_PROVIDER_NAMES)[number];
+export type ProviderMessageRole = "system" | "user" | "assistant";
+
+export interface ProviderMessage {
+  role: ProviderMessageRole;
+  content: string;
+}
+
+export interface StreamChatRequest {
+  messages: ProviderMessage[];
+  model?: string;
+  temperature?: number;
+  maxTokens?: number;
+}
+
+export interface Provider {
+  readonly name: ProviderName;
+  readonly defaultModel: string;
+  streamChat(request: StreamChatRequest): AsyncGenerator<string>;
+}
+
+export class ProviderConfigurationError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "ProviderConfigurationError";
+  }
+}
+
+export class ProviderRequestError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "ProviderRequestError";
+  }
+}
+
+export interface OpenAICompatibleStreamInput {
+  provider: ProviderName;
+  baseUrl: string;
+  apiKey?: string;
+  model: string;
+  messages: ProviderMessage[];
+  temperature?: number;
+  maxTokens?: number;
+  extraHeaders?: Record<string, string>;
+  extraBody?: Record<string, unknown>;
+}
+
+export function normalizeProviderName(raw?: string): ProviderName {
+  if (!raw) {
+    return "openai";
+  }
+
+  const normalized = raw.trim().toLowerCase();
+  if ((SUPPORTED_PROVIDER_NAMES as readonly string[]).includes(normalized)) {
+    return normalized as ProviderName;
+  }
+
+  throw new ProviderConfigurationError(
+    `Unsupported provider \"${raw}\". Supported providers: ${SUPPORTED_PROVIDER_NAMES.join(", ")}.`,
+  );
+}
+
+export async function* streamOpenAICompatibleChat(
+  input: OpenAICompatibleStreamInput,
+): AsyncGenerator<string> {
+  const endpoint = `${input.baseUrl.replace(/\/$/, "")}/chat/completions`;
+
+  const headers: Record<string, string> = {
+    "content-type": "application/json",
+    ...(input.extraHeaders ?? {}),
+  };
+
+  if (input.apiKey) {
+    headers.authorization = `Bearer ${input.apiKey}`;
+  }
+
+  const body: Record<string, unknown> = {
+    model: input.model,
+    messages: input.messages,
+    stream: true,
+    ...(input.extraBody ?? {}),
+  };
+
+  if (input.temperature !== undefined) {
+    body.temperature = input.temperature;
+  }
+
+  if (input.maxTokens !== undefined) {
+    body.max_tokens = input.maxTokens;
+  }
+
+  const response = await fetch(endpoint, {
+    method: "POST",
+    headers,
+    body: JSON.stringify(body),
+  });
+
+  await ensureOk(response, `${input.provider} request failed`);
+
+  for await (const data of iterateSseData(response)) {
+    if (data === "[DONE]") {
+      return;
+    }
+
+    const payload = parseJson<Record<string, unknown>>(data);
+    if (!payload) {
+      continue;
+    }
+
+    const errorMessage = pickErrorMessage(payload);
+    if (errorMessage) {
+      throw new ProviderRequestError(`${input.provider} error: ${errorMessage}`);
+    }
+
+    const maybeChoices = payload.choices;
+    if (!Array.isArray(maybeChoices) || maybeChoices.length === 0) {
+      continue;
+    }
+
+    const firstChoice = maybeChoices[0] as Record<string, unknown>;
+    const delta = firstChoice.delta as Record<string, unknown> | undefined;
+
+    const text =
+      typeof delta?.content === "string"
+        ? delta.content
+        : typeof firstChoice.text === "string"
+          ? firstChoice.text
+          : "";
+
+    if (text.length > 0) {
+      yield text;
+    }
+  }
+}
+
+export async function* iterateSseData(response: Response): AsyncGenerator<string> {
+  if (!response.body) {
+    return;
+  }
+
+  let buffer = "";
+
+  for await (const chunk of response.body) {
+    buffer += chunk.toString("utf8").replace(/\r\n/g, "\n");
+
+    let eventBoundary = buffer.indexOf("\n\n");
+    while (eventBoundary !== -1) {
+      const rawEvent = buffer.slice(0, eventBoundary);
+      buffer = buffer.slice(eventBoundary + 2);
+
+      const data = parseSseData(rawEvent);
+      if (data !== null) {
+        yield data;
+      }
+
+      eventBoundary = buffer.indexOf("\n\n");
+    }
+  }
+
+  const remaining = parseSseData(buffer);
+  if (remaining !== null) {
+    yield remaining;
+  }
+}
+
+export async function* chunkText(text: string, chunkSize = 32): AsyncGenerator<string> {
+  for (let start = 0; start < text.length; start += chunkSize) {
+    yield text.slice(start, start + chunkSize);
+  }
+}
+
+function parseSseData(rawEvent: string): string | null {
+  const lines = rawEvent
+    .split("\n")
+    .map((line) => line.trimEnd())
+    .filter((line) => line.startsWith("data:"))
+    .map((line) => line.slice(5).trimStart());
+
+  if (lines.length === 0) {
+    return null;
+  }
+
+  return lines.join("\n").trim();
+}
+
+function parseJson<T>(value: string): T | null {
+  try {
+    return JSON.parse(value) as T;
+  } catch {
+    return null;
+  }
+}
+
+function pickErrorMessage(payload: Record<string, unknown>): string | null {
+  const maybeError = payload.error;
+  if (typeof maybeError === "string") {
+    return maybeError;
+  }
+
+  if (maybeError && typeof maybeError === "object") {
+    const message = (maybeError as Record<string, unknown>).message;
+    if (typeof message === "string") {
+      return message;
+    }
+  }
+
+  return null;
+}
+
+async function ensureOk(response: Response, fallbackMessage: string): Promise<void> {
+  if (response.ok) {
+    return;
+  }
+
+  const bodyText = (await response.text()).trim();
+  const details = bodyText.length > 0 ? ` ${bodyText}` : "";
+
+  throw new ProviderRequestError(
+    `${fallbackMessage}: HTTP ${response.status} ${response.statusText}${details}`,
+  );
+}

package/src/providers/google.ts

@@ -0,0 +1,21 @@
+import { resolveProviderApiKey } from "./api-key.js";
+import { OpenAICompatibleProvider } from "./openai-compatible.js";
+
+const DEFAULT_GOOGLE_BASE_URL = "https://generativelanguage.googleapis.com/v1beta/openai";
+const DEFAULT_GOOGLE_MODEL = "gemini-3.0-flash";
+
+export class GoogleProvider extends OpenAICompatibleProvider {
+  constructor(apiKey?: string) {
+    super({
+      name: "google",
+      baseUrl: process.env.GOOGLE_BASE_URL ?? DEFAULT_GOOGLE_BASE_URL,
+      apiKey,
+      defaultModel: process.env.GOOGLE_MODEL ?? DEFAULT_GOOGLE_MODEL,
+    });
+  }
+}
+
+export async function createGoogleProvider(): Promise<GoogleProvider> {
+  const apiKey = await resolveProviderApiKey("google", "GOOGLE_API_KEY");
+  return new GoogleProvider(apiKey);
+}

package/src/providers/groq.ts

@@ -0,0 +1,21 @@
+import { resolveProviderApiKey } from "./api-key.js";
+import { OpenAICompatibleProvider } from "./openai-compatible.js";
+
+const DEFAULT_GROQ_BASE_URL = "https://api.groq.com/openai/v1";
+const DEFAULT_GROQ_MODEL = "llama-3.3-70b-versatile";
+
+export class GroqProvider extends OpenAICompatibleProvider {
+  constructor(apiKey?: string) {
+    super({
+      name: "groq",
+      baseUrl: process.env.GROQ_BASE_URL ?? DEFAULT_GROQ_BASE_URL,
+      apiKey,
+      defaultModel: process.env.GROQ_MODEL ?? DEFAULT_GROQ_MODEL,
+    });
+  }
+}
+
+export async function createGroqProvider(): Promise<GroqProvider> {
+  const apiKey = await resolveProviderApiKey("groq", "GROQ_API_KEY");
+  return new GroqProvider(apiKey);
+}

package/src/providers/index.ts

@@ -0,0 +1,65 @@
+import {
+  normalizeProviderName,
+  type Provider,
+  type ProviderName,
+} from "./base.js";
+import { createAnthropicProvider } from "./anthropic.js";
+import { createGoogleProvider } from "./google.js";
+import { createGroqProvider } from "./groq.js";
+import { createMistralProvider } from "./mistral.js";
+import { createOllamaProvider } from "./ollama.js";
+import { createOpenAIProvider } from "./openai.js";
+import { createOpenRouterProvider } from "./openrouter.js";
+import { createTogetherProvider } from "./together.js";
+
+export async function createProvider(name?: string): Promise<Provider> {
+  const resolvedName = normalizeProviderName(name ?? process.env.HIVE_PROVIDER);
+
+  switch (resolvedName) {
+    case "openai":
+      return createOpenAIProvider();
+    case "anthropic":
+      return createAnthropicProvider();
+    case "ollama":
+      return createOllamaProvider();
+    case "groq":
+      return createGroqProvider();
+    case "mistral":
+      return createMistralProvider();
+    case "google":
+      return createGoogleProvider();
+    case "openrouter":
+      return createOpenRouterProvider();
+    case "together":
+      return createTogetherProvider();
+    default:
+      return assertNever(resolvedName);
+  }
+}
+
+export function getDefaultModelForProvider(name: ProviderName): string {
+  switch (name) {
+    case "openai":
+      return process.env.OPENAI_MODEL ?? "gpt-4o-mini";
+    case "anthropic":
+      return process.env.ANTHROPIC_MODEL ?? "claude-3-5-haiku-latest";
+    case "ollama":
+      return process.env.OLLAMA_MODEL ?? "llama3.2";
+    case "groq":
+      return process.env.GROQ_MODEL ?? "llama-3.3-70b-versatile";
+    case "mistral":
+      return process.env.MISTRAL_MODEL ?? "mistral-small-latest";
+    case "google":
+      return process.env.GOOGLE_MODEL ?? "gemini-2.0-flash";
+    case "openrouter":
+      return process.env.OPENROUTER_MODEL ?? "openai/gpt-4o-mini";
+    case "together":
+      return process.env.TOGETHER_MODEL ?? "meta-llama/Llama-3.3-70B-Instruct-Turbo";
+    default:
+      return assertNever(name);
+  }
+}
+
+function assertNever(value: never): never {
+  throw new Error(`Unsupported provider: ${String(value)}`);
+}

package/src/providers/mistral.ts

@@ -0,0 +1,21 @@
+import { resolveProviderApiKey } from "./api-key.js";
+import { OpenAICompatibleProvider } from "./openai-compatible.js";
+
+const DEFAULT_MISTRAL_BASE_URL = "https://api.mistral.ai/v1";
+const DEFAULT_MISTRAL_MODEL = "mistral-small-latest";
+
+export class MistralProvider extends OpenAICompatibleProvider {
+  constructor(apiKey?: string) {
+    super({
+      name: "mistral",
+      baseUrl: process.env.MISTRAL_BASE_URL ?? DEFAULT_MISTRAL_BASE_URL,
+      apiKey,
+      defaultModel: process.env.MISTRAL_MODEL ?? DEFAULT_MISTRAL_MODEL,
+    });
+  }
+}
+
+export async function createMistralProvider(): Promise<MistralProvider> {
+  const apiKey = await resolveProviderApiKey("mistral", "MISTRAL_API_KEY");
+  return new MistralProvider(apiKey);
+}

package/src/providers/ollama.ts

@@ -0,0 +1,22 @@
+import { resolveProviderApiKey } from "./api-key.js";
+import { OpenAICompatibleProvider } from "./openai-compatible.js";
+
+const DEFAULT_OLLAMA_BASE_URL = "http://localhost:11434/v1";
+const DEFAULT_OLLAMA_MODEL = "llama3.2";
+
+export class OllamaProvider extends OpenAICompatibleProvider {
+  constructor(apiKey?: string) {
+    super({
+      name: "ollama",
+      baseUrl: process.env.OLLAMA_BASE_URL ?? DEFAULT_OLLAMA_BASE_URL,
+      apiKey,
+      defaultModel: process.env.OLLAMA_MODEL ?? DEFAULT_OLLAMA_MODEL,
+      allowMissingApiKey: true,
+    });
+  }
+}
+
+export async function createOllamaProvider(): Promise<OllamaProvider> {
+  const apiKey = await resolveProviderApiKey("ollama", "OLLAMA_API_KEY");
+  return new OllamaProvider(apiKey);
+}

package/src/providers/openai-compatible.ts

@@ -0,0 +1,58 @@
+import {
+  ProviderConfigurationError,
+  type Provider,
+  type ProviderName,
+  type StreamChatRequest,
+  streamOpenAICompatibleChat,
+} from "./base.js";
+
+export interface OpenAICompatibleProviderConfig {
+  name: ProviderName;
+  baseUrl: string;
+  defaultModel: string;
+  apiKey?: string;
+  allowMissingApiKey?: boolean;
+  extraHeaders?: Record<string, string>;
+  extraBody?: Record<string, unknown>;
+}
+
+export class OpenAICompatibleProvider implements Provider {
+  readonly name: ProviderName;
+  readonly defaultModel: string;
+
+  private readonly baseUrl: string;
+  private readonly apiKey?: string;
+  private readonly allowMissingApiKey: boolean;
+  private readonly extraHeaders?: Record<string, string>;
+  private readonly extraBody?: Record<string, unknown>;
+
+  constructor(config: OpenAICompatibleProviderConfig) {
+    this.name = config.name;
+    this.baseUrl = config.baseUrl;
+    this.apiKey = config.apiKey;
+    this.defaultModel = config.defaultModel;
+    this.allowMissingApiKey = config.allowMissingApiKey ?? false;
+    this.extraHeaders = config.extraHeaders;
+    this.extraBody = config.extraBody;
+  }
+
+  async *streamChat(request: StreamChatRequest): AsyncGenerator<string> {
+    if (!this.allowMissingApiKey && !this.apiKey) {
+      throw new ProviderConfigurationError(
+        `Provider \"${this.name}\" is missing an API key.`,
+      );
+    }
+
+    yield* streamOpenAICompatibleChat({
+      provider: this.name,
+      baseUrl: this.baseUrl,
+      apiKey: this.apiKey,
+      model: request.model ?? this.defaultModel,
+      messages: request.messages,
+      temperature: request.temperature,
+      maxTokens: request.maxTokens,
+      extraHeaders: this.extraHeaders,
+      extraBody: this.extraBody,
+    });
+  }
+}

package/src/providers/openai.ts

@@ -0,0 +1,21 @@
+import { resolveProviderApiKey } from "./api-key.js";
+import { OpenAICompatibleProvider } from "./openai-compatible.js";
+
+const DEFAULT_OPENAI_BASE_URL = "https://api.openai.com/v1";
+const DEFAULT_OPENAI_MODEL = "gpt-4o-mini";
+
+export class OpenAIProvider extends OpenAICompatibleProvider {
+  constructor(apiKey?: string) {
+    super({
+      name: "openai",
+      baseUrl: process.env.OPENAI_BASE_URL ?? DEFAULT_OPENAI_BASE_URL,
+      apiKey,
+      defaultModel: process.env.OPENAI_MODEL ?? DEFAULT_OPENAI_MODEL,
+    });
+  }
+}
+
+export async function createOpenAIProvider(): Promise<OpenAIProvider> {
+  const apiKey = await resolveProviderApiKey("openai", "OPENAI_API_KEY");
+  return new OpenAIProvider(apiKey);
+}

package/src/providers/openrouter.ts

@@ -0,0 +1,21 @@
+import { resolveProviderApiKey } from "./api-key.js";
+import { OpenAICompatibleProvider } from "./openai-compatible.js";
+
+const DEFAULT_OPENROUTER_BASE_URL = "https://openrouter.ai/api/v1";
+const DEFAULT_OPENROUTER_MODEL = "openai/gpt-4o-mini";
+
+export class OpenRouterProvider extends OpenAICompatibleProvider {
+  constructor(apiKey?: string) {
+    super({
+      name: "openrouter",
+      baseUrl: process.env.OPENROUTER_BASE_URL ?? DEFAULT_OPENROUTER_BASE_URL,
+      apiKey,
+      defaultModel: process.env.OPENROUTER_MODEL ?? DEFAULT_OPENROUTER_MODEL,
+    });
+  }
+}
+
+export async function createOpenRouterProvider(): Promise<OpenRouterProvider> {
+  const apiKey = await resolveProviderApiKey("openrouter", "OPENROUTER_API_KEY");
+  return new OpenRouterProvider(apiKey);
+}

package/src/providers/together.ts

@@ -0,0 +1,21 @@
+import { resolveProviderApiKey } from "./api-key.js";
+import { OpenAICompatibleProvider } from "./openai-compatible.js";
+
+const DEFAULT_TOGETHER_BASE_URL = "https://api.together.xyz/v1";
+const DEFAULT_TOGETHER_MODEL = "meta-llama/Llama-3.3-70B-Instruct-Turbo";
+
+export class TogetherProvider extends OpenAICompatibleProvider {
+  constructor(apiKey?: string) {
+    super({
+      name: "together",
+      baseUrl: process.env.TOGETHER_BASE_URL ?? DEFAULT_TOGETHER_BASE_URL,
+      apiKey,
+      defaultModel: process.env.TOGETHER_MODEL ?? DEFAULT_TOGETHER_MODEL,
+    });
+  }
+}
+
+export async function createTogetherProvider(): Promise<TogetherProvider> {
+  const apiKey = await resolveProviderApiKey("together", "TOGETHER_API_KEY");
+  return new TogetherProvider(apiKey);
+}