GPT-5.5 全面解析：OpenAI 最强模型的架构革新、Prompt 策略与实战迁移指南

# GPT-5.5 Prompt 最小化调优框架
# pip install openai

import openai

client = openai.OpenAI()

def minimal_prompt_tuning(task_description: str, examples: list[dict]):
    """
    GPT-5.5 Prompt 调优三步法：
    1. 从最小 Prompt 开始（只保留产品合约必须的指令）
    2. 逐步增加推理强度（reasoning effort）
    3. 调整 verbosity 和工具描述
    """
    
    # Step 1: 最小 Prompt - 只说任务
    messages = [
        {"role": "user", "content": task_description}
    ]
    
    response = client.chat.completions.create(
        model="gpt-5.5",
        messages=messages,
        reasoning={"effort": "medium"},  # 从中等推理开始
        extra_body={"verbosity": "medium"},
    )
    baseline = response.choices[0].message.content
    print(f"[Baseline] {baseline[:200]}...")
    
    # Step 2: 对每个 example 测试，找出失效场景
    failures = []
    for i, example in enumerate(examples):
        messages = [
            {"role": "user", "content": example["input"]}
        ]
        resp = client.chat.completions.create(
            model="gpt-5.5",
            messages=messages,
            reasoning={"effort": "medium"},
            extra_body={"verbosity": "medium"},
        )
        result = resp.choices[0].message.content
        if not example["expected"] in result:
            failures.append({
                "index": i,
                "input": example["input"][:100],
                "got": result[:200],
            })
    
    print(f"Failures: {len(failures)}/{len(examples)}")
    
    # Step 3: 针对每个失败场景，渐进式添加指令
    for failure in failures:
        # 先加 system prompt
        messages = [
            {"role": "system", "content": "You are a helpful assistant."},
            {"role": "user", "content": failure["input"]},
        ]
        resp = client.chat.completions.create(
            model="gpt-5.5",
            messages=messages,
            reasoning={"effort": "high"},
            extra_body={"verbosity": "high"},
        )
        print(f"  Fix attempt: {resp.choices[0].message.content[:100]}...")
    
    return baseline, failures

# 使用示例
examples = [
    {
        "input": "Extract the user's name and email from: 'Hi, I'm Alice, alice@example.com'",
        "expected": "Alice",
    },
    {
        "input": "Extract the user's name and email from: 'Contact me at bob@test.org - Bob Smith'",
        "expected": "Bob",
    },
]

minimal_prompt_tuning("Extract name and email", examples)

# GPT-5.5 长任务状态更新模式
# 适用于需要多步工具调用且耗时较长的场景
# OpenAI 官方推荐的用户体验优化技巧

import openai
from openai.types.chat import ChatCompletionMessageParam

client = openai.OpenAI()

def send_user_visible_update(update: str):
    """
    在工具调用前，发送简短用户可见更新。
    GPT-5.5 推荐的最佳实践：1-2 句话，确认请求并说明第一步。
    """
    print(f"🔄 {update}")

def agentic_task_with_updates(user_query: str):
    """
    多步任务 + 用户可见更新模式
    
    GPT-5.5 的 reasoning effort 支持 xhigh，
    但推理时间长会导致用户体验下降。
    这个模式通过在工具调用前发送更新来改善体验。
    """
    messages: list[ChatCompletionMessageParam] = [
        {
            "role": "user",
            "content": (
                f"Task: {user_query}\n\n"
                "Before making any tool calls for multi-step tasks, "
                "first send a short user-visible update that acknowledges "
                "the request and states the first step. Keep it to 1-2 sentences."
            )
        }
    ]
    
    response = client.chat.completions.create(
        model="gpt-5.5",
        messages=messages,
        reasoning={"effort": "xhigh"},  # GPT-5.5 新增 xhigh
        extra_body={"verbosity": "low"},  # 控制输出简洁度
        tools=[
            {
                "type": "function",
                "function": {
                    "name": "search_codebase",
                    "description": "Search the codebase for relevant files",
                    "parameters": {
                        "type": "object",
                        "properties": {
                            "query": {"type": "string"},
                            "file_pattern": {"type": "string"},
                        },
                        "required": ["query"],
                    },
                },
            },
            {
                "type": "function",
                "function": {
                    "name": "run_command",
                    "description": "Execute a shell command",
                    "parameters": {
                        "type": "object",
                        "properties": {
                            "command": {"type": "string"},
                        },
                        "required": ["command"],
                    },
                },
            },
        ],
        parallel_tool_calls=True,
    )
    
    # 处理工具调用
    for tool_call in response.choices[0].message.tool_calls or []:
        send_user_visible_update(
            f"Executing: {tool_call.function.name}"
        )
        # ... 执行工具调用逻辑
    
    return response

