@opencode/ai 0.0.0-dev-20415 → 0.0.0-dev-20416

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

@@ -2,6 +2,7 @@ import { Effect } from "effect";
 import { Headers, HttpClientRequest } from "effect/unstable/http";
 import { Framing } from "../framing.js";
 import type { HttpMiddleware, Transport, TransportPrepareInput } from "./index.js";
+import { AIError } from "../../schema/index.js";
 export type JsonRequestInput<Body> = TransportPrepareInput<Body>;
 export interface JsonRequestParts<Body = unknown> {
     readonly url: string;
@@ -19,7 +20,7 @@ export declare const jsonRequestParts: <Body>(input: JsonRequestInput<Body>) =>
     jsonBody: Record<string, unknown> | Body;
     bodyText: string;
     headers: Headers.Headers;
-}, import("../../schema/errors.js").AIError, never>;
+}, AIError, never>;
 export interface HttpJsonInput<_Body, Frame> {
     readonly framing: Framing.Definition<Frame>;
 }

package/dist/route/transport/http.js

@@ -1,10 +1,10 @@
-import { Effect } from "effect";
+import { Clock, Duration, Effect, Stream } from "effect";
 import { Headers, HttpClientRequest } from "effect/unstable/http";
 import { Auth } from "../auth.js";
 import { render as renderEndpoint } from "../endpoint.js";
 import { Framing } from "../framing.js";
 import * as ProviderShared from "../../protocols/shared.js";
-import { mergeJsonRecords } from "../../schema/index.js";
+import { AIError, DEFAULT_HTTP_TIMEOUT_MS, mergeJsonRecords, TransportError, } from "../../schema/index.js";
 import { RequestExecutor } from "../executor.js";
 const applyQuery = (url, query) => {
     if (!query)
@@ -53,15 +53,37 @@ export const httpJson = (input) => ({
             middleware: prepareInput.middleware,
         };
     }),
-    execute: (prepared, _request, runtime) => Effect.gen(function* () {
-        const response = yield* runtime.http.execute(prepared.request, prepared.middleware);
+    execute: (prepared, request, runtime) => Effect.gen(function* () {
+        const timeout = (operation, message, http) => new AIError({
+            reason: new TransportError({
+                message,
+                transport: "http",
+                operation,
+                code: "Timeout",
+                url: prepared.request.url,
+                http,
+            }),
+        });
+        const started = yield* Clock.currentTimeMillis;
+        // Unlike the header and chunk limits, the whole-request budget has no default.
+        const total = request.http?.timeout ? Duration.millis(request.http.timeout) : Duration.infinity;
+        const response = yield* runtime.http.execute(prepared.request, prepared.middleware).pipe(Effect.timeoutOrElse({
+            duration: Duration.min(timeoutDuration(request.http?.headerTimeout), total),
+            orElse: () => timeout("request", "Timed out waiting for response headers"),
+        }));
+        const http = RequestExecutor.responseHttp(response);
+        const remaining = Duration.subtract(total, Duration.millis((yield* Clock.currentTimeMillis) - started));
         return {
-            frames: prepared.framing.frame(RequestExecutor.responseStream(response)),
-            http: RequestExecutor.responseHttp(response),
+            frames: prepared.framing.frame(RequestExecutor.responseStream(response).pipe(Stream.timeoutOrElse({
+                duration: timeoutDuration(request.http?.chunkTimeout),
+                orElse: () => Stream.fail(timeout("read", "Timed out waiting for response data", http)),
+            }), Stream.interruptWhen(Effect.sleep(remaining).pipe(Effect.andThen(Effect.fail(timeout("read", "Timed out waiting for the response to complete", http))))))),
+            http,
             body: prepared.framing.body,
         };
     }),
 });
