effect 4.0.5 → 4.0.7

package/src/ai/Prompt.ts

@@ -465,9 +465,15 @@ export interface FilePartEncoded extends BasePartEncoded<"file", FilePartOptions
    */
   readonly fileName?: string | undefined
   /**
-   * File data as base64 string of data, a byte array, or a URL.
-   */
-  readonly data: string | Uint8Array | URL
+   * File data as a base64 string, a byte array, a URL, or the tagged JSON
+   * form that encoding produces for byte arrays and URLs.
+   */
+  readonly data:
+    | string
+    | Uint8Array
+    | URL
+    | { readonly _tag: "Uint8Array"; readonly base64: string }
+    | { readonly _tag: "URL"; readonly href: string }
 }
 
 /**
@@ -491,7 +497,18 @@ export const FilePart: Schema.Struct<{
   readonly type: Schema.Literal<"file">
   readonly mediaType: Schema.String
   readonly fileName: Schema.optional<Schema.String>
-  readonly data: Schema.Union<readonly [Schema.String, Schema.Uint8Array, Schema.URL]>
+  readonly data: Schema.Union<
+    readonly [
+      Schema.String,
+      Schema.decodeTo<
+        Schema.Uint8Array,
+        Schema.TaggedStruct<"Uint8Array", { readonly base64: Schema.Uint8ArrayFromBase64 }>
+      >,
+      Schema.decodeTo<Schema.URL, Schema.TaggedStruct<"URL", { readonly href: Schema.URLFromString }>>,
+      Schema.Uint8Array,
+      Schema.URL
+    ]
+  >
   readonly "~effect/ai/Prompt/Part": Schema.withDecodingDefaultKey<Schema.Literal<"~effect/ai/Prompt/Part">>
   readonly options: Schema.withDecodingDefault<
     Schema.$Record<
@@ -504,7 +521,33 @@ export const FilePart: Schema.Struct<{
   type: Schema.Literal("file"),
   mediaType: Schema.String,
   fileName: Schema.optional(Schema.String),
-  data: Schema.Union([Schema.String, Schema.Uint8Array, Schema.URL])
+  // The tagged members come first so that encoding produces JSON-safe data,
+  // while the raw members keep decoding byte arrays and URLs directly
+  data: Schema.Union([
+    Schema.String,
+    Schema.TaggedStruct("Uint8Array", { base64: Schema.Uint8ArrayFromBase64 }).pipe(Schema.decodeTo(
+      Schema.Uint8Array,
+      SchemaTransformation.transform({
+        decode: ({ base64 }) => base64,
+        encode: (base64) => (({
+          _tag: "Uint8Array",
+          base64
+        }) as const)
+      })
+    )),
+    Schema.TaggedStruct("URL", { href: Schema.URLFromString }).pipe(Schema.decodeTo(
+      Schema.URL,
+      SchemaTransformation.transform({
+        decode: ({ href }) => href,
+        encode: (href) => (({
+          _tag: "URL",
+          href
+        }) as const)
+      })
+    )),
+    Schema.Uint8Array,
+    Schema.URL
+  ])
 }).annotate({ identifier: "FilePart" })
 
 /**
@@ -646,6 +689,60 @@ export const toolCallPart = (params: PartConstructorParams<ToolCallPart>): ToolC
 // Tool Result Part
 // =============================================================================
 
+/**
+ * A part returned by a tool's `toModelOutput` mapping and sent to the model in
+ * place of the serialized tool result.
+ *
+ * @stability unstable
+ * @category models
+ * @since 4.0.0
+ */
+export type ToolModelOutputPart = TextPart | FilePart
+
+/**
+ * Schema for validation and encoding of tool model output parts.
+ *
+ * @stability unstable
+ * @category schemas
+ * @since 4.0.0
+ */
+export const ToolModelOutputPart: Schema.Union<readonly [typeof TextPart, typeof FilePart]> = Schema.Union([
+  TextPart,
+  FilePart
+])
+
+/**
+ * Converts tool model output to text for providers that only accept text tool
+ * results.
+ *
+ * **Details**
+ *
+ * Joins text parts with newlines and replaces each file part with a placeholder
+ * naming its media type and file name.
+ *
+ * **Example** (Converting tool model output to text)
+ *
+ * ```ts import.meta.vitest
+ * import { Prompt } from "effect/ai"
+ *
+ * const text = Prompt.toolModelOutputToText([
+ *   Prompt.textPart({ text: "Screenshot" }),
+ *   Prompt.filePart({ mediaType: "image/png", fileName: "screenshot.png", data: "iVBORw0KGgo=" })
+ * ])
+ * text // => "Screenshot\n[image/png screenshot.png omitted]"
+ * ```
+ *
+ * @stability unstable
+ * @category combinators
+ * @since 4.0.0
+ */
+export const toolModelOutputToText = (parts: ReadonlyArray<ToolModelOutputPart>): string =>
+  parts.map((part) =>
+    part.type === "text"
+      ? part.text
+      : `[${part.mediaType}${part.fileName === undefined ? "" : ` ${part.fileName}`} omitted]`
+  ).join("\n")
+
 /**
  * Content part representing the result of a tool call.
  *
@@ -689,6 +786,10 @@ export interface ToolResultPart extends BasePart<"tool-result", ToolResultPartOp
    * The result returned by the tool execution.
    */
   readonly result: unknown
