@opencode/ai 2.1.1 → 2.1.3

package/dist/route/client.d.ts

@@ -214,222 +214,6 @@ export declare function stream(request: LLMRequest, options?: StreamOptions): St
 export declare function generate(request: LLMRequest, options?: StreamOptions): Effect.Effect<LLMResponse, AIError, Service>;
 export declare function compact(request: CheckpointRequest, options: TriggerCompactOptions): Effect.Effect<CompactionCheckpointResponse, AIError, Service>;
 export declare function compact(request: CompactionRequest, options?: EndpointCompactOptions): Effect.Effect<CompactionResponse, AIError, Service>;
-export declare const streamRequest: (request: LLMRequest, options?: StreamOptions) => Stream.Stream<{
-    readonly type: "step-start";
-    readonly index: number;
-} | {
-    readonly type: "text-start";
-    readonly id: string;
-    readonly providerMetadata?: {
-        readonly [x: string]: {
-            readonly [x: string]: unknown;
-        };
-    } | undefined;
-} | {
-    readonly type: "text-delta";
-    readonly id: string;
-    readonly text: string;
-    readonly providerMetadata?: {
-        readonly [x: string]: {
-            readonly [x: string]: unknown;
-        };
-    } | undefined;
-} | {
-    readonly type: "text-end";
-    readonly id: string;
-    readonly text?: string | undefined;
-    readonly providerMetadata?: {
-        readonly [x: string]: {
-            readonly [x: string]: unknown;
-        };
-    } | undefined;
-} | {
-    readonly type: "reasoning-start";
-    readonly id: string;
-    readonly providerMetadata?: {
-        readonly [x: string]: {
-            readonly [x: string]: unknown;
-        };
-    } | undefined;
-} | {
-    readonly type: "reasoning-delta";
-    readonly id: string;
-    readonly text: string;
-    readonly providerMetadata?: {
-        readonly [x: string]: {
-            readonly [x: string]: unknown;
-        };
-    } | undefined;
-} | {
-    readonly type: "reasoning-end";
-    readonly id: string;
-    readonly text?: string | undefined;
-    readonly providerMetadata?: {
-        readonly [x: string]: {
-            readonly [x: string]: unknown;
-        };
-    } | undefined;
-} | {
-    readonly type: "tool-input-start";
-    readonly id: string;
-    readonly name: string;
-    readonly namespace?: string | undefined;
-    readonly providerExecuted?: boolean | undefined;
-    readonly providerMetadata?: {
-        readonly [x: string]: {
-            readonly [x: string]: unknown;
-        };
-    } | undefined;
-} | {
-    readonly type: "tool-input-delta";
-    readonly id: string;
-    readonly name: string;
-    readonly namespace?: string | undefined;
-    readonly text: string;
-    readonly input?: unknown;
-} | {
-    readonly type: "tool-input-end";
-    readonly id: string;
-    readonly name: string;
-    readonly namespace?: string | undefined;
-    readonly providerMetadata?: {
-        readonly [x: string]: {
-            readonly [x: string]: unknown;
-        };
-    } | undefined;
-} | {
-    readonly type: "tool-input-error";
-    readonly id: string;
-    readonly name: string;
-    readonly namespace?: string | undefined;
-    readonly raw: string;
-} | {
-    readonly type: "tool-call";
-    readonly id: string;
-    readonly name: string;
-    readonly namespace?: string | undefined;
-    readonly input: unknown;
-    readonly providerExecuted?: boolean | undefined;
-    readonly providerMetadata?: {
-        readonly [x: string]: {
-            readonly [x: string]: unknown;
-        };
-    } | undefined;
-} | {
-    readonly type: "tool-result";
-    readonly id: string;
-    readonly name: string;
-    readonly namespace?: string | undefined;
-    readonly result: {
-        readonly type: "json";
-        readonly value: unknown;
-    } | {
-        readonly type: "text";
-        readonly value: unknown;
-    } | {
-        readonly type: "error";
-        readonly value: unknown;
-    } | {
-        readonly type: "content";
-        readonly value: readonly ({
-            readonly type: "text";
-            readonly text: string;
-        } | {
-            readonly type: "file";
-            readonly uri: string;
-            readonly mime: string;
-            readonly name?: string | undefined;
-        })[];
-    };
-    readonly output?: {
-        readonly structured: unknown;
-        readonly content: readonly ({
-            readonly type: "text";
-            readonly text: string;
-        } | {
-            readonly type: "file";
-            readonly uri: string;
-            readonly mime: string;
-            readonly name?: string | undefined;
-        })[];
-    } | undefined;
-    readonly providerExecuted?: boolean | undefined;
-    readonly providerMetadata?: {
-        readonly [x: string]: {
-            readonly [x: string]: unknown;
-        };
-    } | undefined;
-} | {
-    readonly type: "tool-error";
-    readonly id: string;
-    readonly name: string;
-    readonly namespace?: string | undefined;
-    readonly message: string;
-    readonly error?: unknown;
-    readonly providerMetadata?: {
-        readonly [x: string]: {
-            readonly [x: string]: unknown;
-        };
-    } | undefined;
-} | {
-    readonly type: "step-finish";
-    readonly index: number;
-    readonly reason: {
-        readonly normalized: "content-filter" | "error" | "length" | "stop" | "tool-calls" | "unknown";
-        readonly raw?: string | undefined;
-        readonly category?: string | undefined;
-        readonly explanation?: string | undefined;
-    };
-    readonly usage?: import("../schema/events.js").Usage | undefined;
-    readonly providerMetadata?: {
-        readonly [x: string]: {
-            readonly [x: string]: unknown;
-        };
-    } | undefined;
-} | {
-    readonly type: "finish";
-    readonly reason: {
-        readonly normalized: "content-filter" | "error" | "length" | "stop" | "tool-calls" | "unknown";
-        readonly raw?: string | undefined;
-        readonly category?: string | undefined;
-        readonly explanation?: string | undefined;
-    };
-    readonly usage?: import("../schema/events.js").Usage | undefined;
-    readonly providerMetadata?: {
-        readonly [x: string]: {
-            readonly [x: string]: unknown;
-        };
-    } | undefined;
-} | {
-    readonly type: "media";
-    readonly media: import("../media.js").Asset;
-    readonly providerMetadata?: {
-        readonly [x: string]: {
-            readonly [x: string]: unknown;
-        };
-    } | undefined;
-} | {
-    readonly type: "provider-error";
-    readonly message: string;
-    readonly classification?: "context-overflow" | "payload-too-large" | undefined;
-    readonly providerMetadata?: {
-        readonly [x: string]: {
-            readonly [x: string]: unknown;
-        };
-    } | undefined;
-} | ({
-    readonly type: "compaction";
-    readonly provider: string & import("effect/Brand").Brand<"AI.ProviderID">;
-    readonly id?: string | undefined;
-    readonly encrypted?: string | undefined;
-    readonly text?: string | null | undefined;
-} & ({
-    readonly encrypted: string;
-    readonly text?: never;
-} | {
-    readonly text: string | null;
-    readonly encrypted?: never;
-})), AIError, LLMClientService>;
 export declare const layer: Layer.Layer<Service, never, RequestExecutor.Service>;
 export declare const Route: {
     readonly make: typeof make;

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)
@@ -272,9 +271,6 @@ export function compact(request, options) {
         return yield* unsupportedCompaction(request, options?.mechanism);
     });
 }
