fix(tui): share runtime with external TSX plugins

packages/ai/src/provider-error.ts

@@ -16,6 +16,7 @@ import {
 
 const patterns = [
   /prompt is too long/i,
+  /request_too_large/i,
   /input is too long for requested model/i,
   /exceeds the context window/i,
   /exceeds (?:the )?(?:model'?s )?maximum context length(?: of [\d,]+ tokens?|\s*\([\d,]+\))/i,
@@ -32,6 +33,7 @@ const patterns = [
   /context window exceeds limit/i,
   /exceeded model token limit/i,
   /context[_ ]length[_ ]exceeded/i,
+  /request entity too large/i,
   /context length is only \d+ tokens/i,
   /input length.*exceeds.*context length/i,
   /prompt too long; exceeded (?:max )?context length/i,
@@ -42,15 +44,11 @@ const patterns = [
   /token limit exceeded/i,
 ]
 
-const payloadPatterns = [/request_too_large/i, /request entity too large/i, /payload too large/i, /request too large/i]
-
 const exclusions = [/^(throttling error|service unavailable):/i, /rate limit/i, /too many requests/i]
 
 export const isContextOverflow = (message: string) =>
   !exclusions.some((pattern) => pattern.test(message)) &&
-  (patterns.some((pattern) => pattern.test(message)) || /^400\s*(status code)?\s*\(no body\)/i.test(message))
-
-export const isPayloadTooLarge = (message: string) => payloadPatterns.some((pattern) => pattern.test(message))
+  (patterns.some((pattern) => pattern.test(message)) || /^4(00|13)\s*(status code)?\s*\(no body\)/i.test(message))
 
 export const isContextOverflowFailure = (failure: unknown) =>
   failure instanceof LLMError
@@ -102,8 +100,6 @@ export function classifyProviderFailure(input: ProviderFailure): LLMError["reaso
       isContextOverflow(text))
   )
     return new InvalidRequestReason({ ...common, classification: "context-overflow" })
-  if (input.status === 413 || isPayloadTooLarge(text))
-    return new InvalidRequestReason({ ...common, classification: "payload-too-large" })
   if (CONTENT_POLICY_TEXT.test(text)) return new ContentPolicyReason(common)
   if (codes.some((code) => QUOTA_CODES.has(code)) || (input.status === 429 && QUOTA_TEXT.test(text)))
     return new QuotaExceededReason(common)
@@ -146,7 +142,12 @@ export function classifyProviderFailure(input: ProviderFailure): LLMError["reaso
       retryAfterMs: input.retryAfterMs,
     })
   if (codes.some((code) => INVALID_REQUEST_CODES.has(code))) return new InvalidRequestReason(common)
-  if (input.status === 400 || input.status === 404 || input.status === 413 || input.status === 422)
+  if (
+    input.status === 400 ||
+    input.status === 404 ||
+    input.status === 413 ||
+    input.status === 422
+  )
     return new InvalidRequestReason(common)
   return new UnknownProviderReason({ ...common, status: input.status })
 }

packages/ai/src/route/client.ts

@@ -5,7 +5,7 @@ import { Endpoint, type EndpointPatch } from "./endpoint"
 import { RequestExecutor } from "./executor"
 import { Framing } from "./framing"
 import { HttpTransport } from "./transport"
-import type { HttpMiddleware, Transport, TransportRuntime } from "./transport"
+import type { HttpRequestTransform, Transport, TransportRuntime } from "./transport"
 import { WebSocketExecutor } from "./transport"
 import type { Protocol } from "./protocol"
 import { applyCachePolicy } from "../cache-policy"
@@ -96,10 +96,7 @@ export interface RoutePatch<Body, Prepared> extends RouteDefaultsInput {
 
 type RouteMappedModelInput = RouteModelInput | RouteRoutedModelInput
 
-const makeRouteModel = <Options extends ProviderOptions = ProviderOptions>(
-  route: AnyRoute,
-  mapped: RouteMappedModelInput,
-) => {
+const makeRouteModel = <Options extends ProviderOptions = ProviderOptions>(route: AnyRoute, mapped: RouteMappedModelInput) => {
   const provider = route.provider ?? ("provider" in mapped ? mapped.provider : undefined)
   if (!provider) throw new Error(`Route.model(${route.id}) requires a provider`)
   if (!endpointBaseURL(route.endpoint))
@@ -153,7 +150,7 @@ export interface Interface {
 }
 
 export interface StreamOptions {
-  readonly http?: HttpMiddleware
+  readonly transform?: HttpRequestTransform
 }
 
 export interface StreamMethod {
@@ -305,7 +302,7 @@ function makeFromTransport<Body, Prepared, Frame, Event, State>(
           auth: routeInput.auth ?? Auth.none,
           encodeBody,
           headers: routeInput.headers,
-          middleware: options?.http,
+          transform: options?.transform,
         }),
       streamPrepared: (prepared: Prepared, request: LLMRequest, runtime: TransportRuntime) => {
         const route = `${request.model.provider}/${request.model.route.id}`

packages/ai/src/route/executor.ts

@@ -1,4 +1,4 @@
-import { Cause, Context, Effect, Layer, Stream } from "effect"
+import { Cause, Context, Effect, Layer } from "effect"
 import {
   FetchHttpClient,
   Headers,
@@ -20,13 +20,9 @@ import { classifyProviderFailure } from "../provider-error"
 export interface Interface {
   readonly execute: (
     request: HttpClientRequest.HttpClientRequest,
-    middleware?: HttpMiddleware,
   ) => Effect.Effect<HttpClientResponse.HttpClientResponse, LLMError>
 }
 
-export type HttpHandler = (request: Request) => Effect.Effect<Response, Error>
-export type HttpMiddleware = (request: Request, handler: HttpHandler) => Effect.Effect<Response, Error>
-
 export class Service extends Context.Service<Service, Interface>()("@opencode/LLM/RequestExecutor") {}
 
 const BODY_LIMIT = 16_384
@@ -286,41 +282,12 @@ export const layer: Layer.Layer<Service, never, HttpClient.HttpClient> = Layer.e
   Service,
   Effect.gen(function* () {
     const http = yield* HttpClient.HttpClient
-    const executeOnce = (request: HttpClientRequest.HttpClientRequest, middleware?: HttpMiddleware) =>
+    const executeOnce = (request: HttpClientRequest.HttpClientRequest) =>
       Effect.gen(function* () {
         const redactedNames = yield* Headers.CurrentRedactedNames
-        if (!middleware)
-          return yield* http
-            .execute(request)
-            .pipe(Effect.mapError(toHttpError(redactedNames)), Effect.flatMap(statusError(request, redactedNames)))
-
-        let sent = request
-        const origins = new WeakMap<Response, HttpClientRequest.HttpClientRequest>()
-        const response = yield* HttpClientRequest.toWeb(request).pipe(
-          Effect.flatMap((web) =>
-            middleware(web, (input) =>
-              Effect.gen(function* () {
-                sent = HttpClientRequest.fromWeb(input)
-                if (input.body)
-                  sent = HttpClientRequest.bodyUint8Array(
-                    sent,
-                    new Uint8Array(yield* Effect.promise(() => input.arrayBuffer())),
-                    input.headers.get("content-type") ?? undefined,
-                  )
-                const response = yield* http
-                  .execute(sent)
-                  .pipe(Effect.mapError((cause) => (cause instanceof Error ? cause : new Error(String(cause)))))
-                const body = yield* Stream.toReadableStreamEffect(response.stream)
-                const web = new Response(body, { status: response.status, headers: response.headers })
-                origins.set(web, sent)
-                return web
-              }),
-            ),
-          ),
-          Effect.mapError(toHttpError(redactedNames)),
-        )
-        const origin = origins.get(response) ?? sent
-        return yield* statusError(origin, redactedNames)(HttpClientResponse.fromWeb(origin, response))
+        return yield* http
+          .execute(request)
+          .pipe(Effect.mapError(toHttpError(redactedNames)), Effect.flatMap(statusError(request, redactedNames)))
       })
     return Service.of({
       execute: executeOnce,

packages/ai/src/route/index.ts

@@ -23,4 +23,4 @@ export type { ApiKeyMode, AuthOverride, ProviderAuthOption } from "./auth-option
 export type { Definition as EndpointFn, EndpointInput } from "./endpoint"
 export type { Definition as FramingDef } from "./framing"
 export type { Protocol as ProtocolDef } from "./protocol"
-export type { HttpHandler, HttpMiddleware, Transport as TransportDef, TransportRuntime } from "./transport"
+export type { HttpRequest, HttpRequestTransform, Transport as TransportDef, TransportRuntime } from "./transport"

packages/ai/src/route/transport/http.ts

@@ -3,7 +3,7 @@ import { Headers, HttpClientRequest } from "effect/unstable/http"
 import { Auth } from "../auth"
 import { render as renderEndpoint } from "../endpoint"
 import { Framing } from "../framing"
-import type { HttpMiddleware, Transport, TransportPrepareInput } from "./index"
+import type { Transport, TransportPrepareInput } from "./index"
 import * as ProviderShared from "../../protocols/shared"
 import { mergeJsonRecords, type LLMRequest } from "../../schema"
 
@@ -19,7 +19,6 @@ export interface JsonRequestParts<Body = unknown> {
 export interface HttpPrepared<Frame> {
   readonly request: HttpClientRequest.HttpClientRequest
   readonly framing: Framing.Definition<Frame>
-  readonly middleware?: HttpMiddleware
 }
 
 const applyQuery = (url: string, query: Record<string, string> | undefined) => {
@@ -75,21 +74,21 @@ export const httpJson = <Body, Frame>(input: HttpJsonInput<Body, Frame>): HttpJs
   prepare: (prepareInput) =>
     Effect.gen(function* () {
       const parts = yield* jsonRequestParts({ ...prepareInput })
-      const request = ProviderShared.jsonPost({
-        url: parts.url,
-        body: parts.bodyText,
-        headers: parts.headers,
-      })
+      const request = { url: parts.url, method: "POST", headers: { ...parts.headers }, body: parts.bodyText }
+      yield* (prepareInput.transform?.(request) ?? Effect.void)
       return {
-        request,
+        request: ProviderShared.jsonPost({
+          url: request.url,
+          body: request.body ?? "",
+          headers: Headers.fromInput(request.headers),
+        }),
         framing: input.framing,
-        middleware: prepareInput.middleware,
       }
     }),
   frames: (prepared, request, runtime) =>
     Stream.unwrap(
       runtime.http
-        .execute(prepared.request, prepared.middleware)
+        .execute(prepared.request)
         .pipe(
           Effect.map((response) =>
             prepared.framing.frame(

packages/ai/src/route/transport/index.ts

@@ -1,7 +1,7 @@
 import type { Effect, Stream } from "effect"
 import { Endpoint } from "../endpoint"
 import { Auth } from "../auth"
-import type { HttpMiddleware, Interface as RequestExecutorInterface } from "../executor"
+import type { Interface as RequestExecutorInterface } from "../executor"
 import type { Interface as WebSocketExecutorInterface } from "./websocket"
 import type { LLMError, LLMRequest } from "../../schema"
 
@@ -10,6 +10,15 @@ export interface TransportRuntime {
   readonly webSocket?: WebSocketExecutorInterface
 }
 
+export interface HttpRequest {
+  url: string
+  readonly method: string
+  headers: Record<string, string>
+  body: string | undefined
+}
+
+export type HttpRequestTransform = (request: HttpRequest) => Effect.Effect<void>
+
 export interface Transport<Body, Prepared, Frame> {
   readonly id: string
   readonly prepare: (input: TransportPrepareInput<Body>) => Effect.Effect<Prepared, LLMError>
@@ -27,9 +36,8 @@ export interface TransportPrepareInput<Body> {
   readonly auth: Auth.Definition
   readonly encodeBody: (body: Body) => string
   readonly headers?: (input: { readonly request: LLMRequest }) => Record<string, string>
-  readonly middleware?: HttpMiddleware
+  readonly transform?: HttpRequestTransform
 }
 
 export * as HttpTransport from "./http"
-export type { HttpHandler, HttpMiddleware } from "../executor"
 export { WebSocketExecutor, WebSocketTransport } from "./websocket"

packages/ai/src/schema/errors.ts

@@ -2,7 +2,7 @@ import { Schema } from "effect"
 import { Tool } from "@opencode-ai/schema/tool"
 import { ModelID, ProviderID, ProviderMetadata, RouteID } from "./ids"
 
-export const ProviderFailureClassification = Schema.Literals(["context-overflow", "payload-too-large"])
+export const ProviderFailureClassification = Schema.Literal("context-overflow")
 export type ProviderFailureClassification = typeof ProviderFailureClassification.Type
 
 export class HttpRequestDetails extends Schema.Class<HttpRequestDetails>("LLM.HttpRequestDetails")({

packages/ai/test/compile.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, test } from "bun:test"
-import { Effect, Ref, Schema } from "effect"
+import { Effect, Schema } from "effect"
 import { HttpClientRequest } from "effect/unstable/http"
 import { LLM, mergeProviderOptions } from "../src"
 import { AnthropicMessages, OpenAIChat } from "../src/protocols"
@@ -146,19 +146,12 @@ describe("request option precedence", () => {
         prompt: "Say hello.",
       }),
       {
-        http: (request, handler) =>
-          Effect.gen(function* () {
-            expect(request.headers.get("authorization")).toBe("Bearer fresh-key")
-            const headers = new Headers(request.headers)
-            headers.set("x-plugin", "transformed")
-            headers.set("content-type", "application/custom+json")
-            return yield* handler(
-              new Request("https://proxy.test/v1/chat/completions", {
-                method: "PUT",
-                headers,
-                body: JSON.stringify({ transformed: true }),
-              }),
-            )
+        transform: (request) =>
+          Effect.sync(() => {
+            expect(request.headers.authorization).toBe("Bearer fresh-key")
+            request.url = "https://proxy.test/v1/chat/completions"
+            request.headers["x-plugin"] = "transformed"
+            request.body = JSON.stringify({ transformed: true })
           }),
       },
     ).pipe(
@@ -167,9 +160,7 @@ describe("request option precedence", () => {
           Effect.gen(function* () {
             const web = yield* HttpClientRequest.toWeb(input.request).pipe(Effect.orDie)
             expect(web.url).toBe("https://proxy.test/v1/chat/completions")
-            expect(web.method).toBe("PUT")
             expect(web.headers.get("x-plugin")).toBe("transformed")
-            expect(web.headers.get("content-type")).toBe("application/custom+json")
             expect(decodeJson(input.text)).toEqual({ transformed: true })
             return input.respond(sseEvents(deltaChunk({}, "stop")), {
               headers: { "content-type": "text/event-stream" },
@@ -180,83 +171,6 @@ describe("request option precedence", () => {
     ),
   )
 
-  it.effect("transforms the HTTP response before protocol decoding", () =>
-    Effect.gen(function* () {
-      const response = yield* LLMClient.generate(
-        LLM.request({
-          model: OpenAIChat.route
-            .with({ endpoint: { baseURL: "https://api.openai.test/v1/" }, auth: Auth.bearer("test") })
-            .model({ id: "gpt-4o-mini" }),
-          prompt: "Say hello.",
-        }),
-        {
-          http: (request, handler) =>
-            Effect.gen(function* () {
-              const response = yield* handler(request)
-              const body = yield* Effect.promise(() => response.text())
-              return new Response(body.replace("network", "hooked"), {
-                status: response.status,
-                headers: response.headers,
-              })
-            }),
-        },
-      ).pipe(
-        Effect.provide(
-          dynamicResponse((input) =>
-            Effect.succeed(
-              input.respond(sseEvents(deltaChunk({ content: "network" }, "stop")), {
-                headers: { "content-type": "text/event-stream" },
-              }),
-            ),
-          ),
-        ),
-      )
-
-      expect(response.text).toBe("hooked")
-    }),
-  )
-
-  it.effect("can inspect an error response and retry the native request", () =>
-    Effect.gen(function* () {
-      const attempts = yield* Ref.make(0)
-      const response = yield* LLMClient.generate(
-        LLM.request({
-          model: OpenAIChat.route
-            .with({ endpoint: { baseURL: "https://api.openai.test/v1/" }, auth: Auth.bearer("stale") })
-            .model({ id: "gpt-4o-mini" }),
-          prompt: "Say hello.",
-        }),
-        {
-          http: (request, handler) =>
-            Effect.gen(function* () {
-              const retry = request.clone()
-              const response = yield* handler(request)
-              expect(response.status).toBe(401)
-              const headers = new Headers(retry.headers)
-              headers.set("authorization", "Bearer refreshed")
-              return yield* handler(new Request(retry, { headers }))
-            }),
-        },
-      ).pipe(
-        Effect.provide(
-          dynamicResponse((input) =>
-            Effect.gen(function* () {
-              yield* Ref.update(attempts, (value) => value + 1)
-              if (input.request.headers.authorization !== "Bearer refreshed")
-                return input.respond("unauthorized", { status: 401 })
-              return input.respond(sseEvents(deltaChunk({ content: "retried" }, "stop")), {
-                headers: { "content-type": "text/event-stream" },
-              })
-            }),
-          ),
-        ),
-      )
-
-      expect(response.text).toBe("retried")
-      expect(yield* Ref.get(attempts)).toBe(2)
-    }),
-  )
-
   it.effect("applies raw body overlays after protocol lowering", () =>
     LLMClient.generate(
       LLM.request({

packages/ai/test/executor.test.ts

@@ -85,17 +85,14 @@ describe("RequestExecutor", () => {
     ),
   )
 
-  it.effect("classifies generic HTTP 413 payload errors", () =>
+  it.effect("does not classify generic HTTP 413 payload errors as context overflow", () =>
     Effect.gen(function* () {
       const executor = yield* RequestExecutor.Service
       const error = yield* executor.execute(request).pipe(Effect.flip)
 
       expectLLMError(error)
-      expect(error.reason).toMatchObject({
-        _tag: "InvalidRequest",
-        classification: "payload-too-large",
-        http: { response: { status: 413 } },
-      })
+      expect(error.reason).toMatchObject({ _tag: "InvalidRequest" })
+      expect("classification" in error.reason ? error.reason.classification : undefined).toBeUndefined()
     }).pipe(Effect.provide(responsesLayer([new Response("request too large", { status: 413 })]))),
   )
 

packages/ai/test/provider-error.test.ts

@@ -6,6 +6,7 @@ describe("provider error classification", () => {
   test("classifies provider token limit messages as context overflow", () => {
     const messages = [
       "tokens in request more than max tokens allowed",
+      '{"error":{"type":"request_too_large","message":"Request exceeds the maximum size"}}',
       "Requested token count exceeds the model's maximum context length of 131072 tokens.",
       "Input length (265330) exceeds model's maximum context length (262144).",
       "Input length 131393 exceeds the maximum allowed input length of 131040 tokens.",
@@ -18,24 +19,6 @@ describe("provider error classification", () => {
     expect(messages.every(isContextOverflow)).toBe(true)
   })
 
-  test("classifies request size failures separately from context overflow", () => {
-    const failures = [
-      classifyProviderFailure({ message: "request too large", status: 413 }),
-      classifyProviderFailure({
-        message: '{"error":{"type":"request_too_large","message":"Request exceeds the maximum size"}}',
-        status: 400,
-      }),
-      classifyProviderFailure({ message: "upstream request entity too large", status: 502 }),
-    ]
-
-    expect(failures).toEqual(
-      failures.map((failure) =>
-        expect.objectContaining({ _tag: "InvalidRequest", classification: "payload-too-large" }),
-      ),
-    )
-    expect(isContextOverflow("413 status code (no body)")).toBe(false)
-  })
-
   test("does not classify rate limits as context overflow", () => {
     const messages = [
       "Throttling error: Too many tokens, please wait before trying again.",
@@ -76,10 +59,9 @@ describe("provider error classification", () => {
   })
 
   test("classifies transient client statuses as provider internal", () => {
-    expect([408, 409].map((status) => classifyProviderFailure({ message: `HTTP ${status}`, status })._tag)).toEqual([
-      "ProviderInternal",
-      "ProviderInternal",
-    ])
+    expect(
+      [408, 409].map((status) => classifyProviderFailure({ message: `HTTP ${status}`, status })._tag),
+    ).toEqual(["ProviderInternal", "ProviderInternal"])
   })
 
   test("classifies nested provider codes when a top-level code is also present", () => {

packages/client/src/effect/api/api.ts

@@ -398,7 +398,7 @@ export type Endpoint5_26Output =
           readonly location?: Location.Ref | undefined
           readonly data: {
             readonly sessionID: Session.ID
-            readonly error: { readonly type: string; readonly message: string; readonly status?: number | undefined }
+            readonly error: { readonly type: string; readonly message: string }
           }
         }
       | {
@@ -524,7 +524,7 @@ export type Endpoint5_26Output =
           readonly data: {
             readonly sessionID: Session.ID
             readonly assistantMessageID: SessionMessage.ID
-            readonly error: { readonly type: string; readonly message: string; readonly status?: number | undefined }
+            readonly error: { readonly type: string; readonly message: string }
             readonly cost?: (number & Brand.Brand<"Money.USD">) | undefined
             readonly tokens?:
               | {
@@ -686,7 +686,7 @@ export type Endpoint5_26Output =
             readonly sessionID: Session.ID
             readonly assistantMessageID: SessionMessage.ID
             readonly callID: string
-            readonly error: { readonly type: string; readonly message: string; readonly status?: number | undefined }
+            readonly error: { readonly type: string; readonly message: string }
             readonly content?:
               | readonly [
                   (
@@ -726,7 +726,7 @@ export type Endpoint5_26Output =
             readonly assistantMessageID: SessionMessage.ID
             readonly attempt: number
             readonly at: number
-            readonly error: { readonly type: string; readonly message: string; readonly status?: number | undefined }
+            readonly error: { readonly type: string; readonly message: string }
           }
         }
       | {
@@ -776,7 +776,7 @@ export type Endpoint5_26Output =
           readonly data: {
             readonly sessionID: Session.ID
             readonly reason: "auto" | "manual"
-            readonly error: { readonly type: string; readonly message: string; readonly status?: number | undefined }
+            readonly error: { readonly type: string; readonly message: string }
             readonly inputID?: SessionMessage.ID | undefined
           }
         }

packages/client/src/promise/generated/types.ts

@@ -108,7 +108,7 @@ export type ToolTextContent = { type: "text"; text: string }
 
 export type ToolFileContent = { type: "file"; uri: string; mime: string; name?: string | null }
 
-export type SessionStructuredError = { type: string; message: string; status?: number }
+export type SessionStructuredError = { type: string; message: string }
 
 export type SessionMessageCompactionRunning = {
   type: "compaction"

packages/core/src/plugin/promise.ts

@@ -194,9 +194,7 @@ export function fromPromise(plugin: Plugin) {
                               ),
                             ),
                           refresh:
-                            refresh === undefined
-                              ? undefined
-                              : (credential) => Effect.promise(() => refresh(credential)),
+                            refresh === undefined ? undefined : (credential) => Effect.promise(() => refresh(credential)),
                         })
                       },
                       remove: draft.method.remove,
@@ -265,35 +263,8 @@ export function fromPromise(plugin: Plugin) {
               ),
           },
           session: {
-            hook: (name, callback) => {
-              if (name !== "http")
-                return register(
-                  host.session.hook(name, (event) =>
-                    Effect.promise(() => Promise.resolve(Reflect.apply(callback, undefined, [event]))),
-                  ),
-                )
-              return register(
-                host.session.hook("http", (event) => {
-                  const request = event.request
-                  const output = {
-                    ...event,
-                    request: (input: Request) =>
-                      Effect.runPromiseWith(context)(request(input), { signal: input.signal }),
-                  }
-                  return Effect.promise(() => Promise.resolve(Reflect.apply(callback, undefined, [output]))).pipe(
-                    Effect.tap(() =>
-                      Effect.sync(() => {
-                        event.request = (input) =>
-                          Effect.tryPromise({
-                            try: (signal) => output.request(new Request(input, { signal })),
-                            catch: (cause) => (cause instanceof Error ? cause : new Error(String(cause))),
-                          })
-                      }),
-                    ),
-                  )
-                }),
-              )
-            },
+            hook: (name, callback) =>
+              register(host.session.hook(name, (event) => Effect.promise(() => Promise.resolve(callback(event))))),
             create: (input) =>
               run(
                 host.session.create(

packages/core/src/plugin/provider/openai.ts

@@ -225,25 +225,15 @@ export const OpenAIPlugin = define({
         })
       }
     })
-    yield* ctx.session.hook("http", (evt) =>
+    yield* ctx.session.hook("request", (evt) =>
       Effect.sync(() => {
         if (!chatgpt || evt.model.providerID !== Provider.ID.openai) return
-        const request = evt.request
-        evt.request = (input) => {
-          const url = new URL(input.url)
-          const headers = new Headers(input.headers)
-          headers.set("originator", "opencode")
-          headers.set("session-id", evt.sessionID)
-          if (url.origin !== "https://api.openai.com") return request(new Request(input, { headers }))
-          return request(
-            new Request(`${codexBaseURL}${url.pathname.replace(/^\/v1/, "")}${url.search}`, {
-              method: input.method,
-              headers,
-              body: input.body,
-              signal: input.signal,
-            }),
-          )
+        const url = new URL(evt.url)
+        if (url.origin === "https://api.openai.com") {
+          evt.url = `${codexBaseURL}${url.pathname.replace(/^\/v1/, "")}${url.search}`
         }
+        evt.headers.originator = "opencode"
+        evt.headers["session-id"] = evt.sessionID
       }),
     )
 

packages/core/src/session/model-request.ts

@@ -220,15 +220,24 @@ export const layer = Layer.effect(
         toolChoice: stepLimitReached ? "none" : undefined,
       })
       const options: StreamOptions = {
-        http: (request, handler) =>
+        transform: (request) =>
           hooks
-            .trigger("session", "http", {
+            .trigger("session", "request", {
               sessionID: session.id,
               agent: agent.id,
               model: resolved.ref,
-              request: handler,
+              ...request,
             })
-            .pipe(Effect.flatMap((event) => event.request(request))),
+            .pipe(
+              Effect.tap((event) =>
+                Effect.sync(() => {
+                  request.url = event.url
+                  request.headers = event.headers
+                  request.body = event.body
+                }),
+              ),
+              Effect.asVoid,
+            ),
       }
       if (promptCacheSnapshots) {
         const current = PromptCacheDiagnostics.snapshot(request)

packages/core/src/session/to-session-error.ts

@@ -11,25 +11,25 @@ export function toSessionError(cause: unknown): SessionError.Error {
   if (cause instanceof LLMError) {
     switch (cause.reason._tag) {
       case "RateLimit":
-        return providerError("provider.rate-limit", cause.reason)
+        return { type: "provider.rate-limit", message: cause.reason.message }
       case "Authentication":
-        return providerError("provider.auth", cause.reason)
+        return { type: "provider.auth", message: cause.reason.message }
       case "QuotaExceeded":
-        return providerError("provider.quota", cause.reason)
+        return { type: "provider.quota", message: cause.reason.message }
       case "ContentPolicy":
-        return providerError("provider.content-filter", cause.reason)
+        return { type: "provider.content-filter", message: cause.reason.message }
       case "Transport":
-        return providerError("provider.transport", cause.reason)
+        return { type: "provider.transport", message: cause.reason.message }
       case "ProviderInternal":
-        return providerError("provider.internal", cause.reason)
+        return { type: "provider.internal", message: cause.reason.message }
       case "InvalidProviderOutput":
-        return providerError("provider.invalid-output", cause.reason)
+        return { type: "provider.invalid-output", message: cause.reason.message }
       case "InvalidRequest":
-        return providerError("provider.invalid-request", cause.reason)
+        return { type: "provider.invalid-request", message: cause.reason.message }
       case "NoRoute":
-        return providerError("provider.no-route", cause.reason)
+        return { type: "provider.no-route", message: cause.reason.message }
       case "UnknownProvider":
-        return providerError("provider.unknown", cause.reason)
+        return { type: "provider.unknown", message: cause.reason.message }
       default: {
         const exhaustive: never = cause.reason
         return exhaustive
@@ -58,9 +58,3 @@ export function toSessionError(cause: unknown): SessionError.Error {
   if (cause instanceof Integration.AuthorizationError) return { type: "provider.auth", message: cause.message }
   return { type: "unknown", message: cause instanceof Error ? cause.message : String(cause) }
 }
-
-function providerError(type: string, reason: LLMError["reason"]): SessionError.Error {
-  const status =
-    ("http" in reason ? reason.http?.response?.status : undefined) ?? ("status" in reason ? reason.status : undefined)
-  return { type, message: reason.message, ...(status === undefined ? {} : { status }) }
-}

packages/core/test/plugin/promise.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect } from "bun:test"
 import { Message, SystemPart } from "@opencode-ai/ai"
-import { DateTime, Deferred, Effect, Fiber, Schema } from "effect"
+import { DateTime, Effect, Schema } from "effect"
 import { Agent } from "@opencode-ai/core/agent"
 import { Catalog } from "@opencode-ai/core/catalog"
 import { Model } from "@opencode-ai/core/model"
@@ -148,9 +148,7 @@ describe("fromPromise", () => {
             expect((await ctx.agent.get({ agentID: Agent.ID.make("reviewer") })).data).toMatchObject({
               description: "Reviews code",
             })
-            await expect(ctx.agent.get({ agentID: Agent.ID.make("missing") })).rejects.toThrow(
-              "Agent not found: missing",
-            )
+            await expect(ctx.agent.get({ agentID: Agent.ID.make("missing") })).rejects.toThrow("Agent not found: missing")
             const models = (await ctx.catalog.model.list()).data
             expect(models.find((model) => model.providerID === "test" && model.id === "alias")).toMatchObject({
               modelID: "gpt-5",
@@ -223,77 +221,6 @@ describe("fromPromise", () => {
     }),
   )
 
-  it.effect("adapts promise session HTTP hooks", () =>
-    Effect.gen(function* () {
-      const plugin = yield* Plugin.Service
-      const hooks = yield* PluginHooks.Service
-      const host = yield* PluginHost.make(plugin)
-      yield* PluginPromise.fromPromise(
-        define({
-          id: "promise-session-http",
-          setup: async (ctx) => {
-            await ctx.session.hook("http", (event) => {
-              const request = event.request
-              event.request = async (input) => {
-                const response = await request(new Request(input, { headers: { "x-hook": "promise" } }))
-                return new Response(`${await response.text()}-response`)
-              }
-            })
-          },
-        }),
-      ).effect(host)
-      const event: SessionHooks["http"] = {
-        sessionID: Session.ID.make("ses_promise_session_http"),
-        agent: Agent.ID.make("build"),
-        model: Model.Ref.make({ providerID: Provider.ID.make("test"), id: Model.ID.make("model") }),
-        request: (input) => Effect.succeed(new Response(input.headers.get("x-hook") ?? "missing")),
-      }
-
-      yield* hooks.trigger("session", "http", event)
-      const response = yield* event.request(new Request("https://provider.test"))
-
-      expect(yield* Effect.promise(() => response.text())).toBe("promise-response")
-    }),
-  )
-
-  it.effect("interrupts the Effect request through a promise session HTTP hook", () =>
-    Effect.gen(function* () {
-      const plugin = yield* Plugin.Service
-      const hooks = yield* PluginHooks.Service
-      const host = yield* PluginHost.make(plugin)
-      yield* PluginPromise.fromPromise(
-        define({
-          id: "promise-session-http-interrupt",
-          setup: async (ctx) => {
-            await ctx.session.hook("http", (event) => {
-              const request = event.request
-              event.request = (input) => request(input)
-            })
-          },
-        }),
-      ).effect(host)
-      const started = yield* Deferred.make<void>()
-      const interrupted = yield* Deferred.make<void>()
-      const event: SessionHooks["http"] = {
-        sessionID: Session.ID.make("ses_promise_session_http_interrupt"),
-        agent: Agent.ID.make("build"),
-        model: Model.Ref.make({ providerID: Provider.ID.make("test"), id: Model.ID.make("model") }),
-        request: () =>
-          Deferred.succeed(started, undefined).pipe(
-            Effect.andThen(Effect.never),
-            Effect.onInterrupt(() => Deferred.succeed(interrupted, undefined)),
-          ),
-      }
-
-      yield* hooks.trigger("session", "http", event)
-      const fiber = yield* event.request(new Request("https://provider.test")).pipe(Effect.forkChild)
-      yield* Deferred.await(started)
-      yield* Fiber.interrupt(fiber)
-
-      expect(yield* Deferred.isDone(interrupted)).toBeTrue()
-    }),
-  )
-
   it.effect("disposes a hook registration on request", () =>
     Effect.gen(function* () {
       const agents = yield* Agent.Service
@@ -388,17 +315,19 @@ describe("fromPromise", () => {
         id: "promise-tool",
         setup: async (ctx) => {
           await ctx.tool.transform((tools) => {
-            tools.add({
-              name: "hello",
-              options: { codemode: false },
-              description: "Hello",
-              input: Schema.Struct({ name: Schema.String }),
-              output: Schema.String,
-              execute: async ({ name }, context) => {
-                await context.progress({ phase: "greeting" })
-                return { output: `Hello, ${name}!` }
+            tools.add(
+              {
+                name: "hello",
+                options: { codemode: false },
+                description: "Hello",
+                input: Schema.Struct({ name: Schema.String }),
+                output: Schema.String,
+                execute: async ({ name }, context) => {
+                  await context.progress({ phase: "greeting" })
+                  return { output: `Hello, ${name}!` }
+                },
               },
-            })
+            )
           })
         },
       })

packages/core/test/plugin/provider-openai.test.ts

@@ -29,21 +29,6 @@ function required<T>(value: T | undefined): T {
   return value
 }
 
-const http = Effect.fn(function* (providerID: Provider.ID, url: string) {
-  const event = yield* (yield* PluginHooks.Service).trigger("session", "http", {
-    sessionID: Session.ID.make("ses_test"),
-    agent: Agent.ID.make("build"),
-    model: Model.Ref.make({ providerID, id: Model.ID.make("gpt-5.5") }),
-    request: (input) => {
-      const headers = new Headers(input.headers)
-      headers.set("x-seen-url", input.url)
-      return Effect.succeed(new Response(null, { headers }))
-    },
-  })
-  const response = yield* event.request(new Request(url, { method: "POST", body: "{}" }))
-  return { url: response.headers.get("x-seen-url"), headers: Object.fromEntries(response.headers.entries()) }
-})
-
 describe("OpenAIPlugin", () => {
   it.effect("registers browser and headless ChatGPT OAuth methods", () =>
     Effect.gen(function* () {
@@ -115,9 +100,33 @@ describe("OpenAIPlugin", () => {
       })
       yield* addPlugin()
 
-      const request = yield* http(Provider.ID.openai, "https://api.openai.com/v1/responses")
-      const custom = yield* http(Provider.ID.make("custom-openai"), "https://custom.example/v1/responses")
-      const proxy = yield* http(Provider.ID.openai, "https://proxy.example/v1/responses?region=us")
+      const request = yield* (yield* PluginHooks.Service).trigger("session", "request", {
+        sessionID: Session.ID.make("ses_test"),
+        agent: Agent.ID.make("build"),
+        model: Model.Ref.make({ providerID: Provider.ID.openai, id: Model.ID.make("gpt-5.5") }),
+        url: "https://api.openai.com/v1/responses",
+        method: "POST",
+        headers: {},
+        body: "{}",
+      })
+      const custom = yield* (yield* PluginHooks.Service).trigger("session", "request", {
+        sessionID: Session.ID.make("ses_test"),
+        agent: Agent.ID.make("build"),
+        model: Model.Ref.make({ providerID: Provider.ID.make("custom-openai"), id: Model.ID.make("gpt-5.5") }),
+        url: "https://custom.example/v1/responses",
+        method: "POST",
+        headers: {},
+        body: "{}",
+      })
+      const proxy = yield* (yield* PluginHooks.Service).trigger("session", "request", {
+        sessionID: Session.ID.make("ses_test"),
+        agent: Agent.ID.make("build"),
+        model: Model.Ref.make({ providerID: Provider.ID.openai, id: Model.ID.make("gpt-5.5") }),
+        url: "https://proxy.example/v1/responses?region=us",
+        method: "POST",
+        headers: {},
+        body: "{}",
+      })
 
       const provider = required(yield* catalog.provider.get(Provider.ID.openai))
       expect(provider.package).toBe("@opencode-ai/ai/providers/openai")
@@ -125,7 +134,7 @@ describe("OpenAIPlugin", () => {
       expect(provider.headers).toMatchObject({ "chatgpt-account-id": "acct_123" })
       expect(request.url).toBe("https://chatgpt.com/backend-api/codex/responses")
       expect(request.headers).toMatchObject({ originator: "opencode", "session-id": "ses_test" })
-      expect(custom.headers).not.toHaveProperty("originator")
+      expect(custom.headers).toEqual({})
       expect(proxy.url).toBe("https://proxy.example/v1/responses?region=us")
       expect(proxy.headers).toMatchObject({ originator: "opencode", "session-id": "ses_test" })
       const eligible = required(yield* catalog.model.get(Provider.ID.openai, Model.ID.make("gpt-5.5")))
@@ -175,13 +184,21 @@ describe("OpenAIPlugin", () => {
       })
       yield* addPlugin()
 
-      const request = yield* http(Provider.ID.openai, "https://api.openai.com/v1/responses")
+      const request = yield* (yield* PluginHooks.Service).trigger("session", "request", {
+        sessionID: Session.ID.make("ses_test"),
+        agent: Agent.ID.make("build"),
+        model: Model.Ref.make({ providerID: Provider.ID.openai, id: Model.ID.make("gpt-5.5") }),
+        url: "https://api.openai.com/v1/responses",
+        method: "POST",
+        headers: {},
+        body: "{}",
+      })
 
       const model = required(yield* catalog.model.get(Provider.ID.openai, Model.ID.make("gpt-5.5")))
       expect(model.package).toBe("@opencode-ai/ai/providers/openai")
       expect(model.enabled).toBe(true)
       expect(model.limit).toEqual({ context: 1_050_000, input: 922_000, output: 128_000 })
-      expect(request.headers).not.toHaveProperty("originator")
+      expect(request.headers).toEqual({})
       expect(required(yield* catalog.model.get(Provider.ID.openai, Model.ID.make("gpt-4.1"))).enabled).toBe(true)
     }),
   )

packages/core/test/session-error.test.ts

@@ -14,9 +14,6 @@ import {
   TransportReason,
   UnknownProviderReason,
   ToolFailure,
-  HttpContext,
-  HttpRequestDetails,
-  HttpResponseDetails,
 } from "@opencode-ai/ai"
 import { Permission } from "@opencode-ai/core/permission"
 import { Tool } from "@opencode-ai/schema/tool"
@@ -74,23 +71,6 @@ describe("toSessionError", () => {
     })
   })
 
-  test("preserves provider HTTP status", () => {
-    const http = new HttpContext({
-      request: new HttpRequestDetails({ method: "POST", url: "https://example.com", headers: {} }),
-      response: new HttpResponseDetails({ status: 413, headers: {} }),
-    })
-    expect(toSessionError(llm(new InvalidRequestReason({ message: "too large", http })))).toEqual({
-      type: "provider.invalid-request",
-      message: "too large",
-      status: 413,
-    })
-    expect(toSessionError(llm(new ProviderInternalReason({ message: "bad gateway", status: 502 })))).toEqual({
-      type: "provider.internal",
-      message: "bad gateway",
-      status: 502,
-    })
-  })
-
   test("retries only rate limits, provider-internal failures, and transport failures", () => {
     const eligible = [
       llm(new RateLimitReason({ message: "rate" })),

packages/plugin/src/effect/session.ts

@@ -1,9 +1,10 @@
 import type { SessionApi } from "@opencode-ai/client/effect/api"
 import type { Message, SystemPart } from "@opencode-ai/ai"
+import type { HttpRequest } from "@opencode-ai/ai/route"
 import type { Agent } from "@opencode-ai/schema/agent"
 import type { Model } from "@opencode-ai/schema/model"
 import type { Session } from "@opencode-ai/schema/session"
-import type { Effect, JsonSchema } from "effect"
+import type { JsonSchema } from "effect"
 import type { Hooks } from "./registration.js"
 
 export interface SessionContext {
@@ -15,16 +16,15 @@ export interface SessionContext {
   tools: Record<string, { description: string; input: JsonSchema.JsonSchema }>
 }
 
-export interface SessionHttp {
+export interface SessionRequest extends HttpRequest {
   readonly sessionID: Session.ID
   readonly agent: Agent.ID
   readonly model: Model.Ref
-  request: (input: Request) => Effect.Effect<Response, Error>
 }
 
 export interface SessionHooks {
   readonly context: SessionContext
-  readonly http: SessionHttp
+  readonly request: SessionRequest
 }
 
 export type SessionDomain = Pick<

packages/plugin/src/promise/session.ts

@@ -1,5 +1,6 @@
 import type { SessionApi } from "@opencode-ai/client/promise/api"
 import type { Message, SystemPart } from "@opencode-ai/ai"
+import type { HttpRequest } from "@opencode-ai/ai/route"
 import type { Agent } from "@opencode-ai/schema/agent"
 import type { Model } from "@opencode-ai/schema/model"
 import type { Session } from "@opencode-ai/schema/session"
@@ -15,16 +16,15 @@ export interface SessionContext {
   tools: Record<string, { description: string; input: JsonSchema.JsonSchema }>
 }
 
-export interface SessionHttp {
+export interface SessionRequest extends HttpRequest {
   readonly sessionID: Session.ID
   readonly agent: Agent.ID
   readonly model: Model.Ref
-  request: (input: Request) => Promise<Response>
 }
 
 export interface SessionHooks {
   readonly context: SessionContext
-  readonly http: SessionHttp
+  readonly request: SessionRequest
 }
 
 export type SessionDomain = Pick<

packages/schema/src/session-error.ts

@@ -1,11 +1,9 @@
 export * as SessionError from "./session-error.js"
 
 import { Schema } from "effect"
-import { optional } from "./schema.js"
 
 export interface Error extends Schema.Schema.Type<typeof Error> {}
 export const Error = Schema.Struct({
   type: Schema.String,
   message: Schema.String,
-  status: Schema.Int.check(Schema.isBetween({ minimum: 100, maximum: 599 })).pipe(optional),
 }).annotate({ identifier: "Session.StructuredError" })

packages/tui/package.json

@@ -77,6 +77,11 @@
       "bun": "./src/plugin/runtime-plugin-support.bun.ts",
       "node": "./src/plugin/runtime-plugin-support.node.ts",
       "default": "./src/plugin/runtime-plugin-support.node.ts"
+    },
+    "#plugin-loader": {
+      "bun": "./src/plugin/loader.bun.ts",
+      "node": "./src/plugin/loader.node.ts",
+      "default": "./src/plugin/loader.node.ts"
     }
   },
   "dependencies": {

packages/tui/src/component/dialog-model.tsx

@@ -63,15 +63,15 @@ export function DialogModel(props: { providerID?: string }) {
         .filter((model) => (props.providerID ? model.providerID === props.providerID : true))
         .map((model) => {
           const provider = providers().get(model.providerID)
-          const favorite = favorites.some((item) => item.providerID === model.providerID && item.modelID === model.id)
           return {
             value: { providerID: model.providerID, modelID: model.id },
             providerID: model.providerID,
             providerName: provider?.name ?? model.providerID,
             title: model.name,
             releaseDate: model.time.released,
-            favorite,
-            description: favorite ? "(Favorite)" : undefined,
+            description: favorites.some((item) => item.providerID === model.providerID && item.modelID === model.id)
+              ? "(Favorite)"
+              : undefined,
             category: connected() ? (provider?.name ?? model.providerID) : undefined,
             footer: free(model) ? "Free" : undefined,
             onSelect() {
@@ -96,9 +96,7 @@ export function DialogModel(props: { providerID?: string }) {
     )
 
     if (needle) {
-      return prioritizeFavorites(
-        fuzzysort.go(needle, modelOptions, { keys: ["title", "category"] }).map((item) => item.obj),
-      )
+      return fuzzysort.go(needle, modelOptions, { keys: ["title", "category"] }).map((item) => item.obj)
     }
 
     return [...favoriteOptions, ...recentOptions, ...modelOptions]
@@ -162,10 +160,6 @@ export function DialogModel(props: { providerID?: string }) {
   )
 }
 
-export function prioritizeFavorites<T extends { favorite: boolean }>(options: T[]) {
-  return options.toSorted((a, b) => Number(b.favorite) - Number(a.favorite))
-}
-
 export function sortModelOptions<
   T extends { providerID?: string; providerName?: string; releaseDate: string | number; title: string },
 >(options: T[]) {

packages/tui/src/feature-plugins/sidebar/context.tsx

@@ -7,7 +7,7 @@ const money = new Intl.NumberFormat("en-US", {
   currency: "USD",
 })
 
-export function SidebarContext(props: { context: Plugin.Context; sessionID: string }) {
+function View(props: { context: Plugin.Context; sessionID: string }) {
   const theme = props.context.theme
   const msg = createMemo(() => props.context.data.session.message.list(props.sessionID))
   const session = createMemo(() => props.context.data.session.get(props.sessionID))
@@ -18,32 +18,28 @@ export function SidebarContext(props: { context: Plugin.Context; sessionID: stri
   )
 
   return (
-    <Show when={state() || cost() > 0}>
-      <box>
-        <text fg={theme.text.default}>
-          <b>Context</b>
-        </text>
-        <Show when={state()}>
-          {(value) => (
-            <>
-              <text fg={theme.text.subdued}>{value().tokens.toLocaleString()} tokens</text>
-              <Show when={value().percent !== undefined}>
-                <text fg={theme.text.subdued}>{value().percent}% used</text>
-              </Show>
-            </>
-          )}
-        </Show>
-        <Show when={cost() > 0}>
-          <text fg={theme.text.subdued}>{money.format(cost())} spent</text>
-        </Show>
-      </box>
-    </Show>
+    <box>
+      <text fg={theme.text.default}>
+        <b>Context</b>
+      </text>
+      <Show when={state()} fallback={<text fg={theme.text.subdued}>Not measured</text>}>
+        {(value) => (
+          <>
+            <text fg={theme.text.subdued}>{value().tokens.toLocaleString()} tokens</text>
+            <Show when={value().percent !== undefined}>
+              <text fg={theme.text.subdued}>{value().percent}% used</text>
+            </Show>
+          </>
+        )}
+      </Show>
+      <text fg={theme.text.subdued}>{money.format(cost())} spent</text>
+    </box>
   )
 }
 
 export default Plugin.define({
   id: "internal:sidebar-context",
   setup(context) {
-    context.ui.slot("sidebar.content", (props) => <SidebarContext context={context} sessionID={props.sessionID} />)
+    context.ui.slot("sidebar.content", (props) => <View context={context} sessionID={props.sessionID} />)
   },
 })

packages/tui/src/plugin/context.tsx

@@ -7,6 +7,7 @@ import type { Page, Slot, SlotName } from "@opencode-ai/plugin/tui/context"
 import { createStore, produce, reconcile as reconcileStore } from "solid-js/store"
 import { isDeepEqual } from "remeda"
 import "#runtime-plugin-support"
+import { preparePlugin } from "#plugin-loader"
 import { useConfig } from "../config"
 import { useTuiLifecycle } from "../context/runtime"
 import { errorMessage } from "../util/error"
@@ -215,7 +216,7 @@ export function PluginProvider(props: ParentProps<{ packages: PackageResolver }>
       const memo = local ? undefined : npmFailures.get(target)
       const resolved = memo
         ? { status: "failed" as const, error: memo }
-        : await resolvePlugin(target, local, options, previous, props.packages).catch((error) => ({
+        : await resolvePlugin(target, local, options, previous, props.packages, host.paths.state).catch((error) => ({
             status: "failed" as const,
             error: errorMessage(error),
           }))
@@ -439,6 +440,7 @@ async function resolvePlugin(
   options: Readonly<Record<string, any>> | undefined,
   previous: Registration | undefined,
   packages: PackageResolver,
+  state: string,
 ) {
   // Package entrypoints never change within a session, so a loaded previous
   // version needs no re-resolution (which could otherwise hit npm).
@@ -451,7 +453,7 @@ async function resolvePlugin(
   const version = local ? freshSpecifier(entrypoint, (await stat(new URL(entrypoint))).mtimeMs) : entrypoint
   if (previous && previous.version === version && sameOptions(previous.options, options))
     return { status: "unchanged" as const, plugin: previous.plugin, version }
-  const mod: { readonly default?: unknown } = await import(version)
+  const mod: { readonly default?: unknown } = await import(await preparePlugin(entrypoint, version, state))
   if (!isPlugin(mod.default)) throw new Error(`Invalid V2 TUI plugin module: ${spec}`)
   return { status: "loaded" as const, plugin: mod.default, version }
 }

packages/tui/src/plugin/loader.bun.ts

@@ -0,0 +1,44 @@
+import { createSolidTransformPlugin } from "@opentui/solid/bun-plugin"
+import { isCoreRuntimeModuleSpecifier, runtimeModuleIdForSpecifier } from "@opentui/core/runtime-plugin"
+import { mkdir } from "node:fs/promises"
+import path from "node:path"
+import { fileURLToPath } from "node:url"
+
+const runtime = new Set([
+  "@opentui/solid",
+  "@opentui/solid/components",
+  "@opentui/solid/jsx-runtime",
+  "@opentui/solid/jsx-dev-runtime",
+  "solid-js",
+  "solid-js/store",
+])
+
+export async function preparePlugin(entrypoint: string, version: string, state: string) {
+  const source = fileURLToPath(entrypoint)
+  if (!source.endsWith(".tsx") && !source.endsWith(".jsx")) return version
+  const result = await Bun.build({
+    entrypoints: [source],
+    target: "bun",
+    format: "esm",
+    sourcemap: "inline",
+    plugins: [
+      createSolidTransformPlugin({
+        moduleName: runtimeModuleIdForSpecifier("@opentui/solid"),
+        resolvePath(specifier) {
+          if (!runtime.has(specifier) && !isCoreRuntimeModuleSpecifier(specifier)) return null
+          return runtimeModuleIdForSpecifier(specifier)
+        },
+      }),
+    ],
+    external: [...runtime, "@opentui/core", "@opentui/core/testing"].flatMap((specifier) => [
+      specifier,
+      runtimeModuleIdForSpecifier(specifier),
+    ]),
+  })
+  if (!result.success) throw new Error(result.logs.join("\n"))
+  const directory = path.join(state, "tui-plugin-cache")
+  const output = path.join(directory, `${Bun.hash(version).toString(16)}.mjs`)
+  await mkdir(directory, { recursive: true })
+  await Bun.write(output, result.outputs[0]!)
+  return output
+}

packages/tui/src/plugin/loader.node.ts

@@ -0,0 +1,3 @@
+export async function preparePlugin(_entrypoint: string, version: string, _state: string) {
+  return version
+}

packages/tui/src/routes/session/sidebar.tsx

@@ -27,11 +27,9 @@ export function Sidebar(props: { sessionID: string; overlay?: boolean }) {
         position={props.overlay ? "absolute" : "relative"}
       >
         <scrollbox
-          ref={(scroll) => queueMicrotask(() => scroll.verticalScrollBar.resetVisibilityControl())}
           flexGrow={1}
           scrollAcceleration={scrollAcceleration()}
           verticalScrollbarOptions={{
-            visible: false,
             trackOptions: {
               backgroundColor: theme.background.default,
               foregroundColor: theme.scrollbar.default,

packages/tui/test/cli/cmd/tui/model-options.test.ts

@@ -1,23 +1,5 @@
 import { describe, expect, test } from "bun:test"
-import { prioritizeFavorites, sortModelOptions } from "../../../../src/component/dialog-model"
-
-describe("prioritizeFavorites", () => {
-  test("moves favorites first while preserving fuzzy result order", () => {
-    const prioritized = prioritizeFavorites([
-      { title: "Best match", favorite: false },
-      { title: "Favorite match", favorite: true },
-      { title: "Second best match", favorite: false },
-      { title: "Second favorite match", favorite: true },
-    ])
-
-    expect(prioritized.map((model) => model.title)).toEqual([
-      "Favorite match",
-      "Second favorite match",
-      "Best match",
-      "Second best match",
-    ])
-  })
-})
+import { sortModelOptions } from "../../../../src/component/dialog-model"
 
 describe("sortModelOptions", () => {
   test("orders opencode models before other providers", () => {

packages/tui/test/feature-plugins/sidebar-context.test.tsx

@@ -1,70 +0,0 @@
-/** @jsxImportSource @opentui/solid */
-import { expect, test } from "bun:test"
-import { RGBA } from "@opentui/core"
-import { testRender } from "@opentui/solid"
-import type { Context } from "@opencode-ai/plugin/tui/context"
-import { SidebarContext } from "../../src/feature-plugins/sidebar/context"
-
-function context(options?: { cost?: number; tokens?: number }) {
-  const color = RGBA.fromInts(200, 200, 200)
-  return {
-    theme: { text: { default: color, subdued: color } },
-    data: {
-      session: {
-        get: () => ({ location: { directory: "/workspace" } }),
-        cost: () => options?.cost ?? 0,
-        message: {
-          list: () =>
-            options?.tokens
-              ? [
-                  {
-                    id: "message",
-                    type: "assistant",
-                    model: { providerID: "provider", id: "model" },
-                    tokens: {
-                      input: options.tokens,
-                      output: 0,
-                      reasoning: 0,
-                      cache: { read: 0, write: 0 },
-                    },
-                  },
-                ]
-              : [],
-        },
-      },
-      location: {
-        model: { list: () => [] },
-      },
-    },
-  } as unknown as Context
-}
-
-test("sidebar omits context before usage is available", async () => {
-  const app = await testRender(() => <SidebarContext context={context()} sessionID="session" />, {
-    width: 42,
-    height: 8,
-  })
-
-  try {
-    await app.renderOnce()
-    expect(app.captureCharFrame()).not.toContain("Context")
-    expect(app.captureCharFrame()).not.toContain("Not measured")
-  } finally {
-    app.renderer.destroy()
-  }
-})
-
-test("sidebar shows available context usage", async () => {
-  const app = await testRender(() => <SidebarContext context={context({ tokens: 1234 })} sessionID="session" />, {
-    width: 42,
-    height: 8,
-  })
-
-  try {
-    await app.renderOnce()
-    expect(app.captureCharFrame()).toContain("Context")
-    expect(app.captureCharFrame()).toContain("1,234 tokens")
-  } finally {
-    app.renderer.destroy()
-  }
-})

packages/tui/test/plugin-reactivity.test.tsx

@@ -0,0 +1,72 @@
+import { expect, test } from "bun:test"
+import { createComponent, createSignal, type JSX } from "solid-js"
+import { testRender } from "@opentui/solid"
+import { mkdir, writeFile } from "node:fs/promises"
+import path from "node:path"
+import { preparePlugin } from "../src/plugin/loader.bun"
+import "../src/plugin/runtime-plugin-support.bun"
+import { tmpdir } from "./fixture/fixture"
+
+test("an external TSX plugin uses the host Solid runtime", async () => {
+  await using tmp = await tmpdir()
+  const root = path.join(tmp.path, ".opencode")
+  const source = path.join(root, "plugins", "tui", "reactive.tsx")
+  const helper = path.join(root, "plugins", "tui", "signal.ts")
+  const localSolid = path.join(root, "node_modules", "solid-js")
+  const localOpenTui = path.join(root, "node_modules", "@opentui", "solid")
+  await Promise.all([
+    mkdir(path.dirname(source), { recursive: true }),
+    mkdir(localSolid, { recursive: true }),
+    mkdir(localOpenTui, { recursive: true }),
+  ])
+  await Promise.all([
+    writeFile(
+      path.join(localSolid, "package.json"),
+      JSON.stringify({ name: "solid-js", type: "module", main: "index.js" }),
+    ),
+    writeFile(
+      path.join(localSolid, "index.js"),
+      "export const createSignal = () => { throw new Error('local Solid used') }\n",
+    ),
+    writeFile(
+      path.join(localOpenTui, "package.json"),
+      JSON.stringify({ name: "@opentui/solid", type: "module", main: "index.js" }),
+    ),
+    writeFile(path.join(localOpenTui, "index.js"), "throw new Error('local OpenTUI used')\n"),
+    writeFile(helper, 'export { createSignal, onCleanup } from "solid-js"\n'),
+    writeFile(
+      source,
+      `
+import { createSignal, onCleanup } from "./signal"
+
+export const signal = createSignal
+
+export default {
+  id: "test.reactive",
+  setup(context: any) {
+    context.ui.slot("home.footer", () => {
+      const [count, setCount] = createSignal(0)
+      const timer = setTimeout(() => setCount(1), 10)
+      onCleanup(() => clearTimeout(timer))
+      return <box><text>count:{count()}</text></box>
+    })
+  },
+}
+`,
+    ),
+  ])
+
+  const plugin = await import(await preparePlugin(new URL(`file://${source}`).href, `${source}?mtime=1`, tmp.path))
+  expect(plugin.signal).toBe(createSignal)
+  let slot: ((input: object) => JSX.Element) | undefined
+  await plugin.default.setup({ ui: { slot: (_name: string, render: typeof slot) => (slot = render) } })
+  if (!slot) throw new Error("Plugin did not register its slot")
+
+  const setup = await testRender(() => createComponent(slot!, {}), { width: 20, height: 2 })
+  try {
+    expect(await setup.waitForFrame((frame) => frame.includes("count:0"))).toContain("count:0")
+    expect(await setup.waitForFrame((frame) => frame.includes("count:1"))).toContain("count:1")
+  } finally {
+    setup.renderer.destroy()
+  }
+})

packages/www/content/docs/build/plugins.mdx

@@ -246,8 +246,7 @@ mutable fields:
 | ------------------------------------------- | ------------------------------------------------------------------------------ |
 | `ctx.aisdk.hook("sdk", callback)`           | `sdk`, after inspecting `model`, `package`, and `options`                      |
 | `ctx.aisdk.hook("language", callback)`      | `language`, after inspecting `model`, `sdk`, and `options`                     |
-| `ctx.session.hook("context", callback)`     | `system`, `messages`, and the `tools` record immediately before model dispatch |
-| `ctx.session.hook("http", callback)`        | `request`, wrapping the model's HTTP request and response                       |
+| `ctx.session.hook("request", callback)`     | `system`, `messages`, and the `tools` record immediately before model dispatch |
 | `ctx.tool.hook("execute.before", callback)` | `input`, before the selected tool executes                                     |
 | `ctx.tool.hook("execute.after", callback)`  | Terminal `result` on success or `error` on failure                            |
 
@@ -260,7 +259,7 @@ import { Plugin } from "@opencode-ai/plugin"
 export default Plugin.define({
   id: "acme.guards",
   setup: async (ctx) => {
-    await ctx.session.hook("context", (event) => {
+    await ctx.session.hook("request", (event) => {
       delete event.tools.write
     })