qwenproxy-cli 1.0.0 → 1.0.1

package/src/routes/anthropic/types.ts

@@ -1,154 +1,154 @@
-// Anthropic API Types
-
-export interface AnthropicRequest {
-  model: string;
-  max_tokens: number;
-  system?: string | AnthropicContentBlock[];
-  messages: AnthropicMessage[];
-  tools?: AnthropicTool[];
-  tool_choice?: AnthropicToolChoice;
-  thinking?: AnthropicThinking;
-  stream?: boolean;
-  temperature?: number;
-  top_p?: number;
-  top_k?: number;
-  metadata?: Record<string, unknown>;
-}
-
-export interface AnthropicThinking {
-  type: "enabled" | "disabled";
-  budget_tokens?: number;
-}
-
-export interface AnthropicMessage {
-  role: "user" | "assistant";
-  content: string | AnthropicContentBlock[];
-}
-
-export interface AnthropicContentBlock {
-  type: "text" | "tool_use" | "tool_result" | "image" | "document" | "thinking";
-  text?: string;
-  id?: string;
-  name?: string;
-  input?: Record<string, unknown>;
-  tool_use_id?: string;
-  content?: string | AnthropicContentBlock[];
-  is_error?: boolean;
-  source?: AnthropicImageSource;
-  thinking?: string;
-}
-
-export interface AnthropicImageSource {
-  type: "base64" | "url";
-  media_type: string;
-  data?: string;
-  url?: string;
-}
-
-export interface AnthropicTool {
-  name: string;
-  description?: string;
-  input_schema: Record<string, unknown>;
-}
-
-export interface AnthropicToolChoice {
-  type: "auto" | "any" | "tool" | "none";
-  name?: string;
-}
-
-export interface AnthropicResponse {
-  id: string;
-  type: "message";
-  role: "assistant";
-  content: AnthropicResponseContentBlock[];
-  model: string;
-  stop_reason: "end_turn" | "tool_use" | "max_tokens" | "stop_sequence" | null;
-  stop_sequence: string | null;
-  usage: AnthropicUsage;
-}
-
-export interface AnthropicResponseContentBlock {
-  type: "text" | "tool_use" | "thinking";
-  text?: string;
-  id?: string;
-  name?: string;
-  input?: Record<string, unknown>;
-  thinking?: string;
-}
-
-export interface AnthropicUsage {
-  input_tokens: number;
-  output_tokens: number;
-  cache_creation_input_tokens?: number;
-  cache_read_input_tokens?: number;
-}
-
-export interface AnthropicError {
-  type: "error";
-  error: {
-    type: string;
-    message: string;
-  };
-  request_id?: string;
-}
-
-// Internal OpenAI-compatible types for conversion
-export interface OpenAIRequest {
-  model: string;
-  messages: OpenAIMessage[];
-  max_tokens?: number;
-  max_completion_tokens?: number;
-  tools?: OpenAITool[];
-  tool_choice?: string | object;
-  reasoning_effort?: string;
-  stream?: boolean;
-  temperature?: number;
-  top_p?: number;
-}
-
-export interface OpenAIMessage {
-  role: "system" | "user" | "assistant" | "tool";
-  content: string | null | Array<{ type: string; text?: string; image_url?: { url: string } }>;
-  tool_calls?: OpenAIToolCall[];
-  tool_call_id?: string;
-  reasoning_content?: string;
-}
-
-export interface OpenAITool {
-  type: "function";
-  function: {
-    name: string;
-    description?: string;
-    parameters?: Record<string, unknown>;
-  };
-}
-
-export interface OpenAIToolCall {
-  id: string;
-  type: "function";
-  function: {
-    name: string;
-    arguments: string;
-  };
-}
-
-export interface OpenAIResponse {
-  id: string;
-  object: "chat.completion";
-  created: number;
-  model: string;
-  choices: OpenAIChoice[];
-  usage: OpenAIUsage;
-}
-
-export interface OpenAIChoice {
-  index: number;
-  message: OpenAIMessage;
-  finish_reason: "stop" | "tool_calls" | "length" | "content_filter" | null;
-}
-
-export interface OpenAIUsage {
-  prompt_tokens: number;
-  completion_tokens: number;
-  total_tokens: number;
-}
+// Anthropic API Types
+
+export interface AnthropicRequest {
+  model: string;
+  max_tokens: number;
+  system?: string | AnthropicContentBlock[];
+  messages: AnthropicMessage[];
+  tools?: AnthropicTool[];
+  tool_choice?: AnthropicToolChoice;
+  thinking?: AnthropicThinking;
+  stream?: boolean;
+  temperature?: number;
+  top_p?: number;
+  top_k?: number;
+  metadata?: Record<string, unknown>;
+}
+
+export interface AnthropicThinking {
+  type: "enabled" | "disabled";
+  budget_tokens?: number;
+}
+
+export interface AnthropicMessage {
+  role: "user" | "assistant";
+  content: string | AnthropicContentBlock[];
+}
+
+export interface AnthropicContentBlock {
+  type: "text" | "tool_use" | "tool_result" | "image" | "document" | "thinking";
+  text?: string;
+  id?: string;
+  name?: string;
+  input?: Record<string, unknown>;
+  tool_use_id?: string;
+  content?: string | AnthropicContentBlock[];
+  is_error?: boolean;
+  source?: AnthropicImageSource;
+  thinking?: string;
+}
+
+export interface AnthropicImageSource {
+  type: "base64" | "url";
+  media_type: string;
+  data?: string;
+  url?: string;
+}
+
+export interface AnthropicTool {
+  name: string;
+  description?: string;
+  input_schema: Record<string, unknown>;
+}
+
+export interface AnthropicToolChoice {
+  type: "auto" | "any" | "tool" | "none";
+  name?: string;
+}
+
+export interface AnthropicResponse {
+  id: string;
+  type: "message";
+  role: "assistant";
+  content: AnthropicResponseContentBlock[];
+  model: string;
+  stop_reason: "end_turn" | "tool_use" | "max_tokens" | "stop_sequence" | null;
+  stop_sequence: string | null;
+  usage: AnthropicUsage;
+}
+
+export interface AnthropicResponseContentBlock {
+  type: "text" | "tool_use" | "thinking";
+  text?: string;
+  id?: string;
+  name?: string;
+  input?: Record<string, unknown>;
+  thinking?: string;
+}
+
+export interface AnthropicUsage {
+  input_tokens: number;
+  output_tokens: number;
+  cache_creation_input_tokens?: number;
+  cache_read_input_tokens?: number;
+}
+
+export interface AnthropicError {
+  type: "error";
+  error: {
+    type: string;
+    message: string;
+  };
+  request_id?: string;
+}
+
+// Internal OpenAI-compatible types for conversion
+export interface OpenAIRequest {
+  model: string;
+  messages: OpenAIMessage[];
+  max_tokens?: number;
+  max_completion_tokens?: number;
+  tools?: OpenAITool[];
+  tool_choice?: string | object;
+  reasoning_effort?: string;
+  stream?: boolean;
+  temperature?: number;
+  top_p?: number;
+}
+
+export interface OpenAIMessage {
+  role: "system" | "user" | "assistant" | "tool";
+  content: string | null | Array<{ type: string; text?: string; image_url?: { url: string } }>;
+  tool_calls?: OpenAIToolCall[];
+  tool_call_id?: string;
+  reasoning_content?: string;
+}
+
+export interface OpenAITool {
+  type: "function";
+  function: {
+    name: string;
+    description?: string;
+    parameters?: Record<string, unknown>;
+  };
+}
+
+export interface OpenAIToolCall {
+  id: string;
+  type: "function";
+  function: {
+    name: string;
+    arguments: string;
+  };
+}
+
+export interface OpenAIResponse {
+  id: string;
+  object: "chat.completion";
+  created: number;
+  model: string;
+  choices: OpenAIChoice[];
+  usage: OpenAIUsage;
+}
+
+export interface OpenAIChoice {
+  index: number;
+  message: OpenAIMessage;
+  finish_reason: "stop" | "tool_calls" | "length" | "content_filter" | null;
+}
+
+export interface OpenAIUsage {
+  prompt_tokens: number;
+  completion_tokens: number;
+  total_tokens: number;
+}

