@opencode-ai/ai 0.0.0-next-16745 → 0.0.0-next-16772

package/dist/route/client.d.ts

@@ -4,7 +4,7 @@ import { Endpoint, type EndpointPatch } from "./endpoint";
 import { RequestExecutor } from "./executor";
 import { Framing } from "./framing";
 import { HttpTransport } from "./transport";
-import type { HttpRequestTransform, Transport, TransportRuntime } from "./transport";
+import type { HttpMiddleware, Transport, TransportRuntime } from "./transport";
 import type { Protocol } from "./protocol";
 import type { ProtocolID, ProviderOptions } from "../schema";
 import { AIError, GenerationOptions, HttpOptions, LLMRequest, LLMResponse, LanguageModel, LanguageModelLimits, LLMEvent, ProviderID } from "../schema";
@@ -63,7 +63,7 @@ export interface Interface {
     readonly generate: GenerateMethod;
 }
 export interface StreamOptions {
-    readonly transform?: HttpRequestTransform;
+    readonly http?: HttpMiddleware;
 }
 export interface StreamMethod {
     (request: LLMRequest, options?: StreamOptions): Stream.Stream<LLMEvent, AIError>;

package/dist/route/client.js

@@ -112,7 +112,7 @@ function makeFromTransport(input) {
                 auth: routeInput.auth ?? Auth.none,
                 encodeBody,
                 headers: routeInput.headers,
-                transform: options?.transform,
+                middleware: options?.http,
             }),
             streamPrepared: (prepared, request, runtime) => {
                 const route = `${request.model.provider}/${request.model.route.id}`;

package/dist/route/executor.d.ts

@@ -2,8 +2,10 @@ import { Context, Effect, Layer } from "effect";
 import { HttpClient, HttpClientRequest, HttpClientResponse } from "effect/unstable/http";
 import { AIError } from "../schema";
 export interface Interface {
-    readonly execute: (request: HttpClientRequest.HttpClientRequest) => Effect.Effect<HttpClientResponse.HttpClientResponse, AIError>;
+    readonly execute: (request: HttpClientRequest.HttpClientRequest, middleware?: HttpMiddleware) => Effect.Effect<HttpClientResponse.HttpClientResponse, AIError>;
 }
+export type HttpHandler = (request: HttpClientRequest.HttpClientRequest) => Effect.Effect<HttpClientResponse.HttpClientResponse, Error>;
+export type HttpMiddleware = (request: HttpClientRequest.HttpClientRequest, handler: HttpHandler) => Effect.Effect<HttpClientResponse.HttpClientResponse, Error>;
 declare const Service_base: Context.ServiceClass<Service, "@opencode/AI/RequestExecutor", Interface>;
 export declare class Service extends Service_base {
 }

package/dist/route/executor.js

@@ -197,7 +197,7 @@ const toHttpError = (redactedNames) => (error) => {
         return transportError({ message: error.message, kind: "Timeout" });
     }
     if (!HttpClientError.isHttpClientError(error)) {
-        return transportError({ message: "HTTP transport failed" });
+        return transportError({ message: error instanceof Error ? error.message : "HTTP transport failed" });
     }
     const request = "request" in error ? error.request : undefined;
     if (error.reason._tag === "TransportError") {
@@ -215,11 +215,16 @@ const toHttpError = (redactedNames) => (error) => {
 };
 export const layer = Layer.effect(Service, Effect.gen(function* () {
     const http = yield* HttpClient.HttpClient;
-    const executeOnce = (request) => Effect.gen(function* () {
+    const executeOnce = (request, middleware) => Effect.gen(function* () {
         const redactedNames = yield* Headers.CurrentRedactedNames;
-        return yield* http
-            .execute(request)
-            .pipe(Effect.mapError(toHttpError(redactedNames)), Effect.flatMap(statusError(request, redactedNames)));
+        if (!middleware)
+            return yield* http
+                .execute(request)
+                .pipe(Effect.mapError(toHttpError(redactedNames)), Effect.flatMap(statusError(request, redactedNames)));
+        const response = yield* middleware(request, (input) => http
+            .execute(input)
+            .pipe(Effect.mapError((cause) => (cause instanceof Error ? cause : new Error(String(cause)))))).pipe(Effect.mapError(toHttpError(redactedNames)));
+        return yield* statusError(response.request, redactedNames)(response);
     });
     return Service.of({
         execute: executeOnce,

package/dist/route/index.d.ts

@@ -13,4 +13,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 { HttpRequest, HttpRequestTransform, Transport as TransportDef, TransportRuntime } from "./transport";
+export type { HttpHandler, HttpMiddleware, Transport as TransportDef, TransportRuntime } from "./transport";

package/dist/route/transport/http.d.ts

@@ -1,7 +1,7 @@
 import { Effect } from "effect";
 import { Headers, HttpClientRequest } from "effect/unstable/http";
 import { Framing } from "../framing";
-import type { Transport, TransportPrepareInput } from "./index";
+import type { HttpMiddleware, Transport, TransportPrepareInput } from "./index";
 export type JsonRequestInput<Body> = TransportPrepareInput<Body>;
 export interface JsonRequestParts<Body = unknown> {
     readonly url: string;
@@ -12,6 +12,7 @@ export interface JsonRequestParts<Body = unknown> {
 export interface HttpPrepared<Frame> {
     readonly request: HttpClientRequest.HttpClientRequest;
     readonly framing: Framing.Definition<Frame>;
+    readonly middleware?: HttpMiddleware;
 }
 export declare const jsonRequestParts: <Body>(input: JsonRequestInput<Body>) => Effect.Effect<{
     url: string;

package/dist/route/transport/http.js

@@ -41,19 +41,19 @@ export const httpJson = (input) => ({
     with: (patch) => httpJson({ ...input, ...patch }),
     prepare: (prepareInput) => Effect.gen(function* () {
         const parts = yield* jsonRequestParts({ ...prepareInput });
-        const request = { url: parts.url, method: "POST", headers: { ...parts.headers }, body: parts.bodyText };
-        yield* (prepareInput.transform?.(request) ?? Effect.void);
+        const request = ProviderShared.jsonPost({
+            url: parts.url,
+            body: parts.bodyText,
+            headers: parts.headers,
+        });
         return {
-            request: ProviderShared.jsonPost({
-                url: request.url,
-                body: request.body ?? "",
-                headers: Headers.fromInput(request.headers),
-            }),
+            request,
             framing: input.framing,
+            middleware: prepareInput.middleware,
         };
     }),
     frames: (prepared, request, runtime) => Stream.unwrap(runtime.http
-        .execute(prepared.request)
+        .execute(prepared.request, prepared.middleware)
         .pipe(Effect.map((response) => prepared.framing.frame(response.stream.pipe(Stream.mapError((error) => ProviderShared.eventError(`${request.model.provider}/${request.model.route.id}`, `Failed to read ${request.model.provider}/${request.model.route.id} stream`, ProviderShared.errorText(error)))))))),
 });
 export const sseJson = {

package/dist/route/transport/index.d.ts

@@ -1,20 +1,13 @@
 import type { Effect, Stream } from "effect";
 import { Endpoint } from "../endpoint";
 import { Auth } from "../auth";
-import type { Interface as RequestExecutorInterface } from "../executor";
+import type { HttpMiddleware, Interface as RequestExecutorInterface } from "../executor";
 import type { Interface as WebSocketExecutorInterface } from "./websocket";
 import type { AIError, LLMRequest } from "../../schema";
 export interface TransportRuntime {
     readonly http: RequestExecutorInterface;
     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, AIError>;
@@ -29,7 +22,8 @@ export interface TransportPrepareInput<Body> {
     readonly headers?: (input: {
         readonly request: LLMRequest;
     }) => Record<string, string>;
-    readonly transform?: HttpRequestTransform;
+    readonly middleware?: HttpMiddleware;
 }
 export * as HttpTransport from "./http";
+export type { HttpHandler, HttpMiddleware } from "../executor";
 export { WebSocketExecutor, WebSocketTransport } from "./websocket";

package/package.json

@@ -1,6 +1,6 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
-  "version": "0.0.0-next-16745",
+  "version": "0.0.0-next-16772",
   "name": "@opencode-ai/ai",
   "type": "module",
   "license": "MIT",
@@ -30,7 +30,7 @@
   "devDependencies": {
     "@clack/prompts": "1.0.0-alpha.1",
     "@effect/platform-node": "4.0.0-beta.101",
-    "@opencode-ai/http-recorder": "0.0.0-next-16745",
+    "@opencode-ai/http-recorder": "0.0.0-next-16772",
     "@tsconfig/bun": "1.0.9",
     "@types/bun": "1.3.13",
     "@typescript/native-preview": "7.0.0-dev.20251207.1",
@@ -39,7 +39,7 @@
   "dependencies": {
     "@smithy/eventstream-codec": "4.2.14",
     "@smithy/util-utf8": "4.2.2",
-    "@opencode-ai/schema": "0.0.0-next-16745",
+    "@opencode-ai/schema": "0.0.0-next-16772",
     "aws4fetch": "1.0.20",
     "effect": "4.0.0-beta.101",
     "google-auth-library": "10.5.0"