opencode-plugboard 0.20.0 → 0.21.0

package/src/responses/response.ts

@@ -7,6 +7,7 @@
  * call passes a no-op `emit`. Reasoning deltas are dropped (no reasoning items are produced).
  */
 import type { PlugError, PlugEvent, PlugFinish, PlugUsage } from "../contract.js"
+import { structuredMissing, textFallback } from "../openai/response.js"
 
 type ToolCall = Extract<PlugEvent, { type: "tool-call" }>
 
@@ -25,6 +26,8 @@ export interface ResponsesExchange {
    * answer is the message text only when the step called no caller tool.
    */
   readonly callerTools?: boolean
+  /** The caller's `text.format` schema: a text answer is taken when the model skipped the respond call (`textFallback`, #173). */
+  readonly structuredSchema?: Readonly<Record<string, unknown>>
 }
 
 /** A stream event as emitted: `type` is also the SSE event name. */
@@ -37,6 +40,8 @@ export interface ResponseRun {
   readonly started: boolean
   /** The final response object (completed, incomplete or failed once started). */
   readonly response?: object
+  /** The structured answer came from the final text, not the respond call (`textFallback`). */
+  readonly structuredFallback?: boolean
 }
 
 type Item = Record<string, unknown>
@@ -63,21 +68,6 @@ const failedRun = (): PlugError => ({ status: 500, kind: "server", message: "Mod
 /** SSE frame of one stream event: `event: <type>` then `data: <json>`. */
 export const sseFrame = (event: ResponsesStreamEvent): string => `event: ${event.type}\ndata: ${JSON.stringify(event)}\n\n`
 
-/**
- * Structured-output projection, same rules as the Chat Completions front-end: in structured mode
- * the message text is exactly the arguments of the first call to the `respond` tool; prose and
- * other calls are suppressed. Without an answer the exchange fails, except when the model
- * stopped for `length` or `content-filter`, which keep their status with empty output.
- */
-const structuredFailure = (exchange: ResponsesExchange, finish: Exclude<PlugFinish, "error">, answered: boolean): PlugError | undefined =>
-  exchange.structuredTool === undefined || answered || finish === "length" || finish === "content-filter"
-    ? undefined
-    : {
-        status: 502,
-        kind: "server",
-        code: "structured_output_missing",
-        message: `The model finished without calling the \`${exchange.structuredTool}\` tool, so there is no structured output`,
-      }
 
 /**
  * `committed`: whether the transport already committed a 200 stream before any event was emitted
@@ -114,6 +104,8 @@ export async function runResponse(
   let started = false
   let calls = 0
   let answered = false
+  /** The text of a structured turn (not emitted): it is the answer only if the respond call never comes (#173). */
+  let collected = ""
   /** With caller tools offered the structured answer waits for the finish: a caller tool call in the same step replaces it. */
   let held: ToolCall | undefined
   let finish: Exclude<PlugFinish, "error"> | undefined
@@ -199,6 +191,7 @@ export async function runResponse(
         }
         continue
       }
+      if (event.type === "text-delta") collected += event.text
       if (!(exchange.callerTools && event.type === "tool-call")) continue
     }
     if (event.type === "text-delta") text(event.text)