package/src/routes/anthropic/validation.ts

@@ -1,144 +1,144 @@
-export interface ValidationResult {
-  valid: boolean;
-  error?: string;
-}
-
-/**
- * Validate Anthropic request format
- */
-export function validateAnthropicRequest(body: unknown): ValidationResult {
-  if (!body || typeof body !== "object" || Array.isArray(body)) {
-    return { valid: false, error: "Request body must be a JSON object" };
-  }
-
-  const req = body as Record<string, unknown>;
-
-  // Model is required
-  if (!req.model || typeof req.model !== "string") {
-    return { valid: false, error: "Missing or invalid 'model' field" };
-  }
-
-  // max_tokens is required
-  if (req.max_tokens === undefined || req.max_tokens === null) {
-    return { valid: false, error: "Missing required field: max_tokens" };
-  }
-
-  if (typeof req.max_tokens !== "number" || req.max_tokens < 1) {
-    return { valid: false, error: "max_tokens must be a positive number" };
-  }
-
-  // messages is required
-  if (!req.messages || !Array.isArray(req.messages)) {
-    return { valid: false, error: "Missing or invalid 'messages' field" };
-  }
-
-  if (req.messages.length === 0) {
-    return { valid: false, error: "messages array cannot be empty" };
-  }
-
-  // Validate each message
-  for (let i = 0; i < req.messages.length; i++) {
-    const msg = req.messages[i];
-    if (!msg || typeof msg !== "object") {
-      return { valid: false, error: `messages[${i}] must be an object` };
-    }
-
-    if (
-      msg.role !== "user" &&
-      msg.role !== "assistant" &&
-      msg.role !== "system"
-    ) {
-      return {
-        valid: false,
-        error: `messages[${i}].role must be 'user', 'assistant' or 'system'`,
-      };
-    }
-
-    if (msg.content === undefined || msg.content === null) {
-      return { valid: false, error: `messages[${i}].content is required` };
-    }
-
-    // Content can be string or array of content blocks
-    if (typeof msg.content !== "string" && !Array.isArray(msg.content)) {
-      return {
-        valid: false,
-        error: `messages[${i}].content must be a string or array of content blocks`,
-      };
-    }
-  }
-
-  // Validate tools if present
-  if (req.tools !== undefined) {
-    if (!Array.isArray(req.tools)) {
-      return { valid: false, error: "'tools' must be an array" };
-    }
-
-    for (let i = 0; i < req.tools.length; i++) {
-      const tool = req.tools[i];
-      if (!tool || typeof tool !== "object") {
-        return { valid: false, error: `tools[${i}] must be an object` };
-      }
-
-      if (!tool.name || typeof tool.name !== "string") {
-        return {
-          valid: false,
-          error: `tools[${i}].name is required and must be a string`,
-        };
-      }
-
-      if (tool.input_schema && typeof tool.input_schema !== "object") {
-        return {
-          valid: false,
-          error: `tools[${i}].input_schema must be an object`,
-        };
-      }
-    }
-  }
-
-  // Validate tool_choice if present
-  if (req.tool_choice !== undefined && req.tool_choice !== null) {
-    const toolChoice = req.tool_choice as Record<string, unknown>;
-    if (typeof toolChoice !== "object" || !toolChoice.type) {
-      return {
-        valid: false,
-        error: "'tool_choice' must be an object with a 'type' field",
-      };
-    }
-
-    const validTypes = ["auto", "any", "tool", "none"];
-    if (!validTypes.includes(toolChoice.type as string)) {
-      return {
-        valid: false,
-        error: `tool_choice.type must be one of: ${validTypes.join(", ")}`,
-      };
-    }
-
-    if (toolChoice.type === "tool" && !toolChoice.name) {
-      return {
-        valid: false,
-        error: "tool_choice.name is required when type is 'tool'",
-      };
-    }
-  }
-
-  // Validate stream if present
-  if (req.stream !== undefined && typeof req.stream !== "boolean") {
-    return { valid: false, error: "'stream' must be a boolean" };
-  }
-
-  // Validate temperature if present
-  if (req.temperature !== undefined) {
-    if (
-      typeof req.temperature !== "number" ||
-      req.temperature < 0 ||
-      req.temperature > 1
-    ) {
-      return {
-        valid: false,
-        error: "'temperature' must be a number between 0 and 1",
-      };
-    }
-  }
-
-  return { valid: true };
-}
+export interface ValidationResult {
+  valid: boolean;
+  error?: string;
+}
+
+/**
+ * Validate Anthropic request format
+ */
+export function validateAnthropicRequest(body: unknown): ValidationResult {
+  if (!body || typeof body !== "object" || Array.isArray(body)) {
+    return { valid: false, error: "Request body must be a JSON object" };
+  }
+
+  const req = body as Record<string, unknown>;
+
+  // Model is required
+  if (!req.model || typeof req.model !== "string") {
+    return { valid: false, error: "Missing or invalid 'model' field" };
+  }
+
+  // max_tokens is required
+  if (req.max_tokens === undefined || req.max_tokens === null) {
+    return { valid: false, error: "Missing required field: max_tokens" };
+  }
+
+  if (typeof req.max_tokens !== "number" || req.max_tokens < 1) {
+    return { valid: false, error: "max_tokens must be a positive number" };
+  }
+
+  // messages is required
+  if (!req.messages || !Array.isArray(req.messages)) {
+    return { valid: false, error: "Missing or invalid 'messages' field" };
+  }
+
+  if (req.messages.length === 0) {
+    return { valid: false, error: "messages array cannot be empty" };
+  }
+
+  // Validate each message
+  for (let i = 0; i < req.messages.length; i++) {
+    const msg = req.messages[i];
+    if (!msg || typeof msg !== "object") {
+      return { valid: false, error: `messages[${i}] must be an object` };
+    }
+
+    if (
+      msg.role !== "user" &&
+      msg.role !== "assistant" &&
+      msg.role !== "system"
+    ) {
+      return {
+        valid: false,
+        error: `messages[${i}].role must be 'user', 'assistant' or 'system'`,
+      };
+    }
+
+    if (msg.content === undefined || msg.content === null) {
+      return { valid: false, error: `messages[${i}].content is required` };
+    }
+
+    // Content can be string or array of content blocks
+    if (typeof msg.content !== "string" && !Array.isArray(msg.content)) {
+      return {
+        valid: false,
+        error: `messages[${i}].content must be a string or array of content blocks`,
+      };
+    }
+  }
+
+  // Validate tools if present
+  if (req.tools !== undefined) {
+    if (!Array.isArray(req.tools)) {
+      return { valid: false, error: "'tools' must be an array" };
+    }
+
+    for (let i = 0; i < req.tools.length; i++) {
+      const tool = req.tools[i];
+      if (!tool || typeof tool !== "object") {
+        return { valid: false, error: `tools[${i}] must be an object` };
+      }
+
+      if (!tool.name || typeof tool.name !== "string") {
+        return {
+          valid: false,
+          error: `tools[${i}].name is required and must be a string`,
+        };
+      }
+
+      if (tool.input_schema && typeof tool.input_schema !== "object") {
+        return {
+          valid: false,
+          error: `tools[${i}].input_schema must be an object`,
+        };
+      }
+    }
+  }
+
+  // Validate tool_choice if present
+  if (req.tool_choice !== undefined && req.tool_choice !== null) {
+    const toolChoice = req.tool_choice as Record<string, unknown>;
+    if (typeof toolChoice !== "object" || !toolChoice.type) {
+      return {
+        valid: false,
+        error: "'tool_choice' must be an object with a 'type' field",
+      };
+    }
+
+    const validTypes = ["auto", "any", "tool", "none"];
+    if (!validTypes.includes(toolChoice.type as string)) {
+      return {
+        valid: false,
+        error: `tool_choice.type must be one of: ${validTypes.join(", ")}`,
+      };
+    }
+
+    if (toolChoice.type === "tool" && !toolChoice.name) {
+      return {
+        valid: false,
+        error: "tool_choice.name is required when type is 'tool'",
+      };
+    }
+  }
+
+  // Validate stream if present
+  if (req.stream !== undefined && typeof req.stream !== "boolean") {
+    return { valid: false, error: "'stream' must be a boolean" };
+  }
+
+  // Validate temperature if present
+  if (req.temperature !== undefined) {
+    if (
+      typeof req.temperature !== "number" ||
+      req.temperature < 0 ||
+      req.temperature > 1
+    ) {
+      return {
+        valid: false,
+        error: "'temperature' must be a number between 0 and 1",
+      };
+    }
+  }
+
+  return { valid: true };
+}