opencode-plugboard 0.20.0 → 0.21.1

package/src/session/events.ts

@@ -6,13 +6,18 @@
  * ModelCaller streams out through `events()` (not buffered beyond the queue).
  *
  * The turn is stopped from inside the model loop (see `session/seeds.ts`): once the step has ended
- * (`session.step.ended`) with at least one tool call, the owner is asked to interrupt the
+ * (`session.step.ended`) with at least one caller tool call, the owner is asked to interrupt the
  * session before a second model step can start, and the request finishes as `tool-calls`.
  * The collector never calls the host itself; the owner passes `stopTurn`.
+ *
+ * A call to one of the app's `serverTools` is not the caller's: OpenCode runs it, the runner starts
+ * the next step with its result, and the collector neither emits it nor stops the turn. A step with
+ * only server calls continues; a step that also holds a caller call is returned to the caller as usual.
+ * Server steps are counted and capped (`maxServerToolSteps`); each server call is logged once.
  */
 
 import { isPlugError, type PlugError, type PlugEvent, type PlugFinish, type PlugUsage } from "../contract.js"
-import { logError } from "../log.js"
+import { log, logError } from "../log.js"
 import type { BusEvent } from "./host.js"
 import { FAILURE_EVENT } from "./state.js"
 
@@ -145,6 +150,18 @@ const toUsage = (tokens?: RawUsage): PlugUsage | undefined =>
 const CONTEXT_OVERFLOW =
   /context[_ ](?:length|window)|maximum context|prompt (?:is )?too long|too many tokens|token limit|input length.*exceeds|exceeds the (?:available )?context|reduce the length of the messages/i
 
+/**
+ * Provider wording that the status does not settle (#171). A ChatGPT subscription at its limit is a
+ * `provider.invalid-request` with `subscription_sharing_usage_limit_exceeded` and no status. These
+ * are matched on the message and the raw body, and only ever decide a class; the text never leaves.
+ */
+const USAGE_LIMIT = /usage[_ ]limit|quota/i
+const RATE_LIMIT = /rate[_ ]limit|too many requests/i
+const AUTH_FAILURE = /unauthori[sz]ed|invalid[_ ]api[_ ]key|incorrect api key|not logged in|log in again|sign in|permission denied/i
+const MODEL_NOT_FOUND = /model[^\n]{0,60}(?:not found|does not exist|not supported|unknown)|unknown model|model_not_found/i
+
+const AUTH_MESSAGE = "The model provider rejected its credentials; the plugboard host needs to sign in again"
+
 /**
  * Host `SessionError` (`{ type, message, status?, response? }`) to a `PlugError`. Provider and host
  * error text can carry endpoints, account or organization ids, so it never reaches the caller:
@@ -167,10 +184,9 @@ function toPlugError(error: RawError | undefined, fallback: string): PlugError {
     return { status: 400, kind: "invalid_request", code: "context_length_exceeded", param: "messages", message: "The request is longer than the model's context window" }
   }
   if (type === "provider.auth" || status === 401 || status === 403) {
-    const message = "The model provider rejected its credentials; the plugboard host needs to sign in again"
-    if (status === 401) return { status, kind: "authentication", code: "provider_auth_failed", message }
-    if (status === 403) return { status, kind: "permission", code: "provider_auth_failed", message }
-    return { status: 502, kind: "server", code: "provider_auth_failed", message }
+    if (status === 401) return { status, kind: "authentication", code: "provider_auth_failed", message: AUTH_MESSAGE }
+    if (status === 403) return { status, kind: "permission", code: "provider_auth_failed", message: AUTH_MESSAGE }
+    return { status: 502, kind: "server", code: "provider_auth_failed", message: AUTH_MESSAGE }
   }
   if (type === "provider.content-filter") {
     return { status: 400, kind: "invalid_request", code: "content_filter", message: "The model provider's content filter blocked the request" }
@@ -179,6 +195,11 @@ function toPlugError(error: RawError | undefined, fallback: string): PlugError {
     return { status: 504, kind: "timeout", code: "provider_timeout", message: "The model provider timed out" }
   }
   if (type.startsWith("provider.")) {
+    const detail = `${error?.message ?? ""}\n${error?.response?.body ?? ""}`
+    if (USAGE_LIMIT.test(detail)) return { status: 429, kind: "rate_limit", code: "quota_exceeded", message: "The model provider's usage quota is exhausted" }
+    if (RATE_LIMIT.test(detail)) return { status: 429, kind: "rate_limit", code: "rate_limited", message: "The model provider is rate limiting requests; retry later" }
+    if (MODEL_NOT_FOUND.test(detail)) return { status: 404, kind: "not_found", code: "model_not_found", param: "model", message: "The model provider does not know the requested model" }
+    if (AUTH_FAILURE.test(detail)) return { status: 502, kind: "server", code: "provider_auth_failed", message: AUTH_MESSAGE }
     if (status === 404) return { status, kind: "not_found", code: "provider_rejected_request", message: "The model provider rejected the request" }
     if (status !== undefined && status < 500) return { status, kind: "invalid_request", code: "provider_rejected_request", message: "The model provider rejected the request" }
     return { status: status ?? 502, kind: "server", code: "provider_unavailable", message: "The model provider is unavailable or returned an error" }
@@ -191,6 +212,18 @@ export interface CollectorHooks {
   readonly stopTurn: () => void
   /** The request's id, for the log line that carries a failure's raw host text. */
   readonly requestID?: string
