claude-glm-alt-installer 2.0.0

package/adapters/anthropic-gateway.ts

@@ -0,0 +1,153 @@
+// Main Fastify server that routes requests by provider prefix
+import Fastify from "fastify";
+import { parseProviderModel, warnIfTools } from "./map.js";
+import type { AnthropicRequest, ProviderModel } from "./types.js";
+import { chatOpenAI } from "./providers/openai.js";
+import { chatOpenRouter } from "./providers/openrouter.js";
+import { chatGemini } from "./providers/gemini.js";
+import { passThrough } from "./providers/anthropic-pass.js";
+import { config } from "dotenv";
+import { join } from "path";
+import { homedir } from "os";
+
+// Load .env from ~/.claude-proxy/.env
+const envPath = join(homedir(), ".claude-proxy", ".env");
+config({ path: envPath });
+
+const PORT = Number(process.env.CLAUDE_PROXY_PORT || 17870);
+
+let active: ProviderModel | null = null;
+
+const fastify = Fastify({ logger: false });
+
+// Health check endpoint
+fastify.get("/healthz", async () => ({
+  ok: true,
+  active: active ?? { provider: "glm", model: "auto" }
+}));
+
+// Status endpoint (shows current active provider/model)
+fastify.get("/_status", async () => {
+  return active ?? { provider: "glm", model: "glm-4.7" };
+});
+
+// Main messages endpoint - routes by model prefix
+fastify.post("/v1/messages", async (req, res) => {
+  try {
+    const body = req.body as AnthropicRequest;
+    const defaults = active ?? undefined;
+    const { provider, model } = parseProviderModel(body.model, defaults);
+
+    // Warn if using tools with providers that may not support them
+    warnIfTools(body, provider);
+
+    active = { provider, model };
+
+    // Validate API keys BEFORE setting headers
+    if (provider === "openai") {
+      const key = process.env.OPENAI_API_KEY;
+      if (!key) {
+        throw apiError(401, "OPENAI_API_KEY not set in ~/.claude-proxy/.env");
+      }
+      // Set headers only after validation
+      res.raw.setHeader("Content-Type", "text/event-stream");
+      res.raw.setHeader("Cache-Control", "no-cache, no-transform");
+      res.raw.setHeader("Connection", "keep-alive");
+      // @ts-ignore
+      res.raw.flushHeaders?.();
+      return chatOpenAI(res, body, model, key);
+    }
+
+    if (provider === "openrouter") {
+      const key = process.env.OPENROUTER_API_KEY;
+      if (!key) {
+        throw apiError(401, "OPENROUTER_API_KEY not set in ~/.claude-proxy/.env");
+      }
+      res.raw.setHeader("Content-Type", "text/event-stream");
+      res.raw.setHeader("Cache-Control", "no-cache, no-transform");
+      res.raw.setHeader("Connection", "keep-alive");
+      // @ts-ignore
+      res.raw.flushHeaders?.();
+      return chatOpenRouter(res, body, model, key);
+    }
+
+    if (provider === "gemini") {
+      const key = process.env.GEMINI_API_KEY;
+      if (!key) {
+        throw apiError(401, "GEMINI_API_KEY not set in ~/.claude-proxy/.env");
+      }
+      res.raw.setHeader("Content-Type", "text/event-stream");
+      res.raw.setHeader("Cache-Control", "no-cache, no-transform");
+      res.raw.setHeader("Connection", "keep-alive");
+      // @ts-ignore
+      res.raw.flushHeaders?.();
+      return chatGemini(res, body, model, key);
+    }
+
+    if (provider === "anthropic") {
+      const base = process.env.ANTHROPIC_UPSTREAM_URL;
+      const key = process.env.ANTHROPIC_API_KEY;
+      if (!base || !key) {
+        throw apiError(
+          500,
+          "ANTHROPIC_UPSTREAM_URL and ANTHROPIC_API_KEY not set in ~/.claude-proxy/.env"
+        );
+      }
+      // Don't set headers here - passThrough will do it after validation
+      return passThrough({
+        res,
+        body,
+        model,
+        baseUrl: base,
+        headers: {
+          "Content-Type": "application/json",
+          "x-api-key": key,
+          "anthropic-version": process.env.ANTHROPIC_VERSION || "2023-06-01"
+        }
+      });
+    }
+
+    // Default: glm (Z.AI)
+    const glmBase = process.env.GLM_UPSTREAM_URL;
+    const glmKey = process.env.ZAI_API_KEY || process.env.GLM_API_KEY;
+    if (!glmBase || !glmKey) {
+      throw apiError(
+        500,
+        "GLM_UPSTREAM_URL and ZAI_API_KEY not set in ~/.claude-proxy/.env. Run: ccx --setup"
+      );
+    }
+    // Don't set headers here - passThrough will do it after validation
+    return passThrough({
+      res,
+      body,
+      model,
+      baseUrl: glmBase,
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${glmKey}`,
+        "anthropic-version": process.env.ANTHROPIC_VERSION || "2023-06-01"
+      }
+    });
+  } catch (e: any) {
+    const status = e?.statusCode ?? 500;
+    return res.code(status).send({ error: e?.message || "proxy error" });
+  }
+});
+
+function apiError(status: number, message: string) {
+  const e = new Error(message);
+  // @ts-ignore
+  e.statusCode = status;
+  return e;
+}
+
+fastify
+  .listen({ port: PORT, host: "127.0.0.1" })
+  .then(() => {
+    console.log(`[ccx] Proxy listening on http://127.0.0.1:${PORT}`);
+    console.log(`[ccx] Configure API keys in: ${envPath}`);
+  })
+  .catch((err) => {
+    console.error("[ccx] Failed to start proxy:", err.message);
+    process.exit(1);
+  });

package/adapters/map.ts

@@ -0,0 +1,83 @@
+// Provider parsing and message mapping utilities
+import { AnthropicMessage, AnthropicRequest, ProviderKey, ProviderModel } from "./types.js";
+
+const PROVIDER_PREFIXES: ProviderKey[] = ["openai", "openrouter", "gemini", "glm", "anthropic"];
+
+/**
+ * Parse provider and model from the model field
+ * Supports formats: "provider:model" or "provider/model"
+ * Falls back to defaults if no valid prefix found
+ */
+export function parseProviderModel(modelField: string, defaults?: ProviderModel): ProviderModel {
+  if (!modelField) {
+    if (defaults) return defaults;
+    throw new Error("Missing 'model' in request");
+  }
+
+  const sep = modelField.includes(":") ? ":" : modelField.includes("/") ? "/" : null;
+  if (!sep) {
+    // no prefix: fall back to defaults or assume glm as legacy
+    return defaults ?? { provider: "glm", model: modelField };
+  }
+
+  const [maybeProv, ...rest] = modelField.split(sep);
+  const prov = maybeProv.toLowerCase() as ProviderKey;
+
+  if (!PROVIDER_PREFIXES.includes(prov)) {
+    // unrecognized prefix -> use defaults or treat full string as model
+    return defaults ?? { provider: "glm", model: modelField };
+  }
+
+  return { provider: prov, model: rest.join(sep) };
+}
+
+/**
+ * Warn if tools are being used with providers that may not support them
+ */
+export function warnIfTools(req: AnthropicRequest, provider: ProviderKey): void {
+  if (req.tools && req.tools.length > 0) {
+    // Only GLM and Anthropic support tools natively
+    if (provider !== "glm" && provider !== "anthropic") {
+      console.warn(`[proxy] Warning: ${provider} may not fully support Anthropic-style tools. Passing through anyway.`);
+    }
+  }
+}
+
+/**
+ * Convert Anthropic content to plain text
+ */
+export function toPlainText(content: AnthropicMessage["content"]): string {
+  if (typeof content === "string") return content;
+  return content
+    .map((c) => {
+      if (typeof c === "string") return c;
+      if (c.type === "text") return c.text;
+      if (c.type === "tool_result") {
+        // Convert tool results to text representation
+        if (typeof c.content === "string") return c.content;
+        return JSON.stringify(c.content);
+      }
+      return "";
+    })
+    .join("");
+}
+
+/**
+ * Convert Anthropic messages to OpenAI format
+ */
+export function toOpenAIMessages(messages: AnthropicMessage[]) {
+  return messages.map((m) => ({
+    role: m.role,
+    content: toPlainText(m.content)
+  }));
+}
+
+/**
+ * Convert Anthropic messages to Gemini format
+ */
+export function toGeminiContents(messages: AnthropicMessage[]) {
+  return messages.map((m) => ({
+    role: m.role === "assistant" ? "model" : "user",
+    parts: [{ text: toPlainText(m.content) }]
+  }));
+}

package/adapters/providers/anthropic-pass.ts

@@ -0,0 +1,64 @@
+// Pass-through adapter for Anthropic-compatible upstreams (Anthropic API and Z.AI GLM)
+import { FastifyReply } from "fastify";
+
+type PassArgs = {
+  res: FastifyReply;
+  body: any;
+  model: string;
+  baseUrl: string;
+  headers: Record<string, string>;
+};
+
+/**
+ * Pass through requests to Anthropic-compatible APIs
+ * This works for both:
+ * - Anthropic's official API
+ * - Z.AI's GLM API (Anthropic-compatible)
+ */
+export async function passThrough({ res, body, model, baseUrl, headers }: PassArgs) {
+  const url = `${stripEndSlash(baseUrl)}/v1/messages`;
+
+  // Ensure stream is true for Claude Code UX
+  body.stream = true;
+
+  const resp = await fetch(url, {
+    method: "POST",
+    headers,
+    body: JSON.stringify(body)
+  });
+
+  if (!resp.ok || !resp.body) {
+    const text = await safeText(resp);
+    const err = new Error(`Upstream error (${resp.status}): ${text}`);
+    // @ts-ignore
+    err.statusCode = resp.status || 502;
+    throw err;
+  }
+
+  // Pipe upstream SSE as-is (already in Anthropic format)
+  res.raw.setHeader("Content-Type", "text/event-stream");
+  res.raw.setHeader("Cache-Control", "no-cache, no-transform");
+  res.raw.setHeader("Connection", "keep-alive");
+  // @ts-ignore
+  res.raw.flushHeaders?.();
+
+  const reader = resp.body.getReader();
+  while (true) {
+    const { value, done } = await reader.read();
+    if (done) break;
+    res.raw.write(value);
+  }
+  res.raw.end();
+}
+
+function stripEndSlash(s: string) {
+  return s.endsWith("/") ? s.slice(0, -1) : s;
+}
+
+async function safeText(resp: Response) {
+  try {
+    return await resp.text();
+  } catch {
+    return "<no-body>";
+  }
+}

package/adapters/providers/gemini.ts

@@ -0,0 +1,89 @@
+// Gemini adapter using streamGenerateContent (SSE)
+import { FastifyReply } from "fastify";
+import { createParser } from "eventsource-parser";
+import { deltaText, startAnthropicMessage, stopAnthropicMessage } from "../sse.js";
+import { toGeminiContents } from "../map.js";
+import type { AnthropicRequest } from "../types.js";
+
+const G_BASE = process.env.GEMINI_BASE_URL || "https://generativelanguage.googleapis.com/v1beta";
+
+export async function chatGemini(
+  res: FastifyReply,
+  body: AnthropicRequest,
+  model: string,
+  apiKey?: string
+) {
+  if (!apiKey) {
+    throw withStatus(401, "Missing GEMINI_API_KEY. Set it in ~/.claude-proxy/.env");
+  }
+
+  const url = `${G_BASE}/models/${encodeURIComponent(model)}:streamGenerateContent?alt=sse&key=${apiKey}`;
+
+  const reqBody: any = {
+    contents: toGeminiContents(body.messages),
+    generationConfig: {
+      temperature: body.temperature ?? 0.7,
+      maxOutputTokens: body.max_tokens
+    }
+  };
+
+  // Note: Gemini has different tool format, just warn for now
+  if (body.tools && body.tools.length > 0) {
+    console.warn("[gemini] Tools not yet adapted to Gemini format, skipping");
+  }
+
+  const resp = await fetch(url, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(reqBody)
+  });
+
+  if (!resp.ok || !resp.body) {
+    const text = await safeText(resp);
+    throw withStatus(resp.status || 500, `Gemini error: ${text}`);
+  }
+
+  startAnthropicMessage(res, model);
+
+  const reader = resp.body.getReader();
+  const decoder = new TextDecoder();
+  const parser = createParser((event) => {
+    if (event.type !== "event") return;
+    const data = event.data;
+    if (!data) return;
+    try {
+      const json = JSON.parse(data);
+      // Gemini response: candidates[0].content.parts[].text
+      const text =
+        json?.candidates?.[0]?.content?.parts
+          ?.map((p: any) => p?.text || "")
+          .join("") || "";
+      if (text) deltaText(res, text);
+    } catch {
+      // ignore parse errors
+    }
+  });
+
+  while (true) {
+    const { value, done } = await reader.read();
+    if (done) break;
+    parser.feed(decoder.decode(value));
+  }
+
+  stopAnthropicMessage(res);
+}
+
+function withStatus(status: number, message: string) {
+  const e = new Error(message);
+  // @ts-ignore
+  e.statusCode = status;
+  return e;
+}
+
+async function safeText(resp: Response) {
+  try {
+    return await resp.text();
+  } catch {
+    return "<no-body>";
+  }
+}

package/adapters/providers/openai.ts

@@ -0,0 +1,90 @@
+// OpenAI adapter using chat.completions with SSE streaming
+import { FastifyReply } from "fastify";
+import { createParser } from "eventsource-parser";
+import { deltaText, startAnthropicMessage, stopAnthropicMessage } from "../sse.js";
+import { toOpenAIMessages } from "../map.js";
+import type { AnthropicRequest } from "../types.js";
+
+const OPENAI_BASE = process.env.OPENAI_BASE_URL || "https://api.openai.com/v1";
+
+export async function chatOpenAI(
+  res: FastifyReply,
+  body: AnthropicRequest,
+  model: string,
+  apiKey?: string
+) {
+  if (!apiKey) {
+    throw withStatus(401, "Missing OPENAI_API_KEY. Set it in ~/.claude-proxy/.env");
+  }
+
+  const url = `${OPENAI_BASE}/chat/completions`;
+
+  const oaiBody: any = {
+    model,
+    messages: toOpenAIMessages(body.messages),
+    stream: true,
+    temperature: body.temperature ?? 0.7,
+    max_tokens: body.max_tokens
+  };
+
+  // Pass through tools if provided (note: OpenAI format may differ)
+  if (body.tools && body.tools.length > 0) {
+    console.warn("[openai] Tools passed through but format may not be compatible");
+    oaiBody.tools = body.tools;
+  }
+
+  const resp = await fetch(url, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${apiKey}`,
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify(oaiBody)
+  });
+
+  if (!resp.ok || !resp.body) {
+    const text = await safeText(resp);
+    throw withStatus(resp.status || 500, `OpenAI error: ${text}`);
+  }
+
+  // Emit Anthropic SSE start events
+  startAnthropicMessage(res, model);
+
+  const reader = resp.body.getReader();
+  const decoder = new TextDecoder();
+  const parser = createParser((event) => {
+    if (event.type !== "event") return;
+    const data = event.data;
+    if (!data || data === "[DONE]") return;
+    try {
+      const json = JSON.parse(data);
+      const chunk = json.choices?.[0]?.delta?.content ?? "";
+      if (chunk) deltaText(res, chunk);
+    } catch {
+      // ignore parse errors on keepalives, etc.
+    }
+  });
+
+  while (true) {
+    const { value, done } = await reader.read();
+    if (done) break;
+    parser.feed(decoder.decode(value));
+  }
+
+  stopAnthropicMessage(res);
+}
+
+function withStatus(status: number, message: string) {
+  const e = new Error(message);
+  // @ts-ignore
+  e.statusCode = status;
+  return e;
+}
+
+async function safeText(resp: Response) {
+  try {
+    return await resp.text();
+  } catch {
+    return "<no-body>";
+  }
+}

package/adapters/providers/openrouter.ts

@@ -0,0 +1,98 @@
+// OpenRouter adapter (OpenAI-compatible API)
+import { FastifyReply } from "fastify";
+import { createParser } from "eventsource-parser";
+import { deltaText, startAnthropicMessage, stopAnthropicMessage } from "../sse.js";
+import { toOpenAIMessages } from "../map.js";
+import type { AnthropicRequest } from "../types.js";
+
+const OR_BASE = process.env.OPENROUTER_BASE_URL || "https://openrouter.ai/api/v1";
+
+export async function chatOpenRouter(
+  res: FastifyReply,
+  body: AnthropicRequest,
+  model: string,
+  apiKey?: string
+) {
+  if (!apiKey) {
+    throw withStatus(401, "Missing OPENROUTER_API_KEY. Set it in ~/.claude-proxy/.env");
+  }
+
+  const url = `${OR_BASE}/chat/completions`;
+  const headers: Record<string, string> = {
+    Authorization: `Bearer ${apiKey}`,
+    "Content-Type": "application/json"
+  };
+
+  // Add optional OpenRouter headers
+  if (process.env.OPENROUTER_REFERER) {
+    headers["HTTP-Referer"] = process.env.OPENROUTER_REFERER;
+  }
+  if (process.env.OPENROUTER_TITLE) {
+    headers["X-Title"] = process.env.OPENROUTER_TITLE;
+  }
+
+  const reqBody: any = {
+    model,
+    messages: toOpenAIMessages(body.messages),
+    stream: true,
+    temperature: body.temperature ?? 0.7,
+    max_tokens: body.max_tokens
+  };
+
+  // Pass through tools if provided
+  if (body.tools && body.tools.length > 0) {
+    console.warn("[openrouter] Tools passed through but format may not be compatible");
+    reqBody.tools = body.tools;
+  }
+
+  const resp = await fetch(url, {
+    method: "POST",
+    headers,
+    body: JSON.stringify(reqBody)
+  });
+
+  if (!resp.ok || !resp.body) {
+    const text = await safeText(resp);
+    throw withStatus(resp.status || 500, `OpenRouter error: ${text}`);
+  }
+
+  startAnthropicMessage(res, model);
+
+  const reader = resp.body.getReader();
+  const decoder = new TextDecoder();
+  const parser = createParser((event) => {
+    if (event.type !== "event") return;
+    const data = event.data;
+    if (!data || data === "[DONE]") return;
+    try {
+      const json = JSON.parse(data);
+      const chunk = json.choices?.[0]?.delta?.content ?? "";
+      if (chunk) deltaText(res, chunk);
+    } catch {
+      // ignore parse errors
+    }
+  });
+
+  while (true) {
+    const { value, done } = await reader.read();
+    if (done) break;
+    parser.feed(decoder.decode(value));
+  }
+
+  stopAnthropicMessage(res);
+}
+
+function withStatus(status: number, message: string) {
+  const e = new Error(message);
+  // @ts-ignore
+  e.statusCode = status;
+  return e;
+}
+
+async function safeText(resp: Response) {
+  try {
+    return await resp.text();
+  } catch {
+    return "<no-body>";
+  }
+}

package/adapters/sse.ts

@@ -0,0 +1,62 @@
+// Server-Sent Events (SSE) utilities for Anthropic-style streaming
+import type { FastifyReply } from "fastify";
+
+export function initSSE(res: FastifyReply) {
+  res.raw.setHeader("Content-Type", "text/event-stream");
+  res.raw.setHeader("Cache-Control", "no-cache, no-transform");
+  res.raw.setHeader("Connection", "keep-alive");
+  // @ts-ignore
+  res.raw.flushHeaders?.();
+}
+
+export function sendEvent(res: FastifyReply, event: string, data: unknown) {
+  res.raw.write(`event: ${event}\n`);
+  res.raw.write(`data: ${JSON.stringify(data)}\n\n`);
+}
+
+export function endSSE(res: FastifyReply) {
+  res.raw.write("event: done\n");
+  res.raw.write("data: {}\n\n");
+  res.raw.end();
+}
+
+export function startAnthropicMessage(res: FastifyReply, model: string) {
+  const id = `msg_${Date.now()}`;
+  sendEvent(res, "message_start", {
+    type: "message_start",
+    message: {
+      id,
+      type: "message",
+      role: "assistant",
+      model,
+      content: [],
+      stop_reason: null,
+      stop_sequence: null,
+      usage: { input_tokens: 0, output_tokens: 0 }
+    }
+  });
+  sendEvent(res, "content_block_start", {
+    type: "content_block_start",
+    index: 0,
+    content_block: { type: "text", text: "" }
+  });
+}
+
+export function deltaText(res: FastifyReply, text: string) {
+  if (!text) return;
+  sendEvent(res, "content_block_delta", {
+    type: "content_block_delta",
+    index: 0,
+    delta: { type: "text_delta", text }
+  });
+}
+
+export function stopAnthropicMessage(res: FastifyReply) {
+  sendEvent(res, "content_block_stop", { type: "content_block_stop", index: 0 });
+  sendEvent(res, "message_delta", {
+    type: "message_delta",
+    delta: { stop_reason: "end_turn", stop_sequence: null },
+    usage: { output_tokens: 0 }
+  });
+  sendEvent(res, "message_stop", { type: "message_stop" });
+}

package/adapters/types.ts

@@ -0,0 +1,36 @@
+// TypeScript type definitions for Anthropic API subset
+// Used across all adapter files
+
+export type AnthropicContentBlock =
+  | { type: "text"; text: string }
+  | { type: "image"; source: { type: "base64"; media_type: string; data: string } }
+  | { type: "tool_use"; id: string; name: string; input: unknown }
+  | { type: "tool_result"; tool_use_id: string; content: string | unknown[] };
+
+export type AnthropicMessage = {
+  role: "user" | "assistant";
+  content: string | AnthropicContentBlock[];
+};
+
+export type AnthropicTool = {
+  name: string;
+  description?: string;
+  input_schema?: unknown;
+};
+
+export type AnthropicRequest = {
+  model: string;
+  messages: AnthropicMessage[];
+  max_tokens?: number;
+  temperature?: number;
+  stream?: boolean;
+  tools?: AnthropicTool[];
+  system?: string;
+};
+
+export type ProviderKey = "openai" | "openrouter" | "gemini" | "glm" | "anthropic";
+
+export type ProviderModel = {
+  provider: ProviderKey;
+  model: string;
+};