+  /**
+   * Content sent to the model in place of the serialized `result`.
+   */
+  readonly modelOutput?: ReadonlyArray<ToolModelOutputPart> | undefined
   /**
    * Whether the tool was executed by the provider (true) or framework (false).
    */
@@ -719,6 +820,10 @@ export interface ToolResultPartEncoded extends BasePartEncoded<"tool-result", To
    * The result returned by the tool execution.
    */
   readonly result: unknown
+  /**
+   * Content sent to the model in place of the serialized `result`.
+   */
+  readonly modelOutput?: ReadonlyArray<TextPartEncoded | FilePartEncoded> | undefined
   /**
    * Whether the tool was executed by the provider (true) or framework (false).
    */
@@ -748,6 +853,7 @@ export const ToolResultPart: Schema.Struct<{
   readonly name: Schema.String
   readonly isFailure: Schema.Boolean
   readonly result: Schema.Unknown
+  readonly modelOutput: Schema.optional<Schema.$Array<typeof ToolModelOutputPart>>
   readonly providerExecuted: Schema.withDecodingDefault<Schema.Boolean>
   readonly "~effect/ai/Prompt/Part": Schema.withDecodingDefaultKey<Schema.Literal<"~effect/ai/Prompt/Part">>
   readonly options: Schema.withDecodingDefault<
@@ -763,6 +869,7 @@ export const ToolResultPart: Schema.Struct<{
   name: Schema.String,
   isFailure: Schema.Boolean,
   result: Schema.Unknown,
+  modelOutput: Schema.optional(Schema.Array(ToolModelOutputPart)),
   providerExecuted: Schema.Boolean.pipe(Schema.withDecodingDefault(Effect.succeed(false)))
 }).annotate({ identifier: "ToolResultPart" })
 
@@ -1407,36 +1514,7 @@ export const UserMessage: Schema.Struct<{
         never,
         never
       >,
-      Schema.$Array<
-        Schema.Union<
-          readonly [
-            Schema.Struct<{
-              readonly type: Schema.Literal<"text">
-              readonly text: Schema.String
-              readonly "~effect/ai/Prompt/Part": Schema.withDecodingDefaultKey<Schema.Literal<"~effect/ai/Prompt/Part">>
-              readonly options: Schema.withDecodingDefault<
-                Schema.$Record<
-                  Schema.String,
-                  Schema.NullOr<Schema.Codec<Schema.Json>>
-                >
-              >
-            }>,
-            Schema.Struct<{
-              readonly type: Schema.Literal<"file">
-              readonly mediaType: Schema.String
-              readonly fileName: Schema.optional<Schema.String>
-              readonly data: Schema.Union<readonly [Schema.String, Schema.Uint8Array, Schema.URL]>
-              readonly "~effect/ai/Prompt/Part": Schema.withDecodingDefaultKey<Schema.Literal<"~effect/ai/Prompt/Part">>
-              readonly options: Schema.withDecodingDefault<
-                Schema.$Record<
-                  Schema.String,
-                  Schema.NullOr<Schema.Codec<Schema.Json>>
-                >
-              >
-            }>
-          ]
-        >
-      >
+      Schema.$Array<Schema.Union<readonly [typeof TextPart, typeof FilePart]>>
     ]
   >
   readonly "~effect/ai/Prompt/Message": Schema.withDecodingDefaultKey<Schema.Literal<"~effect/ai/Prompt/Message">>
