cc-x10ded 3.0.0

package/src/proxy/server.ts

@@ -0,0 +1,87 @@
+import { serve } from "bun";
+import { parseProviderModel } from "./map";
+import { streamOpenAI, streamGemini, streamPassThrough } from "./providers";
+import { Config } from "../core/config";
+import { AnthropicRequest } from "./types";
+
+export function startProxyServer(config: Config, port: number = 17870) {
+  return serve({
+    port,
+    hostname: "127.0.0.1",
+    async fetch(req) {
+      const url = new URL(req.url);
+
+      if (url.pathname === "/healthz") return Response.json({ ok: true });
+      if (req.method !== "POST" || url.pathname !== "/v1/messages") {
+        return new Response("Not Found", { status: 404 });
+      }
+
+      try {
+        const body = await req.json() as AnthropicRequest;
+        const { provider, model } = parseProviderModel(body.model);
+        
+        const headers = {
+          "Content-Type": "text/event-stream",
+          "Cache-Control": "no-cache",
+          "Connection": "keep-alive",
+        };
+
+        const providers = config.providers;
+
+        // OpenAI-compatible handlers
+        if (provider === "openai") {
+          const conf = providers.openai;
+          if (!conf?.apiKey) throw new Error("Missing OpenAI API Key");
+          return new Response(streamOpenAI(body, model, conf.apiKey, conf.baseUrl || "https://api.openai.com/v1"), { headers });
+        }
+
+        if (provider === "openrouter") {
+          const conf = providers.openrouter;
+          if (!conf?.apiKey) throw new Error("Missing OpenRouter API Key");
+          return new Response(streamOpenAI(body, model, conf.apiKey, conf.baseUrl || "https://openrouter.ai/api/v1"), { headers });
+        }
+
+        if (provider === "gemini") {
+          const conf = providers.gemini;
+          if (!conf?.apiKey) throw new Error("Missing Gemini API Key");
+          return new Response(streamGemini(body, model, conf.apiKey, conf.baseUrl || "https://generativelanguage.googleapis.com/v1beta"), { headers });
+        }
+        
+        // Anthropic-compatible handlers (Passthrough)
+        let baseUrl = "";
+        let apiKey = "";
+        let extraHeaders: Record<string, string> = {};
+
+        if (provider === "anthropic") {
+           const conf = providers.anthropic;
+           if (!conf?.apiKey) throw new Error("Missing Anthropic API Key");
+           baseUrl = conf.baseUrl || "https://api.anthropic.com";
+           apiKey = conf.apiKey;
+           extraHeaders["x-api-key"] = apiKey;
+        } else if (provider === "minimax") {
+           apiKey = config.minimaxApiKey || "";
+           if (!apiKey) throw new Error("Missing Minimax API Key");
+           baseUrl = "https://api.minimax.io/anthropic";
+           extraHeaders["Authorization"] = `Bearer ${apiKey}`;
+        } else {
+           // GLM (Default)
+           apiKey = config.zaiApiKey || "";
+           if (!apiKey) throw new Error("Missing Z.AI API Key");
+           baseUrl = "https://api.z.ai/api/anthropic";
+           extraHeaders["Authorization"] = `Bearer ${apiKey}`;
+        }
+
+        const apiHeaders = {
+            "Content-Type": "application/json",
+            "anthropic-version": "2023-06-01",
+            ...extraHeaders
+        };
+
+        return new Response(streamPassThrough(body, baseUrl, apiHeaders), { headers });
+
+      } catch (e: any) {
+        return new Response(JSON.stringify({ error: e.message }), { status: 500, headers: { "Content-Type": "application/json" } });
+      }
+    },
+  });
+}

package/src/proxy/types.ts

@@ -0,0 +1,21 @@
+export type ProviderKey = "openai" | "openrouter" | "gemini" | "glm" | "anthropic" | "minimax";
+
+export interface ProviderModel {
+  provider: ProviderKey;
+  model: string;
+}
+
+export interface AnthropicMessage {
+  role: "user" | "assistant";
+  content: string | Array<{ type: "text"; text: string } | { type: "tool_result"; content: string | any }>;
+}
+
+export interface AnthropicRequest {
+  model: string; // "provider:model" or just "model"
+  messages: AnthropicMessage[];
+  max_tokens: number;
+  temperature?: number;
+  system?: string;
+  tools?: any[];
+  stream?: boolean;
+}

package/src/proxy/utils.ts

@@ -0,0 +1,54 @@
+export function createSSEMessage(event: string, data: any) {
+  return `event: ${event}\ndata: ${JSON.stringify(data)}\n\n`;
+}
+
+export function createStartMessage(model: string) {
+  const id = `msg_${Date.now()}`;
+  return (
+    createSSEMessage("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 }
+      }
+    }) +
+    createSSEMessage("content_block_start", {
+      type: "content_block_start",
+      index: 0,
+      content_block: { type: "text", text: "" }
+    })
+  );
+}
+
+export function createDelta(text: string) {
+  if (!text) return "";
+  return createSSEMessage("content_block_delta", {
+    type: "content_block_delta",
+    index: 0,
+    delta: { type: "text_delta", text }
+  });
+}
+
+export function createStopMessage() {
+  return (
+    createSSEMessage("content_block_stop", { type: "content_block_stop", index: 0 }) +
+    createSSEMessage("message_delta", {
+      type: "message_delta",
+      delta: { stop_reason: "end_turn", stop_sequence: null },
+      usage: { output_tokens: 0 }
+    }) +
+    createSSEMessage("message_stop", { type: "message_stop" })
+  );
+}
+
+export class ApiError extends Error {
+  constructor(public message: string, public statusCode: number = 500) {
+    super(message);
+  }
+}

package/tsconfig.json

@@ -0,0 +1,29 @@
+{
+  "compilerOptions": {
+    // Environment setup & latest features
+    "lib": ["ESNext"],
+    "target": "ESNext",
+    "module": "Preserve",
+    "moduleDetection": "force",
+    "jsx": "react-jsx",
+    "allowJs": true,
+
+    // Bundler mode
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "verbatimModuleSyntax": true,
+    "noEmit": true,
+
+    // Best practices
+    "strict": true,
+    "skipLibCheck": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUncheckedIndexedAccess": true,
+    "noImplicitOverride": true,
+
+    // Some stricter flags (disabled by default)
+    "noUnusedLocals": false,
+    "noUnusedParameters": false,
+    "noPropertyAccessFromIndexSignature": false
+  }
+}