@effect-uai/core 0.13.0 → 0.15.0

package/dist/{Audio-60lKKHxS.d.mts → Audio-_nGR4V0X.d.mts}

@@ -1,4 +1,4 @@
-import { i as MediaUrl, n as MediaBytes, t as MediaBase64 } from "./Media-DwgpifPD.mjs";
+import { i as MediaBytes, o as MediaUrl, r as MediaBase64 } from "./Media-BbX7BAaO.mjs";
 import { Duration } from "effect";
 declare namespace Audio_d_exports {
   export { AudioBlob, AudioChunk, AudioFormat, AudioMimeType, AudioSource, isAudioBase64, isAudioBytes, isAudioUrl };
@@ -58,4 +58,4 @@ type AudioBlob = {
 };
 //#endregion
 export { AudioSource as a, isAudioBytes as c, AudioMimeType as i, isAudioUrl as l, AudioChunk as n, Audio_d_exports as o, AudioFormat as r, isAudioBase64 as s, AudioBlob as t };
-//# sourceMappingURL=Audio-60lKKHxS.d.mts.map
+//# sourceMappingURL=Audio-_nGR4V0X.d.mts.map

package/dist/{Audio-60lKKHxS.d.mts.map → Audio-_nGR4V0X.d.mts.map}

@@ -1 +1 @@
-{"version":3,"file":"Audio-60lKKHxS.d.mts","names":[],"sources":["../src/domain/Audio.ts"],"mappings":";;;;;;;;;;;;;KAWY;;;;;;;;;;KA0BA,cACR,SAAS,iBACT,YAAY,iBACZ,WAAW;cAEF,aAAU,GAAO,gBAAc,KAAK,SAAS;cAC7C,gBAAa,GAAO,gBAAc,KAAK,YAAY;cAEnD,eAAY,GAAO,gBAAc,KAAK,WAAW;;;;;;;KAQlD;WACD;WACA;WAUA;;WAEA;WACA;;;;;;;KAQC;WACD,OAAO;;;;;;KAON;WACD,QAAQ;WACR,OAAO;WACP,WAAW,SAAS"}
+{"version":3,"file":"Audio-_nGR4V0X.d.mts","names":[],"sources":["../src/domain/Audio.ts"],"mappings":";;;;;;;;;;;;;KAWY;;;;;;;;;;KA0BA,cACR,SAAS,iBACT,YAAY,iBACZ,WAAW;cAEF,aAAU,GAAO,gBAAc,KAAK,SAAS;cAC7C,gBAAa,GAAO,gBAAc,KAAK,YAAY;cAEnD,eAAY,GAAO,gBAAc,KAAK,WAAW;;;;;;;KAQlD;WACD;WACA;WAUA;;WAEA;WACA;;;;;;;KAQC;WACD,OAAO;;;;;;KAON;WACD,QAAQ;WACR,OAAO;WACP,WAAW,SAAS"}

package/dist/Image-Cv6iBLTy.d.mts

@@ -0,0 +1,99 @@
+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 };
+}
+/**
+ * Image MIME types AI providers typically accept. The first four are the
+ * universal subset (Cohere v4, Voyage multimodal, Jina v4, Google
+ * `gemini-embedding-2`); HEIC / HEIF are Google-specific. The
+ * `(string & {})` tail keeps autocomplete on the literals while still
+ * accepting any string, so a newly-supported format works without an
+ * SDK update.
+ */
+type ImageMimeType = "image/png" | "image/jpeg" | "image/webp" | "image/gif" | "image/heic" | "image/heif" | (string & {});
+type ImageUrlSource = MediaUrl<ImageMimeType>;
+type ImageBase64Source = MediaBase64<ImageMimeType>;
+type ImageBytesSource = MediaBytes<ImageMimeType>;
+/**
+ * Where an image lives. Provider layers normalize across these:
+ * `bytes` becomes a base64 data URI for OpenAI / Anthropic, an
+ * `inlineData` part for Gemini, and a separate field for Cohere /
+ * Voyage. URL constraints (must be HTTPS, must be public, …) are
+ * provider-specific and validated at the layer, not in the type.
+ */
+type ImageSource = MediaSource<ImageMimeType>;
+declare const ImageUrlSource: Schema.TaggedStruct<"url", {
+  readonly url: Schema.String;
+  readonly mimeType: Schema.optional<Schema.Schema<ImageMimeType>>;
+}>;
+declare const ImageBase64Source: Schema.TaggedStruct<"base64", {
+  readonly base64: Schema.String;
+  readonly mimeType: Schema.Schema<ImageMimeType>;
+}>;
+declare const ImageBytesSource: Schema.TaggedStruct<"bytes", {
+  readonly bytes: Schema.Uint8Array;
+  readonly mimeType: Schema.Schema<ImageMimeType>;
+}>;
+declare const ImageSource: Schema.Schema<ImageSource>;
+declare const imageUrl: (url: string, mimeType?: ImageMimeType) => ImageUrlSource;
+declare const imageBase64: (base64: string, mimeType: ImageMimeType) => ImageBase64Source;
+declare const imageBytes: (bytes: Uint8Array, mimeType: ImageMimeType) => ImageBytesSource;
+/**
+ * Resolution tier, roughly the short edge in pixels. A tier rather than
+ * a pixel pair: adapters whose wire takes exact dimensions derive them
+ * from the tier and the aspect ratio. Image-typed on purpose, video
+ * models tier by scan height instead.
+ */
+type ImageResolution = "1K" | "2K" | "4K";
+/**
+ * Turn the portable ratio and tier into pixels: the tier is the short
+ * edge, the long edge follows the ratio. `undefined` when neither was
+ * asked for, which the caller sends as "no size" so the endpoint picks.
+ *
+ * Adapters whose wire wants `"WxH"` format the pair; those wanting an
+ * object send it as is. Whether the result is in range for a given model
+ * is the server's call: per-model limits churn and we do not table them.
+ */
+declare const pixelsOf: (request: {
+  readonly aspectRatio?: AspectRatio;
+  readonly resolution?: ImageResolution;
+}) => Result.Result<Dimensions | undefined, string>;
+/**
+ * Per-image extras a provider reported and this type has no field for:
+ * pixel dimensions, a file name, a revised prompt. Opaque here, and a
+ * shared slot, so a provider keys its data under its own name
+ * (`{ fal: … }`, `{ openai: … }`) and reads only that key. Each provider
+ * package ships a typed reader; the framework never interprets it.
+ *
+ * Not promoted to real fields because the providers disagree on what
+ * they report. Only some fal endpoints return dimensions, and neither
+ * OpenAI's Images API nor Gemini returns them at all.
+ */
+type ProviderData = unknown;
+/** One image off a generation call, plus what the provider stamped into it. */
+type GeneratedImage = {
+  readonly image: ImageSource;
+  /** Set only when the provider applies one. */
+  readonly watermark?: Watermark;
+  /** {@link ProviderData}: per-image extras, keyed by provider name. */
+  readonly providerData?: ProviderData;
+};
+declare const isImageUrl: <I>(input: I) => input is I & {
+  readonly _tag: "url";
+  readonly url: string;
+  readonly mimeType?: ImageMimeType | undefined;
+};
+declare const isImageBase64: <I>(input: I) => input is I & {
+  readonly _tag: "base64";
+  readonly base64: string;
+  readonly mimeType: ImageMimeType;
+};
+declare const isImageBytes: <I>(input: I) => input is I & {
+  readonly _tag: "bytes";
+  readonly bytes: Uint8Array<ArrayBufferLike>;
+  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

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

@@ -0,0 +1 @@
+{"version":3,"file":"Image-Cv6iBLTy.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,OAAO;cAM3B,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-SfUabNuB.d.mts → Items-C7MyrYPX.d.mts}

@@ -1,7 +1,7 @@
-import { i as ImageSource } from "./Image-BK8-4H6s.mjs";
+import { o as ImageSource } from "./Image-Cv6iBLTy.mjs";
 import { Schema } from "effect";
 declare namespace Items_d_exports {
-  export { Annotation, ContainerFileCitation, ContentBlock, FileCitation, FilePath, HistoryItem, InputImage, InputText, InputTokensDetails, Message, OutputText, OutputTokensDetails, Reasoning, Refusal, Role, StopReason, ToolCall, ToolCallOutput, UrlCitation, Usage, assistantText, isContainerFileCitation, isFileCitation, isFilePath, isInputImage, isInputText, isMessage, isOutputText, isReasoning, isRefusal, isToolCall, isToolCallOutput, isUrlCitation, systemText, toolCallOutput, userText };
+  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 };
 }
 declare const InputText: Schema.Struct<{
   readonly type: Schema.Literal<"input_text">;
@@ -137,6 +137,21 @@ declare const OutputText: Schema.Struct<{
   }>]>>>;
 }>;
 type OutputText = typeof OutputText.Type;
