llm-simple-router 0.8.2 → 0.9.4

package/dist/proxy/transform/stream-resp2ant.d.ts

@@ -0,0 +1,21 @@
+import { BaseSSETransform } from "./stream-transform-base.js";
+export declare class ResponsesToAnthropicTransform extends BaseSSETransform {
+    private hasSentMessageStart;
+    private blockIndex;
+    private msgId;
+    private inputTokens;
+    private outputTokens;
+    private currentOutputIndex;
+    private hasSentMessageStop;
+    private hasFunctionCall;
+    private activeItems;
+    private ensureMessageStart;
+    protected processEvent(event: {
+        event?: string;
+        data?: string;
+    }): void;
+    private emitStopSequence;
+    private resolveStopReason;
+    protected flushPendingData(): void;
+    protected ensureTerminated(): void;
+}

package/dist/proxy/transform/stream-resp2ant.js

@@ -0,0 +1,238 @@
+import { BaseSSETransform } from "./stream-transform-base.js";
+import { generateMsgId } from "./id-utils.js";
+export class ResponsesToAnthropicTransform extends BaseSSETransform {
+    hasSentMessageStart = false;
+    blockIndex = 0;
+    msgId = generateMsgId();
+    inputTokens = 0;
+    outputTokens = 0;
+    currentOutputIndex = -1;
+    hasSentMessageStop = false;
+    hasFunctionCall = false;
+    // Track current items by output_index
+    activeItems = new Map();
+    ensureMessageStart() {
+        if (this.hasSentMessageStart)
+            return;
+        this.hasSentMessageStart = true;
+        this.pushAnthropicSSE("message_start", {
+            type: "message_start",
+            message: {
+                id: this.msgId,
+                type: "message",
+                role: "assistant",
+                content: [],
+                model: this.model,
+                status: "in_progress",
+                usage: { input_tokens: this.inputTokens },
+            },
+        });
+    }
+    processEvent(event) {
+        const eventType = event.event;
+        let payload;
+        try {
+            payload = JSON.parse(event.data);
+        }
+        catch (err) {
+            this.emit("warning", err);
+            return;
+        }
+        switch (eventType) {
+            case "response.created":
+            case "response.in_progress":
+            case "response.queued": {
+                // Extract usage from response object if present
+                const resp = payload.response;
+                if (resp?.usage) {
+                    const usage = resp.usage;
+                    this.inputTokens = usage.input_tokens ?? this.inputTokens;
+                }
+                break;
+            }
+            case "response.output_item.added": {
+                this.ensureMessageStart();
+                const item = payload.item;
+                const outputIdx = payload.output_index ?? this.blockIndex;
+                this.currentOutputIndex = outputIdx;
+                const itemType = item?.type;
+                const tracked = {
+                    type: itemType,
+                    id: item?.id ?? "",
+                    name: item?.name,
+                    callId: item?.call_id ?? undefined,
+                    outputIndex: outputIdx,
+                };
+                this.activeItems.set(outputIdx, tracked);
+                if (itemType === "message") {
+                    // Don't start content block yet — wait for content_part.added
+                }
+                else if (itemType === "function_call") {
+                    this.hasFunctionCall = true;
+                    const rawCallId = tracked.callId ?? tracked.id;
+                    // Anthropic requires "toolu_" prefix on tool_use IDs
+                    const toolId = rawCallId.startsWith("toolu_") ? rawCallId : `toolu_${rawCallId}`;
+                    const toolName = tracked.name ?? "";
+                    this.pushAnthropicSSE("content_block_start", {
+                        type: "content_block_start",
+                        index: this.blockIndex,
+                        content_block: { type: "tool_use", id: toolId, name: toolName, input: {} },
+                    });
+                }
+                else if (itemType === "reasoning") {
+                    this.pushAnthropicSSE("content_block_start", {
+                        type: "content_block_start",
+                        index: this.blockIndex,
+                        content_block: { type: "thinking", thinking: "" },
+                    });
+                }
+                break;
+            }
+            case "response.content_part.added": {
+                this.ensureMessageStart();
+                const part = payload.part;
+                const partType = part?.type;
+                if (partType === "output_text") {
+                    this.pushAnthropicSSE("content_block_start", {
+                        type: "content_block_start",
+                        index: this.blockIndex,
+                        content_block: { type: "text", text: "" },
+                    });
+                }
+                break;
+            }
+            case "response.output_text.delta": {
+                const delta = payload.delta;
+                if (delta) {
+                    this.pushAnthropicSSE("content_block_delta", {
+                        type: "content_block_delta",
+                        index: this.blockIndex,
+                        delta: { type: "text_delta", text: delta },
+                    });
+                }
+                break;
+            }
+            case "response.output_text.done":
+            case "response.content_part.done": {
+                // Nothing to emit — wait for output_item.done to send content_block_stop
+                break;
+            }
+            case "response.reasoning_summary_text.delta": {
+                const delta = payload.delta;
+                if (delta) {
+                    this.pushAnthropicSSE("content_block_delta", {
+                        type: "content_block_delta",
+                        index: this.blockIndex,
+                        delta: { type: "thinking_delta", thinking: delta },
+                    });
+                }
+                break;
+            }
+            case "response.reasoning_summary_part.added":
+            case "response.reasoning_summary_text.done":
+            case "response.reasoning_summary_part.done": {
+                // Sub-events of reasoning — no Anthropic equivalent, handled at output_item.done
+                break;
+            }
+            case "response.function_call_arguments.delta": {
+                const delta = payload.delta;
+                if (delta) {
+                    this.pushAnthropicSSE("content_block_delta", {
+                        type: "content_block_delta",
+                        index: this.blockIndex,
+                        delta: { type: "input_json_delta", partial_json: delta },
+                    });
+                }
+                break;
+            }
+            case "response.function_call_arguments.done": {
+                // Nothing — wait for output_item.done
+                break;
+            }
+            case "response.output_item.done": {
+                const outputIdx = payload.output_index ?? this.currentOutputIndex;
+                // content_block_stop — same for all item types (index-only)
+                this.pushAnthropicSSE("content_block_stop", {
+                    type: "content_block_stop",
+                    index: this.blockIndex,
+                });
+                this.activeItems.delete(outputIdx);
+                this.blockIndex++;
+                break;
+            }
+            case "response.completed": {
+                const resp = payload.response;
+                if (resp?.usage) {
+                    const usage = resp.usage;
+                    this.inputTokens = usage.input_tokens ?? this.inputTokens;
+                    this.outputTokens = usage.output_tokens ?? this.outputTokens;
+                }
+                this.emitStopSequence(resp?.status);
+                break;
+            }
+            case "response.incomplete": {
+                const resp = payload.response;
+                if (resp?.usage) {
+                    const usage = resp.usage;
+                    this.outputTokens = usage.output_tokens ?? this.outputTokens;
+                }
+                this.emitStopSequence("incomplete");
+                break;
+            }
+            case "response.failed": {
+                const resp = payload.response;
+                const err = resp?.error;
+                this.pushAnthropicSSE("error", {
+                    type: "error",
+                    error: {
+                        type: "api_error",
+                        message: err?.message ?? "Upstream error",
+                    },
+                });
+                break;
+            }
+            case "error": {
+                this.pushAnthropicSSE("error", {
+                    type: "error",
+                    error: {
+                        type: "api_error",
+                        message: payload.message ?? "Stream error",
+                    },
+                });
+                break;
+            }
+            default: {
+                this.emit("warning", { event: "unknown_sse_event", eventType });
+                break;
+            }
+        }
+    }
+    emitStopSequence(status) {
+        if (this.hasSentMessageStop)
+            return;
+        const stopReason = this.resolveStopReason(status);
+        this.pushAnthropicSSE("message_delta", {
+            type: "message_delta",
+            delta: { stop_reason: stopReason, stop_sequence: null },
+            usage: { output_tokens: this.outputTokens },
+        });
+        this.pushAnthropicSSE("message_stop", { type: "message_stop" });
+        this.hasSentMessageStop = true;
+    }
+    resolveStopReason(status) {
+        if (status === "incomplete")
+            return "max_tokens";
+        if (this.hasFunctionCall)
+            return "tool_use";
+        return "end_turn";
+    }
+    flushPendingData() {
+        // No buffered data
+    }
+    ensureTerminated() {
+        if (!this.hasSentMessageStop) {
+            this.ensureMessageStart();
+            this.emitStopSequence("completed");
+        }
+    }
+}

