cctra 0.3.0

package/src/server/handlers/messages.ts

@@ -0,0 +1,89 @@
+// ============================================================================
+// POST /anthropic/v1/messages 处理器
+// ============================================================================
+import { anthropicToCanonical } from "../../convert/inbound/anthropic-to-canonical";
+import { callUpstream, callUpstreamStream, UpstreamError } from "../upstream";
+import { canonicalToAnthropicResponse } from "../../convert/outbound/canonical-to-anthropic";
+import { anthropicErrorBody } from "../error";
+import { errorResponseToHttpStatus } from "../error-status";
+import { resolveRoute } from "../../core/routing";
+import { wrapWithKeepalive } from "../keepalive";
+import { loadConfigFile } from "../../core/config";
+import { logger } from "../../utils/logger";
+
+export async function handleMessages(req: Request): Promise<Response> {
+  const config = loadConfigFile();
+  let body: unknown;
+  try {
+    body = await req.json();
+  } catch {
+    return Response.json(anthropicErrorBody("Invalid JSON body"), { status: 400 });
+  }
+  const b = body as { model?: string };
+  if (!b.model) {
+    return Response.json(anthropicErrorBody("Missing 'model' field"), { status: 400 });
+  }
+
+  let route;
+  try {
+    route = resolveRoute(b.model, config);
+  } catch (e) {
+    return Response.json(anthropicErrorBody((e as Error).message), { status: 400 });
+  }
+
+  const canonical = anthropicToCanonical(body as Parameters<typeof anthropicToCanonical>[0]);
+  canonical.model = route.upstreamModelId;
+
+  if (canonical.stream) {
+    try {
+      const { upstreamStream, parser, format } = await callUpstreamStream({
+        route,
+        canonical,
+        clientFormat: "anthropic-messages",
+        clientSignal: req.signal,
+      });
+      const cstream = parser(upstreamStream);
+      const encoder = new TextEncoder();
+      const inner = new ReadableStream<Uint8Array>({
+        async start(controller) {
+          try {
+            for await (const chunk of cstream) {
+              for (const s of format(chunk)) controller.enqueue(encoder.encode(s));
+            }
+          } catch (e) {
+            logger.error(`[messages:stream] error: ${(e as Error).message}`);
+            if (e instanceof UpstreamError) {
+              // Anthropic 错误 SSE 事件：event: error / data: {"type":"error",...}
+              // 注意：发完 error 后**不再发 message_stop**（cc-switch 二元化约束）
+              const errEvent = `event: error\ndata: ${JSON.stringify({
+                type: "error",
+                error: { type: "api_error", message: e.message },
+              })}\n\n`;
+              controller.enqueue(encoder.encode(errEvent));
+            }
+          } finally {
+            controller.close();
+          }
+        },
+      });
+      return new Response(wrapWithKeepalive(inner), {
+        headers: { "Content-Type": "text/event-stream", "Cache-Control": "no-cache" },
+      });
+    } catch (e) {
+      return Response.json(anthropicErrorBody((e as Error).message), { status: 500 });
+    }
+  }
+
+  try {
+    const upstreamRes = await callUpstream({
+      route, canonical, clientFormat: "anthropic-messages", clientSignal: req.signal,
+    });
+    const body = canonicalToAnthropicResponse(upstreamRes);
+    const httpStatus = errorResponseToHttpStatus(upstreamRes);
+    return httpStatus !== undefined
+      ? Response.json(body, { status: httpStatus })
+      : Response.json(body);
+  } catch (e) {
+    return Response.json(anthropicErrorBody((e as Error).message), { status: 500 });
+  }
+}

package/src/server/handlers/models.ts

@@ -0,0 +1,35 @@
+// ============================================================================
+// GET /v1/models 处理器
+// 聚合所有订阅和插件的模型，按 OpenAI 格式输出
+// ============================================================================
+import { loadConfigFile } from "../../core/config";
+
+export function handleModels(): Response {
+  const config = loadConfigFile();
+  const items: Array<{ id: string; object: "model"; created: number; owned_by: string }> = [];
+  const now = Math.floor(Date.now() / 1000);
+
+  for (const [subName, sub] of Object.entries(config.subscriptions)) {
+    for (const m of sub.models) {
+      items.push({ id: `${subName}/${m.id}`, object: "model", created: now, owned_by: subName });
+      if (m.alias) {
+        items.push({ id: `${subName}/${m.alias}`, object: "model", created: now, owned_by: subName });
+      }
+    }
+  }
+  for (const [pluginName, plugin] of Object.entries(config.plugins)) {
+    if (!plugin.enabled) continue;
+    for (const m of plugin.models) {
+      items.push({ id: `${pluginName}/${m.id}`, object: "model", created: now, owned_by: pluginName });
+      if (m.alias) {
+        items.push({ id: `${pluginName}/${m.alias}`, object: "model", created: now, owned_by: pluginName });
+      }
+    }
+  }
+  // 加 4 个 tier
+  for (const t of ["cctra", "cctra-pro", "cctra-flash", "cctra-vision"]) {
+    items.push({ id: t, object: "model", created: now, owned_by: "cctra" });
+  }
+
+  return Response.json({ object: "list", data: items });
+}

