qwenproxy-cli 1.0.0

package/src/routes/responses/types.ts

@@ -0,0 +1,285 @@
+// OpenAI Responses API types (/v1/responses)
+
+import type { ContextMeterSnapshot } from "../../services/context-meter.ts";
+
+// ============ Request types ============
+
+export interface ResponsesRequest {
+  model: string;
+  input: string | ResponsesInputMessage[];
+  instructions?: string | null;
+  stream?: boolean;
+  previous_response_id?: string | null;
+  tools?: ResponsesTool[] | null;
+  tool_choice?: ResponsesToolChoice | null;
+  temperature?: number;
+  top_p?: number;
+  max_output_tokens?: number;
+  store?: boolean;
+  user?: string;
+  metadata?: Record<string, string>;
+  parallel_tool_calls?: boolean;
+  // Reasoning (optional, passthrough — accepts any string, normalized internally)
+  reasoning?: {
+    effort?: string;
+    summary?: "auto" | "concise" | "detailed";
+  } | null;
+  reasoning_effort?: string;
+  text?: {
+    format?: {
+      type?: "text" | "json_schema" | "json_object";
+      name?: string;
+      description?: string;
+      schema?: Record<string, unknown>;
+      strict?: boolean;
+    };
+    verbosity?: "low" | "medium" | "high";
+  } | null;
+  truncation?: "auto" | "disabled";
+  service_tier?: "auto" | "default" | "flex" | "priority";
+}
+
+export type ResponsesInputMessage =
+  | ResponsesMessageInputItem
+  | ResponsesFunctionCallInputItem
+  | ResponsesFunctionCallOutputInputItem;
+
+export interface ResponsesMessageInputItem {
+  type?: "message";
+  role: "user" | "assistant" | "system" | "developer";
+  content: string | ResponsesContentPart[];
+}
+
+export interface ResponsesFunctionCallInputItem {
+  type: "function_call";
+  call_id?: string;
+  name?: string;
+  arguments?: string;
+}
+
+export interface ResponsesFunctionCallOutputInputItem {
+  type: "function_call_output";
+  call_id?: string;
+  output?: string;
+  content?: string | ResponsesContentPart[];
+  role?: "tool";
+}
+
+export interface ResponsesContentPart {
+  type: "input_text" | "output_text" | "text" | "input_image" | "input_file";
+  text?: string;
+  // For images
+  image_url?: string;
+  detail?: "auto" | "low" | "high";
+  // For files
+  file?: {
+    file_id?: string;
+    file_data?: string;
+    filename?: string;
+  };
+}
+
+export interface ResponsesFunctionTool {
+  type: "function";
+  name: string;
+  description?: string;
+  parameters?: Record<string, unknown>;
+  strict?: boolean;
+}
+
+export interface ResponsesBuiltinTool {
+  type: string; // web_search, file_search, shell, code_interpreter, etc.
+  [key: string]: unknown;
+}
+
+export type ResponsesTool = ResponsesFunctionTool | ResponsesBuiltinTool;
+
+export type ResponsesToolChoice =
+  | "auto"
+  | "required"
+  | "none"
+  | {
+      type: "function";
+      name?: string;
+      function?: { name: string };
+    };
+
+// ============ Response types ============
+
+export interface ResponsesResponse {
+  id: string;
+  object: "response";
+  created_at: number;
+  model: string;
+  status: "completed" | "failed" | "in_progress" | "cancelled" | "incomplete";
+  error?: {
+    code: string;
+    message: string;
+  } | null;
+  incomplete_details?: {
+    reason: string;
+  } | null;
+  output: ResponsesOutputItem[];
+  parallel_tool_calls?: boolean;
+  tool_choice?: ResponsesToolChoice;
+  tools?: ResponsesTool[];
+  usage?: ResponsesUsage;
+  // Metadata
+  temperature?: number;
+  top_p?: number;
+  max_output_tokens?: number;
+  previous_response_id?: string | null;
+  /** ID of the last response in this conversation chain (for client memory) */
+  last_response_id?: string | null;
+  metadata?: Record<string, string>;
+  text?: { verbosity?: "low" | "medium" | "high"; format?: { type: "text" } };
+  reasoning?: {
+    effort?: string;
+    summary?: "auto" | "concise" | "detailed";
+  };
+  truncation?: "auto" | "disabled";
+  user?: string;
+}
+
+export interface ResponsesUsage {
+  input_tokens: number;
+  output_tokens: number;
+  total_tokens: number;
+  input_tokens_details: {
+    cached_tokens: number;
+  };
+  output_tokens_details: {
+    reasoning_tokens: number;
+  };
+  /** Optional QwenProxy diagnostic extension when context metering is enabled. */
+  context_meter?: ContextMeterSnapshot;
+}
+
+export interface ResponsesOutputReasoning {
+  type: "reasoning";
+  id: string;
+  summary: Array<{ type: "summary_text"; text: string }>;
+}
+
+export type ResponsesOutputItem =
+  | ResponsesOutputMessage
+  | ResponsesOutputFunctionCall
+  | ResponsesOutputReasoning;
+
+export interface ResponsesOutputMessage {
+  type: "message";
+  id: string;
+  role: "assistant";
+  status: "completed" | "in_progress";
+  content: ResponsesOutputContentPart[];
+}
+
+export interface ResponsesOutputFunctionCall {
+  type: "function_call";
+  id: string;
+  call_id: string;
+  name: string;
+  arguments: string;
+  status: "completed" | "in_progress";
+}
+
+export interface ResponsesOutputContentPart {
+  type: "output_text";
+  text: string;
+  annotations: unknown[];
+}
+
+// ============ Streaming event types ============
+
+export type ResponsesStreamEvent =
+  | { type: "response.created"; response: ResponsesResponse; sequence_number?: number }
+  | { type: "response.in_progress"; response: ResponsesResponse; sequence_number?: number }
+  | {
+      type: "response.output_item.added";
+      output_index: number;
+      item: ResponsesOutputItem;
+      sequence_number?: number;
+    }
+  | {
+      type: "response.content_part.added";
+      item_id: string;
+      output_index: number;
+      content_index: number;
+      part: ResponsesOutputContentPart;
+      sequence_number?: number;
+    }
+  | {
+      type: "response.output_text.delta";
+      item_id: string;
+      output_index: number;
+      content_index: number;
+      delta: string;
+      sequence_number?: number;
+    }
+  | {
+      type: "response.output_text.done";
+      item_id: string;
+      output_index: number;
+      content_index: number;
+      text: string;
+      sequence_number?: number;
+    }
+  | {
+      type: "response.content_part.done";
+      item_id: string;
+      output_index: number;
+      content_index: number;
+      part: ResponsesOutputContentPart;
+      sequence_number?: number;
+    }
+  | {
+      type: "response.output_item.done";
+      output_index: number;
+      item: ResponsesOutputItem;
+      sequence_number?: number;
+    }
+  | {
+      type: "response.function_call_arguments.delta";
+      item_id: string;
+      output_index: number;
+      delta: string;
+      sequence_number?: number;
+    }
+  | {
+      type: "response.function_call_arguments.done";
+      item_id: string;
+      output_index: number;
+      arguments: string;
+      sequence_number?: number;
+    }
+  | {
+      type: "response.reasoning_summary_part.added";
+      item_id: string;
+      output_index: number;
+      part: { type: "summary_text"; text: string };
+      sequence_number?: number;
+    }
+  | {
+      type: "response.reasoning_summary_text.delta";
+      item_id: string;
+      output_index: number;
+      delta: string;
+      sequence_number?: number;
+    }
+  | {
+      type: "response.reasoning_summary_text.done";
+      item_id: string;
+      output_index: number;
+      text: string;
+      sequence_number?: number;
+    }
+  | {
+      type: "response.reasoning_summary_part.done";
+      item_id: string;
+      output_index: number;
+      part: { type: "summary_text"; text: string };
+      sequence_number?: number;
+    }
+  | { type: "response.completed"; response: ResponsesResponse; sequence_number?: number }
+  | { type: "response.failed"; response: ResponsesResponse; sequence_number?: number }
+  | { type: "error"; code: string; message: string; sequence_number?: number };