+const timeoutDuration = (value) => value === false ? Duration.infinity : Duration.millis(value ?? DEFAULT_HTTP_TIMEOUT_MS);
 export const sseJson = {
     id: "http-json/sse",
     with: () => httpJson({ framing: Framing.sse }),

package/dist/schema/options.d.ts

@@ -9,10 +9,21 @@ export type ProviderOptions = Schema.Schema.Type<typeof ProviderOptions>;
 export declare const ProviderMetadata: Schema.$Record<Schema.String, Schema.$Record<Schema.String, Schema.Unknown>>;
 export type ProviderMetadata = Schema.Schema.Type<typeof ProviderMetadata>;
 export declare const mergeProviderOptions: (...items: ReadonlyArray<ProviderOptions | undefined>) => ProviderOptions | undefined;
+/** Milliseconds for an HTTP timeout, or `false` to disable it. */
+export declare const HttpTimeout: Schema.Union<readonly [Schema.Number, Schema.Literal<false>]>;
+export type HttpTimeout = Schema.Schema.Type<typeof HttpTimeout>;
+/** Applied to `headerTimeout` and `chunkTimeout` when a request leaves them unset. */
+export declare const DEFAULT_HTTP_TIMEOUT_MS = 300000;
 declare const HttpOptions_base: Schema.Class<HttpOptions, Schema.Struct<{
     readonly body: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
     readonly headers: Schema.optional<Schema.$Record<Schema.String, Schema.String>>;
     readonly query: Schema.optional<Schema.$Record<Schema.String, Schema.String>>;
+    /** Time allowed for the whole request, from send until the response completes. Unbounded when unset. */
+    readonly timeout: Schema.optional<Schema.Union<readonly [Schema.Number, Schema.Literal<false>]>>;
+    /** Time allowed for response headers to arrive. */
+    readonly headerTimeout: Schema.optional<Schema.Union<readonly [Schema.Number, Schema.Literal<false>]>>;
+    /** Time allowed between streamed response chunks once headers have arrived. */
+    readonly chunkTimeout: Schema.optional<Schema.Union<readonly [Schema.Number, Schema.Literal<false>]>>;
 }>, {}>;
 export declare class HttpOptions extends HttpOptions_base {
 }

package/dist/schema/options.js

@@ -32,10 +32,20 @@ export const ProviderMetadata = Schema.Record(Schema.String, Schema.Record(Schem
     identifier: "LLM.ProviderMetadata",
 });
 export const mergeProviderOptions = (...items) => mergeJsonRecords(...items);
+/** Milliseconds for an HTTP timeout, or `false` to disable it. */
+export const HttpTimeout = Schema.Union([Schema.Number.check(Schema.isGreaterThan(0)), Schema.Literal(false)]);
+/** Applied to `headerTimeout` and `chunkTimeout` when a request leaves them unset. */
+export const DEFAULT_HTTP_TIMEOUT_MS = 300_000;
 export class HttpOptions extends Schema.Class("AI.HttpOptions")({
     body: Schema.optional(JsonSchema),
     headers: Schema.optional(Schema.Record(Schema.String, Schema.String)),
     query: Schema.optional(Schema.Record(Schema.String, Schema.String)),
+    /** Time allowed for the whole request, from send until the response completes. Unbounded when unset. */
+    timeout: Schema.optional(HttpTimeout),
+    /** Time allowed for response headers to arrive. */
+    headerTimeout: Schema.optional(HttpTimeout),
+    /** Time allowed between streamed response chunks once headers have arrived. */
+    chunkTimeout: Schema.optional(HttpTimeout),
 }) {
 }
 (function (HttpOptions) {
@@ -50,9 +60,12 @@ export const mergeHttpOptions = (...items) => {
     const body = mergeJsonRecords(...items.map((item) => item?.body));
     const headers = mergeStringRecords(...items.map((item) => item?.headers));
     const query = mergeStringRecords(...items.map((item) => item?.query));
-    if (!body && !headers && !query)
+    const timeout = items.findLast((item) => item?.timeout !== undefined)?.timeout;
+    const headerTimeout = items.findLast((item) => item?.headerTimeout !== undefined)?.headerTimeout;
+    const chunkTimeout = items.findLast((item) => item?.chunkTimeout !== undefined)?.chunkTimeout;
+    if (!body && !headers && !query && timeout === undefined && headerTimeout === undefined && chunkTimeout === undefined)
         return undefined;
-    return new HttpOptions({ body, headers, query });
+    return new HttpOptions({ body, headers, query, timeout, headerTimeout, chunkTimeout });
 };
 export class GenerationOptions extends Schema.Class("LLM.GenerationOptions")({
     maxTokens: Schema.optional(Schema.Number),

package/package.json

@@ -1,6 +1,6 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
-  "version": "0.0.0-dev-20415",
+  "version": "0.0.0-dev-20416",
   "name": "@opencode/ai",
   "type": "module",
   "license": "MIT",
@@ -34,7 +34,7 @@
   "devDependencies": {
     "@clack/prompts": "1.0.0-alpha.1",
     "@effect/platform-node": "4.0.0-rc.112",
-    "@opencode/http-recorder": "0.0.0-dev-20415",
+    "@opencode/http-recorder": "0.0.0-dev-20416",
     "@tsconfig/bun": "1.0.9",
     "@types/bun": "1.4.0",
     "@typescript/native-preview": "7.0.0-dev.20251207.1",
@@ -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": "0.0.0-dev-20415",
+    "@opencode/schema": "0.0.0-dev-20416",
     "aws4fetch": "1.0.20",
     "effect": "4.0.0-rc.112",
     "google-auth-library": "10.5.0"