opencode-raven 2.2.2 → 2.3.1

package/rpc.ts

@@ -0,0 +1,45 @@
+import type { Rpc } from "@opencode/plugin"
+import { z } from "zod"
+
+// Portable contract shared by the v2 server, terminal companion, and clients.
+export const RavenRpc = {
+  id: "opencode-raven",
+  methods: {
+    refreshMcps: {
+      input: z.object({ serverName: z.string().optional() }),
+      output: z.object({ refreshed: z.array(z.string()), failed: z.array(z.string()) }),
+    },
+    command: {
+      input: z.object({ arguments: z.string() }),
+      output: z.object({ text: z.string() }),
+    },
+  },
+  events: {
+    notice: {
+      schema: z.object({
+        kind: z.enum(["command", "toast"]),
+        message: z.string(),
+        title: z.string().optional(),
+        sessionID: z.string().optional(),
+        variant: z.enum(["info", "success", "warning", "error"]).optional(),
+        duration: z.number().optional(),
+      }),
+    },
+  },
+} as const satisfies Rpc.PortableDefinition
+
+export default RavenRpc
+
+export function mcpRefreshArguments(raw: string): { serverName?: string } | undefined {
+  const match = raw.trim().match(/^mcp\s+refresh(?:\s+(.+))?$/i)
+  return match ? (match[1] ? { serverName: match[1].trim() } : {}) : undefined
+}
+
+export function mcpRefreshToast(result: { refreshed: string[]; failed: string[] }) {
+  const refreshed = result.refreshed.length ? result.refreshed.join(", ") : "none"
+  const failed = result.failed.length ? result.failed.join(", ") : "none"
+  return {
+    title: "Raven MCP", message: `Refresh complete.\nRefreshed: ${refreshed}\nFailed: ${failed}`,
+    variant: result.failed.length ? "warning" as const : "success" as const, duration: 6000,
+  }
+}

package/tui.ts

