File size: 9,546 Bytes
eeaa10a
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
"""Claude Code as the actor, with a fresh, context-free config inside the sandbox (sandbox.py).

- The per-run config dir is mounted where the logged-in config lives (settings.CLAUDE_CONFIG_DIR). It has no
  CLAUDE.md, skills, plugins, agents, memory, or history. A Claude model gets only the login keys of .claude.json,
  and the real .credentials.json is bind-mounted on top so auth (and token refresh) writes back to the user's
  credential file. A non-Claude model (machine.yaml model_backends) gets no login: its backend token authenticates,
  so Claude Code need not be signed in.
- Only the `lab` MCP server is configured (--strict-mcp-config).
- guard_hook.py (guard.py installs it, needles stored only as hashes): PreToolUse denies WebSearch/WebFetch/Bash
  requests naming the source; PostToolUse withholds any tool output string that contains a blocklisted string.
- --disable-slash-commands removes all skills (claude.ai account skills are synced into any config dir).
"""
import collections
import json
import sys
import uuid

from .. import settings
from ..claude_cli import claude_env_for, limit_hit, model_backend, wait_for_reset
from ..lab import LAB_REQUEST_TOTAL_S
from . import guard
from .base import ActorAgent
from .sandbox import actor_env, bwrap_prefix

# Only these keys of the logged-in .claude.json are copied into the actor's config dir (auth + onboarding), for a
# Claude model only.
CLAUDE_JSON_KEEP = [
    "oauthAccount", "userID", "hasCompletedOnboarding", "lastOnboardingVersion", "installMethod",
    "autoUpdates", "machineID", "migrationVersion", "firstStartTime",
    "opusProMigrationComplete", "sonnet1m45MigrationComplete",
]
# Blacklist, not a whitelist: tools that reach outside the run (other Claude sessions on the
# machine, remote triggers, notifications) or schedule work after it. Subagent tools (Task, Workflow) stay; their
# results come back as tool results and do not need SendMessage.
DISALLOWED_TOOLS = ["ListAgents", "SendMessage", "RemoteTrigger", "PushNotification",
                    "CronCreate", "CronDelete", "CronList", "ScheduleWakeup"]
EXTRA_FLAGS = ["--disable-slash-commands", "--disallowed-tools", ",".join(DISALLOWED_TOOLS)]
EMPTY_TOOL_NAME ='"name":"","input":'        # a tool_use block whose name the model left empty
EMPTY_TOOL_NAME_ERROR = "Param Incorrect"     # the provider's 400 for that history (via LiteLLM)
MCP_TIMEOUT_MARGIN_S = 300        # the actor's MCP tool timeout exceeds a lab request's total limit by this much
MCP_CONFIG_FILE = "lab_mcp.json"  # in the per-run config dir, rewritten with the lab url on every invocation
SYNTHETIC_MODEL = "<synthetic>"   # Claude Code's placeholder model on locally generated assistant messages


