OpenAI API：Responses API 与结构化输出规范及实现指南

import OpenAI from "openai";

const client = new OpenAI();

const response = await client.responses.create({
  model: "gpt-4o",
  input: "告诉我东京的天气。",
});

console.log(response.output_text); // 使用 output_text 助手直接获取文本

response.output[0].content[0].text

// 两者结果相同
console.log(response.output_text);
console.log(response.output[0].content[0].text);

for (const item of response.output) {
  if (item.type === "message") {
    for (const block of item.content) {
      if (block.type === "output_text") {
        console.log(block.text);
      }
    }
  }
}

const response = await client.responses.create({
  model: "gpt-4o",
  input: [
    {
      role: "system",
      content: "你是一个有帮助的助手。请简洁地回答。",
    },
    {
      role: "user",
      content: "告诉我 JavaScript 数组方法。",
    },
  ],
});

{
  "id": "resp_68af4030...",
  "object": "response",
  "created_at": 1756315696,
  "model": "gpt-4o",
  "output": [
    {
      "id": "msg_68af4033...",
      "type": "message",
      "status": "completed",
      "role": "assistant",
      "content": [
        {
          "type": "output_text",
          "text": "东京天气晴朗。"
        }
      ]
    }
  ],
  "usage": {
    "input_tokens": 15,
    "output_tokens": 12,
    "total_tokens": 27
  }
}

const history = [
  { role: "system", content: "你是一个有帮助的助手。" },
  { role: "user", content: "告诉我东京的天气。" },
  { role: "assistant", content: "东京今天天气晴朗。" },
];

const response = await client.responses.create({
  model: "gpt-4o",
  input: [...history, { role: "user", content: "明天呢？" }],
});

// 第一轮
const response1 = await client.responses.create({
  model: "gpt-4o",
  input: "告诉我东京的天气。",
});

// 第二轮：仅使用 previous_response_id 继承上下文
const response2 = await client.responses.create({
  model: "gpt-4o",
  input: "明天呢？",
  previous_response_id: response1.id,
});

const response = await client.responses.create({
  model: "gpt-4o",
  input: "搜索最新的 OpenAI 新闻并进行总结。",
  tools: [
    { type: "web_search_preview" },
    { type: "file_search" },
    { type: "code_interpreter" },
  ],
});

const response = await client.responses.create({
  model: "gpt-4o",
  input: "投 2d6 并告诉我结果。",
  tools: [
    {
      type: "mcp",
      server_label: "dice_server",           // 服务器标识符（任意）
      server_url: "https://example.com/mcp", // MCP 服务器 URL
      require_approval: "never",             // 自动批准工具调用
    },
  ],
});

console.log(response.output_text);

const response = await client.responses.create({
  model: "gpt-4o",
  input: "告诉我 MCP 规范的传输协议。",
  tools: [
    {
      type: "mcp",
      server_label: "deepwiki",
      server_url: "https://mcp.deepwiki.com/mcp",
      require_approval: {
        never: {
          // 这两个工具无需审批；其他工具需要审批
          tool_names: ["ask_question", "read_wiki_structure"],
        },
      },
    },
  ],
});

const response = await client.responses.create({
  model: "gpt-4o",
  input: "获取一些数据。",
  tools: [
    {
      type: "mcp",
      server_label: "my_server",
      server_url: "https://my-mcp-server.example.com/mcp",
      require_approval: "never",
      headers: {
        Authorization: `Bearer ${process.env.MCP_ACCESS_TOKEN}`,
      },
    },
  ],
});

const response = await client.responses.create({
  model: "o3",
  input: "找出这个数列的通项公式：1, 1, 2, 3, 5, 8, 13, ...",
  reasoning_effort: "high",
});

import OpenAI from "openai";
import { zodResponseFormat } from "openai/helpers/zod";
import { z } from "zod";

const client = new OpenAI();

const Step = z.object({
  explanation: z.string().describe("此计算步骤中所做内容的说明。"),
  output: z.string().describe("此步骤的计算结果（公式或数值）。"),
});

const MathResponse = z.object({
  steps: z.array(Step).describe("解题步骤列表。"),
  final_answer: z.string().describe("方程的最终答案（例如，x = -3.75）。"),
});

const response = await client.responses.parse({
  model: "gpt-4o",
  input: [
    { role: "system", content: "你是一名数学辅导老师。请逐步解释。" },
    { role: "user", content: "求解 8x + 7 = -23" },
  ],
  text: { format: zodResponseFormat(MathResponse, "math_response") },
});

const result = response.output_parsed;
console.log(result.final_answer);
for (const step of result.steps) {
  console.log(step.explanation, "->", step.output);
}

const response = await client.responses.create({
  model: "gpt-4o",
  input: [
    { role: "system", content: "你是一名数学辅导老师。" },
    { role: "user", content: "求解 8x + 7 = -23" },
  ],
  text: {
    format: {
      type: "json_schema",
      name: "math_response",
      strict: true,
      schema: {
        type: "object",
        description: "显示方程逐步解题过程的响应。",
        properties: {
          steps: {
            type: "array",
            description: "解题步骤列表。",
            items: {
              type: "object",
              properties: {
                explanation: {
                  type: "string",
                  description: "此计算步骤中所做内容的说明。",
                },
                output: {
                  type: "string",
                  description: "此步骤的计算结果（公式或数值）。",
                },
              },
              required: ["explanation", "output"],
              additionalProperties: false,
            },
          },
          final_answer: {
            type: "string",
            description: "方程的最终答案（例如，x = -3.75）。",
          },
        },
        required: ["steps", "final_answer"],
        additionalProperties: false,
      },
    },
  },
});

const response = await client.responses.create({
  model: "gpt-4o",
  input: "告诉我订单 #12345 的交货日期",
  tools: [
    {
      type: "function",
      name: "get_delivery_date",
      description: "获取订单的预计交货日期。",
      strict: true,
      parameters: {
        type: "object",
        properties: {
          order_id: { type: "string" },
        },
        required: ["order_id"],
        additionalProperties: false,
      },
    },
  ],
});

const response = await client.responses.parse({
  model: "gpt-4o",
  input: [/* ... */],
  text: { format: zodResponseFormat(MathResponse, "math_response") },
});

if (response.output[0].content[0].type === "refusal") {
  console.log("模型拒绝：", response.output[0].content[0].refusal);
} else {
  const result = response.output_parsed;
}

const stream = await client.responses.stream({
  model: "gpt-4o",
  input: "详细讲述宇宙的起源。",
});

for await (const event of stream) {
  if (
    event.type === "response.output_text.delta" &&
    event.delta
  ) {
    process.stdout.write(event.delta);
  }
}

import retry from "async-retry";

async function callApiWithBackoff(params) {
  return retry(
    async () => {
      return await client.responses.create(params);
    },
    {
      retries: 6,
      minTimeout: 1000,
      maxTimeout: 60000,
      randomize: true,
    }
  );
}