package/src/routes/responses/validation.ts

@@ -0,0 +1,202 @@
+import { z } from "zod";
+import type { ResponsesRequest } from "./types.ts";
+
+// ============ Zod schemas ============
+
+const ContentPartSchema = z.object({
+  type: z.enum([
+    "input_text",
+    "output_text",
+    "text",
+    "input_image",
+    "input_file",
+  ]),
+  text: z.string().optional(),
+  image_url: z.string().optional(),
+  detail: z.enum(["auto", "low", "high"]).optional(),
+  file: z
+    .object({
+      file_id: z.string().optional(),
+      file_data: z.string().optional(),
+      filename: z.string().optional(),
+    })
+    .optional(),
+});
+
+const MessageInputSchema = z.object({
+  type: z.literal("message").optional(),
+  role: z.enum(["user", "assistant", "system", "developer"]),
+  content: z.union([z.string(), z.array(ContentPartSchema)]),
+});
+
+const FunctionCallInputSchema = z.object({
+  type: z.literal("function_call"),
+  call_id: z.string().optional(),
+  name: z.string().optional(),
+  arguments: z.string().optional(),
+});
+
+const FunctionCallOutputInputSchema = z.object({
+  type: z.literal("function_call_output"),
+  call_id: z.string().optional(),
+  output: z.string().optional(),
+  content: z.union([z.string(), z.array(ContentPartSchema)]).optional(),
+  role: z.literal("tool").optional(),
+});
+
+// Items with explicit type field
+const TypedInputSchema = z.union([
+  FunctionCallInputSchema,
+  FunctionCallOutputInputSchema,
+]);
+
+// Fallback: accept any object with a type field (e.g. reasoning items)
+// This prevents rejection of input types we don't explicitly handle
+const UnknownTypedInputSchema = z
+  .object({
+    type: z.string(),
+  })
+  .passthrough();
+
+// Messages can have type: "message" or no type at all (inferred from role)
+const InputMessageSchema = z.union([
+  TypedInputSchema,
+  MessageInputSchema,
+  UnknownTypedInputSchema,
+]);
+
+// Function tool schema
+const FunctionToolSchema = z.object({
+  type: z.literal("function"),
+  name: z.string().min(1),
+  description: z.string().optional(),
+  parameters: z.record(z.string(), z.any()).optional(),
+  strict: z.boolean().optional(),
+});
+
+// Built-in tools (web_search, file_search, shell, etc.) - passthrough
+const BuiltInToolSchema = z
+  .object({
+    type: z.string(),
+  })
+  .passthrough();
+
+const ToolSchema = z.union([FunctionToolSchema, BuiltInToolSchema]);
+
+const ToolChoiceSchema = z.union([
+  z.literal("auto"),
+  z.literal("required"),
+  z.literal("none"),
+  z
+    .object({
+      type: z.literal("function"),
+      name: z.string().optional(),
+      function: z.object({ name: z.string() }).optional(),
+    })
+    .refine((value) => value.name || value.function?.name, {
+      message: "Function tool_choice requires 'name' or 'function.name'",
+    }),
+]);
+
+const ResponsesRequestSchema = z.object({
+  model: z.string().min(1),
+  input: z.union([z.string(), z.array(InputMessageSchema)]),
+  instructions: z.string().nullable().optional(),
+  stream: z.boolean().optional(),
+  previous_response_id: z.string().nullable().optional(),
+  tools: z.array(ToolSchema).nullable().optional(),
+  tool_choice: ToolChoiceSchema.nullable().optional(),
+  temperature: z.number().min(0).max(2).optional(),
+  top_p: z.number().min(0).max(1).optional(),
+  max_output_tokens: z.number().int().positive().optional(),
+  store: z.boolean().optional(),
+  user: z.string().optional(),
+  metadata: z.record(z.string(), z.string()).optional(),
+  parallel_tool_calls: z.boolean().optional(),
+  reasoning: z
+    .object({
+      effort: z.string().optional(),
+      summary: z.enum(["auto", "concise", "detailed"]).optional(),
+    })
+    .nullable()
+    .optional(),
+  reasoning_effort: z.string().optional(),
+  text: z
+    .object({
+      format: z
+        .object({
+          type: z.enum(["text", "json_schema", "json_object"]),
+          name: z.string().optional(),
+          description: z.string().optional(),
+          schema: z.record(z.string(), z.any()).optional(),
+          strict: z.boolean().optional(),
+        })
+        .optional(),
+      verbosity: z.enum(["low", "medium", "high"]).optional(),
+    })
+    .nullable()
+    .optional(),
+  truncation: z.enum(["auto", "disabled"]).optional(),
+  service_tier: z.enum(["auto", "default", "flex", "priority"]).optional(),
+});
+
+// ============ Validation function ============
+
+export interface ValidationResult {
+  valid: boolean;
+  error?: string;
+  // Use broader type to accept unknown input item types from clients like Codex
+  data?: Omit<ResponsesRequest, "input"> & {
+    input: string | unknown[];
+  };
+}
+
+export function validateResponsesRequest(body: unknown): ValidationResult {
+  const result = ResponsesRequestSchema.safeParse(body);
+  if (!result.success) {
+    const firstIssue = result.error.issues[0];
+    const path = firstIssue.path.join(".");
+    // Log the problematic input for debugging
+    const inputVal = (body as any)?.input;
+    const itemPath = firstIssue.path;
+    let debugInfo = "";
+    if (Array.isArray(inputVal) && itemPath.length >= 2) {
+      const idx = typeof itemPath[1] === "number" ? itemPath[1] : undefined;
+      if (idx !== undefined) {
+        debugInfo = ` | item[${idx}]: ${JSON.stringify(inputVal[idx]).substring(0, 200)}`;
+      }
+    }
+    console.warn(
+      `[Responses] Validation failed: '${path}' — ${firstIssue.message}${debugInfo}`,
+    );
+    return {
+      valid: false,
+      error: `Invalid '${path}': ${firstIssue.message}`,
+    };
+  }
+
+  // Extra validations
+  const data = result.data;
+
+  // Validate tool_choice requires tools
+  if (
+    data.tool_choice != null &&
+    data.tool_choice !== "none" &&
+    !data.tools?.length
+  ) {
+    return {
+      valid: false,
+      error: "'tool_choice' requires at least one tool in 'tools'",
+    };
+  }
+
+  // Validate previous_response_id is not empty
+  if (data.previous_response_id === "") {
+    return {
+      valid: false,
+      error: "'previous_response_id' cannot be empty",
+    };
+  }
+
+  return { valid: true, data };
+}