//#region src/services/proxy/transformer.d.ts
/**
* API format transformer
* Converts between Anthropic and OpenAI API formats
*/
interface AnthropicMessage {
  role: "user" | "assistant";
  content: string | AnthropicContentBlock[];
}
interface AnthropicContentBlock {
  type: "text" | "image" | "tool_use" | "tool_result";
  text?: string;
  source?: {
    type: "base64";
    media_type: string;
    data: string;
  };
  id?: string;
  name?: string;
  input?: unknown;
  tool_use_id?: string;
  content?: string;
}
interface AnthropicTool {
  name: string;
  description?: string;
  input_schema: Record<string, unknown>;
}
interface AnthropicRequest {
  model: string;
  messages: AnthropicMessage[];
  max_tokens?: number;
  temperature?: number;
  top_p?: number;
  top_k?: number;
  stop_sequences?: string[];
  stream?: boolean;
  system?: string;
  metadata?: Record<string, unknown>;
  tools?: AnthropicTool[];
  tool_choice?: {
    type: string;
    name?: string;
  } | string;
}
interface AnthropicResponse {
  id: string;
  type: "message";
  role: "assistant";
  content: AnthropicContentBlock[];
  model: string;
  stop_reason: "end_turn" | "max_tokens" | "stop_sequence" | "tool_use" | null;
  stop_sequence: string | null;
  usage: {
    input_tokens: number;
    output_tokens: number;
  };
}
interface OpenAIMessage {
  role: "system" | "user" | "assistant" | "tool";
  content: string | OpenAIContentPart[] | null;
  name?: string;
  tool_calls?: OpenAIToolCall[];
  tool_call_id?: string;
}
interface OpenAIContentPart {
  type: "text" | "image_url";
  text?: string;
  image_url?: {
    url: string;
    detail?: "auto" | "low" | "high";
  };
}
interface OpenAIToolCall {
  id: string;
  type: "function";
  function: {
    name: string;
    arguments: string;
  };
}
interface OpenAITool {
  type: "function";
  function: {
    name: string;
    description?: string;
    parameters: Record<string, unknown>;
  };
}
interface OpenAIRequest {
  model: string;
  messages: OpenAIMessage[];
  max_tokens?: number;
  temperature?: number;
  top_p?: number;
  stop?: string | string[];
  stream?: boolean;
  n?: number;
  presence_penalty?: number;
  frequency_penalty?: number;
  tools?: OpenAITool[];
  tool_choice?: "none" | "auto" | "required" | {
    type: "function";
    function: {
      name: string;
    };
  };
}
/**
* Convert Anthropic request to OpenAI format
*/
declare function anthropicToOpenAIRequest(anthropicReq: AnthropicRequest): OpenAIRequest;
/**
* Convert OpenAI response to Anthropic format
*/
declare function openAIToAnthropicResponse(openAIRes: unknown, originalModel: string): AnthropicResponse;
/**
* Transform OpenAI SSE stream to Anthropic SSE stream
*/
declare function createStreamTransformer(originalModel: string): TransformStream<Uint8Array, Uint8Array>;
/**
* Check if request is in Anthropic format
*/
declare function isAnthropicRequest(body: unknown): boolean;
/**
* Check if response is in OpenAI format
*/
declare function isOpenAIResponse(body: unknown): boolean;
/**
* OpenAI Responses API request format
*/
interface ResponsesAPIRequest {
  model: string;
  input: string | ResponsesAPIInputItem[];
  instructions?: string;
  tools?: ResponsesAPITool[];
  temperature?: number;
  max_output_tokens?: number;
  stream?: boolean;
  previous_response_id?: string;
  reasoning?: {
    effort?: "low" | "medium" | "high";
  };
}
interface ResponsesAPIInputItem {
  type?: "message" | "item_reference" | "function_call" | "function_call_output";
  role?: "user" | "assistant" | "system" | "developer";
  content?: string | ResponsesAPIContentPart[];
  id?: string;
  call_id?: string;
  name?: string;
  arguments?: string;
  output?: string;
}
interface ResponsesAPIContentPart {
  type: "input_text" | "input_image" | "input_file";
  text?: string;
  image_url?: string;
  file_id?: string;
}
interface ResponsesAPITool {
  type: "function" | "web_search" | "file_search" | "computer_use";
  function?: {
    name: string;
    description?: string;
    parameters?: Record<string, unknown>;
  };
  name?: string;
  description?: string;
  parameters?: Record<string, unknown>;
}
/**
* OpenAI Responses API response format
*/
interface ResponsesAPIResponse {
  id: string;
  object: "response";
  created_at: number;
  model: string;
  output: ResponsesAPIOutputItem[];
  usage?: {
    input_tokens: number;
    output_tokens: number;
    total_tokens: number;
  };
  status: "completed" | "failed" | "in_progress" | "incomplete";
  error?: {
    code: string;
    message: string;
  };
}
interface ResponsesAPIOutputItem {
  id?: string;
  type: "message";
  status?: "completed" | "in_progress";
  role: "assistant";
  content: ResponsesAPIOutputContent[];
}
interface ResponsesAPIOutputContent {
  type: "output_text" | "input_text";
  text: string;
}
/**
* Check if request is in OpenAI Responses API format
*/
declare function isResponsesAPIRequest(body: unknown): boolean;
/**
* Convert OpenAI Responses API request to OpenAI Chat Completions format
*/
declare function responsesAPIToOpenAIRequest(req: ResponsesAPIRequest): OpenAIRequest;
/**
* Convert OpenAI Chat Completions response to Responses API format
*/
declare function openAIToResponsesAPIResponse(openAIRes: unknown, originalModel: string): ResponsesAPIResponse;
/**
* Create stream transformer for Responses API format
* Converts OpenAI SSE stream to Responses API SSE stream
*/
declare function createResponsesAPIStreamTransformer(originalModel: string): TransformStream<Uint8Array, Uint8Array>;
//#endregion
export { anthropicToOpenAIRequest, createResponsesAPIStreamTransformer, createStreamTransformer, isAnthropicRequest, isOpenAIResponse, isResponsesAPIRequest, openAIToAnthropicResponse, openAIToResponsesAPIResponse, responsesAPIToOpenAIRequest };