| |
| """Build a public Hermes-agentic SFT corpus (synthetic, Apache-2.0). |
| |
| Teaches models to call Hermes tools correctly and STOP — not to loop. |
| No third-party distill, no live home-directory traces. |
| """ |
| from __future__ import annotations |
|
|
| import hashlib |
| import json |
| import random |
| from pathlib import Path |
|
|
| ROOT = Path(__file__).resolve().parents[1] |
| DATA = ROOT / "data" |
| RNG = random.Random(20260813) |
|
|
| TOOLS = { |
| "terminal": { |
| "type": "function", |
| "function": { |
| "name": "terminal", |
| "description": "Execute a shell command. Do not repeat a command whose output you already have.", |
| "parameters": { |
| "type": "object", |
| "properties": { |
| "command": {"type": "string", "description": "The command to execute"}, |
| "timeout": {"type": "integer", "minimum": 1}, |
| "workdir": {"type": "string"}, |
| }, |
| "required": ["command"], |
| }, |
| }, |
| }, |
| "read_file": { |
| "type": "function", |
| "function": { |
| "name": "read_file", |
| "description": "Read a text file.", |
| "parameters": { |
| "type": "object", |
| "properties": { |
| "path": {"type": "string"}, |
| "offset": {"type": "integer"}, |
| "limit": {"type": "integer"}, |
| }, |
| "required": ["path"], |
| }, |
| }, |
| }, |
| "search_files": { |
| "type": "function", |
| "function": { |
| "name": "search_files", |
| "description": "Search file contents or names.", |
| "parameters": { |
| "type": "object", |
| "properties": { |
| "pattern": {"type": "string"}, |
| "path": {"type": "string"}, |
| "target": {"type": "string", "enum": ["content", "files"]}, |
| }, |
| "required": ["pattern"], |
| }, |
| }, |
| }, |
| "write_file": { |
| "type": "function", |
| "function": { |
| "name": "write_file", |
| "description": "Write a text file. Overwrites the entire file.", |
| "parameters": { |
| "type": "object", |
| "properties": { |
| "path": {"type": "string"}, |
| "content": {"type": "string"}, |
| }, |
| "required": ["path", "content"], |
| }, |
| }, |
| }, |
| "web_search": { |
| "type": "function", |
| "function": { |
| "name": "web_search", |
| "description": "Search the public web. One good search is enough; do not retry an identical query.", |
| "parameters": { |
| "type": "object", |
| "properties": {"query": {"type": "string"}, "limit": {"type": "integer"}}, |
| "required": ["query"], |
| }, |
| }, |
| }, |
| "web_extract": { |
| "type": "function", |
| "function": { |
| "name": "web_extract", |
| "description": "Fetch a URL as text. Not a search engine.", |
| "parameters": { |
| "type": "object", |
| "properties": {"urls": {"type": "array", "items": {"type": "string"}}}, |
| "required": ["urls"], |
| }, |
| }, |
| }, |
| "todo": { |
| "type": "function", |
| "function": { |
| "name": "todo", |
| "description": "Write or update an in-session task list.", |
| "parameters": { |
| "type": "object", |
| "properties": { |
| "todos": {"type": "array"}, |
| "merge": {"type": "boolean"}, |
| }, |
| "required": ["todos"], |
| }, |
| }, |
| }, |
| } |
|
|
| CORE = ["terminal", "read_file", "search_files", "write_file", "web_search"] |
|
|
|
|
| def tc(i: str, name: str, args: dict) -> dict: |
| return { |
| "id": i, |
| "type": "function", |
| "function": {"name": name, "arguments": json.dumps(args, separators=(",", ":"))}, |
| } |
|
|
|
|
| def row(tag: str, messages: list, tool_names: list[str], extra: str = "") -> dict: |
| seq = next_seq() |
| blob = json.dumps({"tag": tag, "messages": messages, "x": extra, "n": seq}, sort_keys=True) |
| rid = hashlib.sha1(blob.encode()).hexdigest()[:12] |
| return { |
| "id": f"{tag}-{seq:04d}-{rid}", |
| "tag": tag, |
| "source": "synthetic-hermes-v1", |
| "license": "apache-2.0", |
| "messages": messages, |
| "tools": [TOOLS[n] for n in tool_names], |
| } |
|
|
|
|
| _SEQ = 0 |
|
|
|
|
| def next_seq() -> int: |
| global _SEQ |
| _SEQ += 1 |
| return _SEQ |
|
|
|
|
| PROJECTS = [ |
| ("demo", ["README.md", "src/app.py", "data/config.yaml"], "8084"), |
| ("api", ["README.md", "app/main.py", "config/settings.toml"], "8000"), |
| ("bot", ["README.md", "hermes_bot.py", "env.example"], "8083"), |
| ("web", ["README.md", "frontend/index.html", "nginx.conf"], "443"), |
| ("ml", ["README.md", "train.py", "configs/base.yaml"], "6006"), |
| ("cli", ["README.md", "src/cli.py", "pyproject.toml"], "0"), |
| ("gate", ["README.md", "hermes_loop_gate.py", "docs/serve.md"], "8084"), |
| ("agent", ["README.md", "agent/loop.py", "prompts/system.md"], "11434"), |
| ("svc", ["README.md", "service.py", "deploy/compose.yml"], "9090"), |
| ("lib", ["README.md", "src/lib.rs", "Cargo.toml"], "0"), |
| ] |
|
|
| QUERIES = [ |
| ("latest stable Python 3", "Python 3.14.6 is the latest stable release.", "3.14.6"), |
| ("Hermes Agent tool calling", "Hermes Agent uses OpenAI-style tools= / tool_calls.", "OpenAI tool_calls"), |
| ("Muse Glimmer context length", "Muse Glimmer documents a 131K context window.", "131K"), |
| ("llama.cpp server OpenAI API", "llama-server exposes POST /v1/chat/completions.", "/v1/chat/completions"), |
| ("current UTC date", "The cited page lists Thursday, 13 August 2026.", "13 August 2026"), |
| ] |
|
|
|
|
| def stop_ls() -> dict: |
| name, files, _ = RNG.choice(PROJECTS) |
| listing = "\n".join(files) + "\n" |
| return row( |
| "stop", |
| [ |
| {"role": "user", "content": f"List files in the {name} workspace. Then stop and name them. Do not list again."}, |
| {"role": "assistant", "tool_calls": [tc("c1", "terminal", {"command": RNG.choice(["ls", "ls -la", "dir"])})]}, |
| {"role": "tool", "tool_call_id": "c1", "content": listing}, |
| {"role": "assistant", "content": "Files: " + ", ".join(files) + "."}, |
| ], |
| ["terminal", "search_files", "read_file"], |
| name, |
| ) |
|
|
|
|
| def stop_read() -> dict: |
| name, files, port = RNG.choice(PROJECTS) |
| path = files[-1] |
| return row( |
| "stop", |
| [ |
| {"role": "user", "content": f"Read {path} and tell me the port. One read is enough."}, |
| {"role": "assistant", "tool_calls": [tc("c1", "read_file", {"path": path})]}, |
| {"role": "tool", "tool_call_id": "c1", "content": f"port = {port}\nhost = 127.0.0.1\n"}, |
| {"role": "assistant", "content": f"The port is {port}."}, |
| ], |
| ["read_file", "terminal"], |
| path, |
| ) |
|
|
|
|
| def stop_search() -> dict: |
| name, files, port = RNG.choice(PROJECTS) |
| hit = files[-1] |
| return row( |
| "stop", |
| [ |
| {"role": "user", "content": f"Find which file sets the listen port in {name}. Then stop."}, |
| {"role": "assistant", "tool_calls": [tc("c1", "search_files", {"pattern": "port", "target": "content"})]}, |
| {"role": "tool", "tool_call_id": "c1", "content": f"{hit}:1:port = {port}"}, |
| {"role": "assistant", "content": f"{hit} sets port {port}."}, |
| ], |
| ["search_files", "read_file"], |
| hit, |
| ) |
|
|
|
|
| def stop_write() -> dict: |
| path = RNG.choice(["notes.txt", "out/ok.txt", "STATUS.md"]) |
| word = RNG.choice(["ready", "ok", "done"]) |
| return row( |
| "stop", |
| [ |
| {"role": "user", "content": f"Write {path} containing just '{word}'. Then stop."}, |
| {"role": "assistant", "tool_calls": [tc("c1", "write_file", {"path": path, "content": word + "\n"})]}, |
| {"role": "tool", "tool_call_id": "c1", "content": f"wrote {path} ({len(word)+1} bytes)"}, |
| {"role": "assistant", "content": f"Wrote {path}."}, |
| ], |
| ["write_file", "terminal"], |
| path, |
| ) |
|
|
|
|
| def stop_web() -> dict: |
| q, snippet, ans = RNG.choice(QUERIES) |
| return row( |
| "stop", |
| [ |
| {"role": "user", "content": f"Search the web once for {q}. Then answer briefly. Do not extract extra URLs."}, |
| {"role": "assistant", "tool_calls": [tc("c1", "web_search", {"query": q})]}, |
| {"role": "tool", "tool_call_id": "c1", "content": f"1. {snippet} — https://example.test/a"}, |
| {"role": "assistant", "content": ans}, |
| ], |
| ["web_search", "web_extract"], |
| q, |
| ) |
|
|
|
|
| def stop_todo() -> dict: |
| return row( |
| "stop", |
| [ |
| {"role": "user", "content": "Plan a 3-step audit of this repo as a todo list. Do not start the audit."}, |
| { |
| "role": "assistant", |
| "tool_calls": [ |
| tc( |
| "c1", |
| "todo", |
| { |
| "todos": [ |
| {"id": "1", "content": "List top-level files", "status": "pending"}, |
| {"id": "2", "content": "Read the README", "status": "pending"}, |
| {"id": "3", "content": "Note open questions", "status": "pending"}, |
| ] |
| }, |
| ) |
| ], |
| }, |
| {"role": "tool", "tool_call_id": "c1", "content": "ok, 3 todos"}, |
| {"role": "assistant", "content": "Planned three steps: list files, read README, note questions. Not starting yet."}, |
| ], |
| ["todo", "web_search", "terminal"], |
| "todo", |
| ) |
|
|
|
|
| def no_tool_math() -> dict: |
| a, b = RNG.randint(11, 40), RNG.randint(11, 40) |
| return row( |
| "no_tool", |
| [ |
| {"role": "user", "content": f"What is {a} times {b}? Reply with just the number. Do not use tools."}, |
| {"role": "assistant", "content": str(a * b)}, |
| ], |
| CORE, |
| f"{a}x{b}", |
| ) |
|
|
|
|
| def no_tool_def() -> dict: |
| q, a = RNG.choice( |
| [ |
| ("In one sentence, what is a JSON schema? Do not run shell commands.", "A JSON Schema is a JSON document that declares the shape, types, and constraints of other JSON data."), |
| ("What is OpenAI tool calling? One sentence. No tools.", "The model emits structured tool_calls; the client runs the function and returns a tool message."), |
| ("What does HIT_CAP mean in an agent bench? No tools.", "The model kept calling tools until the turn limit with no user-facing answer."), |
| ] |
| ) |
| return row("no_tool", [{"role": "user", "content": q}, {"role": "assistant", "content": a}], CORE, q[:40]) |
|
|
|
|
| def recover_missing() -> dict: |
| name, files, port = RNG.choice(PROJECTS) |
| bad, good = "config.yaml", files[-1] |
| return row( |
| "recover", |
| [ |
| {"role": "user", "content": f"Read {bad} and tell me the port."}, |
| {"role": "assistant", "tool_calls": [tc("c1", "read_file", {"path": bad})]}, |
| {"role": "tool", "tool_call_id": "c1", "content": f"ERROR: File not found: {bad}. Try {good}"}, |
| {"role": "assistant", "tool_calls": [tc("c2", "read_file", {"path": good})]}, |
| {"role": "tool", "tool_call_id": "c2", "content": f"port = {port}\n"}, |
| {"role": "assistant", "content": f"{bad} is missing. {good} sets port {port}."}, |
| ], |
| ["read_file", "search_files"], |
| good, |
| ) |
|
|
|
|
| def recover_perm() -> dict: |
| cmd = RNG.choice(["cat /etc/secret.conf", "cat /root/.env"]) |
| return row( |
| "recover", |
| [ |
| {"role": "user", "content": f"Show me the contents using the terminal: {cmd}"}, |
| {"role": "assistant", "tool_calls": [tc("c1", "terminal", {"command": cmd})]}, |
| {"role": "tool", "tool_call_id": "c1", "content": "ERROR: permission denied"}, |
| {"role": "assistant", "content": "That path is not readable here (permission denied). I will not keep retrying the same command."}, |
| ], |
| ["terminal", "read_file"], |
| cmd, |
| ) |
|
|
|
|
| def dead_web() -> dict: |
| q, _, _ = RNG.choice(QUERIES) |
| err = RNG.choice( |
| [ |
| "ERROR: search backend unavailable (ddgs package is not installed).", |
| "ERROR: FIRECRAWL_API_KEY is not set; extract/search backend unavailable.", |
| "ERROR: DuckDuckGo (ddgs) is a search-only backend and cannot fetch arbitrary URLs.", |
| ] |
| ) |
| return row( |
| "dead_tool", |
| [ |
| {"role": "user", "content": f"Search the web for {q}."}, |
| {"role": "assistant", "tool_calls": [tc("c1", "web_search", {"query": q})]}, |
| {"role": "tool", "tool_call_id": "c1", "content": err}, |
| { |
| "role": "assistant", |
| "content": "Web search is not available on this instance. I will not retry the same call. Configure a search backend (for example ddgs) if you want me to look it up.", |
| }, |
| ], |
| ["web_search", "web_extract"], |
| err[:40], |
| ) |
|
|
|
|
| def dead_extract() -> dict: |
| return row( |
| "dead_tool", |
| [ |
| {"role": "user", "content": "Search once for the latest stable Python 3, then answer. Do not fetch extra pages if extract fails."}, |
| {"role": "assistant", "tool_calls": [tc("c1", "web_search", {"query": "Python 3 latest stable version"})]}, |
| {"role": "tool", "tool_call_id": "c1", "content": "1. Python 3.14.6 is the latest stable release."}, |
| {"role": "assistant", "content": "Latest stable is 3.14.6."}, |
| ], |
| ["web_search", "web_extract"], |
| "no-extract", |
| ) |
|
|
|
|
| def schema_fix() -> dict: |
| return row( |
| "schema", |
| [ |
| {"role": "user", "content": "Run `pwd` using the terminal tool, then report the result."}, |
| {"role": "assistant", "tool_calls": [tc("c1", "terminal", {"command": "pwd"})]}, |
| {"role": "tool", "tool_call_id": "c1", "content": "/workspace/demo\n"}, |
| {"role": "assistant", "content": "pwd → /workspace/demo"}, |
| ], |
| ["terminal"], |
| "pwd", |
| ) |
|
|
|
|
| def schema_not_code() -> dict: |
| return row( |
| "schema", |
| [ |
| {"role": "user", "content": "Use the terminal to echo hello. Put the shell command in the command field, not a Python code field."}, |
| {"role": "assistant", "tool_calls": [tc("c1", "terminal", {"command": "echo hello"})]}, |
| {"role": "tool", "tool_call_id": "c1", "content": "hello\n"}, |
| {"role": "assistant", "content": "hello"}, |
| ], |
| ["terminal"], |
| "echo", |
| ) |
|
|
|
|
| BUILDERS = [ |
| (stop_ls, 280), |
| (stop_read, 260), |
| (stop_search, 180), |
| (stop_write, 140), |
| (stop_web, 180), |
| (stop_todo, 80), |
| (no_tool_math, 160), |
| (no_tool_def, 80), |
| (recover_missing, 160), |
| (recover_perm, 80), |
| (dead_web, 160), |
| (dead_extract, 80), |
| (schema_fix, 80), |
| (schema_not_code, 60), |
| ] |
|
|
|
|
| def main() -> None: |
| rows = [] |
| seen = set() |
| for fn, n in BUILDERS: |
| got = 0 |
| spins = 0 |
| while got < n and spins < n * 20: |
| spins += 1 |
| r = fn() |
| if r["id"] in seen: |
| continue |
| seen.add(r["id"]) |
| rows.append(r) |
| got += 1 |
| RNG.shuffle(rows) |
| n_val = max(80, len(rows) // 10) |
| val = rows[:n_val] |
| train = rows[n_val:] |
| DATA.mkdir(parents=True, exist_ok=True) |
| for name, part in ("train.jsonl", train), ("validation.jsonl", val): |
| path = DATA / name |
| with path.open("w", encoding="utf-8") as f: |
| for r in part: |
| f.write(json.dumps(r, ensure_ascii=False) + "\n") |
| tags = {} |
| for r in rows: |
| tags[r["tag"]] = tags.get(r["tag"], 0) + 1 |
| print(json.dumps({"n": len(rows), "train": len(train), "validation": len(val), "tags": tags}, indent=2)) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
