1. Responses API 是什么？

Responses API 是 OpenAI 在 2024 年推出的统一接口，目标是：

统一所有模型调用方式（文本、图像、音频、多模态）
简化输入格式（只需 input）
统一输出格式（output 字段）
支持结构化输出、工具调用、多模态输入

它是未来 OpenAI API 的核心接口。

2. Responses API 与旧接口的核心区别

2.1 输入格式对比

接口	输入字段	输入结构	是否支持多模态
/v1/completions	prompt	字符串	否
/v1/chat/completions	messages	数组 + role	否
/v1/responses	input	字符串 / 数组 / 图像 / 音频	✔ 支持

2.2 输出格式对比

接口	输出字段	内容
/v1/completions	text	文本续写
/v1/chat/completions	message	对话消息
/v1/responses	output	统一输出（文本/图像/结构化）

2.3 功能对比

功能	completions	chat/completions	responses
文本生成	✔	✔	✔
多轮对话	✖	✔	✔
工具调用	✖	✔	✔（更强）
多模态输入	✖	✖	✔
结构化输出	✖	✖	✔

3. 为什么 LiteLLM 不支持 Responses API？

LiteLLM 的目标是：

兼容 OpenAI 旧接口（completions / chat / embeddings）
统一调用第三方模型（如 DeepSeek、Qwen、Llama）

Responses API 太新、太复杂，包含：

多模态输入
工具调用增强
结构化输出
多类型 output

因此 LiteLLM 目前（2026）尚未完全支持。

4. 如何实现 Responses API → Chat Completions 的兼容层？

由于 Responses API 的输入格式更简单（input），可以将其转换为 Chat Completions 的 messages。

4.1 输入映射

Responses API	Chat Completions
`input: "hello"`	`messages: [{"role": "user", "content": "hello"}]`

4.2 输出映射

Chat Completions	Responses API
`choices[0].message.content`	`output`

5. 兼容层逻辑流程

5.1 请求流程

客户端发送：
```
{
 "model": "xxx",
 "input": "hello"
}
```

兼容层转换为：

{
 "model": "xxx",
 "messages": [
   {"role": "user", "content": "hello"}
 ]
}

转发到 LiteLLM /v1/chat/completions

5.2 响应流程

LiteLLM 返回：

{
 "choices": [
   {"message": {"content": "你好"}}
 ]
}

兼容层转换为：
```
{
 "output": "你好"
}
```

6. 兼容层应支持的扩展能力

6.1 流式输出（Streaming）

将 Chat Completions 的 SSE 流转换为 Responses API 的 SSE 流

6.2 工具调用（Tools）

将 Responses API 的工具调用格式映射到 Chat Completions 的 function_call

6.3 多模态输入（可选）

若未来需要，可扩展 input 数组解析

7. 兼容层适用场景

使用 Codex CLI 调用 LiteLLM
使用 OpenAI SDK（2024+） 调用 LiteLLM
使用 Responses API 的第三方应用 调用 LiteLLM
想让内部网关兼容未来 OpenAI API

8. 总结

Responses API 是未来趋势，但目前许多代理层（如 LiteLLM）尚未支持。通过构建一个轻量级兼容层，可以：

保持与 OpenAI 新接口一致
无缝兼容旧模型和第三方模型
让 Codex CLI、OpenAI SDK 等工具正常工作

兼容层的核心是：

input → messages
choices → output

未来如需加入流式输出、多模态支持，也可以在此基础上扩展。

9. 生产环境实用示例：FastAPI 兼容层代码

Gemini 提供了一个实用的 FastAPI 兼容层示例，解决了在生产环境中常见的两个关键问题：

Header 透传（尤其是 Authorization）

客户端请求会带上 Authorization: Bearer sk-xxx，如果兼容层不把这个头部转发给后端 LiteLLM，会导致后端拒绝请求（401 Unauthorized）。这是实现安全认证链路的关键。
流式响应支持

新版 OpenAI SDK 和很多客户端默认使用流式（streaming）输出，兼容层需要支持 SSE 格式的流式转发，否则流式请求会失败或报错。

