@opencode/ai 2.1.0 → 2.1.2

package/dist/experimental/realtime.js

@@ -1,7 +1,7 @@
 import { Clock, Effect, Redacted, Schema } from "effect";
 import { HttpClientRequest } from "effect/http";
 import { RequestExecutor } from "../route/executor.js";
-import { AIError, HttpContext, InvalidProviderOutputError, InvalidRequestError } from "../schema/index.js";
+import { AIError, InvalidProviderOutputError, InvalidRequestError } from "../schema/index.js";
 import { encodeJson } from "../utils/json.js";
 const OPENAI_BASE_URL = "https://api.openai.com/v1";
 const XAI_BASE_URL = "https://api.x.ai/v1";
@@ -28,7 +28,10 @@ export const connect = Effect.fn("Realtime.connect")(function* (input) {
         }
         case "openai-realtime": {
             if (input.transport.type === "websocket")
-                return yield* clientSecret(resolved.id, OPENAI_BASE_URL, input.model, input.apiKey, session);
+                return yield* clientSecret(resolved.id, OPENAI_BASE_URL, input.model, input.apiKey, {
+                    expires_after: { anchor: "created_at", seconds: 60 },
+                    session,
+                });
             const form = new FormData();
             form.append("sdp", input.transport.sdp);
             form.append("session", encodeJson(session));
@@ -39,7 +42,9 @@ export const connect = Effect.fn("Realtime.connect")(function* (input) {
         case "xai-realtime": {
             if (input.transport.type !== "websocket")
                 return yield* invalidRequest("xAI Grok Voice only supports WebSocket transport");
-            return yield* clientSecret(resolved.id, XAI_BASE_URL, input.model, input.apiKey);
+            return yield* clientSecret(resolved.id, XAI_BASE_URL, input.model, input.apiKey, {
+                expires_after: { seconds: 60 },
+            });
         }
         case "gemini-live": {
             if (input.transport.type !== "websocket")
@@ -69,7 +74,7 @@ const LiveSessionResponse = Schema.fromJsonString(Schema.Struct({
     transport: Schema.Struct({ sdp: Schema.String }),
 }));
 // xAI's ephemeral-token docs (https://docs.x.ai/developers/model-capabilities/audio/ephemeral-tokens)
-// document the request body (`{ expires_after: { seconds } }`) but not the response payload; we assume
+// document the request body (`{ expires_after: { seconds } }`, no `anchor` or `session`) but not the response payload; we assume
 // it mirrors OpenAI's `{ value, expires_at }` response shape.
 const ClientSecretResponse = Schema.fromJsonString(Schema.Struct({
     value: Schema.String,
@@ -86,12 +91,12 @@ const post = (route, url, apiKey, body, response, authHeader) => Effect.gen(func
         : HttpClientRequest.bearerToken(apiKey), body instanceof FormData
         ? HttpClientRequest.bodyFormData(body)
         : HttpClientRequest.bodyText(encodeJson(body), "application/json")));
-    const http = new HttpContext({ url: res.request.url, status: res.status, headers: res.headers });
+    const http = RequestExecutor.responseHttp(res);
     const fail = (message, cause, raw) => new AIError({ reason: new InvalidProviderOutputError({ route, message, body: raw, http, cause }) });
     const text = yield* res.text.pipe(Effect.mapError((cause) => fail(`Failed to read ${route} response`, cause)));
     return yield* Schema.decodeEffect(response)(text).pipe(Effect.mapError((cause) => fail(`${route} returned an invalid response`, cause, text)));
 });
-const clientSecret = (route, baseURL, model, apiKey, session) => post(route, `${baseURL}/realtime/client_secrets`, apiKey, { expires_after: { seconds: 60 }, session }, ClientSecretResponse).pipe(Effect.map((data) => ({
+const clientSecret = (route, baseURL, model, apiKey, body) => post(route, `${baseURL}/realtime/client_secrets`, apiKey, body, ClientSecretResponse).pipe(Effect.map((data) => ({
     type: "websocket",
     url: `${baseURL.replace(/^http/, "ws")}/realtime?model=${encodeURIComponent(model)}`,
     token: data.value,

package/dist/experimental/system-one.js

@@ -2,7 +2,9 @@ import { Effect, Schema } from "effect";
 import { Headers, HttpClientRequest } from "effect/http";
 import { ChoiceQuestion, EvaluationInput, EvaluationModel, EvaluationResponse, EvaluationRounding, ScoreQuestion, } from "./evaluation.js";
 import { Auth } from "../route/auth.js";
-import { AIError, HttpContext, HttpOptions, InvalidProviderOutputError, InvalidRequestError, ModelID, Usage, mergeJsonRecords, } from "../schema/index.js";
+import { RequestExecutor } from "../route/executor.js";
+import { JsonObject, ProviderShared } from "../protocols/shared.js";
+import { AIError, HttpOptions, InvalidProviderOutputError, InvalidRequestError, ModelID, ProviderMetadata, Usage, mergeJsonRecords, } from "../schema/index.js";
 const Noul = Schema.Struct({
     type: Schema.Literal("noul"),
     instructions: EvaluationInput,
@@ -24,7 +26,7 @@ const Request = Schema.StructWithRest(Schema.Struct({
     model: Schema.String,
     state: EvaluationInput,
     questions: Schema.Record(Schema.String, Question),
-}), [Schema.Record(Schema.String, Schema.Any)]);
+}), [JsonObject]);
 const Probability = Schema.Number.check(Schema.isBetween({ minimum: 0, maximum: 1 }));
 const NoulAnswer = Schema.Struct({ type: Schema.Literal("noul"), noul: Probability });
 const Choice = Schema.Struct({
@@ -44,14 +46,14 @@ const Answer = Schema.Union([NoulAnswer, Choice, Score]).pipe(Schema.toTaggedUni
 const NativeUsage = Schema.StructWithRest(Schema.Struct({
     input_tokens: Schema.optional(Schema.Number),
     output_tokens: Schema.optional(Schema.Number),
-}), [Schema.Record(Schema.String, Schema.Unknown)]);
+}), [JsonObject]);
 const Response = Schema.Struct({
     model: Schema.String,
     answers: Schema.Record(Schema.String, Answer),
     usage: Schema.optional(NativeUsage),
     id: Schema.optional(Schema.String),
     provider: Schema.optional(Schema.String),
-    provider_metadata: Schema.optional(Schema.Record(Schema.String, Schema.Record(Schema.String, Schema.Unknown))),
+    provider_metadata: Schema.optional(ProviderMetadata),
 });
 export const model = (cfg) => EvaluationModel.make({
     id: cfg.id,
@@ -76,7 +78,7 @@ export const model = (cfg) => EvaluationModel.make({
                 headers: Headers.fromInput({ ...cfg.headers, ...req.http?.headers }),
             });
             const res = yield* send(HttpClientRequest.post(url).pipe(HttpClientRequest.setHeaders(headers), HttpClientRequest.bodyText(body, "application/json")));
-            const http = new HttpContext({ url: res.request.url, status: res.status, headers: res.headers });
+            const http = RequestExecutor.responseHttp(res);
             const fail = (message, cause, body) => new AIError({ reason: new InvalidProviderOutputError({ route: "system-one", message, body, http, cause }) });
             const text = yield* res.text.pipe(Effect.mapError((cause) => fail("Failed to read the System One response", cause)));
             const data = yield* Schema.decodeUnknownEffect(Schema.fromJsonString(Response))(text).pipe(Effect.mapError((cause) => fail("System One returned an invalid response", cause, text)));
@@ -120,9 +122,7 @@ export const model = (cfg) => EvaluationModel.make({
                     ? new Usage({
                         inputTokens: data.usage.input_tokens,
                         outputTokens: data.usage.output_tokens,
-                        totalTokens: data.usage.input_tokens === undefined && data.usage.output_tokens === undefined
-                            ? undefined
-                            : (data.usage.input_tokens ?? 0) + (data.usage.output_tokens ?? 0),
+                        totalTokens: ProviderShared.totalTokens(data.usage.input_tokens, data.usage.output_tokens, undefined),
                         providerMetadata: { [cfg.providerMetadataKey]: data.usage },
                     })
                     : undefined,

package/dist/media.js

@@ -3,9 +3,9 @@ import { Effect, FileSystem, Schema, SchemaGetter } from "effect";
 import { Base64 } from "effect/encoding";
 import { HttpClientRequest } from "effect/http";
 import { ProviderID } from "./schema/ids.js";
-import { AIError, HttpContext, InvalidProviderOutputError, InvalidRequestError } from "./schema/errors.js";
+import { AIError, InvalidProviderOutputError, InvalidRequestError } from "./schema/errors.js";
 import { ProviderMetadata } from "./schema/options.js";
-import { Service } from "./route/executor-service.js";
+import { responseHttp, Service } from "./route/executor-service.js";
 import { detectMediaType, fileMediaType } from "./utils/media-type.js";
 export { detectMediaType } from "./utils/media-type.js";
 const OCTET_STREAM = "application/octet-stream";
@@ -183,7 +183,7 @@ const download = Effect.fn("Media.download")(function* (source, headers) {
     const buffer = yield* response.arrayBuffer.pipe(Effect.mapError((cause) => new AIError({
         reason: new InvalidProviderOutputError({
             message: `Failed to read media from ${source.url}`,
-            http: new HttpContext({ url: response.request.url, status: response.status, headers: response.headers }),
+            http: responseHttp(response),
             cause,
         }),
     })));

package/dist/protocols/venice-chat.js

@@ -49,7 +49,7 @@ const Assistant = Schema.StructWithRest(Schema.Struct({
     ...OpenAIChat.OpenAIChatMessage.cases.assistant.schema.fields,
     tool_calls: optionalArray(ToolCall),
     thought_signature: Schema.optional(Schema.String),
-}), [Schema.Record(Schema.String, Schema.Unknown)]);
+}), [JsonObject]);
 const Messages = Schema.Array(Schema.Union([
     OpenAIChat.OpenAIChatMessage.cases.system,
     OpenAIChat.OpenAIChatMessage.cases.user,
@@ -85,16 +85,16 @@ const Delta = Schema.StructWithRest(Schema.Struct({
     ...OpenAIChat.OpenAIChatDelta.schema.fields,
     tool_calls: optionalNull(Schema.Array(ToolDelta)),
     thought_signature: optionalNull(Schema.String),
-}), [Schema.Record(Schema.String, Schema.Unknown)]);
-const Choice = Schema.StructWithRest(Schema.Struct({ ...OpenAIChat.OpenAIChatChoice.schema.fields, delta: optionalNull(Delta) }), [Schema.Record(Schema.String, Schema.Unknown)]);
+}), [JsonObject]);
+const Choice = Schema.StructWithRest(Schema.Struct({ ...OpenAIChat.OpenAIChatChoice.schema.fields, delta: optionalNull(Delta) }), [JsonObject]);
 const Usage = Schema.StructWithRest(Schema.Struct({
     ...OpenAIChat.OpenAIChatUsage.schema.fields,
     prompt_tokens_details: optionalNull(Schema.StructWithRest(Schema.Struct({
         cached_tokens: optionalNull(Schema.Number),
         cache_write_tokens: optionalNull(Schema.Number),
         cache_creation_input_tokens: optionalNull(Schema.Number),
-    }), [Schema.Record(Schema.String, Schema.Unknown)])),
-}), [Schema.Record(Schema.String, Schema.Unknown)]);
+    }), [JsonObject])),
+}), [JsonObject]);
 const Event = Schema.StructWithRest(Schema.Struct({
     ...OpenAIChat.OpenAIChatEvent.schema.fields,
     choices: optionalNull(Schema.Array(Choice)),
@@ -104,7 +104,7 @@ const Event = Schema.StructWithRest(Schema.Struct({
         message: Schema.String,
         path: Schema.optional(Schema.Array(Schema.Union([Schema.String, Schema.Number]))),
     })),
-}), [Schema.Record(Schema.String, Schema.Unknown)]);
+}), [JsonObject]);
 const MARKER = "__ENCRYPTED_REASONING__";
 // ---------------------------------------------------------------------------
 // Request lowering

package/dist/provider-error.js

@@ -201,7 +201,7 @@ export function classifyProviderFailure(input) {
     if (input.status === 402 ||
         codes.some((code) => QUOTA_CODES.has(code)) ||
         (input.status === 429 && QUOTA_TEXT.test(text)))
-        return new QuotaExceededError(details);
+        return new QuotaExceededError({ ...details, retryAfterMs: input.retryAfterMs });
     if (input.status === 401 ||
         input.status === 403 ||
         codes.some((code) => AUTH_CODES.has(code)) ||

package/dist/providers/vercel-ai-gateway.js

@@ -4,19 +4,20 @@ import { EvaluationAnswer, EvaluationInput, EvaluationModel, EvaluationQuestion,
 import { AnthropicMessages } from "../protocols/anthropic-messages.js";
 import { OpenAIChat } from "../protocols/openai-chat.js";
 import { OpenResponses } from "../protocols/open-responses.js";
-import { optionalNull, ProviderShared } from "../protocols/shared.js";
+import { JsonObject, optionalNull, ProviderShared } from "../protocols/shared.js";
 import { gatewayProtocol } from "../protocols/utils/gateway-protocol.js";
 import { Auth } from "../route/auth.js";
 import { AuthOptions } from "../route/auth-options.js";
 import { Route } from "../route/client.js";
 import { Endpoint } from "../route/endpoint.js";
+import { RequestExecutor } from "../route/executor.js";
 import { Framing } from "../route/framing.js";
-import { AIError, HttpContext, HttpOptions, InvalidProviderOutputError, InvalidRequestError, LLMRequest, ModelID, ProviderID, ProviderMetadata, ReasoningEffort, Usage, } from "../schema/index.js";
+import { AIError, HttpOptions, InvalidProviderOutputError, InvalidRequestError, LLMRequest, ModelID, ProviderID, ProviderMetadata, ProviderOptions, ReasoningEffort, Usage, } from "../schema/index.js";
 export const id = ProviderID.make("vercel-ai-gateway");
 const baseURL = "https://ai-gateway.vercel.sh/v1";
 const GatewayOptionsSchema = Schema.Struct({
     gateway: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)),
-    upstream: Schema.optional(Schema.Record(Schema.String, Schema.Record(Schema.String, Schema.Unknown))),
+    upstream: Schema.optional(ProviderMetadata),
     reasoningEffort: Schema.optional(ReasoningEffort),
     thinking: Schema.optional(Schema.Struct({
         type: Schema.String,
@@ -110,8 +111,8 @@ const Request = Schema.StructWithRest(Schema.Struct({
     model: Schema.String,
     state: EvaluationInput,
     questions: Schema.Record(Schema.String, EvaluationQuestion),
-    providerOptions: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)),
-}), [Schema.Record(Schema.String, Schema.Any)]);
+    providerOptions: Schema.optional(ProviderOptions),
+}), [JsonObject]);
 const Response = Schema.Struct({
     model: optionalNull(Schema.String),
     answers: Schema.Record(Schema.String, EvaluationAnswer),
@@ -170,7 +171,7 @@ export const configure = (input = {}) => {
                     headers: Headers.fromInput({ ...input.headers, ...req.http?.headers }),
                 });
                 const res = yield* send(HttpClientRequest.post(url).pipe(HttpClientRequest.setHeaders(headers), HttpClientRequest.bodyText(body, "application/json")));
-                const http = new HttpContext({ url: res.request.url, status: res.status, headers: res.headers });
+                const http = RequestExecutor.responseHttp(res);
                 const fail = (message, cause, body) => new AIError({
                     reason: new InvalidProviderOutputError({
                         route: "vercel-evaluation",

package/dist/route/client.js

@@ -15,7 +15,7 @@ const makeRouteLanguageModel = (route, mapped) => {
     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))
+    if (!route.endpoint.baseURL)
         throw new ProviderConfigurationError({
             provider: ProviderID.make(provider),
             message: `Route.model(${route.id}) requires an endpoint baseURL — configure it on the route first`,
@@ -37,7 +37,6 @@ const mergeRouteDefaults = (base, patch) => {
         http: mergeHttpOptions(base?.http, HttpOptions.make(patch.http), headers === undefined ? undefined : new HttpOptions({ headers })),
     };
 };
-const endpointBaseURL = (endpoint) => typeof endpoint.baseURL === "string" ? endpoint.baseURL : undefined;
 const mergeHeaders = (...items) => {
     const entries = items.flatMap((item) => item === undefined ? [] : Object.entries(item).filter((entry) => entry[1] !== undefined));
     if (entries.length === 0)

package/dist/route/executor-service.d.ts

@@ -1,6 +1,6 @@
 import { Context, type Effect } from "effect";
-import type { HttpClientRequest, HttpClientResponse } from "effect/http";
-import type { AIError } from "../schema/errors.js";
+import type { Headers, HttpClientRequest, HttpClientResponse } from "effect/http";
+import { HttpContext, type AIError } from "../schema/errors.js";
 export interface Interface {
     readonly execute: (request: HttpClientRequest.HttpClientRequest, middleware?: HttpMiddleware) => Effect.Effect<HttpClientResponse.HttpClientResponse, AIError>;
 }
@@ -11,4 +11,8 @@ export declare class RequestExecutorService extends RequestExecutorService_base
 }
 export declare const Service: typeof RequestExecutorService;
 export type Service = RequestExecutorService;
+export declare const headerDetails: (headers: Headers.Headers) => {
+    [k: string]: string;
+};
+export declare const responseHttp: (response: HttpClientResponse.HttpClientResponse) => HttpContext;
 export {};

package/dist/route/executor-service.js

@@ -1,4 +1,11 @@
 import { Context } from "effect";
+import { HttpContext } from "../schema/errors.js";
 export class RequestExecutorService extends Context.Service()("@opencode/AI/RequestExecutor") {
 }
 export const Service = RequestExecutorService;
+export const headerDetails = (headers) => Object.fromEntries(Object.entries(headers).map(([name, value]) => [name, String(value)]));
+export const responseHttp = (response) => new HttpContext({
+    url: response.request.url,
+    status: response.status,
+    headers: headerDetails(response.headers),
+});

package/dist/route/executor.d.ts

@@ -1,10 +1,9 @@
 import { Layer, Stream } from "effect";
 import { HttpClient, HttpClientRequest, HttpClientResponse } from "effect/http";
-import { HttpContext, AIError } from "../schema/index.js";
+import { AIError } from "../schema/index.js";
 import { Service, type HttpMiddleware, type Interface } from "./executor-service.js";
-export { Service } from "./executor-service.js";
+export { responseHttp, Service } from "./executor-service.js";
 export type { HttpHandler, HttpMiddleware, Interface } from "./executor-service.js";
-export declare const responseHttp: (response: HttpClientResponse.HttpClientResponse) => HttpContext;
 /** Preserve HTTP diagnostics for executor and externally captured failures alike. */
 export declare const httpFailure: (input: {
     readonly message: string;

package/dist/route/executor.js

@@ -2,23 +2,23 @@ import { Cause, Effect, Layer, Option, Schema, Stream } from "effect";
 import { FetchHttpClient, Headers, HttpClient, HttpClientError, HttpClientRequest, HttpClientResponse, } from "effect/http";
 import { HttpContext, HttpRateLimitDetails, AIError, TransportError } from "../schema/index.js";
 import { classifyProviderFailure, providerErrorMessage } from "../provider-error.js";
-import { Service } from "./executor-service.js";
-export { Service } from "./executor-service.js";
-const headerDetails = (headers) => Object.fromEntries(Object.entries(headers).map(([name, value]) => [name, String(value)]));
+import { headerDetails, responseHttp, Service } from "./executor-service.js";
+export { responseHttp, Service } from "./executor-service.js";
 const normalizedHeaders = (headers) => Object.fromEntries(Object.entries(headers).map(([key, value]) => [key.toLowerCase(), value]));
+const clampRetryAfterMs = (millis) => Math.min(Number.MAX_SAFE_INTEGER, Math.max(0, Math.ceil(millis)));
 const retryAfterMs = (headers) => {
     const millis = Number(headers["retry-after-ms"]);
     if (Number.isFinite(millis))
-        return Math.max(0, millis);
+        return clampRetryAfterMs(millis);
     const value = headers["retry-after"];
     if (!value)
         return undefined;
     const seconds = Number(value);
     if (Number.isFinite(seconds))
-        return Math.max(0, seconds * 1000);
+        return clampRetryAfterMs(seconds * 1000);
     const date = Date.parse(value);
     if (!Number.isNaN(date))
-        return Math.max(0, date - Date.now());
+        return clampRetryAfterMs(date - Date.now());
     return undefined;
 };
 const addRateLimitValue = (target, key, value) => {
@@ -60,11 +60,6 @@ const rateLimitDetails = (headers, retryAfter) => {
         reset: Object.keys(reset).length === 0 ? undefined : reset,
     });
 };
-export const responseHttp = (response) => new HttpContext({
-    url: response.request.url,
-    status: response.status,
-    headers: headerDetails(response.headers),
-});
 const MAX_BODY_CHARS = 2000;
 // Without a recognized message, show the raw body so the provider's explanation is never dropped.
 const providerMessage = (status, body) => {

package/dist/route/media-protocol.d.ts

@@ -3,7 +3,7 @@ import { HttpClientResponse } from "effect/http";
 import type { Snapshot, Status } from "../generation.js";
 import { Media } from "../media.js";
 import type { AuthInput } from "./auth.js";
-import { AIError, AuthenticationError, HttpContext, InvalidRequestError, ProviderID, ProviderInternalError, RateLimitError } from "../schema/index.js";
+import { AIError, AuthenticationError, type HttpContext, InvalidRequestError, ProviderID, ProviderInternalError, RateLimitError } from "../schema/index.js";
 /** Array values become repeated parameters (`keyterm=a&keyterm=b`). */
 export type Query = Readonly<Record<string, string | ReadonlyArray<string>>>;
 /** `query` is appended to the endpoint URL before the route and caller `http.query` overlays. */

package/dist/route/media-protocol.js

@@ -1,7 +1,8 @@
 import { Clock, Duration, Effect, Schema } from "effect";
 import { HttpClientResponse } from "effect/http";
 import { Media } from "../media.js";
-import { AIError, AuthenticationError, ContentPolicyError, HttpContext, InvalidProviderOutputError, InvalidRequestError, ProviderID, ProviderInternalError, RateLimitError, UnsupportedOperationError, } from "../schema/index.js";
+import { RequestExecutor } from "./executor.js";
+import { AIError, AuthenticationError, ContentPolicyError, InvalidProviderOutputError, InvalidRequestError, ProviderID, ProviderInternalError, RateLimitError, UnsupportedOperationError, } from "../schema/index.js";
 export const json = (value, query) => ({
     type: "json",
     value,
@@ -27,7 +28,6 @@ const FAILURES = {
     RateLimit: RateLimitError,
     ProviderInternal: ProviderInternalError,
 };
-const context = (response) => new HttpContext({ url: response.request.url, status: response.status, headers: response.headers });
 /** One protocol's route id, display name, and provider, with the decoders and errors that carry them. */
 export const identity = (input) => {
     const provider = ProviderID.make(input.provider);
@@ -40,7 +40,7 @@ export const identity = (input) => {
      * `contentPolicy` is a moderated result.
      */
     const text = Effect.fn("MediaProtocol.text")(function* (response) {
-        const http = context(response);
+        const http = RequestExecutor.responseHttp(response);
         const body = yield* response.text.pipe(Effect.mapError((cause) => new AIError({
             reason: new InvalidProviderOutputError({
                 route: input.id,

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

@@ -2,7 +2,6 @@ import { Effect, Stream } from "effect";
 import { Headers } from "effect/http";
 import { Socket } from "effect/socket";
 import { AIError, type HttpContext } from "../../schema/index.js";
-import type { Transport } from "./index.js";
 import type { WebSocketChannelExecutor } from "./websocket-channel.js";
 export interface WebSocketRequest {
     readonly url: string;
@@ -23,30 +22,7 @@ export declare const fromWebSocket: (ws: Socket.WebSocketLike, input: WebSocketR
 export declare const messageText: (message: string | Uint8Array, decoder: TextDecoder) => string;
 export declare const makeDirect: (connector: WebSocketConnector) => WebSocketChannelExecutor;
 export declare const direct: Effect.Effect<WebSocketChannelExecutor, never, Socket.WebSocketConstructor>;
-export interface JsonPrepared {
-    readonly url: string;
-    readonly headers: Headers.Headers;
-    readonly message: string;
-}
-export interface JsonInput<Body, Message> {
-    readonly toMessage: (body: Body | Record<string, unknown>) => Effect.Effect<Message, AIError>;
-    readonly encodeMessage: (message: Message) => string;
-}
-export type JsonPatch<Body, Message> = Partial<JsonInput<Body, Message>>;
-export interface JsonTransport<Body, Message> extends Transport<Body, JsonPrepared, string> {
-    readonly with: (patch: JsonPatch<Body, Message>) => JsonTransport<Body, Message>;
-}
-export declare const json: <Body, Message>(input: JsonInput<Body, Message>) => JsonTransport<Body, Message>;
-export declare const jsonTransport: {
-    readonly id: "websocket-json";
-    readonly with: typeof json;
-};
 export declare const WebSocketTransport: {
-    readonly json: typeof json;
-    readonly jsonTransport: {
-        readonly id: "websocket-json";
-        readonly with: typeof json;
-    };
     readonly direct: Effect.Effect<WebSocketChannelExecutor, never, Socket.WebSocketConstructor>;
     readonly makeDirect: typeof makeDirect;
     readonly open: typeof open;

package/dist/route/transport/websocket.js

@@ -2,7 +2,6 @@ import { Cause, Effect, Queue, Stream } from "effect";
 import { Headers } from "effect/http";
 import { Socket } from "effect/socket";
 import { AIError, AIErrorReason, TransportError, } from "../../schema/index.js";
-import * as HttpTransport from "./http.js";
 const MAX_FRAME_BYTES = 16 * 1024 * 1024;
 const transportError = (message, input) => new AIError({
     reason: new TransportError({
@@ -300,56 +299,7 @@ export const direct = Effect.gen(function* () {
         open: (input) => open(input).pipe(Effect.provideService(Socket.WebSocketConstructor, constructor)),
     });
 });
-export const json = (input) => ({
-    id: "websocket-json",
-    with: (patch) => json({ ...input, ...patch }),
-    prepare: (prepareInput) => Effect.gen(function* () {
-        const parts = yield* HttpTransport.jsonRequestParts({
-            ...prepareInput,
-        });
-        return {
-            url: yield* toWebSocketUrl(parts.url),
-            headers: parts.headers,
-            message: input.encodeMessage(yield* input.toMessage(parts.jsonBody)),
-        };
-    }),
-    execute: (prepared, request, _runtime, options) => {
-        const webSocket = options?.webSocket;
-        if (!webSocket) {
-            return Effect.fail(transportError("WebSocket JSON transport requires StreamOptions.webSocket", {
-                url: prepared.url,
-                operation: "request",
-                code: "unavailable",
-                phase: "prepare",
-                delivery: "not-sent",
-            }));
-        }
-        const driver = {
-            create: () => Effect.succeed({ message: prepared.message, mode: "full" }),
-            observe: (_create, frame) => Effect.succeed({ type: "frame", frame }),
-        };
-        const exchange = {
-            id: request.id ?? "request",
-            connect: { url: prepared.url, headers: prepared.headers },
-            fallback: () => Stream.fail(transportError("WebSocket JSON transport does not provide HTTP fallback", {
-                url: prepared.url,
-                operation: "request",
-                code: "websocket",
-                phase: "fallback",
-                delivery: "not-sent",
-            })),
-            driver,
-        };
-        return webSocket.execute(exchange);
-    },
-});
-export const jsonTransport = {
-    id: "websocket-json",
-    with: json,
-};
 export const WebSocketTransport = {
-    json,
-    jsonTransport,
     direct,
     makeDirect,
     open,

package/dist/schema/errors.d.ts

@@ -10,7 +10,7 @@ declare const HttpContext_base: Schema.Class<HttpContext, Schema.Struct<{
 export declare class HttpContext extends HttpContext_base {
 }
 declare const HttpRateLimitDetails_base: Schema.Class<HttpRateLimitDetails, Schema.Struct<{
-    readonly retryAfterMs: Schema.optional<Schema.Number>;
+    readonly retryAfterMs: Schema.optional<Schema.Int>;
     readonly limit: Schema.optional<Schema.$Record<Schema.String, Schema.String>>;
     readonly remaining: Schema.optional<Schema.$Record<Schema.String, Schema.String>>;
     readonly reset: Schema.optional<Schema.$Record<Schema.String, Schema.String>>;
@@ -80,16 +80,17 @@ declare const RateLimitError_base: Schema.Class<RateLimitError, Schema.TaggedStr
     readonly body: Schema.optional<Schema.String>;
     readonly http: Schema.optional<typeof HttpContext>;
     readonly cause: Schema.optional<Schema.Defect>;
-    readonly retryAfterMs: Schema.optional<Schema.Number>;
+    readonly retryAfterMs: Schema.optional<Schema.Int>;
     readonly rateLimit: Schema.optional<typeof HttpRateLimitDetails>;
 }>, import("effect/Cause").YieldableError>;
 export declare class RateLimitError extends RateLimitError_base {
 }
 declare const QuotaExceededError_base: Schema.Class<QuotaExceededError, Schema.TaggedStruct<"QuotaExceeded", {
-    message: Schema.String;
-    body: Schema.optional<Schema.String>;
-    http: Schema.optional<typeof HttpContext>;
-    cause: Schema.optional<Schema.Defect>;
+    readonly message: Schema.String;
+    readonly body: Schema.optional<Schema.String>;
+    readonly http: Schema.optional<typeof HttpContext>;
+    readonly cause: Schema.optional<Schema.Defect>;
+    readonly retryAfterMs: Schema.optional<Schema.Int>;
 }>, import("effect/Cause").YieldableError>;
 export declare class QuotaExceededError extends QuotaExceededError_base {
 }
@@ -106,7 +107,7 @@ declare const ProviderInternalError_base: Schema.Class<ProviderInternalError, Sc
     readonly body: Schema.optional<Schema.String>;
     readonly http: Schema.optional<typeof HttpContext>;
     readonly cause: Schema.optional<Schema.Defect>;
-    readonly retryAfterMs: Schema.optional<Schema.Number>;
+    readonly retryAfterMs: Schema.optional<Schema.Int>;
 }>, import("effect/Cause").YieldableError>;
 export declare class ProviderInternalError extends ProviderInternalError_base {
 }

package/dist/schema/errors.js

@@ -1,4 +1,5 @@
 import { Schema } from "effect";
+import { NonNegativeInt } from "@opencode/schema";
 import { Tool } from "@opencode/schema/tool";
 import { ModelID, ProviderID, RouteID } from "./ids.js";
 export const ProviderFailureClassification = Schema.Literals(["context-overflow", "payload-too-large"]);
@@ -9,7 +10,7 @@ export class HttpContext extends Schema.Class("AI.HttpContext")({
 }) {
 }
 export class HttpRateLimitDetails extends Schema.Class("AI.HttpRateLimitDetails")({
-    retryAfterMs: Schema.optional(Schema.Number),
+    retryAfterMs: Schema.optional(NonNegativeInt),
     limit: Schema.optional(Schema.Record(Schema.String, Schema.String)),
     remaining: Schema.optional(Schema.Record(Schema.String, Schema.String)),
     reset: Schema.optional(Schema.Record(Schema.String, Schema.String)),
@@ -63,17 +64,20 @@ export class AuthenticationError extends Schema.TaggedError("AI.Error.Authentica
 }
 export class RateLimitError extends Schema.TaggedError("AI.Error.RateLimit")("RateLimit", {
     ...ReasonFields,
-    retryAfterMs: Schema.optional(Schema.Number),
+    retryAfterMs: Schema.optional(NonNegativeInt),
     rateLimit: Schema.optional(HttpRateLimitDetails),
 }) {
 }
-export class QuotaExceededError extends Schema.TaggedError("AI.Error.QuotaExceeded")("QuotaExceeded", ReasonFields) {
+export class QuotaExceededError extends Schema.TaggedError("AI.Error.QuotaExceeded")("QuotaExceeded", {
+    ...ReasonFields,
+    retryAfterMs: Schema.optional(NonNegativeInt),
+}) {
 }
 export class ContentPolicyError extends Schema.TaggedError("AI.Error.ContentPolicy")("ContentPolicy", ReasonFields) {
 }
 export class ProviderInternalError extends Schema.TaggedError("AI.Error.ProviderInternal")("ProviderInternal", {
     ...ReasonFields,
-    retryAfterMs: Schema.optional(Schema.Number),
+    retryAfterMs: Schema.optional(NonNegativeInt),
 }) {
 }
 export const TransportType = Schema.Literals(["http", "websocket"]);

package/package.json

@@ -1,6 +1,6 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
-  "version": "2.1.0",
+  "version": "2.1.2",
   "name": "@opencode/ai",
   "type": "module",
   "license": "MIT",
@@ -34,7 +34,7 @@
   "devDependencies": {
     "@clack/prompts": "1.0.0-alpha.1",
     "@effect/platform-node": "4.0.1",
-    "@opencode/http-recorder": "2.1.0",
+    "@opencode/http-recorder": "2.1.2",
     "@tsconfig/bun": "1.0.9",
     "@types/bun": "1.4.0",
     "@typescript/native": "npm:typescript@7.0.2",
@@ -44,7 +44,7 @@
     "@aws-sdk/credential-providers": "3.1057.0",
     "@smithy/eventstream-codec": "4.2.14",
     "@smithy/util-utf8": "4.2.2",
-    "@opencode/schema": "2.1.0",
+    "@opencode/schema": "2.1.2",
     "aws4fetch": "1.0.20",
     "effect": "4.0.1",
     "google-auth-library": "10.5.0"