feat(agent): permission modes for every harness, asking first by default (#2854)

* fix(agent): show the side menu's agent page whenever the tab is shown

* feat(agent): permission modes for every harness, asking first by default

* test(agent): give the drawer page tests their agent page explicitly

* fix(agent): fail turns on lost stdin writes, wait for Codex to initialize, keep approvals visible

* fix(agent): redo setup on a kept process after it failed, keep approvals in view

* fix(agent): keep full-page panels closed while an approval waits
This commit is contained in:
Kurt Himebauch authored and GitHub committed 2026-11-18 15:43:55 -05:00
1 parent 24f5fa20f8
commit f0f7f7a116
11 files changed
+967 -308

No files matched your search

@@ -84,10 +84,10 @@ class AgentHostTest {
val command = ClaudeCode.turn("hello there", null, AgentHarness.Options())
assertEquals("stream-json", command[command.indexOf("--input-format") + 1])
assertFalse("hello there" in command)
val line = org.json.JSONObject(ClaudeCode.input("hello there")!!)
val line = org.json.JSONObject(ClaudeCode.input("hello there"))
assertEquals("user", line.getString("type"))
assertEquals("hello there", line.getJSONObject("message").getJSONArray("content").getJSONObject(0).getString("text"))
assertNull(Codex.input("hi"))
assertEquals(listOf(ClaudeCode.input("hi")), ClaudeCode.protocol().input("hi", "abc", AgentHarness.Options(), started = false))
}
@Test fun aTaskNotificationResultIsMarkedBackgroundAndCarriesItsUsage() {
@@ -126,13 +126,35 @@ class AgentHostTest {
assertTrue(used("Monitor", """{"command":"tail -f log"}""").background)
}
@Test fun claudeTurnsBypassPermissionsOrPlanAndTakeAModel() {
@Test fun claudeTurnsAskFirstByDefaultAndTakeAModel() {
val first = ClaudeCode.turn("hi", null, AgentHarness.Options())
assertTrue("bypassPermissions" in first && "--resume" !in first && "--model" !in first && "--include-partial-messages" in first)
assertEquals("manual", first[first.indexOf("--permission-mode") + 1])
assertTrue("--permission-prompt-tool=stdio" in first && "--resume" !in first && "--model" !in first && "--include-partial-messages" in first)
val next = ClaudeCode.turn("hi", "abc", AgentHarness.Options(model = "opus", plan = true))
assertEquals("abc", next[next.indexOf("--resume") + 1])
assertEquals("opus", next[next.indexOf("--model") + 1])
assertEquals("plan", next[next.indexOf("--permission-mode") + 1])
assertFalse("--permission-prompt-tool=stdio" in next)
fun mode(permission: String) = ClaudeCode.turn("hi", null, AgentHarness.Options(permission = permission)).let { it[it.indexOf("--permission-mode") + 1] }
assertEquals(listOf("manual", "acceptEdits", "auto", "dontAsk", "bypassPermissions"), ClaudeCode.permissions.map { mode(it.id) })
assertFalse("--permission-prompt-tool=stdio" in ClaudeCode.turn("hi", null, AgentHarness.Options(permission = AgentHarness.FULL)))
}
@Test fun claudePermissionPromptsBecomeApprovalsAnsweredOnStdin() {
val event = ClaudeCode.parse("""{"type":"control_request","request_id":"r1","request":{"subtype":"can_use_tool","tool_name":"Bash","input":{"command":"rm -rf build"},"tool_use_id":"t1"}}""")!!
val approval = event.approval!!
assertEquals(AgentHost.Approval("r1", "Bash", "rm -rf build", "rm -rf build", """{"command":"rm -rf build"}"""), approval)
val allow = org.json.JSONObject(ClaudeCode.answer(approval, allow = true))
assertEquals("control_response", allow.getString("type"))
val response = allow.getJSONObject("response")
assertEquals("r1", response.getString("request_id"))
assertEquals("allow", response.getJSONObject("response").getString("behavior"))
assertEquals("rm -rf build", response.getJSONObject("response").getJSONObject("updatedInput").getString("command"))
val deny = org.json.JSONObject(ClaudeCode.answer(approval, allow = false)).getJSONObject("response").getJSONObject("response")
assertEquals("deny", deny.getString("behavior"))
assertTrue(deny.getString("message").isNotEmpty())
assertEquals("r1", ClaudeCode.parse("""{"type":"control_cancel_request","request_id":"r1"}""")!!.resolved)
assertNull(ClaudeCode.parse("""{"type":"control_request","request_id":"r2","request":{"subtype":"hook_callback"}}"""))
}
@Test fun claudeShowsWholeEditsAndTodos() {
@@ -142,28 +164,99 @@ class AgentHostTest {
"""{"todos":[{"content":"read","status":"completed"},{"content":"fix","status":"in_progress"},{"content":"test","status":"pending"}]}""")))
}
@Test fun codexEventsBecomeEntries() {
assertEquals("t1", Codex.parse("""{"type":"thread.started","thread_id":"t1"}""")!!.conversation)
assertEquals(listOf(Entry.Used("i1", "Shell", "uname -m", "uname -m")),
Codex.parse("""{"type":"item.started","item":{"id":"i1","type":"command_execution","command":"uname -m","status":"in_progress"}}""")!!.entries)
assertEquals(listOf(Entry.Result("i1", "aarch64\n", false)),
Codex.parse("""{"type":"item.completed","item":{"id":"i1","type":"command_execution","command":"uname -m","aggregated_output":"aarch64\n","exit_code":0}}""")!!.entries)
assertEquals(listOf(Entry.Said("It is aarch64.")),
Codex.parse("""{"type":"item.completed","item":{"id":"i2","type":"agent_message","text":"It is aarch64."}}""")!!.entries)
assertEquals(Entry.Used("i3", "Edit", "a.kt, b.kt", "a.kt\nb.kt"),
Codex.parse("""{"type":"item.completed","item":{"id":"i3","type":"file_change","status":"completed","changes":[{"path":"a.kt"},{"path":"b.kt"}]}}""")!!.entries.first())
assertEquals(listOf(Entry.Finished(null)), Codex.parse("""{"type":"turn.completed","usage":{}}""")!!.entries)
assertEquals(listOf(Entry.Finished("quota")), Codex.parse("""{"type":"turn.failed","error":{"message":"quota"}}""")!!.entries)
assertNull(Codex.parse("""{"type":"error","message":"Reconnecting... 1/5 (stream disconnected before completion)"}"""))
assertEquals(listOf(Entry.Finished("unauthorized")), Codex.parse("""{"type":"error","message":"unauthorized"}""")!!.entries)
assertNull(Codex.parse("""{"type":"item.started","item":{"type":"reasoning"}}"""))
private fun json(line: String) = org.json.JSONObject(line)
@Test fun codexOpensAThreadThenStartsTheTurn() {
val command = Codex.turn("hi", null, AgentHarness.Options())
assertEquals(listOf("/root/.local/bin/codex", "app-server"), command.takeLast(2))
assertTrue(command[2].endsWith("2>/root/.cache/droiddeck/codex.log"))
val p = Codex.Protocol()
val init = json(p.input("hi", null, AgentHarness.Options(model = "gpt", effort = "high", brief = "brief"), started = true).single())
assertEquals("initialize", init.getString("method"))
val lines = p.parse("""{"id":${init.getInt("id")},"result":{"userAgent":"codex"}}""")!!.reply
assertEquals(listOf("initialized", "thread/start"), lines.map { json(it).getString("method") })
val start = json(lines[1])
val params = start.getJSONObject("params")
assertEquals("untrusted", params.getString("approvalPolicy"))
assertEquals("danger-full-access", params.getString("sandbox"))
assertEquals("brief", params.getString("developerInstructions"))
val opened = p.parse("""{"id":${start.getInt("id")},"result":{"thread":{"id":"t1"},"approvalPolicy":"untrusted"}}""")!!
assertEquals("t1", opened.conversation)
val turn = json(opened.reply.single())
assertEquals("turn/start", turn.getString("method"))
assertEquals("t1", turn.getJSONObject("params").getString("threadId"))
assertEquals("hi", turn.getJSONObject("params").getJSONArray("input").getJSONObject(0).getString("text"))
assertEquals("high", turn.getJSONObject("params").getString("effort"))
val next = json(p.input("again", "t1", AgentHarness.Options(), started = false).single())
assertEquals("turn/start", next.getString("method"))
assertEquals("t1", next.getJSONObject("params").getString("threadId"))
fun opening(q: Codex.Protocol, conversation: String?, options: AgentHarness.Options): org.json.JSONObject {
val id = json(q.input("hi", conversation, options, started = true).single()).getInt("id")
return json(q.parse("""{"id":$id,"result":{}}""")!!.reply.last())
}
val resumed = opening(Codex.Protocol(), "t9", AgentHarness.Options(permission = AgentHarness.FULL))
assertEquals("thread/resume", resumed.getString("method"))
assertEquals("t9", resumed.getJSONObject("params").getString("threadId"))
assertEquals("never", resumed.getJSONObject("params").getString("approvalPolicy"))
assertEquals(listOf(Entry.Finished("no such thread")), Codex.Protocol().let { q ->
val id = opening(q, "gone", AgentHarness.Options()).getInt("id")
q.parse("""{"id":$id,"error":{"code":-32600,"message":"no such thread"}}""")!!.entries
})
// A thread that failed to open is asked for again on the same connection without a second initialize.
Codex.Protocol().let { q ->
val id = opening(q, "gone", AgentHarness.Options()).getInt("id")
q.parse("""{"id":$id,"error":{"code":-32600,"message":"no such thread"}}""")
assertEquals(listOf("thread/resume"), q.input("again", "gone", AgentHarness.Options(), started = false).map { json(it).getString("method") })
}
assertEquals(listOf(Entry.Finished("not signed in")), Codex.Protocol().let { q ->
val id = json(q.input("hi", null, AgentHarness.Options(), started = true).single()).getInt("id")
q.parse("""{"id":$id,"error":{"code":-32600,"message":"not signed in"}}""")!!.entries
})
}
@Test fun codexTurnsSkipItsSandboxResumeAndTakeAModel() {
assertEquals(listOf("/root/.local/bin/codex", "exec", "--json", "--dangerously-bypass-approvals-and-sandbox", "--skip-git-repo-check", "hi"),
Codex.turn("hi", null, AgentHarness.Options()))
assertEquals(listOf("/root/.local/bin/codex", "exec", "resume", "t1", "--json", "--dangerously-bypass-approvals-and-sandbox", "--skip-git-repo-check", "-m", "gpt", "hi"),
Codex.turn("hi", "t1", AgentHarness.Options(model = "gpt")))
@Test fun codexItemsBecomeEntries() {
val p = Codex.Protocol()
assertEquals(listOf(Entry.Used("e1", "Shell", "touch x", "touch x")), p.parse(
"""{"method":"item/started","params":{"item":{"type":"commandExecution","id":"e1","command":"/bin/bash -lc 'touch x'","status":"inProgress","aggregatedOutput":null,"exitCode":null}}}""")!!.entries)
assertEquals(listOf(Entry.Result("e1", "", false)), p.parse(
"""{"method":"item/completed","params":{"item":{"type":"commandExecution","id":"e1","command":"/bin/bash -lc 'touch x'","status":"completed","aggregatedOutput":null,"exitCode":0}}}""")!!.entries)
assertTrue((p.parse("""{"method":"item/completed","params":{"item":{"type":"commandExecution","id":"e2","command":"false","status":"declined","aggregatedOutput":null,"exitCode":null}}}""")!!.entries.single() as Entry.Result).failed)
assertEquals(listOf(Entry.Said("done")), p.parse("""{"method":"item/completed","params":{"item":{"type":"agentMessage","id":"m1","text":"done","phase":"final_answer"}}}""")!!.entries)
assertEquals("Do", p.parse("""{"method":"item/agentMessage/delta","params":{"itemId":"m1","delta":"Do"}}""")!!.text)
assertEquals(listOf(Entry.Used("f1#0", "Edit", "/w/note.txt", "/w/note.txt\n+hi")), p.parse(
"""{"method":"item/started","params":{"item":{"type":"fileChange","id":"f1","changes":[{"path":"/w/note.txt","kind":{"type":"add"},"diff":"hi\n"}],"status":"inProgress"}}}""")!!.entries)
assertEquals(listOf(Entry.Result("f1#0", "", false)), p.parse(
"""{"method":"item/completed","params":{"item":{"type":"fileChange","id":"f1","changes":[{"path":"/w/note.txt","kind":{"type":"add"},"diff":"hi\n"}],"status":"completed"}}}""")!!.entries)
p.parse("""{"method":"turn/started","params":{"turn":{"id":"u1"}}}""")
assertEquals("[x] read\n[~] fix\n[ ] test", (p.parse("""{"method":"turn/plan/updated","params":{"plan":[{"step":"read","status":"completed"},{"step":"fix","status":"inProgress"},{"step":"test","status":"pending"}]}}""")!!.entries.single() as Entry.Used).input)
val usage = p.parse("""{"method":"thread/tokenUsage/updated","params":{"tokenUsage":{"total":{"totalTokens":32017},"last":{"totalTokens":16055,"inputTokens":16019,"outputTokens":36},"modelContextWindow":258400}}}""")!!
assertEquals(16_055L, usage.context)
assertEquals(258_400L, usage.window)
assertEquals(listOf(AgentHost.Limit(10_080, 84, 1795123687)), p.parse(
"""{"method":"account/rateLimits/updated","params":{"rateLimits":{"limitId":"codex","primary":{"usedPercent":84,"windowDurationMins":10080,"resetsAt":1795123687},"secondary":null}}}""")!!.limits)
val end = p.parse("""{"method":"turn/completed","params":{"turn":{"id":"u1","status":"completed","error":null,"durationMs":4200}}}""")!!
assertEquals(listOf(Entry.Finished(null)), end.entries)
assertEquals(AgentHost.Usage(4200, 0.0, 16_019, 36), end.usage)
assertEquals(listOf(Entry.Finished("quota")), p.parse("""{"method":"turn/completed","params":{"turn":{"id":"u2","status":"failed","error":{"message":"quota"},"durationMs":null}}}""")!!.entries)
assertNull(p.parse("""{"method":"error","params":{"error":{"message":"Reconnecting..."},"willRetry":true}}"""))
assertNull(p.parse("not json"))
}
@Test fun codexApprovalRequestsWaitForTheUser() {
val p = Codex.Protocol()
val command = p.parse("""{"method":"item/commandExecution/requestApproval","id":0,"params":{"kind":"command","itemId":"e1","command":"/bin/bash -lc 'touch x'","cwd":"/w"}}""")!!.approval!!
assertEquals(AgentHost.Approval("0", "Shell", "touch x", "touch x", """{"id":0}"""), command)
assertEquals("""{"id":0,"result":{"decision":"accept"}}""", p.answer(command, allow = true))
assertEquals("decline", json(p.answer(command, allow = false)).getJSONObject("result").getString("decision"))
p.parse("""{"method":"item/started","params":{"item":{"type":"fileChange","id":"f1","changes":[{"path":"/w/a.kt","kind":{"type":"update"},"diff":"@@ -1 +1 @@\n-old\n+new\n"}],"status":"inProgress"}}}""")
val edit = p.parse("""{"method":"item/fileChange/requestApproval","id":1,"params":{"itemId":"f1","reason":null}}""")!!.approval!!
assertEquals("Edit", edit.tool)
assertEquals("/w/a.kt", edit.detail)
assertEquals("/w/a.kt\n-old\n+new", edit.input)
val refused = json(p.parse("""{"method":"item/tool/requestUserInput","id":2,"params":{}}""")!!.reply.single())
assertEquals(2, refused.getInt("id"))
assertTrue(refused.has("error"))
assertEquals("1", p.parse("""{"method":"serverRequest/resolved","params":{"requestId":1}}""")!!.resolved)
}
@Test fun aToolIdUsedAgainInALaterTurnIsANewCall() {
@@ -289,28 +382,6 @@ class AgentHostTest {
assertEquals(1_000_000L, result.window)
}
@Test fun codexTokenCountsCarryContextAndLimits() {
val event = Codex.tokenCount("""{"timestamp":"t","type":"event_msg","payload":{"type":"token_count","info":{"total_token_usage":{"total_tokens":90000},"last_token_usage":{"total_tokens":41000},"model_context_window":272000},"rate_limits":{"primary":{"used_percent":12.5,"window_minutes":300,"resets_at":1794435600},"secondary":{"used_percent":40.0,"window_minutes":10080,"resets_at":1794592800}}}}""")!!
assertEquals(41_000L, event.context)
assertEquals(272_000L, event.window)
assertEquals(listOf(AgentHost.Limit(300, 12, 1794435600), AgentHost.Limit(10_080, 40, 1794592800)), event.limits)
assertNull(Codex.tokenCount("""{"type":"event_msg","payload":{"type":"agent_message"}}"""))
}
@Test fun codexUsageComesFromTheThreadsSessionLog() {
val root = Files.createTempDirectory("rootfs").toFile()
val log = File(root, "root/.codex/sessions/2026/11/12/rollout-2026-11-12T10-00-00-thread1.jsonl").apply { parentFile!!.mkdirs() }
log.writeText(
"""{"type":"event_msg","payload":{"type":"token_count","info":{"last_token_usage":{"total_tokens":15692},"model_context_window":258400},"rate_limits":{"primary":{"used_percent":86.0,"window_minutes":10080,"resets_at":1794716485},"secondary":null}}}""" + "\n" +
"""{"type":"response_item","payload":{"type":"additional_tools","tools":[{"description":"reports token_count as it goes"}]}}""" + "\n",
)
val event = Codex.usage(root, "thread1")!!
assertEquals(15_692L, event.context)
assertEquals(258_400L, event.window)
assertEquals(listOf(AgentHost.Limit(10_080, 86, 1794716485)), event.limits)
assertNull(Codex.usage(root, "other"))
}
@Test fun limitsRoundTripThroughPrefs() {
val limits = listOf(AgentHost.Limit(300, 7, 1794435600), AgentHost.Limit(10_080, 85, 1794592800))
assertEquals(limits, AgentHost.decodeLimits(AgentHost.encodeLimits(limits)))
@@ -18,61 +18,133 @@ import java.nio.file.Files
class OpenCodeTest {
private val session = "ses_1"
private fun event(type: String, part: String) = """{"type":"$type","timestamp":1,"sessionID":"$session","part":$part}"""
private fun json(line: String) = JSONObject(line)
private fun update(u: String) = """{"jsonrpc":"2.0","method":"session/update","params":{"sessionId":"$session","update":$u}}"""
@Test fun turnsResumeByIdAndCarryModelPlanAndVariant() {
assertEquals(listOf(OpenCode.binary, "run", "--format", "json", "--auto", "--thinking", "--", "brief\n\nhi"),
OpenCode.turn("hi", null, AgentHarness.Options(brief = "brief")))
assertEquals(listOf(OpenCode.binary, "run", "--format", "json", "--auto", "--thinking", "-s", "ses_1", "--agent", "plan",
"-m", "opencode/big-pickle", "--variant", "high", "--", "-hi"),
OpenCode.turn("-hi", "ses_1", AgentHarness.Options(model = "opencode/big-pickle", plan = true, brief = "brief", effort = "high")))
/** Drives a new process through initialize and session/new to the prompt, returning it and the prompt's id. */
private fun opened(options: AgentHarness.Options = AgentHarness.Options()): Pair<OpenCode.Protocol, Int> {
val p = OpenCode.Protocol()
var line = p.input("hi", null, options, started = true).single()
var result = "{}"
while (true) {
val request = json(line)
if (request.getString("method") == "session/prompt") return p to request.getInt("id")
if (request.getString("method") == "session/new") result = """{"sessionId":"$session"}"""
line = p.parse("""{"jsonrpc":"2.0","id":${request.getInt("id")},"result":$result}""")!!.reply.single()
}
}
@Test fun textReasoningAndStepsBecomeEntries() {
OpenCode.turn("hi", null, AgentHarness.Options())
assertEquals(session, OpenCode.parse(event("step_start", """{"type":"step-start"}"""))!!.conversation)
assertEquals(listOf(Entry.Said("x86_64")), OpenCode.parse(event("text", """{"type":"text","text":" x86_64\n"}"""))!!.entries)
assertEquals(listOf(Entry.Thought("why")), OpenCode.parse(event("reasoning", """{"type":"reasoning","text":"why"}"""))!!.entries)
val step = OpenCode.parse(event("step_finish", """{"reason":"tool-calls","tokens":{"total":7894,"input":6013,"output":89,"reasoning":0,"cache":{"write":0,"read":1792}},"cost":0.01}"""))!!
assertEquals(emptyList<Entry>(), step.entries)
assertEquals(7894L, step.context)
val end = OpenCode.parse(event("step_finish", """{"reason":"stop","tokens":{"total":7927,"input":241,"output":6,"reasoning":2,"cache":{"write":0,"read":7680}},"cost":0.02}"""))!!
assertEquals(listOf(Entry.Finished(null)), end.entries)
assertEquals(AgentHost.Usage(0, 0.03, 6013L + 1792 + 241 + 7680, 89L + 6 + 2), end.usage!!.copy(costUsd = Math.round(end.usage!!.costUsd * 100) / 100.0))
@Test fun turnsServeAcpUnderTheChosenRules() {
val command = OpenCode.turn("hi", null, AgentHarness.Options()).dropWhile { it != "/usr/bin/env" }
assertEquals(listOf("/usr/bin/env", OpenCode.binary, "acp"), listOf(command[0]) + command.drop(2))
val ask = json(command[1].removePrefix("OPENCODE_PERMISSION="))
assertEquals("ask", ask.getString("edit"))
assertEquals("ask", ask.getString("bash"))
assertFalse(ask.has("*"))
assertEquals("allow", OpenCode.rules(AgentHarness.EDITS).getString("edit"))
assertEquals("ask", OpenCode.rules(AgentHarness.EDITS).getString("bash"))
assertEquals("""{"*":"allow"}""", OpenCode.rules(AgentHarness.FULL).toString())
}
@Test fun eachTurnCountsOnlyItsOwnSteps() {
OpenCode.turn("one", null, AgentHarness.Options())
OpenCode.parse(event("step_finish", """{"reason":"stop","tokens":{"input":100,"output":10,"cache":{}},"cost":1}"""))
OpenCode.turn("two", session, AgentHarness.Options())
val end = OpenCode.parse(event("step_finish", """{"reason":"stop","tokens":{"input":5,"output":1,"cache":{}},"cost":0}"""))!!
assertEquals(AgentHost.Usage(0, 0.0, 5, 1), end.usage)
@Test fun aNewProcessOpensItsSessionAndSetsModelModeAndEffortBeforeThePrompt() {
val p = OpenCode.Protocol()
val init = json(p.input("hi", null, AgentHarness.Options(model = "opencode/big-pickle", effort = "high", brief = "brief", workdir = "/root/DroidDeck"), started = true).single())
assertEquals("initialize", init.getString("method"))
val new = json(p.parse("""{"jsonrpc":"2.0","id":${init.getInt("id")},"result":{"protocolVersion":1}}""")!!.reply.single())
assertEquals("session/new", new.getString("method"))
assertEquals("/root/DroidDeck", new.getJSONObject("params").getString("cwd"))
val created = p.parse("""{"jsonrpc":"2.0","id":${new.getInt("id")},"result":{"sessionId":"$session","configOptions":[]}}""")!!
assertEquals(session, created.conversation)
val sent = mutableListOf<JSONObject>()
var line = created.reply.single()
while (true) {
val request = json(line)
sent += request
if (request.getString("method") == "session/prompt") break
// A refused effort, one the model does not have, does not stop the turn.
val refused = request.getJSONObject("params").getString("configId") == "effort"
val answer = if (refused) """"error":{"code":-32602,"message":"no"}""" else """"result":{}"""
line = p.parse("""{"jsonrpc":"2.0","id":${request.getInt("id")},$answer}""")!!.reply.single()
}
assertEquals(listOf("model" to "opencode/big-pickle", "effort" to "high", "mode" to "build"),
sent.dropLast(1).map { it.getJSONObject("params").let { o -> o.getString("configId") to o.getString("value") } })
assertEquals("brief\n\nhi", sent.last().getJSONObject("params").getJSONArray("prompt").getJSONObject(0).getString("text"))
val again = json(p.input("two", session, AgentHarness.Options(brief = "brief"), started = false).single())
assertEquals("session/prompt", again.getString("method"))
assertEquals("two", again.getJSONObject("params").getJSONArray("prompt").getJSONObject(0).getString("text"))
}
@Test fun toolsBecomeCallsWithTheirResults() {
val bash = OpenCode.parse(event("tool_use", """{"type":"tool","tool":"bash","callID":"c1","state":{"status":"completed","input":{"command":"uname -m"},"output":"aarch64\n","metadata":{"exit":0}}}"""))!!
assertEquals(listOf(Entry.Used("c1", "Bash", "uname -m", "uname -m"), Entry.Result("c1", "aarch64\n", false)), bash.entries)
val failed = OpenCode.parse(event("tool_use", """{"type":"tool","tool":"bash","callID":"c2","state":{"status":"completed","input":{"command":"false"},"output":"(no output)","metadata":{"exit":1}}}"""))!!
assertTrue((failed.entries[1] as Entry.Result).failed)
val edit = OpenCode.parse(event("tool_use", """{"type":"tool","tool":"edit","callID":"c3","state":{"status":"completed","input":{"filePath":"/w/a.txt","oldString":"hi","newString":"bye"},"output":"Edit applied successfully."}}"""))!!
assertEquals(Entry.Used("c3", "Edit", "/w/a.txt", "/w/a.txt\n-hi\n+bye"), edit.entries[0])
val write = OpenCode.parse(event("tool_use", """{"type":"tool","tool":"write","callID":"c4","state":{"status":"completed","input":{"filePath":"/w/b.txt","content":"one\n"},"output":"Wrote file successfully."}}"""))!!
assertEquals("/w/b.txt\n+one", (write.entries[0] as Entry.Used).input)
val todo = OpenCode.parse(event("tool_use", """{"type":"tool","tool":"todowrite","callID":"c5","state":{"status":"completed","input":{"todos":[{"content":"A","status":"completed"},{"content":"B","status":"in_progress"},{"content":"C","status":"pending"}]},"output":"[]"}}"""))!!
assertEquals("[x] A\n[~] B\n[ ] C", (todo.entries[0] as Entry.Used).input)
val read = OpenCode.parse(event("tool_use", """{"type":"tool","tool":"read","callID":"c6","state":{"status":"error","input":{"filePath":"/nope"},"error":"File not found"}}"""))!!
assertEquals("Read", (read.entries[0] as Entry.Used).tool)
assertEquals("/nope", (read.entries[0] as Entry.Used).detail)
assertEquals(Entry.Result("c6", "File not found", true), read.entries[1])
val running = OpenCode.parse(event("tool_use", """{"type":"tool","tool":"bash","callID":"c7","state":{"status":"running","input":{"command":"sleep 9"}}}"""))!!
assertEquals(listOf(Entry.Used("c7", "Bash", "sleep 9", "sleep 9")), running.entries)
@Test fun aResumedSessionPlansWhenAsked() {
val p = OpenCode.Protocol()
val init = json(p.input("hi", "ses_9", AgentHarness.Options(plan = true), started = true).single())
val resume = json(p.parse("""{"jsonrpc":"2.0","id":${init.getInt("id")},"result":{}}""")!!.reply.single())
assertEquals("session/resume", resume.getString("method"))
assertEquals("ses_9", resume.getJSONObject("params").getString("sessionId"))
val resumed = p.parse("""{"jsonrpc":"2.0","id":${resume.getInt("id")},"result":{"configOptions":[]}}""")!!
assertEquals("ses_9", resumed.conversation)
val mode = json(resumed.reply.single())
assertEquals("plan", mode.getJSONObject("params").getString("value"))
assertEquals(listOf(Entry.Finished("Invalid mode")), p.parse("""{"jsonrpc":"2.0","id":${mode.getInt("id")},"error":{"code":-32602,"message":"Invalid mode"}}""")!!.entries)
// The next message on the same process asks for the mode again rather than prompting in whatever mode the session has.
val retry = json(p.input("again", "ses_9", AgentHarness.Options(plan = true), started = false).single())
assertEquals("session/set_config_option", retry.getString("method"))
assertEquals("plan", retry.getJSONObject("params").getString("value"))
val prompt = json(p.parse("""{"jsonrpc":"2.0","id":${retry.getInt("id")},"result":{}}""")!!.reply.single())
assertEquals("session/prompt", prompt.getString("method"))
p.parse("""{"jsonrpc":"2.0","id":${prompt.getInt("id")},"result":{"stopReason":"end_turn"}}""")
assertEquals("session/prompt", json(p.input("third", "ses_9", AgentHarness.Options(plan = true), started = false).single()).getString("method"))
val gone = OpenCode.Protocol()
val id = json(gone.input("hi", "ses_x", AgentHarness.Options(), started = true).single()).getInt("id")
val resumeId = json(gone.parse("""{"jsonrpc":"2.0","id":$id,"result":{}}""")!!.reply.single()).getInt("id")
assertEquals(listOf(Entry.Finished("Session not found")), gone.parse("""{"jsonrpc":"2.0","id":$resumeId,"error":{"code":-32603,"message":"Internal error","data":{"message":"Session not found"}}}""")!!.entries)
}
@Test fun errorsEndTheTurn() {
assertEquals(listOf(Entry.Finished("Invalid credential")), OpenCode.parse(
"""{"type":"error","sessionID":"ses_1","error":{"name":"APIError","data":{"message":"Invalid credential","statusCode":401}}}""")!!.entries)
assertEquals(listOf(Entry.Finished("UnknownError")), OpenCode.parse("""{"type":"error","error":{"name":"UnknownError"}}""")!!.entries)
assertNull(OpenCode.parse("not json"))
@Test fun chunksAndToolCallsBecomeEntries() {
val (p, prompt) = opened()
assertEquals("We need", p.parse(update("""{"sessionUpdate":"agent_thought_chunk","content":{"type":"text","text":"We need"}}"""))!!.thinking)
val pending = p.parse(update("""{"sessionUpdate":"tool_call","toolCallId":"c1","title":"bash","kind":"execute","status":"pending","locations":[],"rawInput":{"cwd":"/work"}}"""))!!
assertEquals(listOf(Entry.Thought("We need"), Entry.Used("c1", "Bash", "", "")), pending.entries)
assertEquals(listOf(Entry.Used("c1", "Bash", "touch /work/probe.txt", "touch /work/probe.txt")), p.parse(update(
"""{"sessionUpdate":"tool_call_update","toolCallId":"c1","status":"in_progress","kind":"execute","title":"touch /work/probe.txt","rawInput":{"command":"touch /work/probe.txt","cwd":"/work"}}"""))!!.entries)
assertEquals(listOf(Entry.Used("c1", "Bash", "touch /work/probe.txt", "touch /work/probe.txt"), Entry.Result("c1", "(no output)", false)), p.parse(update(
"""{"sessionUpdate":"tool_call_update","toolCallId":"c1","status":"completed","title":"touch /work/probe.txt","content":[{"type":"content","content":{"type":"text","text":"(no output)"}}],"rawOutput":{"output":"(no output)","metadata":{"exit":0}}}"""))!!.entries)
p.parse(update("""{"sessionUpdate":"tool_call","toolCallId":"c2","title":"write","kind":"edit","status":"pending","rawInput":{}}"""))
assertEquals(Entry.Used("c2", "Write", "/work/note.txt", "/work/note.txt\n+hi"), p.parse(update(
"""{"sessionUpdate":"tool_call_update","toolCallId":"c2","status":"in_progress","kind":"edit","title":"write","rawInput":{"content":"hi","filePath":"/work/note.txt"}}"""))!!.entries.single())
assertEquals(Entry.Result("c2", "The user rejected permission to use this specific tool call.", true), p.parse(update(
"""{"sessionUpdate":"tool_call_update","toolCallId":"c2","status":"failed","rawOutput":{"error":"The user rejected permission to use this specific tool call."}}"""))!!.entries[1])
assertEquals("done", p.parse(update("""{"sessionUpdate":"agent_message_chunk","content":{"type":"text","text":"done"}}"""))!!.text)
val usage = p.parse(update("""{"sessionUpdate":"usage_update","used":7760,"size":200000,"cost":{"amount":0.25,"currency":"USD"}}"""))!!
assertEquals(7760L, usage.context)
assertEquals(200_000L, usage.window)
val end = p.parse("""{"jsonrpc":"2.0","id":$prompt,"result":{"stopReason":"end_turn","usage":{"inputTokens":592,"outputTokens":3,"totalTokens":7763,"cachedReadTokens":7168}}}""")!!
assertEquals(listOf(Entry.Said("done"), Entry.Finished(null)), end.entries)
assertEquals(0.25, end.usage!!.costUsd, 0.0)
assertEquals(592L + 7168, end.usage!!.inputTokens)
assertTrue(OpenCode.sessionCost)
}
@Test fun permissionRequestsWaitForTheUser() {
val (p, prompt) = opened()
p.parse(update("""{"sessionUpdate":"tool_call","toolCallId":"c1","title":"bash","kind":"execute","status":"pending","rawInput":{}}"""))
val bash = p.parse("""{"jsonrpc":"2.0","id":0,"method":"session/request_permission","params":{"sessionId":"$session","toolCall":{"toolCallId":"c1","title":"touch /w/x","kind":"execute","status":"pending","rawInput":{"command":"touch /w/x"}},"options":[{"optionId":"once","kind":"allow_once","name":"Allow once"},{"optionId":"reject","kind":"reject_once","name":"Reject"}]}}""")!!.approval!!
assertEquals(AgentHost.Approval("0", "Bash", "touch /w/x", "touch /w/x", """{"id":0}"""), bash)
val outside = p.parse("""{"jsonrpc":"2.0","id":5,"method":"session/request_permission","params":{"sessionId":"$session","toolCall":{"toolCallId":"c1","title":"touch /root/x","kind":"other","rawInput":{"command":"touch /root/x","parentDir":"/root"}}}}""")!!.approval!!
assertEquals("External directory", outside.tool)
assertEquals("/root", outside.detail)
val allow = json(p.answer(bash, allow = true))
assertEquals(0, allow.getInt("id"))
assertEquals("once", allow.getJSONObject("result").getJSONObject("outcome").getString("optionId"))
assertEquals("reject", json(p.answer(bash, allow = false)).getJSONObject("result").getJSONObject("outcome").getString("optionId"))
val edit = p.parse("""{"jsonrpc":"2.0","id":1,"method":"session/request_permission","params":{"sessionId":"$session","toolCall":{"toolCallId":"c2","title":"/w/a.txt","kind":"edit","rawInput":{"filepath":"/w/a.txt","diff":"Index: /w/a.txt\n===\n--- /w/a.txt\n+++ /w/a.txt\n@@ -1,1 +1,1 @@\n-old\n+new\n"}}}}""")!!.approval!!
assertEquals("Edit", edit.tool)
assertEquals("/w/a.txt\n-old\n+new", edit.input)
val write = json(p.parse("""{"jsonrpc":"2.0","id":2,"method":"fs/write_text_file","params":{"sessionId":"$session","path":"/w/a.txt","content":"new"}}""")!!.reply.single())
assertEquals(2, write.getInt("id"))
assertTrue(write.has("error"))
assertEquals(listOf(Entry.Finished("Invalid credential")), p.parse(
"""{"jsonrpc":"2.0","id":$prompt,"error":{"code":-32603,"message":"Internal error","data":{"message":"Invalid credential"}}}""")!!.entries)
assertNull(p.parse("not json"))
}
@Test fun verboseModelListingGivesLabelsAndWindows() {
@@ -108,16 +180,12 @@ class OpenCodeTest {
assertEquals(mapOf("opencode/big-pickle" to 200000L, "opencode-go/kimi-k3" to 262144L), windows)
}
@Test fun modelsAndWindowComeFromTheCachedListing() {
@Test fun modelsComeFromTheCachedListing() {
val root = Files.createTempDirectory("rootfs").toFile()
assertEquals(emptyList<AgentHarness.Model>(), OpenCode.models(root))
File(root, "root/.cache/droiddeck/opencode-models").apply { parentFile!!.mkdirs() }
.writeText("opencode/big-pickle\n{\n \"providerID\": \"opencode\",\n \"name\": \"Big Pickle\",\n \"limit\": {\"context\": 200000}\n}\n")
assertEquals(listOf(AgentHarness.Model("opencode/big-pickle", "Big Pickle")), OpenCode.models(root))
OpenCode.turn("hi", null, AgentHarness.Options(model = "opencode/big-pickle"))
assertEquals(200000L, OpenCode.usage(root, session)!!.window)
OpenCode.turn("hi", null, AgentHarness.Options())
assertNull(OpenCode.usage(root, session))
}
private fun provider(id: String) = OpenCode.providers.first { it.id == id }
@@ -5,7 +5,7 @@ import org.junit.Test
class SessionDrawerPageTest {
@Test fun singleScreenNavigationStartsWithControllerAndSkipsSecondScreen() {
val pages = sessionDrawerPages(false)
val pages = sessionDrawerPages(false, hasAgent = false)
assertEquals(SessionDrawerPage.CONTROLLER, pages.first())
assertFalse(SessionDrawerPage.SECOND_SCREEN in pages)
assertEquals(SessionDrawerPage.DISPLAY, pages.step(SessionDrawerPage.CONTROLLER, 1))
@@ -14,11 +14,11 @@ class SessionDrawerPageTest {
}
@Test fun connectedSecondaryDisplayAddsItsPageAfterControllerAndPreservesOtherPages() {
val connected = sessionDrawerPages(true)
val connected = sessionDrawerPages(true, hasAgent = false)
assertEquals(SessionDrawerPage.SECOND_SCREEN, connected.step(SessionDrawerPage.CONTROLLER, 1))
assertEquals(SessionDrawerPage.DISPLAY, connected.step(SessionDrawerPage.SECOND_SCREEN, 1))
assertEquals(sessionDrawerPages(false), connected.filter { it != SessionDrawerPage.SECOND_SCREEN })
for (pages in listOf(connected, sessionDrawerPages(false))) {
assertEquals(sessionDrawerPages(false, hasAgent = false), connected.filter { it != SessionDrawerPage.SECOND_SCREEN })
for (pages in listOf(connected, sessionDrawerPages(false, hasAgent = false))) {
assertEquals(SessionDrawerPage.HUD, pages.step(SessionDrawerPage.DISPLAY, 1))
assertEquals(SessionDrawerPage.EFFECTS, pages.step(SessionDrawerPage.HUD, 1))
assertEquals(SessionDrawerPage.VR, pages.step(SessionDrawerPage.EFFECTS, 1))
@@ -27,7 +27,7 @@ class SessionDrawerPageTest {
}
}
@Test fun theAgentPageComesBeforeSessionOnlyWhenTheAgentIsInstalled() {
@Test fun theAgentPageComesBeforeSessionOnlyWhenTheTabIsShown() {
val with = sessionDrawerPages(false, hasAgent = true)
assertEquals(SessionDrawerPage.AGENT, with.step(SessionDrawerPage.GAMES, 1))
assertEquals(SessionDrawerPage.SESSION, with.step(SessionDrawerPage.AGENT, 1))