use multiple apis

This commit is contained in:
2026-03-10 10:35:03 +08:00
parent 0498c5dbcd
commit c07d69ec71
8 changed files with 1189 additions and 138 deletions

View File

@@ -15,6 +15,94 @@ logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)
def _parse_json(content: str, error_prefix: str) -> dict:
"""解析 LLM 返回的 JSON解析失败时尝试正则兜底。"""
try:
return json.loads(content)
except json.JSONDecodeError:
import re
m = re.search(r'\{.*\}', content, re.DOTALL)
if m:
return json.loads(m.group())
raise ValueError(f"{error_prefix}: {content}")
class ClarifyAgent:
"""需求澄清 Agent —— 判断需求是否完整,并追问用户补充信息"""
def __init__(self):
self.settings = get_settings()
self.client = OpenAI(api_key=self.settings.api_key, base_url=self.settings.base_url)
def start(self, raw_requirement: str) -> dict:
"""
用户第一次提交需求时调用。
返回 {"ready": bool, "question": str, "clarified_requirement": str}
"""
prompt = f"""你是一个资深的产品经理助手,负责在正式分析需求之前确认需求的完整性。
用户提交的需求:
{raw_requirement}
请判断该需求是否足够清晰,可以直接开始产品分析。
返回 JSON
{{
"ready": true 或 false,
"question": "如果 ready=false给用户一个简洁的追问如果 ready=true此字段为空字符串",
"clarified_requirement": "整合后的完整需求描述(即使 ready=false 也要输出当前已有的描述)"
}}
判断标准:
- 需求描述清楚要做什么
- 有基本的场景或目标
- 不需要追问过多细节,够 PM 开始分析即可
返回 ONLY JSON不要有其他文字。"""
response = self.client.chat.completions.create(
model=self.settings.model,
messages=[
{"role": "system", "content": "你是一个产品经理助手,负责判断需求完整性,输出必须是严格的 JSON 格式。"},
{"role": "user", "content": prompt}
],
temperature=0.2,
max_tokens=500,
response_format={"type": "json_object"}
)
return _parse_json(response.choices[0].message.content, "ClarifyAgent.start 解析失败")
def continue_clarify(self, clarify_history: list[dict], user_reply: str) -> dict:
"""
用户补充信息后继续澄清。
clarify_history 格式:[{"role": "assistant"|"user", "content": str}, ...]
返回同 start() 的格式。
"""
messages = [
{"role": "system", "content": "你是一个产品经理助手,负责判断需求完整性,输出必须是严格的 JSON 格式。"}
] + clarify_history + [
{"role": "user", "content": user_reply}
]
suffix = """\n\n根据以上对话,判断需求现在是否足够清晰。返回 JSON
{{
"ready": true 或 false,
"question": "如果 ready=false继续追问如果 ready=true此字段为空字符串",
"clarified_requirement": "整合所有对话后的完整需求描述"
}}
返回 ONLY JSON不要有其他文字。"""
messages.append({"role": "user", "content": suffix})
response = self.client.chat.completions.create(
model=self.settings.model,
messages=messages,
temperature=0.2,
max_tokens=500,
response_format={"type": "json_object"}
)
return _parse_json(response.choices[0].message.content, "ClarifyAgent.continue_clarify 解析失败")
class PMAgent:
"""产品经理Agent - 完善和扩展需求"""
@@ -22,20 +110,10 @@ class PMAgent:
self.settings = get_settings()
self.client = OpenAI(api_key=self.settings.api_key, base_url=self.settings.base_url)
def analyze_requirement(self, simple_requirement: str) -> RequirementAnalysis:
"""
分析和完善简单的需求描述
def _build_prompt(self, requirement: str) -> str:
return f"""你是一个资深的产品经理。请根据以下简单的需求描述,进行深入分析和完善。
Args:
simple_requirement: 用户提供的简单需求描述
Returns:
RequirementAnalysis: 包含完善后的需求信息
"""
prompt = f"""你是一个资深的产品经理。请根据以下简单的需求描述,进行深入分析和完善。
需求描述:{simple_requirement}
需求描述:{requirement}
请按以下格式返回JSON结果必须是有效的JSON格式
{{
@@ -55,6 +133,104 @@ class PMAgent:
返回ONLY JSON内容不要有其他文字。"""
def analyze_requirement(self, simple_requirement: str) -> RequirementAnalysis:
"""
分析和完善简单的需求描述
Args:
simple_requirement: 用户提供的简单需求描述
Returns:
RequirementAnalysis: 包含完善后的需求信息
"""
response = self.client.chat.completions.create(
model=self.settings.model,
messages=[
{"role": "system", "content": "你是一个资深的产品经理,擅长需求分析和拆解,输出必须是严格的 JSON 格式。"},
{"role": "user", "content": self._build_prompt(simple_requirement)}
],
temperature=0.2,
max_tokens=2000,
response_format={"type": "json_object"}
)
result = _parse_json(response.choices[0].message.content, "PMAgent 解析失败")
return RequirementAnalysis(**result)
def stream_analyze(self, simple_requirement: str):
"""
流式版需求分析。yield 文本块(str),最后 yield (None, RequirementAnalysis) 作为哨兵。
"""
stream = self.client.chat.completions.create(
model=self.settings.model,
messages=[
{"role": "system", "content": "你是一个资深的产品经理,擅长需求分析和拆解,输出必须是严格的 JSON 格式。"},
{"role": "user", "content": self._build_prompt(simple_requirement)}
],
temperature=0.2,
max_tokens=2000,
response_format={"type": "json_object"},
stream=True,
)
full_text = ""
for chunk in stream:
delta = chunk.choices[0].delta.content or ""
if delta:
full_text += delta
yield delta
result = _parse_json(full_text, "PMAgent stream 解析失败")
yield (None, RequirementAnalysis(**result))
def stream_refine(self, previous: RequirementAnalysis, feedback: str):
"""
流式版需求分析修改。yield 文本块(str),最后 yield (None, RequirementAnalysis) 作为哨兵。
"""
prompt = f"""你是一个资深的产品经理。以下是你之前输出的需求分析结果,用户对此有修改意见,请根据意见调整输出。
之前的需求分析:
{json.dumps(previous, ensure_ascii=False, indent=2)}
用户的修改意见:
{feedback}
请在原有基础上修改,保持 JSON 格式不变,返回完整的修改后结果,返回 ONLY JSON不要有其他文字。"""
stream = self.client.chat.completions.create(
model=self.settings.model,
messages=[
{"role": "system", "content": "你是一个资深的产品经理,擅长需求分析和拆解,输出必须是严格的 JSON 格式。"},
{"role": "user", "content": prompt}
],
temperature=0.2,
max_tokens=2000,
response_format={"type": "json_object"},
stream=True,
)
full_text = ""
for chunk in stream:
delta = chunk.choices[0].delta.content or ""
if delta:
full_text += delta
yield delta
result = _parse_json(full_text, "PMAgent stream_refine 解析失败")
yield (None, RequirementAnalysis(**result))
def refine(self, previous: RequirementAnalysis, feedback: str) -> RequirementAnalysis:
"""
根据用户反馈修改已有的需求分析结果。
Returns:
RequirementAnalysis: 修改后的需求分析结果
"""
prompt = f"""你是一个资深的产品经理。以下是你之前输出的需求分析结果,用户对此有修改意见,请根据意见调整输出。
之前的需求分析:
{json.dumps(previous, ensure_ascii=False, indent=2)}
用户的修改意见:
{feedback}
请在原有基础上修改,保持 JSON 格式不变,返回完整的修改后结果,返回 ONLY JSON不要有其他文字。"""
response = self.client.chat.completions.create(
model=self.settings.model,
messages=[
@@ -65,22 +241,8 @@ class PMAgent:
max_tokens=2000,
response_format={"type": "json_object"}
)
# 提取响应内容
content = response.choices[0].message.content
# 解析JSON
try:
result = json.loads(content)
return RequirementAnalysis(**result)
except json.JSONDecodeError:
# 如果JSON解析失败尝试提取JSON部分
import re
json_match = re.search(r'\{.*\}', content, re.DOTALL)
if json_match:
result = json.loads(json_match.group())
return RequirementAnalysis(**result)
raise ValueError(f"无法解析Agent响应: {content}")
result = _parse_json(response.choices[0].message.content, "PMAgent.refine 解析失败")
return RequirementAnalysis(**result)
class QAAgent:
@@ -90,18 +252,7 @@ class QAAgent:
self.settings = get_settings()
self.client = OpenAI(api_key=self.settings.api_key, base_url=self.settings.base_url)
def generate_test_cases(self, requirement_analysis: RequirementAnalysis) -> TestCaseResult:
"""
基于需求分析生成测试用例
Args:
requirement_analysis: PM Agent的分析结果
Returns:
TestCaseResult: 包含测试用例的结果
"""
# 构建需求信息
def _build_prompt(self, requirement_analysis: RequirementAnalysis) -> str:
requirement_text = f"""
功能需求:
{chr(10).join(f"- {req}" for req in requirement_analysis["functional_requirements"])}
@@ -118,8 +269,7 @@ class QAAgent:
需求总结:
{requirement_analysis["summary"]}
"""
prompt = f"""你是一个资深的Java QA工程师。根据以下需求信息生成全面的Java测试用例和测试策略。所有测试用例必须基于Java语言步骤和预期结果要符合Java的类型系统、异常机制和JUnit测试框架。
return f"""你是一个资深的Python QA工程师。根据以下需求信息生成全面的Python测试用例和测试策略。所有测试用例必须基于Python语言步骤和预期结果要符合Python的类型系统、异常机制和pytest测试框架。
{requirement_text}
@@ -145,61 +295,140 @@ class QAAgent:
2. 为每个边缘情况生成1个测试用例
3. 生成至少1个性能测试用例
4. 生成至少1个安全测试用例
5. 测试用例要包含明确的步骤和预期结果,步骤和预期结果必须符合Java语言特性(不要出现Python或其他语言的描述)
5. 测试用例要包含明确的步骤和预期结果,步骤和预期结果必须符合Python语言特性(不要出现Java或其他语言的描述)
6. 步骤和预期结果必须用自然语言描述,不得包含任何代码片段或代码块,不要出现 ```、assert、assertEquals 等代码语法
7. 测试策略不要出现JUnit或者Java这种字眼,应该是针对需求的测试方法论和思路描述,覆盖计划要说明如何确保测试覆盖所有功能和边界情况
7. 测试策略不要出现pytest或者Python这种字眼,应该是针对需求的测试方法论和思路描述,覆盖计划要说明如何确保测试覆盖所有功能和边界情况
返回ONLY JSON内容不要有其他文字。"""
def generate_test_cases(self, requirement_analysis: RequirementAnalysis) -> TestCaseResult:
"""
基于需求分析生成测试用例
Args:
requirement_analysis: PM Agent的分析结果
Returns:
TestCaseResult: 包含测试用例的结果
"""
response = self.client.chat.completions.create(
model=self.settings.model,
messages=[
{"role": "system", "content": "你是一个资深的 Python QA 工程师,擅长为 Python 应用程序设计测试用例,所有测试步骤和预期结果必须基于 Python 语言特性(如 pytest、动态类型、异常机制等输出必须是严格的 JSON 格式。"},
{"role": "user", "content": self._build_prompt(requirement_analysis)}
],
temperature=0.2,
max_tokens=3000,
response_format={"type": "json_object"}
)
result = _parse_json(response.choices[0].message.content, "QAAgent 解析失败")
return TestCaseResult(**result)
def stream_generate_test_cases(self, requirement_analysis: RequirementAnalysis):
"""
流式版测试用例生成。yield 文本块(str),最后 yield (None, TestCaseResult) 作为哨兵。
"""
stream = self.client.chat.completions.create(
model=self.settings.model,
messages=[
{"role": "system", "content": "你是一个资深的 Python QA 工程师,擅长为 Python 应用程序设计测试用例,输出必须是严格的 JSON 格式。"},
{"role": "user", "content": self._build_prompt(requirement_analysis)}
],
temperature=0.2,
max_tokens=3000,
response_format={"type": "json_object"},
stream=True,
)
full_text = ""
for chunk in stream:
delta = chunk.choices[0].delta.content or ""
if delta:
full_text += delta
yield delta
result = _parse_json(full_text, "QAAgent stream 解析失败")
yield (None, TestCaseResult(**result))
def stream_refine(self, previous: TestCaseResult, feedback: str):
"""
流式版测试用例修改。yield 文本块(str),最后 yield (None, TestCaseResult) 作为哨兵。
"""
prompt = f"""你是一个资深的Python QA工程师。以下是你之前输出的测试用例用户对此有修改意见请根据意见调整输出。
之前的测试用例:
{json.dumps(previous, ensure_ascii=False, indent=2)}
用户的修改意见:
{feedback}
请在原有基础上修改,保持 JSON 格式不变,返回完整的修改后结果。
步骤和预期结果必须用自然语言描述,不得包含代码片段。
返回 ONLY JSON不要有其他文字。"""
stream = self.client.chat.completions.create(
model=self.settings.model,
messages=[
{"role": "system", "content": "你是一个资深的 Python QA 工程师,输出必须是严格的 JSON 格式。"},
{"role": "user", "content": prompt}
],
temperature=0.2,
max_tokens=3000,
response_format={"type": "json_object"},
stream=True,
)
full_text = ""
for chunk in stream:
delta = chunk.choices[0].delta.content or ""
if delta:
full_text += delta
yield delta
result = _parse_json(full_text, "QAAgent stream_refine 解析失败")
yield (None, TestCaseResult(**result))
def refine(self, previous: TestCaseResult, feedback: str) -> TestCaseResult:
"""
根据用户反馈修改已有的测试用例结果。
Args:
previous: 上一次的测试用例结果
feedback: 用户的修改意见
Returns:
TestCaseResult: 修改后的测试用例结果
"""
prompt = f"""你是一个资深的Python QA工程师。以下是你之前输出的测试用例用户对此有修改意见请根据意见调整输出。
之前的测试用例:
{json.dumps(previous, ensure_ascii=False, indent=2)}
用户的修改意见:
{feedback}
请在原有基础上修改,保持 JSON 格式不变,返回完整的修改后结果。
步骤和预期结果必须用自然语言描述,不得包含代码片段。
返回 ONLY JSON不要有其他文字。"""
response = self.client.chat.completions.create(
model=self.settings.model,
messages=[
{"role": "system", "content": "你是一个资深的 Java QA 工程师,擅长为 Java 应用程序设计测试用例,所有测试步骤和预期结果必须基于 Java 语言特性(如 JUnit、强类型系统、异常机制等输出必须是严格的 JSON 格式。"},
{"role": "system", "content": "你是一个资深的 Python QA 工程师,输出必须是严格的 JSON 格式。"},
{"role": "user", "content": prompt}
],
temperature=0.2,
max_tokens=3000,
response_format={"type": "json_object"}
)
content = response.choices[0].message.content
try:
result = json.loads(content)
return TestCaseResult(**result)
except json.JSONDecodeError:
import re
json_match = re.search(r'\{.*\}', content, re.DOTALL)
if json_match:
result = json.loads(json_match.group())
return TestCaseResult(**result)
raise ValueError(f"无法解析QA Agent响应: {content}")
result = _parse_json(response.choices[0].message.content, "QAAgent.refine 解析失败")
return TestCaseResult(**result)
class DevAgent:
"""开发Agent - 生成Java代码和单元测试"""
"""开发Agent - 生成Python代码和单元测试"""
def __init__(self):
self.settings = get_settings()
self.client = OpenAI(api_key=self.settings.api_key, base_url=self.settings.base_url)
def generate_code(
self,
requirement_analysis: RequirementAnalysis,
test_cases: TestCaseResult
) -> CodeGenerationResult:
"""
生成Java实现代码和单元测试代码
Args:
requirement_analysis: PM Agent的分析结果
test_cases: QA Agent的测试用例
Returns:
CodeGenerationResult: 包含Java代码和单元测试代码
"""
# 构建上下文
def _build_prompt(self, requirement_analysis: RequirementAnalysis, test_cases: TestCaseResult) -> str:
requirement_text = f"""
功能需求:
{chr(10).join(f"- {req}" for req in requirement_analysis["functional_requirements"])}
@@ -213,7 +442,6 @@ class DevAgent:
需求总结:
{requirement_analysis["summary"]}
"""
test_cases_text = chr(10).join(
f"- [{c['test_id']}] {c['test_name']}(类型:{c.get('test_type', '未分类')})|预期结果:{c['expected_result']}"
for c in test_cases["test_cases"]
@@ -226,8 +454,7 @@ class DevAgent:
关键测试用例列表:
{test_cases_text}
"""
prompt = f"""你是一个资深的Java开发工程师。根据以下需求和测试用例生成高质量的Java实现代码和单元测试代码。
return f"""你是一个资深的Python开发工程师。根据以下需求和测试用例生成高质量的Python实现代码和单元测试代码。
{requirement_text}
@@ -235,61 +462,246 @@ class DevAgent:
请返回JSON格式的结果必须是有效的JSON格式
{{
"java_code": "完整的Java实现代码(包含主和必要的辅助类)",
"unit_tests": "使用JUnit的单元测试代码",
"implementation_notes": "实现说明和注意事项",
"unit_tests_count": "生成的单元测试总数量(整数)",
"passed_tests_count": "基于代码逻辑分析,预期可通过的单元测试数量(整数)"
"java_code": "完整的Python实现代码(包含主模块和必要的辅助类/函数",
"unit_tests": "使用pytest的单元测试代码",
"implementation_notes": "实现说明和注意事项"
}}
Java代码要求:
1. 使用 Java 11 语法和特性(如 var 局部变量类型推断、String::isBlank/strip/lines、Optional、Stream API、List.of/Map.of 等不可变集合工厂方法),不要使用 Java 8 以前的写法
2. 包含详细的中文代码注释,所有注释内容必须中文撰写,所有多行注释必须以 /* 开头、以 */ 结尾Javadoc注释以 /** 开头、以 */ 结尾,绝对不能用单独的 / 作为注释结尾
Python代码要求:
1. 使用 Python 3.10+ 语法和特性(如 match/case、类型注解、dataclass、pathlib、f-string、列表推导等代码风格遵循 PEP 8
2. 包含详细的中文代码注释,类和函数必须中文 docstring
3. 包含异常处理
4. 支持所有的功能需求
5. 考虑非功能需求(性能、安全等)
单元测试要求:
1. 使用 JUnit 5jupiter充分利用 @DisplayName、@ParameterizedTest、assertThrows 等特性
2. 为每个公共方法生成测试
1. 使用 pytest充分利用 @pytest.mark.parametrize、pytest.raises、fixture 等特性
2. 为每个公共函数/方法生成测试
3. 包含正常情况、边缘情况和异常情况的测试
4. 使用有意义的测试方法名称
5. 每个测试类顶部加中文类级注释说明该类的测试范围
4. 使用有意义的测试函数名称(如 test_xxx_when_xxx_should_xxx
5. 每个测试函数内用中文注释标注 Given / When / Then 三个阶段
6. 测试代码要清晰易读
7. 重要:业务代码文件保存名为 implementation.py测试代码文件保存名为 test_implementation.py测试文件必须使用 `from implementation import ...` 或 `import implementation` 导入业务代码
implementation_notes要求返回中文实现说明内容要具体且有指导意义不能只是简单的总结性描述要包含对关键设计决策的解释和对复杂逻辑的说明。
返回ONLY JSON内容不要有其他文字。"""
def generate_code(
self,
requirement_analysis: RequirementAnalysis,
test_cases: TestCaseResult
) -> CodeGenerationResult:
"""
生成Python实现代码和单元测试代码
Args:
requirement_analysis: PM Agent的分析结果
test_cases: QA Agent的测试用例
Returns:
CodeGenerationResult: 包含Python代码和单元测试代码
"""
response = self.client.chat.completions.create(
model=self.settings.model,
messages=[
{"role": "system", "content": "你是一个资深的 Java 11 开发工程师,擅长使用 Java 11 特性var、Stream API、Optional、HttpClient、String 新方法等)编写高质量代码和单元测试,所有代码注释用中文,类名和方法名保持英文命名规范,输出必须是严格的 JSON 格式。"},
{"role": "system", "content": "你是一个资深的 Python 3.10+ 开发工程师,擅长使用 Python 类型注解、dataclass、pytest 等特性编写高质量代码和单元测试,所有代码注释用中文,输出必须是严格的 JSON 格式。"},
{"role": "user", "content": self._build_prompt(requirement_analysis, test_cases)}
],
temperature=0.2,
max_tokens=8192,
response_format={"type": "json_object"}
)
result = _parse_json(response.choices[0].message.content, "DevAgent 解析失败")
return CodeGenerationResult(**result)
def stream_generate_code(
self,
requirement_analysis: RequirementAnalysis,
test_cases: TestCaseResult,
):
"""
流式版代码生成。yield 文本块(str),最后 yield (None, CodeGenerationResult) 作为哨兵。
"""
stream = self.client.chat.completions.create(
model=self.settings.model,
messages=[
{"role": "system", "content": "你是一个资深的 Python 3.10+ 开发工程师,擅长使用 Python 类型注解、dataclass、pytest 等特性编写高质量代码,所有代码注释用中文,输出必须是严格的 JSON 格式。"},
{"role": "user", "content": self._build_prompt(requirement_analysis, test_cases)}
],
temperature=0.2,
max_tokens=8192,
response_format={"type": "json_object"},
stream=True,
)
full_text = ""
for chunk in stream:
delta = chunk.choices[0].delta.content or ""
if delta:
full_text += delta
yield delta
result = _parse_json(full_text, "DevAgent stream 解析失败")
yield (None, CodeGenerationResult(**result))
def refine(
self,
previous: CodeGenerationResult,
requirement_analysis: RequirementAnalysis,
test_cases: TestCaseResult,
feedback: str
) -> CodeGenerationResult:
"""
根据用户反馈修改已有的代码生成结果。
Args:
previous: 上一次的代码生成结果
requirement_analysis: PM Agent的分析结果供参考
test_cases: QA Agent的测试用例供参考
feedback: 用户的修改意见
Returns:
CodeGenerationResult: 修改后的代码生成结果
"""
refine_prompt = f"""以下是你之前生成的代码结果,用户对此有修改意见,请根据意见调整输出。
用户的修改意见:
{feedback}
请在原有代码基础上修改,保持 JSON 格式不变,返回完整的修改后结果。
继续遵守原有的 Python 3.10+、中文注释、pytest 等所有要求。
返回 ONLY JSON不要有其他文字。"""
response = self.client.chat.completions.create(
model=self.settings.model,
messages=[
{"role": "system", "content": "你是一个资深的 Python 3.10+ 开发工程师,所有代码注释用中文,输出必须是严格的 JSON 格式。"},
{"role": "user", "content": self._build_prompt(requirement_analysis, test_cases)},
{"role": "assistant", "content": json.dumps(previous, ensure_ascii=False)},
{"role": "user", "content": refine_prompt}
],
temperature=0.2,
max_tokens=8192,
response_format={"type": "json_object"}
)
result = _parse_json(response.choices[0].message.content, "DevAgent.refine 解析失败")
return CodeGenerationResult(**result)
class FixAgent:
"""自动修复Agent - 根据pytest失败信息修复Python代码"""
def __init__(self):
self.settings = get_settings()
self.client = OpenAI(api_key=self.settings.api_key, base_url=self.settings.base_url)
def fix(self, code_generation: CodeGenerationResult, test_output: str) -> CodeGenerationResult:
"""
根据pytest输出自动修复业务代码和/或测试代码。
Args:
code_generation: 之前 DevAgent 的产出
test_output: pytest 执行的完整输出
Returns:
CodeGenerationResult: 修复后的完整代码
"""
prompt = f"""以下Python代码在运行单元测试时出现了失败请根据pytest失败信息修复代码。
当前业务代码implementation.py
```python
{code_generation["java_code"]}
```
当前测试代码test_implementation.py
```python
{code_generation["unit_tests"]}
```
pytest 执行输出:
{test_output[:4000]}
请分析失败原因并修复(业务代码和/或测试代码中的问题 都可以修复)。
层层修复要径直至递推所有测试权都能通过。
业务代码文件名为 implementation.py测试文件名为 test_implementation.py测试文件导入必须用 from implementation import ...。
返回 JSON 格式:
{{
"java_code": "修复后的完整Python业务代码",
"unit_tests": "修复后的完整Python测试代码",
"implementation_notes": "修复说明:具体说明了哪些问题,如何修复的"
}}
返回 ONLY JSON不要有其他文字。"""
response = self.client.chat.completions.create(
model=self.settings.model,
messages=[
{"role": "system", "content": "你是一个资深的 Python 3.10+ 开发工程师,擅长根据测试错误信息定位并修复 Bug所有代码注释用中文输出必须是严格的 JSON 格式。"},
{"role": "user", "content": prompt}
],
temperature=0.2,
max_tokens=8192,
response_format={"type": "json_object"}
)
result = _parse_json(response.choices[0].message.content, "FixAgent 解析失败")
return CodeGenerationResult(**result)
content = response.choices[0].message.content
def stream_fix(self, code_generation: CodeGenerationResult, test_output: str):
"""
流式修复。yield 文本块(str),最后 yield (None, CodeGenerationResult) 作为哨兵。
"""
prompt = f"""以下Python代码在运行单元测试时出现了失败请根据pytest失败信息修复代码。
当前业务代码implementation.py
```python
{code_generation["java_code"]}
```
try:
result = json.loads(content)
return CodeGenerationResult(**result)
except json.JSONDecodeError:
import re
json_match = re.search(r'\{.*\}', content, re.DOTALL)
if json_match:
result = json.loads(json_match.group())
return CodeGenerationResult(**result)
raise ValueError(f"无法解析Dev Agent响应: {content}")
当前测试代码test_implementation.py
```python
{code_generation["unit_tests"]}
```
pytest 执行输出:
{test_output[:4000]}
请分析失败原因并修复(业务代码和/或测试代码中的问题 都可以修复)。
层层修复要径直至递推所有测试权都能通过。
业务代码文件名为 implementation.py测试文件名为 test_implementation.py测试文件导入必须用 from implementation import ...。
返回 JSON 格式:
{{
"java_code": "修复后的完整Python业务代码",
"unit_tests": "修复后的完整Python测试代码",
"implementation_notes": "修复说明:具体说明了哪些问题,如何修复的"
}}
返回 ONLY JSON不要有其他文字。"""
stream = self.client.chat.completions.create(
model=self.settings.model,
messages=[
{"role": "system", "content": "你是一个资深的 Python 3.10+ 开发工程师,擅长根据测试错误信息定位并修复 Bug所有代码注释用中文输出必须是严格的 JSON 格式。"},
{"role": "user", "content": prompt}
],
temperature=0.2,
max_tokens=8192,
response_format={"type": "json_object"},
stream=True,
)
full_text = ""
for chunk in stream:
delta = chunk.choices[0].delta.content or ""
if delta:
full_text += delta
yield delta
result = _parse_json(full_text, "FixAgent stream 解析失败")
yield (None, CodeGenerationResult(**result))
async def orchestrate_agents(simple_requirement: str) -> dict:
"""
编排三个Agent的工作流程
编排三个Agent的工作流程(保留原有全量接口)
Args:
simple_requirement: 用户的简单需求描述