curl -X POST "https://api.tokenops.ai/v1/responses" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer <API-KEY>" \
  -d '{
    "model": "gpt-5-2025-08-07",
    "input": [
      {
        "role": "user",
        "content": [
          {
            "type": "input_text",
            "text": "分析苹果公司的基本信息，包括公司名称、成立年份、创始人、主要业务等"
          }
        ]
      }
    ],
    "text": {
      "format": {
        "type": "json_schema",
        "name": "company_analysis",
        "schema": {
          "type": "object",
          "properties": {
            "company_name": {
              "type": "string",
              "description": "公司名称"
            },
            "founded_year": {
              "type": "integer",
              "description": "成立年份"
            },
            "founders": {
              "type": "array",
              "items": {
                "type": "string"
              },
              "description": "创始人列表"
            },
            "main_business": {
              "type": "array",
              "items": {
                "type": "string"
              },
              "description": "主要业务领域"
            },
            "headquarters": {
              "type": "string",
              "description": "总部位置"
            },
            "ceo": {
              "type": "string",
              "description": "现任CEO"
            }
          },
          "required": ["company_name", "founded_year", "founders", "main_business", "headquarters", "ceo"],
          "additionalProperties": false
        },
        "strict": true,
        "description": "公司基本信息分析的结构化输出格式"
      }
    }
  }'

import requests
import json

# 配置API密钥和基础URL
API_KEY = "<API-KEY>"
BASE_URL = "https://api.tokenops.ai/v1"

def create_structured_response():
    """使用结构化输出分析公司信息"""
    url = f"{BASE_URL}/responses"
    headers = {
        "Content-Type": "application/json",
        "Authorization": f"Bearer {API_KEY}"
    }

    # 定义JSON Schema
    schema = {
        "type": "object",
        "properties": {
            "company_name": {
                "type": "string",
                "description": "公司名称"
            },
            "founded_year": {
                "type": "integer",
                "description": "成立年份"
            },
            "founders": {
                "type": "array",
                "items": {
                    "type": "string"
                },
                "description": "创始人列表"
            },
            "main_business": {
                "type": "array",
                "items": {
                    "type": "string"
                },
                "description": "主要业务领域"
            },
            "headquarters": {
                "type": "string",
                "description": "总部位置"
            },
            "ceo": {
                "type": "string",
                "description": "现任CEO"
            },
            "market_cap_billion": {
                "type": "number",
                "description": "市值（十亿美元）"
            },
            "employee_count": {
                "type": "integer",
                "description": "员工数量"
            }
        },
        "required": ["company_name", "founded_year", "founders", "main_business", "headquarters", "ceo"],
        "additionalProperties": false
    }

    payload = {
        "model": "gpt-5-2025-08-07",
        "input": [
            {
                "role": "user",
                "content": [
                    {
                        "type": "input_text",
                        "text": "分析苹果公司的基本信息，包括公司名称、成立年份、创始人、主要业务、总部位置、现任CEO、市值和员工数量等"
                    }
                ]
            }
        ],
        "text": {
            "format": {
                "type": "json_schema",
                "name": "company_analysis",
                "schema": schema,
                "strict": True,
                "description": "公司基本信息分析的结构化输出格式"
            }
        }
    }

    response = requests.post(url, headers=headers, json=payload)

    if response.status_code == 200:
        result = response.json()

        # 解析结构化输出 - 从实际响应结构中获取
        if result.get("status") == "completed" and result.get("output"):
            # 从output数组中找到message类型的输出
            message_output = None
            for output_item in result["output"]:
                if output_item.get("type") == "message":
                    message_output = output_item
                    break
            
            if message_output and message_output.get("content"):
                # 从content数组中获取output_text
                for content_item in message_output["content"]:
                    if content_item.get("type") == "output_text":
                        structured_content = content_item.get("text")
                        break
            else:
                structured_content = result.get("output_text")  # 兼容旧格式
        else:
            structured_content = result.get("output_text")  # 兼容旧格式

        # 结构化输出已经是有效的JSON对象
        if isinstance(structured_content, str):
            try:
                company_data = json.loads(structured_content)
            except json.JSONDecodeError:
                print("返回的不是有效的JSON格式")
                return None
        else:
            company_data = structured_content

        print("=== 结构化输出结果 ===")
        print(json.dumps(company_data, indent=2, ensure_ascii=False))

        # 显示使用统计
        usage = result.get("usage", {})
        print(f"\nToken使用: {usage.get('total_tokens', 0)} (输入: {usage.get('input_tokens', 0)}, 输出: {usage.get('output_tokens', 0)})")

        return company_data
    else:
        print(f"HTTP错误: {response.status_code}")
        print(response.text)
        return None


