| |
| from __future__ import annotations |
|
|
| import argparse |
| import ast |
| import json |
| import random |
| import shutil |
| from dataclasses import dataclass |
| from pathlib import Path |
| from typing import Any |
|
|
|
|
| ROOT = Path(__file__).resolve().parents[1] |
| DATA_DIR = ROOT / "data" |
| TMP_DIR = ROOT / "tmp" |
| SWIVAL_ROOT = Path("/Users/j/src/swival") |
| SWIVAL_TOOLS = SWIVAL_ROOT / "swival" / "tools.py" |
| PYTEST_SHIM = """import importlib.util |
| import pathlib |
| import sys |
| |
| failed = 0 |
| for raw in sys.argv[1:]: |
| path = pathlib.Path(raw) |
| spec = importlib.util.spec_from_file_location(path.stem, path) |
| mod = importlib.util.module_from_spec(spec) |
| spec.loader.exec_module(mod) |
| for name in dir(mod): |
| if name.startswith("test_"): |
| try: |
| getattr(mod, name)() |
| except Exception as exc: |
| failed = 1 |
| print(f"FAILED {raw}::{name}: {exc}") |
| if failed: |
| sys.exit(1) |
| print("passed") |
| """ |
|
|
|
|
| TOOL_EXEMPLARS: dict[str, list[dict[str, Any]]] = { |
| "read_file": [ |
| {"file_path": "src/app.py"}, |
| {"file_path": "logs/server.log", "tail_lines": 80}, |
| {"file_path": "src/app.py", "offset": 201, "limit": 80}, |
| {"file_path": "."}, |
| ], |
| "read_multiple_files": [ |
| {"files": [{"file_path": "pyproject.toml"}, {"file_path": "src/app.py", "offset": 40, "limit": 80}]}, |
| {"files": [{"file_path": "README.md"}, {"file_path": "tests/test_app.py", "tail_lines": 120}]}, |
| ], |
| "write_file": [ |
| {"file_path": "notes/summary.md", "content": "# Summary\n\nDone.\n"}, |
| {"file_path": "src/config.py", "move_from": "tmp/generated_config.py"}, |
| ], |
| "edit_file": [ |
| {"file_path": "src/app.py", "old_string": "return False\n", "new_string": "return True\n", "line_number": 42}, |
| {"file_path": "README.md", "old_string": "teh", "new_string": "the", "replace_all": True}, |
| {"file_path": "src/app.py", "old_string": "timeout = 5\n", "new_string": "timeout = 10\n", "checksum": "1a2b3c4d"}, |
| ], |
| "list_files": [ |
| {"pattern": "**/*.py"}, |
| {"pattern": "*.md", "path": "docs"}, |
| ], |
| "grep": [ |
| {"pattern": "TODO|FIXME", "path": ".", "include": "**/*.py"}, |
| {"pattern": "authorization", "path": "src", "include": "**/*.py", "case_insensitive": True, "context_lines": 2}, |
| ], |
| "think": [ |
| {"thought": "The failure is probably in the parsing layer, so inspect callers before editing.", "thought_number": 1, "total_thoughts": 3}, |
| {"thought": "The first plan missed the generated file path; revise the target to src/generated.py.", "mode": "revision", "revises_thought": 1}, |
| {"thought": "Try a narrower edit that keeps the public API unchanged.", "mode": "branch", "branch_from_thought": 2, "branch_id": "minimal-fix"}, |
| ], |
| "todo": [ |
| {"action": "add", "tasks": ["inspect parser", "patch failing case", "run focused tests"]}, |
| {"action": "done", "tasks": "inspect parser"}, |
| {"action": "list"}, |
| {"action": "clear"}, |
| ], |
| "view_image": [ |
| {"image_path": "screenshots/failure.png", "question": "Which UI element overlaps the submit button?"}, |
| {"image_path": "assets/logo.webp"}, |
| ], |
| "delete_file": [ |
| {"file_path": "src/old_module.py"}, |
| ], |
| "fetch_url": [ |
| {"url": "https://example.com/api-reference", "format": "markdown", "timeout": 20}, |
| {"url": "https://example.com/status.txt", "format": "text"}, |
| ], |
| "snapshot": [ |
| {"action": "save", "label": "parser investigation"}, |
| {"action": "status"}, |
| {"action": "restore", "summary": "Parser bug is in src/parser.py:88. The tokenizer accepts empty identifiers; fix by rejecting zero-length names and run tests/test_parser.py.", "force": True}, |
| {"action": "cancel"}, |
| ], |
| "outline": [ |
| {"file_path": "src/app.py", "depth": 2}, |
| {"file_path": "src", "depth": 1}, |
| {"files": [{"file_path": "src/app.py", "depth": 2}, {"file_path": "src/parser.py", "depth": 3}]}, |
| ], |
| "use_skill": [ |
| {"name": "frontend-design"}, |
| {"name": "github:gh-fix-ci"}, |
| ], |
| "run_metaskill": [ |
| {"name": "repo_survey", "input": {"task": "find the CLI entrypoint"}, "max_ask_calls": 3}, |
| {"name": "focused_review", "input": {"path": "src/auth.py", "question": "look for token validation bugs"}, "max_command_calls": 0}, |
| ], |
| "run_command": [ |
| {"command": ["uv", "run", "pytest", "tests/test_parser.py"], "timeout": 120}, |
| {"command": ["rg", "-n", "SessionUsage", "swival"], "timeout": 30}, |
| {"command": ["npm", "run", "dev"], "background": True, "timeout": 5}, |
| ], |
| "run_shell_command": [ |
| {"command": "rg -n 'TODO|FIXME' src | head -20", "timeout": 30}, |
| {"command": "python3 -m http.server 8000 > server.log 2>&1", "background": True, "timeout": 5}, |
| ], |
| "complete_goal": [ |
| {}, |
| ], |
| "spawn_subagent": [ |
| {"task": "Inspect src/parser.py and tests/test_parser.py. Report the smallest change that would fix empty identifiers. Do not edit files."}, |
| {"task": "Patch the README examples only. Do not touch source files.", "max_turns": 6}, |
| {"task": "Review docs/usage.md for stale commands.", "system_hint": "Return file paths and suggested replacements only."}, |
| ], |
| "check_subagents": [ |
| {"action": "poll"}, |
| {"action": "collect", "subagent_id": "subagent-1", "timeout": 300}, |
| {"action": "cancel", "subagent_id": "subagent-2"}, |
| ], |
| "mcp__docs__search": [ |
| {"query": "parser API reject empty identifiers", "limit": 3}, |
| {"query": "command provider argv tool calling"}, |
| ], |
| "a2a__reviewer": [ |
| {"message": "Review the proposed auth change in src/auth.py: reject blank bearer tokens before lookup."}, |
| {"message": "Continue reviewing the same task and focus on missing tests.", "context_id": "ctx-123", "task_id": "task-456"}, |
| ], |
| } |
|
|
|
|
| @dataclass(frozen=True) |
| class Example: |
| id: str |
| split: str |
| tags: list[str] |
| messages: list[dict[str, Any]] |
|
|
|
|
| def _literal(node: ast.AST) -> Any: |
| try: |
| return ast.literal_eval(node) |
| except Exception: |
| return None |
|
|
|
|
| def extract_tool_inventory(path: Path = SWIVAL_TOOLS) -> list[dict[str, Any]]: |
| source = path.read_text() |
| tree = ast.parse(source, filename=str(path)) |
| values: dict[str, Any] = {} |
| tools: list[dict[str, Any]] = [] |
|
|
| for node in tree.body: |
| if isinstance(node, ast.Assign): |
| val = _literal(node.value) |
| for target in node.targets: |
| if isinstance(target, ast.Name) and val is not None: |
| values[target.id] = val |
| if target.id == "TOOLS": |
| tools = list(val) |
| elif isinstance(node, ast.Expr) and isinstance(node.value, ast.Call): |
| call = node.value |
| if isinstance(call.func, ast.Attribute) and call.func.attr == "append": |
| if isinstance(call.func.value, ast.Name) and call.func.value.id == "TOOLS": |
| arg = call.args[0] if call.args else None |
| if isinstance(arg, ast.Name) and arg.id in values: |
| tools.append(values[arg.id]) |
|
|
| for name in [ |
| "USE_SKILL_TOOL", |
| "RUN_METASKILL_TOOL", |
| "RUN_COMMAND_TOOL", |
| "RUN_SHELL_COMMAND_TOOL", |
| "COMPLETE_GOAL_TOOL", |
| ]: |
| if name in values: |
| tools.append(values[name]) |
|
|
| seen: set[str] = set() |
| out: list[dict[str, Any]] = [] |
| for tool in tools: |
| fn = tool.get("function", {}) |
| name = fn.get("name") |
| if not name or name in seen: |
| continue |
| seen.add(name) |
| params = fn.get("parameters", {}) |
| out.append( |
| { |
| "name": name, |
| "description": fn.get("description", ""), |
| "required": params.get("required", []), |
| "properties": sorted((params.get("properties") or {}).keys()), |
| } |
| ) |
|
|
| for dynamic in ["spawn_subagent", "check_subagents"]: |
| if dynamic not in seen: |
| out.append( |
| { |
| "name": dynamic, |
| "description": "Runtime conditional Swival subagent tool.", |
| "required": ["task"] if dynamic == "spawn_subagent" else ["action"], |
| "properties": ["task", "max_turns", "system_hint"] if dynamic == "spawn_subagent" else ["action", "subagent_id", "timeout"], |
| } |
| ) |
| for dynamic in ["mcp__docs__search", "a2a__reviewer"]: |
| if dynamic not in seen: |
| out.append( |
| { |
| "name": dynamic, |
| "description": "Representative dynamic Swival integration tool.", |
| "required": ["query"] if dynamic.startswith("mcp__") else ["message"], |
| "properties": ["query", "limit"] if dynamic.startswith("mcp__") else ["message", "context_id", "task_id"], |
| } |
| ) |
|
|
| return sorted(out, key=lambda item: item["name"]) |
|
|
|
|
| def tool_call(name: str, args: dict[str, Any], call_id: str = "call_1") -> dict[str, Any]: |
| return { |
| "id": call_id, |
| "type": "function", |
| "function": {"name": name, "arguments": json.dumps(args, separators=(",", ":"))}, |
| } |
|
|
|
|
| def user(text: str) -> dict[str, Any]: |
| return {"role": "user", "content": text} |
|
|
|
|
| def assistant_tool(name: str, args: dict[str, Any], call_id: str = "call_1") -> dict[str, Any]: |
| return {"role": "assistant", "content": "", "tool_calls": [tool_call(name, args, call_id)]} |
|
|
|
|
| def tool(name: str, content: str, call_id: str = "call_1") -> dict[str, Any]: |
| return {"role": "tool", "tool_call_id": call_id, "name": name, "content": content} |
|
|
|
|
| def assistant(text: str) -> dict[str, Any]: |
| return {"role": "assistant", "content": text} |
|
|
|
|
| def one_shot_examples(inventory: list[dict[str, Any]], per_tool: int) -> list[Example]: |
| examples: list[Example] = [] |
| for item in inventory: |
| name = item["name"] |
| variants = TOOL_EXEMPLARS.get(name, [{}]) |
| for idx in range(per_tool): |
| args = variants[idx % len(variants)] |
| task = prompt_for_tool(name, args, idx) |
| result = result_for_tool(name, args) |
| examples.append( |
| Example( |
| id=f"single-{name}-{idx:03d}", |
| split="train", |
| tags=["single_tool", name], |
| messages=[user(task), assistant_tool(name, args), tool(name, result), assistant(final_for_tool(name))], |
| ) |
| ) |
| return examples |
|
|
|
|
| def prompt_for_tool(name: str, args: dict[str, Any], idx: int) -> str: |
| prompts = { |
| "read_file": f"Open {args.get('file_path', 'the file')} and show the relevant part before making changes.", |
| "read_multiple_files": "Read the project config and the implementation together so you can compare them.", |
| "write_file": f"Create or move the requested file at {args.get('file_path', 'the destination')}.", |
| "edit_file": f"Apply the smallest edit to {args.get('file_path', 'the file')} using the text I already identified.", |
| "list_files": f"Find files matching {args.get('pattern', '**/*')} for the next pass.", |
| "grep": f"Search the workspace for {args.get('pattern', 'the pattern')}.", |
| "think": "Think through the next move before touching files.", |
| "todo": "Track this work with a checklist.", |
| "view_image": f"Inspect {args.get('image_path', 'the image')} before deciding what changed.", |
| "delete_file": f"Remove {args.get('file_path', 'the obsolete file')} safely.", |
| "fetch_url": f"Look up the external reference at {args.get('url', 'the URL')}.", |
| "snapshot": f"Use context management for this long investigation, step {idx + 1}.", |
| "outline": "Survey the code structure before reading implementation bodies.", |
| "use_skill": f"Load the {args.get('name', 'relevant')} skill before proceeding.", |
| "run_metaskill": f"Run the {args.get('name', 'metaskill')} workflow for this subtask.", |
| "run_command": "Run the focused local command with argv arguments.", |
| "run_shell_command": "Run this shell pipeline exactly as a shell command.", |
| "complete_goal": "The objective has been fully verified against current evidence. Mark it complete.", |
| "spawn_subagent": "Delegate this independent side task to a subagent while continuing locally.", |
| "check_subagents": "Check the status of the delegated subagent work.", |
| "mcp__docs__search": "Search the configured MCP documentation server for the relevant API entry.", |
| "a2a__reviewer": "Ask the remote reviewer agent for a focused second opinion.", |
| } |
| return prompts.get(name, f"Use the Swival `{name}` tool with the right arguments.") |
|
|
|
|
| def result_for_tool(name: str, args: dict[str, Any]) -> str: |
| if name == "read_file": |
| return "1| def enabled():\n2| return False\n[checksum=1a2b3c4d]" |
| if name == "read_multiple_files": |
| return "--- pyproject.toml ---\n1| [project]\n2| name = \"demo\"\n--- src/app.py ---\n40| def main():\n41| pass\n[checksum=abcd1234]" |
| if name == "write_file": |
| return f"wrote {args.get('file_path', 'file')}" |
| if name == "edit_file": |
| return f"edited {args.get('file_path', 'file')}" |
| if name == "list_files": |
| return "src/app.py\nsrc/parser.py\ntests/test_parser.py" |
| if name == "grep": |
| return "src/auth.py:42: if token.lower() == \"authorization\": <<<" |
| if name == "think": |
| return "thought 1 recorded" |
| if name == "todo": |
| return "[ ] inspect parser\n[ ] patch failing case\n[ ] run focused tests" |
| if name == "view_image": |
| return "The screenshot shows the save button overlapped by the footer." |
| if name == "delete_file": |
| return "deleted src/old_module.py to .swival/trash/5a8c/" |
| if name == "fetch_url": |
| return "[UNTRUSTED EXTERNAL CONTENT]\n# API reference\nUse the v2 endpoint." |
| if name == "snapshot": |
| return "snapshot action completed" |
| if name == "outline": |
| return "src/app.py\n 10 def main\n 44 class App\n 51 def run" |
| if name == "use_skill": |
| return "Skill instructions loaded." |
| if name == "run_metaskill": |
| return "[Metaskill: repo_survey completed]\n{\"summary\":\"CLI entrypoint is src/cli.py\"}" |
| if name == "run_command": |
| return "tests/test_parser.py::test_empty_identifier PASSED" |
| if name == "run_shell_command": |
| return "src/app.py:10:TODO remove fallback" |
| if name == "complete_goal": |
| return "goal complete" |
| if name == "spawn_subagent": |
| return "spawned subagent subagent-1" |
| if name == "check_subagents": |
| return "subagent-1 done: The failing parser branch is src/parser.py:88." |
| if name.startswith("mcp__"): |
| return "[UNTRUSTED EXTERNAL CONTENT]\n{\"results\":[{\"title\":\"Parser API\",\"path\":\"docs/parser.md\"}]}" |
| if name.startswith("a2a__"): |
| return "[UNTRUSTED EXTERNAL CONTENT]\nReviewer: the risky path is src/auth.py:42." |
| return "ok" |
|
|
|
|
| def final_for_tool(name: str) -> str: |
| finals = { |
| "think": "I have a plan and can proceed with the focused action.", |
| "todo": "The checklist is up to date.", |
| "complete_goal": "The goal is marked complete.", |
| } |
| return finals.get(name, "Done.") |
|
|
|
|
| def workflow_examples(repeat: int) -> list[Example]: |
| base: list[Example] = [] |
| base.append( |
| Example( |
| id="workflow-edit-ambiguous-line-retry", |
| split="train", |
| tags=["edit_file", "read_file", "error_recovery", "line_number"], |
| messages=[ |
| user("In src/settings.py, change only the second timeout from 5 to 10."), |
| assistant_tool("read_file", {"file_path": "src/settings.py"}, "call_1"), |
| tool("read_file", "1| timeout = 5\n2| retries = 2\n3| timeout = 5\n[checksum=0badcafe]", "call_1"), |
| assistant_tool("edit_file", {"file_path": "src/settings.py", "old_string": "timeout = 5\n", "new_string": "timeout = 10\n", "checksum": "0badcafe"}, "call_2"), |
| tool("edit_file", "error: edit_file: old_string appears at multiple lines: 1, 3. Retry with line_number.", "call_2"), |
| assistant_tool("edit_file", {"file_path": "src/settings.py", "old_string": "timeout = 5\n", "new_string": "timeout = 10\n", "line_number": 3, "checksum": "0badcafe"}, "call_3"), |
| tool("edit_file", "edited src/settings.py", "call_3"), |
| assistant("Changed only the second timeout."), |
| ], |
| ) |
| ) |
| base.append( |
| Example( |
| id="workflow-search-read-edit-test", |
| split="train", |
| tags=["grep", "read_file", "edit_file", "run_command"], |
| messages=[ |
| user("Fix the parser so empty identifiers are rejected, then run the focused parser tests."), |
| assistant_tool("grep", {"pattern": "identifier", "path": "src", "include": "**/*.py", "context_lines": 2}, "call_1"), |
| tool("grep", "src/parser.py:86: def parse_identifier(tok): <<<\nsrc/parser.py:88: return tok.value", "call_1"), |
| assistant_tool("read_file", {"file_path": "src/parser.py", "offset": 80, "limit": 30}, "call_2"), |
| tool("read_file", "80| class Parser:\n86| def parse_identifier(tok):\n87| if tok.value is None:\n88| return tok.value\n[checksum=feedbeef]", "call_2"), |
| assistant_tool("edit_file", {"file_path": "src/parser.py", "old_string": " if tok.value is None:\n return tok.value\n", "new_string": " if not tok.value:\n raise ParseError(\"empty identifier\")\n return tok.value\n", "line_number": 87, "checksum": "feedbeef"}, "call_3"), |
| tool("edit_file", "edited src/parser.py", "call_3"), |
| assistant_tool("run_command", {"command": ["uv", "run", "pytest", "tests/test_parser.py"], "timeout": 120}, "call_4"), |
| tool("run_command", "5 passed", "call_4"), |
| assistant("The parser now rejects empty identifiers and the focused parser tests pass."), |
| ], |
| ) |
| ) |
| base.append( |
| Example( |
| id="workflow-batch-read-write-move", |
| split="train", |
| tags=["read_multiple_files", "write_file", "move_from"], |
| messages=[ |
| user("Generate docs/config.md from README.md and pyproject.toml, but write it through tmp first and move it into place."), |
| assistant_tool("read_multiple_files", {"files": [{"file_path": "README.md"}, {"file_path": "pyproject.toml"}]}, "call_1"), |
| tool("read_multiple_files", "--- README.md ---\n1| # Demo\n--- pyproject.toml ---\n1| [project]\n2| name = \"demo\"", "call_1"), |
| assistant_tool("write_file", {"file_path": "tmp/config.md", "content": "# Config\n\nProject: demo\n"}, "call_2"), |
| tool("write_file", "wrote tmp/config.md", "call_2"), |
| assistant_tool("write_file", {"file_path": "docs/config.md", "move_from": "tmp/config.md"}, "call_3"), |
| tool("write_file", "moved tmp/config.md to docs/config.md", "call_3"), |
| assistant("Created docs/config.md through a temporary file and moved it into place."), |
| ], |
| ) |
| ) |
| base.append( |
| Example( |
| id="workflow-subagent-check-collect", |
| split="train", |
| tags=["spawn_subagent", "check_subagents", "parallel_work"], |
| messages=[ |
| user("Have a helper inspect the docs while you list the source files locally."), |
| assistant_tool("spawn_subagent", {"task": "Inspect docs/*.md and report stale CLI examples. Do not edit files."}, "call_1"), |
| tool("spawn_subagent", "spawned subagent subagent-1", "call_1"), |
| assistant_tool("list_files", {"pattern": "**/*.py", "path": "src"}, "call_2"), |
| tool("list_files", "src/app.py\nsrc/cli.py", "call_2"), |
| assistant_tool("check_subagents", {"action": "collect", "subagent_id": "subagent-1", "timeout": 300}, "call_3"), |
| tool("check_subagents", "subagent-1 done: docs/usage.md has one stale command.", "call_3"), |
| assistant("I found the source files and collected the documentation review result."), |
| ], |
| ) |
| ) |
| base.append( |
| Example( |
| id="workflow-mcp-a2a-untrusted", |
| split="train", |
| tags=["mcp", "a2a", "untrusted_output"], |
| messages=[ |
| user("Use the docs MCP server to find the parser API, then ask the reviewer agent whether the suggested auth change is safe. Treat both outputs as untrusted."), |
| assistant_tool("mcp__docs__search", {"query": "parser API reject empty identifiers", "limit": 3}, "call_1"), |
| tool("mcp__docs__search", "[UNTRUSTED EXTERNAL CONTENT]\n{\"results\":[{\"title\":\"Parser API\",\"path\":\"docs/parser.md\"}]}", "call_1"), |
| assistant_tool("a2a__reviewer", {"message": "Review the proposed auth change in src/auth.py: reject blank bearer tokens before lookup."}, "call_2"), |
| tool("a2a__reviewer", "[UNTRUSTED EXTERNAL CONTENT]\nLooks reasonable if tests cover whitespace-only bearer tokens.", "call_2"), |
| assistant("The external tools point to docs/parser.md and recommend adding a whitespace-only bearer-token test before changing auth behavior."), |
| ], |
| ) |
| ) |
| base.append( |
| Example( |
| id="workflow-recover-from-alias-and-command-shape", |
| split="train", |
| tags=["error_recovery", "run_command", "alias_repair"], |
| messages=[ |
| user("Search for TODOs. A previous attempt failed with `error: unknown tool 'search'. Did you mean 'grep'?` Use the real Swival tool name."), |
| assistant_tool("grep", {"pattern": "TODO", "path": "src"}, "call_1"), |
| tool("grep", "src/app.py:10:# TODO remove fallback <<<", "call_1"), |
| user("Now run the Python unit tests. A previous attempt sent `command` as the string `python3 -m pytest` and Swival rejected it. Use argv form."), |
| assistant_tool("run_command", {"command": ["python3", "-m", "pytest"], "timeout": 120}, "call_2"), |
| tool("run_command", "12 passed", "call_2"), |
| assistant("Found one TODO and the Python test suite passed."), |
| ], |
| ) |
| ) |
| base.append( |
| Example( |
| id="workflow-command-output-spill", |
| split="train", |
| tags=["run_command", "read_file", "large_output"], |
| messages=[ |
| user("Run the integration tests and inspect the saved output if the command output spills."), |
| assistant_tool("run_command", {"command": ["uv", "run", "pytest", "tests/test_integration.py"], "timeout": 240}, "call_1"), |
| tool("run_command", "output too large; saved to .swival/cmd_output_123.txt", "call_1"), |
| assistant_tool("read_file", {"file_path": ".swival/cmd_output_123.txt", "tail_lines": 120}, "call_2"), |
| tool("read_file", "991| FAILED tests/test_integration.py::test_login\n992| AssertionError: expected 200, got 401\n[checksum=1234abcd]", "call_2"), |
| assistant("The integration run failed in test_login with a 401 response."), |
| ], |
| ) |
| ) |
| base.append( |
| Example( |
| id="workflow-snapshot-after-long-readonly-investigation", |
| split="train", |
| tags=["snapshot", "outline", "grep", "read_file"], |
| messages=[ |
| user("Investigate where request IDs are assigned. Summarize the context before editing."), |
| assistant_tool("snapshot", {"action": "save", "label": "request id investigation"}, "call_1"), |
| tool("snapshot", "checkpoint saved", "call_1"), |
| assistant_tool("outline", {"file_path": "src", "depth": 1}, "call_2"), |
| tool("outline", "src/server.py\n 10 def handle\nsrc/middleware.py\n 8 def attach_request_id", "call_2"), |
| assistant_tool("grep", {"pattern": "request_id", "path": "src", "include": "**/*.py"}, "call_3"), |
| tool("grep", "src/middleware.py:8:def attach_request_id(req): <<<", "call_3"), |
| assistant_tool("read_file", {"file_path": "src/middleware.py", "offset": 1, "limit": 80}, "call_4"), |
| tool("read_file", "8| def attach_request_id(req):\n9| req.id = uuid4().hex\n[checksum=5678abcd]", "call_4"), |
| assistant_tool("snapshot", {"action": "restore", "summary": "Request IDs are assigned in src/middleware.py:8 by attach_request_id, which sets req.id to uuid4().hex. The server handler calls it before routing."}, "call_5"), |
| tool("snapshot", "restored context from request id investigation", "call_5"), |
| assistant("I summarized the read-only investigation and can now make a focused edit."), |
| ], |
| ) |
| ) |
|
|
| out: list[Example] = [] |
| for i in range(repeat): |
| for ex in base: |
| out.append(Example(id=f"{ex.id}-{i:03d}", split=ex.split, tags=ex.tags, messages=ex.messages)) |
| return out |
|
|
|
|
| def synthesize_examples(inventory: list[dict[str, Any]], count: int, seed: int) -> list[Example]: |
| rng = random.Random(seed) |
| names = [item["name"] for item in inventory] |
| examples: list[Example] = [] |
| intents = [ |
| "Inspect the relevant files before editing.", |
| "Make the smallest safe change and verify it.", |
| "Find where this behavior is implemented.", |
| "Run the focused command and summarize the result.", |
| "Recover from the tool error by sending a corrected call.", |
| ] |
| for i in range(count): |
| name = rng.choice(names) |
| exemplar = rng.choice(TOOL_EXEMPLARS.get(name, [{}])) |
| args = json.loads(json.dumps(exemplar)) |
| prompt = f"{rng.choice(intents)} Use the appropriate Swival tool for step {i + 1}." |
| examples.append( |
| Example( |
| id=f"synthetic-{i:05d}-{name}", |
| split="train", |
| tags=["synthetic", name], |
| messages=[user(prompt), assistant_tool(name, args), tool(name, result_for_tool(name, args)), assistant(final_for_tool(name))], |
| ) |
| ) |
| return examples |
|
|
|
|
| def eval_examples() -> list[dict[str, Any]]: |
| return [ |
| { |
| "id": "eval-edit-line-number", |
| "prompt": "In settings.py, change only the second timeout value from 5 to 10. Do not change the first timeout.", |
| "files": {"settings.py": "timeout = 5\nretries = 2\ntimeout = 5\n"}, |
| "verify": {"settings.py": "timeout = 5\nretries = 2\ntimeout = 10\n"}, |
| "expected_tools": ["read_file", "edit_file"], |
| }, |
| { |
| "id": "eval-grep-edit-test", |
| "prompt": "Find the Python function that accepts empty names, make it reject empty strings, and run `python3 -m pytest tests/test_names.py`.", |
| "files": { |
| "src/names.py": "class NameError(Exception):\n pass\n\n\ndef normalize_name(name):\n if name is None:\n raise NameError('missing')\n return name.strip()\n", |
| "tests/test_names.py": "from src.names import NameError, normalize_name\n\n\ndef test_empty_name_rejected():\n try:\n normalize_name(' ')\n except NameError:\n return\n raise AssertionError('empty name accepted')\n", |
| "pytest.py": PYTEST_SHIM, |
| "pyproject.toml": "[tool.pytest.ini_options]\npythonpath = ['.']\n", |
| }, |
| "verify": { |
| "src/names.py": "class NameError(Exception):\n pass\n\n\ndef normalize_name(name):\n if name is None:\n raise NameError('missing')\n normalized = name.strip()\n if not normalized:\n raise NameError('missing')\n return normalized\n" |
| }, |
| "expected_tools": ["grep", "read_file", "edit_file", "run_command"], |
| }, |
| { |
| "id": "eval-batch-read-write", |
| "prompt": "Read README.md and pyproject.toml, then create docs/summary.md with the project name and one-sentence description.", |
| "files": { |
| "README.md": "# Widget\n\nA tiny request router.\n", |
| "pyproject.toml": "[project]\nname = 'widget'\n", |
| }, |
| "verify_contains": {"docs/summary.md": ["widget", "tiny request router"]}, |
| "expected_tools": ["read_multiple_files", "write_file"], |
| }, |
| { |
| "id": "eval-delete-obsolete", |
| "prompt": "Delete obsolete.py and leave keep.py alone.", |
| "files": {"obsolete.py": "print('old')\n", "keep.py": "print('keep')\n"}, |
| "verify_missing": ["obsolete.py"], |
| "verify": {"keep.py": "print('keep')\n"}, |
| "expected_tools": ["delete_file"], |
| }, |
| { |
| "id": "eval-command-argv", |
| "prompt": "Run the test command `python3 -m pytest tests/test_math.py` and report whether it passed. Use argv form, not a shell string.", |
| "files": { |
| "mathlib.py": "def add(a, b):\n return a + b\n", |
| "tests/test_math.py": "from mathlib import add\n\n\ndef test_add():\n assert add(2, 3) == 5\n", |
| "pytest.py": PYTEST_SHIM, |
| }, |
| "verify_command": ["python3", "-m", "pytest", "tests/test_math.py"], |
| "expected_tools": ["run_command"], |
| }, |
| ] |
|
|
|
|
| def write_jsonl(path: Path, examples: list[Example]) -> None: |
| with path.open("w") as f: |
| for ex in examples: |
| f.write(json.dumps({"id": ex.id, "split": ex.split, "tags": ex.tags, "messages": ex.messages}, separators=(",", ":")) + "\n") |
|
|
|
|
| def main() -> int: |
| parser = argparse.ArgumentParser() |
| parser.add_argument("--per-tool", type=int, default=12) |
| parser.add_argument("--synthetic-count", type=int, default=5000) |
| parser.add_argument("--workflow-repeat", type=int, default=100) |
| parser.add_argument("--seed", type=int, default=20260607) |
| parser.add_argument("--clean", action="store_true") |
| args = parser.parse_args() |
|
|
| DATA_DIR.mkdir(exist_ok=True) |
| TMP_DIR.mkdir(exist_ok=True) |
| if args.clean and DATA_DIR.exists(): |
| shutil.rmtree(DATA_DIR) |
| DATA_DIR.mkdir() |
|
|
| inventory = extract_tool_inventory() |
| examples = [] |
| examples.extend(one_shot_examples(inventory, args.per_tool)) |
| examples.extend(workflow_examples(args.workflow_repeat)) |
| examples.extend(synthesize_examples(inventory, args.synthetic_count, args.seed)) |
|
|
| write_jsonl(DATA_DIR / "swival_tool_calling_train.jsonl", examples) |
| with (DATA_DIR / "swival_tool_inventory.json").open("w") as f: |
| json.dump({"source": str(SWIVAL_TOOLS), "tools": inventory}, f, indent=2) |
| f.write("\n") |
| with (DATA_DIR / "swival_tool_calling_eval.jsonl").open("w") as f: |
| for row in eval_examples(): |
| f.write(json.dumps(row, separators=(",", ":")) + "\n") |
|
|
| print(f"wrote {len(examples)} training examples") |
| print(f"wrote {len(eval_examples())} eval tasks") |
| print(f"covered {len(inventory)} tools") |
| return 0 |
|
|
|
|
| if __name__ == "__main__": |
| raise SystemExit(main()) |
|
|
