npm - @opencode-ai/ai - Versions diffs - 0.0.0-next-16255 → 0.0.0-next-16274 - Mend

@opencode-ai/ai 0.0.0-next-16255 → 0.0.0-next-16274

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 (42) hide show

package/dist/llm.d.ts +60 -60
package/dist/protocols/anthropic-messages.d.ts +303 -303
package/dist/protocols/anthropic-messages.js +1 -0
package/dist/protocols/bedrock-converse.d.ts +246 -242
package/dist/protocols/gemini.d.ts +136 -132
package/dist/protocols/gemini.js +1 -0
package/dist/protocols/open-responses.d.ts +232 -232
package/dist/protocols/openai-chat.d.ts +147 -141
package/dist/protocols/openai-chat.js +1 -0
package/dist/protocols/openai-compatible-chat.d.ts +48 -46
package/dist/protocols/openai-compatible-responses.d.ts +56 -56
package/dist/protocols/openai-responses.d.ts +388 -388
package/dist/protocols/shared.d.ts +5 -4
package/dist/protocols/shared.js +1 -0
package/dist/protocols/utils/bedrock-media.d.ts +10 -10
package/dist/protocols/utils/tool-stream.d.ts +180 -180
package/dist/providers/amazon-bedrock.d.ts +109 -107
package/dist/providers/anthropic-compatible.d.ts +145 -145
package/dist/providers/anthropic.d.ts +145 -145
package/dist/providers/azure.d.ts +112 -110
package/dist/providers/cloudflare.d.ts +144 -138
package/dist/providers/github-copilot.d.ts +112 -110
package/dist/providers/google-vertex-chat.d.ts +48 -46
package/dist/providers/google-vertex-messages.d.ts +145 -146
package/dist/providers/google-vertex-responses.d.ts +56 -56
package/dist/providers/google-vertex.d.ts +52 -50
package/dist/providers/google.d.ts +52 -50
package/dist/providers/openai-compatible-responses.d.ts +56 -56
package/dist/providers/openai-compatible.d.ts +48 -46
package/dist/providers/openai.d.ts +176 -174
package/dist/providers/openrouter.d.ts +147 -141
package/dist/providers/xai.d.ts +112 -110
package/dist/route/client.d.ts +60 -60
package/dist/schema/errors.d.ts +2 -6
package/dist/schema/errors.js +2 -5
package/dist/schema/events.d.ts +1117 -1115
package/dist/schema/messages.d.ts +9 -9
package/dist/schema/messages.js +3 -4
package/dist/tool-runtime.js +1 -1
package/dist/tool.d.ts +5 -4
package/dist/tool.js +1 -0
package/package.json +5 -5

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

@@ -171,7 +171,7 @@ export declare const ToolResult: Schema.Struct<{
             readonly type: Schema.Literal<"file">;
             readonly uri: Schema.String;
             readonly mime: Schema.String;
-            readonly name: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+            readonly name: Schema.optional<Schema.String>;
         }>]>>;
     }>]> & {
         is: (value: unknown) => value is ToolResultValue;
@@ -186,10 +186,10 @@ export declare const ToolResult: Schema.Struct<{
             readonly type: Schema.Literal<"file">;
             readonly uri: Schema.String;
             readonly mime: Schema.String;
-            readonly name: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+            readonly name: Schema.optional<Schema.String>;
         }>]>>;
     }> & {
-        make: (structured: unknown, content?: ReadonlyArray<import("@opencode-ai/schema/llm").ToolContent>) => ToolOutput;
+        make: (structured: unknown, content?: ReadonlyArray<import("@opencode-ai/schema/tool").Content>) => ToolOutput;
         fromResultValue: (result: ToolResultValue) => ToolOutput | undefined;
         toResultValue: (output: ToolOutput) => ToolResultValue;
     }>;
@@ -318,7 +318,7 @@ declare const llmEventTagged: Schema.toTaggedUnion<"type", readonly [Schema.Stru
             readonly type: Schema.Literal<"file">;
             readonly uri: Schema.String;
             readonly mime: Schema.String;
-            readonly name: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+            readonly name: Schema.optional<Schema.String>;
         }>]>>;
     }>]> & {
         is: (value: unknown) => value is ToolResultValue;
@@ -333,10 +333,10 @@ declare const llmEventTagged: Schema.toTaggedUnion<"type", readonly [Schema.Stru
             readonly type: Schema.Literal<"file">;
             readonly uri: Schema.String;
             readonly mime: Schema.String;
-            readonly name: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+            readonly name: Schema.optional<Schema.String>;
         }>]>>;
     }> & {
-        make: (structured: unknown, content?: ReadonlyArray<import("@opencode-ai/schema/llm").ToolContent>) => ToolOutput;
+        make: (structured: unknown, content?: ReadonlyArray<import("@opencode-ai/schema/tool").Content>) => ToolOutput;
         fromResultValue: (result: ToolResultValue) => ToolOutput | undefined;
         toResultValue: (output: ToolOutput) => ToolResultValue;
     }>;
@@ -466,7 +466,7 @@ export declare const LLMEvent: Schema.Union<readonly [Schema.Struct<{
             readonly type: Schema.Literal<"file">;
             readonly uri: Schema.String;
             readonly mime: Schema.String;
-            readonly name: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+            readonly name: Schema.optional<Schema.String>;
         }>]>>;
     }>]> & {
         is: (value: unknown) => value is ToolResultValue;
@@ -481,10 +481,10 @@ export declare const LLMEvent: Schema.Union<readonly [Schema.Struct<{
             readonly type: Schema.Literal<"file">;
             readonly uri: Schema.String;
             readonly mime: Schema.String;
-            readonly name: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+            readonly name: Schema.optional<Schema.String>;
         }>]>>;
     }> & {
-        make: (structured: unknown, content?: ReadonlyArray<import("@opencode-ai/schema/llm").ToolContent>) => ToolOutput;
+        make: (structured: unknown, content?: ReadonlyArray<import("@opencode-ai/schema/tool").Content>) => ToolOutput;
         fromResultValue: (result: ToolResultValue) => ToolOutput | undefined;
         toResultValue: (output: ToolOutput) => ToolResultValue;
     }>;
