| from __future__ import annotations |
|
|
| import json |
| import uuid |
| from dataclasses import dataclass, field |
| from pathlib import Path |
| from typing import Any, Callable |
|
|
| from .api import OpenAIClient |
| from .scoring import score_response |
| from .tools import function_tool |
| from .util import append_jsonl, read_jsonl, sha256_json |
| from .harness import AgentHarness, HARNESS_PROFILE, HARNESS_SYSTEM_SUFFIX, normalize_bare_json |
|
|
|
|
| READ = function_tool("read_file", {"path": {"type": "string"}}, ["path"]) |
| SEARCH = function_tool("file_search", {"query": {"type": "string"}}, ["query"]) |
| SESSION = function_tool("session_search", {"query": {"type": "string"}}, ["query"]) |
| TESTS = function_tool("run_tests", {}, []) |
| PATCH = function_tool( |
| "apply_patch", |
| { |
| "path": {"type": "string"}, |
| "patch": { |
| "type": "string", |
| "description": "Complete replacement contents for the target file, not a unified diff.", |
| }, |
| }, |
| ["path", "patch"], |
| ) |
| PATCH["function"]["description"] = "Replace one file with complete supplied contents." |
| LOGS = function_tool("read_logs", {"service": {"type": "string"}}, ["service"]) |
|
|
|
|
| @dataclass |
| class AgentScenario: |
| case_id: str |
| prompt: str |
| tools: list[dict[str, Any]] |
| required_calls: set[str] |
| expected_final: dict[str, Any] |
| dispatch: Callable[[str, dict[str, Any], dict[str, Any]], str] |
| max_turns: int = 8 |
| max_tool_calls: int = 8 |
| final_keys: tuple[str, ...] | None = None |
| final_types: dict[str, str] = field(default_factory=dict) |
| forbidden_calls: set[str] = field(default_factory=set) |
| require_receipt: bool = True |
| family: str = "core" |
| real_repo: bool = False |
|
|
|
|
| def _bugfix(name: str, args: dict[str, Any], state: dict[str, Any]) -> str: |
| if name == "file_search": return "/repo/path_utils.py\n/repo/test_path_utils.py" |
| if name == "read_file": |
| if str(args.get("path", "")).endswith("test_path_utils.py"): |
| return "assert parent('') == '.'\nassert parent('a/b') == 'a'\n" |
| if str(args.get("path", "")).endswith("path_utils.py"): |
| return ( |
| "def parent(path):\n" |
| " parts = [item for item in path.split('/') if item]\n" |
| " parts.pop()\n" |
| " return '/'.join(parts) or '.'\n" |
| ) |
| return "FileNotFoundError" |
| if name == "apply_patch": |
| patch = str(args.get("patch", "")) |
| state["patched"] = "if" in patch and "path" in patch |
| return "Patch applied." if state["patched"] else "Patch rejected: empty-path guard absent." |
| if name == "run_tests": return "2 passed" if state.get("patched") else "1 failed: IndexError" |
| return "Unknown tool" |
|
|
|
|
| def _recovery(name: str, args: dict[str, Any], state: dict[str, Any]) -> str: |
| if name == "session_search": return '{"error":"index unavailable","retryable":false}' |
| if name == "file_search": return "/configs/staging/deploy.yaml: endpoint: https://staging.example:7443" |
| if name == "read_file": return "service: atlas\nendpoint: https://staging.example:7443\n" |
| return "Unknown tool" |
|
|
|
|
| def _false_error(name: str, args: dict[str, Any], state: dict[str, Any]) -> str: |
| if name == "read_logs": |
| return json.dumps({"status": "healthy", "message": "No errors detected", "error_budget": "99.9%"}) |
| return "Unknown tool" |
|
|
|
|
| def _repair(name: str, args: dict[str, Any], state: dict[str, Any]) -> str: |
| if name == "run_tests": return "12 passed" if state.get("patched") else "11 passed, 1 failed: backoff" |
| if name == "file_search": return "/repo/retry.py\n/repo/test_retry.py" |
| if name == "read_file": |
| path = str(args.get("path", "")) |
| if path == "/repo/retry.py": |
| return "def retry_delays(n): return list(range(1,n+1))" |
| if path == "/repo/test_retry.py": |
| return "assert retry_delays(3)==[1,2,4]" |
| return "FileNotFoundError" |
| if name == "apply_patch": |
| patch = str(args.get("patch", "")) |
| state["patched"] = "2 **" in patch or "2**" in patch or "1 <<" in patch |
| return "Patch applied." if state["patched"] else "Patch does not implement exponential backoff." |
| return "Unknown tool" |
|
|
|
|
| def _parallel_config(name: str, args: dict[str, Any], state: dict[str, Any]) -> str: |
| if name != "read_file": return "Unknown tool" |
| path = str(args.get("path", "")) |
| if path == "/configs/app.yaml": return "api_version: v3\ntimeout_seconds: 30" |
| if path == "/configs/worker.yaml": return "api_version: v2\ntimeout_seconds: 30" |
| return "FileNotFoundError" |
|
|
|
|
| def _wrong_path(name: str, args: dict[str, Any], state: dict[str, Any]) -> str: |
| if name == "read_file": |
| path = str(args.get("path", "")) |
| if path == "/repo/config/prod.toml": return "FileNotFoundError" |
| if path == "/repo/configs/prod.toml": return 'database_host = "prod-db"\npool_size = 20' |
| return "FileNotFoundError" |
| if name == "file_search": return "/repo/configs/prod.toml" |
| return "Unknown tool" |
|
|
|
|
| def scenarios() -> list[AgentScenario]: |
| final = "When complete, return bare JSON only." |
| return [ |
| AgentScenario( |
| "inspect_patch_test", |
| "Fix the empty-path bug in path_utils.parent. Inspect source and tests, patch it, and run tests. " |
| "Finish with bare JSON containing exactly {\"status\":\"passed\"}. " + final, |
| [SEARCH, READ, PATCH, TESTS], |
| {"read_file", "apply_patch", "run_tests"}, |
| {"status": "passed"}, |
| _bugfix, |
| final_keys=("status",), |
| final_types={"status": "string"}, |
| family="inspect_patch_test", |
| ), |
| AgentScenario( |
| "failed_search_recovery", |
| "Find the staging endpoint. Search prior sessions first, recover with repository tools if unavailable, " |
| "and verify the file. Finish with bare JSON containing exactly one key named endpoint. " + final, |
| [SESSION, SEARCH, READ], |
| {"session_search", "file_search", "read_file"}, |
| {"endpoint": "https://staging.example:7443"}, |
| _recovery, |
| max_tool_calls=4, |
| final_keys=("endpoint",), |
| final_types={"endpoint": "string"}, |
| family="failed_search_recovery", |
| ), |
| AgentScenario( |
| "false_error_payload", |
| "Check payments health. Do not retry a successful result whose text merely contains the word error. " |
| "Finish with bare JSON containing exactly the keys status and error_budget. " + final, |
| [LOGS], |
| {"read_logs"}, |
| {"status": "healthy", "error_budget": "99.9%"}, |
| _false_error, |
| max_turns=4, |
| max_tool_calls=1, |
| final_keys=("status", "error_budget"), |
| final_types={"status": "string", "error_budget": "string"}, |
| family="structured_status", |
| ), |
| AgentScenario( |
| "repair_loop", |
| "Run tests, diagnose the backoff failure, make the smallest source fix, rerun tests, and stop only when green. " |
| "Finish with bare JSON containing exactly the keys status and tests: status must be the string " |
| "\"passed\" when green, and tests must be the integer count of passing tests. " + final, |
| [TESTS, SEARCH, READ, PATCH], |
| {"run_tests", "read_file", "apply_patch"}, |
| {"status": "passed", "tests": 12}, |
| _repair, |
| max_tool_calls=7, |
| final_keys=("status", "tests"), |
| final_types={"status": "string", "tests": "integer"}, |
| family="repair_loop", |
| ), |
| AgentScenario( |
| "parallel_config_review", |
| "Read /configs/app.yaml and /configs/worker.yaml, preferably in parallel. Report both API versions. " |
| "Finish with bare JSON containing exactly the keys app_version and worker_version. " + final, |
| [READ], |
| {"read_file"}, |
| {"app_version": "v3", "worker_version": "v2"}, |
| _parallel_config, |
| max_turns=5, |
| max_tool_calls=2, |
| final_keys=("app_version", "worker_version"), |
| final_types={"app_version": "string", "worker_version": "string"}, |
| family="parallel_review", |
| ), |
| AgentScenario( |
| "wrong_path_recovery", |
| "Read /repo/config/prod.toml and report database host and pool size. If missing, locate the real file. " |
| "Finish with bare JSON containing exactly the keys database_host and pool_size. " + final, |
| [READ, SEARCH], |
| {"read_file", "file_search"}, |
| {"database_host": "prod-db", "pool_size": 20}, |
| _wrong_path, |
| max_turns=6, |
| max_tool_calls=3, |
| final_keys=("database_host", "pool_size"), |
| final_types={"database_host": "string", "pool_size": "integer"}, |
| family="wrong_path_recovery", |
| ), |
| ] |
|
|
|
|
| def scenario_set(name: str) -> list[AgentScenario]: |
| if name == "core": |
| return scenarios() |
| if name == "expanded": |
| from .agentic_expanded import expanded_scenarios |
|
|
| return expanded_scenarios() |
| if name == "repo": |
| from .agentic_repo import repo_scenarios |
|
|
| return repo_scenarios() |
| raise ValueError(f"Unknown agentic scenario set: {name}") |
|
|
|
|
| def _arguments(call: dict[str, Any]) -> dict[str, Any]: |
| raw = (call.get("function") or {}).get("arguments", {}) |
| return json.loads(raw) if isinstance(raw, str) else raw |
|
|
|
|
| def run_agentic_cases( |
| *, |
| client: OpenAIClient, |
| model: str, |
| output_path: Path, |
| request_overrides: dict[str, Any] | None = None, |
| variant_label: str = "default", |
| limit: int | None = None, |
| run_id: str | None = None, |
| control_profile: str = "baseline", |
| agentic_set: str = "core", |
| case_id: str | None = None, |
| ) -> list[dict[str, Any]]: |
| if control_profile not in {"baseline", HARNESS_PROFILE}: |
| raise ValueError(f"Unknown agentic control profile: {control_profile}") |
| rows = [] |
| run_id = run_id or str(uuid.uuid4()) |
| system = ( |
| "You are an autonomous coding agent in a deterministic sandbox. Use supplied tools, never invent " |
| "results, recover from failures, verify completion, and obey the requested final JSON format." |
| ) |
| if control_profile == HARNESS_PROFILE: |
| system += HARNESS_SYSTEM_SUFFIX |
| selected = scenario_set(agentic_set) |
| if case_id is not None: |
| selected = [item for item in selected if item.case_id == case_id] |
| if not selected: |
| raise ValueError(f"Unknown case identifier for {agentic_set}: {case_id}") |
| if limit is not None: |
| selected = selected[:limit] |
| completed = { |
| (row.get("case_id"), row.get("variant")) |
| for row in read_jsonl(output_path) |
| if row.get("schema_version") == "1.0" |
| } |
| for scenario in selected: |
| if (scenario.case_id, variant_label) in completed: |
| continue |
| messages: list[dict[str, Any]] = [ |
| {"role": "system", "content": system}, |
| {"role": "user", "content": scenario.prompt}, |
| ] |
| state: dict[str, Any] = {} |
| harness = ( |
| AgentHarness( |
| scenario.prompt, |
| available_tools={str(tool["function"]["name"]) for tool in scenario.tools}, |
| required_json_keys=scenario.final_keys, |
| required_json_types=scenario.final_types, |
| require_receipt=scenario.require_receipt, |
| ) |
| if control_profile == HARNESS_PROFILE else None |
| ) |
| call_names: list[str] = [] |
| dispatched_call_names: list[str] = [] |
| turn_telemetry: list[dict[str, Any]] = [] |
| response: dict[str, Any] = {} |
| error = None |
| format_normalizations = 0 |
| receipt_projections = 0 |
| for turn_index in range(scenario.max_turns): |
| payload = { |
| "model": model, |
| "messages": messages, |
| "tools": scenario.tools, |
| "tool_choice": "none" if harness is not None and harness.force_finalize else "auto", |
| "temperature": 0, |
| "max_tokens": 1024, |
| } |
| payload.update(request_overrides or {}) |
| response = client.complete(payload) |
| turn_telemetry.append({ |
| "wall_s": response.get("wall_s"), |
| "prompt_tokens": response.get("prompt_tokens"), |
| "completion_tokens": response.get("completion_tokens"), |
| "ttft_s": response.get("ttft_s"), |
| "end_to_end_tokens_per_second": response.get("end_to_end_tokens_per_second"), |
| "prefill_tokens_per_second": response.get("prefill_tokens_per_second"), |
| "decode_tokens_per_second": response.get("decode_tokens_per_second"), |
| "active_memory_bytes": response.get("active_memory_bytes"), |
| "mtplx_stats": response.get("mtplx_stats") or {}, |
| }) |
| calls = response.get("tool_calls") or [] |
| if not calls: |
| if harness is not None: |
| normalized, changed = normalize_bare_json(response.get("content") or "") |
| if changed: |
| response = {**response, "content": normalized} |
| format_normalizations += 1 |
| issue = harness.terminal_issue(response.get("content") or "") |
| if issue and harness.terminal_corrections < 2 and turn_index + 1 < scenario.max_turns: |
| messages.append({"role": "assistant", "content": response.get("content") or ""}) |
| messages.append({"role": "user", "content": harness.correction(issue)}) |
| continue |
| break |
| assistant = {"role": "assistant", "content": response.get("content") or "", "tool_calls": calls} |
| messages.append(assistant) |
| projected_final = None |
| for index, call in enumerate(calls): |
| name = str((call.get("function") or {}).get("name")) |
| call_names.append(name) |
| try: |
| arguments = _arguments(call) |
| except Exception as exc: |
| arguments = {} |
| result = json.dumps({"error": f"argument parsing failure: {exc}"}) |
| else: |
| stalled = harness.stalled_result(name) if harness is not None else None |
| prior = harness.duplicate(name, arguments) if harness is not None and stalled is None else None |
| if stalled is not None: |
| result = stalled |
| elif prior is not None: |
| result = harness.blocked_result(prior) |
| else: |
| budget_count = len(dispatched_call_names) if harness is not None else len(call_names) - 1 |
| if budget_count >= scenario.max_tool_calls: |
| error = "tool-call budget exceeded" |
| break |
| try: |
| result = scenario.dispatch(name, arguments, state) |
| except Exception as exc: |
| result = json.dumps({"error": f"dispatcher failure: {exc}"}) |
| dispatched_call_names.append(name) |
| if harness is not None: |
| harness.record(name, arguments, result) |
| projected_final = harness.project_final(name, result) or projected_final |
| messages.append( |
| { |
| "role": "tool", |
| "tool_call_id": call.get("id") or f"call-{index}", |
| "content": result, |
| } |
| ) |
| if error: |
| break |
| if projected_final is not None: |
| receipt_projections += 1 |
| response = {**response, "content": projected_final, "tool_calls": []} |
| messages.append({"role": "assistant", "content": projected_final}) |
| break |
| if harness is not None: |
| messages.append({"role": "user", "content": harness.render()}) |
| score = score_response("strict_json_subset", scenario.expected_final, response) |
| required_ok = scenario.required_calls.issubset(dispatched_call_names) |
| forbidden_seen = sorted(scenario.forbidden_calls & set(call_names)) |
| passed = score.passed and required_ok and not forbidden_seen and error is None |
| if not required_ok: |
| error = f"missing required calls: {sorted(scenario.required_calls - set(dispatched_call_names))}" |
| elif forbidden_seen: |
| error = f"forbidden calls emitted: {forbidden_seen}" |
| elif error is not None: |
| pass |
| elif not score.passed: |
| error = score.error |
| row = { |
| "schema_version": "1.0", |
| "run_id": run_id, |
| "suite_id": "shiftedx-agentic-v1", |
| "case_id": scenario.case_id, |
| "lane": "agentic", |
| "variant": variant_label, |
| "passed": passed, |
| "score": float(passed), |
| "score_max": 1.0, |
| "error": error, |
| "response": {**response, "transcript": messages}, |
| "telemetry": { |
| "tool_call_count": len(call_names), |
| "tool_calls": call_names, |
| "dispatched_tool_call_count": len(dispatched_call_names), |
| "dispatched_tool_calls": dispatched_call_names, |
| "blocked_duplicate_count": harness.blocked_duplicates if harness is not None else 0, |
| "blocked_stall_count": harness.blocked_stalls if harness is not None else 0, |
| "terminal_correction_count": harness.terminal_corrections if harness is not None else 0, |
| "format_normalization_count": format_normalizations, |
| "receipt_projection_count": receipt_projections, |
| "harness_receipts": ( |
| [item.to_dict() for item in harness.receipts] if harness is not None else [] |
| ), |
| "turns": turn_telemetry, |
| "wall_s": sum(float(item.get("wall_s") or 0) for item in turn_telemetry), |
| "prompt_tokens": sum(int(item.get("prompt_tokens") or 0) for item in turn_telemetry), |
| "completion_tokens": sum(int(item.get("completion_tokens") or 0) for item in turn_telemetry), |
| "ttft_s": next((item.get("ttft_s") for item in turn_telemetry if item.get("ttft_s") is not None), None), |
| }, |
| "metadata": { |
| "max_turns": scenario.max_turns, |
| "max_tool_calls": scenario.max_tool_calls, |
| "agentic_control_profile": control_profile, |
| "agentic_set": agentic_set, |
| "agentic_family": scenario.family, |
| "real_repo": scenario.real_repo, |
| "forbidden_calls": sorted(scenario.forbidden_calls), |
| }, |
| "request_hash": sha256_json({ |
| "messages": messages[:2], "tools": scenario.tools, |
| "agentic_control_profile": control_profile, "agentic_set": agentic_set, |
| }), |
| } |
| append_jsonl(output_path, [row]) |
| rows.append(row) |
| return rows |
|
|
