[FEATURE]: Plugin hook that fires before provider/inference API calls #21240

Feature hasn't been suggested before.

• I have verified this feature I'm about to request hasn't been suggested before.

Describe the enhancement you want to request

OpenCode's plugin system has tool.execute.before for intercepting tool calls, but no hook that fires before the model inference call. Plugins that need to validate something before the provider API is called (credential freshness, rate limits, cost budgets) have no way to do it.

Use case: Enterprise credential rotation

When using AWS Bedrock with temporary credentials (via SAML/SSO federation), credentials expire periodically. A plugin needs to check credential validity and attempt refresh before the Bedrock API call. tool.execute.before doesn't cover inference, so expired credentials produce a raw provider error instead of a helpful message.

Claude Code solves this with UserPromptSubmit (fires before the model is called). pi-mono solves it with before_provider_request (fires right before the HTTP request).

The same hook would also cover rate limiting, request logging, cost controls, or any other pre-flight check.

Proposed hook: chat.request.before

A trigger-style hook that fires after chat.params and chat.headers resolve but before streamText() is called. It would follow the existing Plugin.trigger() pattern.

The existing trigger chain in llm.ts already has two hooks right before the inference call:

The streamText() call (the actual provider API request) happens after tool resolution:

A new Plugin.trigger("chat.request.before", ...) between tool resolution and streamText() (around line 260) would let plugins inspect the assembled request and throw to block it, same as throwing from tool.execute.before blocks a tool call. The input would mirror the existing chat.params/chat.headers shape (sessionID, agent, model, provider).

The type definition would sit alongside the existing chat.headers definition:

Proposed interface

For reference, here's what the equivalent hooks expose in other systems:

• Claude Code's UserPromptSubmit receives the user's prompt text, session ID, and working directory. It can block the prompt (with a reason shown to the user) or inject additional context. It fires once per user prompt, before any processing.
• pi-mono's before_provider_request receives the fully serialized provider payload (messages, temperature, tools, etc.). It can inspect the payload for debugging or replace it entirely. It fires once per LLM call, including retries.

A useful middle ground for OpenCode, following the existing Plugin.trigger() pattern:

"chat.request.before"?: (
  input: {
    sessionID: string
    agent: string
    model: Model
    provider: ProviderContext
    messages: ModelMessage[]
    tools: string[]
  },
  output: {},
) => Promise<void>

input gives the plugin enough to make decisions: which provider and model are being called, what messages are being sent, and which tools are active. messages and tools are read-only context (not mutable through this hook, since experimental.chat.messages.transform and chat.params already cover mutation). output is empty since this is a validation hook.

To block a request, a plugin throws. To allow it, it returns normally:

export const CredentialCheck: Plugin = async () => {
  return {
    "chat.request.before": async (input) => {
      if (input.provider.info.id === "amazon-bedrock") {
        const remaining = getCredentialTTL()
        if (remaining <= 0) {
          throw new Error("AWS credentials have expired. Refresh credentials and try again.")
        }
      }
    },
  }
}