@effect-uai/core 0.18.0 → 0.19.0-dev-20261109183959

package/README.md

@@ -35,7 +35,7 @@ No provider deps. Pair with one or more provider packages:
 [`@effect-uai/anthropic`](https://www.npmjs.com/package/@effect-uai/anthropic),
 [`@effect-uai/google`](https://www.npmjs.com/package/@effect-uai/google),
 [`@effect-uai/mistral`](https://www.npmjs.com/package/@effect-uai/mistral)
-and [the rest](https://effect-uai.betalyra.com/providers/).
+and [the rest](https://effect-uai.com/providers/).
 
 ## Install
 
@@ -47,10 +47,10 @@ ESM-only. Requires `effect@>=4.0.1` (Effect 4.0 stable) as a peer.
 
 ## Docs
 
-Full docs: <https://effect-uai.betalyra.com>
+Full docs: <https://effect-uai.com>
 
-Start with [One turn is a stream](https://effect-uai.betalyra.com/start/getting-started/)
-and then [Basic usage](https://effect-uai.betalyra.com/recipes/basic-usage/).
+Start with [One turn is a stream](https://effect-uai.com/start/getting-started/)
+and then [Basic usage](https://effect-uai.com/recipes/basic-usage/).
 
 ## License
 

package/dist/Content-D_Qfn8Ja.d.mts

@@ -0,0 +1,48 @@
+import { i as FileSource, r as FileMimeType } from "./File-B923KvZ9.mjs";
+import { i as ImageMimeType, o as ImageSource } from "./Image-Bzc1H_UK.mjs";
+import { Schema } from "effect";
+declare namespace Content_d_exports {
+  export { File, Image, Media, Value, file, image, isMedia };
+}
+declare const Image_base: Schema.Class<Image, Schema.TaggedStruct<"Image", {
+  readonly source: Schema.Union<readonly [Schema.TaggedStruct<"url", {
+    readonly url: Schema.String;
+    readonly mimeType: Schema.optionalKey<Schema.Codec<ImageMimeType, ImageMimeType, never, never>>;
+  }>, Schema.TaggedStruct<"base64", {
+    readonly base64: Schema.String;
+    readonly mimeType: Schema.Codec<ImageMimeType, ImageMimeType, never, never>;
+  }>, Schema.TaggedStruct<"bytes", {
+    readonly bytes: Schema.Uint8ArrayFromBase64;
+    readonly mimeType: Schema.Codec<ImageMimeType, ImageMimeType, never, never>;
+  }>]>;
+}>, {}>;
+declare class Image extends Image_base {}
+declare const File_base: Schema.Class<File, Schema.TaggedStruct<"File", {
+  readonly source: Schema.Union<readonly [Schema.TaggedStruct<"url", {
+    readonly url: Schema.String;
+    readonly mimeType: Schema.optionalKey<Schema.Codec<FileMimeType, FileMimeType, never, never>>;
+  }>, Schema.TaggedStruct<"base64", {
+    readonly base64: Schema.String;
+    readonly mimeType: Schema.Codec<FileMimeType, FileMimeType, never, never>;
+  }>, Schema.TaggedStruct<"bytes", {
+    readonly bytes: Schema.Uint8ArrayFromBase64;
+    readonly mimeType: Schema.Codec<FileMimeType, FileMimeType, never, never>;
+  }>]>;
+  readonly filename: Schema.optionalKey<Schema.String>;
+}>, {}>;
+declare class File extends File_base {}
+declare const Media: Schema.Union<readonly [typeof Image, typeof File]>;
+type Media = typeof Media.Type;
+declare const image: (source: ImageSource) => Image;
+declare const file: (source: FileSource, filename?: string) => File;
+declare const isMedia: (u: unknown) => u is Media;
+/**
+ * Text, JSON, one medium, or a top-level array mixing JSON and media. Encodes to
+ * JSON (bytes as base64), so it also serves as the UI codec for tools without
+ * an `outputSchema`.
+ */
+declare const Value: Schema.Union<readonly [Schema.String, Schema.Union<readonly [typeof Image, typeof File]>, Schema.$Array<Schema.Union<readonly [Schema.Union<readonly [typeof Image, typeof File]>, Schema.Codec<Schema.Json, Schema.Json, never, never>]>>, Schema.Codec<Schema.Json, Schema.Json, never, never>]>;
+type Value = typeof Value.Type;
+//#endregion
+export { Value as a, isMedia as c, Media as i, File as n, file as o, Image as r, image as s, Content_d_exports as t };
+//# sourceMappingURL=Content-D_Qfn8Ja.d.mts.map

package/dist/Content-D_Qfn8Ja.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Content-D_Qfn8Ja.d.mts","names":[],"sources":["../src/tool/Content.ts"],"mappings":";;;;;;;;;;;;;;;;;;cASa,cAAc;;;;;;;;;;;;;;cAEd,aAAa;cAKb,OAAK,OAAA,uBAAA,cAAA;KACN,eAAe,MAAM;cAEpB,QAAK,QAAY,gBAAc;cAE/B,OAAI,QAAY,YAAU,sBAAsB;cAGhD,UAAO,eAAiB,KAAK;;;;;;cAO7B,OAAK,OAAA,gBAAA,OAAA,QAAA,OAAA,uBAAA,cAAA,QAAA,OAAA,OAAA,OAAA,gBAAA,OAAA,uBAAA,cAAA,QAAA,OAAA,MAAA,OAAA,MAAA,OAAA,wBAAA,OAAA,MAAA,OAAA,MAAA,OAAA;KAMN,eAAe,MAAM"}

package/dist/File-B923KvZ9.d.mts

@@ -0,0 +1,46 @@
+import { a as MediaSource, i as MediaBytes, o as MediaUrl, r as MediaBase64 } from "./Media-BbX7BAaO.mjs";
+import { Schema } from "effect";
+//#region src/domain/File.d.ts
+/**
+ * MIME types of files a user hands to a model: documents, audio, video. The
+ * listed ones are common; the `(string & {})` tail accepts any other, so a
+ * newly supported format works without an SDK update. Which types a model
+ * reads is the provider's call: an unsupported one is rejected by the
+ * provider, not converted here.
+ */
+type FileMimeType = "application/pdf" | "text/plain" | "text/markdown" | "text/csv" | "text/html" | "application/json" | "application/vnd.openxmlformats-officedocument.wordprocessingml.document" | "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet" | "audio/mpeg" | "audio/wav" | "video/mp4" | (string & {});
+type FileUrlSource = MediaUrl<FileMimeType>;
+type FileBase64Source = MediaBase64<FileMimeType>;
+type FileBytesSource = MediaBytes<FileMimeType>;
+/** Where a file lives: a URL the model fetches, inline base64, or raw bytes. */
+type FileSource = MediaSource<FileMimeType>;
+declare const FileUrlSource: Schema.TaggedStruct<"url", {
+  readonly url: Schema.String;
+  readonly mimeType: Schema.optionalKey<Schema.Codec<FileMimeType, FileMimeType, never, never>>;
+}>;
+declare const FileBase64Source: Schema.TaggedStruct<"base64", {
+  readonly base64: Schema.String;
+  readonly mimeType: Schema.Codec<FileMimeType, FileMimeType, never, never>;
+}>;
+declare const FileBytesSource: Schema.TaggedStruct<"bytes", {
+  readonly bytes: Schema.Uint8Array;
+  readonly mimeType: Schema.Codec<FileMimeType, FileMimeType, never, never>;
+}>;
+declare const FileSource: Schema.Codec<FileSource>;
+/** `FileSource` as JSON: bytes encode as base64 (e.g. tool output on a UI wire). */
+declare const FileSourceJson: Schema.Union<readonly [Schema.TaggedStruct<"url", {
+  readonly url: Schema.String;
+  readonly mimeType: Schema.optionalKey<Schema.Codec<FileMimeType, FileMimeType, never, never>>;
+}>, Schema.TaggedStruct<"base64", {
+  readonly base64: Schema.String;
+  readonly mimeType: Schema.Codec<FileMimeType, FileMimeType, never, never>;
+}>, Schema.TaggedStruct<"bytes", {
+  readonly bytes: Schema.Uint8ArrayFromBase64;
+  readonly mimeType: Schema.Codec<FileMimeType, FileMimeType, never, never>;
+}>]>;
+declare const fileUrl: (url: string, mimeType?: FileMimeType) => FileUrlSource;
+declare const fileBase64: (base64: string, mimeType: FileMimeType) => FileBase64Source;
+declare const fileBytes: (bytes: Uint8Array, mimeType: FileMimeType) => FileBytesSource;
+//#endregion
+export { FileSourceJson as a, fileBytes as c, FileSource as i, fileUrl as l, FileBytesSource as n, FileUrlSource as o, FileMimeType as r, fileBase64 as s, FileBase64Source as t };
+//# sourceMappingURL=File-B923KvZ9.d.mts.map

package/dist/File-B923KvZ9.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"File-B923KvZ9.d.mts","names":[],"sources":["../src/domain/File.ts"],"mappings":";;;;;;;;;;KAUY;KAiBA,gBAAgB,SAAS;KACzB,mBAAmB,YAAY;KAC/B,kBAAkB,WAAW;;KAG7B,aAAa,YAAY;cAExB,eAAa,OAAA;;;;cAKb,kBAAgB,OAAA;;;;cAKhB,iBAAe,OAAA;;;;cAKf,YAAY,OAAO,MAAM;;cAOzB,gBAAc,OAAA,gBAAA,OAAA;;;;;;;;;;cASd,UAAO,aAAe,WAAa,iBAAe;cAGlD,aAAU,gBAAkB,UAAY,iBAAe;cAMvD,YAAS,OAAW,YAAU,UAAY,iBAAe"}

package/dist/{Image-Cv6iBLTy.d.mts → Image-Bzc1H_UK.d.mts}

@@ -1,7 +1,7 @@
 import { a as MediaSource, c as Watermark, i as MediaBytes, n as Dimensions, o as MediaUrl, r as MediaBase64, t as AspectRatio } from "./Media-BbX7BAaO.mjs";
 import { Result, Schema } from "effect";
 declare namespace Image_d_exports {
-  export { AspectRatio, Dimensions, GeneratedImage, ImageBase64Source, ImageBytesSource, ImageMimeType, ImageResolution, ImageSource, ImageUrlSource, ProviderData, imageBase64, imageBytes, imageUrl, isImageBase64, isImageBytes, isImageUrl, pixelsOf };
+  export { AspectRatio, Dimensions, GeneratedImage, ImageBase64Source, ImageBytesSource, ImageMimeType, ImageResolution, ImageSource, ImageSourceJson, ImageUrlSource, ProviderData, imageBase64, imageBytes, imageUrl, isImageBase64, isImageBytes, isImageUrl, pixelsOf };
 }
 /**
  * Image MIME types AI providers typically accept. The first four are the
@@ -25,17 +25,28 @@ type ImageBytesSource = MediaBytes<ImageMimeType>;
 type ImageSource = MediaSource<ImageMimeType>;
 declare const ImageUrlSource: Schema.TaggedStruct<"url", {
   readonly url: Schema.String;
-  readonly mimeType: Schema.optional<Schema.Schema<ImageMimeType>>;
+  readonly mimeType: Schema.optionalKey<Schema.Codec<ImageMimeType, ImageMimeType, never, never>>;
 }>;
 declare const ImageBase64Source: Schema.TaggedStruct<"base64", {
   readonly base64: Schema.String;
-  readonly mimeType: Schema.Schema<ImageMimeType>;
+  readonly mimeType: Schema.Codec<ImageMimeType, ImageMimeType, never, never>;
 }>;
 declare const ImageBytesSource: Schema.TaggedStruct<"bytes", {
   readonly bytes: Schema.Uint8Array;
-  readonly mimeType: Schema.Schema<ImageMimeType>;
+  readonly mimeType: Schema.Codec<ImageMimeType, ImageMimeType, never, never>;
 }>;
-declare const ImageSource: Schema.Schema<ImageSource>;
+declare const ImageSource: Schema.Codec<ImageSource>;
+/** `ImageSource` as JSON: bytes encode as base64 (e.g. tool output on a UI wire). */
+declare const ImageSourceJson: Schema.Union<readonly [Schema.TaggedStruct<"url", {
+  readonly url: Schema.String;
+  readonly mimeType: Schema.optionalKey<Schema.Codec<ImageMimeType, ImageMimeType, never, never>>;
+}>, Schema.TaggedStruct<"base64", {
+  readonly base64: Schema.String;
+  readonly mimeType: Schema.Codec<ImageMimeType, ImageMimeType, never, never>;
+}>, Schema.TaggedStruct<"bytes", {
+  readonly bytes: Schema.Uint8ArrayFromBase64;
+  readonly mimeType: Schema.Codec<ImageMimeType, ImageMimeType, never, never>;
+}>]>;
 declare const imageUrl: (url: string, mimeType?: ImageMimeType) => ImageUrlSource;
 declare const imageBase64: (base64: string, mimeType: ImageMimeType) => ImageBase64Source;
 declare const imageBytes: (bytes: Uint8Array, mimeType: ImageMimeType) => ImageBytesSource;
@@ -82,7 +93,7 @@ type GeneratedImage = {
 declare const isImageUrl: <I>(input: I) => input is I & {
   readonly _tag: "url";
   readonly url: string;
-  readonly mimeType?: ImageMimeType | undefined;
+  readonly mimeType?: ImageMimeType;
 };
 declare const isImageBase64: <I>(input: I) => input is I & {
   readonly _tag: "base64";
@@ -95,5 +106,5 @@ declare const isImageBytes: <I>(input: I) => input is I & {
   readonly mimeType: ImageMimeType;
 };
 //#endregion
-export { ImageResolution as a, Image_d_exports as c, imageBytes as d, imageUrl as f, pixelsOf as g, isImageUrl as h, ImageMimeType as i, ProviderData as l, isImageBytes as m, ImageBase64Source as n, ImageSource as o, isImageBase64 as p, ImageBytesSource as r, ImageUrlSource as s, GeneratedImage as t, imageBase64 as u };
-//# sourceMappingURL=Image-Cv6iBLTy.d.mts.map
+export { pixelsOf as _, ImageResolution as a, ImageUrlSource as c, imageBase64 as d, imageBytes as f, isImageUrl as g, isImageBytes as h, ImageMimeType as i, Image_d_exports as l, isImageBase64 as m, ImageBase64Source as n, ImageSource as o, imageUrl as p, ImageBytesSource as r, ImageSourceJson as s, GeneratedImage as t, ProviderData as u };
+//# sourceMappingURL=Image-Bzc1H_UK.d.mts.map

package/dist/Image-Bzc1H_UK.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Image-Bzc1H_UK.d.mts","names":[],"sources":["../src/domain/Image.ts"],"mappings":";;;;;;;;;;;;;KAoBY;KAYA,iBAAiB,SAAS;KAC1B,oBAAoB,YAAY;KAChC,mBAAmB,WAAW;;;;;;;;KAS9B,cAAc,YAAY;cAEzB,gBAAc,OAAA;;;;cAKd,mBAAiB,OAAA;;;;cAKjB,kBAAgB,OAAA;;;;cAKhB,aAAa,OAAO,MAAM;;cAO1B,iBAAe,OAAA,gBAAA,OAAA;;;;;;;;;;cASf,WAAQ,aAAe,WAAa,kBAAgB;cAGpD,cAAW,gBAAkB,UAAY,kBAAgB;cAMzD,aAAU,OAAW,YAAU,UAAY,kBAAgB;;;;;;;KAe5D;;;;;;;;;;cAaC,WAAQ;WACV,cAAc;WACd,aAAa;MACpB,OAAO,OAAO;;;;;;;;;;;;KAqBN;;KAGA;WACD,OAAO;;WAEP,YAAY;;WAEZ,eAAe;;cAGb,aAAU,GAAA,OAAA,MAAA,SAAA;;;;;cACV,gBAAa,GAAA,OAAA,MAAA,SAAA;;;;;cACb,eAAY,GAAA,OAAA,MAAA,SAAA"}

package/dist/{Items-C7MyrYPX.d.mts → Items-Bvx8s9QH.d.mts}

@@ -1,7 +1,8 @@
-import { o as ImageSource } from "./Image-Cv6iBLTy.mjs";
+import { i as FileSource } from "./File-B923KvZ9.mjs";
+import { o as ImageSource } from "./Image-Bzc1H_UK.mjs";
 import { Schema } from "effect";
 declare namespace Items_d_exports {
-  export { Annotation, ContainerFileCitation, ContentBlock, FileCitation, FilePath, HistoryItem, InputImage, InputText, InputTokensDetails, Message, OutputImage, OutputText, OutputTokensDetails, Reasoning, Refusal, Role, StopReason, ToolCall, ToolCallOutput, UrlCitation, Usage, assistantText, isContainerFileCitation, isFileCitation, isFilePath, isInputImage, isInputText, isMessage, isOutputImage, isOutputText, isReasoning, isRefusal, isToolCall, isToolCallOutput, isUrlCitation, systemText, toolCallOutput, userText };
+  export { Annotation, ContainerFileCitation, ContentBlock, FileCitation, FilePath, HistoryItem, InputFile, InputImage, InputJson, InputText, InputTokensDetails, Message, OutputImage, OutputText, OutputTokensDetails, Reasoning, Refusal, Role, StopReason, ToolCall, ToolCallOutput, ToolOutputContent, UrlCitation, Usage, assistantText, file, image, isContainerFileCitation, isFileCitation, isFilePath, isInputFile, isInputImage, isInputJson, isInputText, isMessage, isOutputImage, isOutputText, isReasoning, isRefusal, isToolCall, isToolCallOutput, isUrlCitation, json, systemText, text, toolCallOutput, userText };
 }
 declare const InputText: Schema.Struct<{
   readonly type: Schema.Literal<"input_text">;
@@ -18,9 +19,22 @@ type InputText = typeof InputText.Type;
  */
 declare const InputImage: Schema.Struct<{
   readonly type: Schema.Literal<"input_image">;
-  readonly source: Schema.Schema<ImageSource>;
+  readonly source: Schema.Codec<ImageSource, ImageSource, never, never>;
 }>;
 type InputImage = typeof InputImage.Type;
+/**
+ * User-provided file: a document (PDF, text, docx), audio or video. The
+ * `source` MIME type says which; provider codecs map it to their own file
+ * part, and a provider that cannot read a type rejects the request.
+ *
+ * Not in `ContentBlock` yet: it joins once every provider codec encodes it.
+ */
+declare const InputFile: Schema.Struct<{
+  readonly type: Schema.Literal<"input_file">;
+  readonly source: Schema.Codec<FileSource, FileSource, never, never>;
+  readonly filename: Schema.optionalKey<Schema.String>;
+}>;
+type InputFile = typeof InputFile.Type;
 /**
  * A cited source. `url` + `title` are the only near-universal fields; the
  * link from a source to the answer text varies by provider, so it is optional
@@ -149,7 +163,7 @@ type OutputText = typeof OutputText.Type;
  */
 declare const OutputImage: Schema.Struct<{
   readonly type: Schema.Literal<"output_image">;
-  readonly source: Schema.Schema<ImageSource>;
+  readonly source: Schema.Codec<ImageSource, ImageSource, never, never>;
 }>;
 type OutputImage = typeof OutputImage.Type;
 /**
@@ -168,7 +182,7 @@ declare const ContentBlock: Schema.Union<readonly [Schema.Struct<{
   readonly text: Schema.String;
 }>, Schema.Struct<{
   readonly type: Schema.Literal<"input_image">;
-  readonly source: Schema.Schema<ImageSource>;
+  readonly source: Schema.Codec<ImageSource, ImageSource, never, never>;
 }>, Schema.Struct<{
   readonly type: Schema.Literal<"output_text">;
   readonly text: Schema.String;
@@ -197,7 +211,7 @@ declare const ContentBlock: Schema.Union<readonly [Schema.Struct<{
   }>]>>>;
 }>, Schema.Struct<{
   readonly type: Schema.Literal<"output_image">;
-  readonly source: Schema.Schema<ImageSource>;
+  readonly source: Schema.Codec<ImageSource, ImageSource, never, never>;
 }>, Schema.Struct<{
   readonly type: Schema.Literal<"refusal">;
   readonly text: Schema.String;
@@ -213,7 +227,7 @@ declare const Message: Schema.Struct<{
     readonly text: Schema.String;
   }>, Schema.Struct<{
     readonly type: Schema.Literal<"input_image">;
-    readonly source: Schema.Schema<ImageSource>;
+    readonly source: Schema.Codec<ImageSource, ImageSource, never, never>;
   }>, Schema.Struct<{
     readonly type: Schema.Literal<"output_text">;
     readonly text: Schema.String;
@@ -242,7 +256,7 @@ declare const Message: Schema.Struct<{
     }>]>>>;
   }>, Schema.Struct<{
     readonly type: Schema.Literal<"output_image">;
-    readonly source: Schema.Schema<ImageSource>;
+    readonly source: Schema.Codec<ImageSource, ImageSource, never, never>;
   }>, Schema.Struct<{
     readonly type: Schema.Literal<"refusal">;
     readonly text: Schema.String;
@@ -258,10 +272,46 @@ declare const ToolCall: Schema.Struct<{
   readonly providerData: Schema.optional<Schema.Unknown>;
 }>;
 type ToolCall = typeof ToolCall.Type;
+/** A JSON value in a tool output. Kept as a value; provider codecs serialize it. */
+declare const InputJson: Schema.Struct<{
+  readonly type: Schema.Literal<"input_json">;
+  readonly value: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+}>;
+type InputJson = typeof InputJson.Type;
+declare const ToolOutputContent: Schema.Union<readonly [Schema.Struct<{
+  readonly type: Schema.Literal<"input_text">;
+  readonly text: Schema.String;
+}>, Schema.Struct<{
+  readonly type: Schema.Literal<"input_json">;
+  readonly value: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+}>, Schema.Struct<{
+  readonly type: Schema.Literal<"input_image">;
+  readonly source: Schema.Codec<ImageSource, ImageSource, never, never>;
+}>, Schema.Struct<{
+  readonly type: Schema.Literal<"input_file">;
+  readonly source: Schema.Codec<FileSource, FileSource, never, never>;
+  readonly filename: Schema.optionalKey<Schema.String>;
+}>]>;
+type ToolOutputContent = typeof ToolOutputContent.Type;
 declare const ToolCallOutput: Schema.Struct<{
   readonly type: Schema.Literal<"function_call_output">;
   readonly call_id: Schema.String;
-  readonly output: Schema.String;
+  readonly output: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+    readonly type: Schema.Literal<"input_text">;
+    readonly text: Schema.String;
+  }>, Schema.Struct<{
+    readonly type: Schema.Literal<"input_json">;
+    readonly value: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+  }>, Schema.Struct<{
+    readonly type: Schema.Literal<"input_image">;
+    readonly source: Schema.Codec<ImageSource, ImageSource, never, never>;
+  }>, Schema.Struct<{
+    readonly type: Schema.Literal<"input_file">;
+    readonly source: Schema.Codec<FileSource, FileSource, never, never>;
+    readonly filename: Schema.optionalKey<Schema.String>;
+  }>]>>;
+  /** The call failed. Native on some providers; others only see the content. */
+  readonly isError: Schema.optionalKey<Schema.Boolean>;
   readonly providerData: Schema.optional<Schema.Unknown>;
 }>;
 type ToolCallOutput = typeof ToolCallOutput.Type;
@@ -287,7 +337,7 @@ declare const HistoryItem: Schema.Union<readonly [Schema.Struct<{
     readonly text: Schema.String;
   }>, Schema.Struct<{
     readonly type: Schema.Literal<"input_image">;
-    readonly source: Schema.Schema<ImageSource>;
+    readonly source: Schema.Codec<ImageSource, ImageSource, never, never>;
   }>, Schema.Struct<{
     readonly type: Schema.Literal<"output_text">;
     readonly text: Schema.String;
@@ -316,7 +366,7 @@ declare const HistoryItem: Schema.Union<readonly [Schema.Struct<{
     }>]>>>;
   }>, Schema.Struct<{
     readonly type: Schema.Literal<"output_image">;
-    readonly source: Schema.Schema<ImageSource>;
+    readonly source: Schema.Codec<ImageSource, ImageSource, never, never>;
   }>, Schema.Struct<{
     readonly type: Schema.Literal<"refusal">;
     readonly text: Schema.String;
@@ -331,7 +381,22 @@ declare const HistoryItem: Schema.Union<readonly [Schema.Struct<{
 }>, Schema.Struct<{
   readonly type: Schema.Literal<"function_call_output">;
   readonly call_id: Schema.String;
-  readonly output: Schema.String;
+  readonly output: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+    readonly type: Schema.Literal<"input_text">;
+    readonly text: Schema.String;
+  }>, Schema.Struct<{
+    readonly type: Schema.Literal<"input_json">;
+    readonly value: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+  }>, Schema.Struct<{
+    readonly type: Schema.Literal<"input_image">;
+    readonly source: Schema.Codec<ImageSource, ImageSource, never, never>;
+  }>, Schema.Struct<{
+    readonly type: Schema.Literal<"input_file">;
+    readonly source: Schema.Codec<FileSource, FileSource, never, never>;
+    readonly filename: Schema.optionalKey<Schema.String>;
+  }>]>>;
+  /** The call failed. Native on some providers; others only see the content. */
+  readonly isError: Schema.optionalKey<Schema.Boolean>;
   readonly providerData: Schema.optional<Schema.Unknown>;
 }>, Schema.Struct<{
   readonly type: Schema.Literal<"reasoning">;
@@ -349,6 +414,15 @@ declare const isInputImage: <I>(input: I) => input is I & {
   readonly type: "input_image";
   readonly source: ImageSource;
 };
+declare const isInputFile: <I>(input: I) => input is I & {
+  readonly type: "input_file";
+  readonly source: FileSource;
+  readonly filename?: string;
+};
+declare const isInputJson: <I>(input: I) => input is I & {
+  readonly type: "input_json";
+  readonly value: Schema.Json;
+};
 declare const isOutputText: <I>(input: I) => input is I & {
   readonly type: "output_text";
   readonly text: string;
@@ -438,7 +512,21 @@ declare const isToolCall: <I>(input: I) => input is I & {
 declare const isToolCallOutput: <I>(input: I) => input is I & {
   readonly type: "function_call_output";
   readonly call_id: string;
-  readonly output: string;
+  readonly output: readonly ({
+    readonly type: "input_text";
+    readonly text: string;
+  } | {
+    readonly type: "input_image";
+    readonly source: ImageSource;
+  } | {
+    readonly type: "input_file";
+    readonly source: FileSource;
+    readonly filename?: string;
+  } | {
+    readonly type: "input_json";
+    readonly value: Schema.Json;
+  })[];
+  readonly isError?: boolean;
   readonly providerData?: unknown;
 };
 declare const isReasoning: <I>(input: I) => input is I & {
@@ -486,7 +574,12 @@ type StopReason = typeof StopReason.Type;
 declare const userText: (text: string) => Message;
 declare const systemText: (text: string) => Message;
 declare const assistantText: (text: string) => Message;
-declare const toolCallOutput: (call_id: string, output: string) => ToolCallOutput;
+/** A tool output with one text part. */
+declare const toolCallOutput: (call_id: string, text: string) => ToolCallOutput;
+declare const text: (text: string) => InputText;
+declare const json: (value: Schema.Json) => InputJson;
+declare const image: (source: ImageSource) => InputImage;
+declare const file: (source: FileSource, filename?: string) => InputFile;
 //#endregion
-export { isOutputImage as A, assistantText as C, isInputImage as D, isFilePath as E, isToolCallOutput as F, isUrlCitation as I, systemText as L, isReasoning as M, isRefusal as N, isInputText as O, isToolCall as P, toolCallOutput as R, Usage as S, isFileCitation as T, Role as _, FilePath as a, ToolCallOutput as b, InputText as c, Message as d, OutputImage as f, Refusal as g, Reasoning as h, FileCitation as i, isOutputText as j, isMessage as k, InputTokensDetails as l, OutputTokensDetails as m, ContainerFileCitation as n, HistoryItem as o, OutputText as p, ContentBlock as r, InputImage as s, Annotation as t, Items_d_exports as u, StopReason as v, isContainerFileCitation as w, UrlCitation as x, ToolCall as y, userText as z };
-//# sourceMappingURL=Items-C7MyrYPX.d.mts.map
+export { isFileCitation as A, isRefusal as B, ToolOutputContent as C, file as D, assistantText as E, isInputText as F, systemText as G, isToolCallOutput as H, isMessage as I, userText as J, text as K, isOutputImage as L, isInputFile as M, isInputImage as N, image as O, isInputJson as P, isOutputText as R, ToolCallOutput as S, Usage as T, isUrlCitation as U, isToolCall as V, json as W, Reasoning as _, FilePath as a, StopReason as b, InputImage as c, InputTokensDetails as d, Items_d_exports as f, OutputTokensDetails as g, OutputText as h, FileCitation as i, isFilePath as j, isContainerFileCitation as k, InputJson as l, OutputImage as m, ContainerFileCitation as n, HistoryItem as o, Message as p, toolCallOutput as q, ContentBlock as r, InputFile as s, Annotation as t, InputText as u, Refusal as v, UrlCitation as w, ToolCall as x, Role as y, isReasoning as z };
+//# sourceMappingURL=Items-Bvx8s9QH.d.mts.map

package/dist/Items-Bvx8s9QH.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Items-Bvx8s9QH.d.mts","names":[],"sources":["../src/domain/Items.ts"],"mappings":";;;;;;cAQa,WAAS,OAAA;;;;KAIV,mBAAmB,UAAU;;;;;;;;;cAU5B,YAAU,OAAA;;;;KAIX,oBAAoB,WAAW;;;;;;;;cAS9B,WAAS,OAAA;;;;;KAKV,mBAAmB,UAAU;;;;;;;;;cAgB5B,aAAW,OAAA;;;;;;;;;KASZ,qBAAqB,YAAY;cAEhC,cAAY,OAAA;;;;;KAKb,sBAAsB,aAAa;cAElC,uBAAqB,OAAA;;;;;;;KAOtB,+BAA+B,sBAAsB;cAEpD,UAAQ,OAAA;;;;;KAKT,kBAAkB,SAAS;cAE1B,YAAU,OAAA,gBAAA,OAAA;;;;;;;;;;;;;;;;;;;;;;;KACX,oBAAoB,WAAW;cAE9B,gBAAa,GAAA,OAAA,MAAA,SAAA;;;;;;;;;cACb,iBAAc,GAAA,OAAA,MAAA,SAAA;;;;;cACd,0BAAuB,GAAA,OAAA,MAAA,SAAA;;;;;;;cACvB,aAAU,GAAA,OAAA,MAAA,SAAA;;;;;cAEV,YAAU,OAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;KAKX,oBAAoB,WAAW;;;;;;;;;;;cAY9B,aAAW,OAAA;;;;KAIZ,qBAAqB,YAAY;;;;;;;cAQhC,SAAO,OAAA;;;;KAIR,iBAAiB,QAAQ;cAExB,cAAY,OAAA,gBAAA,OAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KACb,sBAAsB,aAAa;cAElC,MAAI,OAAA;KACL,cAAc,KAAK;cAqBlB,SAAO,OAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAMR,iBAAiB,QAAQ;cAExB,UAAQ,OAAA;;;;;;;KAQT,kBAAkB,SAAS;;cAG1B,WAAS,OAAA;;;;KAIV,mBAAmB,UAAU;cAE5B,mBAAiB,OAAA,gBAAA,OAAA;;;;;;;;;;;;;;KAClB,2BAA2B,kBAAkB;cAE5C,gBAAc,OAAA;;;;;;;;;;;;;;;;;;;;;KAQf,wBAAwB,eAAe;;;;;;;cAQtC,WAAS,OAAA;;;;;;;KAOV,mBAAmB,UAAU;cAE5B,aAAW,OAAA,gBAAA,OAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KACZ,qBAAqB,YAAY;cAMhC,cAAW,GAAA,OAAA,MAAA,SAAA;;;;cACX,eAAY,GAAA,OAAA,MAAA,SAAA;;;;cACZ,cAAW,GAAA,OAAA,MAAA,SAAA;;;;;cACX,cAAW,GAAA,OAAA,MAAA,SAAA;;;;cACX,eAAY,GAAA,OAAA,MAAA,SAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;cACZ,gBAAa,GAAA,OAAA,MAAA,SAAA;;;;cACb,YAAS,GAAA,OAAA,MAAA,SAAA;;;;cAET,YAAS,GAAA,OAAA,MAAA,SAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cACT,aAAU,GAAA,OAAA,MAAA,SAAA;;;;;;;cACV,mBAAgB,GAAA,OAAA,MAAA,SAAA;;;;;;;;;;;;;;;;;;;;cAChB,cAAW,GAAA,OAAA,MAAA,SAAA;;;;;;;;;;;;;;;;;;cAiBX,oBAAkB,OAAA;;;;KAInB,4BAA4B,mBAAmB;cAE9C,qBAAmB,OAAA;;;KAGpB,6BAA6B,oBAAoB;cAEhD,OAAK,OAAA;;;;;;;;;;;;KAON,eAAe,MAAM;cAEpB,YAAU,OAAA;KAUX,oBAAoB,WAAW;cAM9B,WAAQ,iBAAmB;cAM3B,aAAU,iBAAmB;cAM7B,gBAAa,iBAAmB;;cAOhC,iBAAc,iBAAmB,iBAAiB;cAMlD,OAAI,iBAAmB;cACvB,OAAI,OAAW,OAAO,SAAO;cAC7B,QAAK,QAAY,gBAAc;cAC/B,OAAI,QAAY,YAAU,sBAAsB"}

package/dist/{Loop-ChpaO-ya.d.mts → Loop-CeA0AelN.d.mts}

@@ -95,12 +95,13 @@ declare const stop: <S = never>(state?: S) => Stream.Stream<Step<never, S>>;
  * Dual: data-first `onTurnComplete(deltas, then)` and data-last
  * `deltas.pipe(onTurnComplete(then))` both work.
  */
-type TurnContinuation<S, A, E2, R2> = Stream.Stream<Step<A, S>, E2, R2> | Effect.Effect<Stream.Stream<Step<A, S>, E2, R2>, E2, R2>;
+type TurnContinuation<S, A, E2, R2, E3, R3> = Stream.Stream<Step<A, S>, E2, R2> | Effect.Effect<Stream.Stream<Step<A, S>, E2, R2>, E3, R3>;
 declare const onTurnComplete: {
-  <S, A, E2 = never, R2 = never>(then: (turn: Turn) => TurnContinuation<S, A, E2, R2>): <E, R>(deltas: Stream.Stream<TurnEvent, E, R>) => Stream.Stream<Step<TurnEvent | A, S>, E | E2 | IncompleteTurn, R | R2>;
-  <S, A, E, R, E2 = never, R2 = never>(deltas: Stream.Stream<TurnEvent, E, R>, then: (turn: Turn) => TurnContinuation<S, A, E2, R2>): Stream.Stream<Step<TurnEvent | A, S>, E | E2 | IncompleteTurn, R | R2>;
+  <S, A, E2 = never, R2 = never, E3 = never, R3 = never>(then: (turn: Turn) => TurnContinuation<S, A, E2, R2, E3, R3>): <E, R>(deltas: Stream.Stream<TurnEvent, E, R>) => Stream.Stream<Step<TurnEvent | A, S>, E | E2 | E3 | IncompleteTurn, R | R2 | R3>;
+  <S, A, E, R, E2 = never, R2 = never, E3 = never, R3 = never>(deltas: Stream.Stream<TurnEvent, E, R>, then: (turn: Turn) => TurnContinuation<S, A, E2, R2, E3, R3>): Stream.Stream<Step<TurnEvent | A, S>, E | E2 | E3 | IncompleteTurn, R | R2 | R3>;
 };
 type LoopBody<S, A, E, R> = (state: S) => Stream.Stream<Step<A, S>, E, R> | Effect.Effect<Stream.Stream<Step<A, S>, E, R>, E, R>;
+type LoopBodyIn<S, A, E, R, E2, R2> = (state: S) => Stream.Stream<Step<A, S>, E, R> | Effect.Effect<Stream.Stream<Step<A, S>, E, R>, E2, R2>;
 /**
  * Drive a state-threaded loop body. Each iteration runs `body(state)` to get
  * a `Stream<Step<A, S>>`; values flow downstream, `next(s)` continues with
@@ -111,8 +112,8 @@ type LoopBody<S, A, E, R> = (state: S) => Stream.Stream<Step<A, S>, E, R> | Effe
  * (or `pipe(initial, loop(body))`) both work.
  */
 declare const loop: {
-  <S, A, E, R>(body: LoopBody<S, A, E, R>): (initial: S) => Stream.Stream<A, E, R>;
-  <S, A, E, R>(initial: S, body: LoopBody<S, A, E, R>): Stream.Stream<A, E, R>;
+  <S, A, E, R, E2 = never, R2 = never>(body: LoopBodyIn<S, A, E, R, E2, R2>): (initial: S) => Stream.Stream<A, E | E2, R | R2>;
+  <S, A, E, R, E2 = never, R2 = never>(initial: S, body: LoopBodyIn<S, A, E, R, E2, R2>): Stream.Stream<A, E | E2, R | R2>;
 };
 type LoopOverBody<S, I, A, E, R> = (state: S, input: I) => Stream.Stream<Step<A, S>, E, R> | Effect.Effect<Stream.Stream<Step<A, S>, E, R>, E, R>;
 /**
@@ -168,4 +169,4 @@ declare const loopWithState: <S, A, E, R>(initial: S, body: LoopBody<S, A, E, R>
 }>;
 //#endregion
 export { StopWith as a, loopOver as c, onTurnComplete as d, stop as f, Stop as i, loopWithState as l, Next as n, Value as o, value as p, Step as r, loop as s, Loop_d_exports as t, next as u };
-//# sourceMappingURL=Loop-ChpaO-ya.d.mts.map
+//# sourceMappingURL=Loop-CeA0AelN.d.mts.map

package/dist/Loop-CeA0AelN.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Loop-CeA0AelN.d.mts","names":[],"sources":["../src/loop/Loop.ts"],"mappings":"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"}