mirror of
https://github.com/Droid-Deck/DroidDeck.git
synced 2026-11-19 12:56:06 +00:00
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:
1 parent
24f5fa20f8
commit
f0f7f7a116
11 files changed
+967
-308
No files matched your search
@@ -1,11 +1,13 @@
|
||||
package com.droiddeck.launcher.agent
|
||||
|
||||
import androidx.annotation.StringRes
|
||||
import androidx.annotation.VisibleForTesting
|
||||
import com.droiddeck.launcher.R
|
||||
import org.json.JSONArray
|
||||
import org.json.JSONObject
|
||||
import java.io.File
|
||||
|
||||
/** One coding agent CLI in the Linux userland, run one process per turn (or kept open, see [input]). */
|
||||
/** One coding agent CLI in the Linux userland, run as a process that takes its turns over stdin (see [AgentProtocol]). */
|
||||
interface AgentHarness {
|
||||
val id: String
|
||||
val name: String
|
||||
@@ -35,22 +37,20 @@ interface AgentHarness {
|
||||
/** Whether the CLI has models that need no account; [useFree] then counts as signed in. */
|
||||
val free: Boolean get() = false
|
||||
fun useFree(rootfs: File) {}
|
||||
/** Usage reports the conversation's whole cost rather than the turn's. */
|
||||
val sessionCost: Boolean get() = false
|
||||
/** Whether [Options.plan] means anything to this CLI. */
|
||||
val plans: Boolean
|
||||
/** Reasoning effort levels the CLI accepts, lowest first; empty when it has none. */
|
||||
val efforts: List<String>
|
||||
/** Models to offer besides the CLI's default; [rootfs] is where the CLI's own files can be read. */
|
||||
fun models(rootfs: File): List<Model>
|
||||
/** The guest command for one turn; [conversation] is null for the first one. */
|
||||
/** How the CLI may run its tools, the one that asks before each action first and the default. */
|
||||
val permissions: List<Permission>
|
||||
/** The guest command of the process that runs the conversation's turns; [conversation] is null for a new one. */
|
||||
fun turn(message: String, conversation: String?, options: Options): List<String>
|
||||
/**
|
||||
* The line that hands [message] to a [turn] process over stdin, or null when the message is already in the
|
||||
* command. A process that takes its messages this way stays open between turns, so work it started in the
|
||||
* background can wake it, as it does in the CLI's own terminal.
|
||||
*/
|
||||
fun input(message: String): String? = null
|
||||
/** One line of the CLI's output, or null when it carries nothing to show. */
|
||||
fun parse(line: String): AgentEvent?
|
||||
/** A new reader for one [turn] process; it keeps what that process has said so far. */
|
||||
fun protocol(): AgentProtocol
|
||||
/** The folder, under the userland's root, where the CLI loads user skills (`<name>/SKILL.md`). */
|
||||
val skills: String
|
||||
/** The CLI's global instructions file under the userland's root, where DroidDeck keeps its rules in a marked block. */
|
||||
@@ -65,14 +65,42 @@ interface AgentHarness {
|
||||
/** An API reached with a key; [keyPage] is where the key is made, and a [custom] one is any OpenAI-compatible server. */
|
||||
data class Provider(val id: String, val name: String, val keyPage: String? = null, val custom: Boolean = false)
|
||||
|
||||
data class Options(val model: String? = null, val plan: Boolean = false, val brief: String? = null, val effort: String? = null)
|
||||
/** A permission mode; [id] is DroidDeck's own name for it, which each CLI maps to its flags. */
|
||||
data class Permission(val id: String, @StringRes val label: Int, @StringRes val hint: Int)
|
||||
|
||||
data class Options(
|
||||
val model: String? = null, val plan: Boolean = false, val brief: String? = null, val effort: String? = null,
|
||||
val permission: String = ASK, val workdir: String = "/root",
|
||||
)
|
||||
|
||||
companion object {
|
||||
const val ASK = "ask"
|
||||
const val EDITS = "edits"
|
||||
const val AUTO = "auto"
|
||||
const val DONT_ASK = "dontask"
|
||||
const val FULL = "full"
|
||||
|
||||
val all: List<AgentHarness> = listOf(ClaudeCode, Codex, OpenCode)
|
||||
fun byId(id: String?): AgentHarness = all.firstOrNull { it.id == id } ?: ClaudeCode
|
||||
}
|
||||
}
|
||||
|
||||
/** What goes to one CLI process's stdin, and what its output lines mean. */
|
||||
interface AgentProtocol {
|
||||
/**
|
||||
* The lines that start a turn of [message]; [started] is true for a process that has just been started. The
|
||||
* process stays open between turns, so work it started in the background can wake it.
|
||||
*/
|
||||
fun input(message: String, conversation: String?, options: AgentHarness.Options, started: Boolean): List<String>
|
||||
/** One line of the process's output, or null when it carries nothing to show. */
|
||||
fun parse(line: String): AgentEvent?
|
||||
/** The line that answers [approval]. */
|
||||
fun answer(approval: AgentHost.Approval, allow: Boolean): String
|
||||
}
|
||||
|
||||
/** The message a CLI tells its model when the user denies a tool call. */
|
||||
internal const val DENIED = "The user denied this tool call."
|
||||
|
||||
/** What one line of output carries: whole entries, or text still being written. */
|
||||
data class AgentEvent(
|
||||
val conversation: String? = null,
|
||||
@@ -89,6 +117,12 @@ data class AgentEvent(
|
||||
val background: Boolean = false,
|
||||
/** The error a background turn ended with, if it failed. */
|
||||
val backgroundError: String? = null,
|
||||
/** Lines to write to the process's stdin right away, the next step of a request it has answered. */
|
||||
val reply: List<String> = emptyList(),
|
||||
/** A tool call that waits for the user to allow it. */
|
||||
val approval: AgentHost.Approval? = null,
|
||||
/** The id of an approval the CLI no longer waits for. */
|
||||
val resolved: String? = null,
|
||||
)
|
||||
|
||||
/** Claude Code: `claude -p` with stream-json input and output, resumed by session id. */
|
||||
@@ -130,22 +164,54 @@ object ClaudeCode : AgentHarness {
|
||||
AgentHarness.Model("opus", "Opus"), AgentHarness.Model("sonnet", "Sonnet"), AgentHarness.Model("haiku", "Haiku"),
|
||||
)
|
||||
|
||||
// DroidDeck runs the agent unattended on the user's own device; permission prompts have no one to answer them.
|
||||
override val permissions = listOf(
|
||||
AgentHarness.Permission(AgentHarness.ASK, R.string.agent_permission_ask, R.string.agent_permission_ask_hint),
|
||||
AgentHarness.Permission(AgentHarness.EDITS, R.string.agent_permission_edits, R.string.agent_permission_edits_hint),
|
||||
AgentHarness.Permission(AgentHarness.AUTO, R.string.agent_permission_auto, R.string.agent_permission_auto_hint),
|
||||
AgentHarness.Permission(AgentHarness.DONT_ASK, R.string.agent_permission_dont_ask, R.string.agent_permission_dont_ask_hint),
|
||||
AgentHarness.Permission(AgentHarness.FULL, R.string.agent_permission_full, R.string.agent_permission_full_hint),
|
||||
)
|
||||
|
||||
private val MODES = mapOf(
|
||||
AgentHarness.ASK to "manual", AgentHarness.EDITS to "acceptEdits", AgentHarness.AUTO to "auto",
|
||||
AgentHarness.DONT_ASK to "dontAsk", AgentHarness.FULL to "bypassPermissions",
|
||||
)
|
||||
|
||||
/**
|
||||
* Prompts reach DroidDeck as can_use_tool requests on stdout (the SDK's stdio prompt tool). Plan mode keeps
|
||||
* answering none, so a turn that would leave plan mode ends on its plan.
|
||||
*/
|
||||
override fun turn(message: String, conversation: String?, options: AgentHarness.Options) = buildList {
|
||||
addAll(listOf(binary, "-p", "--input-format", "stream-json", "--output-format", "stream-json", "--verbose", "--include-partial-messages"))
|
||||
addAll(listOf("--permission-mode", if (options.plan) "plan" else "bypassPermissions"))
|
||||
val mode = if (options.plan) "plan" else MODES[options.permission] ?: "manual"
|
||||
addAll(listOf("--permission-mode", mode))
|
||||
if (mode != "plan" && mode != "bypassPermissions") add("--permission-prompt-tool=stdio")
|
||||
options.model?.let { addAll(listOf("--model", it)) }
|
||||
options.effort?.let { addAll(listOf("--effort", it)) }
|
||||
options.brief?.let { addAll(listOf("--append-system-prompt", it)) }
|
||||
if (conversation != null) addAll(listOf("--resume", conversation))
|
||||
}
|
||||
|
||||
override fun input(message: String): String? = JSONObject()
|
||||
fun input(message: String): String = JSONObject()
|
||||
.put("type", "user")
|
||||
.put("message", JSONObject().put("role", "user").put("content", JSONArray().put(JSONObject().put("type", "text").put("text", message))))
|
||||
.toString()
|
||||
|
||||
override fun parse(line: String): AgentEvent? {
|
||||
override fun protocol(): AgentProtocol = object : AgentProtocol {
|
||||
override fun input(message: String, conversation: String?, options: AgentHarness.Options, started: Boolean) = listOf(this@ClaudeCode.input(message))
|
||||
override fun parse(line: String) = this@ClaudeCode.parse(line)
|
||||
override fun answer(approval: AgentHost.Approval, allow: Boolean) = this@ClaudeCode.answer(approval, allow)
|
||||
}
|
||||
|
||||
@VisibleForTesting
|
||||
internal fun answer(approval: AgentHost.Approval, allow: Boolean): String {
|
||||
val decision = if (allow) JSONObject().put("behavior", "allow").put("updatedInput", runCatching { JSONObject(approval.payload) }.getOrDefault(JSONObject()))
|
||||
else JSONObject().put("behavior", "deny").put("message", DENIED)
|
||||
return JSONObject().put("type", "control_response")
|
||||
.put("response", JSONObject().put("subtype", "success").put("request_id", approval.id).put("response", decision)).toString()
|
||||
}
|
||||
|
||||
fun parse(line: String): AgentEvent? {
|
||||
val o = runCatching { JSONObject(line) }.getOrNull() ?: return null
|
||||
val conversation = o.optString("session_id").takeIf { it.isNotEmpty() }
|
||||
// A subagent's messages carry the call that started it; only its tool calls are shown, under that call.
|
||||
@@ -192,6 +258,13 @@ object ClaudeCode : AgentHarness {
|
||||
AgentEvent(conversation, results)
|
||||
}
|
||||
"rate_limit_event" -> AgentEvent(conversation, limits = limits(o.optJSONObject("rate_limit_info")))
|
||||
"control_request" -> {
|
||||
val request = o.optJSONObject("request")?.takeIf { it.optString("subtype") == "can_use_tool" } ?: return null
|
||||
val tool = request.optString("tool_name")
|
||||
val input = request.optJSONObject("input") ?: JSONObject()
|
||||
AgentEvent(approval = AgentHost.Approval(o.optString("request_id"), tool, detail(input), fullInput(tool, input), input.toString()))
|
||||
}
|
||||
"control_cancel_request" -> AgentEvent(resolved = o.optString("request_id"))
|
||||
// The CLI starts turns of its own for background tasks (a resumed session first answers the ones the last
|
||||
// run left behind). Such a result is not the end of the user's turn; the host decides what it ends.
|
||||
"result" -> {
|
||||
@@ -274,7 +347,7 @@ object ClaudeCode : AgentHarness {
|
||||
}.joinToString("\n")
|
||||
}
|
||||
|
||||
/** OpenAI Codex: `codex exec --json`, resumed by thread id. */
|
||||
/** OpenAI Codex: `codex app-server`, its JSON-RPC protocol over stdio, resumed by thread id. */
|
||||
object Codex : AgentHarness {
|
||||
override val id = "codex"
|
||||
override val name = "Codex"
|
||||
@@ -300,6 +373,13 @@ object Codex : AgentHarness {
|
||||
override val plans = false
|
||||
override val efforts = listOf("low", "medium", "high")
|
||||
|
||||
// Codex's sandbox needs Landlock and seccomp, which proot does not provide, so commands run unsandboxed
|
||||
// and "untrusted" is what makes Codex ask before each one that is not known to be safe.
|
||||
override val permissions = listOf(
|
||||
AgentHarness.Permission(AgentHarness.ASK, R.string.agent_permission_ask, R.string.agent_permission_ask_hint),
|
||||
AgentHarness.Permission(AgentHarness.FULL, R.string.agent_permission_full, R.string.agent_permission_full_hint),
|
||||
)
|
||||
|
||||
/** Codex keeps the models its account can use in `~/.codex/models_cache.json` once it has run. */
|
||||
override fun models(rootfs: File): List<AgentHarness.Model> = runCatching {
|
||||
val o = JSONObject(File(rootfs, "root/.codex/models_cache.json").readText())
|
||||
@@ -312,106 +392,230 @@ object Codex : AgentHarness {
|
||||
}
|
||||
}.getOrDefault(emptyList())
|
||||
|
||||
// Codex's own sandbox needs Landlock and seccomp, which proot does not provide.
|
||||
override fun turn(message: String, conversation: String?, options: AgentHarness.Options) = buildList {
|
||||
addAll(listOf(binary, "exec"))
|
||||
if (conversation != null) addAll(listOf("resume", conversation))
|
||||
addAll(listOf("--json", "--dangerously-bypass-approvals-and-sandbox", "--skip-git-repo-check"))
|
||||
options.model?.let { addAll(listOf("-m", it)) }
|
||||
options.effort?.let { addAll(listOf("-c", "model_reasoning_effort=\"$it\"")) }
|
||||
// codex exec has no system prompt option, so a new conversation starts with the brief.
|
||||
add(if (conversation == null && options.brief != null) "${options.brief}\n\n$message" else message)
|
||||
}
|
||||
override fun turn(message: String, conversation: String?, options: AgentHarness.Options) = withoutStderr("codex", listOf(binary, "app-server"))
|
||||
|
||||
override fun parse(line: String): AgentEvent? {
|
||||
val o = runCatching { JSONObject(line) }.getOrNull() ?: return null
|
||||
val item = o.optJSONObject("item")
|
||||
val id = item?.optString("id").orEmpty()
|
||||
val entries = when (o.optString("type")) {
|
||||
"thread.started" -> return AgentEvent(o.optString("thread_id").takeIf { it.isNotEmpty() })
|
||||
"item.started" -> when (item?.optString("type")) {
|
||||
"command_execution" -> shellCommand(item.optString("command")).let { listOf(AgentHost.Entry.Used(id, "Shell", firstLine(it), it)) }
|
||||
"mcp_tool_call" -> listOf(AgentHost.Entry.Used(id, item.optString("tool").ifEmpty { "Tool" }, item.optString("server"), item.optJSONObject("arguments")?.toString(2).orEmpty()))
|
||||
"web_search" -> listOf(AgentHost.Entry.Used(id, "Search", item.optString("query"), item.optString("query")))
|
||||
else -> emptyList()
|
||||
}
|
||||
"item.updated" -> when (item?.optString("type")) {
|
||||
"todo_list" -> listOf(todoEntry(id, item))
|
||||
else -> emptyList()
|
||||
}
|
||||
"item.completed" -> when (item?.optString("type")) {
|
||||
"agent_message" -> item.optString("text").trim().takeIf { it.isNotEmpty() }?.let { listOf(AgentHost.Entry.Said(it)) }.orEmpty()
|
||||
"reasoning" -> item.optString("text").trim().takeIf { it.isNotEmpty() }?.let { listOf(AgentHost.Entry.Thought(it)) }.orEmpty()
|
||||
"command_execution" -> listOf(AgentHost.Entry.Result(id, item.optString("aggregated_output"),
|
||||
item.has("exit_code") && !item.isNull("exit_code") && item.optInt("exit_code") != 0))
|
||||
"mcp_tool_call" -> listOf(AgentHost.Entry.Result(id, item.optJSONObject("result")?.toString(2) ?: item.optJSONObject("error")?.optString("message").orEmpty(),
|
||||
item.optString("status") == "failed"))
|
||||
"web_search" -> listOf(AgentHost.Entry.Result(id, "", false))
|
||||
"file_change" -> listOf(
|
||||
AgentHost.Entry.Used(id, "Edit", changedFiles(item), changedFiles(item).replace(", ", "\n")),
|
||||
AgentHost.Entry.Result(id, item.optString("status"), item.optString("status") == "failed"),
|
||||
)
|
||||
"todo_list" -> listOf(todoEntry(id, item))
|
||||
"error" -> listOf(AgentHost.Entry.Said("⚠ " + item.optString("message")))
|
||||
else -> emptyList()
|
||||
}
|
||||
"turn.completed" -> return AgentEvent(
|
||||
entries = listOf(AgentHost.Entry.Finished(null)),
|
||||
usage = o.optJSONObject("usage")?.let { AgentHost.Usage(0, 0.0, it.optLong("input_tokens") + it.optLong("cached_input_tokens"), it.optLong("output_tokens")) },
|
||||
override fun protocol(): AgentProtocol = Protocol()
|
||||
|
||||
@VisibleForTesting
|
||||
internal class Protocol : AgentProtocol {
|
||||
private var next = 1
|
||||
private var thread: String? = null
|
||||
/** The initialize request, the thread/start or thread/resume sent once it succeeds, and the turn that waits for its thread. */
|
||||
private var initializing = -1
|
||||
private var initialized = false
|
||||
private var open: String? = null
|
||||
private var opening = -1
|
||||
private var waiting: JSONObject? = null
|
||||
private var starting = -1
|
||||
private var turnId = ""
|
||||
/** Each file change's paths and diffs, from its start; an approval for it names only the item. */
|
||||
private val changes = mutableMapOf<String, JSONArray>()
|
||||
private var input = 0L
|
||||
private var output = 0L
|
||||
|
||||
override fun input(message: String, conversation: String?, options: AgentHarness.Options, started: Boolean): List<String> {
|
||||
val turn = JSONObject()
|
||||
.put("input", JSONArray().put(JSONObject().put("type", "text").put("text", message).put("text_elements", JSONArray())))
|
||||
options.model?.let { turn.put("model", it) }
|
||||
options.effort?.let { turn.put("effort", it) }
|
||||
val known = thread
|
||||
if (!started && known != null) return listOf(startTurn(turn.put("threadId", known)))
|
||||
val params = JSONObject()
|
||||
.put("approvalPolicy", if (options.permission == AgentHarness.FULL) "never" else "untrusted")
|
||||
.put("sandbox", "danger-full-access")
|
||||
options.model?.let { params.put("model", it) }
|
||||
options.brief?.let { params.put("developerInstructions", it) }
|
||||
if (conversation != null) params.put("threadId", conversation)
|
||||
waiting = turn
|
||||
opening = next++
|
||||
val request = JSONObject().put("id", opening).put("method", if (conversation != null) "thread/resume" else "thread/start").put("params", params).toString()
|
||||
// Codex refuses a second initialize on one connection, so a thread that failed to open is asked for again alone.
|
||||
if (initialized) return listOf(request)
|
||||
open = request
|
||||
initializing = next++
|
||||
return listOf(
|
||||
JSONObject().put("id", initializing).put("method", "initialize")
|
||||
.put("params", JSONObject().put("clientInfo", JSONObject().put("name", "droiddeck").put("title", "DroidDeck").put("version", "1"))
|
||||
.put("capabilities", JSONObject.NULL)).toString(),
|
||||
)
|
||||
"turn.failed" -> listOf(AgentHost.Entry.Finished(o.optJSONObject("error")?.optString("message") ?: "turn failed"))
|
||||
// codex reports a dropped stream it is retrying as an error event, and the turn goes on.
|
||||
"error" -> o.optString("message").let { message ->
|
||||
if (message.startsWith("Reconnecting...")) emptyList() else listOf(AgentHost.Entry.Finished(message.ifEmpty { "error" }))
|
||||
}
|
||||
else -> emptyList()
|
||||
}
|
||||
return if (entries.isEmpty()) null else AgentEvent(entries = entries)
|
||||
|
||||
private fun startTurn(params: JSONObject): String {
|
||||
starting = next++
|
||||
return JSONObject().put("id", starting).put("method", "turn/start").put("params", params).toString()
|
||||
}
|
||||
|
||||
override fun answer(approval: AgentHost.Approval, allow: Boolean): String =
|
||||
JSONObject(approval.payload).put("result", JSONObject().put("decision", if (allow) "accept" else "decline")).toString()
|
||||
|
||||
override fun parse(line: String): AgentEvent? {
|
||||
val o = runCatching { JSONObject(line) }.getOrNull() ?: return null
|
||||
val method = o.optString("method")
|
||||
if (method.isEmpty()) return response(o)
|
||||
val params = o.optJSONObject("params") ?: JSONObject()
|
||||
if (o.has("id")) return request(o.get("id"), method, params)
|
||||
return notification(method, params)
|
||||
}
|
||||
|
||||
private fun response(o: JSONObject): AgentEvent? {
|
||||
val id = o.optInt("id", -1)
|
||||
val error = o.optJSONObject("error")?.optString("message")?.ifEmpty { "error" }
|
||||
return when (id) {
|
||||
initializing -> {
|
||||
if (error != null) return AgentEvent(entries = listOf(AgentHost.Entry.Finished(error)))
|
||||
initialized = true
|
||||
val request = open ?: return null
|
||||
open = null
|
||||
AgentEvent(reply = listOf(JSONObject().put("method", "initialized").toString(), request))
|
||||
}
|
||||
opening -> {
|
||||
if (error != null) return AgentEvent(entries = listOf(AgentHost.Entry.Finished(error)))
|
||||
val started = o.optJSONObject("result")?.optJSONObject("thread")?.optString("id")?.takeIf { it.isNotEmpty() } ?: return null
|
||||
thread = started
|
||||
val turn = waiting ?: return AgentEvent(started)
|
||||
waiting = null
|
||||
AgentEvent(started, reply = listOf(startTurn(turn.put("threadId", started))))
|
||||
}
|
||||
starting -> error?.let { AgentEvent(entries = listOf(AgentHost.Entry.Finished(it))) }
|
||||
else -> null
|
||||
}
|
||||
}
|
||||
|
||||
private fun request(id: Any, method: String, params: JSONObject): AgentEvent {
|
||||
val payload = JSONObject().put("id", id).toString()
|
||||
return when (method) {
|
||||
"item/commandExecution/requestApproval" -> {
|
||||
val command = shellCommand(params.optString("command"))
|
||||
val reason = params.optString("reason").takeIf { it.isNotEmpty() && it != "null" }
|
||||
AgentEvent(approval = AgentHost.Approval(id.toString(), "Shell", firstLine(command), listOfNotNull(command, reason).joinToString("\n\n"), payload))
|
||||
}
|
||||
"item/fileChange/requestApproval" -> {
|
||||
val list = changes[params.optString("itemId")] ?: JSONArray()
|
||||
val files = (0 until list.length()).mapNotNull { list.optJSONObject(it) }
|
||||
AgentEvent(approval = AgentHost.Approval(
|
||||
id.toString(), "Edit", files.joinToString(", ") { it.optString("path") }.take(400),
|
||||
files.joinToString("\n\n") { it.optString("path") + "\n" + patchLines(it.optString("diff"), it.optJSONObject("kind")?.optString("type").orEmpty()) }, payload,
|
||||
))
|
||||
}
|
||||
// Everything else asks for something DroidDeck has no screen for; refusing keeps the turn going.
|
||||
else -> AgentEvent(reply = listOf(JSONObject(payload)
|
||||
.put("error", JSONObject().put("code", -32601).put("message", "DroidDeck cannot answer $method")).toString()))
|
||||
}
|
||||
}
|
||||
|
||||
private fun notification(method: String, params: JSONObject): AgentEvent? {
|
||||
val item = params.optJSONObject("item")
|
||||
val id = item?.optString("id").orEmpty()
|
||||
val entries: List<AgentHost.Entry> = when (method) {
|
||||
"thread/started" -> return params.optJSONObject("thread")?.optString("id")?.takeIf { it.isNotEmpty() }?.let { AgentEvent(it) }
|
||||
"turn/started" -> {
|
||||
turnId = params.optJSONObject("turn")?.optString("id").orEmpty()
|
||||
input = 0
|
||||
output = 0
|
||||
return null
|
||||
}
|
||||
"item/agentMessage/delta" -> return AgentEvent(text = params.optString("delta"))
|
||||
"item/reasoning/summaryTextDelta", "item/reasoning/textDelta" -> return AgentEvent(thinking = params.optString("delta"))
|
||||
"item/started" -> when (item?.optString("type")) {
|
||||
"commandExecution" -> shellCommand(item.optString("command")).let { listOf(AgentHost.Entry.Used(id, "Shell", firstLine(it), it)) }
|
||||
"mcpToolCall" -> listOf(AgentHost.Entry.Used(id, item.optString("tool").ifEmpty { "Tool" }, item.optString("server"), item.opt("arguments")?.let(::pretty).orEmpty()))
|
||||
"webSearch" -> listOf(AgentHost.Entry.Used(id, "Search", item.optString("query"), item.optString("query")))
|
||||
"fileChange" -> {
|
||||
val list = item.optJSONArray("changes") ?: JSONArray()
|
||||
changes[id] = list
|
||||
fileEntries(id, list)
|
||||
}
|
||||
else -> emptyList()
|
||||
}
|
||||
"item/completed" -> when (item?.optString("type")) {
|
||||
"agentMessage" -> item.optString("text").trim().takeIf { it.isNotEmpty() }?.let { listOf(AgentHost.Entry.Said(it)) }.orEmpty()
|
||||
"reasoning" -> {
|
||||
val parts = (strings(item.optJSONArray("summary")) + strings(item.optJSONArray("content"))).joinToString("\n\n").trim()
|
||||
if (parts.isEmpty()) emptyList() else listOf(AgentHost.Entry.Thought(parts))
|
||||
}
|
||||
"commandExecution" -> {
|
||||
val status = item.optString("status")
|
||||
val exit = if (item.isNull("exitCode")) 0 else item.optInt("exitCode")
|
||||
val out = item.optString("aggregatedOutput").takeUnless { item.isNull("aggregatedOutput") }.orEmpty()
|
||||
listOf(AgentHost.Entry.Result(id, if (status == "declined") out.ifEmpty { DENIED } else out, status != "completed" || exit != 0))
|
||||
}
|
||||
"mcpToolCall" -> listOf(AgentHost.Entry.Result(id,
|
||||
item.optJSONObject("result")?.let(::pretty) ?: item.optJSONObject("error")?.optString("message").orEmpty(), item.optString("status") == "failed"))
|
||||
"webSearch" -> listOf(AgentHost.Entry.Result(id, "", false))
|
||||
"fileChange" -> {
|
||||
val list = item.optJSONArray("changes") ?: changes[id] ?: JSONArray()
|
||||
changes.remove(id)
|
||||
val failed = item.optString("status") != "completed"
|
||||
(0 until list.length()).map { AgentHost.Entry.Result("$id#$it", if (failed) item.optString("status") else "", failed) }
|
||||
}
|
||||
else -> emptyList()
|
||||
}
|
||||
"turn/plan/updated" -> listOf(plan(params.optJSONArray("plan")))
|
||||
"thread/tokenUsage/updated" -> {
|
||||
val usage = params.optJSONObject("tokenUsage") ?: return null
|
||||
val last = usage.optJSONObject("last")
|
||||
input += last?.optLong("inputTokens") ?: 0
|
||||
output += last?.optLong("outputTokens") ?: 0
|
||||
return AgentEvent(
|
||||
context = last?.optLong("totalTokens")?.takeIf { it > 0 },
|
||||
window = usage.optLong("modelContextWindow").takeIf { it > 0 },
|
||||
)
|
||||
}
|
||||
"account/rateLimits/updated" -> return rateLimits(params.optJSONObject("rateLimits"))?.let { AgentEvent(limits = it) }
|
||||
"serverRequest/resolved" -> return AgentEvent(resolved = params.opt("requestId")?.toString())
|
||||
"turn/completed" -> {
|
||||
val turn = params.optJSONObject("turn") ?: JSONObject()
|
||||
val error = when (turn.optString("status")) {
|
||||
"failed" -> turn.optJSONObject("error")?.optString("message")?.ifEmpty { null } ?: "turn failed"
|
||||
else -> null
|
||||
}
|
||||
return AgentEvent(
|
||||
entries = listOf(AgentHost.Entry.Finished(error)),
|
||||
usage = AgentHost.Usage(if (turn.isNull("durationMs")) 0 else turn.optLong("durationMs"), 0.0, input, output),
|
||||
)
|
||||
}
|
||||
else -> emptyList()
|
||||
}
|
||||
return if (entries.isEmpty()) null else AgentEvent(entries = entries)
|
||||
}
|
||||
|
||||
private fun plan(steps: JSONArray?): AgentHost.Entry.Used {
|
||||
val text = (0 until (steps?.length() ?: 0)).mapNotNull { i ->
|
||||
val step = steps?.optJSONObject(i) ?: return@mapNotNull null
|
||||
val mark = when (step.optString("status")) { "completed" -> "[x]"; "inProgress" -> "[~]"; else -> "[ ]" }
|
||||
"$mark ${step.optString("step")}"
|
||||
}.joinToString("\n")
|
||||
return AgentHost.Entry.Used("$turnId-todo", "TodoWrite", "", text, output = "")
|
||||
}
|
||||
}
|
||||
|
||||
private const val TOKEN_COUNT = "\"payload\":{\"type\":\"token_count\""
|
||||
|
||||
/** Codex prints no limits with --json; its session log, named after the thread, has a token_count event each step. */
|
||||
override fun usage(rootfs: File, conversation: String?): AgentEvent? {
|
||||
conversation ?: return null
|
||||
val log = File(rootfs, "root/.codex/sessions").walkBottomUp().filter { it.isFile && it.name.endsWith("-$conversation.jsonl") }
|
||||
.maxByOrNull { it.lastModified() } ?: return null
|
||||
val last = runCatching { log.readLines().lastOrNull { it.contains(TOKEN_COUNT) } }.getOrNull() ?: return null
|
||||
return tokenCount(last)
|
||||
/** One Edit per changed file: its path, then the diff as lines led by ' ', '-' or '+'. */
|
||||
private fun fileEntries(id: String, changes: JSONArray) = (0 until changes.length()).mapNotNull { i ->
|
||||
val change = changes.optJSONObject(i) ?: return@mapNotNull null
|
||||
val path = change.optString("path")
|
||||
AgentHost.Entry.Used("$id#$i", "Edit", path, path + "\n" + patchLines(change.optString("diff"), change.optJSONObject("kind")?.optString("type").orEmpty()))
|
||||
}
|
||||
|
||||
@VisibleForTesting
|
||||
internal fun tokenCount(line: String): AgentEvent? {
|
||||
val payload = runCatching { JSONObject(line).optJSONObject("payload") }.getOrNull()?.takeIf { it.optString("type") == "token_count" } ?: return null
|
||||
val info = payload.optJSONObject("info")
|
||||
val rates = payload.optJSONObject("rate_limits")
|
||||
val limits = listOf("primary", "secondary").mapNotNull { key ->
|
||||
val w = rates?.optJSONObject(key) ?: return@mapNotNull null
|
||||
AgentHost.Limit(w.optInt("window_minutes"), w.optDouble("used_percent", 0.0).toInt(), w.optLong("resets_at"))
|
||||
}
|
||||
return AgentEvent(
|
||||
context = info?.optJSONObject("last_token_usage")?.optLong("total_tokens")?.takeIf { it > 0 },
|
||||
window = info?.optLong("model_context_window")?.takeIf { it > 0 },
|
||||
limits = limits.takeIf { it.isNotEmpty() },
|
||||
)
|
||||
internal fun rateLimits(snapshot: JSONObject?): List<AgentHost.Limit>? {
|
||||
snapshot ?: return null
|
||||
return listOf("primary", "secondary").mapNotNull { key ->
|
||||
val w = snapshot.optJSONObject(key) ?: return@mapNotNull null
|
||||
AgentHost.Limit(w.optInt("windowDurationMins"), w.optDouble("usedPercent", 0.0).toInt(), w.optLong("resetsAt"))
|
||||
}.takeIf { it.isNotEmpty() }
|
||||
}
|
||||
|
||||
private fun todoEntry(id: String, item: JSONObject): AgentHost.Entry.Used {
|
||||
val items = item.optJSONArray("items") ?: JSONArray()
|
||||
val text = (0 until items.length()).mapNotNull { i ->
|
||||
val todo = items.optJSONObject(i) ?: return@mapNotNull null
|
||||
"${if (todo.optBoolean("completed")) "[x]" else "[ ]"} ${todo.optString("text")}"
|
||||
}.joinToString("\n")
|
||||
return AgentHost.Entry.Used("$id-todo", "TodoWrite", "", text, output = "")
|
||||
}
|
||||
private fun strings(list: JSONArray?) = (0 until (list?.length() ?: 0)).mapNotNull { list?.optString(it)?.takeIf { s -> s.isNotBlank() } }
|
||||
|
||||
private fun changedFiles(item: JSONObject): String {
|
||||
val changes = item.optJSONArray("changes") ?: return ""
|
||||
return (0 until changes.length()).mapNotNull { changes.optJSONObject(it)?.optString("path") }.joinToString(", ").take(400)
|
||||
private fun pretty(value: Any): String = when (value) {
|
||||
is JSONObject -> value.toString(2)
|
||||
is JSONArray -> value.toString(2)
|
||||
JSONObject.NULL -> ""
|
||||
else -> value.toString()
|
||||
}
|
||||
}
|
||||
|
||||
/** OpenCode: `opencode run --format json`, resumed by session id. */
|
||||
/** OpenCode: `opencode acp`, the Agent Client Protocol over stdio, resumed by session id. */
|
||||
object OpenCode : AgentHarness {
|
||||
override val id = "opencode"
|
||||
override val name = "OpenCode"
|
||||
@@ -579,86 +783,234 @@ object OpenCode : AgentHarness {
|
||||
|
||||
private val MODEL_ID = Regex("""^[\w.-]+/\S+$""")
|
||||
|
||||
private class Spent(var cost: Double = 0.0, var input: Long = 0, var output: Long = 0)
|
||||
private val spent = Spent()
|
||||
@Volatile private var model: String? = null
|
||||
override val permissions = listOf(
|
||||
AgentHarness.Permission(AgentHarness.ASK, R.string.agent_permission_ask, R.string.agent_permission_ask_hint),
|
||||
AgentHarness.Permission(AgentHarness.EDITS, R.string.agent_permission_edits, R.string.agent_permission_edits_hint),
|
||||
AgentHarness.Permission(AgentHarness.FULL, R.string.agent_permission_full, R.string.agent_permission_full_hint),
|
||||
)
|
||||
|
||||
override fun turn(message: String, conversation: String?, options: AgentHarness.Options): List<String> {
|
||||
synchronized(spent) { spent.cost = 0.0; spent.input = 0; spent.output = 0 }
|
||||
model = options.model
|
||||
// DroidDeck runs the agent unattended; --auto approves all the agent does not deny itself, and plan mode denies edits.
|
||||
return buildList {
|
||||
addAll(listOf(binary, "run", "--format", "json", "--auto", "--thinking"))
|
||||
if (conversation != null) addAll(listOf("-s", conversation))
|
||||
if (options.plan) addAll(listOf("--agent", "plan"))
|
||||
options.model?.let { addAll(listOf("-m", it)) }
|
||||
options.effort?.let { addAll(listOf("--variant", it)) }
|
||||
add("--")
|
||||
// opencode run has no system prompt option, so a new conversation starts with the brief.
|
||||
add(if (conversation == null && options.brief != null) "${options.brief}\n\n$message" else message)
|
||||
/**
|
||||
* Rules merged over the user's opencode config. OpenCode applies the last rule that matches in key order, so the
|
||||
* asking modes name each permission rather than "*", which could land after a rule of the user's and override it.
|
||||
*/
|
||||
@VisibleForTesting
|
||||
internal fun rules(permission: String): JSONObject {
|
||||
val asks = listOf("bash", "webfetch", "websearch", "codesearch")
|
||||
return when (permission) {
|
||||
AgentHarness.FULL -> JSONObject().put("*", "allow")
|
||||
AgentHarness.EDITS -> JSONObject().put("edit", "allow").apply { asks.forEach { put(it, "ask") } }
|
||||
else -> JSONObject().put("edit", "ask").apply { asks.forEach { put(it, "ask") } }
|
||||
}
|
||||
}
|
||||
|
||||
override fun usage(rootfs: File, conversation: String?): AgentEvent? {
|
||||
val id = model ?: return null
|
||||
return listed(rootfs)?.windows?.get(id)?.let { AgentEvent(window = it) }
|
||||
}
|
||||
override fun turn(message: String, conversation: String?, options: AgentHarness.Options) =
|
||||
withoutStderr("opencode", listOf("/usr/bin/env", "OPENCODE_PERMISSION=${rules(options.permission)}", binary, "acp"))
|
||||
|
||||
override fun parse(line: String): AgentEvent? {
|
||||
val o = runCatching { JSONObject(line) }.getOrNull() ?: return null
|
||||
val conversation = o.optString("sessionID").takeIf { it.isNotEmpty() }
|
||||
val part = o.optJSONObject("part")
|
||||
return when (o.optString("type")) {
|
||||
"text" -> AgentEvent(conversation, text(part) { AgentHost.Entry.Said(it) })
|
||||
"reasoning" -> AgentEvent(conversation, text(part) { AgentHost.Entry.Thought(it) })
|
||||
"tool_use" -> AgentEvent(conversation, part?.let { tool(it) }.orEmpty())
|
||||
"step_finish" -> {
|
||||
val tokens = part?.optJSONObject("tokens")
|
||||
val cache = tokens?.optJSONObject("cache")
|
||||
val total = synchronized(spent) {
|
||||
spent.cost += part?.optDouble("cost", 0.0) ?: 0.0
|
||||
spent.input += (tokens?.optLong("input") ?: 0) + (cache?.optLong("read") ?: 0) + (cache?.optLong("write") ?: 0)
|
||||
spent.output += (tokens?.optLong("output") ?: 0) + (tokens?.optLong("reasoning") ?: 0)
|
||||
AgentHost.Usage(0, spent.cost, spent.input, spent.output)
|
||||
/** The conversation's cost so far; DroidDeck takes the turn's share from what its chat has recorded. */
|
||||
override val sessionCost = true
|
||||
|
||||
override fun protocol(): AgentProtocol = Protocol()
|
||||
|
||||
/** `opencode acp`: the Agent Client Protocol, JSON-RPC over stdio. */
|
||||
@VisibleForTesting
|
||||
internal class Protocol : AgentProtocol {
|
||||
private enum class Stage { INIT, SESSION, CONFIG, PROMPT, IDLE }
|
||||
|
||||
private var next = 1
|
||||
private var stage = Stage.IDLE
|
||||
private var pending = -1
|
||||
private var session: String? = null
|
||||
private var resume: String? = null
|
||||
private var cwd = "/root"
|
||||
/** Requests for the session still to send, each once the one before it has been answered. */
|
||||
private val queue = ArrayDeque<(String) -> JSONObject>()
|
||||
private val said = StringBuilder()
|
||||
private val thought = StringBuilder()
|
||||
/** Each tool call's name, which only its first update carries, and its latest entry. */
|
||||
private val names = mutableMapOf<String, String>()
|
||||
private val used = mutableMapOf<String, AgentHost.Entry.Used>()
|
||||
private var cost = 0.0
|
||||
private var started = 0L
|
||||
|
||||
override fun input(message: String, conversation: String?, options: AgentHarness.Options, started: Boolean): List<String> {
|
||||
val text = if (conversation == null && options.brief != null) "${options.brief}\n\n$message" else message
|
||||
val prompt = { id: String ->
|
||||
JSONObject().put("sessionId", id).put("prompt", JSONArray().put(JSONObject().put("type", "text").put("text", text)))
|
||||
}
|
||||
queue.clear()
|
||||
val known = session
|
||||
if (!started && known != null && configured) return listOf(send(Stage.PROMPT, "session/prompt", prompt(known)))
|
||||
fun option(config: String, value: String) = { id: String -> JSONObject().put("sessionId", id).put("configId", config).put("value", value) }
|
||||
options.model?.let { queue += option("model", it) }
|
||||
options.effort?.let { queue += option("effort", it) }
|
||||
queue += option("mode", if (options.plan) "plan" else "build")
|
||||
queue += prompt
|
||||
// A session whose options were refused sets them all again before its next prompt.
|
||||
if (!started && known != null) return listOf(advance(known))
|
||||
resume = conversation
|
||||
cwd = options.workdir
|
||||
return listOf(send(Stage.INIT, "initialize", JSONObject().put("protocolVersion", 1).put("clientCapabilities", JSONObject())))
|
||||
}
|
||||
|
||||
private fun send(stage: Stage, method: String, params: JSONObject): String {
|
||||
this.stage = stage
|
||||
pending = next++
|
||||
if (stage == Stage.PROMPT) started = System.currentTimeMillis()
|
||||
return JSONObject().put("jsonrpc", "2.0").put("id", pending).put("method", method).put("params", params).toString()
|
||||
}
|
||||
|
||||
/** The next queued request: the prompt once nothing else is left. */
|
||||
private fun advance(id: String): String {
|
||||
val make = queue.removeFirst()
|
||||
val params = make(id)
|
||||
configuring = params.optString("configId")
|
||||
configured = queue.isEmpty()
|
||||
return if (queue.isEmpty()) send(Stage.PROMPT, "session/prompt", params) else send(Stage.CONFIG, "session/set_config_option", params)
|
||||
}
|
||||
|
||||
/** The config option the pending set_config_option sets. */
|
||||
private var configuring = ""
|
||||
/** The session's model, effort and mode were all set, so a later prompt can go straight to it. */
|
||||
private var configured = false
|
||||
|
||||
override fun answer(approval: AgentHost.Approval, allow: Boolean): String = JSONObject(approval.payload).put("jsonrpc", "2.0")
|
||||
.put("result", JSONObject().put("outcome", JSONObject().put("outcome", "selected").put("optionId", if (allow) "once" else "reject"))).toString()
|
||||
|
||||
override fun parse(line: String): AgentEvent? {
|
||||
val o = runCatching { JSONObject(line) }.getOrNull() ?: return null
|
||||
val method = o.optString("method")
|
||||
val params = o.optJSONObject("params") ?: JSONObject()
|
||||
return when {
|
||||
method.isEmpty() -> response(o)
|
||||
o.has("id") -> request(o.get("id"), method, params)
|
||||
method == "session/update" -> update(params.optJSONObject("update") ?: return null)
|
||||
else -> null
|
||||
}
|
||||
}
|
||||
|
||||
private fun response(o: JSONObject): AgentEvent? {
|
||||
if (o.optInt("id", -1) != pending) return null
|
||||
val error = o.optJSONObject("error")?.let { it.optJSONObject("data")?.optString("message")?.ifEmpty { null } ?: it.optString("message").ifEmpty { "error" } }
|
||||
val result = o.optJSONObject("result") ?: JSONObject()
|
||||
return when (stage) {
|
||||
Stage.INIT -> error?.let(::failed) ?: AgentEvent(reply = listOf(
|
||||
resume?.let { send(Stage.SESSION, "session/resume", JSONObject().put("sessionId", it).put("cwd", cwd).put("mcpServers", JSONArray())) }
|
||||
?: send(Stage.SESSION, "session/new", JSONObject().put("cwd", cwd).put("mcpServers", JSONArray())),
|
||||
))
|
||||
Stage.SESSION -> {
|
||||
if (error != null) return failed(error)
|
||||
val id = result.optString("sessionId").ifEmpty { resume.orEmpty() }.takeIf { it.isNotEmpty() } ?: return failed("no session")
|
||||
session = id
|
||||
AgentEvent(id, reply = listOf(advance(id)))
|
||||
}
|
||||
val context = tokens?.optLong("total")?.takeIf { it > 0 }
|
||||
// A step that ends to run tools is followed by another; any other reason ends the turn.
|
||||
if (part?.optString("reason") == "tool-calls") AgentEvent(conversation, context = context)
|
||||
else AgentEvent(conversation, listOf(AgentHost.Entry.Finished(null)), context = context, usage = total)
|
||||
// A model without effort levels refuses one and the turn goes on with its default; a refused
|
||||
// mode would run a plan turn as a build one, so it ends the turn instead.
|
||||
Stage.CONFIG -> if (error != null && configuring == "mode") failed(error) else AgentEvent(reply = listOf(advance(session ?: return null)))
|
||||
Stage.PROMPT -> {
|
||||
stage = Stage.IDLE
|
||||
val usage = result.optJSONObject("usage")
|
||||
val reason = result.optString("stopReason")
|
||||
AgentEvent(
|
||||
session,
|
||||
flush() + AgentHost.Entry.Finished(error ?: if (reason == "refusal") "refused" else null),
|
||||
usage = AgentHost.Usage(
|
||||
System.currentTimeMillis() - started, cost,
|
||||
(usage?.optLong("inputTokens") ?: 0) + (usage?.optLong("cachedReadTokens") ?: 0),
|
||||
(usage?.optLong("outputTokens") ?: 0) + (usage?.optLong("thoughtTokens") ?: 0),
|
||||
),
|
||||
)
|
||||
}
|
||||
Stage.IDLE -> null
|
||||
}
|
||||
"error" -> {
|
||||
val error = o.optJSONObject("error")
|
||||
val message = error?.optJSONObject("data")?.optString("message")?.takeIf { it.isNotEmpty() }
|
||||
?: error?.optString("message")?.takeIf { it.isNotEmpty() } ?: error?.optString("name")?.takeIf { it.isNotEmpty() } ?: "error"
|
||||
AgentEvent(conversation, listOf(AgentHost.Entry.Finished(message)))
|
||||
}
|
||||
|
||||
private fun failed(error: String): AgentEvent {
|
||||
stage = Stage.IDLE
|
||||
configured = false
|
||||
return AgentEvent(session, flush() + AgentHost.Entry.Finished(error))
|
||||
}
|
||||
|
||||
private fun request(id: Any, method: String, params: JSONObject): AgentEvent {
|
||||
val payload = JSONObject().put("id", id).toString()
|
||||
if (method != "session/request_permission") {
|
||||
// File writes and terminals stay with OpenCode, which does them itself when the client declines.
|
||||
return AgentEvent(reply = listOf(JSONObject(payload).put("jsonrpc", "2.0")
|
||||
.put("error", JSONObject().put("code", -32601).put("message", "DroidDeck cannot answer $method")).toString()))
|
||||
}
|
||||
else -> conversation?.let { AgentEvent(it) }
|
||||
val call = params.optJSONObject("toolCall") ?: JSONObject()
|
||||
val raw = call.optJSONObject("rawInput") ?: JSONObject()
|
||||
val name = names[call.optString("toolCallId")] ?: call.optString("kind")
|
||||
val kind = call.optString("kind")
|
||||
val approval = when {
|
||||
kind == "execute" -> AgentHost.Approval(id.toString(), "Bash", firstLine(raw.optString("command")), raw.optString("command"), payload)
|
||||
// OpenCode asks for a folder outside the workspace on its own, before the tool's own ask.
|
||||
raw.has("parentDir") -> AgentHost.Approval(
|
||||
id.toString(), "External directory", raw.optString("parentDir"),
|
||||
listOf(raw.optString("parentDir"), raw.optString("command")).filter { it.isNotEmpty() }.joinToString("\n\n"), payload,
|
||||
)
|
||||
raw.has("diff") -> {
|
||||
val path = raw.optString("filepath")
|
||||
AgentHost.Approval(id.toString(), "Edit", path, path + "\n" + patchLines(raw.optString("diff"), ""), payload)
|
||||
}
|
||||
else -> AgentHost.Approval(id.toString(), toolName(name), call.optString("title"), raw.toString(2), payload)
|
||||
}
|
||||
return AgentEvent(session, flush(), approval = approval)
|
||||
}
|
||||
|
||||
private fun update(u: JSONObject): AgentEvent? = when (u.optString("sessionUpdate")) {
|
||||
"agent_message_chunk" -> chunk(u)?.let { said.append(it); AgentEvent(session, text = it) }
|
||||
"agent_thought_chunk" -> chunk(u)?.let { thought.append(it); AgentEvent(session, thinking = it) }
|
||||
"tool_call", "tool_call_update" -> AgentEvent(session, flush() + tool(u))
|
||||
"usage_update" -> {
|
||||
u.optJSONObject("cost")?.optDouble("amount")?.takeIf { !it.isNaN() }?.let { cost = it }
|
||||
AgentEvent(session, context = u.optLong("used").takeIf { it > 0 }, window = u.optLong("size").takeIf { it > 0 })
|
||||
}
|
||||
else -> null
|
||||
}
|
||||
|
||||
private fun chunk(u: JSONObject) = u.optJSONObject("content")?.takeIf { it.optString("type") == "text" }?.optString("text")?.takeIf { it.isNotEmpty() }
|
||||
|
||||
/** What was written since the last entry, as whole entries. */
|
||||
private fun flush(): List<AgentHost.Entry> = buildList {
|
||||
thought.toString().trim().takeIf { it.isNotEmpty() }?.let { add(AgentHost.Entry.Thought(it)) }
|
||||
said.toString().trim().takeIf { it.isNotEmpty() }?.let { add(AgentHost.Entry.Said(it)) }
|
||||
thought.clear()
|
||||
said.clear()
|
||||
}
|
||||
|
||||
private fun tool(u: JSONObject): List<AgentHost.Entry> {
|
||||
val id = u.optString("toolCallId")
|
||||
if (u.optString("sessionUpdate") == "tool_call") names[id] = u.optString("title")
|
||||
val input = u.optJSONObject("rawInput")?.takeIf { it.length() > 0 }
|
||||
val entry = if (input != null || used[id] == null) tool(id, names[id].orEmpty(), input ?: JSONObject()) else used.getValue(id)
|
||||
used[id] = entry
|
||||
val raw = u.optJSONObject("rawOutput")
|
||||
return when (u.optString("status")) {
|
||||
"completed" -> {
|
||||
val exit = raw?.optJSONObject("metadata")?.opt("exit")
|
||||
listOf(entry, AgentHost.Entry.Result(id, raw?.optString("output")?.ifEmpty { null } ?: content(u), exit is Number && exit.toInt() != 0))
|
||||
}
|
||||
"failed" -> listOf(entry, AgentHost.Entry.Result(id, raw?.optString("error")?.ifEmpty { null } ?: content(u), true))
|
||||
else -> listOf(entry)
|
||||
}
|
||||
}
|
||||
|
||||
private fun content(u: JSONObject): String {
|
||||
val list = u.optJSONArray("content") ?: return ""
|
||||
return (0 until list.length()).mapNotNull { list.optJSONObject(it)?.optJSONObject("content")?.optString("text") }.joinToString("\n")
|
||||
}
|
||||
}
|
||||
|
||||
private fun text(part: JSONObject?, entry: (String) -> AgentHost.Entry) =
|
||||
part?.optString("text")?.trim()?.takeIf { it.isNotEmpty() }?.let { listOf(entry(it)) }.orEmpty()
|
||||
private fun toolName(name: String) = name.replaceFirstChar { it.uppercase() }.ifEmpty { "Tool" }
|
||||
|
||||
private fun tool(part: JSONObject): List<AgentHost.Entry> {
|
||||
val id = part.optString("callID").ifEmpty { part.optString("id") }
|
||||
val state = part.optJSONObject("state") ?: JSONObject()
|
||||
val input = state.optJSONObject("input") ?: JSONObject()
|
||||
private fun tool(id: String, name: String, input: JSONObject): AgentHost.Entry.Used {
|
||||
val path = input.optString("filePath")
|
||||
val (name, detail, full) = when (val tool = part.optString("tool")) {
|
||||
"bash" -> Triple("Bash", firstLine(input.optString("command")), input.optString("command"))
|
||||
"edit" -> Triple("Edit", path, path + "\n" + lineDiff(input.optString("oldString"), input.optString("newString")))
|
||||
"write" -> Triple("Write", path, path + "\n" + lineDiff("", input.optString("content")))
|
||||
"todowrite" -> Triple("TodoWrite", "", todos(input.optJSONArray("todos")))
|
||||
else -> Triple(tool.replaceFirstChar { it.uppercase() }.ifEmpty { "Tool" }, detail(input), input.toString(2))
|
||||
}
|
||||
val used = AgentHost.Entry.Used(id, name, detail, full)
|
||||
return when (state.optString("status")) {
|
||||
"completed" -> {
|
||||
val exit = state.optJSONObject("metadata")?.opt("exit")
|
||||
listOf(used, AgentHost.Entry.Result(id, state.optString("output"), exit is Number && exit.toInt() != 0))
|
||||
}
|
||||
"error" -> listOf(used, AgentHost.Entry.Result(id, state.optString("error"), true))
|
||||
else -> listOf(used)
|
||||
return when (name) {
|
||||
"bash" -> AgentHost.Entry.Used(id, "Bash", firstLine(input.optString("command")), input.optString("command"))
|
||||
"edit" -> AgentHost.Entry.Used(id, "Edit", path, path + "\n" + lineDiff(input.optString("oldString"), input.optString("newString")))
|
||||
"write" -> AgentHost.Entry.Used(id, "Write", path, path + "\n" + lineDiff("", input.optString("content")))
|
||||
"todowrite" -> AgentHost.Entry.Used(id, "TodoWrite", "", todos(input.optJSONArray("todos")))
|
||||
else -> AgentHost.Entry.Used(id, toolName(name), detail(input), if (input.length() == 0) "" else input.toString(2))
|
||||
}
|
||||
}
|
||||
|
||||
@@ -679,6 +1031,13 @@ object OpenCode : AgentHarness {
|
||||
@VisibleForTesting
|
||||
internal fun firstLine(text: String) = text.lineSequence().first().take(160)
|
||||
|
||||
/**
|
||||
* [command] with its stderr in a log of its own under /root/.cache/droiddeck. The agent's stdout and stderr share one
|
||||
* pipe, and a log line written in the middle of a long JSON line would make that line unreadable.
|
||||
*/
|
||||
internal fun withoutStderr(log: String, command: List<String>) =
|
||||
listOf("/bin/sh", "-c", "mkdir -p /root/.cache/droiddeck; exec \"\$@\" 2>/root/.cache/droiddeck/$log.log", "sh") + command
|
||||
|
||||
private const val DIFF_CONTEXT = 2
|
||||
|
||||
/**
|
||||
@@ -701,6 +1060,18 @@ internal fun lineDiff(old: String, new: String): String {
|
||||
}.joinToString("\n")
|
||||
}
|
||||
|
||||
/** A unified diff's hunks without their headers; an added or deleted file's diff is its whole content. */
|
||||
@VisibleForTesting
|
||||
internal fun patchLines(diff: String, kind: String): String {
|
||||
val lines = diff.removeSuffix("\n").lines()
|
||||
when (kind) {
|
||||
"add" -> return lines.joinToString("\n") { "+$it" }
|
||||
"delete" -> return lines.joinToString("\n") { "-$it" }
|
||||
}
|
||||
val start = lines.indexOfFirst { it.startsWith("@@") }
|
||||
return (if (start < 0) lines else lines.drop(start)).filter { it.isNotEmpty() && !it.startsWith("@@") && !it.startsWith("\\") }.joinToString("\n")
|
||||
}
|
||||
|
||||
private val SHELL_WRAPPER = Regex("^/bin/(?:ba)?sh -l?c '(.*)'$", RegexOption.DOT_MATCHES_ALL)
|
||||
|
||||
/** Codex runs each command as `/bin/bash -lc '<command>'`; the command is what the user wants to read. */
|
||||
|
||||
@@ -21,8 +21,8 @@ import java.nio.file.Files
|
||||
|
||||
/**
|
||||
* The launcher's agent: a coding agent CLI ([AgentHarness]) from the Linux userland, run headless
|
||||
* outside any game or desktop session: one process per turn, or for a CLI that takes its messages over
|
||||
* stdin one process kept open between turns, so background work can start a turn of its own. Conversations are kept on disk
|
||||
* outside any game or desktop session as one process that takes its messages over stdin and stays open
|
||||
* between turns, so background work can start a turn of its own. Conversations are kept on disk
|
||||
* ([AgentChats]), so a restart (a Lab build, a crash) continues the same one.
|
||||
*/
|
||||
object AgentHost {
|
||||
@@ -56,6 +56,9 @@ object AgentHost {
|
||||
/** A message typed while the agent was working, sent when the turn ends. */
|
||||
data class Queued(val text: String, val files: List<String>)
|
||||
|
||||
/** A tool call the CLI waits on the user to allow; [payload] is what its protocol needs to answer. */
|
||||
data class Approval(val id: String, val tool: String, val detail: String, val input: String, val payload: String = "")
|
||||
|
||||
enum class State { MISSING, IDLE, WORKING }
|
||||
|
||||
private const val TAG = "AgentHost"
|
||||
@@ -94,6 +97,12 @@ object AgentHost {
|
||||
private set
|
||||
var plan by mutableStateOf(false)
|
||||
private set
|
||||
/** The chosen [AgentHarness.Permission] of [harness]; asking first until the user picks another. */
|
||||
var permission by mutableStateOf(AgentHarness.ASK)
|
||||
private set
|
||||
/** Tool calls of the running turn that wait for the user, oldest first. */
|
||||
val approvals = mutableStateListOf<Approval>()
|
||||
private var approvalNoticed = false
|
||||
var chat by mutableStateOf<String?>(null)
|
||||
private set
|
||||
/** A reply finished since the conversation was last on screen. */
|
||||
@@ -123,7 +132,9 @@ object AgentHost {
|
||||
var lab by mutableStateOf<LabProgress?>(null)
|
||||
private set
|
||||
|
||||
private class Turn(val process: Process, val pid: Int, val stdin: java.io.OutputStream? = null) {
|
||||
private class Turn(val process: Process, val pid: Int, val protocol: AgentProtocol, val stdin: java.io.OutputStream) {
|
||||
fun write(lines: List<String>) = synchronized(this) { stdin.apply { lines.forEach { write((it + "\n").toByteArray()) }; flush() } }
|
||||
|
||||
var writingGeneration: Int? = null
|
||||
var exitStatus: Int? = null
|
||||
var costs: AgentCostTracker? = null
|
||||
@@ -171,6 +182,8 @@ object AgentHost {
|
||||
model = prefs(app).getString(modelKey(harness), null)
|
||||
effort = prefs(app).getString(effortKey(harness), null)?.takeIf { it in harness.efforts }
|
||||
plan = prefs(app).getBoolean(PLAN_KEY, false)
|
||||
permission = prefs(app).getString(permissionKey(harness), null)?.takeIf { id -> harness.permissions.any { it.id == id } }
|
||||
?: harness.permissions.first().id
|
||||
limits = decodeLimits(prefs(app).getString(limitsKey(harness), null))
|
||||
available = LinuxRuntime.hasRootfs(app)
|
||||
installed = harness.files.all { guestFileExists(app, it) }
|
||||
@@ -273,6 +286,42 @@ object AgentHost {
|
||||
prefs(context).edit().putBoolean(PLAN_KEY, on).apply()
|
||||
}
|
||||
|
||||
/** Kept per CLI, for every conversation; the CLI process restarts with it on the next message. */
|
||||
fun choosePermission(context: Context, id: String) {
|
||||
if (harness.permissions.none { it.id == id }) return
|
||||
permission = id
|
||||
prefs(context).edit().putString(permissionKey(harness), id).apply()
|
||||
}
|
||||
|
||||
/** Lets the CLI run [approval]'s tool call, or tells it the user said no. */
|
||||
fun answer(context: Context, approval: Approval, allow: Boolean) {
|
||||
if (!approvals.remove(approval)) return
|
||||
val running = turn ?: session ?: return
|
||||
val line = running.protocol.answer(approval, allow)
|
||||
val app = context.applicationContext
|
||||
val current = harness
|
||||
Thread({ runCatching { running.write(listOf(line)) }.onFailure { lost(app, running, current, it) } }, "agent-approval").start()
|
||||
approvalsChanged(app)
|
||||
}
|
||||
|
||||
/** The approval notice goes once nothing waits on the user any more. */
|
||||
private fun approvalsChanged(app: Context) {
|
||||
if (approvals.isNotEmpty() || !approvalNoticed) return
|
||||
approvalNoticed = false
|
||||
AgentNotice.clear(app)
|
||||
}
|
||||
|
||||
/**
|
||||
* A line the CLI waits for could not be written, so it would wait forever: its process ends, which ends
|
||||
* the turn, and the chat says why. A request that may have reached it is not sent again.
|
||||
*/
|
||||
private fun lost(app: Context, from: Turn, current: AgentHarness, error: Throwable) {
|
||||
Log.w(TAG, "could not write to ${current.name}", error)
|
||||
main.post { if (turn === from || session === from) record(app, Entry.Notice("Could not write to ${current.name}: ${error.message ?: error.javaClass.simpleName}")) }
|
||||
AgentProcesses.killTree(from.pid)
|
||||
from.process.destroy()
|
||||
}
|
||||
|
||||
fun models(context: Context) = harness.models(LinuxRuntime.rootDir(context.applicationContext))
|
||||
|
||||
/** Sends [text] now, or after the current turn when the agent is working. */
|
||||
@@ -303,19 +352,20 @@ object AgentHost {
|
||||
val current = harness
|
||||
val prompt = AgentAttachments.prompt(message, attached)
|
||||
turnPlanned = plan && current.plans
|
||||
val options = AgentHarness.Options(model, turnPlanned, BRIEF, effort)
|
||||
val command = current.turn(prompt, conversation, options)
|
||||
val line = current.input(prompt)
|
||||
val key = "${current.id}|$id|$model|$turnPlanned|$effort"
|
||||
val options = AgentHarness.Options(model, turnPlanned, BRIEF, effort, permission, workspace(app))
|
||||
val key = "${current.id}|$id|$model|$turnPlanned|$effort|$permission"
|
||||
val resumed = conversation
|
||||
background = false
|
||||
approvals.clear()
|
||||
approvalsChanged(app)
|
||||
val kept = session
|
||||
if (kept != null && line != null && sessionKey == key && kept.process.isAlive) {
|
||||
if (kept != null && sessionKey == key && kept.process.isAlive) {
|
||||
main.removeCallbacks(reap)
|
||||
turn = kept
|
||||
kept.writingGeneration = gen
|
||||
kept.clearingCosts = prompt == "/clear"
|
||||
Thread({
|
||||
val written = runCatching { synchronized(kept) { kept.stdin?.apply { write((line + "\n").toByteArray()); flush() } != null } }.getOrDefault(false)
|
||||
val written = runCatching { kept.write(kept.protocol.input(prompt, resumed, options, started = false)) }.isSuccess
|
||||
// The process died between turns: the same message goes to a new one, which resumes the conversation.
|
||||
main.post {
|
||||
if (kept.writingGeneration == gen) kept.writingGeneration = null
|
||||
@@ -323,7 +373,7 @@ object AgentHost {
|
||||
if (!written) {
|
||||
dropSession()
|
||||
turn = null
|
||||
spawn(app, gen, current, current.turn(prompt, conversation, options), line, key)
|
||||
spawn(app, gen, current, prompt, resumed, options, key)
|
||||
} else kept.exitStatus?.let { processExited(app, kept, current, it) }
|
||||
}
|
||||
}
|
||||
@@ -331,12 +381,14 @@ object AgentHost {
|
||||
return
|
||||
}
|
||||
dropSession()
|
||||
spawn(app, gen, current, command, line, key)
|
||||
spawn(app, gen, current, prompt, resumed, options, key)
|
||||
}
|
||||
|
||||
private fun spawn(app: Context, gen: Int, current: AgentHarness, command: List<String>, line: String?, key: String) {
|
||||
val workdir = workspace(app)
|
||||
var threadConversation = conversation
|
||||
private fun spawn(app: Context, gen: Int, current: AgentHarness, prompt: String, resumed: String?, options: AgentHarness.Options, key: String) {
|
||||
val workdir = options.workdir
|
||||
val command = current.turn(prompt, resumed, options)
|
||||
val protocol = current.protocol()
|
||||
var threadConversation = resumed
|
||||
Thread({
|
||||
runCatching { current.prepare(LinuxRuntime.rootDir(app)) }
|
||||
runCatching { AgentSetup.installHelpers(app) }
|
||||
@@ -349,17 +401,18 @@ object AgentHost {
|
||||
main.post { if (generation == gen) finish(app, e.message ?: "could not start") }
|
||||
return@Thread
|
||||
}
|
||||
val started = Turn(child, AgentProcesses.pidOf(child), if (line != null) child.outputStream else null).apply {
|
||||
if (current === ClaudeCode && line != null) costs = AgentCostTracker()
|
||||
val started = Turn(child, AgentProcesses.pidOf(child), protocol, child.outputStream).apply {
|
||||
if (current === ClaudeCode) costs = AgentCostTracker()
|
||||
}
|
||||
OrphanReaper.keep(started.pid)
|
||||
main.post {
|
||||
if (generation == gen && state == State.WORKING && turn == null) {
|
||||
turn = started
|
||||
if (line != null) { session = started; sessionKey = key }
|
||||
session = started
|
||||
sessionKey = key
|
||||
} else AgentProcesses.killTree(started.pid)
|
||||
}
|
||||
if (line != null) runCatching { child.outputStream.apply { write((line + "\n").toByteArray()); flush() } } else child.outputStream.close()
|
||||
runCatching { started.write(protocol.input(prompt, resumed, options, started = true)) }.onFailure { lost(app, started, current, it) }
|
||||
val raw = runCatching {
|
||||
val log = File(app.filesDir, TURN_LOG).apply { parentFile?.mkdirs() }
|
||||
log.renameTo(File(app.filesDir, "$TURN_LOG.1"))
|
||||
@@ -368,7 +421,8 @@ object AgentHost {
|
||||
runCatching {
|
||||
child.inputStream.bufferedReader().forEachLine { output ->
|
||||
runCatching { raw?.apply { write(output); newLine(); flush() } }
|
||||
val parsed = current.parse(output) ?: return@forEachLine
|
||||
val parsed = protocol.parse(output) ?: return@forEachLine
|
||||
if (parsed.reply.isNotEmpty()) runCatching { started.write(parsed.reply) }.onFailure { lost(app, started, current, it) }
|
||||
parsed.conversation?.let { threadConversation = it }
|
||||
val done = parsed.entries.any { it is Entry.Finished }
|
||||
val event = if (!done) parsed else runCatching { current.usage(LinuxRuntime.rootDir(app), threadConversation) }.getOrNull()
|
||||
@@ -410,7 +464,7 @@ object AgentHost {
|
||||
if (background && state == State.WORKING) finish(app, event.backgroundError, usage = event.usage?.let { from.costs?.perTurn(it) ?: it })
|
||||
return
|
||||
}
|
||||
val content = event.text != null || event.thinking != null || event.entries.any { it !is Entry.Finished }
|
||||
val content = event.text != null || event.thinking != null || event.approval != null || event.entries.any { it !is Entry.Finished }
|
||||
if (content && state == State.IDLE && session === from) {
|
||||
main.removeCallbacks(reap)
|
||||
background = true
|
||||
@@ -428,10 +482,17 @@ object AgentHost {
|
||||
from.clearingCosts = false
|
||||
}
|
||||
val applied = if (finished != null && state == State.WORKING && event.usage != null)
|
||||
event.copy(usage = from.costs?.perTurn(event.usage) ?: event.usage) else event
|
||||
event.copy(usage = turnCost(from.costs?.perTurn(event.usage) ?: event.usage)) else event
|
||||
apply(app, applied)
|
||||
}
|
||||
|
||||
/** A CLI that reports the conversation's whole cost spent what this chat has not recorded yet. */
|
||||
private fun turnCost(usage: Usage): Usage {
|
||||
if (!harness.sessionCost) return usage
|
||||
val recorded = entries.sumOf { (it as? Entry.Finished)?.usage?.costUsd ?: 0.0 }
|
||||
return usage.copy(costUsd = (usage.costUsd - recorded).coerceAtLeast(0.0))
|
||||
}
|
||||
|
||||
/** Ends the CLI process kept between turns, and with it whatever it still runs in the background. */
|
||||
private fun dropSession() {
|
||||
main.removeCallbacks(reap)
|
||||
@@ -529,6 +590,15 @@ object AgentHost {
|
||||
}
|
||||
event.text?.let { live += it }
|
||||
event.thinking?.let { liveThinking += it }
|
||||
event.resolved?.let { id ->
|
||||
approvals.removeAll { it.id == id }
|
||||
approvalsChanged(app)
|
||||
}
|
||||
event.approval?.takeIf { a -> state == State.WORKING && approvals.none { it.id == a.id } }?.let {
|
||||
approvals += it
|
||||
approvalNoticed = true
|
||||
AgentNotice.post(app, AgentNotice.Kind.APPROVAL, listOf(it.tool, it.detail).filter { s -> s.isNotEmpty() }.joinToString(": "))
|
||||
}
|
||||
event.context?.let { context = it }
|
||||
event.window?.let { window = it }
|
||||
event.limits?.let { reported ->
|
||||
@@ -549,6 +619,8 @@ object AgentHost {
|
||||
private fun finish(app: Context, error: String?, stopped: Boolean = false, usage: Usage? = null) {
|
||||
if (state != State.WORKING) return
|
||||
turn = null
|
||||
approvals.clear()
|
||||
approvalsChanged(app)
|
||||
val answeredTask = background
|
||||
background = false
|
||||
main.removeCallbacks(reap)
|
||||
@@ -762,6 +834,7 @@ object AgentHost {
|
||||
private const val LINGER_MS = 20 * 60_000L
|
||||
|
||||
private fun modelKey(harness: AgentHarness) = "model_${harness.id}"
|
||||
private fun permissionKey(harness: AgentHarness) = "permission_${harness.id}"
|
||||
private fun limitsKey(harness: AgentHarness) = "limits_${harness.id}"
|
||||
|
||||
@VisibleForTesting
|
||||
|
||||
@@ -16,10 +16,10 @@ internal object AgentNotice {
|
||||
private const val CHANNEL_ID = "agent_done"
|
||||
private const val NOTIFICATION_ID = 4108
|
||||
|
||||
enum class Kind { DONE, FAILED, QUESTION }
|
||||
enum class Kind { DONE, FAILED, QUESTION, APPROVAL }
|
||||
|
||||
fun post(context: Context, kind: Kind, text: String) {
|
||||
if (onScreen(context)) return
|
||||
if (onScreen(context, kind)) return
|
||||
val manager = context.getSystemService(NotificationManager::class.java) ?: return
|
||||
manager.createNotificationChannel(NotificationChannel(CHANNEL_ID, context.getString(R.string.agent_done_channel), NotificationManager.IMPORTANCE_DEFAULT))
|
||||
val open = PendingIntent.getActivity(context, 2,
|
||||
@@ -31,6 +31,7 @@ internal object AgentNotice {
|
||||
Kind.DONE -> R.string.agent_done
|
||||
Kind.FAILED -> R.string.agent_done_failed
|
||||
Kind.QUESTION -> R.string.agent_done_question
|
||||
Kind.APPROVAL -> R.string.agent_done_approval
|
||||
})
|
||||
runCatching {
|
||||
manager.notify(NOTIFICATION_ID, Notification.Builder(context, CHANNEL_ID)
|
||||
@@ -49,9 +50,9 @@ internal object AgentNotice {
|
||||
context.getSystemService(NotificationManager::class.java)?.cancel(NOTIFICATION_ID)
|
||||
}
|
||||
|
||||
/** The chat in a DroidDeck window in front, or the pet, which shows the reply in its own bubble. */
|
||||
private fun onScreen(context: Context): Boolean {
|
||||
if (AgentPet.floating) return true
|
||||
/** The chat in a DroidDeck window in front, or the pet, which shows the reply in its own bubble but has no way to answer an approval. */
|
||||
private fun onScreen(context: Context, kind: Kind): Boolean {
|
||||
if (AgentPet.floating && kind != Kind.APPROVAL) return true
|
||||
val state = ActivityManager.RunningAppProcessInfo().also { ActivityManager.getMyMemoryState(it) }
|
||||
return AgentPet.agentOnScreen > 0 && state.importance <= ActivityManager.RunningAppProcessInfo.IMPORTANCE_FOREGROUND
|
||||
}
|
||||
|
||||
@@ -30,6 +30,7 @@ import androidx.compose.foundation.layout.WindowInsets
|
||||
import androidx.compose.foundation.layout.fillMaxSize
|
||||
import androidx.compose.foundation.layout.fillMaxWidth
|
||||
import androidx.compose.foundation.layout.height
|
||||
import androidx.compose.foundation.layout.heightIn
|
||||
import androidx.compose.foundation.layout.ime
|
||||
import androidx.compose.foundation.layout.imePadding
|
||||
import androidx.compose.foundation.layout.padding
|
||||
@@ -39,6 +40,7 @@ import androidx.compose.foundation.lazy.LazyColumn
|
||||
import androidx.compose.foundation.lazy.LazyListState
|
||||
import androidx.compose.foundation.lazy.rememberLazyListState
|
||||
import androidx.compose.foundation.rememberScrollState
|
||||
import androidx.compose.foundation.verticalScroll
|
||||
import androidx.compose.foundation.shape.CircleShape
|
||||
import androidx.compose.foundation.text.BasicTextField
|
||||
import androidx.compose.foundation.text.KeyboardActions
|
||||
@@ -128,7 +130,7 @@ import kotlinx.coroutines.launch
|
||||
internal enum class AgentPanel { NONE, MODEL, USAGE, HISTORY, PROCESSES, TOOLS }
|
||||
|
||||
/** Slash commands the app handles itself; others go to the CLI, which has its own. */
|
||||
private val LOCAL_COMMANDS = listOf("/new", "/model", "/plan", "/history", "/processes", "/stop")
|
||||
private val LOCAL_COMMANDS = listOf("/new", "/model", "/permissions", "/plan", "/history", "/processes", "/stop")
|
||||
private val CLI_COMMANDS = listOf("/compact", "/cost", "/review", "/init")
|
||||
|
||||
/**
|
||||
@@ -207,7 +209,7 @@ private fun AgentPageContent(
|
||||
var setup by rememberSaveable { mutableStateOf(false) }
|
||||
val draft = rememberSaveable { mutableStateOf("") }
|
||||
if (setup || AgentHost.state == AgentHost.State.MISSING || !(AgentSetup.ready || AgentSetup.completed(context))) {
|
||||
AgentSetupView(modifier, onDone = { setup = false })
|
||||
AgentSetupView(modifier, firstControl = inputModifier, onDone = { setup = false })
|
||||
return
|
||||
}
|
||||
var panel by rememberSaveable { mutableStateOf(AgentPanel.NONE) }
|
||||
@@ -233,6 +235,10 @@ private fun AgentPageContent(
|
||||
// The keyboard leaves too little height for a panel and the editor together, so typing closes the panel.
|
||||
val keyboardOpen = WindowInsets.ime.getBottom(LocalDensity.current) > 0
|
||||
LaunchedEffect(keyboardOpen) { if (keyboardOpen && (panel == AgentPanel.MODEL || panel == AgentPanel.USAGE)) panel = AgentPanel.NONE }
|
||||
// History, processes and tools take the whole page, which would hide an approval the turn is waiting on.
|
||||
LaunchedEffect(AgentHost.approvals.size, panel) {
|
||||
if (AgentHost.approvals.isNotEmpty() && (panel == AgentPanel.HISTORY || panel == AgentPanel.PROCESSES || panel == AgentPanel.TOOLS)) panel = AgentPanel.NONE
|
||||
}
|
||||
Column(
|
||||
modifier.fillMaxSize().imePadding().onPreviewKeyEvent { e ->
|
||||
val k = e.nativeKeyEvent
|
||||
@@ -279,7 +285,8 @@ private fun AgentPageContent(
|
||||
readingBack = false
|
||||
scope.launch { list.scrollToItem(maxOf(0, list.layoutInfo.totalItemsCount - 1), Int.MAX_VALUE / 2) }
|
||||
}
|
||||
val hidden = !composer.focused && !composer.hasUnconsumedFocusRequest() && readingBack && AgentHost.entries.isNotEmpty()
|
||||
val hidden = !composer.focused && !composer.hasUnconsumedFocusRequest() && readingBack && AgentHost.entries.isNotEmpty() &&
|
||||
AgentHost.approvals.isEmpty()
|
||||
var listHeight by remember { mutableIntStateOf(0) }
|
||||
Box(
|
||||
Modifier.weight(1f).fillMaxWidth().clipToBounds().nestedScroll(dragBack).onGloballyPositioned {
|
||||
@@ -354,7 +361,7 @@ private fun AgentTopBar(panel: AgentPanel, onPanel: (AgentPanel) -> Unit, firstC
|
||||
}
|
||||
}
|
||||
|
||||
/** The harness, model, effort and plan mode, opening the model picker; [compact] names only the model. */
|
||||
/** The harness, model, effort, a permission mode other than asking first and plan mode, opening the model picker; [compact] names only the model. */
|
||||
@Composable
|
||||
private fun ModelChip(panel: AgentPanel, onPanel: (AgentPanel) -> Unit, firstControl: Modifier, modifier: Modifier = Modifier, compact: Boolean = false) {
|
||||
val context = LocalContext.current
|
||||
@@ -365,8 +372,12 @@ private fun ModelChip(panel: AgentPanel, onPanel: (AgentPanel) -> Unit, firstCon
|
||||
modifier = modifier.then(if (compact) Modifier.widthIn(max = 120.dp) else Modifier).height(36.dp).clip(Shape12).then(firstControl)
|
||||
.clickable { onPanel(AgentPanel.MODEL) }.padding(horizontal = 8.dp).testTag("agent-model"),
|
||||
) {
|
||||
val parts = if (compact) listOf(model)
|
||||
else listOfNotNull(AgentHost.harness.name, model, AgentHost.effort, stringResource(R.string.agent_plan_short).takeIf { AgentHost.plan && AgentHost.harness.plans })
|
||||
val mode = AgentHost.harness.permissions.drop(1).firstOrNull { it.id == AgentHost.permission }?.let { stringResource(it.label) }
|
||||
val parts = if (compact) listOfNotNull(mode ?: model)
|
||||
else listOfNotNull(
|
||||
AgentHost.harness.name, model, AgentHost.effort, mode,
|
||||
stringResource(R.string.agent_plan_short).takeIf { AgentHost.plan && AgentHost.harness.plans },
|
||||
)
|
||||
Text(parts.joinToString(" · "), fontSize = 13.sp, color = if (panel == AgentPanel.MODEL) pal.primary else pal.onSurfaceVariant,
|
||||
maxLines = 1, overflow = TextOverflow.Ellipsis, modifier = Modifier.weight(1f, fill = false))
|
||||
Icon(Icons.Outlined.ExpandMore, null, tint = pal.onSurfaceVariant, modifier = Modifier.size(16.dp))
|
||||
@@ -523,6 +534,39 @@ internal fun clock(seconds: Long): String {
|
||||
}
|
||||
}
|
||||
|
||||
/** The oldest tool call that waits for the user; tapping its input shows all of it. */
|
||||
@Composable
|
||||
private fun AgentApprovalCard(approval: AgentHost.Approval, more: Int) {
|
||||
val context = LocalContext.current
|
||||
val colors = MaterialTheme.colorScheme
|
||||
val pal = LocalPalette.current
|
||||
var open by remember(approval.id) { mutableStateOf(false) }
|
||||
Column(
|
||||
Modifier.fillMaxWidth().padding(top = 8.dp).clip(Shape14).background(colors.surface).border(1.dp, AttentionAmber, Shape14)
|
||||
.padding(horizontal = 14.dp, vertical = 10.dp).testTag("agent-approval"),
|
||||
) {
|
||||
Row(verticalAlignment = Alignment.CenterVertically, horizontalArrangement = Arrangement.spacedBy(8.dp)) {
|
||||
Column(Modifier.weight(1f)) {
|
||||
Text(stringResource(R.string.agent_approval_title, approval.tool), fontSize = 14.sp, fontWeight = FontWeight.SemiBold, color = colors.onBackground)
|
||||
if (more > 0) Text(stringResource(R.string.agent_approval_more, more), fontSize = 12.5.sp, color = pal.onSurfaceVariant)
|
||||
}
|
||||
SecondaryButton(stringResource(R.string.agent_approval_deny), compact = true, modifier = Modifier.testTag("agent-approval-deny")) {
|
||||
AgentHost.answer(context, approval, allow = false)
|
||||
}
|
||||
PrimaryButton(stringResource(R.string.agent_approval_allow), compact = true, modifier = Modifier.testTag("agent-approval-allow")) {
|
||||
AgentHost.answer(context, approval, allow = true)
|
||||
}
|
||||
}
|
||||
val body = approval.input.ifBlank { approval.detail }
|
||||
val shown = Modifier.fillMaxWidth().padding(top = 6.dp)
|
||||
.then(if (open) Modifier.heightIn(max = 280.dp).verticalScroll(rememberScrollState()) else Modifier).clickable { open = !open }
|
||||
if (body.isNotBlank()) Text(
|
||||
body, fontSize = 12.sp, fontFamily = FontFamily.Monospace, color = pal.onSurfaceVariant,
|
||||
maxLines = if (open) Int.MAX_VALUE else 4, overflow = TextOverflow.Ellipsis, modifier = shown,
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
@Composable
|
||||
private fun AgentLabCard() {
|
||||
val context = LocalContext.current
|
||||
@@ -675,7 +719,7 @@ private fun AgentComposer(
|
||||
val text = draft.trim()
|
||||
when (text.substringBefore(' ')) {
|
||||
"/new" -> AgentHost.forget(context)
|
||||
"/model" -> onPanel(AgentPanel.MODEL)
|
||||
"/model", "/permissions" -> onPanel(AgentPanel.MODEL)
|
||||
"/plan" -> AgentHost.choosePlan(context, !AgentHost.plan)
|
||||
"/history" -> onPanel(AgentPanel.HISTORY)
|
||||
"/processes" -> onPanel(AgentPanel.PROCESSES)
|
||||
@@ -692,6 +736,7 @@ private fun AgentComposer(
|
||||
val keyboardOpen = WindowInsets.ime.getBottom(LocalDensity.current) > 0
|
||||
Column(Modifier.fillMaxWidth().padding(bottom = if (keyboardOpen) 4.dp else 8.dp)) {
|
||||
if (labOpen) AgentLabCard()
|
||||
AgentHost.approvals.firstOrNull()?.let { AgentApprovalCard(it, AgentHost.approvals.size - 1) }
|
||||
if (hasActivity()) Row(
|
||||
horizontalArrangement = Arrangement.spacedBy(8.dp), verticalAlignment = Alignment.CenterVertically,
|
||||
modifier = Modifier.padding(top = 8.dp).fillMaxWidth().horizontalScroll(rememberScrollState()),
|
||||
|
||||
@@ -67,7 +67,7 @@ import kotlinx.coroutines.Dispatchers
|
||||
import kotlinx.coroutines.delay
|
||||
import kotlinx.coroutines.withContext
|
||||
|
||||
/** The model, reasoning effort and plan mode for the next turns; a conversation keeps going with whatever is chosen. */
|
||||
/** The model, reasoning effort, permissions and plan mode for the next turns; a conversation keeps going with whatever is chosen. */
|
||||
@Composable
|
||||
internal fun AgentModelPicker() {
|
||||
val context = LocalContext.current
|
||||
@@ -92,6 +92,20 @@ internal fun AgentModelPicker() {
|
||||
}
|
||||
}
|
||||
}
|
||||
val modes = AgentHost.harness.permissions
|
||||
if (modes.size > 1) Column(verticalArrangement = Arrangement.spacedBy(6.dp)) {
|
||||
Text(stringResource(R.string.agent_permissions), fontSize = 15.sp, fontWeight = FontWeight.SemiBold, color = MaterialTheme.colorScheme.onBackground, modifier = Modifier.padding(horizontal = 2.dp))
|
||||
Row(horizontalArrangement = Arrangement.spacedBy(8.dp), modifier = Modifier.horizontalScroll(rememberScrollState())) {
|
||||
for (mode in modes) {
|
||||
val label = stringResource(mode.label)
|
||||
if (mode.id == AgentHost.permission) PrimaryButton(label, compact = true, modifier = Modifier.testTag("agent-permission")) {}
|
||||
else SecondaryButton(label, compact = true, modifier = Modifier.testTag("agent-permission")) { AgentHost.choosePermission(context, mode.id) }
|
||||
}
|
||||
}
|
||||
modes.firstOrNull { it.id == AgentHost.permission }?.let {
|
||||
Text(stringResource(it.hint), fontSize = 12.5.sp, color = pal.onSurfaceVariant, modifier = Modifier.padding(horizontal = 2.dp))
|
||||
}
|
||||
}
|
||||
if (AgentHost.harness.plans) Row(verticalAlignment = Alignment.CenterVertically, modifier = Modifier.fillMaxWidth().padding(horizontal = 2.dp)) {
|
||||
Column(Modifier.weight(1f)) {
|
||||
Text(stringResource(R.string.agent_plan), fontSize = 15.sp, fontWeight = FontWeight.SemiBold, color = MaterialTheme.colorScheme.onBackground)
|
||||
|
||||
@@ -48,7 +48,7 @@ import com.droiddeck.launcher.agent.AgentSetup.Step
|
||||
import com.droiddeck.launcher.core.WirelessAdbPairingService
|
||||
|
||||
@Composable
|
||||
internal fun AgentSetupView(modifier: Modifier, onDone: () -> Unit = {}) {
|
||||
internal fun AgentSetupView(modifier: Modifier, firstControl: Modifier = Modifier, onDone: () -> Unit = {}) {
|
||||
val context = LocalContext.current
|
||||
val colors = MaterialTheme.colorScheme
|
||||
val pal = LocalPalette.current
|
||||
@@ -78,7 +78,7 @@ internal fun AgentSetupView(modifier: Modifier, onDone: () -> Unit = {}) {
|
||||
Row(horizontalArrangement = Arrangement.spacedBy(10.dp)) {
|
||||
for (harness in AgentHarness.all) {
|
||||
val chosen = harness == AgentHost.harness
|
||||
if (chosen) PrimaryButton(harness.name, compact = true) {} else SecondaryButton(harness.name, enabled = !AgentSetup.busy, compact = true) { AgentHost.choose(context, harness) }
|
||||
if (chosen) PrimaryButton(harness.name, compact = true, modifier = firstControl) {} else SecondaryButton(harness.name, enabled = !AgentSetup.busy, compact = true) { AgentHost.choose(context, harness) }
|
||||
}
|
||||
}
|
||||
val steps = Step.entries
|
||||
|
||||
@@ -14,7 +14,7 @@ internal enum class SessionDrawerPage(val firstControl: String) {
|
||||
}
|
||||
|
||||
internal fun sessionDrawerPages(
|
||||
hasSecondScreen: Boolean, hasGlasses: Boolean = false, hasAgent: Boolean = com.droiddeck.launcher.agent.AgentHost.installed && com.droiddeck.launcher.agent.AgentTab.shown,
|
||||
hasSecondScreen: Boolean, hasGlasses: Boolean = false, hasAgent: Boolean = com.droiddeck.launcher.agent.AgentTab.shown,
|
||||
): List<SessionDrawerPage> =
|
||||
SessionDrawerPage.entries.filter {
|
||||
(hasSecondScreen || it != SessionDrawerPage.SECOND_SCREEN) && (hasGlasses || it != SessionDrawerPage.GLASSES) &&
|
||||
|
||||
@@ -1256,6 +1256,7 @@
|
||||
<string name="agent_done">Agent finished</string>
|
||||
<string name="agent_done_failed">Agent stopped with an error</string>
|
||||
<string name="agent_done_question">Agent has a question</string>
|
||||
<string name="agent_done_approval">Agent is waiting for your OK</string>
|
||||
<plurals name="agent_subagent_steps">
|
||||
<item quantity="one">%d step</item>
|
||||
<item quantity="other">%d steps</item>
|
||||
@@ -1333,6 +1334,21 @@
|
||||
<string name="agent_plan">Plan first</string>
|
||||
<string name="agent_plan_short">Plan</string>
|
||||
<string name="agent_plan_hint">Proposes a plan without changing anything</string>
|
||||
<string name="agent_permissions">Permissions</string>
|
||||
<string name="agent_permission_ask">Ask first</string>
|
||||
<string name="agent_permission_ask_hint">Asks before edits and commands that need your OK</string>
|
||||
<string name="agent_permission_edits">Accept edits</string>
|
||||
<string name="agent_permission_edits_hint">Edits files freely, asks before commands</string>
|
||||
<string name="agent_permission_auto">Auto</string>
|
||||
<string name="agent_permission_auto_hint">A safety check decides, blocking risky actions</string>
|
||||
<string name="agent_permission_dont_ask">Don\'t ask</string>
|
||||
<string name="agent_permission_dont_ask_hint">Denies anything your settings don\'t allow</string>
|
||||
<string name="agent_permission_full">Full access</string>
|
||||
<string name="agent_permission_full_hint">Runs everything without asking</string>
|
||||
<string name="agent_approval_title">Allow %1$s?</string>
|
||||
<string name="agent_approval_allow">Allow</string>
|
||||
<string name="agent_approval_deny">Deny</string>
|
||||
<string name="agent_approval_more">+%1$d more</string>
|
||||
<string name="agent_history">Conversations</string>
|
||||
<string name="agent_history_empty">No conversations yet</string>
|
||||
<string name="agent_just_now">Just now</string>
|
||||
|
||||
@@ -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))
|
||||
|
||||
Reference in new issue
Block a user