@@ -0,0 +1,99 @@
+import type { Plugin } from "@opencode/plugin/tui"
+import { RavenRpc, mcpRefreshArguments, mcpRefreshToast } from "./rpc"
+
+export default {
+  id: "opencode-raven.tui",
+  setup(ctx) {
+    const rpc = ctx.client.rpc(RavenRpc)
+    const refreshController = new AbortController()
+    const refreshes = new Map<string, Promise<void>>()
+    const refreshMcps = (input: { serverName?: string } = {}) => {
+      const key = input.serverName?.toLowerCase() ?? "*"
+      const pending = refreshes.get(key)
+      if (pending) return pending
+      ctx.ui.toast.show({ title: "Raven MCP", message: `Refreshing ${input.serverName ?? "on-demand MCPs"}…`, variant: "info", duration: 3000 })
+      const run = rpc.refreshMcps(input, {
+        location: ctx.location ?? ctx.data.location.default(), signal: refreshController.signal,
+      }).then((result) => {
+        if (!refreshController.signal.aborted) ctx.ui.toast.show(mcpRefreshToast(result))
+      }).catch((error) => {
+        if (refreshController.signal.aborted) return
+        ctx.ui.toast.show({ title: "Raven MCP", message: `Refresh failed: ${String(error)}. Retry /raven mcp refresh.`, variant: "error", duration: 6000 })
+      }).finally(() => refreshes.delete(key))
+      refreshes.set(key, run)
+      return run
+    }
+    const show = async (text: string) => {
+      // Load the host's OpenTUI peer only when the terminal needs it.
+      const { BoxRenderable, TextRenderable, ScrollBoxRenderable, RGBA } = await import("@opentui/core")
+      ctx.ui.dialog.show(() => {
+        const theme = ctx.theme.surface("dialog")
+        const color = theme.background.base
+        const backgroundColor = RGBA.fromValues(color.r, color.g, color.b, 1)
+        const height = () => Math.max(1, Math.min(32, ctx.renderer.height - 4))
+        const box = new BoxRenderable(ctx.renderer, {
+          width: "100%", height: height(), flexDirection: "column",
+          paddingX: 2, paddingY: 1, gap: 1, backgroundColor, overflow: "hidden",
+        })
+        box.add(new TextRenderable(ctx.renderer, {
+          content: "Raven", fg: theme.text.base, flexShrink: 0,
+        }))
+        const scroll = new ScrollBoxRenderable(ctx.renderer, {
+          flexGrow: 1, minHeight: 1, scrollX: false, scrollY: true,
+          contentOptions: { paddingRight: 1 },
+        })
+        scroll.add(new TextRenderable(ctx.renderer, {
+          content: text, fg: theme.text.base, width: "100%", wrapMode: "word", flexShrink: 0,
+        }))
+        box.add(scroll)
+        box.add(new TextRenderable(ctx.renderer, {
+          content: "↑/↓ PgUp/PgDn wheel · esc close",
+          fg: theme.text.muted, flexShrink: 0, wrapMode: "word",
+        }))
+        const resize = () => { box.height = height() }
+        ctx.renderer.on("resize", resize)
+        box.once("destroyed", () => ctx.renderer.off("resize", resize))
+        scroll.focus()
+        return box
+      })
+      ctx.ui.dialog.set({ size: "large", centered: true })
+    }
+    const unsubscribe = rpc.events.on("notice", async (event) => {
+      const location = ctx.location ?? ctx.data.location.default()
+      if (event.location?.directory !== location.directory) return
+      if (event.data.sessionID) {
+        const route = ctx.ui.router.current()
+        if (route.type !== "session" || route.sessionID !== event.data.sessionID) return
+      }
+      if (event.data.kind === "command") {
+        const route = ctx.ui.router.current()
+        if (route.type !== "session" || route.sessionID !== event.data.sessionID) return
+        await show(event.data.message)
+      } else {
+        ctx.ui.toast.show(event.data)
+      }
+    })
+    // V2's service outlives the TUI. Check MCP health on each client attachment,
+    // not just once when the server plugin is initialized.
+    void refreshMcps()
+    ctx.keymap.layer(() => ({ commands: [{
+      id: "raven", title: "Raven", description: "Manage Raven routing, MCPs, models, and status",
+      slash: { name: "raven", arguments: true },
+      async run(input = "") {
+        try {
+          const args = input.replace(/^\s*\/raven(?:\s+|$)/i, "").trim()
+          const refresh = mcpRefreshArguments(args)
+          if (refresh) { await refreshMcps(refresh); return }
+          const result = await rpc.command({ arguments: args }, { location: ctx.location ?? ctx.data.location.default() })
+          await show(result.text)
+        } catch (error) {
+          ctx.ui.toast.show({ title: "Raven", message: String(error), variant: "error" })
+        }
+      },
+    }] }))
+    return () => {
+      refreshController.abort()
+      unsubscribe()
+    }
+  },
+} satisfies Plugin.Definition

package/v2.ts

