@opencode-ai/ai 0.0.0-next-17274 → 0.0.0-next-17288

package/dist/protocols/anthropic-messages.js

@@ -448,7 +448,11 @@ const lowerMessages = Effect.fn("AnthropicMessages.lowerMessages")(function* (re
                 cache_control: cacheControl(breakpoints, part.cache),
             });
         }
-        messages.push({ role: "user", content });
+        const previous = messages.at(-1);
+        if (previous?.role === "user" && previous.content.every((block) => block.type === "tool_result"))
+            messages[messages.length - 1] = { role: "user", content: [...previous.content, ...content] };
+        else
+            messages.push({ role: "user", content });
     }
     return messages;
 });

package/dist/route/executor.d.ts

@@ -1,4 +1,4 @@
-import { Context, Effect, Layer } from "effect";
+import { Context, Effect, Layer, Stream } from "effect";
 import { HttpClient, HttpClientRequest, HttpClientResponse } from "effect/unstable/http";
 import { AIError, TransportReason } from "../schema/index.js";
 export interface Interface {
@@ -17,6 +17,7 @@ export declare const classifyHttpFailure: (input: {
     readonly responseHeaders?: Record<string, string> | undefined;
     readonly responseBody?: string | undefined;
 }) => import("../schema/errors.js").InvalidRequestReason | import("../schema/errors.js").NoRouteReason | import("../schema/errors.js").AuthenticationReason | import("../schema/errors.js").RateLimitReason | import("../schema/errors.js").QuotaExceededReason | import("../schema/errors.js").ContentPolicyReason | import("../schema/errors.js").ProviderInternalReason | TransportReason | import("../schema/errors.js").InvalidProviderOutputReason | import("../schema/errors.js").UnknownProviderReason;
+export declare const stream: (executor: Interface, request: HttpClientRequest.HttpClientRequest, middleware?: HttpMiddleware) => Stream.Stream<Uint8Array, AIError>;
 export declare const layer: Layer.Layer<Service, never, HttpClient.HttpClient>;
 export declare const fetchLayer: Layer.Layer<Service, never, never>;
 export * as RequestExecutor from "./executor.js";

package/dist/route/executor.js

@@ -1,4 +1,4 @@
-import { Cause, Context, Effect, Layer, Option, Schema } from "effect";
+import { Cause, Context, Effect, Layer, Option, Schema, Stream } from "effect";
 import { FetchHttpClient, Headers, HttpClient, HttpClientError, HttpClientRequest, HttpClientResponse, } from "effect/unstable/http";
 import { HttpContext, HttpRateLimitDetails, HttpRequestDetails, HttpResponseDetails, AIError, TransportReason, } from "../schema/index.js";
 import { classifyProviderFailure } from "../provider-error.js";
@@ -215,48 +215,74 @@ export const classifyHttpFailure = (input) => {
         }),
     });
 };