@@ -207,7 +200,9 @@ export async function runResponse(
 
   const passthrough = exchange.callerTools === true && calls > 0
   const structuredAnswer = exchange.structuredTool !== undefined && !passthrough
-  failure ??= finish ? (passthrough ? undefined : structuredFailure(exchange, finish, answered)) : noFinish()
+  const fallback = structuredAnswer && !answered && exchange.structuredSchema !== undefined ? textFallback(collected, exchange.structuredSchema) : undefined
+  const missing = passthrough || answered || fallback !== undefined || exchange.structuredTool === undefined ? undefined : structuredMissing(exchange.structuredTool)
+  failure ??= finish ? missing : noFinish()
   if (failure) {
     if (!started && !committed()) return { failure, started }
     start()
@@ -221,6 +216,7 @@ export async function runResponse(
   }
   start()
   if (held && structuredAnswer) text(args(held.input))
+  if (fallback !== undefined) text(fallback)
   closeMessage()
   const incomplete = finish === "length" ? "max_output_tokens" : finish === "content-filter" ? "content_filter" : undefined
   const response = envelope(incomplete ? "incomplete" : "completed", items, {
@@ -228,5 +224,5 @@ export async function runResponse(
     ...(usage ? { usage: encodeUsage(usage) } : {}),
   })
   send(incomplete ? "response.incomplete" : "response.completed", { response })
-  return { started, response }
+  return { started, response, ...(fallback !== undefined ? { structuredFallback: true } : {}) }
 }

package/src/responses/route.ts

@@ -14,10 +14,10 @@ import { reportServed, type ServedInfo } from "../fallback.js"
 import { boundEvents, sendError, sendJson, sseWriter, type RequestScope } from "../http.js"
 import { resolveModel } from "../models.js"
 import { reportCache } from "../cache.js"
-import { reportPolicy } from "../policy.js"
+import { reportPolicy, reportServerTools } from "../policy.js"
 import { reportUsage } from "../usage-header.js"
 import { setSessionLink } from "../session/link.js"
-import { encodeError } from "../openai/response.js"
+import { STRUCTURED_FALLBACK_HEADER, encodeError } from "../openai/response.js"
 import type { RouteHost } from "../openai/route.js"
 import { parseResponsesRequest } from "./request.js"
 import { runResponse, sseFrame } from "./response.js"
@@ -60,6 +60,7 @@ export async function serveResponses(host: RouteHost, { app, body, response, sco
       onServed: reportServed(response, info, (served) => void (exchange.model = served.model)),
       onPolicy: reportPolicy(response),
       onUsage: reportUsage(response, exchange.stream),
+      onServerTools: reportServerTools(response, exchange.stream),
       onCache: reportCache(response),
     }),
     scope,
@@ -81,5 +82,6 @@ export async function serveResponses(host: RouteHost, { app, body, response, sco
   const run = await runResponse(events, exchange, () => {})
   if (run.failure || !run.response) return fail(run.failure ?? { status: 502, kind: "server", message: "No response from the model" })
   rememberAnswer(app, run.response)
+  if (run.structuredFallback) response.setHeader(STRUCTURED_FALLBACK_HEADER, "text")
   sendJson(response, 200, run.response)
 }

package/src/runtime.ts

@@ -118,8 +118,8 @@ const BACKEND_POLL_MS = 25
 const BIND_RETRY_MS = 15_000
 const BIND_REMINDER_MS = 5 * 60_000
 
-/** 14: the runtime app keys (src/keys.ts, #55) are cached here, so a key created or revoked through the admin routes holds across plugin generations. 13: the budget warning state (`src/budgets.ts`) lives here too. 12: the live key set (`keys`, `Runtime.keys`) that a stricter newer generation replaces at once (#90). 11: the usage store's live days (`src/usage.ts`) live here too. 10: the response cache store (`src/cache.ts`) lives here too. 9: the request limiter state (`src/limits.ts`) lives here, so the concurrency caps and rate windows survive a generation. 8: `Metrics.render` is async and the registry is @prometheus-io/client's. 7: the options fingerprint comes from safe-stable-stringify, so it must not be compared with an older one. 6: the listener retries a failed bind (new fields on `Listener`). 5: adds the metrics registry and the start time. 4: the history sweep state and the session store's register hook. 3: confirmed directories and rejected generations. */
-const VERSION = 14
+/** 15: the last options error (`configError`, #159) and `catalogLoaded` for `/readyz` (#160). 14: the runtime app keys (src/keys.ts, #55) are cached here, so a key created or revoked through the admin routes holds across plugin generations. 13: the budget warning state (`src/budgets.ts`) lives here too. 12: the live key set (`keys`, `Runtime.keys`) that a stricter newer generation replaces at once (#90). 11: the usage store's live days (`src/usage.ts`) live here too. 10: the response cache store (`src/cache.ts`) lives here too. 9: the request limiter state (`src/limits.ts`) lives here, so the concurrency caps and rate windows survive a generation. 8: `Metrics.render` is async and the registry is @prometheus-io/client's. 7: the options fingerprint comes from safe-stable-stringify, so it must not be compared with an older one. 6: the listener retries a failed bind (new fields on `Listener`). 5: adds the metrics registry and the start time. 4: the history sweep state and the session store's register hook. 3: confirmed directories and rejected generations. */
+const VERSION = 15
 const KEY = Symbol.for("opencode-plugboard.runtime")
 
 interface Listener {
@@ -156,6 +156,12 @@ interface Pump {
   stop(): void
 }
 
+/** A plugin options error and when it was recorded (epoch ms). */
+export interface ConfigError {
+  readonly message: string
+  readonly at: number
+}
+
 interface Runtime {
   readonly version: number
   readonly sessions: SessionStore
@@ -187,6 +193,10 @@ interface Runtime {
   readonly budgets: BudgetState
   /** The runtime app keys (src/keys.ts), loaded from storage on the first authentication. */
   readonly runtimeKeys: KeyState
+  /** The last plugin options error (`index.ts`), cleared by the next Location whose options parse (#159). */
+  configError?: ConfigError
+  /** Set once the serving catalog has loaded successfully (`loadServingCatalog`); `/readyz` reads it (#160). */
+  catalogLoaded?: boolean
   listener?: Listener
   /** Present while a fiber is subscribed to the server event bus. */
   pump?: Pump
@@ -345,7 +355,9 @@ export function withResponseCache(caller: ModelCaller, options: PlugboardOptions
       if (rt) rt.cache = held
     }
     const count = options.metrics ? (app: string, result: "hit" | "miss") => processMetrics().cache(app, result) : undefined
-    return cachedCaller(caller, config, held.store, count, (model) => personaOf(options, model) !== undefined)
+    // One bypass predicate: a persona model, or an app whose answers depend on live OpenCode tool output (#82).
+    const serverToolApps = new Set(Object.entries(options.apps).filter(([, policy]) => policy.serverTools !== undefined).map(([app]) => app))
+    return cachedCaller(caller, config, held.store, count, (model, app) => personaOf(options, model) !== undefined || serverToolApps.has(app))
   }
   return { stream: (request, context) => (wrapped ??= build()).stream(request, context) }
 }
@@ -357,12 +369,16 @@ export interface RuntimeStatus extends RuntimeSnapshot {
   readonly listener?: { readonly host: string; readonly port: number; readonly bound: boolean }
   /** The serving generation's Location is a confirmed app directory (else the newest generation serves). */
   readonly servingConfirmed: boolean
+  /** The last plugin options error, when its Location was the latest to load the plugin (#159). */
+  readonly configError?: ConfigError
+  /** The serving catalog has loaded at least once in this process (`/readyz`, #160). */
+  readonly catalogLoaded: boolean
 }
 
 /** A synchronous snapshot of the runtime: no host call, no filesystem. */
 export function processStatus(): RuntimeStatus {
   const rt = runtime()
-  if (!rt) return { runtimeVersion: VERSION, generations: 0, pumpRunning: false, guards: detachedSessions.size(), startedAt: detachedStartedAt, servingConfirmed: false }
+  if (!rt) return { runtimeVersion: VERSION, generations: 0, pumpRunning: false, guards: detachedSessions.size(), startedAt: detachedStartedAt, servingConfirmed: false, catalogLoaded: false }
   const serving = preferred(rt)
   return {
     runtimeVersion: rt.version,
@@ -371,10 +387,23 @@ export function processStatus(): RuntimeStatus {
     guards: rt.sessions.size(),
     startedAt: rt.startedAt,
     servingConfirmed: serving !== undefined && rt.confirmed.has(serving.directory),
+    catalogLoaded: rt.catalogLoaded === true,
     ...(rt.listener ? { listener: { host: rt.listener.listen.host, port: rt.listener.listen.port, bound: rt.listener.bound } } : {}),
+    ...(rt.configError ? { configError: rt.configError } : {}),
   }
 }
 
+/**
+ * Records the plugin options error of the Location that just failed to parse its options, or clears
+ * it (`undefined`) once options parse. Synchronous, so plugin setup may call it. The status and
+ * `/readyz` show it while a listener from an earlier good generation still serves (#159).
+ */
+export function setConfigError(message: string | undefined): void {
+  const rt = runtime()
+  if (!rt) return
+  rt.configError = message === undefined ? undefined : { message, at: Date.now() }
+}
+
 /** The generation that serves requests and supplies the catalog: the newest confirmed app-directory one, else the newest. */
 function preferred(rt: Runtime): Generation | undefined {
   for (let index = rt.generations.length - 1; index >= 0; index--) if (rt.confirmed.has(rt.generations[index]!.directory)) return rt.generations[index]
@@ -385,9 +414,11 @@ function preferred(rt: Runtime): Generation | undefined {
  * The catalog of the preferred accepted generation. `fallback` (the caller's own loader) is only
  * used when no generation is registered, which a live request does not normally see.
  */
-export function loadServingCatalog(fallback: () => Promise<ReadonlyArray<CatalogModel>>): Promise<ReadonlyArray<CatalogModel>> {
+export async function loadServingCatalog(fallback: () => Promise<ReadonlyArray<CatalogModel>>): Promise<ReadonlyArray<CatalogModel>> {
   const rt = runtime()
-  return (rt ? (preferred(rt)?.loadCatalog ?? fallback) : fallback)()
+  const models = await (rt ? (preferred(rt)?.loadCatalog ?? fallback) : fallback)()
+  if (rt) rt.catalogLoaded = true
+  return models
 }
 
 /** JSON with object keys sorted at every level, so equal options compare equal whatever their key order (undefined values are left out, as in `JSON.stringify`). */
@@ -521,7 +552,13 @@ export function registerGeneration(input: GenerationInput): Registration {
   } else if (canonicalJson(keys) !== canonicalJson(rt.keys ?? {})) {
     const live = rt.keys ?? {}
     if (rt.generations.length === 0) rt.keys = keys
-    else if (revokesOrRotatesOnly(live, keys)) {
+    else if (Object.keys(keys).length === 0) {
+      // #152: removing the last key fails closed. The old key must not keep working, and the set must not go keyless.
+      if (canonicalJson(live) !== canonicalJson(REVOKED_KEYS)) {
+        log("listener.keys_updated", { removed: Object.keys(live).length, rotated: 0 })
+        rt.keys = REVOKED_KEYS
+      }
+    } else if (revokesOrRotatesOnly(live, keys)) {
       log("listener.keys_updated", {
         removed: Object.keys(live).filter((app) => !Object.hasOwn(keys, app)).length,
         rotated: Object.keys(keys).filter((app) => Object.hasOwn(live, app) && live[app] !== keys[app]).length,
@@ -571,6 +608,13 @@ export function registerGeneration(input: GenerationInput): Registration {
   }
 }
 
+/**
+ * #152: the live key set once the last key is revoked while a generation serves. An empty key set means
+ * keyless, so this one keeps an entry no request can match: `*` is not a valid app name, and its key is
+ * empty, which `Bearer` (it needs a non-empty token) never presents. Every request gets 401 until restart.
+ */
+const REVOKED_KEYS: Readonly<Record<string, string>> = { "*": "" }
+
 /** #90: `next` names no app that `live` lacks, and names at least one app: it only removes or changes keys. */
 function revokesOrRotatesOnly(live: Readonly<Record<string, string>>, next: Readonly<Record<string, string>>): boolean {
   const apps = Object.keys(next)

package/src/session/caller.ts

@@ -18,15 +18,15 @@
 
 import { randomUUID } from "node:crypto"
 import { raceAbort } from "../abort.js"
-import { APP_NAME_PATTERN, DEFAULT_APP, appPolicy, type AppPolicy, type PlugboardOptions } from "../config.js"
+import { APP_NAME_PATTERN, DEFAULT_APP, DEFAULT_SERVER_TOOL_STEPS, appPolicy, type AppPolicy, type PlugboardOptions } from "../config.js"
 import { isPlugError, type CallContext, type ModelCaller, type PlugError, type PlugEvent, type PlugRequest } from "../contract.js"
-import { log, logError } from "../log.js"
+import { log, logError, logWarn } from "../log.js"
 import { checkAppModel, type Persona } from "../models.js"
 import { RequestCollector } from "./events.js"
 import { ensureAppDir, makeTitle, renderTranscript } from "./history.js"
 import { describeError, type SessionPort } from "./host.js"
 import { ImageError, prepareImages, type RemoteImages } from "./media.js"
-import { REQUEST_PERMISSIONS, seedToolsFor } from "./seeds.js"
+import { requestPermissions, seedToolsFor } from "./seeds.js"
 import type { SessionStore } from "./state.js"
 
 export interface SessionCallerDeps {
@@ -106,6 +106,33 @@ function checkAppTools(request: PlugRequest, app: string, policy: AppPolicy | un
     message: `Request has ${request.tools.length} tools; app ${app} allows ${max} (option \`apps.${app}.maxTools\`)`,
   }
 }
+/** A caller tool may not share a name with one of the app's server tools: the model would see two tools under one name. */
+function checkServerToolNames(request: PlugRequest, policy: AppPolicy | undefined): PlugError | undefined {
+  const clash = request.tools.find((tool) => policy?.serverTools?.includes(tool.name))
+  if (!clash) return undefined
+  return {
+    status: 400,
+    kind: "invalid_request",
+    code: "server_tool_collision",
+    param: "tools",
+    message: `Tool \`${clash.name}\` is one of this app's OpenCode server tools (option \`apps.<name>.serverTools\`); rename the caller's tool`,
+  }
+}
+
+/** Every server tool must be a direct tool of this location right now (fail closed; checked per request, never at setup). */
+async function checkServerToolsAvailable(port: SessionPort, policy: AppPolicy | undefined, signal: AbortSignal): Promise<PlugError | undefined> {
+  if (!policy?.serverTools) return undefined
+  const offered = new Set(await raceAbort(port.directTools(), signal))
+  const missing = policy.serverTools.filter((tool) => !offered.has(tool))
+  if (missing.length === 0) return undefined
+  return {
+    status: 400,
+    kind: "invalid_request",
+    code: "server_tool_unavailable",
+    message: `OpenCode tool(s) not available in this location: ${missing.join(", ")} (option \`apps.<name>.serverTools\`). CodeMode tools, including MCP tools by default, cannot be listed; set codemode: false on the tool`,
+  }
+}
+
 export function createSessionCaller(deps: SessionCallerDeps): ModelCaller {
   const { port, sessions, maxTools, ensureBackend } = deps
   const apps = deps.apps ?? {}
@@ -120,9 +147,12 @@ export function createSessionCaller(deps: SessionCallerDeps): ModelCaller {
       const requestID = randomUUID()
       const startedAt = Date.now()
       let outcome = "cancelled"
+      // Whether the model produced anything at all (text, reasoning or a tool call), for `answer.empty` (#172).
+      let produced = false
       const note = (event: PlugEvent): PlugEvent => {
         if (event.type === "finish") outcome = `finish:${event.reason}`
         else if (event.type === "error") outcome = `error:${event.error.status}${event.error.code ? `:${event.error.code}` : ""}`
+        else produced = true
         return event
       }
 
@@ -133,6 +163,8 @@ export function createSessionCaller(deps: SessionCallerDeps): ModelCaller {
       let { request, stripped } = applyToolPolicy(called, policy)
       const tooMany = checkAppTools(request, app, policy)
       if (tooMany) return yield note({ type: "error", error: tooMany })
+      const clash = checkServerToolNames(request, policy)
+      if (clash) return yield note({ type: "error", error: clash })
       if (stripped) {
         try {
           context.onPolicy?.(["tools-stripped"])
@@ -172,6 +204,9 @@ export function createSessionCaller(deps: SessionCallerDeps): ModelCaller {
         const unavailable = await ensureBackend?.(app, context.signal)
         if (unavailable) return yield note({ type: "error", error: unavailable })
         if (context.signal.aborted) return
+        const missingServerTools = await checkServerToolsAvailable(port, policy, context.signal)
+        if (missingServerTools) return yield note({ type: "error", error: missingServerTools })
+        if (context.signal.aborted) return
 
         // 3b. A persona (see `Persona`). A skill's content leads the system prompt; an agent's prompt replaces the
         // caller's, and the session runs as that agent. Its permissions are still REQUEST_PERMISSIONS (deny all, then seeds).
@@ -188,15 +223,32 @@ export function createSessionCaller(deps: SessionCallerDeps): ModelCaller {
         }
         if (context.signal.aborted) return
 
-        collector = new RequestCollector({ stopTurn: interrupt, requestID })
-        const created = await raceAbort(port.create({
+        collector = new RequestCollector({
+          stopTurn: interrupt,
+          requestID,
+          app,
+          ...(policy?.serverTools
+            ? { serverTools: new Set(policy.serverTools), maxServerToolSteps: policy.maxServerToolSteps ?? DEFAULT_SERVER_TOOL_STEPS }
+            : {}),
+        })
+
+        const creating = port.create({
           directory,
           model: { providerID: request.ref.providerID, id: request.ref.id, ...(request.ref.variant ? { variant: request.ref.variant } : {}) },
           ...(persona?.kind === "agent" ? { agent: persona.agent } : {}),
           title: makeTitle(request),
           metadata: { plugboard: { app, model: request.model, requestID } },
-          permissions: REQUEST_PERMISSIONS,
-        }), context.signal)
+          permissions: requestPermissions(policy?.serverTools ?? []),
+        })
+        const created = await raceAbort(creating, context.signal).catch((error) => {
+          // The host keeps creating after the abort. A session that lands now is in no index, so it is removed.
+          if (context.signal.aborted)
+            void creating.then(
+              (late) => port.remove(late.id).catch((removeError) => logError("session.late_remove_failed", { requestID, app, sessionID: late.id, error: describeError(removeError) })),
+              () => {},
+            )
+          throw error
+        })
         sessionID = String(created.id)
         sessions.register({ sessionID, app, requestID, request, collector, prelude })
 
@@ -240,6 +292,16 @@ export function createSessionCaller(deps: SessionCallerDeps): ModelCaller {
           if (promptStarted) sessions.retire(sessionID, { timeoutMs: CLEANUP_TIMEOUT_MS, onTimeout: interrupt })
           else sessions.release(sessionID)
         }
+        const serverToolCalls = collector?.serverCallCount ?? 0
+        if (serverToolCalls > 0 && context.onServerTools) {
+          try {
+            context.onServerTools(serverToolCalls)
+          } catch (error) {
+            logError("request.on_server_tools_failed", { requestID, app, error: describeError(error) })
+          }
+        }
+        // A turn that stopped with nothing in it is kept as a session for inspection: the session id finds it.
+        if (outcome === "finish:stop" && !produced) logWarn("answer.empty", { requestID, app, model: request.model, sessionID, tools: request.tools.length })
         log("request.finished", { requestID, app, model: request.model, durationMs: Date.now() - startedAt, outcome })
       }
     },

package/src/session/context.ts

@@ -59,10 +59,13 @@ function generationOptions(request: PlugRequest): Record<string, unknown> {
  * Returns how many caller tools got no seed (zero unless the seed pool is smaller than the request
  * needs, or two caller tools share a name and would collapse into one key).
  *
+ * The app's `serverTools` (option `apps`) are kept as the host offered them: their descriptors were
+ * never rewritten, so the host runs the real tool. Not offered when the caller set `tool_choice` none.
+ *
  * The map is built with `Object.fromEntries`: a tool named `__proto__` becomes an own key like any
  * other instead of assigning the prototype and vanishing.
  */
-function remapSeedTools(session: ContextHookEvent, request: PlugRequest): number {
+function remapSeedTools(session: ContextHookEvent, request: PlugRequest, serverTools: ReadonlyArray<string>): number {
   const seeds = Object.entries(session.tools ?? {}).filter(([name]) => name.startsWith(SEED_PREFIX))
   const tools = seedToolsFor(request)
   const next = new Map<string, HostToolDescriptor>()
@@ -77,8 +80,16 @@ function remapSeedTools(session: ContextHookEvent, request: PlugRequest): number
     descriptor.input = tool.parameters
     next.set(tool.name, descriptor)
   }
+  const missing = tools.length - next.size
+  if (request.toolChoice !== "none") {
+    const offered = session.tools ?? {}
+    for (const name of serverTools) {
+      if (!Object.hasOwn(offered, name) || next.has(name)) continue
+      next.set(name, offered[name] as HostToolDescriptor)
+    }
+  }
   session.tools = Object.fromEntries(next)
-  return tools.length - next.size
+  return missing
 }
 
 /**
@@ -109,6 +120,7 @@ function applyContext(event: unknown, sessions: SessionStore, apps: PlugboardOpt
   const state = sessions.lookup(String(session.sessionID))
   if (!state) return
   const { request } = state
+  const policy = appPolicy({ apps }, state.app)
 
   // Swap media placeholders for the Asset-carrying parts the host built from the prompt files.
   const hostMedia = (session.messages ?? [])
@@ -125,7 +137,7 @@ function applyContext(event: unknown, sessions: SessionStore, apps: PlugboardOpt
 
   // Order: the skill's content (prelude), then the app's system policy over the caller's (or an agent's) prompt,
   // then the tool-choice steering below.
-  const system = [...(state.prelude ?? []), ...systemFor(request.system, appPolicy({ apps }, state.app))].map(text)
+  const system = [...(state.prelude ?? []), ...systemFor(request.system, policy)].map(text)
   // The OpenCode session API has no tool-choice control, so a forced or required tool is steered by instruction.
   const choice = request.toolChoice
   if (choice === "required") system.push(text("You must respond by calling one of the provided tools."))
@@ -134,7 +146,7 @@ function applyContext(event: unknown, sessions: SessionStore, apps: PlugboardOpt
   session.messages = toHostMessages(request.messages).map((message) => ({ ...message, content: message.content.map(swap) }))
   Object.assign(session.options ?? (session.options = {}), generationOptions(request))
 
-  const missingTools = remapSeedTools(session, request)
+  const missingTools = remapSeedTools(session, request, policy?.serverTools ?? [])
 
   // The caller validates both before dispatch; this only fires if the host disagrees. The request is
   // already rewritten (no real tool can run); fail it instead of answering from a truncated prompt.