package/src/server/handlers/responses.ts

@@ -0,0 +1,89 @@
+// ============================================================================
+// POST /v1/responses 处理器
+// ============================================================================
+import { responsesToCanonical } from "../../convert/inbound/responses-to-canonical";
+import { callUpstream, callUpstreamStream, UpstreamError } from "../upstream";
+import { canonicalToResponsesResponse } from "../../convert/outbound/canonical-to-responses";
+import { responsesErrorBody } from "../error";
+import { errorResponseToHttpStatus } from "../error-status";
+import { resolveRoute } from "../../core/routing";
+import { wrapWithKeepalive } from "../keepalive";
+import { loadConfigFile } from "../../core/config";
+import { logger } from "../../utils/logger";
+
+export async function handleResponses(req: Request): Promise<Response> {
+  const config = loadConfigFile();
+  let body: unknown;
+  try {
+    body = await req.json();
+  } catch {
+    return Response.json(responsesErrorBody("Invalid JSON body"), { status: 400 });
+  }
+  const b = body as { model?: string };
+  if (!b.model) {
+    return Response.json(responsesErrorBody("Missing 'model' field"), { status: 400 });
+  }
+
+  let route;
+  try {
+    route = resolveRoute(b.model, config);
+  } catch (e) {
+    return Response.json(responsesErrorBody((e as Error).message), { status: 400 });
+  }
+
+  const canonical = responsesToCanonical(body as Parameters<typeof responsesToCanonical>[0]);
+  canonical.model = route.upstreamModelId;
+
+  if (canonical.stream) {
+    try {
+      const { upstreamStream, parser, format } = await callUpstreamStream({
+        route,
+        canonical,
+        clientFormat: "openai-responses",
+        clientSignal: req.signal,
+      });
+      const cstream = parser(upstreamStream);
+      const encoder = new TextEncoder();
+      const inner = new ReadableStream<Uint8Array>({
+        async start(controller) {
+          try {
+            for await (const chunk of cstream) {
+              for (const s of format(chunk)) controller.enqueue(encoder.encode(s));
+            }
+          } catch (e) {
+            logger.error(`[responses:stream] error: ${(e as Error).message}`);
+            if (e instanceof UpstreamError) {
+              // Responses 错误 SSE 事件：event: response.error / data: {...}
+              // 注意：发完 error 后**不再发 response.completed**（cc-switch 二元化约束）
+              const errEvent = `event: response.error\ndata: ${JSON.stringify({
+                code: e.status?.toString() ?? "upstream_error",
+                message: e.message,
+              })}\n\n`;
+              controller.enqueue(encoder.encode(errEvent));
+            }
+          } finally {
+            controller.close();
+          }
+        },
+      });
+      return new Response(wrapWithKeepalive(inner), {
+        headers: { "Content-Type": "text/event-stream", "Cache-Control": "no-cache" },
+      });
+    } catch (e) {
+      return Response.json(responsesErrorBody((e as Error).message), { status: 500 });
+    }
+  }
+
+  try {
+    const upstreamRes = await callUpstream({
+      route, canonical, clientFormat: "openai-responses", clientSignal: req.signal,
+    });
+    const body = canonicalToResponsesResponse(upstreamRes);
+    const httpStatus = errorResponseToHttpStatus(upstreamRes);
+    return httpStatus !== undefined
+      ? Response.json(body, { status: httpStatus })
+      : Response.json(body);
+  } catch (e) {
+    return Response.json(responsesErrorBody((e as Error).message), { status: 500 });
+  }
+}

package/src/server/keepalive.ts