@@ -0,0 +1,353 @@
+import type { Plugin, Agent } from "@opencode/plugin"
+import type { PluginInput, Hooks, ToolContext as V1ToolContext } from "@opencode-ai/plugin"
+import type { SessionMessageInfo, SessionInfo } from "@opencode/client"
+import { z } from "zod"
+import createRavenRuntime from "./raven-core"
+import { RavenRpc, mcpRefreshArguments, mcpRefreshToast } from "./rpc"
+
+type Context = Plugin.Context
+type RequestOptions = NonNullable<Parameters<Context["session"]["get"]>[1]>
+type Runtime = Awaited<ReturnType<typeof createRavenRuntime>>
+type Registration = { dispose(): Promise<void> }
+type Call = { path?: { id: string }; body?: Record<string, any>; signal?: AbortSignal }
+type AgentDefinition = {
+  description: string
+  mode: "subagent"
+  hidden: boolean
+  disable: boolean
+  model?: string
+  options: Record<string, unknown>
+  permission: Record<string, "allow" | "deny" | "ask">
+  prompt: string
+}
+
+function modelRef(value: string): NonNullable<Agent.Info["model"]> {
+  const slash = value.indexOf("/")
+  if (slash < 1 || slash === value.length - 1) throw new Error(`Invalid Raven model: ${value}`)
+  const [id, variant] = value.slice(slash + 1).split("#")
+  if (!id || value.slice(0, slash).includes("#") || value.split("#").length > 2 || (variant !== undefined && !variant)) throw new Error(`Invalid Raven model: ${value}`)
+  return { providerID: value.slice(0, slash), id, ...(variant ? { variant } : {}) } as NonNullable<Agent.Info["model"]>
+}
+
+function legacyError(error: { type: string; message: string; status?: number; response?: { body: string } }) {
+  return { name: error.type, data: { message: error.message, statusCode: error.status, responseBody: error.response?.body } }
+}
+
+// V2 projects messages directly, rather than wrapping them in { info, parts }.
+// Preserve agent switches when validating persisted continuation history.
+function legacyMessages(messages: readonly SessionMessageInfo[], session: SessionInfo) {
+  let agent = typeof session.metadata?.opencodeRavenAgent === "string"
+    ? session.metadata.opencodeRavenAgent : session.agent
+  const currentAgentMatches = session.agent === agent
+  return messages.map((message) => {
+    if (message.type === "agent-switched") agent = message.agent
+    if (message.type === "assistant") {
+      return { info: { ...message, role: "assistant" }, parts: message.content }
+    }
+    return {
+      info: { ...message, role: message.type, agent: currentAgentMatches ? agent : session.agent },
+      parts: message.type === "user" ? [{ type: "text", text: message.text }] : [],
+    }
+  })
+}
+
+export async function setupRaven(ctx: Context): Promise<Plugin.Cleanup> {
+  const registrations: Registration[] = []
+  const controller = new AbortController()
+  const location = { directory: ctx.location.directory }
+  const agents: Record<string, AgentDefinition> = {}
+  const activeSessions = new Set<string>()
+  let emitNotice: (notice: z.infer<typeof RavenRpc.events.notice.schema>) => Promise<void> = async () => {}
+  let runtime: Runtime | undefined
+  let startupTimer: ReturnType<typeof setTimeout> | undefined
+  let eventPump: Promise<void> | undefined
+  let disposed = false
+
+  const requestOptions = (call: Call): RequestOptions => ({ signal: call.signal ? AbortSignal.any([call.signal, controller.signal]) : controller.signal })
+
+  // Adapt only the host boundary. Raven's MCP transports, state, timeout logic,
+  // command parser, and continuation validation remain shared with v1.
+  const client = {
+    provider: {
+      async list(call: Call) {
+        const response = await ctx.model.list({ location }, requestOptions(call))
+        const models = response.data.filter((model) => model.providerID === "opencode" && model.enabled)
+        return { data: {
+          connected: models.length ? ["opencode"] : [],
+          all: [{ id: "opencode", models: Object.fromEntries(models.map((model) => [model.id, {
+            id: model.id,
+            status: model.status,
+            release_date: new Date(model.time.released).toISOString(),
+            tool_call: model.capabilities.tools,
+            cost: model.cost.length && model.cost.every((tier) => tier.input === 0 && tier.output === 0)
+              ? { input: 0, output: 0 } : { input: 1, output: 1 },
+            limit: model.limit,
+          }])) }],
+        } }
+      },
+    },
+    session: {
+      async get(call: Call) {
+        return { data: await ctx.session.get({ sessionID: call.path!.id }, requestOptions(call)) }
+      },
+      async create(call: Call) {
+        const agent = String(call.body!.agent)
+        const definition = agents[agent]
+        if (!definition?.model) throw new Error(`Raven agent ${agent} has no configured model`)
+        return { data: await ctx.session.create({
+          parentID: call.body!.parentID,
+          title: call.body!.title,
+          agent,
+          model: modelRef(definition.model),
+          location,
+          metadata: { opencodeRavenAgent: agent },
+        }, requestOptions(call)) }
+      },
+      async update(call: Call) {
+        await ctx.session.update({ sessionID: call.path!.id, title: call.body!.title }, requestOptions(call))
+      },
+      async messages(call: Call) {
+        const sessionID = call.path!.id
+        const options = requestOptions(call)
+        const [messages, session] = await Promise.all([
+          ctx.session.context({ sessionID }, options), ctx.session.get({ sessionID }, options),
+        ])
+        return { data: legacyMessages(messages, session) }
+      },
+      async abort(call: Call) {
+        await ctx.session.interrupt({ sessionID: call.path!.id, resume: false }, requestOptions(call))
+      },
+      async prompt(call: Call) {
+        const sessionID = call.path!.id
+        const options = requestOptions(call)
+        const session = await ctx.session.get({ sessionID }, options)
+        if (session.agent !== call.body!.agent) throw new Error("Raven session agent changed; start a new retrieval")
+        activeSessions.add(sessionID)
+        try {
+          const previousIDs = new Set((await ctx.session.context({ sessionID }, options)).map((message) => message.id))
+          const admitted = await ctx.session.prompt({
+            sessionID,
+            text: call.body!.parts.map((part: { text: string }) => part.text).join("\n"),
+            delivery: "queue",
+          }, options)
+          // Admission is not completion. Wait for idle, then read only this turn's
+          // final assistant message; a follow-up must never return an older answer.
+          await ctx.session.wait({ sessionID }, options)
+          options.signal?.throwIfAborted()
+          const [messages, completed] = await Promise.all([
+            ctx.session.context({ sessionID }, options), ctx.session.get({ sessionID }, options),
+          ])
+          const boundary = messages.findIndex((message) => message.id === admitted.id)
+          // Compaction may remove the admitted user message from active context.
+          // In that case, only newly projected messages can belong to this turn.
+          const candidates = boundary >= 0 ? messages.slice(boundary + 1) : messages.filter((message) => !previousIDs.has(message.id))
+          const nextUser = candidates.findIndex((message) => message.type === "user")
+          const turn = nextUser < 0 ? candidates : candidates.slice(0, nextUser)
+          const failed = turn.find((message) => message.type === "assistant" && (message.error || message.retry))
+          if (failed?.type === "assistant") throw new Error(JSON.stringify(legacyError(failed.error ?? failed.retry!.error)))
+          if (completed.outcome === "failed" || completed.outcome === "interrupted") {
+            throw new Error(`Raven execution ${completed.outcome}; no completed answer is available`)
+          }
+          const answer = turn.filter((message) => message.type === "assistant").at(-1)
+          if (answer?.type !== "assistant") {
+            throw new Error(`Raven finished without an assistant answer (${completed.outcome ?? "unknown outcome"})`)
+          }
+          return { data: { parts: answer.content } }
+        } finally {
+          activeSessions.delete(sessionID)
+        }
+      },
+    },
+    tui: {
+      async showToast({ body }: { body: { title?: string; message: string; variant?: "info" | "warning"; duration?: number } }) {
+        if (disposed) return
+        await emitNotice({ kind: "toast", ...body })
+      },
+    },
+  }
+
+  const cleanup = async () => {
+    if (disposed) return
+    disposed = true
+    const running = [...activeSessions]
+    controller.abort()
+    if (startupTimer) clearTimeout(startupTimer)
+    await Promise.allSettled(running.map((sessionID) => ctx.session.interrupt({ sessionID, resume: false }, { signal: AbortSignal.timeout(5000) })))
+    await Promise.allSettled(registrations.reverse().map((registration) => registration.dispose()))
+    await runtime?.dispose()
+    await eventPump
+  }
+
+  try {
+    runtime = await createRavenRuntime({
+      client: client as unknown as PluginInput["client"],
+      directory: ctx.location.directory,
+      project: { id: ctx.location.project.id },
+    }, "v2")
+    const raven = runtime
+    const mcp = await ctx.mcp.list({ location }, { signal: controller.signal })
+    const config = {
+      mcp: Object.fromEntries(mcp.data.map((server) => [server.name, { enabled: server.status.status !== "disabled" }])),
+      agent: agents,
+      instructions: [] as string[],
+    }
+    await raven.config(config)
+    registrations.push(await ctx.mcp.transform((editor) => {
+      raven.globalMcpRouting(editor.list().filter(([, server]) => !server.disabled).map(([name]) => name))
+    }))
+
+    async function executeCommand(raw: string) {
+      const output = { parts: [] as Array<{ type: string; text: string }> }
+      await raven["command.execute.before"]({ command: "raven", arguments: raw, sessionID: "" }, output)
+      return { text: output.parts.map((part) => part.text).join("\n") }
+    }
+    const rpc = await ctx.rpc.register(RavenRpc, {
+      command: async ({ arguments: raw }) => executeCommand(raw),
+      refreshMcps: async ({ serverName }) => raven.refreshMcps(serverName),
+    })
+    registrations.push(rpc)
+    emitNotice = (notice) => rpc.events.emit("notice", notice)
+
+    // Delegation needs no extra confirmation. Preserve deny rules and leave
+    // child tools and the Raven-only MCP bridge's permissions unchanged.
+    registrations.push(await ctx.permission.hook("evaluate", (event) => {
+      if (event.effect === "ask" && (event.action === "raven_seek" || event.action === "raven_mcp")) {
+        event.effect = "allow"
+      }
+    }))
+
+    registrations.push(await ctx.agent.transform((editor) => {
+      for (const [id, definition] of Object.entries(agents)) {
+        if (definition.disable) { editor.remove(id); continue }
+        // The shipped registry upserts on update, including previously absent IDs.
+        editor.update(id, (agent) => {
+          agent.name = id as Agent.Name
+          agent.description = definition.description
+          agent.mode = definition.mode
+          agent.hidden = definition.hidden
+          agent.model = definition.model ? modelRef(definition.model) : undefined
+          agent.system = definition.prompt
+          agent.request.body = { ...definition.options }
+          agent.permissions = Object.entries(definition.permission).map(([action, effect]) => ({
+            action: action === "bash" ? "shell" : action === "task" ? "subagent" : action,
+            resource: "*", effect,
+          }))
+        })
+      }
+    }))
+
+    const tools: NonNullable<Hooks["tool"]> = raven.tool
+    registrations.push(await ctx.tool.transform((editor) => {
+      for (const [name, definition] of Object.entries(tools)) {
+        const schema = z.object(definition.args)
+        editor.add({
+          name, description: definition.description,
+          input: z.toJSONSchema(schema),
+          options: { permission: name, codemode: false },
+          async execute(input, context) {
+            await raven["chat.message"]({ sessionID: context.sessionID, agent: context.agent }, {})
+            await raven["tool.execute.before"]({ tool: name, sessionID: context.sessionID, callID: context.id }, { args: input })
+            let metadata: Record<string, unknown> = {}
+            let progress = Promise.resolve()
+            const legacyContext: V1ToolContext = {
+              sessionID: context.sessionID, messageID: context.messageID, agent: context.agent,
+              directory: ctx.location.directory, worktree: ctx.location.project.directory,
+              abort: AbortSignal.any([context.signal, controller.signal]),
+              metadata(update) {
+                metadata = { ...metadata, ...update.metadata, ...(update.title ? { title: update.title } : {}) }
+                progress = progress.then(() => context.progress(metadata)).catch(() => {})
+              },
+              async ask() { throw new Error("Raven tools do not request additional permissions") },
+            }
+            const result = await definition.execute(schema.parse(input), legacyContext)
+            await progress
+            return typeof result === "string" ? { content: result } : {
+              content: result.output,
+              metadata: { ...metadata, ...result.metadata, ...(result.title ? { title: result.title } : {}) },
+            }
+          },
+        })
+      }
+    }))
+
+    registrations.push(await ctx.tool.hook("execute.before", async (event) => {
+      await raven["chat.message"]({ sessionID: event.sessionID, agent: event.agent }, {})
+      const output = { args: event.input }
+      await raven["tool.execute.before"]({
+        ...event,
+        callID: event.id,
+      }, output)
+      event.input = output.args
+    }))
+    registrations.push(await ctx.tool.hook("execute.after", async (event) => {
+      if (event.status !== "completed") return
+      await raven["tool.execute.after"]({ ...event, callID: event.id }, {
+        metadata: event.result.metadata, output: event.result.content ?? "",
+      })
+    }))
+    registrations.push(await ctx.session.hook("context", async (event) => {
+      await raven["chat.message"]({ sessionID: event.sessionID, agent: event.agent }, {})
+      if (event.agent === "raven") return
+      event.system.push({ type: "text", text: event.agent === "raven-mcp" ? raven.mcpGuidance() : raven.guidance() })
+    }))
+    registrations.push(await ctx.session.hook("retry", async (event) => {
+      await raven.event({ event: {
+        type: "session.error", properties: { sessionID: event.sessionID, error: legacyError(event.error) },
+      } })
+    }))
+    registrations.push(await ctx.command.transform((editor) => {
+      editor.add({
+        name: "raven", description: "Manage Raven routing, MCPs, models, timeouts, updates, and status",
+        async execute({ sessionID, prompt }) {
+          const refresh = mcpRefreshArguments(prompt.text)
+          if (refresh) {
+            await emitNotice({ kind: "toast", sessionID, title: "Raven MCP", message: `Refreshing ${refresh.serverName ?? "on-demand MCPs"}…`, variant: "info" })
+            try {
+              const result = await raven.refreshMcps(refresh.serverName)
+              await emitNotice({ kind: "toast", sessionID, ...mcpRefreshToast(result) })
+            } catch (error) {
+              await emitNotice({ kind: "toast", sessionID, title: "Raven MCP", message: `Refresh failed: ${String(error)}`, variant: "error" })
+            }
+            return
+          }
+          const { text } = await executeCommand(prompt.text)
+          await emitNotice({ kind: "command", sessionID, message: text, title: "Raven" })
+        },
+      })
+    }))
+
+    eventPump = (async () => {
+      try {
+        for await (const event of ctx.event.subscribe({ signal: controller.signal })) {
+          if (event.type === "model.updated") {
+            await raven.event({ event: { type: "raven.models.ready" } })
+          } else if (event.type === "session.created") {
+            const data = event.data
+            await raven.event({ event: { type: event.type, properties: { info: { ...data, id: data.sessionID } } } })
+          } else if (event.type === "session.deleted") {
+            const data = event.data
+            await raven.event({ event: { type: event.type, properties: { info: { id: data.sessionID } } } })
+          } else if (event.type === "session.execution.failed" || event.type === "session.retry.scheduled") {
+            const data = event.data
+            await raven.event({ event: { type: "session.error", properties: { sessionID: data.sessionID, error: legacyError(data.error) } } })
+          } else if (event.type === "session.text.delta" || event.type === "session.reasoning.delta" || event.type === "session.tool.input.delta" || event.type === "session.text.started" || event.type === "session.reasoning.started" || event.type === "session.tool.input.started") {
+            const data = event.data
+            await raven.event({ event: { type: "message.part.updated", properties: { part: { sessionID: data.sessionID, type: "text" } } } })
+          }
+        }
+      } catch (error) {
+        if (!controller.signal.aborted) console.error("Raven event subscription failed:", error)
+      }
+    })()
+    await ctx.agent.reload()
+    await ctx.tool.reload()
+    await ctx.command.reload()
+    startupTimer = setTimeout(() => {
+      void raven.event({ event: { type: "raven.ready" } }).catch((error) => console.error("Raven startup failed:", error))
+    }, 3000)
+    return cleanup
+  } catch (error) {
+    await cleanup()
+    throw error
+  }
+}