npm - @opencode-ai/ai - Versions diffs - 0.0.0-next-16093 → 0.0.0-next-16094 - Mend

@opencode-ai/ai 0.0.0-next-16093 → 0.0.0-next-16094

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (15) hide show

package/dist/llm.d.ts +8 -2
package/dist/protocols/anthropic-messages.js +5 -2
package/dist/protocols/bedrock-converse.d.ts +2 -2
package/dist/protocols/bedrock-converse.js +26 -4
package/dist/protocols/gemini.js +15 -3
package/dist/protocols/openai-chat.d.ts +27 -17
package/dist/protocols/openai-chat.js +31 -5
package/dist/protocols/openai-responses.js +4 -1
package/dist/protocols/utils/lifecycle.d.ts +2 -2
package/dist/protocols/utils/tool-stream.d.ts +24 -6
package/dist/providers/openrouter.d.ts +18 -13
package/dist/route/client.d.ts +8 -2
package/dist/schema/events.d.ts +203 -51
package/dist/schema/events.js +8 -4
package/package.json +3 -3

package/dist/llm.d.ts CHANGED Viewed

@@ -176,7 +176,10 @@ export declare class GenerateObjectResponse<T> {
         } | undefined;
     } | {
         readonly type: "step-finish";
-        readonly reason: "length" | "stop" | "tool-calls" | "content-filter" | "error" | "unknown";
+        readonly reason: {
+            readonly normalized: "length" | "stop" | "tool-calls" | "content-filter" | "error" | "unknown";
+            readonly raw?: string | undefined;
+        };
         readonly index: number;
         readonly providerMetadata?: {
             readonly [x: string]: {
@@ -186,7 +189,10 @@ export declare class GenerateObjectResponse<T> {
         readonly usage?: import("./schema").Usage | undefined;
     } | {
         readonly type: "finish";
-        readonly reason: "length" | "stop" | "tool-calls" | "content-filter" | "error" | "unknown";
+        readonly reason: {
+            readonly normalized: "length" | "stop" | "tool-calls" | "content-filter" | "error" | "unknown";
+            readonly raw?: string | undefined;
+        };
         readonly providerMetadata?: {
             readonly [x: string]: {
                 readonly [x: string]: unknown;

package/dist/protocols/anthropic-messages.js CHANGED Viewed

@@ -498,7 +498,7 @@ const fromRequest = Effect.fn("AnthropicMessages.fromRequest")(function* (reques
 const mapFinishReason = (reason) => {
     if (reason === "end_turn" || reason === "stop_sequence" || reason === "pause_turn")
         return "stop";
-    if (reason === "max_tokens")
+    if (reason === "max_tokens" || reason === "model_context_window_exceeded")
         return "length";
     if (reason === "tool_use")
         return "tool-calls";
@@ -701,7 +701,10 @@ const onMessageDelta = (state, event) => {
     const usage = mergeUsage(state.usage, mapUsage(event.usage));
     const events = [];
     const lifecycle = Lifecycle.finish(state.lifecycle, events, {
-        reason: mapFinishReason(event.delta?.stop_reason),
+        reason: {
+            normalized: mapFinishReason(event.delta?.stop_reason),
+            raw: event.delta?.stop_reason ?? undefined,
+        },
         usage,
         providerMetadata: event.delta?.stop_sequence
             ? anthropicMetadata({ stopSequence: event.delta.stop_sequence })

package/dist/protocols/bedrock-converse.d.ts CHANGED Viewed

@@ -1,7 +1,7 @@
 import { Schema } from "effect";
 import { Route } from "../route/client";
 import { Protocol } from "../route/protocol";
-import { Usage, type FinishReason } from "../schema";
+import { Usage, type FinishReasonDetails } from "../schema";
 import { BedrockAuth } from "./utils/bedrock-auth";
 import { Lifecycle } from "./utils/lifecycle";
 import { ToolStream } from "./utils/tool-stream";
@@ -127,7 +127,7 @@ export type BedrockConverseBody = Schema.Schema.Type<typeof BedrockConverseBody>
 interface ParserState {
     readonly tools: ToolStream.State<number>;
     readonly pendingFinish: {
-        readonly reason: FinishReason;
+        readonly reason: FinishReasonDetails;
         readonly usage?: Usage;
     } | undefined;
     readonly hasToolCalls: boolean;

package/dist/protocols/bedrock-converse.js CHANGED Viewed

@@ -336,12 +336,14 @@ const fromRequest = Effect.fn("BedrockConverse.fromRequest")(function* (request)
 const mapFinishReason = (reason) => {
     if (reason === "end_turn" || reason === "stop_sequence")
         return "stop";
-    if (reason === "max_tokens")
+    if (reason === "max_tokens" || reason === "model_context_window_exceeded")
         return "length";
     if (reason === "tool_use")
         return "tool-calls";
     if (reason === "content_filtered" || reason === "guardrail_intervened")
         return "content-filter";
+    if (reason === "malformed_model_output" || reason === "malformed_tool_use")
+        return "error";
     return "unknown";
 };
 // AWS reports inputTokens separately from cache reads and writes.
@@ -447,14 +449,29 @@ const step = (state, event) => Effect.gen(function* () {
         return [
             {
                 ...state,
-                pendingFinish: { reason: mapFinishReason(event.messageStop.stopReason), usage: state.pendingFinish?.usage },
+                pendingFinish: {
+                    reason: {
+                        normalized: mapFinishReason(event.messageStop.stopReason),
+                        raw: event.messageStop.stopReason,
+                    },
+                    usage: state.pendingFinish?.usage,
+                },
             },
             [],
         ];
     }
     if (event.metadata) {
         const usage = mapUsage(event.metadata.usage);
-        return [{ ...state, pendingFinish: { reason: state.pendingFinish?.reason ?? "stop", usage } }, []];
+        return [
+            {
+                ...state,
+                pendingFinish: {
+                    reason: state.pendingFinish?.reason ?? { normalized: "stop" },
+                    usage,
+                },
+            },
+            [],
+        ];
     }
     const exception = [
         ["internalServerException", event.internalServerException],
@@ -480,7 +497,12 @@ const onHalt = (state) => state.pendingFinish
     ? (() => {
         const events = [];
         Lifecycle.finish(state.lifecycle, events, {
-            reason: state.pendingFinish.reason === "stop" && state.hasToolCalls ? "tool-calls" : state.pendingFinish.reason,
+            reason: {
+                ...state.pendingFinish.reason,
+                normalized: state.pendingFinish.reason.normalized === "stop" && state.hasToolCalls
+                    ? "tool-calls"
+                    : state.pendingFinish.reason.normalized,
+            },
             usage: state.pendingFinish.usage,
         });
         return events;

package/dist/protocols/gemini.js CHANGED Viewed

@@ -320,9 +320,18 @@ const mapFinishReason = (finishReason, hasToolCalls) => {
         finishReason === "SAFETY" ||
         finishReason === "BLOCKLIST" ||
         finishReason === "PROHIBITED_CONTENT" ||
-        finishReason === "SPII")
+        finishReason === "SPII" ||
+        finishReason === "MODEL_ARMOR" ||
+        finishReason === "IMAGE_PROHIBITED_CONTENT" ||
+        finishReason === "IMAGE_RECITATION" ||
+        finishReason === "LANGUAGE")
         return "content-filter";
-    if (finishReason === "MALFORMED_FUNCTION_CALL")
+    if (finishReason === "MALFORMED_FUNCTION_CALL" ||
+        finishReason === "UNEXPECTED_TOOL_CALL" ||
+        finishReason === "NO_IMAGE" ||
+        finishReason === "TOO_MANY_TOOL_CALLS" ||
+        finishReason === "MISSING_THOUGHT_SIGNATURE" ||
+        finishReason === "MALFORMED_RESPONSE")
         return "error";
     return "unknown";
 };
@@ -333,7 +342,10 @@ const finish = (state) => state.finishReason || state.usage
             ? Lifecycle.reasoningEnd(state.lifecycle, events, "reasoning-0", googleMetadata({ thoughtSignature: state.reasoningSignature }))
             : state.lifecycle;
         Lifecycle.finish(lifecycle, events, {
-            reason: mapFinishReason(state.finishReason, state.hasToolCalls),
+            reason: {
+                normalized: mapFinishReason(state.finishReason, state.hasToolCalls),
+                raw: state.finishReason,
+            },
             usage: state.usage,
         });
         return events;

package/dist/protocols/openai-chat.d.ts CHANGED Viewed

@@ -2,7 +2,7 @@ import { Schema } from "effect";
 import { Route } from "../route/client";
 import { HttpTransport } from "../route/transport";
 import { Protocol } from "../route/protocol";
-import { LLMEvent, Usage, type FinishReason } from "../schema";
+import { LLMEvent, Usage, type FinishReasonDetails } from "../schema";
 import { Lifecycle } from "./utils/lifecycle";
 import { ToolStream } from "./utils/tool-stream";
 export declare const DEFAULT_BASE_URL = "https://api.openai.com/v1";
@@ -137,7 +137,7 @@ declare const OpenAIChatBody: Schema.Struct<{
 }>;
 export type OpenAIChatBody = Schema.Schema.Type<typeof OpenAIChatBody>;
 export declare const OpenAIChatEvent: Schema.Struct<{
-    readonly choices: Schema.$Array<Schema.Struct<{
+    readonly choices: Schema.optional<Schema.NullOr<Schema.$Array<Schema.Struct<{
         readonly delta: Schema.optional<Schema.NullOr<Schema.StructWithRest<Schema.Struct<{
             readonly content: Schema.optional<Schema.NullOr<Schema.String>>;
             readonly reasoning_content: Schema.optional<Schema.NullOr<Schema.String>>;
@@ -154,7 +154,8 @@ export declare const OpenAIChatEvent: Schema.Struct<{
             }>>>>;
         }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>>>;
         readonly finish_reason: Schema.optional<Schema.NullOr<Schema.String>>;
-    }>>;
+        readonly native_finish_reason: Schema.optional<Schema.NullOr<Schema.String>>;
+    }>>>>;
     readonly usage: Schema.optional<Schema.NullOr<Schema.Struct<{
         readonly prompt_tokens: Schema.optional<Schema.Number>;
         readonly completion_tokens: Schema.optional<Schema.Number>;
@@ -166,6 +167,10 @@ export declare const OpenAIChatEvent: Schema.Struct<{
             readonly reasoning_tokens: Schema.optional<Schema.Number>;
         }>>>;
     }>>>;
+    readonly error: Schema.optional<Schema.NullOr<Schema.Struct<{
+        readonly code: Schema.optional<Schema.NullOr<Schema.Union<readonly [Schema.String, Schema.Number]>>>;
+        readonly message: Schema.String;
+    }>>>;
 }>;
 export type OpenAIChatEvent = Schema.Schema.Type<typeof OpenAIChatEvent>;
 interface PendingToolDelta {
@@ -178,7 +183,7 @@ export interface ParserState {
     readonly pendingTools: Partial<Record<number, PendingToolDelta>>;
     readonly toolCallEvents: ReadonlyArray<LLMEvent>;
     readonly usage?: Usage;
-    readonly finishReason?: FinishReason;
+    readonly finishReason?: FinishReasonDetails;
     readonly lifecycle: Lifecycle.State;
     readonly reasoningField?: string;
     readonly reasoningDetails: Array<unknown>;
@@ -256,7 +261,22 @@ export declare const protocol: Protocol<{
     readonly store?: boolean | undefined;
     readonly reasoning_effort?: string | undefined;
 }, string, {
-    readonly choices: readonly {
+    readonly error?: {
+        readonly message: string;
+        readonly code?: string | number | null | undefined;
+    } | null | undefined;
+    readonly usage?: {
+        readonly prompt_tokens?: number | undefined;
+        readonly completion_tokens?: number | undefined;
+        readonly total_tokens?: number | undefined;
+        readonly prompt_tokens_details?: {
+            readonly cached_tokens?: number | undefined;
+        } | null | undefined;
+        readonly completion_tokens_details?: {
+            readonly reasoning_tokens?: number | undefined;
+        } | null | undefined;
+    } | null | undefined;
+    readonly choices?: readonly {
         readonly delta?: {
             readonly [x: string]: unknown;
             readonly content?: string | null | undefined;
@@ -274,18 +294,8 @@ export declare const protocol: Protocol<{
             readonly reasoning_details?: unknown;
         } | null | undefined;
         readonly finish_reason?: string | null | undefined;
-    }[];
-    readonly usage?: {
-        readonly prompt_tokens?: number | undefined;
-        readonly completion_tokens?: number | undefined;
-        readonly total_tokens?: number | undefined;
-        readonly prompt_tokens_details?: {
-            readonly cached_tokens?: number | undefined;
-        } | null | undefined;
-        readonly completion_tokens_details?: {
-            readonly reasoning_tokens?: number | undefined;
-        } | null | undefined;
-    } | null | undefined;
+        readonly native_finish_reason?: string | null | undefined;
+    }[] | null | undefined;
 }, ParserState>;
 export declare const httpTransport: HttpTransport.HttpJsonTransport<{
     readonly messages: readonly (Schema.Struct.ReadonlySide<{

package/dist/protocols/openai-chat.js CHANGED Viewed

@@ -4,7 +4,8 @@ import { Auth } from "../route/auth";
 import { Endpoint } from "../route/endpoint";
 import { HttpTransport } from "../route/transport";
 import { Protocol } from "../route/protocol";
-import { LLMEvent, Usage, } from "../schema";
+import { LLMError, LLMEvent, Usage, } from "../schema";
+import { classifyProviderFailure } from "../provider-error";
 import { isRecord, JsonObject, optionalArray, optionalNull, ProviderShared } from "./shared";
 import { OpenAIOptions } from "./utils/openai-options";
 import { Lifecycle } from "./utils/lifecycle";
@@ -124,10 +125,16 @@ const OpenAIChatDelta = Schema.StructWithRest(Schema.Struct({
 const OpenAIChatChoice = Schema.Struct({
     delta: optionalNull(OpenAIChatDelta),
     finish_reason: optionalNull(Schema.String),
+    native_finish_reason: optionalNull(Schema.String),
+});
+const OpenAIChatError = Schema.Struct({
+    code: optionalNull(Schema.Union([Schema.String, Schema.Number])),
+    message: Schema.String,
 });
 export const OpenAIChatEvent = Schema.Struct({
-    choices: Schema.Array(OpenAIChatChoice),
+    choices: optionalNull(Schema.Array(OpenAIChatChoice)),
     usage: optionalNull(OpenAIChatUsage),
+    error: optionalNull(OpenAIChatError),
 });
 // =============================================================================
 // Request Lowering
@@ -362,6 +369,8 @@ const mapFinishReason = (reason) => {
         return "content-filter";
     if (reason === "function_call" || reason === "tool_calls")
         return "tool-calls";
+    if (reason === "error")
+        return "error";
     return "unknown";
 };
 // OpenAI Chat reports `prompt_tokens` (inclusive total) with a
@@ -444,10 +453,22 @@ const reasoningMetadata = (field, details) => ({
     },
 });
 const step = (state, event) => Effect.gen(function* () {
+    if (event.error)
+        return yield* new LLMError({
+            module: ADAPTER,
+            method: "stream",
+            reason: classifyProviderFailure({
+                message: event.error.message,
+                code: event.error.code === undefined || event.error.code === null ? undefined : String(event.error.code),
+                status: typeof event.error.code === "number" ? event.error.code : undefined,
+            }),
+        });
     const events = [];
     const usage = mapUsage(event.usage) ?? state.usage;
-    const choice = event.choices[0];
-    const finishReason = choice?.finish_reason ? mapFinishReason(choice.finish_reason) : state.finishReason;
+    const choice = event.choices?.[0];
+    const finishReason = choice?.finish_reason
+        ? { normalized: mapFinishReason(choice.finish_reason), raw: choice.native_finish_reason ?? choice.finish_reason }
+        : state.finishReason;
     const delta = choice?.delta;
     const toolDeltas = delta?.tool_calls ?? [];
     let tools = state.tools;
@@ -520,7 +541,12 @@ const step = (state, event) => Effect.gen(function* () {
 const finishEvents = (state) => {
     const events = [];
     const hasToolCalls = state.toolCallEvents.length > 0;
-    const reason = state.finishReason === "stop" && hasToolCalls ? "tool-calls" : state.finishReason;
+    const reason = state.finishReason
+        ? {
+            ...state.finishReason,
+            normalized: state.finishReason.normalized === "stop" && hasToolCalls ? "tool-calls" : state.finishReason.normalized,
+        }
+        : undefined;
     const metadata = reasoningMetadata(state.reasoningField, state.reasoningDetailsObserved ? state.reasoningDetails : undefined);
     const started = state.reasoningDetailsObserved && !state.reasoningEmitted
         ? Lifecycle.reasoningStart(state.lifecycle, events, "reasoning-0", reasoningMetadata(state.reasoningField))

package/dist/protocols/openai-responses.js CHANGED Viewed

@@ -789,7 +789,10 @@ const onOutputItemDone = Effect.fn("OpenAIResponses.onOutputItemDone")(function*
 const onResponseFinish = (state, event) => {
     const events = [];
     const lifecycle = Lifecycle.finish(state.lifecycle, events, {
-        reason: mapFinishReason(event, state.hasFunctionCall),
+        reason: {
+            normalized: mapFinishReason(event, state.hasFunctionCall),
+            raw: event.response?.incomplete_details?.reason,
+        },
         usage: mapUsage(event.response?.usage),
         providerMetadata: event.response?.id || event.response?.service_tier
             ? openaiMetadata({

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

@@ -1,4 +1,4 @@
-import { LLMEvent, type FinishReason, type ProviderMetadata, type Usage } from "../../schema";
+import { LLMEvent, type FinishReasonDetails, type ProviderMetadata, type Usage } from "../../schema";
 export interface State {
     readonly stepStarted: boolean;
     readonly text: ReadonlySet<string>;
@@ -12,7 +12,7 @@ export declare const reasoningDelta: (state: State, events: LLMEvent[], id: stri
 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 finish: (state: State, events: LLMEvent[], input: {
-    readonly reason: FinishReason;
+    readonly reason: FinishReasonDetails;
     readonly usage?: Usage;
     readonly providerMetadata?: ProviderMetadata;
 }) => State;

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

@@ -219,7 +219,10 @@ export declare const finish: <K extends StreamKey>(route: string, tools: State<K
         } | undefined;
     } | {
         readonly type: "step-finish";
-        readonly reason: "length" | "stop" | "tool-calls" | "content-filter" | "error" | "unknown";
+        readonly reason: {
+            readonly normalized: "length" | "stop" | "tool-calls" | "content-filter" | "error" | "unknown";
+            readonly raw?: string | undefined;
+        };
         readonly index: number;
         readonly providerMetadata?: {
             readonly [x: string]: {
@@ -229,7 +232,10 @@ export declare const finish: <K extends StreamKey>(route: string, tools: State<K
         readonly usage?: import("../..").Usage | undefined;
     } | {
         readonly type: "finish";
-        readonly reason: "length" | "stop" | "tool-calls" | "content-filter" | "error" | "unknown";
+        readonly reason: {
+            readonly normalized: "length" | "stop" | "tool-calls" | "content-filter" | "error" | "unknown";
+            readonly raw?: string | undefined;
+        };
         readonly providerMetadata?: {
             readonly [x: string]: {
                 readonly [x: string]: unknown;
@@ -406,7 +412,10 @@ export declare const finishWithInput: <K extends StreamKey>(route: string, tools
         } | undefined;
     } | {
         readonly type: "step-finish";
-        readonly reason: "length" | "stop" | "tool-calls" | "content-filter" | "error" | "unknown";
+        readonly reason: {
+            readonly normalized: "length" | "stop" | "tool-calls" | "content-filter" | "error" | "unknown";
+            readonly raw?: string | undefined;
+        };
         readonly index: number;
         readonly providerMetadata?: {
             readonly [x: string]: {
@@ -416,7 +425,10 @@ export declare const finishWithInput: <K extends StreamKey>(route: string, tools
         readonly usage?: import("../..").Usage | undefined;
     } | {
         readonly type: "finish";
-        readonly reason: "length" | "stop" | "tool-calls" | "content-filter" | "error" | "unknown";
+        readonly reason: {
+            readonly normalized: "length" | "stop" | "tool-calls" | "content-filter" | "error" | "unknown";
+            readonly raw?: string | undefined;
+        };
         readonly providerMetadata?: {
             readonly [x: string]: {
                 readonly [x: string]: unknown;
@@ -590,7 +602,10 @@ export declare const finishAll: <K extends StreamKey>(route: string, tools: Stat
         } | undefined;
     } | {
         readonly type: "step-finish";
-        readonly reason: "length" | "stop" | "tool-calls" | "content-filter" | "error" | "unknown";
+        readonly reason: {
+            readonly normalized: "length" | "stop" | "tool-calls" | "content-filter" | "error" | "unknown";
+            readonly raw?: string | undefined;
+        };
         readonly index: number;
         readonly providerMetadata?: {
             readonly [x: string]: {
@@ -600,7 +615,10 @@ export declare const finishAll: <K extends StreamKey>(route: string, tools: Stat
         readonly usage?: import("../..").Usage | undefined;
     } | {
         readonly type: "finish";
-        readonly reason: "length" | "stop" | "tool-calls" | "content-filter" | "error" | "unknown";
+        readonly reason: {
+            readonly normalized: "length" | "stop" | "tool-calls" | "content-filter" | "error" | "unknown";
+            readonly raw?: string | undefined;
+        };
         readonly providerMetadata?: {
             readonly [x: string]: {
                 readonly [x: string]: unknown;

package/dist/providers/openrouter.d.ts CHANGED Viewed

@@ -153,7 +153,22 @@ export declare const protocol: Protocol<{
     readonly store?: boolean | undefined;
     readonly reasoning_effort?: string | undefined;
 }, string, {
-    readonly choices: readonly {
+    readonly error?: {
+        readonly message: string;
+        readonly code?: string | number | null | undefined;
+    } | null | undefined;
+    readonly usage?: {
+        readonly prompt_tokens?: number | undefined;
+        readonly completion_tokens?: number | undefined;
+        readonly total_tokens?: number | undefined;
+        readonly prompt_tokens_details?: {
+            readonly cached_tokens?: number | undefined;
+        } | null | undefined;
+        readonly completion_tokens_details?: {
+            readonly reasoning_tokens?: number | undefined;
+        } | null | undefined;
+    } | null | undefined;
+    readonly choices?: readonly {
         readonly delta?: {
             readonly [x: string]: unknown;
             readonly content?: string | null | undefined;
@@ -171,18 +186,8 @@ export declare const protocol: Protocol<{
             readonly reasoning_details?: unknown;
         } | null | undefined;
         readonly finish_reason?: string | null | undefined;
-    }[];
-    readonly usage?: {
-        readonly prompt_tokens?: number | undefined;
-        readonly completion_tokens?: number | undefined;
-        readonly total_tokens?: number | undefined;
-        readonly prompt_tokens_details?: {
-            readonly cached_tokens?: number | undefined;
-        } | null | undefined;
-        readonly completion_tokens_details?: {
-            readonly reasoning_tokens?: number | undefined;
-        } | null | undefined;
-    } | null | undefined;
+        readonly native_finish_reason?: string | null | undefined;
+    }[] | null | undefined;
 }, OpenAIChat.ParserState>;
 export declare const route: Route<{
     readonly [x: string]: any;

package/dist/route/client.d.ts CHANGED Viewed

@@ -295,7 +295,10 @@ export declare const streamRequest: (request: LLMRequest) => Stream.Stream<Schem
     } | undefined;
 } | {
     readonly type: "step-finish";
-    readonly reason: "length" | "stop" | "tool-calls" | "content-filter" | "error" | "unknown";
+    readonly reason: {
+        readonly normalized: "length" | "stop" | "tool-calls" | "content-filter" | "error" | "unknown";
+        readonly raw?: string | undefined;
+    };
     readonly index: number;
     readonly providerMetadata?: {
         readonly [x: string]: {
@@ -305,7 +308,10 @@ export declare const streamRequest: (request: LLMRequest) => Stream.Stream<Schem
     readonly usage?: import("..").Usage | undefined;
 } | {
     readonly type: "finish";
-    readonly reason: "length" | "stop" | "tool-calls" | "content-filter" | "error" | "unknown";
+    readonly reason: {
+        readonly normalized: "length" | "stop" | "tool-calls" | "content-filter" | "error" | "unknown";
+        readonly raw?: string | undefined;
+    };
     readonly providerMetadata?: {
         readonly [x: string]: {
             readonly [x: string]: unknown;

package/dist/schema/events.d.ts CHANGED Viewed

@@ -1,5 +1,5 @@
 import { Schema } from "effect";
-import { ContentBlockID, FinishReason, ProviderMetadata, ToolCallID } from "./ids";
+import { ContentBlockID, ProviderMetadata, ToolCallID } from "./ids";
 import { Message, ToolOutput, ToolResultValue } from "./messages";
 declare const Usage_base: Schema.Class<Usage, Schema.Struct<{
     readonly inputTokens: Schema.optional<Schema.Number>;
@@ -206,17 +206,28 @@ export declare const ToolError: Schema.Struct<{
     readonly providerMetadata: Schema.optional<Schema.$Record<Schema.String, Schema.$Record<Schema.String, Schema.Unknown>>>;
 }>;
 export type ToolError = Schema.Schema.Type<typeof ToolError>;
+export declare const FinishReasonDetails: Schema.Struct<{
+    readonly normalized: Schema.Literals<readonly ["stop", "length", "tool-calls", "content-filter", "error", "unknown"]>;
+    readonly raw: Schema.optional<Schema.String>;
+}>;
+export type FinishReasonDetails = Schema.Schema.Type<typeof FinishReasonDetails>;
 export declare const StepFinish: Schema.Struct<{
     readonly type: Schema.tag<"step-finish">;
     readonly index: Schema.Number;
-    readonly reason: Schema.Literals<readonly ["stop", "length", "tool-calls", "content-filter", "error", "unknown"]>;
+    readonly reason: Schema.Struct<{
+        readonly normalized: Schema.Literals<readonly ["stop", "length", "tool-calls", "content-filter", "error", "unknown"]>;
+        readonly raw: Schema.optional<Schema.String>;
+    }>;
     readonly usage: Schema.optional<typeof Usage>;
     readonly providerMetadata: Schema.optional<Schema.$Record<Schema.String, Schema.$Record<Schema.String, Schema.Unknown>>>;
 }>;
 export type StepFinish = Schema.Schema.Type<typeof StepFinish>;
 export declare const Finish: Schema.Struct<{
     readonly type: Schema.tag<"finish">;
-    readonly reason: Schema.Literals<readonly ["stop", "length", "tool-calls", "content-filter", "error", "unknown"]>;
+    readonly reason: Schema.Struct<{
+        readonly normalized: Schema.Literals<readonly ["stop", "length", "tool-calls", "content-filter", "error", "unknown"]>;
+        readonly raw: Schema.optional<Schema.String>;
+    }>;
     readonly usage: Schema.optional<typeof Usage>;
     readonly providerMetadata: Schema.optional<Schema.$Record<Schema.String, Schema.$Record<Schema.String, Schema.Unknown>>>;
 }>;
@@ -341,12 +352,18 @@ declare const llmEventTagged: Schema.toTaggedUnion<"type", readonly [Schema.Stru
 }>, Schema.Struct<{
     readonly type: Schema.tag<"step-finish">;
     readonly index: Schema.Number;
-    readonly reason: Schema.Literals<readonly ["stop", "length", "tool-calls", "content-filter", "error", "unknown"]>;
+    readonly reason: Schema.Struct<{
+        readonly normalized: Schema.Literals<readonly ["stop", "length", "tool-calls", "content-filter", "error", "unknown"]>;
+        readonly raw: Schema.optional<Schema.String>;
+    }>;
     readonly usage: Schema.optional<typeof Usage>;
     readonly providerMetadata: Schema.optional<Schema.$Record<Schema.String, Schema.$Record<Schema.String, Schema.Unknown>>>;
 }>, Schema.Struct<{
     readonly type: Schema.tag<"finish">;
-    readonly reason: Schema.Literals<readonly ["stop", "length", "tool-calls", "content-filter", "error", "unknown"]>;
+    readonly reason: Schema.Struct<{
+        readonly normalized: Schema.Literals<readonly ["stop", "length", "tool-calls", "content-filter", "error", "unknown"]>;
+        readonly raw: Schema.optional<Schema.String>;
+    }>;
     readonly usage: Schema.optional<typeof Usage>;
     readonly providerMetadata: Schema.optional<Schema.$Record<Schema.String, Schema.$Record<Schema.String, Schema.Unknown>>>;
 }>, Schema.Struct<{
@@ -483,12 +500,18 @@ export declare const LLMEvent: Schema.Union<readonly [Schema.Struct<{
 }>, Schema.Struct<{
     readonly type: Schema.tag<"step-finish">;
     readonly index: Schema.Number;
-    readonly reason: Schema.Literals<readonly ["stop", "length", "tool-calls", "content-filter", "error", "unknown"]>;
+    readonly reason: Schema.Struct<{
+        readonly normalized: Schema.Literals<readonly ["stop", "length", "tool-calls", "content-filter", "error", "unknown"]>;
+        readonly raw: Schema.optional<Schema.String>;
+    }>;
     readonly usage: Schema.optional<typeof Usage>;
     readonly providerMetadata: Schema.optional<Schema.$Record<Schema.String, Schema.$Record<Schema.String, Schema.Unknown>>>;
 }>, Schema.Struct<{
     readonly type: Schema.tag<"finish">;
-    readonly reason: Schema.Literals<readonly ["stop", "length", "tool-calls", "content-filter", "error", "unknown"]>;
+    readonly reason: Schema.Struct<{
+        readonly normalized: Schema.Literals<readonly ["stop", "length", "tool-calls", "content-filter", "error", "unknown"]>;
+        readonly raw: Schema.optional<Schema.String>;
+    }>;
     readonly usage: Schema.optional<typeof Usage>;
     readonly providerMetadata: Schema.optional<Schema.$Record<Schema.String, Schema.$Record<Schema.String, Schema.Unknown>>>;
 }>, Schema.Struct<{
@@ -625,13 +648,19 @@ export declare const LLMEvent: Schema.Union<readonly [Schema.Struct<{
         "step-finish": Schema.Struct<{
             readonly type: Schema.tag<"step-finish">;
             readonly index: Schema.Number;
-            readonly reason: Schema.Literals<readonly ["stop", "length", "tool-calls", "content-filter", "error", "unknown"]>;
+            readonly reason: Schema.Struct<{
+                readonly normalized: Schema.Literals<readonly ["stop", "length", "tool-calls", "content-filter", "error", "unknown"]>;
+                readonly raw: Schema.optional<Schema.String>;
+            }>;
             readonly usage: Schema.optional<typeof Usage>;
             readonly providerMetadata: Schema.optional<Schema.$Record<Schema.String, Schema.$Record<Schema.String, Schema.Unknown>>>;
         }>;
         finish: Schema.Struct<{
             readonly type: Schema.tag<"finish">;
-            readonly reason: Schema.Literals<readonly ["stop", "length", "tool-calls", "content-filter", "error", "unknown"]>;
+            readonly reason: Schema.Struct<{
+                readonly normalized: Schema.Literals<readonly ["stop", "length", "tool-calls", "content-filter", "error", "unknown"]>;
+                readonly raw: Schema.optional<Schema.String>;
+            }>;
             readonly usage: Schema.optional<typeof Usage>;
             readonly providerMetadata: Schema.optional<Schema.$Record<Schema.String, Schema.$Record<Schema.String, Schema.Unknown>>>;
         }>;
@@ -791,7 +820,10 @@ export declare const LLMEvent: Schema.Union<readonly [Schema.Struct<{
         } | undefined;
     } | {
         readonly type: "step-finish";
-        readonly reason: "length" | "stop" | "tool-calls" | "content-filter" | "error" | "unknown";
+        readonly reason: {
+            readonly normalized: "length" | "stop" | "tool-calls" | "content-filter" | "error" | "unknown";
+            readonly raw?: string | undefined;
+        };
         readonly index: number;
         readonly providerMetadata?: {
             readonly [x: string]: {
@@ -801,7 +833,10 @@ export declare const LLMEvent: Schema.Union<readonly [Schema.Struct<{
         readonly usage?: Usage | undefined;
     } | {
         readonly type: "finish";
-        readonly reason: "length" | "stop" | "tool-calls" | "content-filter" | "error" | "unknown";
+        readonly reason: {
+            readonly normalized: "length" | "stop" | "tool-calls" | "content-filter" | "error" | "unknown";
+            readonly raw?: string | undefined;
+        };
         readonly providerMetadata?: {
             readonly [x: string]: {
                 readonly [x: string]: unknown;
@@ -994,7 +1029,10 @@ export declare const LLMEvent: Schema.Union<readonly [Schema.Struct<{
         readonly type: Keys;
     }> | Extract<{
         readonly type: "step-finish";
-        readonly reason: "length" | "stop" | "tool-calls" | "content-filter" | "error" | "unknown";
+        readonly reason: {
+            readonly normalized: "length" | "stop" | "tool-calls" | "content-filter" | "error" | "unknown";
+            readonly raw?: string | undefined;
+        };
         readonly index: number;
         readonly providerMetadata?: {
             readonly [x: string]: {
@@ -1006,7 +1044,10 @@ export declare const LLMEvent: Schema.Union<readonly [Schema.Struct<{
         readonly type: Keys;
     }> | Extract<{
         readonly type: "finish";
-        readonly reason: "length" | "stop" | "tool-calls" | "content-filter" | "error" | "unknown";
+        readonly reason: {
+            readonly normalized: "length" | "stop" | "tool-calls" | "content-filter" | "error" | "unknown";
+            readonly raw?: string | undefined;
+        };
         readonly providerMetadata?: {
             readonly [x: string]: {
                 readonly [x: string]: unknown;
@@ -1191,7 +1232,10 @@ export declare const LLMEvent: Schema.Union<readonly [Schema.Struct<{
         };
         "step-finish": (u: unknown) => u is {
             readonly type: "step-finish";
-            readonly reason: "length" | "stop" | "tool-calls" | "content-filter" | "error" | "unknown";
+            readonly reason: {
+                readonly normalized: "length" | "stop" | "tool-calls" | "content-filter" | "error" | "unknown";
+                readonly raw?: string | undefined;
+            };
             readonly index: number;
             readonly providerMetadata?: {
                 readonly [x: string]: {
@@ -1202,7 +1246,10 @@ export declare const LLMEvent: Schema.Union<readonly [Schema.Struct<{
         };
         finish: (u: unknown) => u is {
             readonly type: "finish";
-            readonly reason: "length" | "stop" | "tool-calls" | "content-filter" | "error" | "unknown";
+            readonly reason: {
+                readonly normalized: "length" | "stop" | "tool-calls" | "content-filter" | "error" | "unknown";
+                readonly raw?: string | undefined;
+            };
             readonly providerMetadata?: {
                 readonly [x: string]: {
                     readonly [x: string]: unknown;
@@ -1386,7 +1433,10 @@ export declare const LLMEvent: Schema.Union<readonly [Schema.Struct<{
             }) => any;
             "step-finish": (value: {
                 readonly type: "step-finish";
-                readonly reason: "length" | "stop" | "tool-calls" | "content-filter" | "error" | "unknown";
+                readonly reason: {
+                    readonly normalized: "length" | "stop" | "tool-calls" | "content-filter" | "error" | "unknown";
+                    readonly raw?: string | undefined;
+                };
                 readonly index: number;
                 readonly providerMetadata?: {
                     readonly [x: string]: {
@@ -1397,7 +1447,10 @@ export declare const LLMEvent: Schema.Union<readonly [Schema.Struct<{
             }) => any;
             finish: (value: {
                 readonly type: "finish";
-                readonly reason: "length" | "stop" | "tool-calls" | "content-filter" | "error" | "unknown";
+                readonly reason: {
+                    readonly normalized: "length" | "stop" | "tool-calls" | "content-filter" | "error" | "unknown";
+                    readonly raw?: string | undefined;
+                };
                 readonly providerMetadata?: {
                     readonly [x: string]: {
                         readonly [x: string]: unknown;
@@ -1564,7 +1617,10 @@ export declare const LLMEvent: Schema.Union<readonly [Schema.Struct<{
             } | undefined;
         } | {
             readonly type: "step-finish";
-            readonly reason: "length" | "stop" | "tool-calls" | "content-filter" | "error" | "unknown";
+            readonly reason: {
+                readonly normalized: "length" | "stop" | "tool-calls" | "content-filter" | "error" | "unknown";
+                readonly raw?: string | undefined;
+            };
             readonly index: number;
             readonly providerMetadata?: {
                 readonly [x: string]: {
@@ -1574,7 +1630,10 @@ export declare const LLMEvent: Schema.Union<readonly [Schema.Struct<{
             readonly usage?: Usage | undefined;
         } | {
             readonly type: "finish";
-            readonly reason: "length" | "stop" | "tool-calls" | "content-filter" | "error" | "unknown";
+            readonly reason: {
+                readonly normalized: "length" | "stop" | "tool-calls" | "content-filter" | "error" | "unknown";
+                readonly raw?: string | undefined;
+            };
             readonly providerMetadata?: {
                 readonly [x: string]: {
                     readonly [x: string]: unknown;
@@ -1755,7 +1814,10 @@ export declare const LLMEvent: Schema.Union<readonly [Schema.Struct<{
             }) => any;
             "step-finish": (value: {
                 readonly type: "step-finish";
-                readonly reason: "length" | "stop" | "tool-calls" | "content-filter" | "error" | "unknown";
+                readonly reason: {
+                    readonly normalized: "length" | "stop" | "tool-calls" | "content-filter" | "error" | "unknown";
+                    readonly raw?: string | undefined;
+                };
                 readonly index: number;
                 readonly providerMetadata?: {
                     readonly [x: string]: {
@@ -1766,7 +1828,10 @@ export declare const LLMEvent: Schema.Union<readonly [Schema.Struct<{
             }) => any;
             finish: (value: {
                 readonly type: "finish";
-                readonly reason: "length" | "stop" | "tool-calls" | "content-filter" | "error" | "unknown";
+                readonly reason: {
+                    readonly normalized: "length" | "stop" | "tool-calls" | "content-filter" | "error" | "unknown";
+                    readonly raw?: string | undefined;
+                };
                 readonly providerMetadata?: {
                     readonly [x: string]: {
                         readonly [x: string]: unknown;
@@ -1933,7 +1998,10 @@ export declare const LLMEvent: Schema.Union<readonly [Schema.Struct<{
             } | undefined;
         } | {
             readonly type: "step-finish";
-            readonly reason: "length" | "stop" | "tool-calls" | "content-filter" | "error" | "unknown";
+            readonly reason: {
+                readonly normalized: "length" | "stop" | "tool-calls" | "content-filter" | "error" | "unknown";
+                readonly raw?: string | undefined;
+            };
             readonly index: number;
             readonly providerMetadata?: {
                 readonly [x: string]: {
@@ -1943,7 +2011,10 @@ export declare const LLMEvent: Schema.Union<readonly [Schema.Struct<{
             readonly usage?: Usage | undefined;
         } | {
             readonly type: "finish";
-            readonly reason: "length" | "stop" | "tool-calls" | "content-filter" | "error" | "unknown";
+            readonly reason: {
+                readonly normalized: "length" | "stop" | "tool-calls" | "content-filter" | "error" | "unknown";
+                readonly raw?: string | undefined;
+            };
             readonly providerMetadata?: {
                 readonly [x: string]: {
                     readonly [x: string]: unknown;
@@ -2128,7 +2199,10 @@ export declare const LLMEvent: Schema.Union<readonly [Schema.Struct<{
     };
     stepFinish: (input: WithUsage<StepFinish>) => {
         readonly type: "step-finish";
-        readonly reason: "length" | "stop" | "tool-calls" | "content-filter" | "error" | "unknown";
+        readonly reason: {
+            readonly normalized: "length" | "stop" | "tool-calls" | "content-filter" | "error" | "unknown";
+            readonly raw?: string | undefined;
+        };
         readonly index: number;
         readonly providerMetadata?: {
             readonly [x: string]: {
@@ -2139,7 +2213,10 @@ export declare const LLMEvent: Schema.Union<readonly [Schema.Struct<{
     };
     finish: (input: WithUsage<Finish>) => {
         readonly type: "finish";
-        readonly reason: "length" | "stop" | "tool-calls" | "content-filter" | "error" | "unknown";
+        readonly reason: {
+            readonly normalized: "length" | "stop" | "tool-calls" | "content-filter" | "error" | "unknown";
+            readonly raw?: string | undefined;
+        };
         readonly providerMetadata?: {
             readonly [x: string]: {
                 readonly [x: string]: unknown;
@@ -2330,7 +2407,10 @@ export declare const LLMEvent: Schema.Union<readonly [Schema.Struct<{
         };
         stepFinish: (u: unknown) => u is {
             readonly type: "step-finish";
-            readonly reason: "length" | "stop" | "tool-calls" | "content-filter" | "error" | "unknown";
+            readonly reason: {
+                readonly normalized: "length" | "stop" | "tool-calls" | "content-filter" | "error" | "unknown";
+                readonly raw?: string | undefined;
+            };
             readonly index: number;
             readonly providerMetadata?: {
                 readonly [x: string]: {
@@ -2341,7 +2421,10 @@ export declare const LLMEvent: Schema.Union<readonly [Schema.Struct<{
         };
         finish: (u: unknown) => u is {
             readonly type: "finish";
-            readonly reason: "length" | "stop" | "tool-calls" | "content-filter" | "error" | "unknown";
+            readonly reason: {
+                readonly normalized: "length" | "stop" | "tool-calls" | "content-filter" | "error" | "unknown";
+                readonly raw?: string | undefined;
+            };
             readonly providerMetadata?: {
                 readonly [x: string]: {
                     readonly [x: string]: unknown;
@@ -2399,7 +2482,7 @@ interface ResponseState {
     readonly events: ReadonlyArray<LLMEvent>;
     readonly message: Message;
     readonly usage?: Usage;
-    readonly finishReason?: FinishReason;
+    readonly finishReason?: FinishReasonDetails;
     readonly textParts: Readonly<Record<string, ContentAssembly>>;
     readonly reasoningParts: Readonly<Record<string, ContentAssembly>>;
     readonly toolInputs: Readonly<Record<string, ToolInputAssembly>>;
@@ -2519,12 +2602,18 @@ declare const LLMResponse_base: Schema.Class<LLMResponse, Schema.Struct<{
     }>, Schema.Struct<{
         readonly type: Schema.tag<"step-finish">;
         readonly index: Schema.Number;
-        readonly reason: Schema.Literals<readonly ["stop", "length", "tool-calls", "content-filter", "error", "unknown"]>;
+        readonly reason: Schema.Struct<{
+            readonly normalized: Schema.Literals<readonly ["stop", "length", "tool-calls", "content-filter", "error", "unknown"]>;
+            readonly raw: Schema.optional<Schema.String>;
+        }>;
         readonly usage: Schema.optional<typeof Usage>;
         readonly providerMetadata: Schema.optional<Schema.$Record<Schema.String, Schema.$Record<Schema.String, Schema.Unknown>>>;
     }>, Schema.Struct<{
         readonly type: Schema.tag<"finish">;
-        readonly reason: Schema.Literals<readonly ["stop", "length", "tool-calls", "content-filter", "error", "unknown"]>;
+        readonly reason: Schema.Struct<{
+            readonly normalized: Schema.Literals<readonly ["stop", "length", "tool-calls", "content-filter", "error", "unknown"]>;
+            readonly raw: Schema.optional<Schema.String>;
+        }>;
         readonly usage: Schema.optional<typeof Usage>;
         readonly providerMetadata: Schema.optional<Schema.$Record<Schema.String, Schema.$Record<Schema.String, Schema.Unknown>>>;
     }>, Schema.Struct<{
@@ -2661,13 +2750,19 @@ declare const LLMResponse_base: Schema.Class<LLMResponse, Schema.Struct<{
             "step-finish": Schema.Struct<{
                 readonly type: Schema.tag<"step-finish">;
                 readonly index: Schema.Number;
-                readonly reason: Schema.Literals<readonly ["stop", "length", "tool-calls", "content-filter", "error", "unknown"]>;
+                readonly reason: Schema.Struct<{
+                    readonly normalized: Schema.Literals<readonly ["stop", "length", "tool-calls", "content-filter", "error", "unknown"]>;
+                    readonly raw: Schema.optional<Schema.String>;
+                }>;
                 readonly usage: Schema.optional<typeof Usage>;
                 readonly providerMetadata: Schema.optional<Schema.$Record<Schema.String, Schema.$Record<Schema.String, Schema.Unknown>>>;
             }>;
             finish: Schema.Struct<{
                 readonly type: Schema.tag<"finish">;
-                readonly reason: Schema.Literals<readonly ["stop", "length", "tool-calls", "content-filter", "error", "unknown"]>;
+                readonly reason: Schema.Struct<{
+                    readonly normalized: Schema.Literals<readonly ["stop", "length", "tool-calls", "content-filter", "error", "unknown"]>;
+                    readonly raw: Schema.optional<Schema.String>;
+                }>;
                 readonly usage: Schema.optional<typeof Usage>;
                 readonly providerMetadata: Schema.optional<Schema.$Record<Schema.String, Schema.$Record<Schema.String, Schema.Unknown>>>;
             }>;
@@ -2827,7 +2922,10 @@ declare const LLMResponse_base: Schema.Class<LLMResponse, Schema.Struct<{
             } | undefined;
         } | {
             readonly type: "step-finish";
-            readonly reason: "length" | "stop" | "tool-calls" | "content-filter" | "error" | "unknown";
+            readonly reason: {
+                readonly normalized: "length" | "stop" | "tool-calls" | "content-filter" | "error" | "unknown";
+                readonly raw?: string | undefined;
+            };
             readonly index: number;
             readonly providerMetadata?: {
                 readonly [x: string]: {
@@ -2837,7 +2935,10 @@ declare const LLMResponse_base: Schema.Class<LLMResponse, Schema.Struct<{
             readonly usage?: Usage | undefined;
         } | {
             readonly type: "finish";
-            readonly reason: "length" | "stop" | "tool-calls" | "content-filter" | "error" | "unknown";
+            readonly reason: {
+                readonly normalized: "length" | "stop" | "tool-calls" | "content-filter" | "error" | "unknown";
+                readonly raw?: string | undefined;
+            };
             readonly providerMetadata?: {
                 readonly [x: string]: {
                     readonly [x: string]: unknown;
@@ -3030,7 +3131,10 @@ declare const LLMResponse_base: Schema.Class<LLMResponse, Schema.Struct<{
             readonly type: Keys;
         }> | Extract<{
             readonly type: "step-finish";
-            readonly reason: "length" | "stop" | "tool-calls" | "content-filter" | "error" | "unknown";
+            readonly reason: {
+                readonly normalized: "length" | "stop" | "tool-calls" | "content-filter" | "error" | "unknown";
+                readonly raw?: string | undefined;
+            };
             readonly index: number;
             readonly providerMetadata?: {
                 readonly [x: string]: {
@@ -3042,7 +3146,10 @@ declare const LLMResponse_base: Schema.Class<LLMResponse, Schema.Struct<{
             readonly type: Keys;
         }> | Extract<{
             readonly type: "finish";
-            readonly reason: "length" | "stop" | "tool-calls" | "content-filter" | "error" | "unknown";
+            readonly reason: {
+                readonly normalized: "length" | "stop" | "tool-calls" | "content-filter" | "error" | "unknown";
+                readonly raw?: string | undefined;
+            };
             readonly providerMetadata?: {
                 readonly [x: string]: {
                     readonly [x: string]: unknown;
@@ -3227,7 +3334,10 @@ declare const LLMResponse_base: Schema.Class<LLMResponse, Schema.Struct<{
             };
             "step-finish": (u: unknown) => u is {
                 readonly type: "step-finish";
-                readonly reason: "length" | "stop" | "tool-calls" | "content-filter" | "error" | "unknown";
+                readonly reason: {
+                    readonly normalized: "length" | "stop" | "tool-calls" | "content-filter" | "error" | "unknown";
+                    readonly raw?: string | undefined;
+                };
                 readonly index: number;
                 readonly providerMetadata?: {
                     readonly [x: string]: {
@@ -3238,7 +3348,10 @@ declare const LLMResponse_base: Schema.Class<LLMResponse, Schema.Struct<{
             };
             finish: (u: unknown) => u is {
                 readonly type: "finish";
-                readonly reason: "length" | "stop" | "tool-calls" | "content-filter" | "error" | "unknown";
+                readonly reason: {
+                    readonly normalized: "length" | "stop" | "tool-calls" | "content-filter" | "error" | "unknown";
+                    readonly raw?: string | undefined;
+                };
                 readonly providerMetadata?: {
                     readonly [x: string]: {
                         readonly [x: string]: unknown;
@@ -3422,7 +3535,10 @@ declare const LLMResponse_base: Schema.Class<LLMResponse, Schema.Struct<{
                 }) => any;
                 "step-finish": (value: {
                     readonly type: "step-finish";
-                    readonly reason: "length" | "stop" | "tool-calls" | "content-filter" | "error" | "unknown";
+                    readonly reason: {
+                        readonly normalized: "length" | "stop" | "tool-calls" | "content-filter" | "error" | "unknown";
+                        readonly raw?: string | undefined;
+                    };
                     readonly index: number;
                     readonly providerMetadata?: {
                         readonly [x: string]: {
@@ -3433,7 +3549,10 @@ declare const LLMResponse_base: Schema.Class<LLMResponse, Schema.Struct<{
                 }) => any;
                 finish: (value: {
                     readonly type: "finish";
-                    readonly reason: "length" | "stop" | "tool-calls" | "content-filter" | "error" | "unknown";
+                    readonly reason: {
+                        readonly normalized: "length" | "stop" | "tool-calls" | "content-filter" | "error" | "unknown";
+                        readonly raw?: string | undefined;
+                    };
                     readonly providerMetadata?: {
                         readonly [x: string]: {
                             readonly [x: string]: unknown;
@@ -3600,7 +3719,10 @@ declare const LLMResponse_base: Schema.Class<LLMResponse, Schema.Struct<{
                 } | undefined;
             } | {
                 readonly type: "step-finish";
-                readonly reason: "length" | "stop" | "tool-calls" | "content-filter" | "error" | "unknown";
+                readonly reason: {
+                    readonly normalized: "length" | "stop" | "tool-calls" | "content-filter" | "error" | "unknown";
+                    readonly raw?: string | undefined;
+                };
                 readonly index: number;
                 readonly providerMetadata?: {
                     readonly [x: string]: {
@@ -3610,7 +3732,10 @@ declare const LLMResponse_base: Schema.Class<LLMResponse, Schema.Struct<{
                 readonly usage?: Usage | undefined;
             } | {
                 readonly type: "finish";
-                readonly reason: "length" | "stop" | "tool-calls" | "content-filter" | "error" | "unknown";
+                readonly reason: {
+                    readonly normalized: "length" | "stop" | "tool-calls" | "content-filter" | "error" | "unknown";
+                    readonly raw?: string | undefined;
+                };
                 readonly providerMetadata?: {
                     readonly [x: string]: {
                         readonly [x: string]: unknown;
@@ -3791,7 +3916,10 @@ declare const LLMResponse_base: Schema.Class<LLMResponse, Schema.Struct<{
                 }) => any;
                 "step-finish": (value: {
                     readonly type: "step-finish";
-                    readonly reason: "length" | "stop" | "tool-calls" | "content-filter" | "error" | "unknown";
+                    readonly reason: {
+                        readonly normalized: "length" | "stop" | "tool-calls" | "content-filter" | "error" | "unknown";
+                        readonly raw?: string | undefined;
+                    };
                     readonly index: number;
                     readonly providerMetadata?: {
                         readonly [x: string]: {
@@ -3802,7 +3930,10 @@ declare const LLMResponse_base: Schema.Class<LLMResponse, Schema.Struct<{
                 }) => any;
                 finish: (value: {
                     readonly type: "finish";
-                    readonly reason: "length" | "stop" | "tool-calls" | "content-filter" | "error" | "unknown";
+                    readonly reason: {
+                        readonly normalized: "length" | "stop" | "tool-calls" | "content-filter" | "error" | "unknown";
+                        readonly raw?: string | undefined;
+                    };
                     readonly providerMetadata?: {
                         readonly [x: string]: {
                             readonly [x: string]: unknown;
@@ -3969,7 +4100,10 @@ declare const LLMResponse_base: Schema.Class<LLMResponse, Schema.Struct<{
                 } | undefined;
             } | {
                 readonly type: "step-finish";
-                readonly reason: "length" | "stop" | "tool-calls" | "content-filter" | "error" | "unknown";
+                readonly reason: {
+                    readonly normalized: "length" | "stop" | "tool-calls" | "content-filter" | "error" | "unknown";
+                    readonly raw?: string | undefined;
+                };
                 readonly index: number;
                 readonly providerMetadata?: {
                     readonly [x: string]: {
@@ -3979,7 +4113,10 @@ declare const LLMResponse_base: Schema.Class<LLMResponse, Schema.Struct<{
                 readonly usage?: Usage | undefined;
             } | {
                 readonly type: "finish";
-                readonly reason: "length" | "stop" | "tool-calls" | "content-filter" | "error" | "unknown";
+                readonly reason: {
+                    readonly normalized: "length" | "stop" | "tool-calls" | "content-filter" | "error" | "unknown";
+                    readonly raw?: string | undefined;
+                };
                 readonly providerMetadata?: {
                     readonly [x: string]: {
                         readonly [x: string]: unknown;
@@ -4164,7 +4301,10 @@ declare const LLMResponse_base: Schema.Class<LLMResponse, Schema.Struct<{
         };
         stepFinish: (input: WithUsage<StepFinish>) => {
             readonly type: "step-finish";
-            readonly reason: "length" | "stop" | "tool-calls" | "content-filter" | "error" | "unknown";
+            readonly reason: {
+                readonly normalized: "length" | "stop" | "tool-calls" | "content-filter" | "error" | "unknown";
+                readonly raw?: string | undefined;
+            };
             readonly index: number;
             readonly providerMetadata?: {
                 readonly [x: string]: {
@@ -4175,7 +4315,10 @@ declare const LLMResponse_base: Schema.Class<LLMResponse, Schema.Struct<{
         };
         finish: (input: WithUsage<Finish>) => {
             readonly type: "finish";
-            readonly reason: "length" | "stop" | "tool-calls" | "content-filter" | "error" | "unknown";
+            readonly reason: {
+                readonly normalized: "length" | "stop" | "tool-calls" | "content-filter" | "error" | "unknown";
+                readonly raw?: string | undefined;
+            };
             readonly providerMetadata?: {
                 readonly [x: string]: {
                     readonly [x: string]: unknown;
@@ -4366,7 +4509,10 @@ declare const LLMResponse_base: Schema.Class<LLMResponse, Schema.Struct<{
             };
             stepFinish: (u: unknown) => u is {
                 readonly type: "step-finish";
-                readonly reason: "length" | "stop" | "tool-calls" | "content-filter" | "error" | "unknown";
+                readonly reason: {
+                    readonly normalized: "length" | "stop" | "tool-calls" | "content-filter" | "error" | "unknown";
+                    readonly raw?: string | undefined;
+                };
                 readonly index: number;
                 readonly providerMetadata?: {
                     readonly [x: string]: {
@@ -4377,7 +4523,10 @@ declare const LLMResponse_base: Schema.Class<LLMResponse, Schema.Struct<{
             };
             finish: (u: unknown) => u is {
                 readonly type: "finish";
-                readonly reason: "length" | "stop" | "tool-calls" | "content-filter" | "error" | "unknown";
+                readonly reason: {
+                    readonly normalized: "length" | "stop" | "tool-calls" | "content-filter" | "error" | "unknown";
+                    readonly raw?: string | undefined;
+                };
                 readonly providerMetadata?: {
                     readonly [x: string]: {
                         readonly [x: string]: unknown;
@@ -4398,7 +4547,10 @@ declare const LLMResponse_base: Schema.Class<LLMResponse, Schema.Struct<{
         };
     }>;
     readonly usage: Schema.optional<typeof Usage>;
-    readonly finishReason: Schema.Literals<readonly ["stop", "length", "tool-calls", "content-filter", "error", "unknown"]>;
+    readonly finishReason: Schema.Struct<{
+        readonly normalized: Schema.Literals<readonly ["stop", "length", "tool-calls", "content-filter", "error", "unknown"]>;
+        readonly raw: Schema.optional<Schema.String>;
+    }>;
 }>, {}>;
 export declare class LLMResponse extends LLMResponse_base {
     /** Concatenated assistant text assembled from streamed `text-delta` events. */

package/dist/schema/events.js CHANGED Viewed

@@ -158,16 +158,20 @@ export const ToolError = Schema.Struct({
     error: Schema.optional(Schema.Defect()),
     providerMetadata: Schema.optional(ProviderMetadata),
 }).annotate({ identifier: "LLM.Event.ToolError" });
+export const FinishReasonDetails = Schema.Struct({
+    normalized: FinishReason,
+    raw: Schema.optional(Schema.String),
+}).annotate({ identifier: "LLM.FinishReasonDetails" });
 export const StepFinish = Schema.Struct({
     type: Schema.tag("step-finish"),
     index: Schema.Number,
-    reason: FinishReason,
+    reason: FinishReasonDetails,
     usage: Schema.optional(Usage),
     providerMetadata: Schema.optional(ProviderMetadata),
 }).annotate({ identifier: "LLM.Event.StepFinish" });
 export const Finish = Schema.Struct({
     type: Schema.tag("finish"),
-    reason: FinishReason,
+    reason: FinishReasonDetails,
     usage: Schema.optional(Usage),
     providerMetadata: Schema.optional(ProviderMetadata),
 }).annotate({ identifier: "LLM.Event.Finish" });
@@ -290,7 +294,7 @@ const appendEvent = (state, event) => {
         return {
             ...state,
             events,
-            finishReason: state.finishReason ?? "error",
+            finishReason: state.finishReason ?? { normalized: "error" },
         };
     }
     return {
@@ -456,7 +460,7 @@ export class LLMResponse extends Schema.Class("LLM.Response")({
     message: Message,
     events: Schema.Array(LLMEvent),
     usage: Schema.optional(Usage),
-    finishReason: FinishReason,
+    finishReason: FinishReasonDetails,
 }) {
     /** Concatenated assistant text assembled from streamed `text-delta` events. */
     get text() {

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
-  "version": "0.0.0-next-16093",
+  "version": "0.0.0-next-16094",
   "name": "@opencode-ai/ai",
   "type": "module",
   "license": "MIT",
@@ -26,7 +26,7 @@
   "devDependencies": {
     "@clack/prompts": "1.0.0-alpha.1",
     "@effect/platform-node": "4.0.0-beta.98",
-    "@opencode-ai/http-recorder": "0.0.0-next-16093",
+    "@opencode-ai/http-recorder": "0.0.0-next-16094",
     "@tsconfig/bun": "1.0.9",
     "@types/bun": "1.3.13",
     "@typescript/native-preview": "7.0.0-dev.20251207.1",
@@ -35,7 +35,7 @@
   "dependencies": {
     "@smithy/eventstream-codec": "4.2.14",
     "@smithy/util-utf8": "4.2.2",
-    "@opencode-ai/schema": "0.0.0-next-16093",
+    "@opencode-ai/schema": "0.0.0-next-16094",
     "aws4fetch": "1.0.20",
     "effect": "4.0.0-beta.98",
     "google-auth-library": "10.5.0"