# 使用示例
if __name__ == "__main__":
    print("结构化输出示例")
    result = create_structured_response()

const axios = require('axios');

// 配置API密钥和基础URL
const API_KEY = '<API-KEY>';
const BASE_URL = 'https://api.tokenops.ai/v1';

async function createStructuredResponse() {
    const url = `${BASE_URL}/responses`;
    const headers = {
        'Content-Type': 'application/json',
        'Authorization': `Bearer ${API_KEY}`
    };

    // 定义JSON Schema
    const schema = {
        type: 'object',
        properties: {
            company_name: {
                type: 'string',
                description: '公司名称'
            },
            founded_year: {
                type: 'integer',
                description: '成立年份'
            },
            founders: {
                type: 'array',
                items: {
                    type: 'string'
                },
                description: '创始人列表'
            },
            main_business: {
                type: 'array',
                items: {
                    type: 'string'
                },
                description: '主要业务领域'
            },
            headquarters: {
                type: 'string',
                description: '总部位置'
            },
            ceo: {
                type: 'string',
                description: '现任CEO'
            },
            market_cap_billion: {
                type: 'number',
                description: '市值（十亿美元）'
            },
            employee_count: {
                type: 'integer',
                description: '员工数量'
            }
        },
        required: ['company_name', 'founded_year', 'founders', 'main_business', 'headquarters', 'ceo'],
        additionalProperties: false
    };

    const payload = {
        model: 'gpt-5-2025-08-07',
        input: [
            {
                role: 'user',
                content: [
                    {
                        type: 'input_text',
                        text: '分析苹果公司的基本信息，包括公司名称、成立年份、创始人、主要业务、总部位置、现任CEO、市值和员工数量等'
                    }
                ]
            }
        ],
        text: {
            format: {
                type: 'json_schema',
                name: 'company_analysis',
                schema: schema,
                strict: true,
                description: '公司基本信息分析的结构化输出格式'
            }
        }
    };

    try {
        const response = await axios.post(url, payload, { headers });

        // 解析结构化输出 - 从实际响应结构中获取
        let structuredContent;
        if (response.data.status === "completed" && response.data.output) {
            // 从output数组中找到message类型的输出
            const messageOutput = response.data.output.find(item => item.type === "message");
            
            if (messageOutput && messageOutput.content) {
                // 从content数组中获取output_text
                const textContent = messageOutput.content.find(item => item.type === "output_text");
                structuredContent = textContent ? textContent.text : response.data.output_text;
            } else {
                structuredContent = response.data.output_text; // 兼容旧格式
            }
        } else {
            structuredContent = response.data.output_text; // 兼容旧格式
        }

        let companyData;
        if (typeof structuredContent === 'string') {
            try {
                companyData = JSON.parse(structuredContent);
            } catch (error) {
                console.log('返回的不是有效的JSON格式');
                return null;
            }
        } else {
            companyData = structuredContent;
        }

        console.log('=== 结构化输出结果 ===');
        console.log(JSON.stringify(companyData, null, 2));

        const usage = response.data.usage || {};
        console.log(`\\nToken使用: ${usage.total_tokens || 0} (输入: ${usage.input_tokens || 0}, 输出: ${usage.output_tokens || 0})`);

        return companyData;
    } catch (error) {
        console.error('请求出错:', error.response?.data || error.message);
        return null;
    }
}


// 使用示例
async function main() {
    try {
        console.log('结构化输出示例');
        await createStructuredResponse();
    } catch (error) {
        console.error('执行出错:', error);
    }
}

main();