+/**
+ * Model-emitted image. The counterpart to {@link InputImage}: same
+ * `ImageSource`, so an image the model drew goes straight back into the
+ * next turn with no conversion.
+ *
+ * How the pixels were produced is not modelled here. A provider may draw
+ * them itself, as an image part of the turn, or reach a hosted tool that
+ * draws them; either way the fact is the same, and enabling it is
+ * provider-specific.
+ */
+declare const OutputImage: Schema.Struct<{
+  readonly type: Schema.Literal<"output_image">;
+  readonly source: Schema.Schema<ImageSource>;
+}>;
+type OutputImage = typeof OutputImage.Type;
 /**
  * Model-emitted refusal. Distinct from `output_text`: the model declined
  * to answer rather than producing normal output. Pair with
@@ -180,6 +195,9 @@ declare const ContentBlock: Schema.Union<readonly [Schema.Struct<{
     readonly file_id: Schema.String;
     readonly index: Schema.Number;
   }>]>>>;
+}>, Schema.Struct<{
+  readonly type: Schema.Literal<"output_image">;
+  readonly source: Schema.Schema<ImageSource>;
 }>, Schema.Struct<{
   readonly type: Schema.Literal<"refusal">;
   readonly text: Schema.String;
@@ -222,6 +240,9 @@ declare const Message: Schema.Struct<{
       readonly file_id: Schema.String;
       readonly index: Schema.Number;
     }>]>>>;
+  }>, Schema.Struct<{
+    readonly type: Schema.Literal<"output_image">;
+    readonly source: Schema.Schema<ImageSource>;
   }>, Schema.Struct<{
     readonly type: Schema.Literal<"refusal">;
     readonly text: Schema.String;
@@ -293,6 +314,9 @@ declare const HistoryItem: Schema.Union<readonly [Schema.Struct<{
       readonly file_id: Schema.String;
       readonly index: Schema.Number;
     }>]>>>;
+  }>, Schema.Struct<{
+    readonly type: Schema.Literal<"output_image">;
+    readonly source: Schema.Schema<ImageSource>;
   }>, Schema.Struct<{
     readonly type: Schema.Literal<"refusal">;
     readonly text: Schema.String;
@@ -352,6 +376,10 @@ declare const isOutputText: <I>(input: I) => input is I & {
     readonly index: number;
   })[] | undefined;
 };
+declare const isOutputImage: <I>(input: I) => input is I & {
+  readonly type: "output_image";
+  readonly source: ImageSource;
+};
 declare const isRefusal: <I>(input: I) => input is I & {
   readonly type: "refusal";
   readonly text: string;
@@ -391,6 +419,9 @@ declare const isMessage: <I>(input: I) => input is I & {
       readonly file_id: string;
       readonly index: number;
     })[] | undefined;
+  } | {
+    readonly type: "output_image";
+    readonly source: ImageSource;
   } | {
     readonly type: "refusal";
     readonly text: string;
@@ -457,5 +488,5 @@ declare const systemText: (text: string) => Message;
 declare const assistantText: (text: string) => Message;
 declare const toolCallOutput: (call_id: string, output: string) => ToolCallOutput;
 //#endregion
-export { isReasoning as A, isContainerFileCitation as C, isInputText as D, isInputImage as E, systemText as F, toolCallOutput as I, userText as L, isToolCall as M, isToolCallOutput as N, isMessage as O, isUrlCitation as P, assistantText as S, isFilePath as T, StopReason as _, FilePath as a, UrlCitation as b, InputText as c, Message as d, OutputText as f, Role as g, Refusal as h, FileCitation as i, isRefusal as j, isOutputText as k, InputTokensDetails as l, Reasoning as m, ContainerFileCitation as n, HistoryItem as o, OutputTokensDetails as p, ContentBlock as r, InputImage as s, Annotation as t, Items_d_exports as u, ToolCall as v, isFileCitation as w, Usage as x, ToolCallOutput as y };
-//# sourceMappingURL=Items-SfUabNuB.d.mts.map
+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

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

@@ -0,0 +1 @@
+{"version":3,"file":"Items-C7MyrYPX.d.mts","names":[],"sources":["../src/domain/Items.ts"],"mappings":";;;;;cAOa,WAAS,OAAA;;;;KAIV,mBAAmB,UAAU;;;;;;;;;cAU5B,YAAU,OAAA;;;;KAIX,oBAAoB,WAAW;;;;;;;;;cAgB9B,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;cAE1B,gBAAc,OAAA;;;;;;KAMf,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,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;cAMhC,iBAAc,iBAAmB,mBAAmB"}

package/dist/Media-BbX7BAaO.d.mts

@@ -0,0 +1,60 @@
+import { Result } from "effect";
+declare namespace Media_d_exports {
+  export { AspectRatio, Dimensions, MediaBase64, MediaBytes, MediaSource, MediaUrl, Watermark, isMediaBase64, isMediaBytes, isMediaUrl, parseAspectRatio, round16 };
+}
+/**
+ * Watermark kind a provider embedded in generated media. Shared across
+ * modalities (audio, image). No provider exposes metadata beyond the
+ * kind, so a bare literal union is enough.
+ */
+type Watermark = "synthid" | "c2pa" | (string & {});
+/**
+ * Requested shape of generated visual media, width to height. Shared by
+ * image and video generation: the listed ratios are the ones providers
+ * accept as literals, and the `(string & {})` tail keeps a
+ * newly-supported ratio working without an SDK update. Which ratios a
+ * given model accepts is not checked here; the provider rejects what it
+ * cannot render and the adapter translates that error.
+ *
+ * Resolution is NOT shared: image models tier by short edge
+ * (`ImageResolution`), video models by scan height. Each modality types
+ * its own.
+ */
+type AspectRatio = "1:1" | "2:3" | "3:2" | "3:4" | "4:3" | "4:5" | "5:4" | "9:16" | "16:9" | "21:9" | "1:4" | "4:1" | "1:8" | "8:1" | (string & {});
+/** Exact pixels, for adapters whose wire takes dimensions rather than a ratio. */
+type Dimensions = {
+  readonly width: number;
+  readonly height: number;
+};
+/**
+ * Read `"W:H"` as a pair. Fails when the ratio is not arithmetic, which
+ * the `(string & {})` tail on {@link AspectRatio} lets through: a caller
+ * asking for `"cinematic"` gets a message rather than NaN pixels. The
+ * failure is a plain string so this file stays free of provider
+ * vocabulary; each adapter wraps it in its own error.
+ */
+declare const parseAspectRatio: (ratio: AspectRatio) => Result.Result<readonly [number, number], string>;
+/** Several image endpoints require both edges to be multiples of 16. */
+declare const round16: (n: number) => number;
+type MediaUrl<M extends string = string> = {
+  readonly _tag: "url";
+  readonly url: string;
+  readonly mimeType?: M;
+};
+type MediaBase64<M extends string = string> = {
+  readonly _tag: "base64";
+  readonly base64: string;
+  readonly mimeType: M;
+};
+type MediaBytes<M extends string = string> = {
+  readonly _tag: "bytes";
+  readonly bytes: Uint8Array;
+  readonly mimeType: M;
+};
+type MediaSource<M extends string = string> = MediaUrl<M> | MediaBase64<M> | MediaBytes<M>;
+declare const isMediaUrl: <M extends string>(s: MediaSource<M>) => s is MediaUrl<M>;
+declare const isMediaBase64: <M extends string>(s: MediaSource<M>) => s is MediaBase64<M>;
+declare const isMediaBytes: <M extends string>(s: MediaSource<M>) => s is MediaBytes<M>;
+//#endregion
+export { MediaSource as a, Watermark as c, isMediaUrl as d, parseAspectRatio as f, MediaBytes as i, isMediaBase64 as l, Dimensions as n, MediaUrl as o, round16 as p, MediaBase64 as r, Media_d_exports as s, AspectRatio as t, isMediaBytes as u };
+//# sourceMappingURL=Media-BbX7BAaO.d.mts.map