@@ -0,0 +1,63 @@
+// ============================================================================
+// SSE keepalive：在 inner 流空闲时每 intervalMs 插入 ": keepalive\n\n" 注释行
+// 防止中间网络设备（nginx / proxy / CDN）超时断流
+// ============================================================================
+
+const DEFAULT_INTERVAL_MS = 15_000;
+
+/**
+ * 包装一个 SSE ReadableStream，定期插入 keepalive 注释行
+ * 下游 cancel() 会清掉 timer，避免泄漏
+ */
+export function wrapWithKeepalive(
+  inner: ReadableStream<Uint8Array>,
+  intervalMs: number = DEFAULT_INTERVAL_MS,
+): ReadableStream<Uint8Array> {
+  const encoder = new TextEncoder();
+  const keepaliveBytes = encoder.encode(": keepalive\n\n");
+
+  let timer: ReturnType<typeof setInterval> | null = null;
+  let cancelled = false;
+
+  const stopTimer = (): void => {
+    if (timer !== null) {
+      clearInterval(timer);
+      timer = null;
+    }
+  };
+
+  return new ReadableStream<Uint8Array>({
+    start(controller) {
+      timer = setInterval(() => {
+        if (cancelled) return;
+        try {
+          controller.enqueue(keepaliveBytes);
+        } catch {
+          stopTimer();
+        }
+      }, intervalMs);
+
+      // 后台 pump：用 for-await 兼容 Bun + web stream 类型
+      void (async () => {
+        try {
+          for await (const chunk of inner as unknown as AsyncIterable<Uint8Array>) {
+            if (cancelled) break;
+            controller.enqueue(chunk);
+          }
+        } catch (e) {
+          if (!cancelled) controller.error(e);
+        } finally {
+          stopTimer();
+          try { controller.close(); } catch { /* 已关 */ }
+        }
+      })();
+    },
+    cancel(reason) {
+      cancelled = true;
+      stopTimer();
+      // 不主动 cancel inner：for-await 已隐式锁了 reader，再 cancel 会报 "ReadableStream is locked"
+      // pump 会因为 inner 自然结束（fetch abort / source close）退出，或 controller.enqueue 失败时退出
+      void reason;
+    },
+  });
+}

package/src/server/responses-parser.ts

@@ -0,0 +1,62 @@
+// ============================================================================
+// 上游响应解析：OpenAI Responses → CanonicalResponse
+// 跟 upstream.ts（orchestrator）配套使用
+// ============================================================================
+import type { CanonicalResponse, CanonicalContentBlock, StopReason } from "../canonical/types";
+
+interface ResponsesUpstreamResponse {
+  id?: string;
+  model?: string;
+  status?: "completed" | "incomplete" | "failed" | string;
+  output?: Array<
+    | { type: "message"; role?: "assistant"; content?: Array<{ type: "output_text"; text: string } | { type: "refusal"; refusal: string }> }
+    | { type: "function_call"; call_id: string; name: string; arguments: string }
+    | { type: "reasoning"; summary?: Array<{ type: "summary_text"; text: string }> }
+  >;
+  usage?: {
+    input_tokens?: number;
+    output_tokens?: number;
+  };
+}
+
+export function parseResponsesResponse(raw: unknown, model: string): CanonicalResponse {
+  const r = raw as ResponsesUpstreamResponse;
+  const blocks: CanonicalContentBlock[] = [];
+
+  for (const item of r.output ?? []) {
+    if (item.type === "message") {
+      for (const c of item.content ?? []) {
+        if (c.type === "output_text") blocks.push({ type: "text", text: c.text });
+        else if (c.type === "refusal") blocks.push({ type: "refusal", refusal: c.refusal });
+      }
+    } else if (item.type === "function_call") {
+      let input: unknown = {};
+      try { input = JSON.parse(item.arguments); } catch { /* keep empty */ }
+      blocks.push({ type: "tool_use", id: item.call_id, name: item.name, input });
+    } else if (item.type === "reasoning") {
+      const thinking = (item.summary ?? []).map((s) => s.text).join("");
+      if (thinking) blocks.push({ type: "thinking", thinking });
+    }
+    // 跳过其他 type（reasoning_summary_text 单元素、file_citation 等）
+  }
+
+  return {
+    id: r.id ?? `resp-${Date.now()}`,
+    model: r.model ?? model,
+    content: blocks,
+    stopReason: mapStopReason(r.status),
+    usage: {
+      inputTokens: r.usage?.input_tokens ?? 0,
+      outputTokens: r.usage?.output_tokens ?? 0,
+    },
+  };
+}
+
+function mapStopReason(s: string | undefined): StopReason {
+  switch (s) {
+    case "completed": return "end_turn";
+    case "incomplete": return "max_tokens";
+    case "failed": return "error";
+    default: return "end_turn";
+  }
+}

package/src/server/serve.ts