package/dist/proxy/transform/stream-transform-base.d.ts

@@ -15,5 +15,6 @@ export declare abstract class BaseSSETransform extends Transform {
     protected abstract ensureTerminated(): void;
     protected pushAnthropicSSE(eventType: string, data: unknown): void;
     protected pushOpenAISSE(data: unknown): void;
+    protected pushResponsesSSE(eventType: string, data: unknown): void;
     protected pushDone(): void;
 }

package/dist/proxy/transform/stream-transform-base.js

@@ -54,6 +54,9 @@ export class BaseSSETransform extends Transform {
     pushOpenAISSE(data) {
         this.push(`data: ${JSON.stringify(data)}\n\n`);
     }
+    pushResponsesSSE(eventType, data) {
+        this.push(`event: ${eventType}\ndata: ${JSON.stringify(data)}\n\n`);
+    }
     pushDone() {
         this.push("data: [DONE]\n\n");
         this.done = true;

package/dist/proxy/transform/transform-coordinator.d.ts

@@ -8,4 +8,5 @@ export declare class TransformCoordinator {
     transformResponse(bodyStr: string, sourceApiType: string, targetApiType: string): string;
     transformErrorResponse(bodyStr: string, sourceApiType: string, targetApiType: string): string;
     createFormatTransform(entryApiType: string, providerApiType: string, model: string): Transform | undefined;
+    private getUpstreamPath;
 }

package/dist/proxy/transform/transform-coordinator.js

@@ -1,32 +1,151 @@
 import { transformRequestBody } from "./request-transform.js";
-import { transformResponseBody, transformErrorResponse } from "./response-transform.js";
+import { transformResponseBody, transformErrorResponse as transformErrorBody, } from "./response-transform.js";
 import { OpenAIToAnthropicTransform } from "./stream-oa2ant.js";
 import { AnthropicToOpenAITransform } from "./stream-ant2oa.js";
+import { responsesToAnthropicRequest, anthropicToResponsesRequest, } from "./request-transform-responses.js";
+import { responsesToAnthropicResponse, anthropicToResponsesResponse, } from "./response-transform-responses.js";
+import { responsesToChatRequest, chatToResponsesRequest, } from "./request-bridge-responses.js";
+import { responsesToChatResponse, chatToResponsesResponse, } from "./response-bridge-responses.js";
+import { AnthropicToResponsesTransform } from "./stream-ant2resp.js";
+import { ResponsesToAnthropicTransform } from "./stream-resp2ant.js";
+import { ChatToResponsesBridgeTransform } from "./stream-bridge-chat2resp.js";
+import { ResponsesToChatBridgeTransform } from "./stream-bridge-resp2chat.js";
 export class TransformCoordinator {
     needsTransform(entryApiType, providerApiType) {
         return entryApiType !== providerApiType;
     }
     transformRequest(body, entryApiType, providerApiType, model) {
-        const upstreamPath = providerApiType === "openai" ? "/v1/chat/completions" : "/v1/messages";
-        return { body: transformRequestBody(body, entryApiType, providerApiType, model), upstreamPath };
+        if (entryApiType === providerApiType) {
+            return { body, upstreamPath: this.getUpstreamPath(providerApiType) };
+        }
+        // Tier-1: Responses ↔ Anthropic
+        if (entryApiType === "openai-responses" && providerApiType === "anthropic") {
+            return { body: responsesToAnthropicRequest(body), upstreamPath: "/v1/messages" };
+        }
+        if (entryApiType === "anthropic" && providerApiType === "openai-responses") {
+            return { body: anthropicToResponsesRequest(body), upstreamPath: "/v1/responses" };
+        }
+        // Existing: OpenAI Chat ↔ Anthropic
+        if (entryApiType === "openai" && providerApiType === "anthropic") {
+            return { body: transformRequestBody(body, "openai", "anthropic", model), upstreamPath: "/v1/messages" };
+        }
+        if (entryApiType === "anthropic" && providerApiType === "openai") {
+            return { body: transformRequestBody(body, "anthropic", "openai", model), upstreamPath: "/v1/chat/completions" };
+        }
+        // Bridge: Responses ↔ Chat
+        if (entryApiType === "openai-responses" && providerApiType === "openai") {
+            return { body: responsesToChatRequest(body), upstreamPath: "/v1/chat/completions" };
+        }
+        if (entryApiType === "openai" && providerApiType === "openai-responses") {
+            return { body: chatToResponsesRequest(body), upstreamPath: "/v1/responses" };
+        }
+        return { body, upstreamPath: this.getUpstreamPath(providerApiType) };
     }
     transformResponse(bodyStr, sourceApiType, targetApiType) {
-        return transformResponseBody(bodyStr, sourceApiType, targetApiType);
+        if (sourceApiType === targetApiType)
+            return bodyStr;
+        // Tier-1
+        if (sourceApiType === "openai-responses" && targetApiType === "anthropic") {
+            return responsesToAnthropicResponse(bodyStr);
+        }
+        if (sourceApiType === "anthropic" && targetApiType === "openai-responses") {
+            return anthropicToResponsesResponse(bodyStr);
+        }
+        // Existing
+        if (sourceApiType === "openai" && targetApiType === "anthropic") {
+            return transformResponseBody(bodyStr, "openai", "anthropic");
+        }
+        if (sourceApiType === "anthropic" && targetApiType === "openai") {
+            return transformResponseBody(bodyStr, "anthropic", "openai");
+        }
+        // Bridge
+        if (sourceApiType === "openai-responses" && targetApiType === "openai") {
+            return responsesToChatResponse(bodyStr);
+        }
+        if (sourceApiType === "openai" && targetApiType === "openai-responses") {
+            return chatToResponsesResponse(bodyStr);
+        }
+        return bodyStr;
     }
     transformErrorResponse(bodyStr, sourceApiType, targetApiType) {
-        return transformErrorResponse(bodyStr, sourceApiType, targetApiType);
+        if (sourceApiType === targetApiType)
+            return bodyStr;
+        try {
+            const parsed = JSON.parse(bodyStr);
+            // Responses ↔ Anthropic error conversion
+            if (sourceApiType === "openai-responses" && targetApiType === "anthropic") {
+                const err = parsed.error ?? parsed;
+                return JSON.stringify({
+                    type: "error",
+                    error: { type: "api_error", message: err.message ?? String(err) },
+                });
+            }
+            if (sourceApiType === "anthropic" && targetApiType === "openai-responses") {
+                const err = parsed.error ?? parsed;
+                return JSON.stringify({
+                    error: {
+                        message: err.message ?? String(err),
+                        type: "invalid_request_error",
+                        code: "upstream_error",
+                    },
+                });
+            }
+            // Responses ↔ Chat error conversion
+            if (sourceApiType === "openai-responses" && targetApiType === "openai") {
+                const err = parsed.error ?? parsed;
+                return JSON.stringify({
+                    error: { message: err.message ?? String(err), type: "api_error", code: "upstream_error" },
+                });
+            }
+            if (sourceApiType === "openai" && targetApiType === "openai-responses") {
+                const err = parsed.error ?? parsed;
+                return JSON.stringify({
+                    error: {
+                        message: err.message ?? String(err),
+                        type: "invalid_request_error",
+                        code: "upstream_error",
+                    },
+                });
+            }
+            // Fall through to existing Chat ↔ Anthropic error conversion
+            return transformErrorBody(bodyStr, sourceApiType, targetApiType);
+        }
+        catch {
+            return bodyStr;
+        }
     }
     createFormatTransform(entryApiType, providerApiType, model) {
-        if (!this.needsTransform(entryApiType, providerApiType))
+        if (entryApiType === providerApiType)
             return undefined;
-        // 上游=provider格式, 客户端=entry格式
-        // OA provider + Ant client → OpenAIToAnthropicTransform
+        // Tier-1 streaming
+        if (providerApiType === "anthropic" && entryApiType === "openai-responses") {
+            return new ResponsesToAnthropicTransform(model);
+        }
+        if (providerApiType === "openai-responses" && entryApiType === "anthropic") {
+            return new AnthropicToResponsesTransform(model);
+        }
+        // Existing streaming
         if (providerApiType === "openai" && entryApiType === "anthropic") {
             return new OpenAIToAnthropicTransform(model);
         }
         if (providerApiType === "anthropic" && entryApiType === "openai") {
             return new AnthropicToOpenAITransform(model);
         }
+        // Bridge streaming
+        if (providerApiType === "openai" && entryApiType === "openai-responses") {
+            return new ResponsesToChatBridgeTransform(model);
+        }
+        if (providerApiType === "openai-responses" && entryApiType === "openai") {
+            return new ChatToResponsesBridgeTransform(model);
+        }
         return undefined;
     }
+    getUpstreamPath(apiType) {
+        switch (apiType) {
+            case "openai": return "/v1/chat/completions";
+            case "openai-responses": return "/v1/responses";
+            case "anthropic": return "/v1/messages";
+            default: return "/v1/chat/completions";
+        }
+    }
 }

package/dist/proxy/transform/types-responses.d.ts

@@ -0,0 +1,177 @@
+export interface ResponseInputMessage {
+    type: "message";
+    role: "user" | "assistant" | "system" | "developer";
+    content: string | ResponseInputContentPart[];
+}
+export interface ResponseInputText {
+    type: "input_text";
+    text: string;
+}
+export interface ResponseInputImage {
+    type: "input_image";
+    image_url: string;
+    detail?: "auto" | "low" | "high";
+}
+export interface ResponseFunctionCallInput {
+    type: "function_call";
+    id: string;
+    call_id: string;
+    name: string;
+    arguments: string;
+}
+export interface ResponseFunctionCallOutputInput {
+    type: "function_call_output";
+    call_id: string;
+    output: string;
+}
+export interface ResponseReasoningInput {
+    type: "reasoning";
+    id: string;
+    summary: Array<{
+        type: "summary_text";
+        text: string;
+    }>;
+    encrypted_content?: string;
+}
+export type ResponseInputItem = ResponseInputMessage | ResponseInputText | ResponseInputImage | ResponseFunctionCallInput | ResponseFunctionCallOutputInput | ResponseReasoningInput;
+export interface ResponseInputContentPart {
+    type: "input_text" | "input_image" | "input_file";
+    text?: string;
+    image_url?: string;
+    file_url?: string;
+    file_data?: string;
+    filename?: string;
+}
+export interface ResponseFunctionTool {
+    type: "function";
+    name: string;
+    description?: string;
+    parameters?: Record<string, unknown>;
+    strict?: boolean;
+}
+export interface ResponseWebSearchTool {
+    type: "web_search_preview";
+    search_context_size?: "low" | "medium" | "high";
+    user_location?: {
+        type: "approximate";
+        city?: string;
+        country?: string;
+    };
+}
+export interface ResponseFileSearchTool {
+    type: "file_search";
+    vector_store_ids?: string[];
+}
+export type ResponseTool = ResponseFunctionTool | ResponseWebSearchTool | ResponseFileSearchTool | Record<string, unknown>;
+export interface ResponseOutputMessage {
+    type: "message";
+    id: string;
+    role: "assistant";
+    content: ResponseOutputContent[];
+    status?: string;
+}
+export interface ResponseOutputContent {
+    type: "output_text";
+    text: string;
+    annotations?: unknown[];
+}
+export interface ResponseFunctionCallOutput {
+    type: "function_call";
+    id: string;
+    call_id: string;
+    name: string;
+    arguments: string;
+    status?: string;
+}
+export interface ResponseReasoningOutput {
+    type: "reasoning";
+    id: string;
+    summary: Array<{
+        type: "summary_text";
+        text: string;
+    }>;
+    encrypted_content?: string;
+}
+export type ResponseOutputItem = ResponseOutputMessage | ResponseFunctionCallOutput | ResponseReasoningOutput | Record<string, unknown>;
+export interface ResponsesApiRequest {
+    model: string;
+    input: string | ResponseInputItem[];
+    instructions?: string;
+    max_output_tokens?: number;
+    temperature?: number;
+    top_p?: number;
+    tools?: ResponseTool[];
+    tool_choice?: "auto" | "none" | "required" | {
+        type: "function";
+        name: string;
+    };
+    stream?: boolean;
+    stream_options?: {
+        include_usage?: boolean;
+    };
+    reasoning?: {
+        effort?: "low" | "medium" | "high";
+        max_tokens?: number;
+        summary?: "auto" | "concise" | "detailed";
+    };
+    previous_response_id?: string;
+    metadata?: Record<string, string>;
+    text?: {
+        format: {
+            type: "json_schema";
+            json_schema: unknown;
+        };
+    };
+    parallel_tool_calls?: boolean;
+    store?: boolean;
+}
+export interface ResponsesApiResponse {
+    id: string;
+    object: "response";
+    model: string;
+    status: "completed" | "failed" | "in_progress" | "incomplete";
+    output: ResponseOutputItem[];
+    usage?: ResponsesApiUsage;
+    error?: {
+        code: string;
+        message: string;
+    };
+    created_at?: number;
+    completed_at?: number;
+}
+export interface ResponsesApiUsage {
+    input_tokens: number;
+    output_tokens: number;
+    total_tokens: number;
+    input_tokens_details?: {
+        cached_tokens: number;
+    };
+    output_tokens_details?: {
+        reasoning_tokens: number;
+    };
+}
+export declare const RESPONSES_SSE_EVENTS: {
+    readonly CREATED: "response.created";
+    readonly IN_PROGRESS: "response.in_progress";
+    readonly QUEUED: "response.queued";
+    readonly OUTPUT_ITEM_ADDED: "response.output_item.added";
+    readonly OUTPUT_ITEM_DONE: "response.output_item.done";
+    readonly CONTENT_PART_ADDED: "response.content_part.added";
+    readonly CONTENT_PART_DONE: "response.content_part.done";
+    readonly OUTPUT_TEXT_DELTA: "response.output_text.delta";
+    readonly OUTPUT_TEXT_DONE: "response.output_text.done";
+    readonly REFUSAL_DELTA: "response.refusal.delta";
+    readonly REFUSAL_DONE: "response.refusal.done";
+    readonly FUNCTION_CALL_ARGUMENTS_DELTA: "response.function_call_arguments.delta";
+    readonly FUNCTION_CALL_ARGUMENTS_DONE: "response.function_call_arguments.done";
+    readonly REASONING_SUMMARY_PART_ADDED: "response.reasoning_summary_part.added";
+    readonly REASONING_SUMMARY_PART_DONE: "response.reasoning_summary_part.done";
+    readonly REASONING_SUMMARY_TEXT_DELTA: "response.reasoning_summary_text.delta";
+    readonly REASONING_SUMMARY_TEXT_DONE: "response.reasoning_summary_text.done";
+    readonly REASONING_TEXT_DELTA: "response.reasoning_text.delta";
+    readonly REASONING_TEXT_DONE: "response.reasoning_text.done";
+    readonly COMPLETED: "response.completed";
+    readonly FAILED: "response.failed";
+    readonly INCOMPLETE: "response.incomplete";
+    readonly ERROR: "error";
+};

package/dist/proxy/transform/types-responses.js

@@ -0,0 +1,27 @@
+// ---------- Responses API 输入 item 类型 ----------
+// ---------- Responses SSE 流式事件类型常量 ----------
+export const RESPONSES_SSE_EVENTS = {
+    CREATED: "response.created",
+    IN_PROGRESS: "response.in_progress",
+    QUEUED: "response.queued",
+    OUTPUT_ITEM_ADDED: "response.output_item.added",
+    OUTPUT_ITEM_DONE: "response.output_item.done",
+    CONTENT_PART_ADDED: "response.content_part.added",
+    CONTENT_PART_DONE: "response.content_part.done",
+    OUTPUT_TEXT_DELTA: "response.output_text.delta",
+    OUTPUT_TEXT_DONE: "response.output_text.done",
+    REFUSAL_DELTA: "response.refusal.delta",
+    REFUSAL_DONE: "response.refusal.done",
+    FUNCTION_CALL_ARGUMENTS_DELTA: "response.function_call_arguments.delta",
+    FUNCTION_CALL_ARGUMENTS_DONE: "response.function_call_arguments.done",
+    REASONING_SUMMARY_PART_ADDED: "response.reasoning_summary_part.added",
+    REASONING_SUMMARY_PART_DONE: "response.reasoning_summary_part.done",
+    REASONING_SUMMARY_TEXT_DELTA: "response.reasoning_summary_text.delta",
+    REASONING_SUMMARY_TEXT_DONE: "response.reasoning_summary_text.done",
+    REASONING_TEXT_DELTA: "response.reasoning_text.delta",
+    REASONING_TEXT_DONE: "response.reasoning_text.done",
+    COMPLETED: "response.completed",
+    FAILED: "response.failed",
+    INCOMPLETE: "response.incomplete",
+    ERROR: "error",
+};

package/dist/proxy/transform/types.d.ts

@@ -1,5 +1,7 @@
 /** 格式转换方向 */
-export type TransformDirection = "openai-to-anthropic" | "anthropic-to-openai";
+export type TransformDirection = "openai-to-anthropic" | "anthropic-to-openai" | "openai-responses-to-anthropic" | "anthropic-to-openai-responses" | "openai-to-openai-responses" | "openai-responses-to-openai";
+/** 所有支持的 API 格式类型 */
+export type ApiType = "openai" | "openai-responses" | "anthropic";
 export interface AnthropicTextBlock {
     type: "text";
     text: string;

package/dist/proxy/transport/transport-fn.d.ts

@@ -11,7 +11,7 @@ export interface TransportFnParams {
     cliHdrs: RawHeaders;
     reply: FastifyReply;
     upstreamPath: string;
-    apiType: "openai" | "anthropic";
+    apiType: "openai" | "openai-responses" | "anthropic";
     isStream: boolean;
     startTime: number;
     logId: string;

package/frontend-dist/assets/CardContent-BhMXx-JD.js

@@ -0,0 +1 @@
+import{Bt as e,Q as t,Rt as n,Y as r,pt as i,r as a,ut as o}from"./button-D27ClX8J.js";var s=[`data-size`],c=t({__name:`Card`,props:{class:{type:[Boolean,null,String,Object,Array]},size:{default:`default`}},setup(t){let c=t;return(l,u)=>(o(),r(`div`,{"data-slot":`card`,"data-size":t.size,class:e(n(a)(`ring-foreground/10 bg-card text-card-foreground gap-4 overflow-hidden rounded-lg py-4 text-sm ring-1 has-data-[slot=card-footer]:pb-0 has-[>img:first-child]:pt-0 data-[size=sm]:gap-3 data-[size=sm]:py-3 data-[size=sm]:has-data-[slot=card-footer]:pb-0 *:[img:first-child]:rounded-t-lg *:[img:last-child]:rounded-b-lg group/card flex flex-col`,c.class))},[i(l.$slots,`default`)],10,s))}}),l=t({__name:`CardContent`,props:{class:{type:[Boolean,null,String,Object,Array]}},setup(t){let s=t;return(t,c)=>(o(),r(`div`,{"data-slot":`card-content`,class:e(n(a)(`px-4 group-data-[size=sm]/card:px-3`,s.class))},[i(t.$slots,`default`)],2))}});export{c as n,l as t};