以下是 Gemini 推荐的完整示例代码，包含 Header 透传和流式支持：

import httpx
import json
from fastapi import FastAPI, HTTPException, Request
from fastapi.responses import StreamingResponse
from pydantic import BaseModel
from typing import Union, List, Any

app = FastAPI(title="OpenAI Responses API 真正可用适配器")

class ResponsesRequest(BaseModel):
    model: str
    input: Union[str, List[Any]]
    stream: bool = False

LITELLM_URL = "http://localhost:4000/v1/chat/completions"

# 专门处理流式响应的生成器
async def stream_processor(upstream_response):
    async for line in upstream_response.aiter_lines():
        if not line:
            continue

        # 处理 OpenAI 规范的 SSE 结束标志
        if line == "data: [DONE]":
            yield "data: [DONE]

"
            break

        if line.startswith("data: "):
            try:
                # 移除 "data: " 前缀并解析 JSON
                raw_json = line[6:]
                data = json.loads(raw_json)

                # 提取 Chat API 的 delta 内容
                choices = data.get("choices", [])
                if choices:
                    delta_content = choices[0].get("delta", {}).get("content", "")

                    # 重新组装成 Responses API 的扁平格式
                    response_payload = {"output": delta_content}
                    yield f"data: {json.dumps(response_payload, ensure_ascii=False)}

"
            except Exception:
                # 忽略解析失败的异常行，保证流不中断
                continue

@app.post("/v1/responses")
async def handle_responses_api(payload: ResponsesRequest, request: Request):
    # 1. 核心关键：提取客户端带来的 Authorization 头部（API Key）
    auth_header = request.headers.get("Authorization")
    headers = {"Content-Type": "application/json"}
    if auth_header:
        headers["Authorization"] = auth_header

    # 2. 输入格式转换
    if isinstance(payload.input, str):
        messages = [{"role": "user", "content": payload.input}]
    else:
        messages = payload.input 

    chat_payload = {
        "model": payload.model,
        "messages": messages,
        "stream": payload.stream
    }

    # 3. 发送请求
    client = httpx.AsyncClient()
    try:
        if payload.stream:
            # ---- 流式处理分支 ----
            # 使用 contextmanager 保持连接
            req = client.build_request("POST", LITELLM_URL, json=chat_payload, headers=headers, timeout=60.0)
            upstream_res = await client.send(req, stream=True)

            if upstream_res.status_code != 200:
                await upstream_res.aread() # 释放连接
                raise HTTPException(status_code=upstream_res.status_code, detail="上游流式请求失败")

            return StreamingResponse(
                stream_processor(upstream_res), 
                media_type="text/event-stream"
            )
        else:
            # ---- 非流式处理分支 ----
            response = await client.post(LITELLM_URL, json=chat_payload, headers=headers, timeout=60.0)
            if response.status_code != 200:
                raise HTTPException(status_code=response.status_code, detail=response.text)

            upstream_data = response.json()
            content = upstream_data["choices"][0]["message"]["content"]
            return {
                "output": content,
                "usage": upstream_data.get("usage", {})
            }

    except httpx.RequestError as exc:
        raise HTTPException(status_code=500, detail=f"上游网关连接失败: {exc}")

如何本地快速测试？

启动你的 LiteLLM（假设在 localhost:4000）。
启动这个 FastAPI 兼容层（假设运行在 localhost:8000）。
使用 curl 模拟新版 Responses API 请求测试：

curl http://localhost:8000/v1/responses 
  -H "Authorization: Bearer your-litellm-key" 
  -H "Content-Type: application/json" 
  -d '{
    "model": "gpt-4o",
    "input": "什么是 Responses API？",
    "stream": false
  }'

你将成功拿到纯净的响应：

{
  "output": "Responses API 是 OpenAI 统一模型调用的新接口...",
  "usage": { "prompt_tokens": 15, "completion_tokens": 30, "total_tokens": 45 }
}

加上 Header 透传和流式处理后，这个方案就已经具备了生产环境环境下的初步可用性。你可以放心地基于这个架构去魔改和扩展了！

Responses API