@opencode/ai 2.0.21 → 2.0.23

package/dist/route/framing.js

@@ -14,32 +14,32 @@ export const sseFraming = (bytes, events, includeDone = false) => bytes.pipe(Str
     return {
         output,
         parser: makeParser((event) => {
-            if (event._tag === "Event")
-                output.push(event);
+            if (event._tag === "Event" &&
+                (events === undefined || events.has(event.event)) &&
+                event.data.length > 0 &&
+                // Some OpenAI-compatible proxies serialize an empty flush as a bare
+                // `data: null`, between events or after `[DONE]`. No protocol has a
+                // null event, so it carries nothing and must not abort the stream.
+                event.data !== "null" &&
+                // Vertex AI partner models (e.g. `xai/grok-4.6`) send their SSE
+                // keepalive comment as `data: : keepalive` while reasoning.
+                event.data !== ": keepalive" &&
+                (event.data !== "[DONE]" || includeDone || (events !== undefined && event.event !== "message")))
+                output.push(event.data);
         }),
     };
-}, (state, chunk) => Effect.gen(function* () {
+}, (state, chunk) => {
     const error = state.parser.feed(chunk);
-    if (error)
-        return yield* new AIError({
-            reason: new InvalidProviderOutputError({
-                route: "sse",
-                message: error.message,
-                body: chunk,
-                cause: error,
-            }),
-        });
-    return [state, state.output.splice(0)];
-})), Stream.filter((event) => (events === undefined || events.has(event.event)) &&
-    event.data.length > 0 &&
-    // Some OpenAI-compatible proxies serialize an empty flush as a bare
-    // `data: null`, between events or after `[DONE]`. No protocol has a
-    // null event, so it carries nothing and must not abort the stream.
-    event.data !== "null" &&
-    // Vertex AI partner models (e.g. `xai/grok-4.6`) send their SSE
-    // keepalive comment as `data: : keepalive` while reasoning.
-    event.data !== ": keepalive" &&
-    (event.data !== "[DONE]" || includeDone || (events !== undefined && event.event !== "message"))), Stream.map((event) => event.data));
+    if (!error)
+        return Effect.succeed([state, state.output.splice(0)]);
+    const reason = new InvalidProviderOutputError({
+        route: "sse",
+        message: error.message,
+        body: chunk,
+        cause: error,
+    });
+    return Effect.fail(new AIError({ reason }));
+}));
 /** Server-Sent Events framing. Used by every JSON-streaming HTTP provider. */
 export const sse = { id: "sse", frame: sseFraming };
 /** Server-Sent Events framing that retains the conventional `[DONE]` sentinel. */

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 }),