-const toHttpError = (redactedNames) => (error) => {
-    const transportError = (input) => new AIError({
+const NativeTransportFailure = Schema.Struct({
+    message: Schema.String,
+    code: Schema.optionalKey(Schema.String),
+    cause: Schema.optionalKey(Schema.Unknown),
+});
+const decodeNativeTransportFailure = Schema.decodeUnknownOption(NativeTransportFailure);
+const nativeTransportFailure = (error) => {
+    const failure = Option.getOrUndefined(decodeNativeTransportFailure(error));
+    if (!failure)
+        return undefined;
+    if (failure.code !== undefined)
+        return failure;
+    const cause = Option.getOrUndefined(decodeNativeTransportFailure(failure.cause));
+    if (cause?.code !== undefined)
+        return cause;
+    return failure;
+};
+const httpError = (input) => {
+    const request = HttpClientError.isHttpClientError(input.error) ? input.error.request : input.request;
+    const transportError = (failure) => new AIError({
         module: "RequestExecutor",
-        method: "execute",
+        method: input.operation,
         reason: new TransportReason({
-            message: input.message,
-            kind: input.kind,
-            url: input.request ? redactUrl(input.request.url) : undefined,
-            http: input.request ? new HttpContext({ request: requestDetails(input.request, redactedNames) }) : undefined,
+            message: failure.message,
+            transport: "http",
+            operation: input.operation,
+            code: failure.code,
+            url: redactUrl(request.url),
+            http: new HttpContext({ request: requestDetails(request, input.redactedNames) }),
         }),
     });
-    if (Cause.isTimeoutError(error)) {
-        return transportError({ message: error.message, kind: "Timeout" });
-    }
-    if (!HttpClientError.isHttpClientError(error)) {
-        return transportError({ message: error instanceof Error ? error.message : "HTTP transport failed" });
-    }
-    const request = "request" in error ? error.request : undefined;
-    if (error.reason._tag === "TransportError") {
+    const source = HttpClientError.isHttpClientError(input.error) && "cause" in input.error.reason
+        ? input.error.reason.cause
+        : input.error;
+    const native = nativeTransportFailure(source);
+    const code = native?.code;
+    const raw = native?.message ?? (input.error instanceof Error ? input.error.message : undefined);
+    const detail = raw ? redactBody(raw, secretValues(request)) : undefined;
+    const message = code && detail && !detail.includes(code) ? `${code}: ${detail}` : detail;
+    if (Cause.isTimeoutError(input.error) || Cause.isTimeoutError(source))
+        return transportError({ message: message ?? "HTTP transport timed out", code: code ?? "Timeout" });
+    if (!HttpClientError.isHttpClientError(input.error))
+        return transportError({ message: message ?? "HTTP transport failed", code });
+    if (input.error.reason._tag === "TransportError") {
         return transportError({
-            message: error.reason.description ?? "HTTP transport failed",
-            kind: error.reason._tag,
-            request,
+            message: message ?? input.error.reason.description ?? "HTTP transport failed",
+            code: code ?? input.error.reason._tag,
         });
     }
     return transportError({
-        message: `HTTP transport failed: ${error.reason._tag}`,
-        kind: error.reason._tag,
-        request,
+        message: message ?? `HTTP transport failed: ${input.error.reason._tag}`,
+        code: code ?? input.error.reason._tag,
     });
 };
+export const stream = (executor, request, middleware) => Stream.unwrap(Effect.gen(function* () {
+    const redactedNames = yield* Headers.CurrentRedactedNames;
+    const response = yield* executor.execute(request, middleware);
+    return response.stream.pipe(Stream.mapError((error) => httpError({ error, request: response.request, operation: "read", redactedNames })));
+}));
 export const layer = Layer.effect(Service, Effect.gen(function* () {
     const http = yield* HttpClient.HttpClient;
     const executeOnce = (request, middleware) => Effect.gen(function* () {
         const redactedNames = yield* Headers.CurrentRedactedNames;
         if (!middleware)
-            return yield* http
-                .execute(request)
-                .pipe(Effect.mapError(toHttpError(redactedNames)), Effect.flatMap(statusError(request, redactedNames)));
+            return yield* http.execute(request).pipe(Effect.mapError((error) => httpError({ error, request, operation: "request", 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)));
+            .pipe(Effect.mapError((cause) => (cause instanceof Error ? cause : new Error(String(cause)))))).pipe(Effect.mapError((error) => httpError({ error, request, operation: "request", redactedNames })));
         return yield* statusError(response.request, redactedNames)(response);
     });
     return Service.of({

package/dist/route/transport/http.js

@@ -1,10 +1,11 @@
-import { Effect, Stream } from "effect";
+import { Effect } 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 { RequestExecutor } from "../executor.js";
 const applyQuery = (url, query) => {
     if (!query)
         return url;
@@ -52,9 +53,7 @@ export const httpJson = (input) => ({
             middleware: prepareInput.middleware,
         };
     }),
-    frames: (prepared, request, runtime) => Stream.unwrap(runtime.http
-        .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)))))))),
+    frames: (prepared, _request, runtime) => prepared.framing.frame(RequestExecutor.stream(runtime.http, prepared.request, prepared.middleware)),
 });
 export const sseJson = {
     id: "http-json/sse",

package/dist/route/transport/websocket.js

@@ -4,10 +4,16 @@ import { AIError, TransportReason } from "../../schema/index.js";
 import * as HttpTransport from "./http.js";
 export class Service extends Context.Service()("@opencode/AI/WebSocketExecutor") {
 }
-const transportError = (method, message, input = {}) => new AIError({
+const transportError = (method, message, input) => new AIError({
     module: "WebSocketExecutor",
     method,
-    reason: new TransportReason({ message, url: input.url, kind: input.kind }),
+    reason: new TransportReason({
+        message,
+        transport: "websocket",
+        operation: input.operation,
+        url: input.url,
+        code: input.code,
+    }),
 });
 const eventMessage = (event) => {
     if ("message" in event && typeof event.message === "string")
@@ -29,7 +35,8 @@ const waitOpen = (ws, input) => {
     if (ws.readyState === globalThis.WebSocket.CLOSING || ws.readyState === globalThis.WebSocket.CLOSED) {
         return Effect.fail(transportError("open", `WebSocket closed before opening (state ${ws.readyState})`, {
             url: input.url,
-            kind: "open",
+            operation: "request",
+            code: "closed",
         }));
     }
     return Effect.callback((resume, signal) => {
@@ -50,13 +57,17 @@ const waitOpen = (ws, input) => {
         };
         const onError = (event) => {
             cleanup();
-            resume(Effect.fail(transportError("open", `Failed to open WebSocket: ${eventMessage(event)}`, { url: input.url, kind: "open" })));
+            resume(Effect.fail(transportError("open", `Failed to open WebSocket: ${eventMessage(event)}`, {
+                url: input.url,
+                operation: "request",
+            })));
         };
         const onClose = (event) => {
             cleanup();
             resume(Effect.fail(transportError("open", `WebSocket closed before opening with code ${event.code}`, {
                 url: input.url,
-                kind: "open",
+                operation: "request",
+                code: String(event.code),
             })));
         };
         ws.addEventListener("open", onOpen, { once: true });
@@ -80,14 +91,15 @@ const webSocketUrl = (value) => Effect.try({
     },
     catch: (error) => transportError("prepare", error instanceof Error ? error.message : "Invalid WebSocket URL", {
         url: value,
-        kind: "websocket",
+        operation: "request",
+        code: "invalid-url",
     }),
 });
 export const open = (input) => Effect.try({
     try: () => new globalThis.WebSocket(input.url, { headers: input.headers }),
     catch: (error) => transportError("open", error instanceof Error ? error.message : "Failed to construct WebSocket", {
         url: input.url,
-        kind: "open",
+        operation: "request",
     }),
 }).pipe(Effect.flatMap((ws) => fromWebSocket(ws, input)));
 export const layer = Layer.succeed(Service, Service.of({ open }));
@@ -100,15 +112,25 @@ export const fromWebSocket = (ws, input) => Effect.gen(function* () {
         const binary = binaryMessage(event.data);
         if (binary)
             return Queue.offerUnsafe(messages, binary);
-        Queue.failCauseUnsafe(messages, Cause.fail(transportError("message", "Unsupported WebSocket message payload", { url: input.url, kind: "message" })));
+        Queue.failCauseUnsafe(messages, Cause.fail(transportError("message", "Unsupported WebSocket message payload", {
+            url: input.url,
+            operation: "read",
+        })));
     };
     const onError = (event) => {
-        Queue.failCauseUnsafe(messages, Cause.fail(transportError("message", `WebSocket error: ${eventMessage(event)}`, { url: input.url, kind: "message" })));
+        Queue.failCauseUnsafe(messages, Cause.fail(transportError("message", `WebSocket error: ${eventMessage(event)}`, {
+            url: input.url,
+            operation: "read",
+        })));
     };
     const onClose = (event) => {
         if (event.code === 1000 || event.code === 1005)
             return Queue.endUnsafe(messages);
-        Queue.failCauseUnsafe(messages, Cause.fail(transportError("message", `WebSocket closed with code ${event.code}`, { url: input.url, kind: "close" })));
+        Queue.failCauseUnsafe(messages, Cause.fail(transportError("message", `WebSocket closed with code ${event.code}`, {
+            url: input.url,
+            operation: "read",
+            code: String(event.code),
+        })));
     };
     const cleanup = Effect.sync(() => {
         ws.removeEventListener("message", onMessage);
@@ -123,7 +145,7 @@ export const fromWebSocket = (ws, input) => Effect.gen(function* () {
             try: () => ws.send(message),
             catch: (error) => transportError("sendText", error instanceof Error ? error.message : "Failed to send WebSocket message", {
                 url: input.url,
-                kind: "write",
+                operation: "write",
             }),
         }),
         messages: Stream.fromQueue(messages),
@@ -153,7 +175,8 @@ export const json = (input) => ({
         if (!webSocket) {
             return Stream.fail(transportError("json", "WebSocket JSON transport requires WebSocketExecutor.Service", {
                 url: prepared.url,
-                kind: "websocket",
+                operation: "request",
+                code: "unavailable",
             }));
         }
         const decoder = new TextDecoder();

package/dist/schema/errors.d.ts

@@ -97,10 +97,16 @@ declare const ProviderInternalReason_base: Schema.Class<ProviderInternalReason,
 }>, {}>;
 export declare class ProviderInternalReason extends ProviderInternalReason_base {
 }
+export declare const TransportType: Schema.Literals<readonly ["http", "websocket"]>;
+export type TransportType = typeof TransportType.Type;
+export declare const TransportOperation: Schema.Literals<readonly ["request", "read", "write"]>;
+export type TransportOperation = typeof TransportOperation.Type;
 declare const TransportReason_base: Schema.Class<TransportReason, Schema.Struct<{
     readonly _tag: Schema.tag<"Transport">;
     readonly message: Schema.String;
-    readonly kind: Schema.optional<Schema.String>;
+    readonly transport: Schema.Literals<readonly ["http", "websocket"]>;
+    readonly operation: Schema.Literals<readonly ["request", "read", "write"]>;
+    readonly code: Schema.optional<Schema.String>;
     readonly url: Schema.optional<Schema.String>;
     readonly http: Schema.optional<typeof HttpContext>;
 }>, {}>;

package/dist/schema/errors.js

@@ -88,10 +88,14 @@ export class ProviderInternalReason extends Schema.Class("AI.Error.ProviderInter
     http: Schema.optional(HttpContext),
 }) {
 }
+export const TransportType = Schema.Literals(["http", "websocket"]);
+export const TransportOperation = Schema.Literals(["request", "read", "write"]);
 export class TransportReason extends Schema.Class("AI.Error.Transport")({
     _tag: Schema.tag("Transport"),
     message: Schema.String,
-    kind: Schema.optional(Schema.String),
+    transport: TransportType,
+    operation: TransportOperation,
+    code: Schema.optional(Schema.String),
     url: Schema.optional(Schema.String),
     http: Schema.optional(HttpContext),
 }) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
-  "version": "0.0.0-next-17274",
+  "version": "0.0.0-next-17288",
   "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-17274",
+    "@opencode-ai/http-recorder": "0.0.0-next-17288",
     "@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-17274",
+    "@opencode-ai/schema": "0.0.0-next-17288",
     "aws4fetch": "1.0.20",
     "effect": "4.0.0-beta.101",
     "google-auth-library": "10.5.0"