GPT-5.5 全面指南：OpenAI 最新旗舰模型的架构升级、Prompt 工程与 Agentic Coding 实战

from openai import OpenAI

client = OpenAI(api_key="YOUR_API_KEY")

# 步骤 1：最小化 baseline（仅核心任务）
baseline_prompt = """
Extract the email addresses from this text and return them as a JSON array.
"""

# 步骤 2：验证 baseline 效果
messages = [
    {"role": "user", "content": baseline_prompt + "\n\n" + sample_text}
]

response = client.chat.completions.create(
    model="gpt-5.5",
    messages=messages,
    extra_body={"verbosity": "low"},  # 精确输出场景用 low
)

# 步骤 3：根据输出质量逐步添加约束
if not is_valid_json(response):
    enhanced_prompt = baseline_prompt + "\n\nOnly output valid JSON. No explanation."
    # 重试...

# 步骤 4：用代表性示例批量验证
test_cases = load_test_cases("email_extraction_test.json")
results = []
for case in test_cases:
    result = client.chat.completions.create(
        model="gpt-5.5",
        messages=[{"role": "user", "content": enhanced_prompt + "\n\n" + case["input"]}],
        extra_body={"verbosity": "low"},
    )
    results.append(evaluate(result, case["expected"]))

print(f"Pass rate: {sum(results)}/{len(results)}")

from openai import OpenAI
import asyncio

client = OpenAI(api_key="YOUR_API_KEY")

async def run_with_feedback(task_description: str, stream_callback=None):
    """
    执行长时间任务时，先发送进度更新，再进行实际处理。
    这是 OpenAI 推荐的 GPT-5.5 UX 模式。
    """
    # 阶段 1：立即发送进度更新
    steps = plan_steps(task_description)
    
    if stream_callback:
        await stream_callback(f"🔍 开始处理：{steps[0]}")
    
    # 阶段 2：执行每个步骤并发送更新
    results = []
    for i, step in enumerate(steps):
        if stream_callback and i > 0:
            await stream_callback(f"⚙️ 步骤 {i+1}/{len(steps)}: {step}")
        
        response = client.chat.completions.create(
            model="gpt-5.5",
            messages=[
                {"role": "system", "content": f"当前步骤：{step}"},
                {"role": "user", "content": task_description},
            ],
            extra_body={"verbosity": "medium"},
        )
        results.append(response.choices[0].message.content)
    
    return results

# 使用示例
async def main():
    async def show_progress(msg):
        print(f"[进度] {msg}")
    
    result = await run_with_feedback(
        "分析这个代码仓库的架构问题，并提供重构建议",
        stream_callback=show_progress,
    )

asyncio.run(main())

# 这是一个展示 GPT-5.5 Agentic Coding 工作流的 Python 脚本
# 模拟了 Codex CLI 的多步骤编程流程

from typing import TypedDict, Optional

class CodeTask(TypedDict):
    """定义编程任务的类型"""
    description: str
    context: Optional[str]  # 代码库上下文
    constraints: list[str]  # 约束条件

class CodeResult(TypedDict):
    """编程结果"""
    code: str
    tests: str
    issues: list[str]

def agentic_coding_workflow(task: CodeTask) -> CodeResult:
    """
    模拟 GPT-5.5 Agentic Coding 工作流。
    实际使用时，替换 gpt55_call 为真实的 OpenAI API 调用。
    """
    
    def gpt55_call(messages: list[dict], **kwargs) -> str:
        """模拟 GPT-5.5 API 调用"""
        # 实际代码：
        # from openai import OpenAI
        # client = OpenAI(api_key="...")
        # resp = client.chat.completions.create(
        #     model="gpt-5.5",
        #     messages=messages,
        #     **kwargs
        # )
        # return resp.choices[0].message.content
        return ""  # placeholder
    
    # 阶段 1：架构设计
    architecture = gpt55_call([
        {"role": "system", "content": "你是一个资深软件架构师。"},
        {"role": "user", "content": f"""
        设计以下需求的整体架构：
        {task['description']}
        
        约束条件：
        {chr(10).join(f'- {c}' for c in task['constraints'])}
        
        输出模块划分和接口定义。
        """}
    ])
    
    # 阶段 2：模块实现
    modules = parse_modules(architecture)
    all_code = {}
    for module in modules:
        code = gpt55_call([
            {"role": "system", "content": f"实现模块：{module['name']}"},
            {"role": "user", "content": f"""
            接口定义：
            {module['interface']}
            
            请实现具体逻辑，包含错误处理和日志。
            """}
        ])
        all_code[module['name']] = code
    
    # 阶段 3：测试生成
    tests = gpt55_call([
        {"role": "system", "content": "你是一个测试工程师。"},
        {"role": "user", "content": f"为以下模块生成完整的测试用例：\n{all_code}"}
    ])
    
    return {
        "code": "\n".join(all_code.values()),
        "tests": tests,
        "issues": [],
    }