class ClaudeCodeActor(ActorAgent):
    name = "claude-code"

    def prepare(self, case, model):
        guard.install(self.cfg / "hooks", case)
        if model_backend(model) is None:
            # a Claude Code started without CLAUDE_CONFIG_DIR keeps its login in ~/.claude.json, not in the config dir
            login = settings.CLAUDE_CONFIG_DIR / ".claude.json"
            assert login.is_file(), (f"{model}: {login} does not exist; sign in Claude Code with this config dir: "
                                     f"CLAUDE_CONFIG_DIR={settings.CLAUDE_CONFIG_DIR} claude")
            host = json.loads(login.read_text())
            slim = {k: host[k] for k in CLAUDE_JSON_KEEP if k in host}
            assert "oauthAccount" in slim, (f"{model}: {login} has no oauthAccount; sign in Claude Code with this "
                                            f"config dir: CLAUDE_CONFIG_DIR={settings.CLAUDE_CONFIG_DIR} claude")
            (self.cfg / ".claude.json").write_text(json.dumps(slim, indent=1))
            (self.cfg / ".credentials.json").touch()     # bind-mount target for the real credentials
            print(f"[actor] {model}: Claude model, login of {settings.CLAUDE_CONFIG_DIR} mounted", flush=True)
        else:
            (self.cfg / ".claude.json").write_text(json.dumps({"hasCompletedOnboarding": True}, indent=1))
            print(f"[actor] {model}: backend token, no Claude Code login mounted", flush=True)
        hook = [{"type": "command",   # path inside the sandbox
                 "command": f"{sys.executable} {settings.CLAUDE_CONFIG_DIR}/hooks/{guard.HOOK_FILE}"}]
        hook_settings = {"hooks": {"PreToolUse": [{"matcher": "|".join(guard.CLAUDE_PRE_TOOLS), "hooks": hook}],
                                   "PostToolUse": [{"matcher": "*", "hooks": hook}]}}
        (self.cfg / "settings.json").write_text(json.dumps(hook_settings, indent=1))
        case.write_actor_workspace(self.ws)

    def new_session_id(self):
        return str(uuid.uuid4())

    def command(self, message, model, mcp_url, session_id, new_session):
        binds = [(self.cfg, settings.CLAUDE_CONFIG_DIR)]
        if model_backend(model) is None:
            creds = settings.CLAUDE_CONFIG_DIR / ".credentials.json"
            binds.append((creds, creds))
        # the hook and the settings that install it, read-only (hooks/guard.log stays writable for the hook)
        protected = [(self.cfg / rel, settings.CLAUDE_CONFIG_DIR / rel) for rel in
                     ("settings.json", f"hooks/{guard.HOOK_FILE}", f"hooks/{guard.NEEDLES_FILE}")]
        # the lab url (with the run's token) goes into a file, not argv: without own_proc, other runs' actors can
        # read every host command line
        (self.cfg / MCP_CONFIG_FILE).write_text(json.dumps({"mcpServers": {"lab": {"type": "http", "url": mcp_url}}}))
        self.model = model   # env() is called right after command() and needs the model's backend
        return bwrap_prefix(binds, self.ws, protected) + [
            str(settings.CLAUDE_BIN), *settings.CLAUDE_LAUNCH_FLAGS, *EXTRA_FLAGS, "-p", message,
            "--model", model, *(["--effort", self.effort] if self.effort is not None else []),
            "--output-format", "stream-json", "--verbose",
            "--mcp-config", str(settings.CLAUDE_CONFIG_DIR / MCP_CONFIG_FILE), "--strict-mcp-config",
            *(["--session-id", session_id] if new_session else ["--resume", session_id]),
        ]

    def env(self):
        # same path inside the sandbox, but the per-run config dir; a non-Claude model gets its backend
        # (claude_cli.model_backend): its token takes precedence over the mounted login
        # MCP_TOOL_TIMEOUT: a lab request may take LAB_REQUEST_TOTAL_S with env retries; the CLI gave up after 300 s
        # (E3 007-02 rth #1, 2026-11-06: the actor never got an answer the ledger recorded)
        return actor_env({**claude_env_for(self.model, settings.CLAUDE_CONFIG_DIR),
                          "MCP_TOOL_TIMEOUT": str((LAB_REQUEST_TOTAL_S + MCP_TIMEOUT_MARGIN_S) * 1000)}, ())

    def session_id_from_stream(self, stream):
        raise AssertionError("Claude Code sessions are started with a known id")

    def served_models(self, stream):
        """Models that actually produced the assistant messages. The requested --model can be silently served by
        another model (both 009 actor runs of 2026-09-27 asked for claude-opus-5-5 and were answered by
        claude-opus-5), so it is checked, not assumed. The last line may still be being written while the actor
        runs; a line that does not parse yet is left for the next check. Only the main thread counts: a subagent the
        actor starts itself may use another model (032-03 web-fetch on Haiku), and is not a substitution."""
        c = collections.Counter()
        for line in stream.read_text(errors="replace").splitlines():
            try:
                m = json.loads(line)
            except json.JSONDecodeError:
                continue
            if (m.get("type") == "assistant" and not m.get("parent_tool_use_id")
                    and m["message"].get("model") != SYNTHETIC_MODEL):
                c[m["message"].get("model")] += 1
        return c

    def usage_limit_hit(self, stream_tail):
        return limit_hit(stream_tail)

    def wait_for_usage_reset(self, stream_tail):
        return wait_for_reset(stream_tail, "actor")

    def terminal_api_error(self, stream_tail):
        # mimo-v2.6-pro emitted a tool call with an empty name (042-02, 058-02 runs of 2026-11-05); Claude Code keeps
        # it in the history and the provider rejects every later request with "Param Incorrect" (a resume of 042-02
        # failed the same way): the model's own output ended the session
        if EMPTY_TOOL_NAME_ERROR in stream_tail and any(
                EMPTY_TOOL_NAME in s.read_text(errors="replace") for s in self.run_dir.glob("actor_stream_*.jsonl")):
            return "empty_tool_name_in_history"
        return None

    @staticmethod
    def tool_events(stream):
        events = []
        for line in stream.read_text().splitlines():
            m = json.loads(line)
            if m["type"] not in ("assistant", "user") or isinstance(m["message"]["content"], str):
                continue
            for c in m["message"]["content"]:
                if c["type"] == "tool_use":
                    events.append({"kind": "call", "name": c["name"], "input": c["input"]})
                elif c["type"] == "tool_result":
                    cc = c["content"]
                    if isinstance(cc, list):
                        cc = " ".join(x.get("text", f"<{x['type']}>") for x in cc)
                    events.append({"kind": "result", "text": str(cc), "lab": False})   # lab results: by text
        return events