@@ -2258,6 +2336,7 @@ export const fromResponseParts = (parts: ReadonlyArray<Response.AnyPart>): Promp
             name: part.name,
             isFailure: part.isFailure,
             result: part.encodedResult,
+            ...(part.modelOutput !== undefined ? { modelOutput: part.modelOutput } : undefined),
             providerExecuted: part.providerExecuted ?? false,
             options: part.metadata
           }))

package/src/ai/Response.ts

@@ -18,6 +18,7 @@ import * as Predicate from "../Predicate.ts"
 import * as Schema from "../Schema.ts"
 import * as SchemaTransformation from "../SchemaTransformation.ts"
 import * as AiError from "./AiError.ts"
+import * as Prompt from "./Prompt.ts"
 import * as Tool from "./Tool.ts"
 import type * as Toolkit from "./Toolkit.ts"
 
@@ -170,6 +171,33 @@ const toolPartSchemas = (tool: Tool.Any) => {
   return parts
 }
 
+type AnyToolParts = ToolCallPart<string, unknown> | ToolResultPart<string, unknown, unknown>
+
+type ToolkitTools<T> = T extends Toolkit.Any ? Toolkit.Tools<T> : Toolkit.WithHandlerTools<T>
+
+type ToolkitTool<T> = ToolkitTools<T>[keyof ToolkitTools<T>]
+
+type ToolkitDecodingServices<T> =
+  | Tool.ParametersDecodingServices<ToolkitTool<T>>
+  | Tool.ResultDecodingServices<ToolkitTool<T>>
+
+type ToolkitEncodingServices<T> =
+  | Tool.ParametersEncodingServices<ToolkitTool<T>>
+  | Tool.ResultEncodingServices<ToolkitTool<T>>
+
+const toolPartSchemasFor = (
+  toolkit: Toolkit.Any | Toolkit.WithHandler<any> | undefined
+): ReadonlyArray<Schema.Top> => {
+  if (toolkit === undefined) {
+    return [
+      makeToolCallPart(Schema.String, Schema.Unknown),
+      makeToolResultPart(Schema.String, Schema.Unknown, Schema.Unknown)
+    ]
+  }
+  const parts = Object.values(toolkit.tools as Record<string, Tool.Any>).map(toolPartSchemas)
+  return [...parts.map((part) => part.toolCall), ...parts.map((part) => part.toolResult)]
+}
+
 /**
  * Creates a Schema for all response parts based on a toolkit.
  *
@@ -178,6 +206,9 @@ const toolPartSchemas = (tool: Tool.Any) => {
  * Generates a schema that includes all possible response parts, with tool call
  * and tool result parts dynamically created based on the provided toolkit.
  *
+ * When no toolkit is provided, tool call and tool result parts accept any tool
+ * name, with parameters and results decoded as `unknown`.
+ *
  * **Example** (Building a response parts schema)
  *
  * ```ts import.meta.vitest
@@ -193,28 +224,95 @@ const toolPartSchemas = (tool: Tool.Any) => {
  *
  * const allPartsSchema = Response.AllParts(myToolkit)
  * Schema.isSchema(allPartsSchema) // => true
+ *
+ * const anyToolPartsSchema = Response.AllParts()
+ * Schema.isSchema(anyToolPartsSchema) // => true
  * ```
  *
  * @stability unstable
  * @category schemas
  * @since 4.0.0
  */
