@opencode-ai/ai 0.0.0-beta-18414 → 0.0.0-beta-18593

package/dist/protocols/shared.js

@@ -158,13 +158,13 @@ export const errorText = (error) => {
 };
 /**
  * `framing` step for Server-Sent Events. Decodes UTF-8, runs the SSE channel
- * decoder, optionally filters named events, and drops empty / `[DONE]`
- * keep-alive events so the protocol event schema sees one JSON string per
- * element. Retry control events are ignored without interrupting the stream.
+ * decoder, optionally filters named events, and drops empty events. `[DONE]`
+ * is dropped by default or retained for protocols that use it as their stream
+ * boundary. Retry control events are ignored without interrupting the stream.
  * Decoder failures become provider output errors so the public error channel
  * stays `AIError`.
  */
-export const sseFraming = (bytes, events) => bytes.pipe(Stream.decodeText(), Stream.mapAccumEffect(() => {
+export const sseFraming = (bytes, events, includeDone = false) => bytes.pipe(Stream.decodeText(), Stream.mapAccumEffect(() => {
     const output = [];
     return {
         output,
@@ -180,7 +180,7 @@ export const sseFraming = (bytes, events) => bytes.pipe(Stream.decodeText(), Str
     return [state, state.output.splice(0)];
 })), Stream.filter((event) => (events === undefined || events.has(event.event)) &&
     event.data.length > 0 &&
-    (event.data !== "[DONE]" || (events !== undefined && event.event !== "message"))), Stream.map((event) => event.data));
+    (event.data !== "[DONE]" || includeDone || (events !== undefined && event.event !== "message"))), Stream.map((event) => event.data));
 /**
  * Canonical invalid-request constructor shared by protocol lowering.
  */

package/dist/protocols/utils/lifecycle.d.ts

@@ -10,8 +10,12 @@ export declare const textStart: (state: State, events: LLMEvent[], id: string, p
 export declare const textDelta: (state: State, events: LLMEvent[], id: string, text: string, providerMetadata?: ProviderMetadata) => State;
 export declare const reasoningStart: (state: State, events: LLMEvent[], id: string, providerMetadata?: ProviderMetadata) => State;
 export declare const reasoningDelta: (state: State, events: LLMEvent[], id: string, text: string, providerMetadata?: ProviderMetadata) => State;
-export declare const reasoningEnd: (state: State, events: LLMEvent[], id: string, providerMetadata?: ProviderMetadata) => State;
-export declare const textEnd: (state: State, events: LLMEvent[], id: string, providerMetadata?: ProviderMetadata) => State;
+export declare const reasoningEnd: (state: State, events: LLMEvent[], id: string, providerMetadata?: ProviderMetadata, 
+/** Authoritative complete value; replaces accumulated deltas when present. */
+text?: string) => State;
+export declare const textEnd: (state: State, events: LLMEvent[], id: string, providerMetadata?: ProviderMetadata, 
+/** Authoritative complete value; replaces accumulated deltas when present. */
+text?: string) => State;
 export declare const finish: (state: State, events: LLMEvent[], input: {
     readonly reason: FinishReasonDetails;
     readonly usage?: Usage;

package/dist/protocols/utils/lifecycle.js

@@ -30,23 +30,27 @@ export const reasoningDelta = (state, events, id, text, providerMetadata) => {
     events.push(LLMEvent.reasoningDelta({ id, text, providerMetadata }));
     return started;
 };
-export const reasoningEnd = (state, events, id, providerMetadata) => {
+export const reasoningEnd = (state, events, id, providerMetadata, 
+/** Authoritative complete value; replaces accumulated deltas when present. */
+text) => {
     if (!state.reasoning.has(id))
         return state;
     const stepped = stepStart(state, events);
-    events.push(LLMEvent.reasoningEnd({ id, providerMetadata }));
+    events.push(LLMEvent.reasoningEnd({ id, text, providerMetadata }));
     const reasoning = new Set(stepped.reasoning);
     reasoning.delete(id);
     return { ...stepped, reasoning };
 };
-export const textEnd = (state, events, id, providerMetadata) => {
+export const textEnd = (state, events, id, providerMetadata, 
+/** Authoritative complete value; replaces accumulated deltas when present. */
+text) => {
     if (!state.text.has(id))
         return state;
     const stepped = stepStart(state, events);
-    events.push(LLMEvent.textEnd({ id, providerMetadata }));
-    const text = new Set(stepped.text);
-    text.delete(id);
-    return { ...stepped, text };
+    events.push(LLMEvent.textEnd({ id, text, providerMetadata }));
+    const open = new Set(stepped.text);
+    open.delete(id);
+    return { ...stepped, text: open };
 };
 const closeOpenBlocks = (state, events) => {
     for (const id of state.reasoning)

package/dist/protocols/utils/tool-stream.d.ts

@@ -93,6 +93,7 @@ export declare const finish: <K extends StreamKey>(route: string, tools: State<K
     } | {
         readonly id: string;
         readonly type: "text-end";
+        readonly text?: string | undefined;
         readonly providerMetadata?: {
             readonly [x: string]: {
                 readonly [x: string]: unknown;
@@ -118,6 +119,7 @@ export declare const finish: <K extends StreamKey>(route: string, tools: State<K
     } | {
         readonly id: string;
         readonly type: "reasoning-end";
+        readonly text?: string | undefined;
         readonly providerMetadata?: {
             readonly [x: string]: {
                 readonly [x: string]: unknown;
@@ -287,6 +289,7 @@ export declare const finishWithInput: <K extends StreamKey>(route: string, tools
     } | {
         readonly id: string;
         readonly type: "text-end";
+        readonly text?: string | undefined;
         readonly providerMetadata?: {
             readonly [x: string]: {
                 readonly [x: string]: unknown;
@@ -312,6 +315,7 @@ export declare const finishWithInput: <K extends StreamKey>(route: string, tools
     } | {
         readonly id: string;
         readonly type: "reasoning-end";
+        readonly text?: string | undefined;
         readonly providerMetadata?: {
             readonly [x: string]: {
                 readonly [x: string]: unknown;
@@ -478,6 +482,7 @@ export declare const finishAll: <K extends StreamKey>(route: string, tools: Stat
     } | {
         readonly id: string;
         readonly type: "text-end";
+        readonly text?: string | undefined;
         readonly providerMetadata?: {
             readonly [x: string]: {
                 readonly [x: string]: unknown;
@@ -503,6 +508,7 @@ export declare const finishAll: <K extends StreamKey>(route: string, tools: Stat
     } | {
         readonly id: string;
         readonly type: "reasoning-end";
+        readonly text?: string | undefined;
         readonly providerMetadata?: {
             readonly [x: string]: {
                 readonly [x: string]: unknown;

package/dist/provider-error.js

@@ -24,6 +24,7 @@ const patterns = [
     /too large for model with \d+ maximum context length/i,
     /prompt has [\d,]+ tokens?, but the configured context size is [\d,]+ tokens?/i,
     /model_context_window_exceeded/i,
+    /range of input length should be/i,
     /too many tokens/i,
     /token limit exceeded/i,
     /request_too_large/i,
@@ -38,6 +39,7 @@ export const isContextOverflowFailure = (failure) => failure instanceof AIError
     : Schema.is(ProviderErrorEvent)(failure) && failure.classification === "context-overflow";
 const decodeJson = Schema.decodeUnknownOption(Schema.fromJsonString(Schema.Unknown));
 const QUOTA_CODES = new Set(["insufficient_quota", "usage_not_included", "billing_error"]);
+const AUTH_CODES = new Set(["authentication_error", "permission_error"]);
 const SERVER_CODES = new Set([
     "api_error",
     "internal_error",
@@ -53,9 +55,12 @@ const INVALID_REQUEST_CODES = new Set(["invalid_prompt", "invalid_request_error"
 const RATE_LIMIT_TEXT = /rate increased too quickly|rate[-_\s]?limit|too[_\s]?many[_\s]?requests/i;
 const QUOTA_TEXT = /insufficient[-_\s]?quota|quota[-_\s]?exceeded/i;
 const CONTENT_POLICY_TEXT = /content[-_\s]?policy|content_filter|safety/i;
-const NETWORK_ERROR_TEXT = /network[-_\s]error/i;
-// Keep HTTP failures and provider-reported stream failures on one typed path so
-// session retry policy never needs provider-specific string matching.
+// Classification records affirmative evidence about a failure. Deterministic
+// failures need positive identification (a 4xx status, quota/auth/policy
+// signals); anything unrecognized stays UnknownProvider, which the session
+// retry policy treats as retry-eligible because transient failures arrive in
+// unpredictable shapes while deterministic rejections almost always carry a
+// status or known code.
 export function classifyProviderFailure(input) {
     const details = { message: input.message, body: input.rawBody, http: input.http, cause: input.cause };
     const body = input.rawBody ?? "";
@@ -76,48 +81,28 @@ export function classifyProviderFailure(input) {
         return new ContentPolicyError(details);
     if (codes.some((code) => QUOTA_CODES.has(code)) || (input.status === 429 && QUOTA_TEXT.test(text)))
         return new QuotaExceededError(details);
-    if (input.status === 401)
-        return new AuthenticationError({ ...details, kind: "invalid" });
-    if (input.status === 403)
-        return new AuthenticationError({ ...details, kind: "insufficient-permissions" });
-    if (codes.includes("authentication_error"))
-        return new AuthenticationError({ ...details, kind: "invalid" });
-    if (codes.includes("permission_error"))
-        return new AuthenticationError({ ...details, kind: "insufficient-permissions" });
-    if (codes.some((code) => code.includes("rate_limit") || code === "too_many_requests" || code === "throttlingexception"))
+    if (input.status === 401 || input.status === 403 || codes.some((code) => AUTH_CODES.has(code)))
+        return new AuthenticationError(details);
+    if (input.status === 429 ||
+        codes.some((code) => code.includes("rate_limit") || code === "too_many_requests" || code === "throttlingexception") ||
+        RATE_LIMIT_TEXT.test(text))
         return new RateLimitError({
             ...details,
             retryAfterMs: input.retryAfterMs,
             rateLimit: input.rateLimit,
         });
-    if (RATE_LIMIT_TEXT.test(text))
-        return new RateLimitError({
-            ...details,
-            retryAfterMs: input.retryAfterMs,
-            rateLimit: input.rateLimit,
-        });
-    if (NETWORK_ERROR_TEXT.test(text))
-        return new ProviderInternalError(details);
-    if (codes.some((code) => SERVER_CODES.has(code) || code.includes("exhausted") || code.includes("unavailable")))
-        return new ProviderInternalError({
-            ...details,
-            retryAfterMs: input.retryAfterMs,
-        });
-    if (input.status === 429) {
-        return new RateLimitError({
-            ...details,
-            retryAfterMs: input.retryAfterMs,
-            rateLimit: input.rateLimit,
-        });
-    }
-    if (input.status === 408 || input.status === 409 || (input.status !== undefined && input.status >= 500))
+    if (input.status === 408 ||
+        input.status === 409 ||
+        (input.status !== undefined && input.status >= 500) ||
+        codes.some((code) => SERVER_CODES.has(code) || code.includes("exhausted") || code.includes("unavailable")))
         return new ProviderInternalError({
             ...details,
             retryAfterMs: input.retryAfterMs,
         });
     if (codes.some((code) => INVALID_REQUEST_CODES.has(code)))
         return new InvalidRequestError(details);
-    if (input.status === 400 || input.status === 404 || input.status === 413 || input.status === 422)
+    // Any remaining 4xx is a deterministic rejection of this request.
+    if (input.status !== undefined && input.status >= 400 && input.status < 500)
         return new InvalidRequestError(details);
     return new UnknownProviderError(details);
 }

package/dist/providers/groq.d.ts

@@ -125,7 +125,7 @@ export declare const protocol: Protocol<{
     readonly parallel_tool_calls?: boolean | undefined;
     readonly reasoning_format?: "parsed" | undefined;
     readonly include_reasoning?: boolean | undefined;
-}, string, {
+}, string, "[DONE]" | {
     readonly [x: string]: unknown;
     readonly error?: {
         readonly [x: string]: unknown;

package/dist/providers/groq.js

@@ -4,7 +4,6 @@ import { ProviderShared } from "../protocols/shared.js";
 import { AuthOptions } from "../route/auth-options.js";
 import { Route } from "../route/client.js";
 import { Endpoint } from "../route/endpoint.js";
-import { Framing } from "../route/framing.js";
 import { Protocol } from "../route/protocol.js";
 import { ProviderID } from "../schema/index.js";
 import { profiles } from "./openai-compatible-profile.js";
@@ -47,7 +46,7 @@ export const route = Route.make({
     providerMetadataKey: "openai",
     protocol,
     endpoint: Endpoint.path("/chat/completions", { baseURL: profiles.groq.baseURL }),
-    framing: Framing.sse,
+    framing: OpenAIChat.framing,
 });
 export const configure = (input = {}) => {
     const { apiKey: _apiKey, auth: _auth, baseURL, ...defaults } = input;

package/dist/providers/openrouter.d.ts

@@ -282,7 +282,7 @@ export declare const protocol: Protocol<{
     readonly tool_stream?: boolean | undefined;
     readonly frequency_penalty?: number | undefined;
     readonly presence_penalty?: number | undefined;
-}, string, {
+}, string, "[DONE]" | {
     readonly [x: string]: unknown;
     readonly error?: {
         readonly [x: string]: unknown;

package/dist/providers/openrouter.js

@@ -1,7 +1,6 @@
 import { Effect, Schema } from "effect";
 import { Route } from "../route/client.js";
 import { Endpoint } from "../route/endpoint.js";
-import { Framing } from "../route/framing.js";
 import { Protocol } from "../route/protocol.js";
 import { AuthOptions } from "../route/auth-options.js";
 import { ProviderID } from "../schema/index.js";
@@ -87,7 +86,7 @@ export const route = Route.make({
     providerMetadataKey: "openrouter",
     protocol,
     endpoint: Endpoint.path("/chat/completions", { baseURL: profile.baseURL }),
-    framing: Framing.sse,
+    framing: OpenAIChat.framing,
 });
 export const routes = [route];
 const configuredRoute = (input) => {

package/dist/route/auth.js

@@ -77,7 +77,7 @@ const toAIError = (error) => {
     if (error instanceof MissingCredentialError || error instanceof Config.ConfigError) {
         return new AIError({
             reason: error instanceof MissingCredentialError
-                ? new AuthenticationError({ message: error.message, cause: error, kind: "missing" })
+                ? new AuthenticationError({ message: error.message, cause: error })
                 : new InvalidRequestError({ message: `Failed to resolve auth config: ${error.message}`, cause: error }),
         });
     }

package/dist/route/client.d.ts

@@ -173,6 +173,7 @@ export declare const streamRequest: (request: LLMRequest, options?: StreamOption
 } | {
     readonly id: string;
     readonly type: "text-end";
+    readonly text?: string | undefined;
     readonly providerMetadata?: {
         readonly [x: string]: {
             readonly [x: string]: unknown;
@@ -198,6 +199,7 @@ export declare const streamRequest: (request: LLMRequest, options?: StreamOption
 } | {
     readonly id: string;
     readonly type: "reasoning-end";
+    readonly text?: string | undefined;
     readonly providerMetadata?: {
         readonly [x: string]: {
             readonly [x: string]: unknown;

package/dist/route/framing.d.ts

@@ -6,8 +6,8 @@ import type { AIError } from "../schema/index.js";
  * `Framing` is the byte-stream-shaped seam between transport and protocol:
  *
  * - SSE (`Framing.sse`) — UTF-8 decode the body, run the SSE channel decoder,
- *   drop empty / `[DONE]` keep-alives. Each emitted frame is the JSON `data:`
- *   payload of one event.
+ *   and emit the `data:` payload of each non-empty event. The default drops
+ *   `[DONE]`; protocols that use it as a terminal select `sseWithDone`.
  * - AWS event stream — length-prefixed binary frames with CRC checksums.
  *   Each emitted frame is one parsed binary event record.
  *
@@ -22,6 +22,8 @@ export interface Definition<Frame> {
 }
 /** Server-Sent Events framing. Used by every JSON-streaming HTTP provider. */
 export declare const sse: Definition<string>;
+/** Server-Sent Events framing that retains the conventional `[DONE]` sentinel. */
+export declare const sseWithDone: Definition<string>;
 /** SSE framing restricted to protocol-recognized event names. */
 export declare const sseEvents: (events: ReadonlySet<string>) => Definition<string>;
 export * as Framing from "./framing.js";

package/dist/route/framing.js

@@ -1,6 +1,11 @@
 import * as ProviderShared from "../protocols/shared.js";
 /** Server-Sent Events framing. Used by every JSON-streaming HTTP provider. */
 export const sse = { id: "sse", frame: ProviderShared.sseFraming };
+/** Server-Sent Events framing that retains the conventional `[DONE]` sentinel. */
+export const sseWithDone = {
+    id: "sse",
+    frame: (bytes) => ProviderShared.sseFraming(bytes, undefined, true),
+};
 /** SSE framing restricted to protocol-recognized event names. */
 export const sseEvents = (events) => ({
     id: "sse",

package/dist/schema/errors.d.ts

@@ -39,11 +39,10 @@ declare const NoRouteError_base: Schema.Class<NoRouteError, Schema.TaggedStruct<
 export declare class NoRouteError extends NoRouteError_base {
 }
 declare const AuthenticationError_base: Schema.Class<AuthenticationError, Schema.TaggedStruct<"Authentication", {
-    readonly kind: Schema.Literals<readonly ["missing", "invalid", "expired", "insufficient-permissions", "unknown"]>;
-    readonly message: Schema.String;
-    readonly body: Schema.optional<Schema.String>;
-    readonly http: Schema.optional<typeof HttpContext>;
-    readonly cause: Schema.optional<Schema.Defect>;
+    message: Schema.String;
+    body: Schema.optional<Schema.String>;
+    http: Schema.optional<typeof HttpContext>;
+    cause: Schema.optional<Schema.Defect>;
 }>, import("effect/Cause").YieldableError>;
 export declare class AuthenticationError extends AuthenticationError_base {
 }

package/dist/schema/errors.js

@@ -35,10 +35,7 @@ export class NoRouteError extends Schema.TaggedError("AI.Error.NoRoute")("NoRout
     model: ModelID,
 }) {
 }
-export class AuthenticationError extends Schema.TaggedError("AI.Error.Authentication")("Authentication", {
-    ...ReasonFields,
-    kind: Schema.Literals(["missing", "invalid", "expired", "insufficient-permissions", "unknown"]),
-}) {
+export class AuthenticationError extends Schema.TaggedError("AI.Error.Authentication")("Authentication", ReasonFields) {
 }
 export class RateLimitError extends Schema.TaggedError("AI.Error.RateLimit")("RateLimit", {
     ...ReasonFields,