# 测试：多步编码任务
agentic_task_with_updates(
    "Find all Python files that handle database connections "
    "and add connection pooling with SQLAlchemy"
)

# GPT-5.5 Agentic Coding 实战：自动重构项目
# 本脚本演示如何使用 GPT-5.5 的 agentic 能力自动重构代码库
# 需要: pip install openai pathlib

import openai
import os
from pathlib import Path

client = openai.OpenAI()

class CodeRefactoringAgent:
    """
    使用 GPT-5.5 自动执行代码重构任务
    
    GPT-5.5 的 agentic coding 能力让它可以：
    1. 理解整个代码库的结构
    2. 制定多步重构计划
    3. 自主执行每个步骤
    4. 验证重构结果
    """
    
    def __init__(self, project_path: str):
        self.project_path = Path(project_path)
        self.history = []
    
    def analyze_project(self) -> str:
        """分析项目结构并生成重构建议"""
        files = []
        for ext in ['*.py', '*.ts', '*.js']:
            files.extend(self.project_path.rglob(ext))
        
        file_contents = {}
        for f in files[:20]:  # 限制文件大小
            try:
                file_contents[str(f.relative_to(self.project_path))] = f.read_text()[:3000]
            except:
                pass
        
        # 构建分析 prompt
        prompt = f"""You are analyzing a codebase for refactoring.

Project structure:
{chr(10).join(file_contents.keys())}

Key files:
{chr(10).join(f'=== {k} ==={chr(10)}{v[:500]}...' for k, v in list(file_contents.items())[:5])}

Identify 3-5 specific refactoring opportunities and create a step-by-step plan.
For each opportunity, specify:
1. Current problem
2. Proposed solution
3. Files to modify
4. Risk assessment"""
        
        response = client.chat.completions.create(
            model="gpt-5.5",
            messages=[{"role": "user", "content": prompt}],
            reasoning={"effort": "xhigh"},
            extra_body={"verbosity": "medium"},
        )
        
        return response.choices[0].message.content
    
    def execute_refactoring(self, plan: str, file_changes: dict[str, str]):
        """
        执行重构计划
        GPT-5.5 可以在一个 agentic loop 中完成：
        读取文件 → 修改代码 → 写回文件 → 验证
        """
        for filepath, new_content in file_changes.items():
            full_path = self.project_path / filepath
            print(f"📝 Modifying {filepath}")
            
            # 备份原文件
            backup = full_path.with_suffix(full_path.suffix + '.bak')
            if full_path.exists():
                backup.write_text(full_path.read_text())
            
            # 写入新内容
            full_path.write_text(new_content)
            self.history.append({
                "action": "modify",
                "file": filepath,
                "backup": str(backup),
            })
    
    def rollback(self):
        """回滚所有更改"""
        for entry in reversed(self.history):
            if entry["action"] == "modify":
                backup = Path(entry["backup"])
                if backup.exists():
                    target = self.project_path / entry["file"]
                    target.write_text(backup.read_text())
                    print(f"↩️ Rolled back {entry['file']}")
        
        self.history = []

# 使用示例
agent = CodeRefactoringAgent("./my-project")
analysis = agent.analyze_project()
print("=== Refactoring Analysis ===")
print(analysis)