opencode-queue 0.10.0 → 0.11.0

package/README.md

@@ -79,6 +79,7 @@ When the session is busy:
 
 - Queued entries are hidden from the transcript and from the running agent.
 - The current agent run keeps using its original agent, model, and thinking variant.
+- Each queued entry replays with the agent, model, and thinking variant selected when it was queued.
 - Queued entries replay in order after the session completes normally and becomes idle.
 - `/queue front ...` puts an entry before the existing queued entries.
 - Only one queued entry is sent per idle transition, so queued work runs one item at a time.

package/index.ts

@@ -1,19 +1,18 @@
 import type { Plugin } from "@opencode-ai/plugin"
 import type { AgentPartInput, FilePart, FilePartInput, SubtaskPartInput, TextPart, TextPartInput } from "@opencode-ai/sdk"
+import { HttpServerResponse } from "effect/unstable/http"
 
 const QUEUE = /^\/queue(?:\s+([\s\S]*))?$/
 const SUFFIX = /^([\s\S]*?)\s+\/queue(?:\s+(front))?\s*$/
 const CMD = /^\/(\S+)(?:\s+([\s\S]*))?$/
 const ITEM_NUMBER = /^[1-9]\d*$/
-const HANDLED = "__QUEUE_HANDLED__"
 const TUI_COMPACT = "session_compact"
 
 type InputPart = TextPartInput | FilePartInput | AgentPartInput | SubtaskPartInput
 type Model = { providerID: string; modelID: string }
-type Meta = { variant?: string; controls?: string[]; fast?: boolean }
 type Run = { agent: string; model?: Model }
-type Info = { agent: string; model: Model } & Meta
-type Msg = { info: { role: string; agent?: string; mode?: string; model?: Model; providerID?: string; modelID?: string } & Meta }
+type Info = { agent: string; model: Model; variant?: string }
+type Msg = { info: { role: string; agent?: string; mode?: string; model?: Model; providerID?: string; modelID?: string; variant?: string } }
 type Ask = { type: string; properties: { id: string; sessionID: string; questions: { question: string; header: string }[] } }
 type Post = (input: { url: string; path?: Record<string, string>; body?: unknown; headers?: Record<string, string> }) => Promise<{ response?: Response; error?: unknown } | undefined>
 type QueueInput = { body: string; front: boolean }