-export const streamRequest = (request, options) => Stream.unwrap(Effect.gen(function* () {
-    return (yield* Service).stream(request, options);
-}));
 export const layer = Layer.effect(Service, Effect.gen(function* () {
     const executor = yield* RequestExecutor.Service;
     const stream = streamRequestWith({ http: executor });

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/http.js

@@ -6,13 +6,6 @@ import { Framing } from "../framing.js";
 import * as ProviderShared from "../../protocols/shared.js";
 import { AIError, DEFAULT_CHUNK_TIMEOUT_MS, DEFAULT_HTTP_TIMEOUT_MS, mergeJsonRecords, TransportError, } from "../../schema/index.js";
 import { RequestExecutor } from "../executor.js";
-const applyQuery = (url, query) => {
-    if (!query)
-        return url;
-    const next = new URL(url);
-    Object.entries(query).forEach(([key, value]) => next.searchParams.set(key, value));
-    return next.toString();
-};
 const bodyWithOverlay = (body, request, encodeBody) => Effect.gen(function* () {
     if (request.http?.body === undefined)
         return { jsonBody: body, bodyText: encodeBody(body) };
@@ -23,7 +16,11 @@ const bodyWithOverlay = (body, request, encodeBody) => Effect.gen(function* () {
     return yield* ProviderShared.invalidRequest("http.body can only overlay JSON object request bodies");
 });
 export const jsonRequestParts = (input) => Effect.gen(function* () {
-    const url = applyQuery(renderEndpoint(input.endpoint, { request: input.request, body: input.body }).toString(), input.request.http?.query);
+    const endpoint = renderEndpoint(input.endpoint, { request: input.request, body: input.body });
+    if (input.request.http?.query) {
+        Object.entries(input.request.http.query).forEach(([key, value]) => endpoint.searchParams.set(key, value));
+    }
+    const url = endpoint.toString();
     const body = yield* bodyWithOverlay(input.body, input.request, input.encodeBody);
     const headers = yield* Auth.toEffect(input.auth)({
         request: input.request,

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 {
 }
@@ -152,7 +153,7 @@ declare const TimeoutError_base: Schema.Class<TimeoutError, Schema.TaggedStruct<
     readonly body: Schema.optional<Schema.String>;
     readonly http: Schema.optional<typeof HttpContext>;
     readonly cause: Schema.optional<Schema.Defect>;
-    readonly timeoutMs: Schema.optional<Schema.Number>;
+    readonly timeoutMs: Schema.optional<Schema.Int>;
 }>, import("effect/Cause").YieldableError>;
 /** A caller-supplied deadline elapsed, such as `Generation.await` polling past its `Poll.timeout`. */
 export declare class TimeoutError extends TimeoutError_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"]);
@@ -100,7 +104,7 @@ export class UnknownProviderError extends Schema.TaggedError("AI.Error.UnknownPr
 /** A caller-supplied deadline elapsed, such as `Generation.await` polling past its `Poll.timeout`. */
 export class TimeoutError extends Schema.TaggedError("AI.Error.Timeout")("Timeout", {
     ...ReasonFields,
-    timeoutMs: Schema.optional(Schema.Number),
+    timeoutMs: Schema.optional(NonNegativeInt),
 }) {
 }
 export const AIErrorReason = Schema.Union([

package/dist/schema/messages.js

@@ -1,9 +1,10 @@
-import { Schema } from "effect";
+import { Option, Schema } from "effect";
 import { withStatics } from "@opencode/schema/schema";
 import { Tool } from "@opencode/schema/tool";
 import { CacheHint, CachePolicy, GenerationOptions, HttpOptions, JsonSchema, LanguageModelSchema, ProviderMetadata, ProviderOptions, ReasoningEffort, } from "./options.js";
 import { ProviderID } from "./ids.js";
 import { Media } from "../media.js";
+import { Json } from "../utils/json.js";
 export const MessageRole = Schema.Literals(["system", "user", "assistant", "tool"]);
 const systemPartSchema = Schema.Struct({
     type: Schema.Literal("text"),
@@ -89,15 +90,11 @@ export const ToolOutput = withStatics(Schema.Struct({
         return { type: "content", value: output.content };
     },
 });
+const encodeJsonOption = Schema.encodeUnknownOption(Json);
 const toolResultText = (value) => {
     if (typeof value === "string")
         return value;
-    try {
-        return JSON.stringify(value) ?? String(value);
-    }
-    catch {
-        return String(value);
-    }
+    return Option.getOrElse(encodeJsonOption(value), () => String(value));
 };
 export const ToolCallPart = withStatics(Schema.Struct({
     type: Schema.Literal("tool-call"),

package/dist/speech-client.d.ts

@@ -60,7 +60,9 @@ export declare const SpeechClient: {
         } | undefined;
     } | import("./generation.js").Observation, import("./index.js").AIError, SpeechClientService>;
     readonly start: (request: SpeechRequestFor) => import("effect/Effect").Effect<import("./generation.js").Generation<SpeechResponse>, import("./index.js").AIError, SpeechClientService>;
-    readonly resume: (model: import("./speech.js").SpeechModel<import("./media-model.js").MediaModel.Options>, token: unknown) => import("effect/Effect").Effect<import("./generation.js").Generation<SpeechResponse>, import("./index.js").AIError, SpeechClientService>;
+    readonly resume: (model: import("./speech.js").SpeechModel<{
+        readonly [x: string]: unknown;
+    }>, token: unknown) => import("effect/Effect").Effect<import("./generation.js").Generation<SpeechResponse>, import("./index.js").AIError, SpeechClientService>;
     readonly Service: typeof SpeechClientService;
 };
 export {};