@@ -0,0 +1,79 @@
+// ============================================================================
+// HTTP 服务器入口：Bun.serve() + 路由表
+// ============================================================================
+import { handleChatCompletions } from "./handlers/chat-completions";
+import { handleResponses } from "./handlers/responses";
+import { handleMessages } from "./handlers/messages";
+import { handleModels } from "./handlers/models";
+import { loadConfigFile } from "../core/config";
+import { logger } from "../utils/logger";
+
+export function startServer(portOverride?: number): { port: number; stop: () => void } {
+  const config = loadConfigFile();
+  const port = portOverride ?? config.port;
+
+  const server = Bun.serve({
+    port,
+    hostname: "127.0.0.1",
+    development: false,
+
+    async fetch(req: Request): Promise<Response> {
+      const url = new URL(req.url);
+
+      // CORS 预检
+      if (req.method === "OPTIONS") {
+        return new Response(null, {
+          status: 204,
+          headers: corsHeaders(),
+        });
+      }
+
+      // 健康检查
+      if (url.pathname === "/healthz") {
+        return Response.json({ ok: true, port });
+      }
+
+      // OpenAI Chat Completions
+      if (url.pathname === "/v1/chat/completions" && req.method === "POST") {
+        return handleChatCompletions(req);
+      }
+
+      // OpenAI Responses
+      if (url.pathname === "/v1/responses" && req.method === "POST") {
+        return handleResponses(req);
+      }
+
+      // Anthropic Messages（带 /v1 后缀的官方 path）
+      if (url.pathname === "/anthropic/v1/messages" && req.method === "POST") {
+        return handleMessages(req);
+      }
+
+      // Models listing
+      if (url.pathname === "/v1/models" && req.method === "GET") {
+        return handleModels();
+      }
+
+      // 未匹配的路径一律 404
+      return new Response(`Not Found: ${url.pathname}`, {
+        status: 404,
+        headers: corsHeaders(),
+      });
+    },
+  });
+
+  const actualPort = server.port ?? port;
+  logger.info(`cctra daemon listening on http://127.0.0.1:${actualPort}`);
+
+  return {
+    port: actualPort,
+    stop: () => server.stop(),
+  };
+}
+
+function corsHeaders(): Record<string, string> {
+  return {
+    "Access-Control-Allow-Origin": "*",
+    "Access-Control-Allow-Methods": "POST, GET, OPTIONS",
+    "Access-Control-Allow-Headers": "*",
+  };
+}

package/src/server/sse.ts

@@ -0,0 +1,61 @@
+// ============================================================================
+// SSE 工具：把 ReadableStream<Uint8Array> 解析成异步事件迭代器
+// 支持跨行 data: 字段（[data: ...\n data: ...] → 拼成一个事件）
+// UTF-8 安全
+// ============================================================================
+
+export interface SseEvent {
+  event?: string;
+  data: string;
+  id?: string;
+}
+
+export async function* parseSseStream(stream: ReadableStream<Uint8Array>): AsyncGenerator<SseEvent> {
+  const reader = stream.getReader();
+  const decoder = new TextDecoder("utf-8");
+  let buffer = "";
+  let dataLines: string[] = [];
+  let eventName: string | undefined;
+
+  while (true) {
+    const { value, done } = await reader.read();
+    if (done) break;
+    buffer += decoder.decode(value, { stream: true });
+
+    let idx: number;
+    while ((idx = buffer.indexOf("\n")) >= 0) {
+      const line = buffer.slice(0, idx).replace(/\r$/, "");
+      buffer = buffer.slice(idx + 1);
+
+      if (line === "") {
+        // 空行：分发事件
+        if (dataLines.length > 0) {
+          yield { event: eventName, data: dataLines.join("\n"), id: undefined };
+          dataLines = [];
+          eventName = undefined;
+        }
+      } else if (line.startsWith(":")) {
+        // 注释行
+      } else if (line.startsWith("data:")) {
+        dataLines.push(line.slice(5).trimStart());
+      } else if (line.startsWith("event:")) {
+        eventName = line.slice(6).trim();
+      } else if (line.startsWith("id:")) {
+        // 暂不实现
+      }
+    }
+  }
+
+  // 收尾：如果 buffer 还有内容
+  if (buffer.length > 0) {
+    if (buffer.startsWith("data:")) dataLines.push(buffer.slice(5).trimStart());
+    if (dataLines.length > 0) {
+      yield { event: eventName, data: dataLines.join("\n"), id: undefined };
+    }
+  }
+}
+
+/** 把字符串包成 SSE data 行 */
+export function sseDataLine(data: string): string {
+  return `data: ${data}\n\n`;
+}