@@ -129,6 +128,11 @@ const control = (op: Op): op is ControlOp => {
 const shouldQueue = (state?: State) => Boolean(state && (state.activity.kind !== "idle" || state.stopped))
 const shouldDeclinePlan = (state?: State) => Boolean(state && (state.activity.kind === "sending" || (!state.stopped && state.items.length)))
 const itemText = (item: Item) => (item.kind === "prompt" ? item.body.trim() || item.label : item.source)
+// OpenCode's command hook has no cancel/noReply output. Throwing a raw Effect
+// response is handled by OpenCode's HTTP layer as an empty successful command.
+const handled = (): never => {
+  throw HttpServerResponse.empty({ status: 204 })
+}
 const plan = (event: unknown): event is Ask => {
   if (typeof event !== "object" || !event || !("type" in event) || event.type !== "question.asked") return false
   const question = (event as Ask).properties?.questions?.[0]
@@ -154,7 +158,7 @@ export const QueuePlugin: Plugin = async ({ client }) => {
 
   const stop = async (message: string, variant: "info" | "error" = "info", duration = 5000): Promise<never> => {
     await toast(message, variant, duration)
-    throw new Error(HANDLED)
+    return handled()
   }
 
   const no = async (id: string) => {
@@ -202,9 +206,9 @@ export const QueuePlugin: Plugin = async ({ client }) => {
     })
 
     return ([...(Array.isArray(result) ? result : (result.data ?? []))].reverse() as Msg[]).flatMap((msg): Info[] => {
-      if (msg.info.role === "user" && msg.info.agent && msg.info.model) return [{ agent: msg.info.agent, model: msg.info.model, variant: msg.info.variant, controls: msg.info.controls, fast: msg.info.fast }]
+      if (msg.info.role === "user" && msg.info.agent && msg.info.model) return [{ agent: msg.info.agent, model: msg.info.model, variant: msg.info.variant }]
       if (msg.info.role === "assistant" && (msg.info.agent || msg.info.mode) && msg.info.providerID && msg.info.modelID) {
-        return [{ agent: msg.info.agent ?? msg.info.mode!, model: { providerID: msg.info.providerID, modelID: msg.info.modelID }, variant: msg.info.variant, controls: msg.info.controls, fast: msg.info.fast }]
+        return [{ agent: msg.info.agent ?? msg.info.mode!, model: { providerID: msg.info.providerID, modelID: msg.info.modelID }, variant: msg.info.variant }]
       }
       return []
     })[0]
@@ -217,7 +221,7 @@ export const QueuePlugin: Plugin = async ({ client }) => {
     return { agent: "build" }
   }
 
-  const opts = (info: Info) => ({ agent: info.agent, model: info.model, variant: info.variant, controls: info.controls, fast: info.fast })
+  const opts = (info: Info) => ({ agent: info.agent, model: info.model, variant: info.variant })
 
   const shell = (sid: string, command: string, info: Run) => client.session.shell({ path: { id: sid }, body: { agent: info.agent, model: info.model, command } })
   // TUI command events target the focused session; queued replay must target the original session.
@@ -406,17 +410,17 @@ export const QueuePlugin: Plugin = async ({ client }) => {
       if (!shouldQueue(sessions.get(sid))) {
         if (op.kind === "shell") {
           await shell(sid, op.shell, await run(sid))
-          throw new Error(HANDLED)
+          return handled()
         }
 
         if (op.kind === "compact") {
           await client.tui.executeCommand({ body: { command: TUI_COMPACT }, throwOnError: true })
-          throw new Error(HANDLED)
+          return handled()
         }
 
         if (op.kind === "command") {
           await client.session.command({ path: { id: sid }, body: { command: op.cmd, arguments: op.args, parts } as any })
-          throw new Error(HANDLED)
+          return handled()
         }
 
         output.parts.splice(0, output.parts.length, { type: "text", text: op.body } as any, ...parts)
@@ -436,7 +440,7 @@ export const QueuePlugin: Plugin = async ({ client }) => {
       const current = state(sid)
       const parts = files(output.parts)
       const op = parse(request, parts.length)
-      const meta = input as Meta
+      const info = { agent: input.agent ?? output.message.agent, model: input.model ?? output.message.model, variant: input.variant }
 
       if (control(op)) {
         hide(output.message.id, text)
@@ -454,19 +458,18 @@ export const QueuePlugin: Plugin = async ({ client }) => {
         if (op.kind === "command") return
         if (op.kind === "compact") {
           hide(output.message.id, text)
-          await compact(sid, { agent: output.message.agent, model: output.message.model, variant: meta.variant, controls: meta.controls, fast: meta.fast })
+          await compact(sid, info)
           return
         }
         if (op.kind === "shell") {
           hide(output.message.id, text)
-          await shell(sid, op.shell, { agent: output.message.agent, model: output.message.model })
+          await shell(sid, op.shell, info)
           return
         }
         text.text = request.body
         return
       }
 
-      const info = { agent: output.message.agent, model: { ...output.message.model }, variant: meta.variant, controls: meta.controls, fast: meta.fast }
       const prior = await latest(sid)
       if (prior) Object.assign(output.message, opts(prior))
       else console.warn("QueuePlugin could not neutralize queued placeholder metadata because the session has no previous message context")

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "opencode-queue",
-  "version": "0.10.0",
+  "version": "0.11.0",
   "type": "module",
   "description": "Queue OpenCode prompts and slash commands until the agent is idle",
   "main": "./index.ts",
@@ -37,6 +37,9 @@
   "scripts": {
     "typecheck": "tsc --noEmit"
   },
+  "dependencies": {
+    "effect": "4.0.0-beta.59"
+  },
   "devDependencies": {
     "@opencode-ai/plugin": "^1.14.37",
     "@opencode-ai/sdk": "^1.14.37",