# 使用示例
result = agentic_coding_workflow({
    "description": "构建一个带缓存和重试机制的 HTTP 客户端",
    "constraints": ["使用 Python 3.12+", "支持异步", "包含类型标注"],
})
print(result["code"])

from openai import OpenAI
import json

client = OpenAI(api_key="YOUR_API_KEY")

# 测试用例集
test_cases = [
    {"input": "写一个二分查找", "expected_keys": ["code", "explanation"]},
    {"input": "解释 RESTful API 设计原则", "expected_keys": ["principles"]},
    {"input": "将这段 Java 代码转为 Python", "expected_keys": ["python_code"]},
]

def run_comparison(model: str, test_cases: list) -> list[dict]:
    """对比不同模型的输出"""
    results = []
    for case in test_cases:
        response = client.chat.completions.create(
            model=model,
            messages=[{"role": "user", "content": case["input"]}],
            extra_body={"verbosity": "low"},
        )
        results.append({
            "input": case["input"],
            "model": model,
            "output_length": len(response.choices[0].message.content),
            "usage": {
                "prompt_tokens": response.usage.prompt_tokens,
                "completion_tokens": response.usage.completion_tokens,
                "total_tokens": response.usage.total_tokens,
            },
        })
    return results

# 运行对比
gpt54_results = run_comparison("gpt-5.4", test_cases)
gpt55_results = run_comparison("gpt-5.5", test_cases)

# 分析差异
for old, new in zip(gpt54_results, gpt55_results):
    token_diff = new["usage"]["total_tokens"] - old["usage"]["total_tokens"]
    pct = (token_diff / old["usage"]["total_tokens"]) * 100
    print(f"任务: {new['input'][:30]}...")
    print(f"  Token 变化: {pct:+.1f}%")
    print()

from openai import OpenAI
from dataclasses import dataclass
from typing import Literal

@dataclass
class ModelProfile:
    """模型配置"""
    name: str
    base_url: str
    api_key: str
    cost_per_m_input: float
    cost_per_m_output: float
    strengths: list[str]

# 模型配置
MODELS = {
    "gpt55": ModelProfile(
        name="gpt-5.5",
        base_url="https://api.openai.com/v1",
        api_key="OPENAI_KEY",
        cost_per_m_input=5.0,
        cost_per_m_output=30.0,
        strengths=["agentic_coding", "complex_reasoning", "multimodal"],
    ),
    "deepseek_v4_pro": ModelProfile(
        name="deepseek/deepseek-v4-pro",
        base_url="https://openrouter.ai/api/v1",
        api_key="OPENROUTER_KEY",
        cost_per_m_input=1.74,
        cost_per_m_output=3.48,
        strengths=["coding", "reasoning", "chinese"],
    ),
    "qwen36": ModelProfile(
        name="qwen/qwen3.6-27b",
        base_url="https://openrouter.ai/api/v1",
        api_key="OPENROUTER_KEY",
        cost_per_m_input=0.10,
        cost_per_m_output=0.30,
        strengths=["chinese", "local_deploy", "cost_efficiency"],
    ),
}

def select_model(task_type: str, budget_tier: Literal["low", "medium", "high"]) -> ModelProfile:
    """根据任务类型和预算选择最优模型"""
    # 任务到能力的映射
    task_capabilities = {
        "agentic_coding": "agentic_coding",
        "code_generation": "coding",
        "reasoning": "complex_reasoning",
        "translation": "chinese",
        "content_generation": "chinese",
        "batch_processing": "cost_efficiency",
    }
    
    required = task_capabilities.get(task_type, "coding")
    
    # 根据预算筛选
    if budget_tier == "low":
        candidates = [m for m in MODELS.values() if m.cost_per_m_input < 2.0]
    elif budget_tier == "medium":
        candidates = [m for m in MODELS.values() if m.cost_per_m_input < 5.0]
    else:
        candidates = list(MODELS.values())
    
    # 选择匹配能力的模型
    for model in candidates:
        if required in model.strengths:
            return model
    
    return candidates[0]  # 默认返回最便宜的

# 使用示例
chosen_model = select_model("agentic_coding", "high")
print(f"选择模型: {chosen_model.name}，输入成本: ${chosen_model.cost_per_m_input}/M token")