package/dist/Media-BbX7BAaO.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Media-BbX7BAaO.d.mts","names":[],"sources":["../src/domain/Media.ts"],"mappings":";;;;;;;;;KAwCY;;;;;;;;;;;;;KAcA;;KAkBA;WACD;WACA;;;;;;;;;cAaE,mBAAgB,OACpB,gBACN,OAAO;;cAQG,UAAO;KAER,SAAS;WACV;WACA;WACA,WAAW;;KAGV,YAAY;WACb;WACA;WACA,UAAU;;KAGT,WAAW;WACZ;WACA,OAAO;WACP,UAAU;;KAGT,YAAY,6BAA6B,SAAS,KAAK,YAAY,KAAK,WAAW;cAElF,aAAc,kBAAgB,GAAK,YAAY,OAAK,KAAK,SAAS;cAGlE,gBAAiB,kBAAgB,GAAK,YAAY,OAAK,KAAK,YAAY;cAGxE,eAAgB,kBAAgB,GAAK,YAAY,OAAK,KAAK,WAAW"}

package/dist/MessengerError-CeK6VAcu.d.mts

@@ -0,0 +1,64 @@
+import { Duration } from "effect";
+declare namespace MessengerError_d_exports {
+  export { MessengerConnectFailed, MessengerError, MessengerOperation, MessengerRateLimited, MessengerRequestFailed, MessengerTransportClosed, MessengerUnsupported, describe };
+}
+declare const MessengerConnectFailed_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+  readonly _tag: "MessengerConnectFailed";
+} & Readonly<A>;
+/** Transport never came up: bad token, rejected handshake. Raised at layer build. */
+declare class MessengerConnectFailed extends MessengerConnectFailed_base<{
+  provider: string;
+  reason: string;
+  raw: unknown;
+}> {}
+declare const MessengerTransportClosed_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+  readonly _tag: "MessengerTransportClosed";
+} & Readonly<A>;
+/**
+ * Inbound transport ended for good (reconnect budget spent, fatal close).
+ * Routine reconnects stay inside the adapter and never surface here.
+ */
+declare class MessengerTransportClosed extends MessengerTransportClosed_base<{
+  provider: string;
+  reason: string;
+  raw?: unknown;
+}> {}
+/** Which verb was rejected. */
+type MessengerOperation = "post" | "edit" | "react" | "typing";
+declare const MessengerRequestFailed_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+  readonly _tag: "MessengerRequestFailed";
+} & Readonly<A>;
+/** An outbound verb was rejected: permission, unknown chat, text too long, no-op edit. */
+declare class MessengerRequestFailed extends MessengerRequestFailed_base<{
+  provider: string;
+  operation: MessengerOperation;
+  reason: string;
+  raw: unknown;
+}> {}
+declare const MessengerRateLimited_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+  readonly _tag: "MessengerRateLimited";
+} & Readonly<A>;
+/**
+ * Slow down, for this long. Typed rather than retried blindly so callers -
+ * `streamViaEdits` above all - decide whether waiting is still worth it.
+ */
+declare class MessengerRateLimited extends MessengerRateLimited_base<{
+  provider: string;
+  retryAfter: Duration.Duration;
+  raw?: unknown;
+}> {}
+declare const MessengerUnsupported_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+  readonly _tag: "MessengerUnsupported";
+} & Readonly<A>;
+/** The platform cannot express this at all: off-set reaction emoji, edits on WhatsApp. */
+declare class MessengerUnsupported extends MessengerUnsupported_base<{
+  provider: string;
+  capability: string;
+  reason: string;
+}> {}
+type MessengerError = MessengerConnectFailed | MessengerTransportClosed | MessengerRequestFailed | MessengerRateLimited | MessengerUnsupported;
+/** Human-readable description for logs. Prose, not a contract; branch on `_tag`. */
+declare const describe: (e: MessengerError) => string;
+//#endregion
+export { MessengerRateLimited as a, MessengerUnsupported as c, MessengerOperation as i, describe as l, MessengerError as n, MessengerRequestFailed as o, MessengerError_d_exports as r, MessengerTransportClosed as s, MessengerConnectFailed as t };
+//# sourceMappingURL=MessengerError-CeK6VAcu.d.mts.map

package/dist/MessengerError-CeK6VAcu.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MessengerError-CeK6VAcu.d.mts","names":[],"sources":["../src/messenger/MessengerError.ts"],"mappings":";;;;;;;;cAMa,+BAA+B;EAC1C;EACA;EACA;;;;;;;;;cAOW,iCAAiC;EAC5C;EACA;EACA;;;KAIU;;;;;cAGC,+BAA+B;EAC1C;EACA,WAAW;EACX;EACA;;;;;;;;;cAOW,6BAA6B;EACxC;EACA,YAAY,SAAS;EACrB;;;;;;cAIW,6BAA6B;EACxC;EACA;EACA;;KAGU,iBACR,yBACA,2BACA,yBACA,uBACA;;cAGS,WAAW,GAAG"}

package/dist/{Tool-DE-rnvkw.d.mts → Tool-BF78QWtn.d.mts}