@@ -520,6 +520,7 @@ export declare const LLMEvent: Schema.Union<readonly [Schema.Struct<{
     readonly classification: Schema.optional<Schema.Literal<"context-overflow">>;
     readonly providerMetadata: Schema.optional<Schema.$Record<Schema.String, Schema.$Record<Schema.String, Schema.Unknown>>>;
 }>]> & {
+    readonly discriminants: readonly ["step-start", "text-start", "text-delta", "text-end", "reasoning-start", "reasoning-delta", "reasoning-end", "tool-input-start", "tool-input-delta", "tool-input-end", "tool-input-error", "tool-call", "tool-result", "tool-error", "step-finish", "finish", "provider-error"];
     readonly cases: {
         "step-start": Schema.Struct<{
             readonly type: Schema.tag<"step-start">;
@@ -612,7 +613,7 @@ export declare const LLMEvent: Schema.Union<readonly [Schema.Struct<{
                     readonly type: Schema.Literal<"file">;
                     readonly uri: Schema.String;
                     readonly mime: Schema.String;
-                    readonly name: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+                    readonly name: Schema.optional<Schema.String>;
                 }>]>>;
             }>]> & {
                 is: (value: unknown) => value is ToolResultValue;
@@ -627,10 +628,10 @@ export declare const LLMEvent: Schema.Union<readonly [Schema.Struct<{
                     readonly type: Schema.Literal<"file">;
                     readonly uri: Schema.String;
                     readonly mime: Schema.String;
-                    readonly name: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+                    readonly name: Schema.optional<Schema.String>;
                 }>]>>;
             }> & {
-                make: (structured: unknown, content?: ReadonlyArray<import("@opencode-ai/schema/llm").ToolContent>) => ToolOutput;
+                make: (structured: unknown, content?: ReadonlyArray<import("@opencode-ai/schema/tool").Content>) => ToolOutput;
                 fromResultValue: (result: ToolResultValue) => ToolOutput | undefined;
                 toResultValue: (output: ToolOutput) => ToolResultValue;
             }>;
@@ -671,92 +672,92 @@ export declare const LLMEvent: Schema.Union<readonly [Schema.Struct<{
             readonly providerMetadata: Schema.optional<Schema.$Record<Schema.String, Schema.$Record<Schema.String, Schema.Unknown>>>;
         }>;
     };
-    readonly isAnyOf: <const Keys>(keys: readonly Keys[]) => (value: Schema.Struct.ReadonlySide<{
-        readonly type: Schema.tag<"step-start">;
-        readonly index: Schema.Number;
-    }, "Type"> | {
-        readonly type: "text-start";
+    readonly isAnyOf: <const Keys>(keys: readonly Keys[]) => (value: {
+        readonly type: "step-start";
+        readonly index: number;
+    } | {
         readonly id: string;
+        readonly type: "text-start";
         readonly providerMetadata?: {
             readonly [x: string]: {
                 readonly [x: string]: unknown;
             };
         } | undefined;
     } | {
+        readonly id: string;
         readonly type: "text-delta";
         readonly text: string;
-        readonly id: string;
         readonly providerMetadata?: {
             readonly [x: string]: {
                 readonly [x: string]: unknown;
             };
         } | undefined;
     } | {
-        readonly type: "text-end";
         readonly id: string;
+        readonly type: "text-end";
         readonly providerMetadata?: {
             readonly [x: string]: {
                 readonly [x: string]: unknown;
             };
         } | undefined;
     } | {
-        readonly type: "reasoning-start";
         readonly id: string;
+        readonly type: "reasoning-start";
         readonly providerMetadata?: {
             readonly [x: string]: {
                 readonly [x: string]: unknown;
             };
         } | undefined;
     } | {
+        readonly id: string;
         readonly type: "reasoning-delta";
         readonly text: string;
-        readonly id: string;
         readonly providerMetadata?: {
             readonly [x: string]: {
                 readonly [x: string]: unknown;
             };
         } | undefined;
     } | {
-        readonly type: "reasoning-end";
         readonly id: string;
+        readonly type: "reasoning-end";
         readonly providerMetadata?: {
             readonly [x: string]: {
                 readonly [x: string]: unknown;
             };
         } | undefined;
     } | {
+        readonly id: string;
         readonly type: "tool-input-start";
         readonly name: string;
-        readonly id: string;
         readonly providerMetadata?: {
             readonly [x: string]: {
                 readonly [x: string]: unknown;
             };
         } | undefined;
         readonly providerExecuted?: boolean | undefined;
-    } | Schema.Struct.ReadonlySide<{
-        readonly type: Schema.tag<"tool-input-delta">;
-        readonly id: Schema.String;
-        readonly name: Schema.String;
-        readonly text: Schema.String;
-    }, "Type"> | {
-        readonly type: "tool-input-end";
+    } | {
+        readonly type: "tool-input-delta";
+        readonly id: string;
         readonly name: string;
+        readonly text: string;
+    } | {
         readonly id: string;
+        readonly type: "tool-input-end";
+        readonly name: string;
         readonly providerMetadata?: {
             readonly [x: string]: {
                 readonly [x: string]: unknown;
             };
         } | undefined;
-    } | Schema.Struct.ReadonlySide<{
-        readonly type: Schema.tag<"tool-input-error">;
-        readonly id: Schema.String;
-        readonly name: Schema.String;
-        readonly raw: Schema.String;
-    }, "Type"> | {
-        readonly type: "tool-call";
+    } | {
+        readonly type: "tool-input-error";
+        readonly id: string;
         readonly name: string;
+        readonly raw: string;
+    } | {
         readonly id: string;
+        readonly type: "tool-call";
+        readonly name: string;
         readonly input: unknown;
         readonly providerMetadata?: {
             readonly [x: string]: {
@@ -765,52 +766,52 @@ export declare const LLMEvent: Schema.Union<readonly [Schema.Struct<{
         } | undefined;
         readonly providerExecuted?: boolean | undefined;
     } | {
+        readonly id: string;
         readonly type: "tool-result";
         readonly name: string;
-        readonly id: string;
-        readonly result: Schema.Struct.ReadonlySide<{
-            readonly type: Schema.Literal<"json">;
-            readonly value: Schema.Unknown;
-        }, "Type"> | Schema.Struct.ReadonlySide<{
-            readonly type: Schema.Literal<"text">;
-            readonly value: Schema.Unknown;
-        }, "Type"> | Schema.Struct.ReadonlySide<{
-            readonly type: Schema.Literal<"error">;
-            readonly value: Schema.Unknown;
-        }, "Type"> | Schema.Struct.ReadonlySide<{
-            readonly type: Schema.Literal<"content">;
-            readonly value: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
-                readonly type: Schema.Literal<"text">;
-                readonly text: Schema.String;
-            }>, Schema.Struct<{
-                readonly type: Schema.Literal<"file">;
-                readonly uri: Schema.String;
-                readonly mime: Schema.String;
-                readonly name: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
-            }>]>>;
-        }, "Type">;
+        readonly result: {
+            readonly type: "json";
+            readonly value: unknown;
+        } | {
+            readonly type: "text";
+            readonly value: unknown;
+        } | {
+            readonly type: "error";
+            readonly value: unknown;
+        } | {
+            readonly type: "content";
+            readonly value: readonly ({
+                readonly type: "text";
+                readonly text: string;
+            } | {
+                readonly type: "file";
+                readonly uri: string;
+                readonly mime: string;
+                readonly name?: string | undefined;
+            })[];
+        };
+        readonly output?: {
+            readonly structured: unknown;
+            readonly content: readonly ({
+                readonly type: "text";
+                readonly text: string;
+            } | {
+                readonly type: "file";
+                readonly uri: string;
+                readonly mime: string;
+                readonly name?: string | undefined;
+            })[];
+        } | undefined;
         readonly providerMetadata?: {
             readonly [x: string]: {
                 readonly [x: string]: unknown;
             };
         } | undefined;
         readonly providerExecuted?: boolean | undefined;
-        readonly output?: Schema.Struct.ReadonlySide<{
-            readonly structured: Schema.Unknown;
-            readonly content: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
-                readonly type: Schema.Literal<"text">;
-                readonly text: Schema.String;
-            }>, Schema.Struct<{
-                readonly type: Schema.Literal<"file">;
-                readonly uri: Schema.String;
-                readonly mime: Schema.String;
-                readonly name: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
-            }>]>>;
-        }, "Type"> | undefined;
     } | {
+        readonly id: string;
         readonly type: "tool-error";
         readonly name: string;
-        readonly id: string;
         readonly message: string;
         readonly error?: unknown;
         readonly providerMetadata?: {
@@ -852,14 +853,14 @@ export declare const LLMEvent: Schema.Union<readonly [Schema.Struct<{
             };
         } | undefined;
         readonly classification?: "context-overflow" | undefined;
-    }) => value is Extract<Schema.Struct.ReadonlySide<{
-        readonly type: Schema.tag<"step-start">;
-        readonly index: Schema.Number;
-    }, "Type">, {
+    }) => value is Extract<{
+        readonly type: "step-start";
+        readonly index: number;
+    }, {
         readonly type: Keys;
     }> | Extract<{
-        readonly type: "text-start";
         readonly id: string;
+        readonly type: "text-start";
         readonly providerMetadata?: {
             readonly [x: string]: {
                 readonly [x: string]: unknown;
@@ -868,9 +869,9 @@ export declare const LLMEvent: Schema.Union<readonly [Schema.Struct<{
     }, {
         readonly type: Keys;
     }> | Extract<{
+        readonly id: string;
         readonly type: "text-delta";
         readonly text: string;
-        readonly id: string;
         readonly providerMetadata?: {
             readonly [x: string]: {
                 readonly [x: string]: unknown;
@@ -879,8 +880,8 @@ export declare const LLMEvent: Schema.Union<readonly [Schema.Struct<{
     }, {
         readonly type: Keys;
     }> | Extract<{
-        readonly type: "text-end";
         readonly id: string;
+        readonly type: "text-end";
         readonly providerMetadata?: {
             readonly [x: string]: {
                 readonly [x: string]: unknown;
@@ -889,8 +890,8 @@ export declare const LLMEvent: Schema.Union<readonly [Schema.Struct<{
     }, {
         readonly type: Keys;
     }> | Extract<{
-        readonly type: "reasoning-start";
         readonly id: string;
+        readonly type: "reasoning-start";
         readonly providerMetadata?: {
             readonly [x: string]: {
                 readonly [x: string]: unknown;
@@ -899,9 +900,9 @@ export declare const LLMEvent: Schema.Union<readonly [Schema.Struct<{
     }, {
         readonly type: Keys;
     }> | Extract<{
+        readonly id: string;
         readonly type: "reasoning-delta";
         readonly text: string;
-        readonly id: string;
         readonly providerMetadata?: {
             readonly [x: string]: {
                 readonly [x: string]: unknown;
@@ -910,8 +911,8 @@ export declare const LLMEvent: Schema.Union<readonly [Schema.Struct<{
     }, {
         readonly type: Keys;
     }> | Extract<{
-        readonly type: "reasoning-end";
         readonly id: string;
+        readonly type: "reasoning-end";
         readonly providerMetadata?: {
             readonly [x: string]: {
                 readonly [x: string]: unknown;
@@ -920,9 +921,9 @@ export declare const LLMEvent: Schema.Union<readonly [Schema.Struct<{
     }, {
         readonly type: Keys;
     }> | Extract<{
+        readonly id: string;
         readonly type: "tool-input-start";
         readonly name: string;
-        readonly id: string;
         readonly providerMetadata?: {
             readonly [x: string]: {
                 readonly [x: string]: unknown;
@@ -931,17 +932,17 @@ export declare const LLMEvent: Schema.Union<readonly [Schema.Struct<{
         readonly providerExecuted?: boolean | undefined;
     }, {
         readonly type: Keys;
-    }> | Extract<Schema.Struct.ReadonlySide<{
-        readonly type: Schema.tag<"tool-input-delta">;
-        readonly id: Schema.String;
-        readonly name: Schema.String;
-        readonly text: Schema.String;
-    }, "Type">, {
+    }> | Extract<{
+        readonly type: "tool-input-delta";
+        readonly id: string;
+        readonly name: string;
+        readonly text: string;
+    }, {
         readonly type: Keys;
     }> | Extract<{
+        readonly id: string;
         readonly type: "tool-input-end";
         readonly name: string;
-        readonly id: string;
         readonly providerMetadata?: {
             readonly [x: string]: {
                 readonly [x: string]: unknown;
@@ -949,17 +950,17 @@ export declare const LLMEvent: Schema.Union<readonly [Schema.Struct<{
         } | undefined;
     }, {
         readonly type: Keys;
-    }> | Extract<Schema.Struct.ReadonlySide<{
-        readonly type: Schema.tag<"tool-input-error">;
-        readonly id: Schema.String;
-        readonly name: Schema.String;
-        readonly raw: Schema.String;
-    }, "Type">, {
+    }> | Extract<{
+        readonly type: "tool-input-error";
+        readonly id: string;
+        readonly name: string;
+        readonly raw: string;
+    }, {
         readonly type: Keys;
     }> | Extract<{
+        readonly id: string;
         readonly type: "tool-call";
         readonly name: string;
-        readonly id: string;
         readonly input: unknown;
         readonly providerMetadata?: {
             readonly [x: string]: {
@@ -970,54 +971,54 @@ export declare const LLMEvent: Schema.Union<readonly [Schema.Struct<{
     }, {
         readonly type: Keys;
     }> | Extract<{
+        readonly id: string;
         readonly type: "tool-result";
         readonly name: string;
-        readonly id: string;
-        readonly result: Schema.Struct.ReadonlySide<{
-            readonly type: Schema.Literal<"json">;
-            readonly value: Schema.Unknown;
-        }, "Type"> | Schema.Struct.ReadonlySide<{
-            readonly type: Schema.Literal<"text">;
-            readonly value: Schema.Unknown;
-        }, "Type"> | Schema.Struct.ReadonlySide<{
-            readonly type: Schema.Literal<"error">;
-            readonly value: Schema.Unknown;
-        }, "Type"> | Schema.Struct.ReadonlySide<{
-            readonly type: Schema.Literal<"content">;
-            readonly value: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
-                readonly type: Schema.Literal<"text">;
-                readonly text: Schema.String;
-            }>, Schema.Struct<{
-                readonly type: Schema.Literal<"file">;
-                readonly uri: Schema.String;
-                readonly mime: Schema.String;
-                readonly name: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
-            }>]>>;
-        }, "Type">;
+        readonly result: {
+            readonly type: "json";
+            readonly value: unknown;
+        } | {
+            readonly type: "text";
+            readonly value: unknown;
+        } | {
+            readonly type: "error";
+            readonly value: unknown;
+        } | {
+            readonly type: "content";
+            readonly value: readonly ({
+                readonly type: "text";
+                readonly text: string;
+            } | {
+                readonly type: "file";
+                readonly uri: string;
+                readonly mime: string;
+                readonly name?: string | undefined;
+            })[];
+        };
+        readonly output?: {
+            readonly structured: unknown;
+            readonly content: readonly ({
+                readonly type: "text";
+                readonly text: string;
+            } | {
+                readonly type: "file";
+                readonly uri: string;
+                readonly mime: string;
+                readonly name?: string | undefined;
+            })[];
+        } | undefined;
         readonly providerMetadata?: {
             readonly [x: string]: {
                 readonly [x: string]: unknown;
             };
         } | undefined;
         readonly providerExecuted?: boolean | undefined;
-        readonly output?: Schema.Struct.ReadonlySide<{
-            readonly structured: Schema.Unknown;
-            readonly content: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
-                readonly type: Schema.Literal<"text">;
-                readonly text: Schema.String;
-            }>, Schema.Struct<{
-                readonly type: Schema.Literal<"file">;
-                readonly uri: Schema.String;
-                readonly mime: Schema.String;
-                readonly name: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
-            }>]>>;
-        }, "Type"> | undefined;
     }, {
         readonly type: Keys;
     }> | Extract<{
+        readonly id: string;
         readonly type: "tool-error";
         readonly name: string;
-        readonly id: string;
         readonly message: string;
         readonly error?: unknown;
         readonly providerMetadata?: {
@@ -1069,13 +1070,13 @@ export declare const LLMEvent: Schema.Union<readonly [Schema.Struct<{
         readonly type: Keys;
     }>;
     readonly guards: {
-        "step-start": (u: unknown) => u is Schema.Struct.ReadonlySide<{
-            readonly type: Schema.tag<"step-start">;
-            readonly index: Schema.Number;
-        }, "Type">;
+        "step-start": (u: unknown) => u is {
+            readonly type: "step-start";
+            readonly index: number;
+        };
         "text-start": (u: unknown) => u is {
-            readonly type: "text-start";
             readonly id: string;
+            readonly type: "text-start";
             readonly providerMetadata?: {
                 readonly [x: string]: {
                     readonly [x: string]: unknown;
@@ -1083,9 +1084,9 @@ export declare const LLMEvent: Schema.Union<readonly [Schema.Struct<{
             } | undefined;
         };
         "text-delta": (u: unknown) => u is {
+            readonly id: string;
             readonly type: "text-delta";
             readonly text: string;
-            readonly id: string;
             readonly providerMetadata?: {
                 readonly [x: string]: {
                     readonly [x: string]: unknown;
@@ -1093,8 +1094,8 @@ export declare const LLMEvent: Schema.Union<readonly [Schema.Struct<{
             } | undefined;
         };
         "text-end": (u: unknown) => u is {
-            readonly type: "text-end";
             readonly id: string;
+            readonly type: "text-end";
             readonly providerMetadata?: {
                 readonly [x: string]: {
                     readonly [x: string]: unknown;
@@ -1102,8 +1103,8 @@ export declare const LLMEvent: Schema.Union<readonly [Schema.Struct<{
             } | undefined;
         };
         "reasoning-start": (u: unknown) => u is {
-            readonly type: "reasoning-start";
             readonly id: string;
+            readonly type: "reasoning-start";
             readonly providerMetadata?: {
                 readonly [x: string]: {
                     readonly [x: string]: unknown;
@@ -1111,9 +1112,9 @@ export declare const LLMEvent: Schema.Union<readonly [Schema.Struct<{
             } | undefined;
         };
         "reasoning-delta": (u: unknown) => u is {
+            readonly id: string;
             readonly type: "reasoning-delta";
             readonly text: string;
-            readonly id: string;
             readonly providerMetadata?: {
                 readonly [x: string]: {
                     readonly [x: string]: unknown;
@@ -1121,8 +1122,8 @@ export declare const LLMEvent: Schema.Union<readonly [Schema.Struct<{
             } | undefined;
         };
         "reasoning-end": (u: unknown) => u is {
-            readonly type: "reasoning-end";
             readonly id: string;
+            readonly type: "reasoning-end";
             readonly providerMetadata?: {
                 readonly [x: string]: {
                     readonly [x: string]: unknown;
@@ -1130,9 +1131,9 @@ export declare const LLMEvent: Schema.Union<readonly [Schema.Struct<{
             } | undefined;
         };
         "tool-input-start": (u: unknown) => u is {
+            readonly id: string;
             readonly type: "tool-input-start";
             readonly name: string;
-            readonly id: string;
             readonly providerMetadata?: {
                 readonly [x: string]: {
                     readonly [x: string]: unknown;
@@ -1140,32 +1141,32 @@ export declare const LLMEvent: Schema.Union<readonly [Schema.Struct<{
             } | undefined;
             readonly providerExecuted?: boolean | undefined;
         };
-        "tool-input-delta": (u: unknown) => u is Schema.Struct.ReadonlySide<{
-            readonly type: Schema.tag<"tool-input-delta">;
-            readonly id: Schema.String;
-            readonly name: Schema.String;
-            readonly text: Schema.String;
-        }, "Type">;
+        "tool-input-delta": (u: unknown) => u is {
+            readonly type: "tool-input-delta";
+            readonly id: string;
+            readonly name: string;
+            readonly text: string;
+        };
         "tool-input-end": (u: unknown) => u is {
+            readonly id: string;
             readonly type: "tool-input-end";
             readonly name: string;
-            readonly id: string;
             readonly providerMetadata?: {
                 readonly [x: string]: {
                     readonly [x: string]: unknown;
                 };
             } | undefined;
         };
-        "tool-input-error": (u: unknown) => u is Schema.Struct.ReadonlySide<{
-            readonly type: Schema.tag<"tool-input-error">;
-            readonly id: Schema.String;
-            readonly name: Schema.String;
-            readonly raw: Schema.String;
-        }, "Type">;
+        "tool-input-error": (u: unknown) => u is {
+            readonly type: "tool-input-error";
+            readonly id: string;
+            readonly name: string;
+            readonly raw: string;
+        };
         "tool-call": (u: unknown) => u is {
+            readonly id: string;
             readonly type: "tool-call";
             readonly name: string;
-            readonly id: string;
             readonly input: unknown;
             readonly providerMetadata?: {
                 readonly [x: string]: {
@@ -1175,53 +1176,53 @@ export declare const LLMEvent: Schema.Union<readonly [Schema.Struct<{
             readonly providerExecuted?: boolean | undefined;
         };
         "tool-result": (u: unknown) => u is {
+            readonly id: string;
             readonly type: "tool-result";
             readonly name: string;
-            readonly id: string;
-            readonly result: Schema.Struct.ReadonlySide<{
-                readonly type: Schema.Literal<"json">;
-                readonly value: Schema.Unknown;
-            }, "Type"> | Schema.Struct.ReadonlySide<{
-                readonly type: Schema.Literal<"text">;
-                readonly value: Schema.Unknown;
-            }, "Type"> | Schema.Struct.ReadonlySide<{
-                readonly type: Schema.Literal<"error">;
-                readonly value: Schema.Unknown;
-            }, "Type"> | Schema.Struct.ReadonlySide<{
-                readonly type: Schema.Literal<"content">;
-                readonly value: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
-                    readonly type: Schema.Literal<"text">;
-                    readonly text: Schema.String;
-                }>, Schema.Struct<{
-                    readonly type: Schema.Literal<"file">;
-                    readonly uri: Schema.String;
-                    readonly mime: Schema.String;
-                    readonly name: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
-                }>]>>;
-            }, "Type">;
+            readonly result: {
+                readonly type: "json";
+                readonly value: unknown;
+            } | {
+                readonly type: "text";
+                readonly value: unknown;
+            } | {
+                readonly type: "error";
+                readonly value: unknown;
+            } | {
+                readonly type: "content";
+                readonly value: readonly ({
+                    readonly type: "text";
+                    readonly text: string;
+                } | {
+                    readonly type: "file";
+                    readonly uri: string;
+                    readonly mime: string;
+                    readonly name?: string | undefined;
+                })[];
+            };
+            readonly output?: {
+                readonly structured: unknown;
+                readonly content: readonly ({
+                    readonly type: "text";
+                    readonly text: string;
+                } | {
+                    readonly type: "file";
+                    readonly uri: string;
+                    readonly mime: string;
+                    readonly name?: string | undefined;
+                })[];
+            } | undefined;
             readonly providerMetadata?: {
                 readonly [x: string]: {
                     readonly [x: string]: unknown;
                 };
             } | undefined;
             readonly providerExecuted?: boolean | undefined;
-            readonly output?: Schema.Struct.ReadonlySide<{
-                readonly structured: Schema.Unknown;
-                readonly content: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
-                    readonly type: Schema.Literal<"text">;
-                    readonly text: Schema.String;
-                }>, Schema.Struct<{
-                    readonly type: Schema.Literal<"file">;
-                    readonly uri: Schema.String;
-                    readonly mime: Schema.String;
-                    readonly name: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
-                }>]>>;
-            }, "Type"> | undefined;
         };
         "tool-error": (u: unknown) => u is {
+            readonly id: string;
             readonly type: "tool-error";
             readonly name: string;
-            readonly id: string;
             readonly message: string;
             readonly error?: unknown;
             readonly providerMetadata?: {
@@ -1270,13 +1271,13 @@ export declare const LLMEvent: Schema.Union<readonly [Schema.Struct<{
     };
     readonly match: {
         <Cases extends {
-            "step-start": (value: Schema.Struct.ReadonlySide<{
-                readonly type: Schema.tag<"step-start">;
-                readonly index: Schema.Number;
-            }, "Type">) => any;
+            "step-start": (value: {
+                readonly type: "step-start";
+                readonly index: number;
+            }) => any;
             "text-start": (value: {
-                readonly type: "text-start";
                 readonly id: string;
+                readonly type: "text-start";
                 readonly providerMetadata?: {
                     readonly [x: string]: {
                         readonly [x: string]: unknown;
@@ -1284,9 +1285,9 @@ export declare const LLMEvent: Schema.Union<readonly [Schema.Struct<{
                 } | undefined;
             }) => any;
             "text-delta": (value: {
+                readonly id: string;
                 readonly type: "text-delta";
                 readonly text: string;
-                readonly id: string;
                 readonly providerMetadata?: {
                     readonly [x: string]: {
                         readonly [x: string]: unknown;
@@ -1294,8 +1295,8 @@ export declare const LLMEvent: Schema.Union<readonly [Schema.Struct<{
                 } | undefined;
             }) => any;
             "text-end": (value: {
-                readonly type: "text-end";
                 readonly id: string;
+                readonly type: "text-end";
                 readonly providerMetadata?: {
                     readonly [x: string]: {
                         readonly [x: string]: unknown;
@@ -1303,8 +1304,8 @@ export declare const LLMEvent: Schema.Union<readonly [Schema.Struct<{
                 } | undefined;
             }) => any;
             "reasoning-start": (value: {
-                readonly type: "reasoning-start";
                 readonly id: string;
+                readonly type: "reasoning-start";
                 readonly providerMetadata?: {
                     readonly [x: string]: {
                         readonly [x: string]: unknown;
@@ -1312,9 +1313,9 @@ export declare const LLMEvent: Schema.Union<readonly [Schema.Struct<{
                 } | undefined;
             }) => any;
             "reasoning-delta": (value: {
+                readonly id: string;
                 readonly type: "reasoning-delta";
                 readonly text: string;
-                readonly id: string;
                 readonly providerMetadata?: {
                     readonly [x: string]: {
                         readonly [x: string]: unknown;
@@ -1322,8 +1323,8 @@ export declare const LLMEvent: Schema.Union<readonly [Schema.Struct<{
                 } | undefined;
             }) => any;
             "reasoning-end": (value: {
-                readonly type: "reasoning-end";
                 readonly id: string;
+                readonly type: "reasoning-end";
                 readonly providerMetadata?: {
                     readonly [x: string]: {
                         readonly [x: string]: unknown;
@@ -1331,9 +1332,9 @@ export declare const LLMEvent: Schema.Union<readonly [Schema.Struct<{
                 } | undefined;
             }) => any;
             "tool-input-start": (value: {
+                readonly id: string;
                 readonly type: "tool-input-start";
                 readonly name: string;
-                readonly id: string;
                 readonly providerMetadata?: {
                     readonly [x: string]: {
                         readonly [x: string]: unknown;
@@ -1341,32 +1342,32 @@ export declare const LLMEvent: Schema.Union<readonly [Schema.Struct<{
                 } | undefined;
                 readonly providerExecuted?: boolean | undefined;
             }) => any;
-            "tool-input-delta": (value: Schema.Struct.ReadonlySide<{
-                readonly type: Schema.tag<"tool-input-delta">;
-                readonly id: Schema.String;
-                readonly name: Schema.String;
-                readonly text: Schema.String;
-            }, "Type">) => any;
+            "tool-input-delta": (value: {
+                readonly type: "tool-input-delta";
+                readonly id: string;
+                readonly name: string;
+                readonly text: string;
+            }) => any;
             "tool-input-end": (value: {
+                readonly id: string;
                 readonly type: "tool-input-end";
                 readonly name: string;
-                readonly id: string;
                 readonly providerMetadata?: {
                     readonly [x: string]: {
                         readonly [x: string]: unknown;
                     };
                 } | undefined;
             }) => any;
-            "tool-input-error": (value: Schema.Struct.ReadonlySide<{
-                readonly type: Schema.tag<"tool-input-error">;
-                readonly id: Schema.String;
-                readonly name: Schema.String;
-                readonly raw: Schema.String;
-            }, "Type">) => any;
+            "tool-input-error": (value: {
+                readonly type: "tool-input-error";
+                readonly id: string;
+                readonly name: string;
+                readonly raw: string;
+            }) => any;
             "tool-call": (value: {
+                readonly id: string;
                 readonly type: "tool-call";
                 readonly name: string;
-                readonly id: string;
                 readonly input: unknown;
                 readonly providerMetadata?: {
                     readonly [x: string]: {
@@ -1376,53 +1377,53 @@ export declare const LLMEvent: Schema.Union<readonly [Schema.Struct<{
                 readonly providerExecuted?: boolean | undefined;
             }) => any;
             "tool-result": (value: {
+                readonly id: string;
                 readonly type: "tool-result";
                 readonly name: string;
-                readonly id: string;
-                readonly result: Schema.Struct.ReadonlySide<{
-                    readonly type: Schema.Literal<"json">;
-                    readonly value: Schema.Unknown;
-                }, "Type"> | Schema.Struct.ReadonlySide<{
-                    readonly type: Schema.Literal<"text">;
-                    readonly value: Schema.Unknown;
-                }, "Type"> | Schema.Struct.ReadonlySide<{
-                    readonly type: Schema.Literal<"error">;
-                    readonly value: Schema.Unknown;
-                }, "Type"> | Schema.Struct.ReadonlySide<{
-                    readonly type: Schema.Literal<"content">;
-                    readonly value: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
-                        readonly type: Schema.Literal<"text">;
-                        readonly text: Schema.String;
-                    }>, Schema.Struct<{
-                        readonly type: Schema.Literal<"file">;
-                        readonly uri: Schema.String;
-                        readonly mime: Schema.String;
-                        readonly name: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
-                    }>]>>;
-                }, "Type">;
+                readonly result: {
+                    readonly type: "json";
+                    readonly value: unknown;
+                } | {
+                    readonly type: "text";
+                    readonly value: unknown;
+                } | {
+                    readonly type: "error";
+                    readonly value: unknown;
+                } | {
+                    readonly type: "content";
+                    readonly value: readonly ({
+                        readonly type: "text";
+                        readonly text: string;
+                    } | {
+                        readonly type: "file";
+                        readonly uri: string;
+                        readonly mime: string;
+                        readonly name?: string | undefined;
+                    })[];
+                };
+                readonly output?: {
+                    readonly structured: unknown;
+                    readonly content: readonly ({
+                        readonly type: "text";
+                        readonly text: string;
+                    } | {
+                        readonly type: "file";
+                        readonly uri: string;
+                        readonly mime: string;
+                        readonly name?: string | undefined;
+                    })[];
+                } | undefined;
                 readonly providerMetadata?: {
                     readonly [x: string]: {
                         readonly [x: string]: unknown;
                     };
                 } | undefined;
                 readonly providerExecuted?: boolean | undefined;
-                readonly output?: Schema.Struct.ReadonlySide<{
-                    readonly structured: Schema.Unknown;
-                    readonly content: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
-                        readonly type: Schema.Literal<"text">;
-                        readonly text: Schema.String;
-                    }>, Schema.Struct<{
-                        readonly type: Schema.Literal<"file">;
-                        readonly uri: Schema.String;
-                        readonly mime: Schema.String;
-                        readonly name: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
-                    }>]>>;
-                }, "Type"> | undefined;
             }) => any;
             "tool-error": (value: {
+                readonly id: string;
                 readonly type: "tool-error";
                 readonly name: string;
-                readonly id: string;
                 readonly message: string;
                 readonly error?: unknown;
                 readonly providerMetadata?: {
@@ -1468,92 +1469,92 @@ export declare const LLMEvent: Schema.Union<readonly [Schema.Struct<{
                 } | undefined;
                 readonly classification?: "context-overflow" | undefined;
             }) => any;
-        }>(value: Schema.Struct.ReadonlySide<{
-            readonly type: Schema.tag<"step-start">;
-            readonly index: Schema.Number;
-        }, "Type"> | {
-            readonly type: "text-start";
+        }>(value: {
+            readonly type: "step-start";
+            readonly index: number;
+        } | {
             readonly id: string;
+            readonly type: "text-start";
             readonly providerMetadata?: {
                 readonly [x: string]: {
                     readonly [x: string]: unknown;
                 };
             } | undefined;
         } | {
+            readonly id: string;
             readonly type: "text-delta";
             readonly text: string;
-            readonly id: string;
             readonly providerMetadata?: {
                 readonly [x: string]: {
                     readonly [x: string]: unknown;
                 };
             } | undefined;
         } | {
-            readonly type: "text-end";
             readonly id: string;
+            readonly type: "text-end";
             readonly providerMetadata?: {
                 readonly [x: string]: {
                     readonly [x: string]: unknown;
                 };
             } | undefined;
         } | {
-            readonly type: "reasoning-start";
             readonly id: string;
+            readonly type: "reasoning-start";
             readonly providerMetadata?: {
                 readonly [x: string]: {
                     readonly [x: string]: unknown;
                 };
             } | undefined;
         } | {
+            readonly id: string;
             readonly type: "reasoning-delta";
             readonly text: string;
-            readonly id: string;
             readonly providerMetadata?: {
                 readonly [x: string]: {
                     readonly [x: string]: unknown;
                 };
             } | undefined;
         } | {
-            readonly type: "reasoning-end";
             readonly id: string;
+            readonly type: "reasoning-end";
             readonly providerMetadata?: {
                 readonly [x: string]: {
                     readonly [x: string]: unknown;
                 };
             } | undefined;
         } | {
+            readonly id: string;
             readonly type: "tool-input-start";
             readonly name: string;
-            readonly id: string;
             readonly providerMetadata?: {
                 readonly [x: string]: {
                     readonly [x: string]: unknown;
                 };
             } | undefined;
             readonly providerExecuted?: boolean | undefined;
-        } | Schema.Struct.ReadonlySide<{
-            readonly type: Schema.tag<"tool-input-delta">;
-            readonly id: Schema.String;
-            readonly name: Schema.String;
-            readonly text: Schema.String;
-        }, "Type"> | {
-            readonly type: "tool-input-end";
+        } | {
+            readonly type: "tool-input-delta";
+            readonly id: string;
             readonly name: string;
+            readonly text: string;
+        } | {
             readonly id: string;
+            readonly type: "tool-input-end";
+            readonly name: string;
             readonly providerMetadata?: {
                 readonly [x: string]: {
                     readonly [x: string]: unknown;
                 };
             } | undefined;
-        } | Schema.Struct.ReadonlySide<{
-            readonly type: Schema.tag<"tool-input-error">;
-            readonly id: Schema.String;
-            readonly name: Schema.String;
-            readonly raw: Schema.String;
-        }, "Type"> | {
-            readonly type: "tool-call";
+        } | {
+            readonly type: "tool-input-error";
+            readonly id: string;
             readonly name: string;
+            readonly raw: string;
+        } | {
             readonly id: string;
+            readonly type: "tool-call";
+            readonly name: string;
             readonly input: unknown;
             readonly providerMetadata?: {
                 readonly [x: string]: {
@@ -1562,52 +1563,52 @@ export declare const LLMEvent: Schema.Union<readonly [Schema.Struct<{
             } | undefined;
             readonly providerExecuted?: boolean | undefined;
         } | {
+            readonly id: string;
             readonly type: "tool-result";
             readonly name: string;
-            readonly id: string;
-            readonly result: Schema.Struct.ReadonlySide<{
-                readonly type: Schema.Literal<"json">;
-                readonly value: Schema.Unknown;
-            }, "Type"> | Schema.Struct.ReadonlySide<{
-                readonly type: Schema.Literal<"text">;
-                readonly value: Schema.Unknown;
-            }, "Type"> | Schema.Struct.ReadonlySide<{
-                readonly type: Schema.Literal<"error">;
-                readonly value: Schema.Unknown;
-            }, "Type"> | Schema.Struct.ReadonlySide<{
-                readonly type: Schema.Literal<"content">;
-                readonly value: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
-                    readonly type: Schema.Literal<"text">;
-                    readonly text: Schema.String;
-                }>, Schema.Struct<{
-                    readonly type: Schema.Literal<"file">;
-                    readonly uri: Schema.String;
-                    readonly mime: Schema.String;
-                    readonly name: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
-                }>]>>;
-            }, "Type">;
+            readonly result: {
+                readonly type: "json";
+                readonly value: unknown;
+            } | {
+                readonly type: "text";
+                readonly value: unknown;
+            } | {
+                readonly type: "error";
+                readonly value: unknown;
+            } | {
+                readonly type: "content";
+                readonly value: readonly ({
+                    readonly type: "text";
+                    readonly text: string;
+                } | {
+                    readonly type: "file";
+                    readonly uri: string;
+                    readonly mime: string;
+                    readonly name?: string | undefined;
+                })[];
+            };
+            readonly output?: {
+                readonly structured: unknown;
+                readonly content: readonly ({
+                    readonly type: "text";
+                    readonly text: string;
+                } | {
+                    readonly type: "file";
+                    readonly uri: string;
+                    readonly mime: string;
+                    readonly name?: string | undefined;
+                })[];
+            } | undefined;
             readonly providerMetadata?: {
                 readonly [x: string]: {
                     readonly [x: string]: unknown;
                 };
             } | undefined;
             readonly providerExecuted?: boolean | undefined;
-            readonly output?: Schema.Struct.ReadonlySide<{
-                readonly structured: Schema.Unknown;
-                readonly content: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
-                    readonly type: Schema.Literal<"text">;
-                    readonly text: Schema.String;
-                }>, Schema.Struct<{
-                    readonly type: Schema.Literal<"file">;
-                    readonly uri: Schema.String;
-                    readonly mime: Schema.String;
-                    readonly name: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
-                }>]>>;
-            }, "Type"> | undefined;
         } | {
+            readonly id: string;
             readonly type: "tool-error";
             readonly name: string;
-            readonly id: string;
             readonly message: string;
             readonly error?: unknown;
             readonly providerMetadata?: {
@@ -1651,13 +1652,13 @@ export declare const LLMEvent: Schema.Union<readonly [Schema.Struct<{
             readonly classification?: "context-overflow" | undefined;
         }, cases: Cases): Cases[keyof Cases] extends (value: any) => infer R ? import("effect/Unify").Unify<R> : never;
         <Cases extends {
-            "step-start": (value: Schema.Struct.ReadonlySide<{
-                readonly type: Schema.tag<"step-start">;
-                readonly index: Schema.Number;
-            }, "Type">) => any;
+            "step-start": (value: {
+                readonly type: "step-start";
+                readonly index: number;
+            }) => any;
             "text-start": (value: {
-                readonly type: "text-start";
                 readonly id: string;
+                readonly type: "text-start";
                 readonly providerMetadata?: {
                     readonly [x: string]: {
                         readonly [x: string]: unknown;
@@ -1665,9 +1666,9 @@ export declare const LLMEvent: Schema.Union<readonly [Schema.Struct<{
                 } | undefined;
             }) => any;
             "text-delta": (value: {
+                readonly id: string;
                 readonly type: "text-delta";
                 readonly text: string;
-                readonly id: string;
                 readonly providerMetadata?: {
                     readonly [x: string]: {
                         readonly [x: string]: unknown;
@@ -1675,8 +1676,8 @@ export declare const LLMEvent: Schema.Union<readonly [Schema.Struct<{
                 } | undefined;
             }) => any;
             "text-end": (value: {
-                readonly type: "text-end";
                 readonly id: string;
+                readonly type: "text-end";
                 readonly providerMetadata?: {
                     readonly [x: string]: {
                         readonly [x: string]: unknown;
@@ -1684,8 +1685,8 @@ export declare const LLMEvent: Schema.Union<readonly [Schema.Struct<{
                 } | undefined;
             }) => any;
             "reasoning-start": (value: {
-                readonly type: "reasoning-start";
                 readonly id: string;
+                readonly type: "reasoning-start";
                 readonly providerMetadata?: {
                     readonly [x: string]: {
                         readonly [x: string]: unknown;
@@ -1693,9 +1694,9 @@ export declare const LLMEvent: Schema.Union<readonly [Schema.Struct<{
                 } | undefined;
             }) => any;
             "reasoning-delta": (value: {
+                readonly id: string;
                 readonly type: "reasoning-delta";
                 readonly text: string;
-                readonly id: string;
                 readonly providerMetadata?: {
                     readonly [x: string]: {
                         readonly [x: string]: unknown;
@@ -1703,8 +1704,8 @@ export declare const LLMEvent: Schema.Union<readonly [Schema.Struct<{
                 } | undefined;
             }) => any;
             "reasoning-end": (value: {
-                readonly type: "reasoning-end";
                 readonly id: string;
+                readonly type: "reasoning-end";
                 readonly providerMetadata?: {
                     readonly [x: string]: {
                         readonly [x: string]: unknown;
@@ -1712,9 +1713,9 @@ export declare const LLMEvent: Schema.Union<readonly [Schema.Struct<{
                 } | undefined;
             }) => any;
             "tool-input-start": (value: {
+                readonly id: string;
                 readonly type: "tool-input-start";
                 readonly name: string;
-                readonly id: string;
                 readonly providerMetadata?: {
                     readonly [x: string]: {
                         readonly [x: string]: unknown;
@@ -1722,32 +1723,32 @@ export declare const LLMEvent: Schema.Union<readonly [Schema.Struct<{
                 } | undefined;
                 readonly providerExecuted?: boolean | undefined;
             }) => any;
-            "tool-input-delta": (value: Schema.Struct.ReadonlySide<{
-                readonly type: Schema.tag<"tool-input-delta">;
-                readonly id: Schema.String;
-                readonly name: Schema.String;
-                readonly text: Schema.String;
-            }, "Type">) => any;
+            "tool-input-delta": (value: {
+                readonly type: "tool-input-delta";
+                readonly id: string;
+                readonly name: string;
+                readonly text: string;
+            }) => any;
             "tool-input-end": (value: {
+                readonly id: string;
                 readonly type: "tool-input-end";
                 readonly name: string;
-                readonly id: string;
                 readonly providerMetadata?: {
                     readonly [x: string]: {
                         readonly [x: string]: unknown;
                     };
                 } | undefined;
             }) => any;
-            "tool-input-error": (value: Schema.Struct.ReadonlySide<{
-                readonly type: Schema.tag<"tool-input-error">;
-                readonly id: Schema.String;
-                readonly name: Schema.String;
-                readonly raw: Schema.String;
-            }, "Type">) => any;
+            "tool-input-error": (value: {
+                readonly type: "tool-input-error";
+                readonly id: string;
+                readonly name: string;
+                readonly raw: string;
+            }) => any;
             "tool-call": (value: {
+                readonly id: string;
                 readonly type: "tool-call";
                 readonly name: string;
-                readonly id: string;
                 readonly input: unknown;
                 readonly providerMetadata?: {
                     readonly [x: string]: {
@@ -1757,53 +1758,53 @@ export declare const LLMEvent: Schema.Union<readonly [Schema.Struct<{
                 readonly providerExecuted?: boolean | undefined;
             }) => any;
             "tool-result": (value: {
+                readonly id: string;
                 readonly type: "tool-result";
                 readonly name: string;
-                readonly id: string;
-                readonly result: Schema.Struct.ReadonlySide<{
-                    readonly type: Schema.Literal<"json">;
-                    readonly value: Schema.Unknown;
-                }, "Type"> | Schema.Struct.ReadonlySide<{
-                    readonly type: Schema.Literal<"text">;
-                    readonly value: Schema.Unknown;
-                }, "Type"> | Schema.Struct.ReadonlySide<{
-                    readonly type: Schema.Literal<"error">;
-                    readonly value: Schema.Unknown;
-                }, "Type"> | Schema.Struct.ReadonlySide<{
-                    readonly type: Schema.Literal<"content">;
-                    readonly value: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
-                        readonly type: Schema.Literal<"text">;
-                        readonly text: Schema.String;
-                    }>, Schema.Struct<{
-                        readonly type: Schema.Literal<"file">;
-                        readonly uri: Schema.String;
-                        readonly mime: Schema.String;
-                        readonly name: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
-                    }>]>>;
-                }, "Type">;
+                readonly result: {
+                    readonly type: "json";
+                    readonly value: unknown;
+                } | {
+                    readonly type: "text";
+                    readonly value: unknown;
+                } | {
+                    readonly type: "error";
+                    readonly value: unknown;
+                } | {
+                    readonly type: "content";
+                    readonly value: readonly ({
+                        readonly type: "text";
+                        readonly text: string;
+                    } | {
+                        readonly type: "file";
+                        readonly uri: string;
+                        readonly mime: string;
+                        readonly name?: string | undefined;
+                    })[];
+                };
+                readonly output?: {
+                    readonly structured: unknown;
+                    readonly content: readonly ({
+                        readonly type: "text";
+                        readonly text: string;
+                    } | {
+                        readonly type: "file";
+                        readonly uri: string;
+                        readonly mime: string;
+                        readonly name?: string | undefined;
+                    })[];
+                } | undefined;
                 readonly providerMetadata?: {
                     readonly [x: string]: {
                         readonly [x: string]: unknown;
                     };
                 } | undefined;
                 readonly providerExecuted?: boolean | undefined;
-                readonly output?: Schema.Struct.ReadonlySide<{
-                    readonly structured: Schema.Unknown;
-                    readonly content: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
-                        readonly type: Schema.Literal<"text">;
-                        readonly text: Schema.String;
-                    }>, Schema.Struct<{
-                        readonly type: Schema.Literal<"file">;
-                        readonly uri: Schema.String;
-                        readonly mime: Schema.String;
-                        readonly name: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
-                    }>]>>;
-                }, "Type"> | undefined;
             }) => any;
             "tool-error": (value: {
+                readonly id: string;
                 readonly type: "tool-error";
                 readonly name: string;
-                readonly id: string;
                 readonly message: string;
                 readonly error?: unknown;
                 readonly providerMetadata?: {
@@ -1849,146 +1850,146 @@ export declare const LLMEvent: Schema.Union<readonly [Schema.Struct<{
                 } | undefined;
                 readonly classification?: "context-overflow" | undefined;
             }) => any;
-        }>(cases: Cases): (value: Schema.Struct.ReadonlySide<{
-            readonly type: Schema.tag<"step-start">;
-            readonly index: Schema.Number;
-        }, "Type"> | {
-            readonly type: "text-start";
+        }>(cases: Cases): (value: {
+            readonly type: "step-start";
+            readonly index: number;
+        } | {
             readonly id: string;
+            readonly type: "text-start";
             readonly providerMetadata?: {
                 readonly [x: string]: {
                     readonly [x: string]: unknown;
                 };
             } | undefined;
         } | {
+            readonly id: string;
             readonly type: "text-delta";
             readonly text: string;
-            readonly id: string;
             readonly providerMetadata?: {
                 readonly [x: string]: {
                     readonly [x: string]: unknown;
                 };
             } | undefined;
         } | {
-            readonly type: "text-end";
             readonly id: string;
+            readonly type: "text-end";
             readonly providerMetadata?: {
                 readonly [x: string]: {
                     readonly [x: string]: unknown;
                 };
             } | undefined;
         } | {
-            readonly type: "reasoning-start";
             readonly id: string;
+            readonly type: "reasoning-start";
             readonly providerMetadata?: {
                 readonly [x: string]: {
                     readonly [x: string]: unknown;
                 };
             } | undefined;
         } | {
+            readonly id: string;
             readonly type: "reasoning-delta";
             readonly text: string;
-            readonly id: string;
             readonly providerMetadata?: {
                 readonly [x: string]: {
                     readonly [x: string]: unknown;
                 };
             } | undefined;
         } | {
-            readonly type: "reasoning-end";
             readonly id: string;
+            readonly type: "reasoning-end";
             readonly providerMetadata?: {
                 readonly [x: string]: {
                     readonly [x: string]: unknown;
                 };
             } | undefined;
         } | {
+            readonly id: string;
             readonly type: "tool-input-start";
             readonly name: string;
-            readonly id: string;
             readonly providerMetadata?: {
                 readonly [x: string]: {
                     readonly [x: string]: unknown;
                 };
             } | undefined;
             readonly providerExecuted?: boolean | undefined;
-        } | Schema.Struct.ReadonlySide<{
-            readonly type: Schema.tag<"tool-input-delta">;
-            readonly id: Schema.String;
-            readonly name: Schema.String;
-            readonly text: Schema.String;
-        }, "Type"> | {
-            readonly type: "tool-input-end";
+        } | {
+            readonly type: "tool-input-delta";
+            readonly id: string;
             readonly name: string;
+            readonly text: string;
+        } | {
             readonly id: string;
+            readonly type: "tool-input-end";
+            readonly name: string;
             readonly providerMetadata?: {
                 readonly [x: string]: {
                     readonly [x: string]: unknown;
                 };
             } | undefined;
-        } | Schema.Struct.ReadonlySide<{
-            readonly type: Schema.tag<"tool-input-error">;
-            readonly id: Schema.String;
-            readonly name: Schema.String;
-            readonly raw: Schema.String;
-        }, "Type"> | {
-            readonly type: "tool-call";
+        } | {
+            readonly type: "tool-input-error";
+            readonly id: string;
             readonly name: string;
+            readonly raw: string;
+        } | {
             readonly id: string;
+            readonly type: "tool-call";
+            readonly name: string;
             readonly input: unknown;
             readonly providerMetadata?: {
                 readonly [x: string]: {
                     readonly [x: string]: unknown;
                 };
             } | undefined;
-            readonly providerExecuted?: boolean | undefined;
-        } | {
-            readonly type: "tool-result";
-            readonly name: string;
-            readonly id: string;
-            readonly result: Schema.Struct.ReadonlySide<{
-                readonly type: Schema.Literal<"json">;
-                readonly value: Schema.Unknown;
-            }, "Type"> | Schema.Struct.ReadonlySide<{
-                readonly type: Schema.Literal<"text">;
-                readonly value: Schema.Unknown;
-            }, "Type"> | Schema.Struct.ReadonlySide<{
-                readonly type: Schema.Literal<"error">;
-                readonly value: Schema.Unknown;
-            }, "Type"> | Schema.Struct.ReadonlySide<{
-                readonly type: Schema.Literal<"content">;
-                readonly value: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
-                    readonly type: Schema.Literal<"text">;
-                    readonly text: Schema.String;
-                }>, Schema.Struct<{
-                    readonly type: Schema.Literal<"file">;
-                    readonly uri: Schema.String;
-                    readonly mime: Schema.String;
-                    readonly name: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
-                }>]>>;
-            }, "Type">;
+            readonly providerExecuted?: boolean | undefined;
+        } | {
+            readonly id: string;
+            readonly type: "tool-result";
+            readonly name: string;
+            readonly result: {
+                readonly type: "json";
+                readonly value: unknown;
+            } | {
+                readonly type: "text";
+                readonly value: unknown;
+            } | {
+                readonly type: "error";
+                readonly value: unknown;
+            } | {
+                readonly type: "content";
+                readonly value: readonly ({
+                    readonly type: "text";
+                    readonly text: string;
+                } | {
+                    readonly type: "file";
+                    readonly uri: string;
+                    readonly mime: string;
+                    readonly name?: string | undefined;
+                })[];
+            };
+            readonly output?: {
+                readonly structured: unknown;
+                readonly content: readonly ({
+                    readonly type: "text";
+                    readonly text: string;
+                } | {
+                    readonly type: "file";
+                    readonly uri: string;
+                    readonly mime: string;
+                    readonly name?: string | undefined;
+                })[];
+            } | undefined;
             readonly providerMetadata?: {
                 readonly [x: string]: {
                     readonly [x: string]: unknown;
                 };
             } | undefined;
             readonly providerExecuted?: boolean | undefined;
-            readonly output?: Schema.Struct.ReadonlySide<{
-                readonly structured: Schema.Unknown;
-                readonly content: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
-                    readonly type: Schema.Literal<"text">;
-                    readonly text: Schema.String;
-                }>, Schema.Struct<{
-                    readonly type: Schema.Literal<"file">;
-                    readonly uri: Schema.String;
-                    readonly mime: Schema.String;
-                    readonly name: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
-                }>]>>;
-            }, "Type"> | undefined;
         } | {
+            readonly id: string;
             readonly type: "tool-error";
             readonly name: string;
-            readonly id: string;
             readonly message: string;
             readonly error?: unknown;
             readonly providerMetadata?: {
@@ -2036,13 +2037,13 @@ export declare const LLMEvent: Schema.Union<readonly [Schema.Struct<{
     stepStart: (input: {
         readonly index: number;
         readonly type?: "step-start" | undefined;
-    }, options?: Schema.MakeOptions) => Schema.Struct.ReadonlySide<{
-        readonly type: Schema.tag<"step-start">;
-        readonly index: Schema.Number;
-    }, "Type">;
+    }, options?: Schema.MakeOptions) => {
+        readonly type: "step-start";
+        readonly index: number;
+    };
     textStart: (input: WithID<TextStart, ContentBlockID>) => {
-        readonly type: "text-start";
         readonly id: string;
+        readonly type: "text-start";
         readonly providerMetadata?: {
             readonly [x: string]: {
                 readonly [x: string]: unknown;
@@ -2050,9 +2051,9 @@ export declare const LLMEvent: Schema.Union<readonly [Schema.Struct<{
         } | undefined;
     };
     textDelta: (input: WithID<TextDelta, ContentBlockID>) => {
+        readonly id: string;
         readonly type: "text-delta";
         readonly text: string;
-        readonly id: string;
         readonly providerMetadata?: {
             readonly [x: string]: {
                 readonly [x: string]: unknown;
@@ -2060,8 +2061,8 @@ export declare const LLMEvent: Schema.Union<readonly [Schema.Struct<{
         } | undefined;
     };
     textEnd: (input: WithID<TextEnd, ContentBlockID>) => {
-        readonly type: "text-end";
         readonly id: string;
+        readonly type: "text-end";
         readonly providerMetadata?: {
             readonly [x: string]: {
                 readonly [x: string]: unknown;
@@ -2069,8 +2070,8 @@ export declare const LLMEvent: Schema.Union<readonly [Schema.Struct<{
         } | undefined;
     };
     reasoningStart: (input: WithID<ReasoningStart, ContentBlockID>) => {
-        readonly type: "reasoning-start";
         readonly id: string;
+        readonly type: "reasoning-start";
         readonly providerMetadata?: {
             readonly [x: string]: {
                 readonly [x: string]: unknown;
@@ -2078,9 +2079,9 @@ export declare const LLMEvent: Schema.Union<readonly [Schema.Struct<{
         } | undefined;
     };
     reasoningDelta: (input: WithID<ReasoningDelta, ContentBlockID>) => {
+        readonly id: string;
         readonly type: "reasoning-delta";
         readonly text: string;
-        readonly id: string;
         readonly providerMetadata?: {
             readonly [x: string]: {
                 readonly [x: string]: unknown;
@@ -2088,8 +2089,8 @@ export declare const LLMEvent: Schema.Union<readonly [Schema.Struct<{
         } | undefined;
     };
     reasoningEnd: (input: WithID<ReasoningEnd, ContentBlockID>) => {
-        readonly type: "reasoning-end";
         readonly id: string;
+        readonly type: "reasoning-end";
         readonly providerMetadata?: {
             readonly [x: string]: {
                 readonly [x: string]: unknown;
@@ -2097,9 +2098,9 @@ export declare const LLMEvent: Schema.Union<readonly [Schema.Struct<{
         } | undefined;
     };
     toolInputStart: (input: WithID<ToolInputStart, ToolCallID>) => {
+        readonly id: string;
         readonly type: "tool-input-start";
         readonly name: string;
-        readonly id: string;
         readonly providerMetadata?: {
             readonly [x: string]: {
                 readonly [x: string]: unknown;
@@ -2107,32 +2108,32 @@ export declare const LLMEvent: Schema.Union<readonly [Schema.Struct<{
         } | undefined;
         readonly providerExecuted?: boolean | undefined;
     };
-    toolInputDelta: (input: WithID<ToolInputDelta, ToolCallID>) => Schema.Struct.ReadonlySide<{
-        readonly type: Schema.tag<"tool-input-delta">;
-        readonly id: Schema.String;
-        readonly name: Schema.String;
-        readonly text: Schema.String;
-    }, "Type">;
+    toolInputDelta: (input: WithID<ToolInputDelta, ToolCallID>) => {
+        readonly type: "tool-input-delta";
+        readonly id: string;
+        readonly name: string;
+        readonly text: string;
+    };
     toolInputEnd: (input: WithID<ToolInputEnd, ToolCallID>) => {
+        readonly id: string;
         readonly type: "tool-input-end";
         readonly name: string;
-        readonly id: string;
         readonly providerMetadata?: {
             readonly [x: string]: {
                 readonly [x: string]: unknown;
             };
         } | undefined;
     };
-    toolInputError: (input: WithID<ToolInputError, ToolCallID>) => Schema.Struct.ReadonlySide<{
-        readonly type: Schema.tag<"tool-input-error">;
-        readonly id: Schema.String;
-        readonly name: Schema.String;
-        readonly raw: Schema.String;
-    }, "Type">;
+    toolInputError: (input: WithID<ToolInputError, ToolCallID>) => {
+        readonly type: "tool-input-error";
+        readonly id: string;
+        readonly name: string;
+        readonly raw: string;
+    };
     toolCall: (input: WithID<ToolCall, ToolCallID>) => {
+        readonly id: string;
         readonly type: "tool-call";
         readonly name: string;
-        readonly id: string;
         readonly input: unknown;
         readonly providerMetadata?: {
             readonly [x: string]: {
@@ -2142,53 +2143,53 @@ export declare const LLMEvent: Schema.Union<readonly [Schema.Struct<{
         readonly providerExecuted?: boolean | undefined;
     };
     toolResult: (input: WithID<ToolResult, ToolCallID>) => {
+        readonly id: string;
         readonly type: "tool-result";
         readonly name: string;
-        readonly id: string;
-        readonly result: Schema.Struct.ReadonlySide<{
-            readonly type: Schema.Literal<"json">;
-            readonly value: Schema.Unknown;
-        }, "Type"> | Schema.Struct.ReadonlySide<{
-            readonly type: Schema.Literal<"text">;
-            readonly value: Schema.Unknown;
-        }, "Type"> | Schema.Struct.ReadonlySide<{
-            readonly type: Schema.Literal<"error">;
-            readonly value: Schema.Unknown;
-        }, "Type"> | Schema.Struct.ReadonlySide<{
-            readonly type: Schema.Literal<"content">;
-            readonly value: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
-                readonly type: Schema.Literal<"text">;
-                readonly text: Schema.String;
-            }>, Schema.Struct<{
-                readonly type: Schema.Literal<"file">;
-                readonly uri: Schema.String;
-                readonly mime: Schema.String;
-                readonly name: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
-            }>]>>;
-        }, "Type">;
+        readonly result: {
+            readonly type: "json";
+            readonly value: unknown;
+        } | {
+            readonly type: "text";
+            readonly value: unknown;
+        } | {
+            readonly type: "error";
+            readonly value: unknown;
+        } | {
+            readonly type: "content";
+            readonly value: readonly ({
+                readonly type: "text";
+                readonly text: string;
+            } | {
+                readonly type: "file";
+                readonly uri: string;
+                readonly mime: string;
+                readonly name?: string | undefined;
+            })[];
+        };
+        readonly output?: {
+            readonly structured: unknown;
+            readonly content: readonly ({
+                readonly type: "text";
+                readonly text: string;
+            } | {
+                readonly type: "file";
+                readonly uri: string;
+                readonly mime: string;
+                readonly name?: string | undefined;
+            })[];
+        } | undefined;
         readonly providerMetadata?: {
             readonly [x: string]: {
                 readonly [x: string]: unknown;
             };
         } | undefined;
         readonly providerExecuted?: boolean | undefined;
-        readonly output?: Schema.Struct.ReadonlySide<{
-            readonly structured: Schema.Unknown;
-            readonly content: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
-                readonly type: Schema.Literal<"text">;
-                readonly text: Schema.String;
-            }>, Schema.Struct<{
-                readonly type: Schema.Literal<"file">;
-                readonly uri: Schema.String;
-                readonly mime: Schema.String;
-                readonly name: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
-            }>]>>;
-        }, "Type"> | undefined;
     };
     toolError: (input: WithID<ToolError, ToolCallID>) => {
+        readonly id: string;
         readonly type: "tool-error";
         readonly name: string;
-        readonly id: string;
         readonly message: string;
         readonly error?: unknown;
         readonly providerMetadata?: {
@@ -2244,13 +2245,13 @@ export declare const LLMEvent: Schema.Union<readonly [Schema.Struct<{
         readonly classification?: "context-overflow" | undefined;
     };
     is: {
-        stepStart: (u: unknown) => u is Schema.Struct.ReadonlySide<{
-            readonly type: Schema.tag<"step-start">;
-            readonly index: Schema.Number;
-        }, "Type">;
+        stepStart: (u: unknown) => u is {
+            readonly type: "step-start";
+            readonly index: number;
+        };
         textStart: (u: unknown) => u is {
-            readonly type: "text-start";
             readonly id: string;
+            readonly type: "text-start";
             readonly providerMetadata?: {
                 readonly [x: string]: {
                     readonly [x: string]: unknown;
@@ -2258,9 +2259,9 @@ export declare const LLMEvent: Schema.Union<readonly [Schema.Struct<{
             } | undefined;
         };
         textDelta: (u: unknown) => u is {
+            readonly id: string;
             readonly type: "text-delta";
             readonly text: string;
-            readonly id: string;
             readonly providerMetadata?: {
                 readonly [x: string]: {
                     readonly [x: string]: unknown;
@@ -2268,8 +2269,8 @@ export declare const LLMEvent: Schema.Union<readonly [Schema.Struct<{
             } | undefined;
         };
         textEnd: (u: unknown) => u is {
-            readonly type: "text-end";
             readonly id: string;
+            readonly type: "text-end";
             readonly providerMetadata?: {
                 readonly [x: string]: {
                     readonly [x: string]: unknown;
@@ -2277,8 +2278,8 @@ export declare const LLMEvent: Schema.Union<readonly [Schema.Struct<{
             } | undefined;
         };
         reasoningStart: (u: unknown) => u is {
-            readonly type: "reasoning-start";
             readonly id: string;
+            readonly type: "reasoning-start";
             readonly providerMetadata?: {
                 readonly [x: string]: {
                     readonly [x: string]: unknown;
@@ -2286,9 +2287,9 @@ export declare const LLMEvent: Schema.Union<readonly [Schema.Struct<{
             } | undefined;
         };
         reasoningDelta: (u: unknown) => u is {
+            readonly id: string;
             readonly type: "reasoning-delta";
             readonly text: string;
-            readonly id: string;
             readonly providerMetadata?: {
                 readonly [x: string]: {
                     readonly [x: string]: unknown;
@@ -2296,8 +2297,8 @@ export declare const LLMEvent: Schema.Union<readonly [Schema.Struct<{
             } | undefined;
         };
         reasoningEnd: (u: unknown) => u is {
-            readonly type: "reasoning-end";
             readonly id: string;
+            readonly type: "reasoning-end";
             readonly providerMetadata?: {
                 readonly [x: string]: {
                     readonly [x: string]: unknown;
@@ -2305,9 +2306,9 @@ export declare const LLMEvent: Schema.Union<readonly [Schema.Struct<{
             } | undefined;
         };
         toolInputStart: (u: unknown) => u is {
+            readonly id: string;
             readonly type: "tool-input-start";
             readonly name: string;
-            readonly id: string;
             readonly providerMetadata?: {
                 readonly [x: string]: {
                     readonly [x: string]: unknown;
@@ -2315,32 +2316,32 @@ export declare const LLMEvent: Schema.Union<readonly [Schema.Struct<{
             } | undefined;
             readonly providerExecuted?: boolean | undefined;
         };
-        toolInputDelta: (u: unknown) => u is Schema.Struct.ReadonlySide<{
-            readonly type: Schema.tag<"tool-input-delta">;
-            readonly id: Schema.String;
-            readonly name: Schema.String;
-            readonly text: Schema.String;
-        }, "Type">;
+        toolInputDelta: (u: unknown) => u is {
+            readonly type: "tool-input-delta";
+            readonly id: string;
+            readonly name: string;
+            readonly text: string;
+        };
         toolInputEnd: (u: unknown) => u is {
+            readonly id: string;
             readonly type: "tool-input-end";
             readonly name: string;
-            readonly id: string;
             readonly providerMetadata?: {
                 readonly [x: string]: {
                     readonly [x: string]: unknown;
                 };
             } | undefined;
         };
-        toolInputError: (u: unknown) => u is Schema.Struct.ReadonlySide<{
-            readonly type: Schema.tag<"tool-input-error">;
-            readonly id: Schema.String;
-            readonly name: Schema.String;
-            readonly raw: Schema.String;
-        }, "Type">;
+        toolInputError: (u: unknown) => u is {
+            readonly type: "tool-input-error";
+            readonly id: string;
+            readonly name: string;
+            readonly raw: string;
+        };
         toolCall: (u: unknown) => u is {
+            readonly id: string;
             readonly type: "tool-call";
             readonly name: string;
-            readonly id: string;
             readonly input: unknown;
             readonly providerMetadata?: {
                 readonly [x: string]: {
@@ -2350,53 +2351,53 @@ export declare const LLMEvent: Schema.Union<readonly [Schema.Struct<{
             readonly providerExecuted?: boolean | undefined;
         };
         toolResult: (u: unknown) => u is {
+            readonly id: string;
             readonly type: "tool-result";
             readonly name: string;
-            readonly id: string;
-            readonly result: Schema.Struct.ReadonlySide<{
-                readonly type: Schema.Literal<"json">;
-                readonly value: Schema.Unknown;
-            }, "Type"> | Schema.Struct.ReadonlySide<{
-                readonly type: Schema.Literal<"text">;
-                readonly value: Schema.Unknown;
-            }, "Type"> | Schema.Struct.ReadonlySide<{
-                readonly type: Schema.Literal<"error">;
-                readonly value: Schema.Unknown;
-            }, "Type"> | Schema.Struct.ReadonlySide<{
-                readonly type: Schema.Literal<"content">;
-                readonly value: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
-                    readonly type: Schema.Literal<"text">;
-                    readonly text: Schema.String;
-                }>, Schema.Struct<{
-                    readonly type: Schema.Literal<"file">;
-                    readonly uri: Schema.String;
-                    readonly mime: Schema.String;
-                    readonly name: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
-                }>]>>;
-            }, "Type">;
+            readonly result: {
+                readonly type: "json";
+                readonly value: unknown;
+            } | {
+                readonly type: "text";
+                readonly value: unknown;
+            } | {
+                readonly type: "error";
+                readonly value: unknown;
+            } | {
+                readonly type: "content";
+                readonly value: readonly ({
+                    readonly type: "text";
+                    readonly text: string;
+                } | {
+                    readonly type: "file";
+                    readonly uri: string;
+                    readonly mime: string;
+                    readonly name?: string | undefined;
+                })[];
+            };
+            readonly output?: {
+                readonly structured: unknown;
+                readonly content: readonly ({
+                    readonly type: "text";
+                    readonly text: string;
+                } | {
+                    readonly type: "file";
+                    readonly uri: string;
+                    readonly mime: string;
+                    readonly name?: string | undefined;
+                })[];
+            } | undefined;
             readonly providerMetadata?: {
                 readonly [x: string]: {
                     readonly [x: string]: unknown;
                 };
             } | undefined;
             readonly providerExecuted?: boolean | undefined;
-            readonly output?: Schema.Struct.ReadonlySide<{
-                readonly structured: Schema.Unknown;
-                readonly content: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
-                    readonly type: Schema.Literal<"text">;
-                    readonly text: Schema.String;
-                }>, Schema.Struct<{
-                    readonly type: Schema.Literal<"file">;
-                    readonly uri: Schema.String;
-                    readonly mime: Schema.String;
-                    readonly name: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
-                }>]>>;
-            }, "Type"> | undefined;
         };
         toolError: (u: unknown) => u is {
+            readonly id: string;
             readonly type: "tool-error";
             readonly name: string;
-            readonly id: string;
             readonly message: string;
             readonly error?: unknown;
             readonly providerMetadata?: {
@@ -2568,7 +2569,7 @@ declare const LLMResponse_base: Schema.Class<LLMResponse, Schema.Struct<{
                 readonly type: Schema.Literal<"file">;
                 readonly uri: Schema.String;
                 readonly mime: Schema.String;
-                readonly name: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+                readonly name: Schema.optional<Schema.String>;
             }>]>>;
         }>]> & {
             is: (value: unknown) => value is ToolResultValue;
@@ -2583,10 +2584,10 @@ declare const LLMResponse_base: Schema.Class<LLMResponse, Schema.Struct<{
                 readonly type: Schema.Literal<"file">;
                 readonly uri: Schema.String;
                 readonly mime: Schema.String;
-                readonly name: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+                readonly name: Schema.optional<Schema.String>;
             }>]>>;
         }> & {
-            make: (structured: unknown, content?: ReadonlyArray<import("@opencode-ai/schema/llm").ToolContent>) => ToolOutput;
+            make: (structured: unknown, content?: ReadonlyArray<import("@opencode-ai/schema/tool").Content>) => ToolOutput;
             fromResultValue: (result: ToolResultValue) => ToolOutput | undefined;
             toResultValue: (output: ToolOutput) => ToolResultValue;
         }>;
@@ -2622,6 +2623,7 @@ declare const LLMResponse_base: Schema.Class<LLMResponse, Schema.Struct<{
         readonly classification: Schema.optional<Schema.Literal<"context-overflow">>;
         readonly providerMetadata: Schema.optional<Schema.$Record<Schema.String, Schema.$Record<Schema.String, Schema.Unknown>>>;
     }>]> & {
+        readonly discriminants: readonly ["step-start", "text-start", "text-delta", "text-end", "reasoning-start", "reasoning-delta", "reasoning-end", "tool-input-start", "tool-input-delta", "tool-input-end", "tool-input-error", "tool-call", "tool-result", "tool-error", "step-finish", "finish", "provider-error"];
         readonly cases: {
             "step-start": Schema.Struct<{
                 readonly type: Schema.tag<"step-start">;
@@ -2714,7 +2716,7 @@ declare const LLMResponse_base: Schema.Class<LLMResponse, Schema.Struct<{
                         readonly type: Schema.Literal<"file">;
                         readonly uri: Schema.String;
                         readonly mime: Schema.String;
-                        readonly name: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+                        readonly name: Schema.optional<Schema.String>;
                     }>]>>;
                 }>]> & {
                     is: (value: unknown) => value is ToolResultValue;
@@ -2729,10 +2731,10 @@ declare const LLMResponse_base: Schema.Class<LLMResponse, Schema.Struct<{
                         readonly type: Schema.Literal<"file">;
                         readonly uri: Schema.String;
                         readonly mime: Schema.String;
-                        readonly name: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+                        readonly name: Schema.optional<Schema.String>;
                     }>]>>;
                 }> & {
-                    make: (structured: unknown, content?: ReadonlyArray<import("@opencode-ai/schema/llm").ToolContent>) => ToolOutput;
+                    make: (structured: unknown, content?: ReadonlyArray<import("@opencode-ai/schema/tool").Content>) => ToolOutput;
                     fromResultValue: (result: ToolResultValue) => ToolOutput | undefined;
                     toResultValue: (output: ToolOutput) => ToolResultValue;
                 }>;
@@ -2773,92 +2775,92 @@ declare const LLMResponse_base: Schema.Class<LLMResponse, Schema.Struct<{
                 readonly providerMetadata: Schema.optional<Schema.$Record<Schema.String, Schema.$Record<Schema.String, Schema.Unknown>>>;
             }>;
         };
-        readonly isAnyOf: <const Keys>(keys: readonly Keys[]) => (value: Schema.Struct.ReadonlySide<{
-            readonly type: Schema.tag<"step-start">;
-            readonly index: Schema.Number;
-        }, "Type"> | {
-            readonly type: "text-start";
+        readonly isAnyOf: <const Keys>(keys: readonly Keys[]) => (value: {
+            readonly type: "step-start";
+            readonly index: number;
+        } | {
             readonly id: string;
+            readonly type: "text-start";
             readonly providerMetadata?: {
                 readonly [x: string]: {
                     readonly [x: string]: unknown;
                 };
             } | undefined;
         } | {
+            readonly id: string;
             readonly type: "text-delta";
             readonly text: string;
-            readonly id: string;
             readonly providerMetadata?: {
                 readonly [x: string]: {
                     readonly [x: string]: unknown;
                 };
             } | undefined;
         } | {
-            readonly type: "text-end";
             readonly id: string;
+            readonly type: "text-end";
             readonly providerMetadata?: {
                 readonly [x: string]: {
                     readonly [x: string]: unknown;
                 };
             } | undefined;
         } | {
-            readonly type: "reasoning-start";
             readonly id: string;
+            readonly type: "reasoning-start";
             readonly providerMetadata?: {
                 readonly [x: string]: {
                     readonly [x: string]: unknown;
                 };
             } | undefined;
         } | {
+            readonly id: string;
             readonly type: "reasoning-delta";
             readonly text: string;
-            readonly id: string;
             readonly providerMetadata?: {
                 readonly [x: string]: {
                     readonly [x: string]: unknown;
                 };
             } | undefined;
         } | {
-            readonly type: "reasoning-end";
             readonly id: string;
+            readonly type: "reasoning-end";
             readonly providerMetadata?: {
                 readonly [x: string]: {
                     readonly [x: string]: unknown;
                 };
             } | undefined;
         } | {
+            readonly id: string;
             readonly type: "tool-input-start";
             readonly name: string;
-            readonly id: string;
             readonly providerMetadata?: {
                 readonly [x: string]: {
                     readonly [x: string]: unknown;
                 };
             } | undefined;
             readonly providerExecuted?: boolean | undefined;
-        } | Schema.Struct.ReadonlySide<{
-            readonly type: Schema.tag<"tool-input-delta">;
-            readonly id: Schema.String;
-            readonly name: Schema.String;
-            readonly text: Schema.String;
-        }, "Type"> | {
-            readonly type: "tool-input-end";
+        } | {
+            readonly type: "tool-input-delta";
+            readonly id: string;
             readonly name: string;
+            readonly text: string;
+        } | {
             readonly id: string;
+            readonly type: "tool-input-end";
+            readonly name: string;
             readonly providerMetadata?: {
                 readonly [x: string]: {
                     readonly [x: string]: unknown;
                 };
             } | undefined;
-        } | Schema.Struct.ReadonlySide<{
-            readonly type: Schema.tag<"tool-input-error">;
-            readonly id: Schema.String;
-            readonly name: Schema.String;
-            readonly raw: Schema.String;
-        }, "Type"> | {
-            readonly type: "tool-call";
+        } | {
+            readonly type: "tool-input-error";
+            readonly id: string;
             readonly name: string;
+            readonly raw: string;
+        } | {
             readonly id: string;
+            readonly type: "tool-call";
+            readonly name: string;
             readonly input: unknown;
             readonly providerMetadata?: {
                 readonly [x: string]: {
@@ -2867,52 +2869,52 @@ declare const LLMResponse_base: Schema.Class<LLMResponse, Schema.Struct<{
             } | undefined;
             readonly providerExecuted?: boolean | undefined;
         } | {
+            readonly id: string;
             readonly type: "tool-result";
             readonly name: string;
-            readonly id: string;
-            readonly result: Schema.Struct.ReadonlySide<{
-                readonly type: Schema.Literal<"json">;
-                readonly value: Schema.Unknown;
-            }, "Type"> | Schema.Struct.ReadonlySide<{
-                readonly type: Schema.Literal<"text">;
-                readonly value: Schema.Unknown;
-            }, "Type"> | Schema.Struct.ReadonlySide<{
-                readonly type: Schema.Literal<"error">;
-                readonly value: Schema.Unknown;
-            }, "Type"> | Schema.Struct.ReadonlySide<{
-                readonly type: Schema.Literal<"content">;
-                readonly value: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
-                    readonly type: Schema.Literal<"text">;
-                    readonly text: Schema.String;
-                }>, Schema.Struct<{
-                    readonly type: Schema.Literal<"file">;
-                    readonly uri: Schema.String;
-                    readonly mime: Schema.String;
-                    readonly name: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
-                }>]>>;
-            }, "Type">;
-            readonly providerMetadata?: {
-                readonly [x: string]: {
-                    readonly [x: string]: unknown;
-                };
-            } | undefined;
-            readonly providerExecuted?: boolean | undefined;
-            readonly output?: Schema.Struct.ReadonlySide<{
-                readonly structured: Schema.Unknown;
-                readonly content: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
-                    readonly type: Schema.Literal<"text">;
-                    readonly text: Schema.String;
-                }>, Schema.Struct<{
-                    readonly type: Schema.Literal<"file">;
-                    readonly uri: Schema.String;
-                    readonly mime: Schema.String;
-                    readonly name: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
-                }>]>>;
-            }, "Type"> | undefined;
+            readonly result: {
+                readonly type: "json";
+                readonly value: unknown;
+            } | {
+                readonly type: "text";
+                readonly value: unknown;
+            } | {
+                readonly type: "error";
+                readonly value: unknown;
+            } | {
+                readonly type: "content";
+                readonly value: readonly ({
+                    readonly type: "text";
+                    readonly text: string;
+                } | {
+                    readonly type: "file";
+                    readonly uri: string;
+                    readonly mime: string;
+                    readonly name?: string | undefined;
+                })[];
+            };
+            readonly output?: {
+                readonly structured: unknown;
+                readonly content: readonly ({
+                    readonly type: "text";
+                    readonly text: string;
+                } | {
+                    readonly type: "file";
+                    readonly uri: string;
+                    readonly mime: string;
+                    readonly name?: string | undefined;
+                })[];
+            } | undefined;
+            readonly providerMetadata?: {
+                readonly [x: string]: {
+                    readonly [x: string]: unknown;
+                };
+            } | undefined;
+            readonly providerExecuted?: boolean | undefined;
         } | {
+            readonly id: string;
             readonly type: "tool-error";
             readonly name: string;
-            readonly id: string;
             readonly message: string;
             readonly error?: unknown;
             readonly providerMetadata?: {
@@ -2954,14 +2956,14 @@ declare const LLMResponse_base: Schema.Class<LLMResponse, Schema.Struct<{
                 };
             } | undefined;
             readonly classification?: "context-overflow" | undefined;
-        }) => value is Extract<Schema.Struct.ReadonlySide<{
-            readonly type: Schema.tag<"step-start">;
-            readonly index: Schema.Number;
-        }, "Type">, {
+        }) => value is Extract<{
+            readonly type: "step-start";
+            readonly index: number;
+        }, {
             readonly type: Keys;
         }> | Extract<{
-            readonly type: "text-start";
             readonly id: string;
+            readonly type: "text-start";
             readonly providerMetadata?: {
                 readonly [x: string]: {
                     readonly [x: string]: unknown;
@@ -2970,9 +2972,9 @@ declare const LLMResponse_base: Schema.Class<LLMResponse, Schema.Struct<{
         }, {
             readonly type: Keys;
         }> | Extract<{
+            readonly id: string;
             readonly type: "text-delta";
             readonly text: string;
-            readonly id: string;
             readonly providerMetadata?: {
                 readonly [x: string]: {
                     readonly [x: string]: unknown;
@@ -2981,8 +2983,8 @@ declare const LLMResponse_base: Schema.Class<LLMResponse, Schema.Struct<{
         }, {
             readonly type: Keys;
         }> | Extract<{
-            readonly type: "text-end";
             readonly id: string;
+            readonly type: "text-end";
             readonly providerMetadata?: {
                 readonly [x: string]: {
                     readonly [x: string]: unknown;
@@ -2991,8 +2993,8 @@ declare const LLMResponse_base: Schema.Class<LLMResponse, Schema.Struct<{
         }, {
             readonly type: Keys;
         }> | Extract<{
-            readonly type: "reasoning-start";
             readonly id: string;
+            readonly type: "reasoning-start";
             readonly providerMetadata?: {
                 readonly [x: string]: {
                     readonly [x: string]: unknown;
@@ -3001,9 +3003,9 @@ declare const LLMResponse_base: Schema.Class<LLMResponse, Schema.Struct<{
         }, {
             readonly type: Keys;
         }> | Extract<{
+            readonly id: string;
             readonly type: "reasoning-delta";
             readonly text: string;
-            readonly id: string;
             readonly providerMetadata?: {
                 readonly [x: string]: {
                     readonly [x: string]: unknown;
@@ -3012,8 +3014,8 @@ declare const LLMResponse_base: Schema.Class<LLMResponse, Schema.Struct<{
         }, {
             readonly type: Keys;
         }> | Extract<{
-            readonly type: "reasoning-end";
             readonly id: string;
+            readonly type: "reasoning-end";
             readonly providerMetadata?: {
                 readonly [x: string]: {
                     readonly [x: string]: unknown;
@@ -3022,9 +3024,9 @@ declare const LLMResponse_base: Schema.Class<LLMResponse, Schema.Struct<{
         }, {
             readonly type: Keys;
         }> | Extract<{
+            readonly id: string;
             readonly type: "tool-input-start";
             readonly name: string;
-            readonly id: string;
             readonly providerMetadata?: {
                 readonly [x: string]: {
                     readonly [x: string]: unknown;
@@ -3033,17 +3035,17 @@ declare const LLMResponse_base: Schema.Class<LLMResponse, Schema.Struct<{
             readonly providerExecuted?: boolean | undefined;
         }, {
             readonly type: Keys;
-        }> | Extract<Schema.Struct.ReadonlySide<{
-            readonly type: Schema.tag<"tool-input-delta">;
-            readonly id: Schema.String;
-            readonly name: Schema.String;
-            readonly text: Schema.String;
-        }, "Type">, {
+        }> | Extract<{
+            readonly type: "tool-input-delta";
+            readonly id: string;
+            readonly name: string;
+            readonly text: string;
+        }, {
             readonly type: Keys;
         }> | Extract<{
+            readonly id: string;
             readonly type: "tool-input-end";
             readonly name: string;
-            readonly id: string;
             readonly providerMetadata?: {
                 readonly [x: string]: {
                     readonly [x: string]: unknown;
@@ -3051,17 +3053,17 @@ declare const LLMResponse_base: Schema.Class<LLMResponse, Schema.Struct<{
             } | undefined;
         }, {
             readonly type: Keys;
-        }> | Extract<Schema.Struct.ReadonlySide<{
-            readonly type: Schema.tag<"tool-input-error">;
-            readonly id: Schema.String;
-            readonly name: Schema.String;
-            readonly raw: Schema.String;
-        }, "Type">, {
+        }> | Extract<{
+            readonly type: "tool-input-error";
+            readonly id: string;
+            readonly name: string;
+            readonly raw: string;
+        }, {
             readonly type: Keys;
         }> | Extract<{
+            readonly id: string;
             readonly type: "tool-call";
             readonly name: string;
-            readonly id: string;
             readonly input: unknown;
             readonly providerMetadata?: {
                 readonly [x: string]: {
@@ -3072,54 +3074,54 @@ declare const LLMResponse_base: Schema.Class<LLMResponse, Schema.Struct<{
         }, {
             readonly type: Keys;
         }> | Extract<{
+            readonly id: string;
             readonly type: "tool-result";
             readonly name: string;
-            readonly id: string;
-            readonly result: Schema.Struct.ReadonlySide<{
-                readonly type: Schema.Literal<"json">;
-                readonly value: Schema.Unknown;
-            }, "Type"> | Schema.Struct.ReadonlySide<{
-                readonly type: Schema.Literal<"text">;
-                readonly value: Schema.Unknown;
-            }, "Type"> | Schema.Struct.ReadonlySide<{
-                readonly type: Schema.Literal<"error">;
-                readonly value: Schema.Unknown;
-            }, "Type"> | Schema.Struct.ReadonlySide<{
-                readonly type: Schema.Literal<"content">;
-                readonly value: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
-                    readonly type: Schema.Literal<"text">;
-                    readonly text: Schema.String;
-                }>, Schema.Struct<{
-                    readonly type: Schema.Literal<"file">;
-                    readonly uri: Schema.String;
-                    readonly mime: Schema.String;
-                    readonly name: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
-                }>]>>;
-            }, "Type">;
+            readonly result: {
+                readonly type: "json";
+                readonly value: unknown;
+            } | {
+                readonly type: "text";
+                readonly value: unknown;
+            } | {
+                readonly type: "error";
+                readonly value: unknown;
+            } | {
+                readonly type: "content";
+                readonly value: readonly ({
+                    readonly type: "text";
+                    readonly text: string;
+                } | {
+                    readonly type: "file";
+                    readonly uri: string;
+                    readonly mime: string;
+                    readonly name?: string | undefined;
+                })[];
+            };
+            readonly output?: {
+                readonly structured: unknown;
+                readonly content: readonly ({
+                    readonly type: "text";
+                    readonly text: string;
+                } | {
+                    readonly type: "file";
+                    readonly uri: string;
+                    readonly mime: string;
+                    readonly name?: string | undefined;
+                })[];
+            } | undefined;
             readonly providerMetadata?: {
                 readonly [x: string]: {
                     readonly [x: string]: unknown;
                 };
             } | undefined;
             readonly providerExecuted?: boolean | undefined;
-            readonly output?: Schema.Struct.ReadonlySide<{
-                readonly structured: Schema.Unknown;
-                readonly content: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
-                    readonly type: Schema.Literal<"text">;
-                    readonly text: Schema.String;
-                }>, Schema.Struct<{
-                    readonly type: Schema.Literal<"file">;
-                    readonly uri: Schema.String;
-                    readonly mime: Schema.String;
-                    readonly name: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
-                }>]>>;
-            }, "Type"> | undefined;
         }, {
             readonly type: Keys;
         }> | Extract<{
+            readonly id: string;
             readonly type: "tool-error";
             readonly name: string;
-            readonly id: string;
             readonly message: string;
             readonly error?: unknown;
             readonly providerMetadata?: {
@@ -3171,13 +3173,13 @@ declare const LLMResponse_base: Schema.Class<LLMResponse, Schema.Struct<{
             readonly type: Keys;
         }>;
         readonly guards: {
-            "step-start": (u: unknown) => u is Schema.Struct.ReadonlySide<{
-                readonly type: Schema.tag<"step-start">;
-                readonly index: Schema.Number;
-            }, "Type">;
+            "step-start": (u: unknown) => u is {
+                readonly type: "step-start";
+                readonly index: number;
+            };
             "text-start": (u: unknown) => u is {
-                readonly type: "text-start";
                 readonly id: string;
+                readonly type: "text-start";
                 readonly providerMetadata?: {
                     readonly [x: string]: {
                         readonly [x: string]: unknown;
@@ -3185,9 +3187,9 @@ declare const LLMResponse_base: Schema.Class<LLMResponse, Schema.Struct<{
                 } | undefined;
             };
             "text-delta": (u: unknown) => u is {
+                readonly id: string;
                 readonly type: "text-delta";
                 readonly text: string;
-                readonly id: string;
                 readonly providerMetadata?: {
                     readonly [x: string]: {
                         readonly [x: string]: unknown;
@@ -3195,8 +3197,8 @@ declare const LLMResponse_base: Schema.Class<LLMResponse, Schema.Struct<{
                 } | undefined;
             };
             "text-end": (u: unknown) => u is {
-                readonly type: "text-end";
                 readonly id: string;
+                readonly type: "text-end";
                 readonly providerMetadata?: {
                     readonly [x: string]: {
                         readonly [x: string]: unknown;
@@ -3204,8 +3206,8 @@ declare const LLMResponse_base: Schema.Class<LLMResponse, Schema.Struct<{
                 } | undefined;
             };
             "reasoning-start": (u: unknown) => u is {
-                readonly type: "reasoning-start";
                 readonly id: string;
+                readonly type: "reasoning-start";
                 readonly providerMetadata?: {
                     readonly [x: string]: {
                         readonly [x: string]: unknown;
@@ -3213,9 +3215,9 @@ declare const LLMResponse_base: Schema.Class<LLMResponse, Schema.Struct<{
                 } | undefined;
             };
             "reasoning-delta": (u: unknown) => u is {
+                readonly id: string;
                 readonly type: "reasoning-delta";
                 readonly text: string;
-                readonly id: string;
                 readonly providerMetadata?: {
                     readonly [x: string]: {
                         readonly [x: string]: unknown;
@@ -3223,8 +3225,8 @@ declare const LLMResponse_base: Schema.Class<LLMResponse, Schema.Struct<{
                 } | undefined;
             };
             "reasoning-end": (u: unknown) => u is {
-                readonly type: "reasoning-end";
                 readonly id: string;
+                readonly type: "reasoning-end";
                 readonly providerMetadata?: {
                     readonly [x: string]: {
                         readonly [x: string]: unknown;
@@ -3232,9 +3234,9 @@ declare const LLMResponse_base: Schema.Class<LLMResponse, Schema.Struct<{
                 } | undefined;
             };
             "tool-input-start": (u: unknown) => u is {
+                readonly id: string;
                 readonly type: "tool-input-start";
                 readonly name: string;
-                readonly id: string;
                 readonly providerMetadata?: {
                     readonly [x: string]: {
                         readonly [x: string]: unknown;
@@ -3242,32 +3244,32 @@ declare const LLMResponse_base: Schema.Class<LLMResponse, Schema.Struct<{
                 } | undefined;
                 readonly providerExecuted?: boolean | undefined;
             };
-            "tool-input-delta": (u: unknown) => u is Schema.Struct.ReadonlySide<{
-                readonly type: Schema.tag<"tool-input-delta">;
-                readonly id: Schema.String;
-                readonly name: Schema.String;
-                readonly text: Schema.String;
-            }, "Type">;
+            "tool-input-delta": (u: unknown) => u is {
+                readonly type: "tool-input-delta";
+                readonly id: string;
+                readonly name: string;
+                readonly text: string;
+            };
             "tool-input-end": (u: unknown) => u is {
+                readonly id: string;
                 readonly type: "tool-input-end";
                 readonly name: string;
-                readonly id: string;
                 readonly providerMetadata?: {
                     readonly [x: string]: {
                         readonly [x: string]: unknown;
                     };
                 } | undefined;
             };
-            "tool-input-error": (u: unknown) => u is Schema.Struct.ReadonlySide<{
-                readonly type: Schema.tag<"tool-input-error">;
-                readonly id: Schema.String;
-                readonly name: Schema.String;
-                readonly raw: Schema.String;
-            }, "Type">;
+            "tool-input-error": (u: unknown) => u is {
+                readonly type: "tool-input-error";
+                readonly id: string;
+                readonly name: string;
+                readonly raw: string;
+            };
             "tool-call": (u: unknown) => u is {
+                readonly id: string;
                 readonly type: "tool-call";
                 readonly name: string;
-                readonly id: string;
                 readonly input: unknown;
                 readonly providerMetadata?: {
                     readonly [x: string]: {
@@ -3277,53 +3279,53 @@ declare const LLMResponse_base: Schema.Class<LLMResponse, Schema.Struct<{
                 readonly providerExecuted?: boolean | undefined;
             };
             "tool-result": (u: unknown) => u is {
+                readonly id: string;
                 readonly type: "tool-result";
                 readonly name: string;
-                readonly id: string;
-                readonly result: Schema.Struct.ReadonlySide<{
-                    readonly type: Schema.Literal<"json">;
-                    readonly value: Schema.Unknown;
-                }, "Type"> | Schema.Struct.ReadonlySide<{
-                    readonly type: Schema.Literal<"text">;
-                    readonly value: Schema.Unknown;
-                }, "Type"> | Schema.Struct.ReadonlySide<{
-                    readonly type: Schema.Literal<"error">;
-                    readonly value: Schema.Unknown;
-                }, "Type"> | Schema.Struct.ReadonlySide<{
-                    readonly type: Schema.Literal<"content">;
-                    readonly value: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
-                        readonly type: Schema.Literal<"text">;
-                        readonly text: Schema.String;
-                    }>, Schema.Struct<{
-                        readonly type: Schema.Literal<"file">;
-                        readonly uri: Schema.String;
-                        readonly mime: Schema.String;
-                        readonly name: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
-                    }>]>>;
-                }, "Type">;
+                readonly result: {
+                    readonly type: "json";
+                    readonly value: unknown;
+                } | {
+                    readonly type: "text";
+                    readonly value: unknown;
+                } | {
+                    readonly type: "error";
+                    readonly value: unknown;
+                } | {
+                    readonly type: "content";
+                    readonly value: readonly ({
+                        readonly type: "text";
+                        readonly text: string;
+                    } | {
+                        readonly type: "file";
+                        readonly uri: string;
+                        readonly mime: string;
+                        readonly name?: string | undefined;
+                    })[];
+                };
+                readonly output?: {
+                    readonly structured: unknown;
+                    readonly content: readonly ({
+                        readonly type: "text";
+                        readonly text: string;
+                    } | {
+                        readonly type: "file";
+                        readonly uri: string;
+                        readonly mime: string;
+                        readonly name?: string | undefined;
+                    })[];
+                } | undefined;
                 readonly providerMetadata?: {
                     readonly [x: string]: {
                         readonly [x: string]: unknown;
                     };
                 } | undefined;
                 readonly providerExecuted?: boolean | undefined;
-                readonly output?: Schema.Struct.ReadonlySide<{
-                    readonly structured: Schema.Unknown;
-                    readonly content: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
-                        readonly type: Schema.Literal<"text">;
-                        readonly text: Schema.String;
-                    }>, Schema.Struct<{
-                        readonly type: Schema.Literal<"file">;
-                        readonly uri: Schema.String;
-                        readonly mime: Schema.String;
-                        readonly name: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
-                    }>]>>;
-                }, "Type"> | undefined;
             };
             "tool-error": (u: unknown) => u is {
+                readonly id: string;
                 readonly type: "tool-error";
                 readonly name: string;
-                readonly id: string;
                 readonly message: string;
                 readonly error?: unknown;
                 readonly providerMetadata?: {
@@ -3372,13 +3374,13 @@ declare const LLMResponse_base: Schema.Class<LLMResponse, Schema.Struct<{
         };
         readonly match: {
             <Cases extends {
-                "step-start": (value: Schema.Struct.ReadonlySide<{
-                    readonly type: Schema.tag<"step-start">;
-                    readonly index: Schema.Number;
-                }, "Type">) => any;
+                "step-start": (value: {
+                    readonly type: "step-start";
+                    readonly index: number;
+                }) => any;
                 "text-start": (value: {
-                    readonly type: "text-start";
                     readonly id: string;
+                    readonly type: "text-start";
                     readonly providerMetadata?: {
                         readonly [x: string]: {
                             readonly [x: string]: unknown;
@@ -3386,9 +3388,9 @@ declare const LLMResponse_base: Schema.Class<LLMResponse, Schema.Struct<{
                     } | undefined;
                 }) => any;
                 "text-delta": (value: {
+                    readonly id: string;
                     readonly type: "text-delta";
                     readonly text: string;
-                    readonly id: string;
                     readonly providerMetadata?: {
                         readonly [x: string]: {
                             readonly [x: string]: unknown;
@@ -3396,8 +3398,8 @@ declare const LLMResponse_base: Schema.Class<LLMResponse, Schema.Struct<{
                     } | undefined;
                 }) => any;
                 "text-end": (value: {
-                    readonly type: "text-end";
                     readonly id: string;
+                    readonly type: "text-end";
                     readonly providerMetadata?: {
                         readonly [x: string]: {
                             readonly [x: string]: unknown;
@@ -3405,8 +3407,8 @@ declare const LLMResponse_base: Schema.Class<LLMResponse, Schema.Struct<{
                     } | undefined;
                 }) => any;
                 "reasoning-start": (value: {
-                    readonly type: "reasoning-start";
                     readonly id: string;
+                    readonly type: "reasoning-start";
                     readonly providerMetadata?: {
                         readonly [x: string]: {
                             readonly [x: string]: unknown;
@@ -3414,9 +3416,9 @@ declare const LLMResponse_base: Schema.Class<LLMResponse, Schema.Struct<{
                     } | undefined;
                 }) => any;
                 "reasoning-delta": (value: {
+                    readonly id: string;
                     readonly type: "reasoning-delta";
                     readonly text: string;
-                    readonly id: string;
                     readonly providerMetadata?: {
                         readonly [x: string]: {
                             readonly [x: string]: unknown;
@@ -3424,8 +3426,8 @@ declare const LLMResponse_base: Schema.Class<LLMResponse, Schema.Struct<{
                     } | undefined;
                 }) => any;
                 "reasoning-end": (value: {
-                    readonly type: "reasoning-end";
                     readonly id: string;
+                    readonly type: "reasoning-end";
                     readonly providerMetadata?: {
                         readonly [x: string]: {
                             readonly [x: string]: unknown;
@@ -3433,9 +3435,9 @@ declare const LLMResponse_base: Schema.Class<LLMResponse, Schema.Struct<{
                     } | undefined;
                 }) => any;
                 "tool-input-start": (value: {
+                    readonly id: string;
                     readonly type: "tool-input-start";
                     readonly name: string;
-                    readonly id: string;
                     readonly providerMetadata?: {
                         readonly [x: string]: {
                             readonly [x: string]: unknown;
@@ -3443,32 +3445,32 @@ declare const LLMResponse_base: Schema.Class<LLMResponse, Schema.Struct<{
                     } | undefined;
                     readonly providerExecuted?: boolean | undefined;
                 }) => any;
-                "tool-input-delta": (value: Schema.Struct.ReadonlySide<{
-                    readonly type: Schema.tag<"tool-input-delta">;
-                    readonly id: Schema.String;
-                    readonly name: Schema.String;
-                    readonly text: Schema.String;
-                }, "Type">) => any;
+                "tool-input-delta": (value: {
+                    readonly type: "tool-input-delta";
+                    readonly id: string;
+                    readonly name: string;
+                    readonly text: string;
+                }) => any;
                 "tool-input-end": (value: {
+                    readonly id: string;
                     readonly type: "tool-input-end";
                     readonly name: string;
-                    readonly id: string;
                     readonly providerMetadata?: {
                         readonly [x: string]: {
                             readonly [x: string]: unknown;
                         };
                     } | undefined;
                 }) => any;
-                "tool-input-error": (value: Schema.Struct.ReadonlySide<{
-                    readonly type: Schema.tag<"tool-input-error">;
-                    readonly id: Schema.String;
-                    readonly name: Schema.String;
-                    readonly raw: Schema.String;
-                }, "Type">) => any;
+                "tool-input-error": (value: {
+                    readonly type: "tool-input-error";
+                    readonly id: string;
+                    readonly name: string;
+                    readonly raw: string;
+                }) => any;
                 "tool-call": (value: {
+                    readonly id: string;
                     readonly type: "tool-call";
                     readonly name: string;
-                    readonly id: string;
                     readonly input: unknown;
                     readonly providerMetadata?: {
                         readonly [x: string]: {
@@ -3478,53 +3480,53 @@ declare const LLMResponse_base: Schema.Class<LLMResponse, Schema.Struct<{
                     readonly providerExecuted?: boolean | undefined;
                 }) => any;
                 "tool-result": (value: {
+                    readonly id: string;
                     readonly type: "tool-result";
                     readonly name: string;
-                    readonly id: string;
-                    readonly result: Schema.Struct.ReadonlySide<{
-                        readonly type: Schema.Literal<"json">;
-                        readonly value: Schema.Unknown;
-                    }, "Type"> | Schema.Struct.ReadonlySide<{
-                        readonly type: Schema.Literal<"text">;
-                        readonly value: Schema.Unknown;
-                    }, "Type"> | Schema.Struct.ReadonlySide<{
-                        readonly type: Schema.Literal<"error">;
-                        readonly value: Schema.Unknown;
-                    }, "Type"> | Schema.Struct.ReadonlySide<{
-                        readonly type: Schema.Literal<"content">;
-                        readonly value: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
-                            readonly type: Schema.Literal<"text">;
-                            readonly text: Schema.String;
-                        }>, Schema.Struct<{
-                            readonly type: Schema.Literal<"file">;
-                            readonly uri: Schema.String;
-                            readonly mime: Schema.String;
-                            readonly name: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
-                        }>]>>;
-                    }, "Type">;
+                    readonly result: {
+                        readonly type: "json";
+                        readonly value: unknown;
+                    } | {
+                        readonly type: "text";
+                        readonly value: unknown;
+                    } | {
+                        readonly type: "error";
+                        readonly value: unknown;
+                    } | {
+                        readonly type: "content";
+                        readonly value: readonly ({
+                            readonly type: "text";
+                            readonly text: string;
+                        } | {
+                            readonly type: "file";
+                            readonly uri: string;
+                            readonly mime: string;
+                            readonly name?: string | undefined;
+                        })[];
+                    };
+                    readonly output?: {
+                        readonly structured: unknown;
+                        readonly content: readonly ({
+                            readonly type: "text";
+                            readonly text: string;
+                        } | {
+                            readonly type: "file";
+                            readonly uri: string;
+                            readonly mime: string;
+                            readonly name?: string | undefined;
+                        })[];
+                    } | undefined;
                     readonly providerMetadata?: {
                         readonly [x: string]: {
                             readonly [x: string]: unknown;
                         };
                     } | undefined;
                     readonly providerExecuted?: boolean | undefined;
-                    readonly output?: Schema.Struct.ReadonlySide<{
-                        readonly structured: Schema.Unknown;
-                        readonly content: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
-                            readonly type: Schema.Literal<"text">;
-                            readonly text: Schema.String;
-                        }>, Schema.Struct<{
-                            readonly type: Schema.Literal<"file">;
-                            readonly uri: Schema.String;
-                            readonly mime: Schema.String;
-                            readonly name: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
-                        }>]>>;
-                    }, "Type"> | undefined;
                 }) => any;
                 "tool-error": (value: {
+                    readonly id: string;
                     readonly type: "tool-error";
                     readonly name: string;
-                    readonly id: string;
                     readonly message: string;
                     readonly error?: unknown;
                     readonly providerMetadata?: {
@@ -3570,92 +3572,92 @@ declare const LLMResponse_base: Schema.Class<LLMResponse, Schema.Struct<{
                     } | undefined;
                     readonly classification?: "context-overflow" | undefined;
                 }) => any;
-            }>(value: Schema.Struct.ReadonlySide<{
-                readonly type: Schema.tag<"step-start">;
-                readonly index: Schema.Number;
-            }, "Type"> | {
-                readonly type: "text-start";
+            }>(value: {
+                readonly type: "step-start";
+                readonly index: number;
+            } | {
                 readonly id: string;
+                readonly type: "text-start";
                 readonly providerMetadata?: {
                     readonly [x: string]: {
                         readonly [x: string]: unknown;
                     };
                 } | undefined;
             } | {
+                readonly id: string;
                 readonly type: "text-delta";
                 readonly text: string;
-                readonly id: string;
                 readonly providerMetadata?: {
                     readonly [x: string]: {
                         readonly [x: string]: unknown;
                     };
                 } | undefined;
             } | {
-                readonly type: "text-end";
                 readonly id: string;
+                readonly type: "text-end";
                 readonly providerMetadata?: {
                     readonly [x: string]: {
                         readonly [x: string]: unknown;
                     };
                 } | undefined;
             } | {
-                readonly type: "reasoning-start";
                 readonly id: string;
+                readonly type: "reasoning-start";
                 readonly providerMetadata?: {
                     readonly [x: string]: {
                         readonly [x: string]: unknown;
                     };
                 } | undefined;
             } | {
+                readonly id: string;
                 readonly type: "reasoning-delta";
                 readonly text: string;
-                readonly id: string;
                 readonly providerMetadata?: {
                     readonly [x: string]: {
                         readonly [x: string]: unknown;
                     };
                 } | undefined;
             } | {
-                readonly type: "reasoning-end";
                 readonly id: string;
+                readonly type: "reasoning-end";
                 readonly providerMetadata?: {
                     readonly [x: string]: {
                         readonly [x: string]: unknown;
                     };
                 } | undefined;
             } | {
+                readonly id: string;
                 readonly type: "tool-input-start";
                 readonly name: string;
-                readonly id: string;
                 readonly providerMetadata?: {
                     readonly [x: string]: {
                         readonly [x: string]: unknown;
                     };
                 } | undefined;
                 readonly providerExecuted?: boolean | undefined;
-            } | Schema.Struct.ReadonlySide<{
-                readonly type: Schema.tag<"tool-input-delta">;
-                readonly id: Schema.String;
-                readonly name: Schema.String;
-                readonly text: Schema.String;
-            }, "Type"> | {
-                readonly type: "tool-input-end";
+            } | {
+                readonly type: "tool-input-delta";
+                readonly id: string;
                 readonly name: string;
+                readonly text: string;
+            } | {
                 readonly id: string;
+                readonly type: "tool-input-end";
+                readonly name: string;
                 readonly providerMetadata?: {
                     readonly [x: string]: {
                         readonly [x: string]: unknown;
                     };
                 } | undefined;
-            } | Schema.Struct.ReadonlySide<{
-                readonly type: Schema.tag<"tool-input-error">;
-                readonly id: Schema.String;
-                readonly name: Schema.String;
-                readonly raw: Schema.String;
-            }, "Type"> | {
-                readonly type: "tool-call";
+            } | {
+                readonly type: "tool-input-error";
+                readonly id: string;
                 readonly name: string;
+                readonly raw: string;
+            } | {
                 readonly id: string;
+                readonly type: "tool-call";
+                readonly name: string;
                 readonly input: unknown;
                 readonly providerMetadata?: {
                     readonly [x: string]: {
@@ -3664,52 +3666,52 @@ declare const LLMResponse_base: Schema.Class<LLMResponse, Schema.Struct<{
                 } | undefined;
                 readonly providerExecuted?: boolean | undefined;
             } | {
+                readonly id: string;
                 readonly type: "tool-result";
                 readonly name: string;
-                readonly id: string;
-                readonly result: Schema.Struct.ReadonlySide<{
-                    readonly type: Schema.Literal<"json">;
-                    readonly value: Schema.Unknown;
-                }, "Type"> | Schema.Struct.ReadonlySide<{
-                    readonly type: Schema.Literal<"text">;
-                    readonly value: Schema.Unknown;
-                }, "Type"> | Schema.Struct.ReadonlySide<{
-                    readonly type: Schema.Literal<"error">;
-                    readonly value: Schema.Unknown;
-                }, "Type"> | Schema.Struct.ReadonlySide<{
-                    readonly type: Schema.Literal<"content">;
-                    readonly value: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
-                        readonly type: Schema.Literal<"text">;
-                        readonly text: Schema.String;
-                    }>, Schema.Struct<{
-                        readonly type: Schema.Literal<"file">;
-                        readonly uri: Schema.String;
-                        readonly mime: Schema.String;
-                        readonly name: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
-                    }>]>>;
-                }, "Type">;
-                readonly providerMetadata?: {
-                    readonly [x: string]: {
-                        readonly [x: string]: unknown;
-                    };
+                readonly result: {
+                    readonly type: "json";
+                    readonly value: unknown;
+                } | {
+                    readonly type: "text";
+                    readonly value: unknown;
+                } | {
+                    readonly type: "error";
+                    readonly value: unknown;
+                } | {
+                    readonly type: "content";
+                    readonly value: readonly ({
+                        readonly type: "text";
+                        readonly text: string;
+                    } | {
+                        readonly type: "file";
+                        readonly uri: string;
+                        readonly mime: string;
+                        readonly name?: string | undefined;
+                    })[];
+                };
+                readonly output?: {
+                    readonly structured: unknown;
+                    readonly content: readonly ({
+                        readonly type: "text";
+                        readonly text: string;
+                    } | {
+                        readonly type: "file";
+                        readonly uri: string;
+                        readonly mime: string;
+                        readonly name?: string | undefined;
+                    })[];
                 } | undefined;
-                readonly providerExecuted?: boolean | undefined;
-                readonly output?: Schema.Struct.ReadonlySide<{
-                    readonly structured: Schema.Unknown;
-                    readonly content: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
-                        readonly type: Schema.Literal<"text">;
-                        readonly text: Schema.String;
-                    }>, Schema.Struct<{
-                        readonly type: Schema.Literal<"file">;
-                        readonly uri: Schema.String;
-                        readonly mime: Schema.String;
-                        readonly name: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
-                    }>]>>;
-                }, "Type"> | undefined;
+                readonly providerMetadata?: {
+                    readonly [x: string]: {
+                        readonly [x: string]: unknown;
+                    };
+                } | undefined;
+                readonly providerExecuted?: boolean | undefined;
             } | {
+                readonly id: string;
                 readonly type: "tool-error";
                 readonly name: string;
-                readonly id: string;
                 readonly message: string;
                 readonly error?: unknown;
                 readonly providerMetadata?: {
@@ -3753,13 +3755,13 @@ declare const LLMResponse_base: Schema.Class<LLMResponse, Schema.Struct<{
                 readonly classification?: "context-overflow" | undefined;
             }, cases: Cases): Cases[keyof Cases] extends (value: any) => infer R ? import("effect/Unify").Unify<R> : never;
             <Cases extends {
-                "step-start": (value: Schema.Struct.ReadonlySide<{
-                    readonly type: Schema.tag<"step-start">;
-                    readonly index: Schema.Number;
-                }, "Type">) => any;
+                "step-start": (value: {
+                    readonly type: "step-start";
+                    readonly index: number;
+                }) => any;
                 "text-start": (value: {
-                    readonly type: "text-start";
                     readonly id: string;
+                    readonly type: "text-start";
                     readonly providerMetadata?: {
                         readonly [x: string]: {
                             readonly [x: string]: unknown;
@@ -3767,9 +3769,9 @@ declare const LLMResponse_base: Schema.Class<LLMResponse, Schema.Struct<{
                     } | undefined;
                 }) => any;
                 "text-delta": (value: {
+                    readonly id: string;
                     readonly type: "text-delta";
                     readonly text: string;
-                    readonly id: string;
                     readonly providerMetadata?: {
                         readonly [x: string]: {
                             readonly [x: string]: unknown;
@@ -3777,8 +3779,8 @@ declare const LLMResponse_base: Schema.Class<LLMResponse, Schema.Struct<{
                     } | undefined;
                 }) => any;
                 "text-end": (value: {
-                    readonly type: "text-end";
                     readonly id: string;
+                    readonly type: "text-end";
                     readonly providerMetadata?: {
                         readonly [x: string]: {
                             readonly [x: string]: unknown;
@@ -3786,8 +3788,8 @@ declare const LLMResponse_base: Schema.Class<LLMResponse, Schema.Struct<{
                     } | undefined;
                 }) => any;
                 "reasoning-start": (value: {
-                    readonly type: "reasoning-start";
                     readonly id: string;
+                    readonly type: "reasoning-start";
                     readonly providerMetadata?: {
                         readonly [x: string]: {
                             readonly [x: string]: unknown;
@@ -3795,9 +3797,9 @@ declare const LLMResponse_base: Schema.Class<LLMResponse, Schema.Struct<{
                     } | undefined;
                 }) => any;
                 "reasoning-delta": (value: {
+                    readonly id: string;
                     readonly type: "reasoning-delta";
                     readonly text: string;
-                    readonly id: string;
                     readonly providerMetadata?: {
                         readonly [x: string]: {
                             readonly [x: string]: unknown;
@@ -3805,8 +3807,8 @@ declare const LLMResponse_base: Schema.Class<LLMResponse, Schema.Struct<{
                     } | undefined;
                 }) => any;
                 "reasoning-end": (value: {
-                    readonly type: "reasoning-end";
                     readonly id: string;
+                    readonly type: "reasoning-end";
                     readonly providerMetadata?: {
                         readonly [x: string]: {
                             readonly [x: string]: unknown;
@@ -3814,9 +3816,9 @@ declare const LLMResponse_base: Schema.Class<LLMResponse, Schema.Struct<{
                     } | undefined;
                 }) => any;
                 "tool-input-start": (value: {
+                    readonly id: string;
                     readonly type: "tool-input-start";
                     readonly name: string;
-                    readonly id: string;
                     readonly providerMetadata?: {
                         readonly [x: string]: {
                             readonly [x: string]: unknown;
@@ -3824,32 +3826,32 @@ declare const LLMResponse_base: Schema.Class<LLMResponse, Schema.Struct<{
                     } | undefined;
                     readonly providerExecuted?: boolean | undefined;
                 }) => any;
-                "tool-input-delta": (value: Schema.Struct.ReadonlySide<{
-                    readonly type: Schema.tag<"tool-input-delta">;
-                    readonly id: Schema.String;
-                    readonly name: Schema.String;
-                    readonly text: Schema.String;
-                }, "Type">) => any;
+                "tool-input-delta": (value: {
+                    readonly type: "tool-input-delta";
+                    readonly id: string;
+                    readonly name: string;
+                    readonly text: string;
+                }) => any;
                 "tool-input-end": (value: {
+                    readonly id: string;
                     readonly type: "tool-input-end";
                     readonly name: string;
-                    readonly id: string;
                     readonly providerMetadata?: {
                         readonly [x: string]: {
                             readonly [x: string]: unknown;
                         };
                     } | undefined;
                 }) => any;
-                "tool-input-error": (value: Schema.Struct.ReadonlySide<{
-                    readonly type: Schema.tag<"tool-input-error">;
-                    readonly id: Schema.String;
-                    readonly name: Schema.String;
-                    readonly raw: Schema.String;
-                }, "Type">) => any;
+                "tool-input-error": (value: {
+                    readonly type: "tool-input-error";
+                    readonly id: string;
+                    readonly name: string;
+                    readonly raw: string;
+                }) => any;
                 "tool-call": (value: {
+                    readonly id: string;
                     readonly type: "tool-call";
                     readonly name: string;
-                    readonly id: string;
                     readonly input: unknown;
                     readonly providerMetadata?: {
                         readonly [x: string]: {
@@ -3859,53 +3861,53 @@ declare const LLMResponse_base: Schema.Class<LLMResponse, Schema.Struct<{
                     readonly providerExecuted?: boolean | undefined;
                 }) => any;
                 "tool-result": (value: {
+                    readonly id: string;
                     readonly type: "tool-result";
                     readonly name: string;
-                    readonly id: string;
-                    readonly result: Schema.Struct.ReadonlySide<{
-                        readonly type: Schema.Literal<"json">;
-                        readonly value: Schema.Unknown;
-                    }, "Type"> | Schema.Struct.ReadonlySide<{
-                        readonly type: Schema.Literal<"text">;
-                        readonly value: Schema.Unknown;
-                    }, "Type"> | Schema.Struct.ReadonlySide<{
-                        readonly type: Schema.Literal<"error">;
-                        readonly value: Schema.Unknown;
-                    }, "Type"> | Schema.Struct.ReadonlySide<{
-                        readonly type: Schema.Literal<"content">;
-                        readonly value: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
-                            readonly type: Schema.Literal<"text">;
-                            readonly text: Schema.String;
-                        }>, Schema.Struct<{
-                            readonly type: Schema.Literal<"file">;
-                            readonly uri: Schema.String;
-                            readonly mime: Schema.String;
-                            readonly name: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
-                        }>]>>;
-                    }, "Type">;
+                    readonly result: {
+                        readonly type: "json";
+                        readonly value: unknown;
+                    } | {
+                        readonly type: "text";
+                        readonly value: unknown;
+                    } | {
+                        readonly type: "error";
+                        readonly value: unknown;
+                    } | {
+                        readonly type: "content";
+                        readonly value: readonly ({
+                            readonly type: "text";
+                            readonly text: string;
+                        } | {
+                            readonly type: "file";
+                            readonly uri: string;
+                            readonly mime: string;
+                            readonly name?: string | undefined;
+                        })[];
+                    };
+                    readonly output?: {
+                        readonly structured: unknown;
+                        readonly content: readonly ({
+                            readonly type: "text";
+                            readonly text: string;
+                        } | {
+                            readonly type: "file";
+                            readonly uri: string;
+                            readonly mime: string;
+                            readonly name?: string | undefined;
+                        })[];
+                    } | undefined;
                     readonly providerMetadata?: {
                         readonly [x: string]: {
                             readonly [x: string]: unknown;
                         };
                     } | undefined;
                     readonly providerExecuted?: boolean | undefined;
-                    readonly output?: Schema.Struct.ReadonlySide<{
-                        readonly structured: Schema.Unknown;
-                        readonly content: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
-                            readonly type: Schema.Literal<"text">;
-                            readonly text: Schema.String;
-                        }>, Schema.Struct<{
-                            readonly type: Schema.Literal<"file">;
-                            readonly uri: Schema.String;
-                            readonly mime: Schema.String;
-                            readonly name: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
-                        }>]>>;
-                    }, "Type"> | undefined;
                 }) => any;
                 "tool-error": (value: {
+                    readonly id: string;
                     readonly type: "tool-error";
                     readonly name: string;
-                    readonly id: string;
                     readonly message: string;
                     readonly error?: unknown;
                     readonly providerMetadata?: {
@@ -3951,92 +3953,92 @@ declare const LLMResponse_base: Schema.Class<LLMResponse, Schema.Struct<{
                     } | undefined;
                     readonly classification?: "context-overflow" | undefined;
                 }) => any;
-            }>(cases: Cases): (value: Schema.Struct.ReadonlySide<{
-                readonly type: Schema.tag<"step-start">;
-                readonly index: Schema.Number;
-            }, "Type"> | {
-                readonly type: "text-start";
+            }>(cases: Cases): (value: {
+                readonly type: "step-start";
+                readonly index: number;
+            } | {
                 readonly id: string;
+                readonly type: "text-start";
                 readonly providerMetadata?: {
                     readonly [x: string]: {
                         readonly [x: string]: unknown;
                     };
                 } | undefined;
             } | {
+                readonly id: string;
                 readonly type: "text-delta";
                 readonly text: string;
-                readonly id: string;
                 readonly providerMetadata?: {
                     readonly [x: string]: {
                         readonly [x: string]: unknown;
                     };
                 } | undefined;
             } | {
-                readonly type: "text-end";
                 readonly id: string;
+                readonly type: "text-end";
                 readonly providerMetadata?: {
                     readonly [x: string]: {
                         readonly [x: string]: unknown;
                     };
                 } | undefined;
             } | {
-                readonly type: "reasoning-start";
                 readonly id: string;
+                readonly type: "reasoning-start";
                 readonly providerMetadata?: {
                     readonly [x: string]: {
                         readonly [x: string]: unknown;
                     };
                 } | undefined;
             } | {
+                readonly id: string;
                 readonly type: "reasoning-delta";
                 readonly text: string;
-                readonly id: string;
                 readonly providerMetadata?: {
                     readonly [x: string]: {
                         readonly [x: string]: unknown;
                     };
                 } | undefined;
             } | {
-                readonly type: "reasoning-end";
                 readonly id: string;
+                readonly type: "reasoning-end";
                 readonly providerMetadata?: {
                     readonly [x: string]: {
                         readonly [x: string]: unknown;
                     };
                 } | undefined;
             } | {
+                readonly id: string;
                 readonly type: "tool-input-start";
                 readonly name: string;
-                readonly id: string;
                 readonly providerMetadata?: {
                     readonly [x: string]: {
                         readonly [x: string]: unknown;
                     };
                 } | undefined;
                 readonly providerExecuted?: boolean | undefined;
-            } | Schema.Struct.ReadonlySide<{
-                readonly type: Schema.tag<"tool-input-delta">;
-                readonly id: Schema.String;
-                readonly name: Schema.String;
-                readonly text: Schema.String;
-            }, "Type"> | {
-                readonly type: "tool-input-end";
+            } | {
+                readonly type: "tool-input-delta";
+                readonly id: string;
                 readonly name: string;
+                readonly text: string;
+            } | {
                 readonly id: string;
+                readonly type: "tool-input-end";
+                readonly name: string;
                 readonly providerMetadata?: {
                     readonly [x: string]: {
                         readonly [x: string]: unknown;
                     };
                 } | undefined;
-            } | Schema.Struct.ReadonlySide<{
-                readonly type: Schema.tag<"tool-input-error">;
-                readonly id: Schema.String;
-                readonly name: Schema.String;
-                readonly raw: Schema.String;
-            }, "Type"> | {
-                readonly type: "tool-call";
+            } | {
+                readonly type: "tool-input-error";
+                readonly id: string;
                 readonly name: string;
+                readonly raw: string;
+            } | {
                 readonly id: string;
+                readonly type: "tool-call";
+                readonly name: string;
                 readonly input: unknown;
                 readonly providerMetadata?: {
                     readonly [x: string]: {
@@ -4045,52 +4047,52 @@ declare const LLMResponse_base: Schema.Class<LLMResponse, Schema.Struct<{
                 } | undefined;
                 readonly providerExecuted?: boolean | undefined;
             } | {
+                readonly id: string;
                 readonly type: "tool-result";
                 readonly name: string;
-                readonly id: string;
-                readonly result: Schema.Struct.ReadonlySide<{
-                    readonly type: Schema.Literal<"json">;
-                    readonly value: Schema.Unknown;
-                }, "Type"> | Schema.Struct.ReadonlySide<{
-                    readonly type: Schema.Literal<"text">;
-                    readonly value: Schema.Unknown;
-                }, "Type"> | Schema.Struct.ReadonlySide<{
-                    readonly type: Schema.Literal<"error">;
-                    readonly value: Schema.Unknown;
-                }, "Type"> | Schema.Struct.ReadonlySide<{
-                    readonly type: Schema.Literal<"content">;
-                    readonly value: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
-                        readonly type: Schema.Literal<"text">;
-                        readonly text: Schema.String;
-                    }>, Schema.Struct<{
-                        readonly type: Schema.Literal<"file">;
-                        readonly uri: Schema.String;
-                        readonly mime: Schema.String;
-                        readonly name: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
-                    }>]>>;
-                }, "Type">;
+                readonly result: {
+                    readonly type: "json";
+                    readonly value: unknown;
+                } | {
+                    readonly type: "text";
+                    readonly value: unknown;
+                } | {
+                    readonly type: "error";
+                    readonly value: unknown;
+                } | {
+                    readonly type: "content";
+                    readonly value: readonly ({
+                        readonly type: "text";
+                        readonly text: string;
+                    } | {
+                        readonly type: "file";
+                        readonly uri: string;
+                        readonly mime: string;
+                        readonly name?: string | undefined;
+                    })[];
+                };
+                readonly output?: {
+                    readonly structured: unknown;
+                    readonly content: readonly ({
+                        readonly type: "text";
+                        readonly text: string;
+                    } | {
+                        readonly type: "file";
+                        readonly uri: string;
+                        readonly mime: string;
+                        readonly name?: string | undefined;
+                    })[];
+                } | undefined;
                 readonly providerMetadata?: {
                     readonly [x: string]: {
                         readonly [x: string]: unknown;
                     };
                 } | undefined;
                 readonly providerExecuted?: boolean | undefined;
-                readonly output?: Schema.Struct.ReadonlySide<{
-                    readonly structured: Schema.Unknown;
-                    readonly content: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
-                        readonly type: Schema.Literal<"text">;
-                        readonly text: Schema.String;
-                    }>, Schema.Struct<{
-                        readonly type: Schema.Literal<"file">;
-                        readonly uri: Schema.String;
-                        readonly mime: Schema.String;
-                        readonly name: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
-                    }>]>>;
-                }, "Type"> | undefined;
             } | {
+                readonly id: string;
                 readonly type: "tool-error";
                 readonly name: string;
-                readonly id: string;
                 readonly message: string;
                 readonly error?: unknown;
                 readonly providerMetadata?: {
@@ -4138,13 +4140,13 @@ declare const LLMResponse_base: Schema.Class<LLMResponse, Schema.Struct<{
         stepStart: (input: {
             readonly index: number;
             readonly type?: "step-start" | undefined;
-        }, options?: Schema.MakeOptions) => Schema.Struct.ReadonlySide<{
-            readonly type: Schema.tag<"step-start">;
-            readonly index: Schema.Number;
-        }, "Type">;
+        }, options?: Schema.MakeOptions) => {
+            readonly type: "step-start";
+            readonly index: number;
+        };
         textStart: (input: WithID<TextStart, ContentBlockID>) => {
-            readonly type: "text-start";
             readonly id: string;
+            readonly type: "text-start";
             readonly providerMetadata?: {
                 readonly [x: string]: {
                     readonly [x: string]: unknown;
@@ -4152,9 +4154,9 @@ declare const LLMResponse_base: Schema.Class<LLMResponse, Schema.Struct<{
             } | undefined;
         };
         textDelta: (input: WithID<TextDelta, ContentBlockID>) => {
+            readonly id: string;
             readonly type: "text-delta";
             readonly text: string;
-            readonly id: string;
             readonly providerMetadata?: {
                 readonly [x: string]: {
                     readonly [x: string]: unknown;
@@ -4162,8 +4164,8 @@ declare const LLMResponse_base: Schema.Class<LLMResponse, Schema.Struct<{
             } | undefined;
         };
         textEnd: (input: WithID<TextEnd, ContentBlockID>) => {
-            readonly type: "text-end";
             readonly id: string;
+            readonly type: "text-end";
             readonly providerMetadata?: {
                 readonly [x: string]: {
                     readonly [x: string]: unknown;
@@ -4171,8 +4173,8 @@ declare const LLMResponse_base: Schema.Class<LLMResponse, Schema.Struct<{
             } | undefined;
         };
         reasoningStart: (input: WithID<ReasoningStart, ContentBlockID>) => {
-            readonly type: "reasoning-start";
             readonly id: string;
+            readonly type: "reasoning-start";
             readonly providerMetadata?: {
                 readonly [x: string]: {
                     readonly [x: string]: unknown;
@@ -4180,9 +4182,9 @@ declare const LLMResponse_base: Schema.Class<LLMResponse, Schema.Struct<{
             } | undefined;
         };
         reasoningDelta: (input: WithID<ReasoningDelta, ContentBlockID>) => {
+            readonly id: string;
             readonly type: "reasoning-delta";
             readonly text: string;
-            readonly id: string;
             readonly providerMetadata?: {
                 readonly [x: string]: {
                     readonly [x: string]: unknown;
@@ -4190,8 +4192,8 @@ declare const LLMResponse_base: Schema.Class<LLMResponse, Schema.Struct<{
             } | undefined;
         };
         reasoningEnd: (input: WithID<ReasoningEnd, ContentBlockID>) => {
-            readonly type: "reasoning-end";
             readonly id: string;
+            readonly type: "reasoning-end";
             readonly providerMetadata?: {
                 readonly [x: string]: {
                     readonly [x: string]: unknown;
@@ -4199,9 +4201,9 @@ declare const LLMResponse_base: Schema.Class<LLMResponse, Schema.Struct<{
             } | undefined;
         };
         toolInputStart: (input: WithID<ToolInputStart, ToolCallID>) => {
+            readonly id: string;
             readonly type: "tool-input-start";
             readonly name: string;
-            readonly id: string;
             readonly providerMetadata?: {
                 readonly [x: string]: {
                     readonly [x: string]: unknown;
@@ -4209,32 +4211,32 @@ declare const LLMResponse_base: Schema.Class<LLMResponse, Schema.Struct<{
             } | undefined;
             readonly providerExecuted?: boolean | undefined;
         };
-        toolInputDelta: (input: WithID<ToolInputDelta, ToolCallID>) => Schema.Struct.ReadonlySide<{
-            readonly type: Schema.tag<"tool-input-delta">;
-            readonly id: Schema.String;
-            readonly name: Schema.String;
-            readonly text: Schema.String;
-        }, "Type">;
+        toolInputDelta: (input: WithID<ToolInputDelta, ToolCallID>) => {
+            readonly type: "tool-input-delta";
+            readonly id: string;
+            readonly name: string;
+            readonly text: string;
+        };
         toolInputEnd: (input: WithID<ToolInputEnd, ToolCallID>) => {
+            readonly id: string;
             readonly type: "tool-input-end";
             readonly name: string;
-            readonly id: string;
             readonly providerMetadata?: {
                 readonly [x: string]: {
                     readonly [x: string]: unknown;
                 };
             } | undefined;
         };
-        toolInputError: (input: WithID<ToolInputError, ToolCallID>) => Schema.Struct.ReadonlySide<{
-            readonly type: Schema.tag<"tool-input-error">;
-            readonly id: Schema.String;
-            readonly name: Schema.String;
-            readonly raw: Schema.String;
-        }, "Type">;
+        toolInputError: (input: WithID<ToolInputError, ToolCallID>) => {
+            readonly type: "tool-input-error";
+            readonly id: string;
+            readonly name: string;
+            readonly raw: string;
+        };
         toolCall: (input: WithID<ToolCall, ToolCallID>) => {
+            readonly id: string;
             readonly type: "tool-call";
             readonly name: string;
-            readonly id: string;
             readonly input: unknown;
             readonly providerMetadata?: {
                 readonly [x: string]: {
@@ -4244,53 +4246,53 @@ declare const LLMResponse_base: Schema.Class<LLMResponse, Schema.Struct<{
             readonly providerExecuted?: boolean | undefined;
         };
         toolResult: (input: WithID<ToolResult, ToolCallID>) => {
+            readonly id: string;
             readonly type: "tool-result";
             readonly name: string;
-            readonly id: string;
-            readonly result: Schema.Struct.ReadonlySide<{
-                readonly type: Schema.Literal<"json">;
-                readonly value: Schema.Unknown;
-            }, "Type"> | Schema.Struct.ReadonlySide<{
-                readonly type: Schema.Literal<"text">;
-                readonly value: Schema.Unknown;
-            }, "Type"> | Schema.Struct.ReadonlySide<{
-                readonly type: Schema.Literal<"error">;
-                readonly value: Schema.Unknown;
-            }, "Type"> | Schema.Struct.ReadonlySide<{
-                readonly type: Schema.Literal<"content">;
-                readonly value: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
-                    readonly type: Schema.Literal<"text">;
-                    readonly text: Schema.String;
-                }>, Schema.Struct<{
-                    readonly type: Schema.Literal<"file">;
-                    readonly uri: Schema.String;
-                    readonly mime: Schema.String;
-                    readonly name: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
-                }>]>>;
-            }, "Type">;
+            readonly result: {
+                readonly type: "json";
+                readonly value: unknown;
+            } | {
+                readonly type: "text";
+                readonly value: unknown;
+            } | {
+                readonly type: "error";
+                readonly value: unknown;
+            } | {
+                readonly type: "content";
+                readonly value: readonly ({
+                    readonly type: "text";
+                    readonly text: string;
+                } | {
+                    readonly type: "file";
+                    readonly uri: string;
+                    readonly mime: string;
+                    readonly name?: string | undefined;
+                })[];
+            };
+            readonly output?: {
+                readonly structured: unknown;
+                readonly content: readonly ({
+                    readonly type: "text";
+                    readonly text: string;
+                } | {
+                    readonly type: "file";
+                    readonly uri: string;
+                    readonly mime: string;
+                    readonly name?: string | undefined;
+                })[];
+            } | undefined;
             readonly providerMetadata?: {
                 readonly [x: string]: {
                     readonly [x: string]: unknown;
                 };
             } | undefined;
             readonly providerExecuted?: boolean | undefined;
-            readonly output?: Schema.Struct.ReadonlySide<{
-                readonly structured: Schema.Unknown;
-                readonly content: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
-                    readonly type: Schema.Literal<"text">;
-                    readonly text: Schema.String;
-                }>, Schema.Struct<{
-                    readonly type: Schema.Literal<"file">;
-                    readonly uri: Schema.String;
-                    readonly mime: Schema.String;
-                    readonly name: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
-                }>]>>;
-            }, "Type"> | undefined;
         };
         toolError: (input: WithID<ToolError, ToolCallID>) => {
+            readonly id: string;
             readonly type: "tool-error";
             readonly name: string;
-            readonly id: string;
             readonly message: string;
             readonly error?: unknown;
             readonly providerMetadata?: {
@@ -4346,13 +4348,13 @@ declare const LLMResponse_base: Schema.Class<LLMResponse, Schema.Struct<{
             readonly classification?: "context-overflow" | undefined;
         };
         is: {
-            stepStart: (u: unknown) => u is Schema.Struct.ReadonlySide<{
-                readonly type: Schema.tag<"step-start">;
-                readonly index: Schema.Number;
-            }, "Type">;
+            stepStart: (u: unknown) => u is {
+                readonly type: "step-start";
+                readonly index: number;
+            };
             textStart: (u: unknown) => u is {
-                readonly type: "text-start";
                 readonly id: string;
+                readonly type: "text-start";
                 readonly providerMetadata?: {
                     readonly [x: string]: {
                         readonly [x: string]: unknown;
@@ -4360,9 +4362,9 @@ declare const LLMResponse_base: Schema.Class<LLMResponse, Schema.Struct<{
                 } | undefined;
             };
             textDelta: (u: unknown) => u is {
+                readonly id: string;
                 readonly type: "text-delta";
                 readonly text: string;
-                readonly id: string;
                 readonly providerMetadata?: {
                     readonly [x: string]: {
                         readonly [x: string]: unknown;
@@ -4370,8 +4372,8 @@ declare const LLMResponse_base: Schema.Class<LLMResponse, Schema.Struct<{
                 } | undefined;
             };
             textEnd: (u: unknown) => u is {
-                readonly type: "text-end";
                 readonly id: string;
+                readonly type: "text-end";
                 readonly providerMetadata?: {
                     readonly [x: string]: {
                         readonly [x: string]: unknown;
@@ -4379,8 +4381,8 @@ declare const LLMResponse_base: Schema.Class<LLMResponse, Schema.Struct<{
                 } | undefined;
             };
             reasoningStart: (u: unknown) => u is {
-                readonly type: "reasoning-start";
                 readonly id: string;
+                readonly type: "reasoning-start";
                 readonly providerMetadata?: {
                     readonly [x: string]: {
                         readonly [x: string]: unknown;
@@ -4388,9 +4390,9 @@ declare const LLMResponse_base: Schema.Class<LLMResponse, Schema.Struct<{
                 } | undefined;
             };
             reasoningDelta: (u: unknown) => u is {
+                readonly id: string;
                 readonly type: "reasoning-delta";
                 readonly text: string;
-                readonly id: string;
                 readonly providerMetadata?: {
                     readonly [x: string]: {
                         readonly [x: string]: unknown;
@@ -4398,8 +4400,8 @@ declare const LLMResponse_base: Schema.Class<LLMResponse, Schema.Struct<{
                 } | undefined;
             };
             reasoningEnd: (u: unknown) => u is {
-                readonly type: "reasoning-end";
                 readonly id: string;
+                readonly type: "reasoning-end";
                 readonly providerMetadata?: {
                     readonly [x: string]: {
                         readonly [x: string]: unknown;
@@ -4407,9 +4409,9 @@ declare const LLMResponse_base: Schema.Class<LLMResponse, Schema.Struct<{
                 } | undefined;
             };
             toolInputStart: (u: unknown) => u is {
+                readonly id: string;
                 readonly type: "tool-input-start";
                 readonly name: string;
-                readonly id: string;
                 readonly providerMetadata?: {
                     readonly [x: string]: {
                         readonly [x: string]: unknown;
@@ -4417,32 +4419,32 @@ declare const LLMResponse_base: Schema.Class<LLMResponse, Schema.Struct<{
                 } | undefined;
                 readonly providerExecuted?: boolean | undefined;
             };
-            toolInputDelta: (u: unknown) => u is Schema.Struct.ReadonlySide<{
-                readonly type: Schema.tag<"tool-input-delta">;
-                readonly id: Schema.String;
-                readonly name: Schema.String;
-                readonly text: Schema.String;
-            }, "Type">;
+            toolInputDelta: (u: unknown) => u is {
+                readonly type: "tool-input-delta";
+                readonly id: string;
+                readonly name: string;
+                readonly text: string;
+            };
             toolInputEnd: (u: unknown) => u is {
+                readonly id: string;
                 readonly type: "tool-input-end";
                 readonly name: string;
-                readonly id: string;
                 readonly providerMetadata?: {
                     readonly [x: string]: {
                         readonly [x: string]: unknown;
                     };
                 } | undefined;
             };
-            toolInputError: (u: unknown) => u is Schema.Struct.ReadonlySide<{
-                readonly type: Schema.tag<"tool-input-error">;
-                readonly id: Schema.String;
-                readonly name: Schema.String;
-                readonly raw: Schema.String;
-            }, "Type">;
+            toolInputError: (u: unknown) => u is {
+                readonly type: "tool-input-error";
+                readonly id: string;
+                readonly name: string;
+                readonly raw: string;
+            };
             toolCall: (u: unknown) => u is {
+                readonly id: string;
                 readonly type: "tool-call";
                 readonly name: string;
-                readonly id: string;
                 readonly input: unknown;
                 readonly providerMetadata?: {
                     readonly [x: string]: {
@@ -4452,53 +4454,53 @@ declare const LLMResponse_base: Schema.Class<LLMResponse, Schema.Struct<{
                 readonly providerExecuted?: boolean | undefined;
             };
             toolResult: (u: unknown) => u is {
+                readonly id: string;
                 readonly type: "tool-result";
                 readonly name: string;
-                readonly id: string;
-                readonly result: Schema.Struct.ReadonlySide<{
-                    readonly type: Schema.Literal<"json">;
-                    readonly value: Schema.Unknown;
-                }, "Type"> | Schema.Struct.ReadonlySide<{
-                    readonly type: Schema.Literal<"text">;
-                    readonly value: Schema.Unknown;
-                }, "Type"> | Schema.Struct.ReadonlySide<{
-                    readonly type: Schema.Literal<"error">;
-                    readonly value: Schema.Unknown;
-                }, "Type"> | Schema.Struct.ReadonlySide<{
-                    readonly type: Schema.Literal<"content">;
-                    readonly value: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
-                        readonly type: Schema.Literal<"text">;
-                        readonly text: Schema.String;
-                    }>, Schema.Struct<{
-                        readonly type: Schema.Literal<"file">;
-                        readonly uri: Schema.String;
-                        readonly mime: Schema.String;
-                        readonly name: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
-                    }>]>>;
-                }, "Type">;
+                readonly result: {
+                    readonly type: "json";
+                    readonly value: unknown;
+                } | {
+                    readonly type: "text";
+                    readonly value: unknown;
+                } | {
+                    readonly type: "error";
+                    readonly value: unknown;
+                } | {
+                    readonly type: "content";
+                    readonly value: readonly ({
+                        readonly type: "text";
+                        readonly text: string;
+                    } | {
+                        readonly type: "file";
+                        readonly uri: string;
+                        readonly mime: string;
+                        readonly name?: string | undefined;
+                    })[];
+                };
+                readonly output?: {
+                    readonly structured: unknown;
+                    readonly content: readonly ({
+                        readonly type: "text";
+                        readonly text: string;
+                    } | {
+                        readonly type: "file";
+                        readonly uri: string;
+                        readonly mime: string;
+                        readonly name?: string | undefined;
+                    })[];
+                } | undefined;
                 readonly providerMetadata?: {
                     readonly [x: string]: {
                         readonly [x: string]: unknown;
                     };
                 } | undefined;
                 readonly providerExecuted?: boolean | undefined;
-                readonly output?: Schema.Struct.ReadonlySide<{
-                    readonly structured: Schema.Unknown;
-                    readonly content: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
-                        readonly type: Schema.Literal<"text">;
-                        readonly text: Schema.String;
-                    }>, Schema.Struct<{
-                        readonly type: Schema.Literal<"file">;
-                        readonly uri: Schema.String;
-                        readonly mime: Schema.String;
-                        readonly name: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
-                    }>]>>;
-                }, "Type"> | undefined;
             };
             toolError: (u: unknown) => u is {
+                readonly id: string;
                 readonly type: "tool-error";
                 readonly name: string;
-                readonly id: string;
                 readonly message: string;
                 readonly error?: unknown;
                 readonly providerMetadata?: {
@@ -4559,9 +4561,9 @@ export declare class LLMResponse extends LLMResponse_base {
     get reasoning(): string;
     /** Completed tool calls emitted by the provider. */
     get toolCalls(): {
+        readonly id: string;
         readonly type: "tool-call";
         readonly name: string;
-        readonly id: string;
         readonly input: unknown;
         readonly providerMetadata?: {
             readonly [x: string]: {
@@ -4591,9 +4593,9 @@ export declare namespace LLMResponse {
     const usage: (response: Output) => Usage | undefined;
     /** Return completed tool calls from a response or collected event list. */
     const toolCalls: (response: Output) => {
+        readonly id: string;
         readonly type: "tool-call";
         readonly name: string;
-        readonly id: string;
         readonly input: unknown;
         readonly providerMetadata?: {
             readonly [x: string]: {