+  /** The app, for the `server_tool.call` log lines. */
+  readonly app?: string
+  /** The app's `serverTools` (option `apps`): OpenCode runs these calls, the caller never sees them. */
+  readonly serverTools?: ReadonlySet<string>
+  /** Steps that may run server tools before the turn is stopped. The owner passes it with `serverTools`. */
+  readonly maxServerToolSteps?: number
+}
+
+interface ServerCall {
+  readonly name: string
+  readonly startedAt: number
+  done: boolean
 }
 
 export class RequestCollector {
@@ -198,6 +231,9 @@ export class RequestCollector {
   private readonly emittedText = new Map<number, number>()
   private readonly toolNames = new Map<string, string>()
   private readonly calls = new Set<string>()
+  private readonly serverCalls = new Map<string, ServerCall>()
+  private stepServerCalls = 0
+  private serverSteps = 0
   private usage?: RawUsage
   private finished = false
   private executionDone = false
@@ -221,6 +257,11 @@ export class RequestCollector {
     return this.settled
   }
 
+  /** How many server tool calls OpenCode ran in this session (each counted when it started). */
+  get serverCallCount(): number {
+    return this.serverCalls.size
+  }
+
   /** True once the owner cancelled the request (client gone or timeout). */
   get cancelled(): boolean {
     return this.wasCancelled
@@ -274,23 +315,48 @@ export class RequestCollector {
       case "session.tool.called": {
         if (this.finished) return
         const id = String(item.id)
-        if (this.calls.has(id)) return
+        if (this.calls.has(id) || this.serverCalls.has(id)) return
+        const name = String(item.name ?? this.toolNames.get(id) ?? "")
+        if (this.hooks.serverTools?.has(name)) {
+          this.serverCalls.set(id, { name, startedAt: Date.now(), done: false })
+          this.stepServerCalls++
+          return
+        }
         this.calls.add(id)
-        this.emit({ type: "tool-call", id, name: String(item.name ?? this.toolNames.get(id) ?? ""), input: item.input })
+        this.emit({ type: "tool-call", id, name, input: item.input })
+        return
+      }
+      case "session.tool.success":
+      case "session.tool.failed": {
+        const call = this.serverCalls.get(String(item.id))
+        if (!call || call.done) return
+        call.done = true
+        log("server_tool.call", {
+          requestID: this.hooks.requestID,
+          app: this.hooks.app,
+          tool: call.name,
+          durationMs: Date.now() - call.startedAt,
+          ok: item.type === "session.tool.success",
+        })
         return
       }
       case "session.usage.updated":
         // Assumed invariant: `tokens` is the host's token-usage record (RawUsage shape).
         this.usage = (item.tokens as RawUsage | undefined) ?? this.usage
         return
-      case "session.step.ended":
+      case "session.step.ended": {
         this.usage = (item.tokens as RawUsage | undefined) ?? this.usage
+        const serverCalls = this.stepServerCalls
+        this.stepServerCalls = 0
         // Also after the response finished: a later step that ended with calls means the first
         // interrupt lost the race or failed; ask again (the guard stays until the execution ends).
         if (this.calls.size > 0 && !this.executionDone) this.hooks.stopTurn()
-        if (this.calls.size === 0 && toFinish(item.finish) === "stop") this.settled = true
-        this.finishWith(withCalls(toFinish(item.finish), this.calls.size > 0))
+        const reason = toFinish(item.finish)
+        if (this.calls.size === 0 && serverCalls > 0) return this.serverStepEnded(reason)
+        if (this.calls.size === 0 && reason === "stop") this.settled = true
+        this.finishWith(withCalls(reason, this.calls.size > 0))
         return
+      }
       case FAILURE_EVENT:
         // Synthetic, from inside the process (lost event stream, preparation mismatch).
         if (isPlugError(item.error)) this.abort(item.error)
@@ -308,12 +374,14 @@ export class RequestCollector {
       }
       case "session.execution.failed":
         this.executionDone = true
+        this.logUnfinishedServerCalls()
         if (!this.finished) this.failFromHost(item.error as RawError | undefined, "Session execution failed")
         this.end()
         return
       case "session.execution.interrupted":
       case "session.execution.succeeded":
         this.executionDone = true
+        this.logUnfinishedServerCalls()
         if (!this.finished) {
           if (this.calls.size > 0) this.finishWith("tool-calls")
           else if (this.wasCancelled) this.end()
@@ -346,16 +414,52 @@ export class RequestCollector {
     this.end()
   }
 
+  /**
+   * A step that ran only server tools: the runner starts the next step with their results. The cap is
+   * checked on each such step; past it the request fails and the turn is stopped.
+   */
+  private serverStepEnded(reason: PlugFinish): void {
+    this.serverSteps++
+    if (this.serverSteps > (this.hooks.maxServerToolSteps ?? 0)) {
+      this.abort({
+        status: 502,
+        kind: "server",
+        code: "server_tool_steps_exceeded",
+        message: "The model used more OpenCode tool steps than this app allows",
+      })
+      return
+    }
+    if (reason === "stop" || reason === "tool-calls") return
+    this.finishWith(reason)
+  }
+
+  /** Server calls the execution ended before they reported back are logged as not ok, once each. */
+  private logUnfinishedServerCalls(): void {
+    for (const call of this.serverCalls.values()) {
+      if (call.done) continue
+      call.done = true
+      log("server_tool.call", {
+        requestID: this.hooks.requestID,
+        app: this.hooks.app,
+        tool: call.name,
+        durationMs: Date.now() - call.startedAt,
+        ok: false,
+      })
+    }
+  }
+
   /** Fail with the caller-safe mapping of a host error; the raw text is logged here and goes nowhere else. */
   private failFromHost(raw: RawError | undefined, fallback: string): void {
     if (this.finished) return
+    const error = toPlugError(raw, fallback)
     logError("model.failed", {
       requestID: this.hooks.requestID,
       type: raw?.type,
       status: raw?.status,
+      code: error.code,
       message: raw?.message?.slice(0, 500),
     })
-    this.fail(toPlugError(raw, fallback))
+    this.fail(error)
   }
 
   private fail(error: PlugError): void {

package/src/session/host.ts

@@ -32,10 +32,19 @@ export interface SessionPort {
   }): Promise<{ id: string }>
   prompt(input: { readonly sessionID: string; readonly text: string; readonly files: ReadonlyArray<{ uri: string; name: string }> }): Promise<unknown>
   interrupt(sessionID: string): Promise<void>
+  /** Deletes a host session. Used only for a session that was created after its request was aborted (#155). */
+  remove(sessionID: string): Promise<void>
   /** The content of skill `id` in the Location at `directory`, or undefined when there is none. Briefly cached per directory. */
   skill(directory: string, id: string): Promise<string | undefined>
   /** The agent `id` in the Location at `directory` (its `system` prompt may be absent), or undefined when there is none. */
   agent(directory: string, id: string): Promise<{ readonly system?: string } | undefined>
+  /**
+   * The ids of the OpenCode tools this location offers directly to a model (`codemode: false`), the only
+   * ones a request session can call by name. CodeMode-wrapped tools are reached through `execute`, which a
+   * request session denies, so they are not listed. A tool whose permission name differs from its id is
+   * not listed either: the session's permission rules are written by id.
+   */
+  directTools(): Promise<ReadonlyArray<string>>
 }
 
 type HostSession = HostContext["session"]
@@ -112,6 +121,11 @@ export function createSessionPort(ctx: HostContext): SessionPort {
       ),
     interrupt: (sessionID) =>
       run(ctx.session.interrupt({ sessionID: hostSessionID(sessionID) } satisfies Parameters<HostSession["interrupt"]>[0])).then(() => undefined),
+    remove: (sessionID) => run(ctx.session.remove({ sessionID: hostSessionID(sessionID) } satisfies Parameters<HostSession["remove"]>[0])).then(() => undefined),
+    directTools: () =>
+      run(ctx.tool.list()).then((tools) =>
+        tools.filter((tool) => tool.options?.codemode === false && (tool.options?.permission ?? tool.id) === tool.id).map((tool) => tool.id),
+      ),
   }
 }
 

package/src/session/seeds.ts

@@ -39,6 +39,16 @@ export const REQUEST_PERMISSIONS: ReadonlyArray<{ action: string; resource: stri
   { action: `${SEED_PREFIX}*`, resource: "*", effect: "allow" },
 ]
 
+/**
+ * Session permissions of a request session of an app with option `serverTools`: the same deny-all, then
+ * each listed OpenCode tool id allowed by its exact name (no wildcard). The host takes the last matching
+ * rule (`Permission.evaluate`, findLast), so the later allows win over the deny. An app without
+ * `serverTools` gets exactly `REQUEST_PERMISSIONS`.
+ */
+export function requestPermissions(serverTools: ReadonlyArray<string>): ReadonlyArray<{ action: string; resource: string; effect: "allow" | "deny" }> {
+  return [...REQUEST_PERMISSIONS, ...serverTools.map((tool) => ({ action: tool, resource: "*", effect: "allow" as const }))]
+}
+
 /** The caller tools that get a seed in the model request (`tool_choice` none offers none, a named tool only that one). */
 export function seedToolsFor(request: PlugRequest): ReadonlyArray<PlugTool> {
   const choice = request.toolChoice

package/tui.ts

@@ -1,4 +1,5 @@
-// The `./tui` entrypoint. OpenCode resolves a package's TUI entry through `exports["./tui"]`, but a
-// plugin configured by local path is resolved as `<directory>/tui` with no `exports` lookup
-// (packages/plugin/src/host.ts in OpenCode 2.0.26), so the entry lives at the package root.
-export { default } from "./src/tui.tsx"
+// The `./tui` entrypoint for a plugin configured by local path. OpenCode resolves that as
+// `<directory>/tui` with no `exports` lookup (packages/plugin/src/host.ts in OpenCode 2.0.26), so the
+// entry lives at the package root. It re-exports the compiled file (`bun run build:tui`), not
+// src/tui.tsx: a local path under node_modules is never Solid-compiled (see build-tui.ts).
+export { default } from "./dist/tui.js"