-export const AllParts = <T extends Toolkit.Any | Toolkit.WithHandler<any>>(
-  toolkit: T
-): Schema.Codec<
-  AllParts<T extends Toolkit.Any ? Toolkit.Tools<T> : Toolkit.WithHandlerTools<T>>,
-  AllPartsEncoded,
-  Tool.ResultDecodingServices<Toolkit.Tools<T>[keyof Toolkit.Tools<T>]>,
-  Tool.ResultEncodingServices<Toolkit.Tools<T>[keyof Toolkit.Tools<T>]>
-> => {
-  const toolCalls: Array<Schema.Top> = []
-  const toolResults: Array<Schema.Top> = []
-  for (const tool of Object.values(toolkit.tools as Record<string, Tool.Any>)) {
-    const parts = toolPartSchemas(tool)
-    toolCalls.push(parts.toolCall)
-    toolResults.push(parts.toolResult)
-  }
-  return Schema.Union([
+export const AllParts: {
+  /**
+   * Creates a Schema for all response parts based on a toolkit.
+   *
+   * **Details**
+   *
+   * Generates a schema that includes all possible response parts, with tool call
+   * and tool result parts dynamically created based on the provided toolkit.
+   *
+   * When no toolkit is provided, tool call and tool result parts accept any tool
+   * name, with parameters and results decoded as `unknown`.
+   *
+   * **Example** (Building a response parts schema)
+   *
+   * ```ts import.meta.vitest
+   * import { Schema } from "effect"
+   * import { Response, Tool, Toolkit } from "effect/ai"
+   *
+   * const myToolkit = Toolkit.make(
+   *   Tool.make("GetWeather", {
+   *     parameters: Schema.Struct({ city: Schema.String }),
+   *     success: Schema.Struct({ temperature: Schema.Number })
+   *   })
+   * )
+   *
+   * const allPartsSchema = Response.AllParts(myToolkit)
+   * Schema.isSchema(allPartsSchema) // => true
+   *
+   * const anyToolPartsSchema = Response.AllParts()
+   * Schema.isSchema(anyToolPartsSchema) // => true
+   * ```
+   *
+   * @stability unstable
+   * @category schemas
+   * @since 4.0.0
+   */
+  <T extends Toolkit.Any | Toolkit.WithHandler<any>>(toolkit: T): Schema.Codec<
+    AllParts<ToolkitTools<T>>,
+    AllPartsEncoded,
+    ToolkitDecodingServices<T>,
+    ToolkitEncodingServices<T>
+  >
+  /**
+   * Creates a Schema for all response parts based on a toolkit.
+   *
+   * **Details**
+   *
+   * Generates a schema that includes all possible response parts, with tool call
+   * and tool result parts dynamically created based on the provided toolkit.
+   *
+   * When no toolkit is provided, tool call and tool result parts accept any tool
+   * name, with parameters and results decoded as `unknown`.
+   *
+   * **Example** (Building a response parts schema)
+   *
+   * ```ts import.meta.vitest
+   * import { Schema } from "effect"
+   * import { Response, Tool, Toolkit } from "effect/ai"
+   *
+   * const myToolkit = Toolkit.make(
+   *   Tool.make("GetWeather", {
+   *     parameters: Schema.Struct({ city: Schema.String }),
+   *     success: Schema.Struct({ temperature: Schema.Number })
+   *   })
+   * )
+   *
+   * const allPartsSchema = Response.AllParts(myToolkit)
+   * Schema.isSchema(allPartsSchema) // => true
+   *
+   * const anyToolPartsSchema = Response.AllParts()
+   * Schema.isSchema(anyToolPartsSchema) // => true
+   * ```
+   *
+   * @stability unstable
+   * @category schemas
+   * @since 4.0.0
+   */
+  (): Schema.Codec<AllParts<{}> | AnyToolParts, AllPartsEncoded>
+} = (toolkit?: Toolkit.Any | Toolkit.WithHandler<any>) =>
+  Schema.Union([
     TextPart,
     TextStartPart,
     TextDeltaPart,
@@ -233,10 +331,8 @@ export const AllParts = <T extends Toolkit.Any | Toolkit.WithHandler<any>>(
     ResponseMetadataPart,
     FinishPart,
     ErrorPart,
-    ...toolCalls,
-    ...toolResults
+    ...toolPartSchemasFor(toolkit)
   ]) as any
-}
 
 // =============================================================================
 // Parts
@@ -289,26 +385,49 @@ export type PartEncoded =
 /**
  * Creates a Schema for non-streaming response parts based on a toolkit.
  *
+ * **Details**
+ *
+ * When no toolkit is provided, tool call and tool result parts accept any tool
+ * name, with parameters and results decoded as `unknown`.
+ *
  * @stability unstable
  * @category schemas
  * @since 4.0.0
  */
-export const Part = <T extends Toolkit.Any | Toolkit.WithHandler<any>>(
-  toolkit: T
-): Schema.Codec<
-  Part<T extends Toolkit.Any ? Toolkit.Tools<T> : Toolkit.WithHandlerTools<T>>,
-  PartEncoded,
-  Tool.ResultDecodingServices<Toolkit.Tools<T>[keyof Toolkit.Tools<T>]>,
-  Tool.ResultEncodingServices<Toolkit.Tools<T>[keyof Toolkit.Tools<T>]>
-> => {
-  const toolCalls: Array<Schema.Top> = []
-  const toolResults: Array<Schema.Top> = []
-  for (const tool of Object.values(toolkit.tools as Record<string, Tool.Any>)) {
-    const parts = toolPartSchemas(tool)
-    toolCalls.push(parts.toolCall)
-    toolResults.push(parts.toolResult)
-  }
-  return Schema.Union([
+export const Part: {
+  /**
+   * Creates a Schema for non-streaming response parts based on a toolkit.
+   *
+   * **Details**
+   *
+   * When no toolkit is provided, tool call and tool result parts accept any tool
+   * name, with parameters and results decoded as `unknown`.
+   *
+   * @stability unstable
+   * @category schemas
+   * @since 4.0.0
+   */
+  <T extends Toolkit.Any | Toolkit.WithHandler<any>>(toolkit: T): Schema.Codec<
+    Part<ToolkitTools<T>>,
+    PartEncoded,
+    ToolkitDecodingServices<T>,
+    ToolkitEncodingServices<T>
+  >
+  /**
+   * Creates a Schema for non-streaming response parts based on a toolkit.
+   *
+   * **Details**
+   *
+   * When no toolkit is provided, tool call and tool result parts accept any tool
+   * name, with parameters and results decoded as `unknown`.
+   *
+   * @stability unstable
+   * @category schemas
+   * @since 4.0.0
+   */
+  (): Schema.Codec<Part<{}> | AnyToolParts, PartEncoded>
+} = (toolkit?: Toolkit.Any | Toolkit.WithHandler<any>) =>
+  Schema.Union([
     TextPart,
     ReasoningPart,
     ToolApprovalRequestPart,
@@ -317,10 +436,8 @@ export const Part = <T extends Toolkit.Any | Toolkit.WithHandler<any>>(
     UrlSourcePart,
     ResponseMetadataPart,
     FinishPart,
-    ...toolCalls,
-    ...toolResults
+    ...toolPartSchemasFor(toolkit)
   ]) as any
-}
 
 // =============================================================================
 // Stream Parts
@@ -386,26 +503,49 @@ export type StreamPartEncoded =
 /**
  * Creates a Schema for streaming response parts based on a toolkit.
  *
+ * **Details**
+ *
+ * When no toolkit is provided, tool call and tool result parts accept any tool
+ * name, with parameters and results decoded as `unknown`.
+ *
  * @stability unstable
  * @category schemas
  * @since 4.0.0
  */
-export const StreamPart = <T extends Toolkit.Any | Toolkit.WithHandler<any>>(
-  toolkit: T
-): Schema.Codec<
-  StreamPart<T extends Toolkit.Any ? Toolkit.Tools<T> : Toolkit.WithHandlerTools<T>>,
-  StreamPartEncoded,
-  Tool.ResultDecodingServices<Toolkit.Tools<T>[keyof Toolkit.Tools<T>]>,
-  Tool.ResultEncodingServices<Toolkit.Tools<T>[keyof Toolkit.Tools<T>]>
-> => {
-  const toolCalls: Array<Schema.Top> = []
-  const toolResults: Array<Schema.Top> = []
-  for (const tool of Object.values(toolkit.tools as Record<string, Tool.Any>)) {
-    const parts = toolPartSchemas(tool)
-    toolCalls.push(parts.toolCall)
-    toolResults.push(parts.toolResult)
-  }
-  return Schema.Union([
+export const StreamPart: {
+  /**
+   * Creates a Schema for streaming response parts based on a toolkit.
+   *
+   * **Details**
+   *
+   * When no toolkit is provided, tool call and tool result parts accept any tool
+   * name, with parameters and results decoded as `unknown`.
+   *
+   * @stability unstable
+   * @category schemas
+   * @since 4.0.0
+   */
+  <T extends Toolkit.Any | Toolkit.WithHandler<any>>(toolkit: T): Schema.Codec<
+    StreamPart<ToolkitTools<T>>,
+    StreamPartEncoded,
+    ToolkitDecodingServices<T>,
+    ToolkitEncodingServices<T>
+  >
+  /**
+   * Creates a Schema for streaming response parts based on a toolkit.
+   *
+   * **Details**
+   *
+   * When no toolkit is provided, tool call and tool result parts accept any tool
+   * name, with parameters and results decoded as `unknown`.
+   *
+   * @stability unstable
+   * @category schemas
+   * @since 4.0.0
+   */
+  (): Schema.Codec<StreamPart<{}> | AnyToolParts, StreamPartEncoded>
+} = (toolkit?: Toolkit.Any | Toolkit.WithHandler<any>) =>
+  Schema.Union([
     TextStartPart,
     TextDeltaPart,
     TextEndPart,
@@ -422,10 +562,8 @@ export const StreamPart = <T extends Toolkit.Any | Toolkit.WithHandler<any>>(
     ResponseMetadataPart,
     FinishPart,
     ErrorPart,
-    ...toolCalls,
-    ...toolResults
+    ...toolPartSchemasFor(toolkit)
   ]) as any
-}
 
 // =============================================================================
 // utility types
@@ -1522,15 +1660,17 @@ export const ToolCallPart: <const Name extends string, Params extends Schema.Con
 > = <const Name extends string, Params extends Schema.Constraint>(
   name: Name,
   params: Params
-) =>
+) => makeToolCallPart(Schema.Literal(name), params) as any
+
+const makeToolCallPart = (name: Schema.Top, params: Schema.Constraint) =>
   Schema.Struct({
     ...BasePart.fields,
     type: Schema.Literal("tool-call"),
     id: Schema.String,
-    name: Schema.Literal(name),
+    name,
     params,
     providerExecuted: Schema.Boolean.pipe(Schema.withDecodingDefaultKey(Effect.succeed(false)))
-  }).annotate({ identifier: "ToolCallPart" }) as any
+  }).annotate({ identifier: "ToolCallPart" })
 
 /**
  * Constructs a new tool call part.
@@ -1568,6 +1708,10 @@ export interface BaseToolResult<Name extends string> extends BasePart<"tool-resu
    * The encoded result for serialization purposes.
    */
   readonly encodedResult: unknown
+  /**
+   * Content sent to the model in place of the encoded result.
+   */
+  readonly modelOutput?: ReadonlyArray<Prompt.ToolModelOutputPart> | undefined
   /**
    * Whether the tool was executed by the provider (true) or framework (false).
    */
@@ -1691,6 +1835,10 @@ export interface ToolResultPartEncoded extends BasePartEncoded<"tool-result", To
    * The result returned by the tool execution.
    */
   readonly result: unknown
+  /**
+   * Content sent to the model in place of the result.
+   */
+  readonly modelOutput?: ReadonlyArray<Prompt.TextPartEncoded | Prompt.FilePartEncoded> | undefined
   /**
    * Whether or not the result of executing the tool call handler was an error.
    */
@@ -1739,14 +1887,21 @@ export const ToolResultPart = <
   ToolResultPartEncoded,
   Success["DecodingServices"] | Failure["DecodingServices"],
   Success["EncodingServices"] | Failure["EncodingServices"]
-> => {
+> =>
+  makeToolResultPart(Schema.Literal(name), success, failure).annotate({
+    identifier: `ToolResultPart(${name})`
+  }) as any
+
+const ModelOutput = Schema.Array(Prompt.ToolModelOutputPart)
+
+const makeToolResultPart = (name: Schema.Top, success: Schema.Constraint, failure: Schema.Constraint) => {
   const makeSchema = (result: Schema.Constraint, isFailure: boolean) => {
     const encodedResult = Schema.toEncoded(result)
     const Common = {
       id: Schema.String,
       type: Schema.Literal("tool-result"),
       isFailure: Schema.Literal(isFailure),
-      name: Schema.Literal(name)
+      name
     }
     const Decoded = Schema.Struct({
       ...Common,
@@ -1755,11 +1910,13 @@ export const ToolResultPart = <
       providerExecuted: Schema.Boolean,
       metadata: ProviderMetadata,
       encodedResult,
+      modelOutput: Schema.optional(ModelOutput),
       preliminary: Schema.Boolean
     })
     const Encoded = Schema.Struct({
       ...Common,
       result: encodedResult,
+      modelOutput: Schema.optional(Schema.toEncoded(ModelOutput)),
       providerExecuted: Schema.optional(Schema.Boolean),
       metadata: Schema.optional(ProviderMetadata),
       preliminary: Schema.optional(Schema.Boolean)
@@ -1779,9 +1936,7 @@ export const ToolResultPart = <
       })
     ))
   }
-  return Schema.Union([makeSchema(success, false), makeSchema(failure, true)]).annotate({
-    identifier: `ToolResultPart(${name})`
-  })
+  return Schema.Union([makeSchema(success, false), makeSchema(failure, true)])
 }
 
 /**