@@ -1,4 +1,4 @@
-import { v as ToolCall, y as ToolCallOutput } from "./Items-SfUabNuB.mjs";
+import { b as ToolCallOutput, y as ToolCall } from "./Items-C7MyrYPX.mjs";
 import { Effect, Schema } from "effect";
 import { StandardJSONSchemaV1, StandardSchemaV1 } from "@standard-schema/spec";
 declare namespace Tool_d_exports {
@@ -311,4 +311,4 @@ declare const decodeArgs: <Input>(tool: DecodableTool<Input>, call: ToolCall) =>
 declare const execute: <Name extends string, Input, Event, Output, E, R>(tool: Tool<Name, Input, Event, Output, E, R>, call: ToolCall) => Effect.Effect<ToolCallOutput, E | ToolError | ToolValidationError, R>;
 //#endregion
 export { providerToolsOf as A, fromEffectSchema as C, make as D, isProviderTool as E, toDescriptors as M, withName as N, noInput as O, withRun as P, fail as S, interaction as T, Tool_d_exports as _, Emit as a, descriptorsOf as b, SignalTool as c, ToolE as d, ToolError as f, ToolValidationError as g, ToolR as h, DecodeResult as i, signal as j, provider as k, Tool as l, ToolInputSchema as m, AnyTool as n, InteractionTool as o, ToolFailed as p, DecodableTool as r, ProviderTool as s, AnyLocalTool as t, ToolDescriptor as u, decodeArgs as v, fromStandardSchema as w, execute as x, decodeCallInput as y };
-//# sourceMappingURL=Tool-DE-rnvkw.d.mts.map
+//# sourceMappingURL=Tool-BF78QWtn.d.mts.map

package/dist/{Tool-DE-rnvkw.d.mts.map → Tool-BF78QWtn.d.mts.map}

@@ -1 +1 @@
-{"version":3,"file":"Tool-DE-rnvkw.d.mts","names":[],"sources":["../src/tool/Tool.ts"],"mappings":"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"}
+{"version":3,"file":"Tool-BF78QWtn.d.mts","names":[],"sources":["../src/tool/Tool.ts"],"mappings":";;;;;;;;;;;;cAMa,kBAAkB;;;;;;;;;;;;;;;cA0BlB,4BAA4B;;;;;;;;;;;;;;cAiB5B,mBAAmB;;;;;;cAanB,OAAI,iBACA;WACM;MACpB,OAAO,cAAc;;;;;;;;;;KAcZ,gBAAgB,mBAAmB,0BAA0B,SACvE,8BAA8B;;;;;;cAOnB,mBAAoB,UAAU,OAAO,6BAA2B,QACnE,MACP,IAAI,gBAAgB;;;;;;;;;;;;;;;;cAkBV,qBAAsB,UAAU,mBAAmB,sBAAoB,QAC1E,MACP,IAAI,gBAAgB,iBAAiB,YAAY;;;;;;;;cAUvC,SAAS,gBAAgB;;;;;;KAiB1B,KAAK,UAAU,OAAO,UAAU,OAAO;;;;;;;;;;;;;KAcvC,KAAK,qBAAqB,OAAO,OAAO,QAAQ,aAAa;WAC9D;WACA,MAAM;WACN;WACA,aAAa,gBAAgB;WAC7B,MAAM,OAAO,OAAO,MAAM,KAAK,WAAW,OAAO,OAAO,QAAQ,GAAG;;;;;;WAMnE;;;;;;;WAOA;;;;;;;;KASC,aAAa,qBAAqB,OAAO,yBAAyB;WACnE;WACA,MAAM;WACN;WACA,aAAa,gBAAgB;WAC7B,UAAU;WACV,QAAQ;WACR;;;;;;;;KASC,WAAW,qBAAqB;WACjC;WACA,MAAM;WACN;WACA,aAAa,gBAAgB;;;;;;;;KAS5B,gBAAgB,qBAAqB;WACtC;WACA,MAAM;WACN;WACA,aAAa,gBAAgB;;;KAI5B,aAAa,SAAS,WAAW,4BAA4B,GAAG;;KAGhE,QAAQ,SAAS,WACzB,4BAA4B,GAAG,KAC/B,yCACA,0BACA;;KAGQ,cAAc;WACf;WACA,aAAa,gBAAgB;;;KAI5B,MAAM,KAAK,UAAU,uCAAuC,KAAK;;KAGjE,MAAM,KAAK,UAAU,kCAAkC,UAAU;;;;;;KAOjE;WACD;WACA;WACA,aAAa;WACb;;;cAWE;GAET,qBACA,UAAU,OAAO,6BACjB,OACA,QACA,WACA,WAEA,MAAM,KAAK,KAAK,MAAM,WAAW,OAAO,QAAQ,GAAG;aACxC,aAAa;MAEvB,KAAK,MAAM,WAAW,OAAO,QAAQ,GAAG;GAC1C,qBAAqB,OAAO,OAAO,QAAQ,WAAW,WACrD,MAAM,KAAK,KAAK,MAAM,OAAO,OAAO,QAAQ,GAAG,cAC9C,KAAK,MAAM,OAAO,OAAO,QAAQ,GAAG;;;;;;;cAgB5B;GAET,qBACA,UAAU,OAAO,6BACjB,yBACA,QAEA,MAAM,KAAK,aAAa,MAAM,WAAW,UAAU;aACxC,aAAa;MAEvB,aAAa,MAAM,WAAW,UAAU;GAC1C,qBAAqB,OAAO,yBAAyB,QACpD,MAAM,KAAK,aAAa,MAAM,OAAO,UAAU,mBAC9C,aAAa,MAAM,OAAO,UAAU;;;;;;;cAgB5B;GACV,qBAAqB,UAAU,OAAO,6BACrC,MAAM,KAAK,WAAW,MAAM;aACjB,aAAa;MAEvB,WAAW,MAAM;GACnB,qBAAqB,OAAO,MAAM,KAAK,WAAW,MAAM,kBAAkB,WAAW,MAAM;;;;;;;cAgBjF;GACV,qBAAqB,UAAU,OAAO,6BACrC,MAAM,KAAK,gBAAgB,MAAM;aACtB,aAAa;MAEvB,gBAAgB,MAAM;GACxB,qBAAqB,OACpB,MAAM,KAAK,gBAAgB,MAAM,kBAChC,gBAAgB,MAAM;;;;;;;cAgBd,WAAY,kBAAkB,UAAU,SAAO,MACpD,GAAC,MACD,MACL,KAAK;WAAwB,MAAM;;;;;;;;;;;;;cAazB,UACX,qBACA,OACA,OACA,QACA,GACA,GACA,SACA,YACA,YAAU,MAEJ,KAAK,MAAM,OAAO,OAAO,QAAQ,GAAG,IAAE,MACtC,OAAO,OAAO,MAAM,KAAK,WAAW,OAAO,OAAO,SAAS,IAAI,QACpE,KAAK,MAAM,OAAO,OAAO,SAAS,IAAI;;cAG5B,iBAAc,MAAU,YAAU,QAAQ;;;;;;cAQ1C,kBAAe,UAChB,SAAS,eAAe,cACjC,cAAc;;;;;;;cASJ,gBAAa,OAAW,cAAc,aAAW,cAAc;;;;;;;;cAqB/D,gBAAa,UACd,SAAS,eAAe,cACjC,cAAc;;;;;;KAQL,aAAa;WACV;WAAqB,OAAO;;WAC5B;;WACA;WAA0B,QAAQ,cAAc,iBAAiB;;;;;;;cAWnE,kBAAmB,OAAK,MAC7B,cAAc,QAAM,MACpB,aACL,OAAO,OAAO,aAAa;;;;;;;;;;cAgCjB,aAAc,OAAK,MACxB,cAAc,QAAM,MACpB,aACL,OAAO,OAAO,OAAO,YAAY;;;;;;;cA4BvB,UAAW,qBAAqB,OAAO,OAAO,QAAQ,GAAG,GAAC,MAC/D,KAAK,MAAM,OAAO,OAAO,QAAQ,GAAG,IAAE,MACtC,aACL,OAAO,OAAO,gBAAgB,IAAI,YAAY,qBAAqB"}

package/dist/{ToolEvent-D99MGQYH.d.mts → ToolEvent-Di4a723B.d.mts}

@@ -1,4 +1,4 @@
-import { t as ToolResult } from "./ToolResult-Cj8ChodL.mjs";
+import { t as ToolResult } from "./ToolResult-BsYQRjmW.mjs";
 import { Data } from "effect";
 declare namespace ToolEvent_d_exports {
   export { ToolEvent, isApprovalRequested, isOutput, isProgress };
@@ -141,4 +141,4 @@ declare const isOutput: (u: unknown) => u is {
 };
 //#endregion
 export { isProgress as a, isOutput as i, ToolEvent_d_exports as n, isApprovalRequested as r, ToolEvent as t };
-//# sourceMappingURL=ToolEvent-D99MGQYH.d.mts.map
+//# sourceMappingURL=ToolEvent-Di4a723B.d.mts.map

package/dist/{ToolEvent-D99MGQYH.d.mts.map → ToolEvent-Di4a723B.d.mts.map}

@@ -1 +1 @@
-{"version":3,"file":"ToolEvent-D99MGQYH.d.mts","names":[],"sources":["../src/tool/ToolEvent.ts"],"mappings":";;;;;KAkBY,YAAY,KAAK;EAC3B;aACW;aACA;aACA;;EAEX;aACW;aACA;aACA;;EAEX;aACW,QAAQ;;;;;;;;;;cAWR;;;aArBS;aACH;aACK;;;;;aAQH,QAAA;;;;;aALC;aACH;aACA;;;;;;;eAPG;eACH;eACK;;;eAQH,QAAA;;;eALC;eACH;eACA;;;;;;;;;;;;;;;;;;;eAPG;eACH;eACK;;;eAQH,QAAA;;;eALC;eACH;eACA;;;;;;;;;;;;;;;;;;;;aAPG;aACH;aACK;;;;aAQH,QAAA;;;;aALC;aACH;aACA;;;cAgBN,sBAAmB,eAAA;;WAvBV;WACH;WACK;;cAsBX,aAAU,eAAA;;WAnBD;WACH;WACA;;cAkBN,WAAQ,eAAA;;WAfA,QAAA"}
+{"version":3,"file":"ToolEvent-Di4a723B.d.mts","names":[],"sources":["../src/tool/ToolEvent.ts"],"mappings":";;;;;KAkBY,YAAY,KAAK;EAC3B;aACW;aACA;aACA;;EAEX;aACW;aACA;aACA;;EAEX;aACW,QAAQ;;;;;;;;;;cAWR;;;aArBS;aACH;aACK;;;;;aAQH,QAAA;;;;;aALC;aACH;aACA;;;;;;;eAPG;eACH;eACK;;;eAQH,QAAA;;;eALC;eACH;eACA;;;;;;;;;;;;;;;;;;;eAPG;eACH;eACK;;;eAQH,QAAA;;;eALC;eACH;eACA;;;;;;;;;;;;;;;;;;;;aAPG;aACH;aACK;;;;aAQH,QAAA;;;;aALC;aACH;aACA;;;cAgBN,sBAAmB,eAAA;;WAvBV;WACH;WACK;;cAsBX,aAAU,eAAA;;WAnBD;WACH;WACA;;cAkBN,WAAQ,eAAA;;WAfA,QAAA"}

package/dist/{ToolResult-Cj8ChodL.d.mts → ToolResult-BsYQRjmW.d.mts}

@@ -1,4 +1,4 @@
-import { v as ToolCall, y as ToolCallOutput } from "./Items-SfUabNuB.mjs";
+import { b as ToolCallOutput, y as ToolCall } from "./Items-C7MyrYPX.mjs";
 import { Data } from "effect";
 declare namespace ToolResult_d_exports {
   export { ToolResult, cancelled, denied, executionError, failed, isFailure, isOk, nonLocalTool, serializeValue, toToolCallOutput, validationError };
@@ -149,4 +149,4 @@ declare const serializeValue: (value: unknown) => string;
 declare const toToolCallOutput: (r: ToolResult) => ToolCallOutput;
 //#endregion
 export { executionError as a, isOk as c, toToolCallOutput as d, validationError as f, denied as i, nonLocalTool as l, ToolResult_d_exports as n, failed as o, cancelled as r, isFailure as s, ToolResult as t, serializeValue as u };
-//# sourceMappingURL=ToolResult-Cj8ChodL.d.mts.map
+//# sourceMappingURL=ToolResult-BsYQRjmW.d.mts.map

package/dist/{ToolResult-Cj8ChodL.d.mts.map → ToolResult-BsYQRjmW.d.mts.map}

@@ -1 +1 @@
-{"version":3,"file":"ToolResult-Cj8ChodL.d.mts","names":[],"sources":["../src/tool/ToolResult.ts"],"mappings":";;;;;KAqBY,aAAa,KAAK;EAC5B;aACW;aACA;aACA;;EAEX;aACW;aACA;aACA;aACA;;;;;;;;;;;cAYA;;;aAfS;aACH;aACA;aACG;;;;;aARA;aACH;aACC;;;;;;;eAGE;eACH;eACA;eACG;;;eARA;eACH;eACC;;;;;;;;;;;;;;;;;eAGE;eACH;eACA;eACG;;;eARA;eACH;eACC;;;;;;;;;;;;;;;;;;aAGE;aACH;aACA;aACG;;;;aARA;aACH;aACC;;;cAoBP,OAAI,eAAA;;WAtBK;WACH;WACC;;cAqBP,YAAS,eAAA;;WAlBA;WACH;WACA;WACG;;cAqBT,SAAM,MAAU,UAAQ,cAAc,oBAAoB;;cAS1D,SAAM,MAAU,UAAQ,oBAAoB;;cAI5C,YAAS,MAAU,UAAQ,oBAAoB;;cAI/C,iBAAc,MAAU,UAAQ,mBAAmB;;;;;;;cASnD,eAAY,MAAU,UAAQ,oBAAoB;;;;;;cAYlD,kBAAe,MAAU,UAAQ,oBAAoB;;;;;;cAYrD,iBAAc;cAOd,mBAAgB,GAAO,eAAa"}
+{"version":3,"file":"ToolResult-BsYQRjmW.d.mts","names":[],"sources":["../src/tool/ToolResult.ts"],"mappings":";;;;;KAqBY,aAAa,KAAK;EAC5B;aACW;aACA;aACA;;EAEX;aACW;aACA;aACA;aACA;;;;;;;;;;;cAYA;;;aAfS;aACH;aACA;aACG;;;;;aARA;aACH;aACC;;;;;;;eAGE;eACH;eACA;eACG;;;eARA;eACH;eACC;;;;;;;;;;;;;;;;;eAGE;eACH;eACA;eACG;;;eARA;eACH;eACC;;;;;;;;;;;;;;;;;;aAGE;aACH;aACA;aACG;;;;aARA;aACH;aACC;;;cAoBP,OAAI,eAAA;;WAtBK;WACH;WACC;;cAqBP,YAAS,eAAA;;WAlBA;WACH;WACA;WACG;;cAqBT,SAAM,MAAU,UAAQ,cAAc,oBAAoB;;cAS1D,SAAM,MAAU,UAAQ,oBAAoB;;cAI5C,YAAS,MAAU,UAAQ,oBAAoB;;cAI/C,iBAAc,MAAU,UAAQ,mBAAmB;;;;;;;cASnD,eAAY,MAAU,UAAQ,oBAAoB;;;;;;cAYlD,kBAAe,MAAU,UAAQ,oBAAoB;;;;;;cAYrD,iBAAc;cAOd,mBAAgB,GAAO,eAAa"}

package/dist/{Toolkit-BEZrNPTI.d.mts → Toolkit-DAjJ9Tvl.d.mts}

@@ -1,9 +1,9 @@
-import { o as HistoryItem, v as ToolCall } from "./Items-SfUabNuB.mjs";
-import { a as Emit, c as SignalTool, d as ToolE, h as ToolR, l as Tool, n as AnyTool, o as InteractionTool, p as ToolFailed, s as ProviderTool, u as ToolDescriptor } from "./Tool-DE-rnvkw.mjs";
+import { o as HistoryItem, y as ToolCall } from "./Items-C7MyrYPX.mjs";
+import { a as Emit, c as SignalTool, d as ToolE, h as ToolR, l as Tool, n as AnyTool, o as InteractionTool, p as ToolFailed, s as ProviderTool, u as ToolDescriptor } from "./Tool-BF78QWtn.mjs";
 import { Turn } from "./domain/Turn.mjs";
 import { r as Step } from "./Loop-B54AB1ME.mjs";
-import { t as ToolResult } from "./ToolResult-Cj8ChodL.mjs";
-import { t as ToolEvent } from "./ToolEvent-D99MGQYH.mjs";
+import { t as ToolResult } from "./ToolResult-BsYQRjmW.mjs";
+import { t as ToolEvent } from "./ToolEvent-Di4a723B.mjs";
 import { Cause, Effect, Stream } from "effect";
 declare namespace Toolkit_d_exports {
   export { DuplicateToolName, ExecuteOptions, Middleware, NoDuplicateNames, ToolMap, Toolkit, ToolkitE, ToolkitR, UniqueTools, appendToolResults, collectResults, compose, continueWithResults, describeFailures, descriptors, fromArray, make, makeNamespaced, namespace, run, wrap };
@@ -190,4 +190,4 @@ declare const continueWithResults: {
 };
 //#endregion
 export { wrap as S, fromArray as _, ToolMap as a, namespace as b, ToolkitR as c, appendToolResults as d, collectResults as f, descriptors as g, describeFailures as h, NoDuplicateNames as i, Toolkit_d_exports as l, continueWithResults as m, ExecuteOptions as n, Toolkit as o, compose as p, Middleware as r, ToolkitE as s, DuplicateToolName as t, UniqueTools as u, make as v, run as x, makeNamespaced as y };
-//# sourceMappingURL=Toolkit-BEZrNPTI.d.mts.map
+//# sourceMappingURL=Toolkit-DAjJ9Tvl.d.mts.map

package/dist/{Toolkit-BEZrNPTI.d.mts.map → Toolkit-DAjJ9Tvl.d.mts.map}

@@ -1 +1 @@
-{"version":3,"file":"Toolkit-BEZrNPTI.d.mts","names":[],"sources":["../src/tool/Toolkit.ts"],"mappings":"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"}
+{"version":3,"file":"Toolkit-DAjJ9Tvl.d.mts","names":[],"sources":["../src/tool/Toolkit.ts"],"mappings":"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"}

package/dist/browser/BrowserTool.d.mts

@@ -1,6 +1,6 @@
 import { BrowserError } from "./BrowserError.mjs";
 import { BrowserSession } from "./Browser.mjs";
-import { l as Tool } from "../Tool-DE-rnvkw.mjs";
+import { l as Tool } from "../Tool-BF78QWtn.mjs";
 declare namespace BrowserTool_d_exports {
   export { browserToolkit, clickTool, fillTool, gotoTool, pressTool, scrollTool };
 }

package/dist/capabilities/Capabilities.d.mts

@@ -1,6 +1,7 @@
+import { o as HistoryItem, r as ContentBlock } from "../Items-C7MyrYPX.mjs";
 import { Effect } from "effect";
 declare namespace Capabilities_d_exports {
-  export { CapabilityWarning, warnDropped, warnDroppedWhen };
+  export { CapabilityWarning, warnDropped, warnDroppedBlocks, warnDroppedWhen };
 }
 /**
  * Structured event emitted when a provider adapter drops a Common
@@ -75,6 +76,29 @@ declare const warnDropped: (warning: Omit<CapabilityWarning, "_tag">) => Effect.
  * ```
  */
 declare const warnDroppedWhen: <T>(value: T | undefined, warning: Omit<CapabilityWarning, "_tag" | "value">) => Effect.Effect<void>;
+/**
+ * Warn when history carries a content block this provider's wire has no
+ * place for, which its encoder therefore omits.
+ *
+ * History is provider-agnostic, so a turn one provider produced can be
+ * replayed into another. A block only one provider can express
+ * (`output_image`, which needs an assistant-role image part) then reaches
+ * an encoder with nothing to map it to. Omitting is right, since failing
+ * would break replaying a mixed history just to continue the text, but it
+ * should not be silent.
+ *
+ * Call once from the effectful request path; the block encoders stay pure.
+ *
+ * @example
+ * ```ts
+ * yield* warnDroppedBlocks(history, "output_image", {
+ *   provider: "anthropic",
+ *   capability: "output_image",
+ *   reason: "Assistant messages carry no image here. Convert with `imagesAsInput` to send it as user content.",
+ * })
+ * ```
+ */
+declare const warnDroppedBlocks: (history: ReadonlyArray<HistoryItem>, type: ContentBlock["type"], warning: Omit<CapabilityWarning, "_tag" | "field" | "value">) => Effect.Effect<void>;
 //#endregion
-export { CapabilityWarning, Capabilities_d_exports as t, warnDropped, warnDroppedWhen };
+export { CapabilityWarning, Capabilities_d_exports as t, warnDropped, warnDroppedBlocks, warnDroppedWhen };
 //# sourceMappingURL=Capabilities.d.mts.map

package/dist/capabilities/Capabilities.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"Capabilities.d.mts","names":[],"sources":["../../src/capabilities/Capabilities.ts"],"mappings":";;;;;;;;;;;;;;;;;KAeY;WACD;WACA;;WAEA;;WAEA;;WAEA;;WAEA;;;;;;;;;;;;;;;;;;;;;;;;;cA0BE,cAAW,SAAa,KAAK,+BAA6B,OAAO;;;;;;;;;;;;;;;;;;;;;;;;cA0BjE,kBAAmB,GAAC,OACxB,eAAa,SACX,KAAK,yCACb,OAAO"}
+{"version":3,"file":"Capabilities.d.mts","names":[],"sources":["../../src/capabilities/Capabilities.ts"],"mappings":";;;;;;;;;;;;;;;;;;KAgBY;WACD;WACA;;WAEA;;WAEA;;WAEA;;WAEA;;;;;;;;;;;;;;;;;;;;;;;;;cA0BE,cAAW,SAAa,KAAK,+BAA6B,OAAO;;;;;;;;;;;;;;;;;;;;;;;;cA0BjE,kBAAmB,GAAC,OACxB,eAAa,SACX,KAAK,yCACb,OAAO;;;;;;;;;;;;;;;;;;;;;;;cAwBG,oBAAiB,SACnB,cAAc,cAAY,MAC7B,sBAAoB,SACjB,KAAK,mDACb,OAAO"}

package/dist/capabilities/Capabilities.mjs

@@ -3,6 +3,7 @@ import { Effect } from "effect";
 //#region src/capabilities/Capabilities.ts
 var Capabilities_exports = /* @__PURE__ */ __exportAll({
 	warnDropped: () => warnDropped,
+	warnDroppedBlocks: () => warnDroppedBlocks,
 	warnDroppedWhen: () => warnDroppedWhen
 });
 /**
@@ -59,7 +60,37 @@ const warnDroppedWhen = (value, warning) => value === void 0 ? Effect.void : war
 	...warning,
 	value
 });
+/**
+* Warn when history carries a content block this provider's wire has no
+* place for, which its encoder therefore omits.
+*
+* History is provider-agnostic, so a turn one provider produced can be
+* replayed into another. A block only one provider can express
+* (`output_image`, which needs an assistant-role image part) then reaches
+* an encoder with nothing to map it to. Omitting is right, since failing
+* would break replaying a mixed history just to continue the text, but it
+* should not be silent.
+*
+* Call once from the effectful request path; the block encoders stay pure.
+*
+* @example
+* ```ts
+* yield* warnDroppedBlocks(history, "output_image", {
+*   provider: "anthropic",
+*   capability: "output_image",
+*   reason: "Assistant messages carry no image here. Convert with `imagesAsInput` to send it as user content.",
+* })
+* ```
+*/
+const warnDroppedBlocks = (history, type, warning) => {
+	const count = history.reduce((n, item) => n + (item.type === "message" ? item.content.filter((b) => b.type === type).length : 0), 0);
+	return count === 0 ? Effect.void : warnDropped({
+		...warning,
+		field: type,
+		value: `${count} block(s)`
+	});
+};
 //#endregion
-export { Capabilities_exports as t, warnDropped, warnDroppedWhen };
+export { Capabilities_exports as t, warnDropped, warnDroppedBlocks, warnDroppedWhen };
 
 //# sourceMappingURL=Capabilities.mjs.map

package/dist/capabilities/Capabilities.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"Capabilities.mjs","names":[],"sources":["../../src/capabilities/Capabilities.ts"],"sourcesContent":["import { Effect } from \"effect\"\n\n/**\n * Structured event emitted when a provider adapter drops a Common\n * request field because its wire API has no place to put it (bucket 2\n * per the capabilities policy: the provider has no structured\n * interpretation; the output is still valid, just less aligned with\n * the caller's hint).\n *\n * Carried on `Effect.logWarning` today for visibility; may be\n * promoted to a typed `AiError` variant in the future if callers need\n * to react programmatically. The shape itself is stable.\n *\n * @category capabilities\n */\nexport type CapabilityWarning = {\n  readonly _tag: \"CapabilityWarning\"\n  readonly provider: string\n  /** The capability name as it appears in docs (`\"lyrics\"`, `\"bpm\"`). */\n  readonly capability: string\n  /** The Common-request field name that was dropped. */\n  readonly field: string\n  /** The value the caller passed; included when useful for debugging. */\n  readonly value?: unknown\n  /** Human-readable explanation; should suggest a workaround. */\n  readonly reason: string\n}\n\n/**\n * Emit a structured `CapabilityWarning` via `Effect.logWarning`. Use\n * when a provider adapter receives a Common-request field it has no\n * structured wire field for, and would otherwise drop silently.\n *\n * Bucket-2 cases only (per the capabilities policy): the provider has\n * no interpretation; the output is still valid, just less aligned\n * with the caller's hint. For bucket-1 cases (structurally broken\n * output if dropped, like wrong audio format), fail\n * `AiError.Unsupported` instead.\n *\n * @example\n * ```ts\n * if (request.lyrics !== undefined) {\n *   yield* warnDropped({\n *     provider: \"lyria\",\n *     capability: \"lyrics\",\n *     field: \"lyrics\",\n *     reason: \"Lyria 3 sync has no `lyrics` wire field. Embed in your prompt instead.\",\n *   })\n * }\n * ```\n */\nexport const warnDropped = (warning: Omit<CapabilityWarning, \"_tag\">): Effect.Effect<void> =>\n  Effect.logWarning(\"Capability dropped\", { ...warning, _tag: \"CapabilityWarning\" })\n\n/**\n * Shorthand for the most common shape: warn-and-drop when a specific\n * field on the Common request is set. The field's value is included\n * automatically.\n *\n * @example\n * ```ts\n * yield* Effect.all([\n *   warnDroppedWhen(request.lyrics, {\n *     provider: \"lyria\",\n *     capability: \"lyrics\",\n *     field: \"lyrics\",\n *     reason: \"Lyria 3 sync has no `lyrics` wire field. Embed in your prompt instead.\",\n *   }),\n *   warnDroppedWhen(request.duration, {\n *     provider: \"lyria\",\n *     capability: \"duration\",\n *     field: \"duration\",\n *     reason: \"Lyria 3 clip is fixed at 30 s.\",\n *   }),\n * ], { discard: true })\n * ```\n */\nexport const warnDroppedWhen = <T>(\n  value: T | undefined,\n  warning: Omit<CapabilityWarning, \"_tag\" | \"value\">,\n): Effect.Effect<void> => (value === undefined ? Effect.void : warnDropped({ ...warning, value }))\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmDA,MAAa,eAAe,YAC1B,OAAO,WAAW,sBAAsB;CAAE,GAAG;CAAS,MAAM;AAAoB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;AAyBnF,MAAa,mBACX,OACA,YACyB,UAAU,KAAA,IAAY,OAAO,OAAO,YAAY;CAAE,GAAG;CAAS;AAAM,CAAC"}
+{"version":3,"file":"Capabilities.mjs","names":[],"sources":["../../src/capabilities/Capabilities.ts"],"sourcesContent":["import { Effect } from \"effect\"\nimport type { ContentBlock, HistoryItem } from \"../domain/Items.js\"\n\n/**\n * Structured event emitted when a provider adapter drops a Common\n * request field because its wire API has no place to put it (bucket 2\n * per the capabilities policy: the provider has no structured\n * interpretation; the output is still valid, just less aligned with\n * the caller's hint).\n *\n * Carried on `Effect.logWarning` today for visibility; may be\n * promoted to a typed `AiError` variant in the future if callers need\n * to react programmatically. The shape itself is stable.\n *\n * @category capabilities\n */\nexport type CapabilityWarning = {\n  readonly _tag: \"CapabilityWarning\"\n  readonly provider: string\n  /** The capability name as it appears in docs (`\"lyrics\"`, `\"bpm\"`). */\n  readonly capability: string\n  /** The Common-request field name that was dropped. */\n  readonly field: string\n  /** The value the caller passed; included when useful for debugging. */\n  readonly value?: unknown\n  /** Human-readable explanation; should suggest a workaround. */\n  readonly reason: string\n}\n\n/**\n * Emit a structured `CapabilityWarning` via `Effect.logWarning`. Use\n * when a provider adapter receives a Common-request field it has no\n * structured wire field for, and would otherwise drop silently.\n *\n * Bucket-2 cases only (per the capabilities policy): the provider has\n * no interpretation; the output is still valid, just less aligned\n * with the caller's hint. For bucket-1 cases (structurally broken\n * output if dropped, like wrong audio format), fail\n * `AiError.Unsupported` instead.\n *\n * @example\n * ```ts\n * if (request.lyrics !== undefined) {\n *   yield* warnDropped({\n *     provider: \"lyria\",\n *     capability: \"lyrics\",\n *     field: \"lyrics\",\n *     reason: \"Lyria 3 sync has no `lyrics` wire field. Embed in your prompt instead.\",\n *   })\n * }\n * ```\n */\nexport const warnDropped = (warning: Omit<CapabilityWarning, \"_tag\">): Effect.Effect<void> =>\n  Effect.logWarning(\"Capability dropped\", { ...warning, _tag: \"CapabilityWarning\" })\n\n/**\n * Shorthand for the most common shape: warn-and-drop when a specific\n * field on the Common request is set. The field's value is included\n * automatically.\n *\n * @example\n * ```ts\n * yield* Effect.all([\n *   warnDroppedWhen(request.lyrics, {\n *     provider: \"lyria\",\n *     capability: \"lyrics\",\n *     field: \"lyrics\",\n *     reason: \"Lyria 3 sync has no `lyrics` wire field. Embed in your prompt instead.\",\n *   }),\n *   warnDroppedWhen(request.duration, {\n *     provider: \"lyria\",\n *     capability: \"duration\",\n *     field: \"duration\",\n *     reason: \"Lyria 3 clip is fixed at 30 s.\",\n *   }),\n * ], { discard: true })\n * ```\n */\nexport const warnDroppedWhen = <T>(\n  value: T | undefined,\n  warning: Omit<CapabilityWarning, \"_tag\" | \"value\">,\n): Effect.Effect<void> => (value === undefined ? Effect.void : warnDropped({ ...warning, value }))\n\n/**\n * Warn when history carries a content block this provider's wire has no\n * place for, which its encoder therefore omits.\n *\n * History is provider-agnostic, so a turn one provider produced can be\n * replayed into another. A block only one provider can express\n * (`output_image`, which needs an assistant-role image part) then reaches\n * an encoder with nothing to map it to. Omitting is right, since failing\n * would break replaying a mixed history just to continue the text, but it\n * should not be silent.\n *\n * Call once from the effectful request path; the block encoders stay pure.\n *\n * @example\n * ```ts\n * yield* warnDroppedBlocks(history, \"output_image\", {\n *   provider: \"anthropic\",\n *   capability: \"output_image\",\n *   reason: \"Assistant messages carry no image here. Convert with `imagesAsInput` to send it as user content.\",\n * })\n * ```\n */\nexport const warnDroppedBlocks = (\n  history: ReadonlyArray<HistoryItem>,\n  type: ContentBlock[\"type\"],\n  warning: Omit<CapabilityWarning, \"_tag\" | \"field\" | \"value\">,\n): Effect.Effect<void> => {\n  const count = history.reduce(\n    (n, item) =>\n      n + (item.type === \"message\" ? item.content.filter((b) => b.type === type).length : 0),\n    0,\n  )\n  return count === 0\n    ? Effect.void\n    : warnDropped({ ...warning, field: type, value: `${count} block(s)` })\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoDA,MAAa,eAAe,YAC1B,OAAO,WAAW,sBAAsB;CAAE,GAAG;CAAS,MAAM;AAAoB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;AAyBnF,MAAa,mBACX,OACA,YACyB,UAAU,KAAA,IAAY,OAAO,OAAO,YAAY;CAAE,GAAG;CAAS;AAAM,CAAC;;;;;;;;;;;;;;;;;;;;;;;AAwBhG,MAAa,qBACX,SACA,MACA,YACwB;CACxB,MAAM,QAAQ,QAAQ,QACnB,GAAG,SACF,KAAK,KAAK,SAAS,YAAY,KAAK,QAAQ,QAAQ,MAAM,EAAE,SAAS,IAAI,CAAC,CAAC,SAAS,IACtF,CACF;CACA,OAAO,UAAU,IACb,OAAO,OACP,YAAY;EAAE,GAAG;EAAS,OAAO;EAAM,OAAO,GAAG,MAAM;CAAW,CAAC;AACzE"}

package/dist/domain/Audio.d.mts

@@ -1,2 +1,2 @@
-import { a as AudioSource, c as isAudioBytes, i as AudioMimeType, l as isAudioUrl, n as AudioChunk, r as AudioFormat, s as isAudioBase64, t as AudioBlob } from "../Audio-60lKKHxS.mjs";
+import { a as AudioSource, c as isAudioBytes, i as AudioMimeType, l as isAudioUrl, n as AudioChunk, r as AudioFormat, s as isAudioBase64, t as AudioBlob } from "../Audio-_nGR4V0X.mjs";
 export { AudioBlob, AudioChunk, AudioFormat, AudioMimeType, AudioSource, isAudioBase64, isAudioBytes, isAudioUrl };

package/dist/domain/Image.d.mts

@@ -1,2 +1,3 @@
-import { a as ImageUrlSource, c as imageBytes, d as isImageBytes, f as isImageUrl, i as ImageSource, l as imageUrl, n as ImageBytesSource, r as ImageMimeType, s as imageBase64, t as ImageBase64Source, u as isImageBase64 } from "../Image-BK8-4H6s.mjs";
-export { ImageBase64Source, ImageBytesSource, ImageMimeType, ImageSource, ImageUrlSource, imageBase64, imageBytes, imageUrl, isImageBase64, isImageBytes, isImageUrl };
+import { n as Dimensions, t as AspectRatio } from "../Media-BbX7BAaO.mjs";
+import { a as ImageResolution, d as imageBytes, f as imageUrl, g as pixelsOf, h as isImageUrl, i as ImageMimeType, l as ProviderData, m as isImageBytes, n as ImageBase64Source, o as ImageSource, p as isImageBase64, r as ImageBytesSource, s as ImageUrlSource, t as GeneratedImage, u as imageBase64 } from "../Image-Cv6iBLTy.mjs";
+export { type AspectRatio, type Dimensions, GeneratedImage, ImageBase64Source, ImageBytesSource, ImageMimeType, ImageResolution, ImageSource, ImageUrlSource, ProviderData, imageBase64, imageBytes, imageUrl, isImageBase64, isImageBytes, isImageUrl, pixelsOf };