@effect-uai/core 0.13.0 → 0.14.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@effect-uai/core",
-  "version": "0.13.0",
+  "version": "0.14.0",
   "description": "Low-level primitives (loop, conversation, items, tools, streaming codecs) for building AI agents with Effect.",
   "keywords": [
     "agents",
@@ -106,6 +106,10 @@
       "types": "./dist/embedding-model/EmbeddingModel.d.mts",
       "import": "./dist/embedding-model/EmbeddingModel.mjs"
     },
+    "./ImageGenerator": {
+      "types": "./dist/image-generator/ImageGenerator.d.mts",
+      "import": "./dist/image-generator/ImageGenerator.mjs"
+    },
     "./LanguageModel": {
       "types": "./dist/language-model/LanguageModel.d.mts",
       "import": "./dist/language-model/LanguageModel.mjs"
@@ -214,6 +218,10 @@
       "types": "./dist/streaming/Lines.d.mts",
       "import": "./dist/streaming/Lines.mjs"
     },
+    "./Multipart": {
+      "types": "./dist/streaming/Multipart.d.mts",
+      "import": "./dist/streaming/Multipart.mjs"
+    },
     "./SSE": {
       "types": "./dist/streaming/SSE.d.mts",
       "import": "./dist/streaming/SSE.mjs"

package/src/capabilities/Capabilities.ts

@@ -1,4 +1,5 @@
 import { Effect } from "effect"
+import type { ContentBlock, HistoryItem } from "../domain/Items.js"
 
 /**
  * Structured event emitted when a provider adapter drops a Common
@@ -79,3 +80,40 @@ export const warnDroppedWhen = <T>(
   value: T | undefined,
   warning: Omit<CapabilityWarning, "_tag" | "value">,
 ): Effect.Effect<void> => (value === undefined ? Effect.void : warnDropped({ ...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.",
+ * })
+ * ```
+ */
+export const warnDroppedBlocks = (
+  history: ReadonlyArray<HistoryItem>,
+  type: ContentBlock["type"],
+  warning: Omit<CapabilityWarning, "_tag" | "field" | "value">,
+): Effect.Effect<void> => {
+  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)` })
+}

package/src/domain/Image.ts

@@ -1,5 +1,14 @@
-import { Schema } from "effect"
-import type { MediaBase64, MediaBytes, MediaSource, MediaUrl } from "./Media.js"
+import { Result, Schema } from "effect"
+import type {
+  AspectRatio,
+  Dimensions,
+  MediaBase64,
+  MediaBytes,
+  MediaSource,
+  MediaUrl,
+  Watermark,
+} from "./Media.js"
+import { parseAspectRatio, round16 } from "./Media.js"
 
 /**
  * Image MIME types AI providers typically accept. The first four are the
@@ -70,6 +79,63 @@ export const imageBytes = (bytes: Uint8Array, mimeType: ImageMimeType): ImageByt
   mimeType,
 })
 
+/** Cross-modality; lives in `Media.ts` because video generation shares it. */
+export type { AspectRatio, Dimensions } from "./Media.js"
+
+/**
+ * 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.
+ */
+export type ImageResolution = "1K" | "2K" | "4K"
+
+const SHORT_EDGE: Record<ImageResolution, number> = { "1K": 1024, "2K": 2048, "4K": 4096 }
+
+/**
+ * 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.
+ */
+export const pixelsOf = (request: {
+  readonly aspectRatio?: AspectRatio
+  readonly resolution?: ImageResolution
+}): Result.Result<Dimensions | undefined, string> =>
+  request.aspectRatio === undefined && request.resolution === undefined
+    ? Result.succeed(undefined)
+    : Result.map(parseAspectRatio(request.aspectRatio ?? "1:1"), ([w, h]) => {
+        const short = SHORT_EDGE[request.resolution ?? "1K"]
+        return w >= h
+          ? { width: round16((short * w) / h), height: short }
+          : { width: short, height: round16((short * h) / w) }
+      })
+
+/**
+ * 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.
+ */
+export type ProviderData = unknown
+
+/** One image off a generation call, plus what the provider stamped into it. */
+export 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
+}
+
 export const isImageUrl = Schema.is(ImageUrlSource)
 export const isImageBase64 = Schema.is(ImageBase64Source)
 export const isImageBytes = Schema.is(ImageBytesSource)

package/src/domain/Items.ts

@@ -88,6 +88,22 @@ export const OutputText = Schema.Struct({
 })
 export 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.
+ */
+export const OutputImage = Schema.Struct({
+  type: Schema.Literal("output_image"),
+  source: ImageSource,
+})
+export type OutputImage = typeof OutputImage.Type
+
 /**
  * Model-emitted refusal. Distinct from `output_text`: the model declined
  * to answer rather than producing normal output. Pair with
@@ -100,7 +116,7 @@ export const Refusal = Schema.Struct({
 })
 export type Refusal = typeof Refusal.Type
 
-export const ContentBlock = Schema.Union([InputText, InputImage, OutputText, Refusal])
+export const ContentBlock = Schema.Union([InputText, InputImage, OutputText, OutputImage, Refusal])
 export type ContentBlock = typeof ContentBlock.Type
 
 export const Role = Schema.Literals(["user", "assistant", "system"])
@@ -176,6 +192,7 @@ export type HistoryItem = typeof HistoryItem.Type
 export const isInputText = Schema.is(InputText)
 export const isInputImage = Schema.is(InputImage)
 export const isOutputText = Schema.is(OutputText)
+export const isOutputImage = Schema.is(OutputImage)
 export const isRefusal = Schema.is(Refusal)
 
 export const isMessage = Schema.is(Message)

package/src/domain/Media.ts

@@ -31,6 +31,72 @@
  * they're a separate union (`FileRef`) added when needed.
  */
 
+import { Result } from "effect"
+
+/**
+ * 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.
+ */
+export 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.
+ */
+export 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. */
+export type Dimensions = {
+  readonly width: number
+  readonly height: number
+}
+
+const positive = (n: number | undefined): n is number =>
+  n !== undefined && Number.isFinite(n) && n > 0
+
+/**
+ * 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.
+ */
+export const parseAspectRatio = (
+  ratio: AspectRatio,
+): Result.Result<readonly [number, number], string> => {
+  const [w, h, ...rest] = ratio.split(":").map(Number)
+  return positive(w) && positive(h) && rest.length === 0
+    ? Result.succeed([w, h] as const)
+    : Result.fail(`aspectRatio "${ratio}" must read "W:H" with positive numbers.`)
+}
+
+/** Several image endpoints require both edges to be multiples of 16. */
+export const round16 = (n: number): number => Math.max(16, Math.round(n / 16) * 16)
+
 export type MediaUrl<M extends string = string> = {
   readonly _tag: "url"
   readonly url: string

package/src/domain/Music.ts

@@ -1,5 +1,6 @@
 import type { Duration } from "effect"
 import type { AudioBlob, AudioChunk, AudioFormat } from "./Audio.js"
+import type { Watermark } from "./Media.js"
 
 /**
  * Prompt fragment with a relative weight. Native to Lyria RealTime
@@ -95,10 +96,10 @@ export const controlInput = (action: MusicSessionControl): MusicSessionInput =>
 
 /**
  * Watermark kind on the response. SynthID is mandatory on Lyria; C2PA
- * is opt-in on ElevenLabs. No provider exposes additional metadata
- * about the watermark itself, so a bare literal-union is enough.
+ * is opt-in on ElevenLabs. Lives in `Media.ts` since image providers
+ * report the same kinds; re-exported here unchanged.
  */
-export type Watermark = "synthid" | "c2pa" | (string & {})
+export type { Watermark } from "./Media.js"
 
 /**
  * Labelled section with absolute timing. Populated when the provider

package/src/domain/Turn.ts

@@ -1,5 +1,6 @@
 import { Data, Effect, Result, Schema, Stream, pipe } from "effect"
 import * as StructuredFormat from "../structured-format/StructuredFormat.js"
+import type { ImageSource } from "./Image.js"
 import {
   type Annotation,
   HistoryItem,
@@ -9,6 +10,7 @@ import {
   ToolCall,
   ToolCallOutput,
   Usage,
+  isOutputImage,
   isOutputText,
   isReasoning,
   isRefusal,
@@ -49,6 +51,12 @@ export type Turn = typeof Turn.Type
  * `WebSearchCall`: lifecycle of a provider-executed web search within the
  * turn. Fires only when the turn grounds against search; absent otherwise.
  *
+ * `ImageOutput`: an image the model produced, whether it drew it as part
+ * of its turn or reached a hosted tool for it. `partialIndex` marks a
+ * preview frame from providers that stream them; the finished image
+ * arrives without one and is also on `TurnComplete.turn` as an
+ * `OutputImage` block.
+ *
  * `CitationAdded`: a citation attached to the answer, emitted incrementally
  * where the provider streams citations. Providers that bundle citations emit
  * none of these; their citations still arrive on `TurnComplete.turn`
@@ -66,6 +74,11 @@ export type TurnEvent = Data.TaggedEnum<{
     readonly query?: string
     readonly action?: "search" | "open_page" | "find_in_page"
   }
+  ImageOutput: {
+    readonly image: ImageSource
+    /** Set only on a preview frame, counting from 0. Absent means finished. */
+    readonly partialIndex?: number
+  }
   CitationAdded: { readonly annotation: Annotation }
   TurnComplete: { readonly turn: Turn }
 }>
@@ -109,6 +122,49 @@ export const assistantTexts = (turn: Turn): ReadonlyArray<string> =>
  */
 export const assistantText = (turn: Turn): string => assistantTexts(turn).join("")
 
+/**
+ * Every image the model produced this turn, in order. The counterpart to
+ * {@link assistantTexts}: each is an `ImageSource`, so it can be written
+ * to disk or passed straight back as an `input_image` on the next turn.
+ */
+export const assistantImages = (turn: Turn): ReadonlyArray<ImageSource> =>
+  assistantMessages(turn)
+    .flatMap((m) => m.content)
+    .filter(isOutputImage)
+    .map((b) => b.source)
+
+/**
+ * Rewrite assistant `output_image` blocks into a user message carrying
+ * the same pictures as `input_image`, so another provider can look at
+ * what this one drew.
+ *
+ * Only Gemini's wire has an assistant-role image part; every other
+ * adapter omits an `output_image` on replay and says so. Moving it to a
+ * user message is the conversion that makes it portable, and it is
+ * yours to make rather than the adapter's: "the assistant drew this" and
+ * "here is an image, look at it" are different claims, and silently
+ * swapping one for the other behind your back would be the wrong kind of
+ * helpful.
+ *
+ * Items with no images pass through untouched, and the new user message
+ * follows the assistant message it came from.
+ */
+export const imagesAsInput = (history: ReadonlyArray<HistoryItem>): ReadonlyArray<HistoryItem> =>
+  history.flatMap((item) => {
+    if (item.type !== "message" || item.role !== "assistant") return [item]
+    const images = item.content.filter(isOutputImage)
+    return images.length === 0
+      ? [item]
+      : [
+          item,
+          {
+            type: "message" as const,
+            role: "user" as const,
+            content: images.map((b) => ({ type: "input_image" as const, source: b.source })),
+          },
+        ]
+  })
+
 /**
  * Every citation annotation attached to the turn's assistant `output_text`
  * blocks, in order. The flat view of a grounded turn's sources, whether the

package/src/image-generator/ImageGenerator.ts

@@ -0,0 +1,165 @@
+import { Context, Data, Effect, Stream } from "effect"
+import type * as AiError from "../domain/AiError.js"
+import type {
+  AspectRatio,
+  GeneratedImage,
+  ImageResolution,
+  ImageSource,
+  ProviderData,
+} from "../domain/Image.js"
+
+export type { AspectRatio, GeneratedImage, ImageResolution, ProviderData } from "../domain/Image.js"
+
+/**
+ * Cross-provider text-to-image request. Shape and resolution are given
+ * as a ratio plus a tier rather than exact pixels: every provider takes
+ * one or derives the other. Exact dimensions, quality tiers, output
+ * encodings, and moderation knobs are vendor-specific and live on each
+ * provider's typed request.
+ */
+export type CommonImageGenerateRequest = {
+  readonly prompt: string
+  /** Each provider narrows this to its typed literal union. */
+  readonly model: string
+  readonly aspectRatio?: AspectRatio
+  readonly resolution?: ImageResolution
+  /** Default 1. Implementors without multi-image output fail `Unsupported` for more. */
+  readonly n?: number
+}
+
+/**
+ * Edit request: the same prompt-driven generation, conditioned on
+ * reference images. Separate from `generate` because the reference set
+ * is required here and absent there, and providers expose the two as
+ * distinct wire shapes. Per-provider caps on the array length apply.
+ */
+export type CommonImageEditRequest = CommonImageGenerateRequest & {
+  readonly images: ReadonlyArray<ImageSource>
+}
+
+/** Gated by {@link ImageStreaming}; `partialImages` is the preview-frame count. */
+export type CommonStreamImageRequest = CommonImageGenerateRequest & {
+  readonly partialImages: 1 | 2 | 3
+}
+
+/** The same previews, for an edit. Gated by {@link ImageStreaming}. */
+export type CommonStreamImageEditRequest = CommonImageEditRequest & {
+  readonly partialImages: 1 | 2 | 3
+}
+
+/** Optional throughout: not every provider bills or reports per token. */
+export type ImageUsage = {
+  readonly inputTokens?: number
+  readonly outputTokens?: number
+  readonly totalTokens?: number
+}
+
+export type ImageResponse = {
+  readonly images: ReadonlyArray<GeneratedImage>
+  readonly usage: ImageUsage
+  /**
+   * Response-level extras, keyed by provider name: the seed a request
+   * resolved to, timings, safety flags. Per-image extras live on each
+   * {@link GeneratedImage} instead. See `Image.ProviderData`.
+   */
+  readonly providerData?: ProviderData
+}
+
+/**
+ * Zero or more `PartialImage` previews, then exactly one `Complete`.
+ * `Complete` carries the `ImageResponse` fields flat, so it is
+ * assignable to `ImageResponse` and needs no unwrapping.
+ */
+export type ImageStreamEvent = Data.TaggedEnum<{
+  PartialImage: {
+    readonly image: ImageSource
+    /** Counts from 0 in emission order. */
+    readonly index: number
+  }
+  Complete: {
+    readonly images: ReadonlyArray<GeneratedImage>
+    readonly usage: ImageUsage
+  }
+}>
+
+/**
+ * Namespace of constructors, type guards, and matchers for
+ * `ImageStreamEvent`, provided by `Data.taggedEnum`.
+ */
+export const ImageStreamEvent = Data.taggedEnum<ImageStreamEvent>()
+
+export const isPartialImage = ImageStreamEvent.$is("PartialImage")
+export const isComplete = ImageStreamEvent.$is("Complete")
+
+export type ImageGeneratorService = {
+  /** Prompt in, images out. Universally supported. */
+  readonly generate: (
+    request: CommonImageGenerateRequest,
+  ) => Effect.Effect<ImageResponse, AiError.AiError>
+  /** Prompt plus reference images in, images out. Universally supported. */
+  readonly edit: (request: CommonImageEditRequest) => Effect.Effect<ImageResponse, AiError.AiError>
+  /**
+   * Preview frames as the image resolves, then the final response.
+   * Implementors without a partial-image wire return `Unsupported` and
+   * do NOT register {@link ImageStreaming}, so the top-level helper is
+   * a compile-time error against their Layer.
+   */
+  readonly streamGeneration: (
+    request: CommonStreamImageRequest,
+  ) => Stream.Stream<ImageStreamEvent, AiError.AiError>
+  /** {@link streamGeneration} conditioned on reference images. */
+  readonly streamEdit: (
+    request: CommonStreamImageEditRequest,
+  ) => Stream.Stream<ImageStreamEvent, AiError.AiError>
+}
+
+export class ImageGenerator extends Context.Service<ImageGenerator, ImageGeneratorService>()(
+  "@betalyra/effect-uai/ImageGenerator",
+) {}
+
+/**
+ * Capability marker for partial-image streaming. Phantom: the value is
+ * `void`, providers register with
+ * `Layer.succeed(ImageStreaming, undefined)`. Calling
+ * {@link streamGeneration} while only a non-streaming Layer is in scope
+ * fails at `Effect.provide` with a type error.
+ */
+export class ImageStreaming extends Context.Service<ImageStreaming, void>()(
+  "@betalyra/effect-uai/capability/ImageStreaming",
+) {}
+
+/** Text to image. */
+export const generate = (
+  request: CommonImageGenerateRequest,
+): Effect.Effect<ImageResponse, AiError.AiError, ImageGenerator> =>
+  Effect.flatMap(ImageGenerator, (g) => g.generate(request))
+
+/** Text plus reference images to image. */
+export const edit = (
+  request: CommonImageEditRequest,
+): Effect.Effect<ImageResponse, AiError.AiError, ImageGenerator> =>
+  Effect.flatMap(ImageGenerator, (g) => g.edit(request))
+
+/** Preview frames then the final response. Requires {@link ImageStreaming} in R. */
+export const streamGeneration = (
+  request: CommonStreamImageRequest,
+): Stream.Stream<ImageStreamEvent, AiError.AiError, ImageGenerator | ImageStreaming> =>
+  Stream.unwrap(
+    Effect.gen(function* () {
+      const g = yield* ImageGenerator
+      yield* ImageStreaming
+      return g.streamGeneration(request)
+    }),
+  )
+
+/** The same, conditioned on reference images. Requires {@link ImageStreaming} in R. */
+export const streamEdit = (
+  request: CommonStreamImageEditRequest,
+): Stream.Stream<ImageStreamEvent, AiError.AiError, ImageGenerator | ImageStreaming> =>
+  Stream.unwrap(
+    Effect.gen(function* () {
+      const g = yield* ImageGenerator
+      yield* ImageStreaming
+      return g.streamEdit(request)
+    }),
+  )

package/src/index.ts

@@ -17,6 +17,7 @@ export * as Transcript from "./domain/Transcript.js"
 export * as Turn from "./domain/Turn.js"
 export * as Embedding from "./embedding-model/Embedding.js"
 export * as EmbeddingModel from "./embedding-model/EmbeddingModel.js"
+export * as ImageGenerator from "./image-generator/ImageGenerator.js"
 export * as LanguageModel from "./language-model/LanguageModel.js"
 export * as MusicGenerator from "./music-generator/MusicGenerator.js"
 export * as Reranker from "./reranker/Reranker.js"
@@ -43,6 +44,7 @@ export * as Approval from "./tool/Approval.js"
 export * as HistoryCheck from "./tool/HistoryCheck.js"
 export * as JSONL from "./streaming/JSONL.js"
 export * as Lines from "./streaming/Lines.js"
+export * as Multipart from "./streaming/Multipart.js"
 export * as SSE from "./streaming/SSE.js"
 export * as StructuredFormat from "./structured-format/StructuredFormat.js"
 export * as Metrics from "./observability/Metrics.js"

package/src/streaming/Multipart.ts

@@ -0,0 +1,29 @@
+import { Effect } from "effect"
+import { HttpClientRequest } from "effect/unstable/http"
+
+/**
+ * Multipart body for an `HttpClientRequest`, encoded to bytes.
+ *
+ * Use this over `HttpClientRequest.bodyFormData`: the Undici client
+ * passes the `FormData` object straight to `dispatcher.request`, which
+ * cannot serialise it, so the request is never sent and the effect
+ * hangs with no error. Encoding here produces the same bytes every
+ * other client derives internally, so it works on all of them.
+ *
+ * The failure is whatever `Response.arrayBuffer` rejects with; map it
+ * to your provider's transport error at the call site.
+ */
+export const bodyMultipart = (
+  form: FormData,
+): Effect.Effect<
+  (request: HttpClientRequest.HttpClientRequest) => HttpClientRequest.HttpClientRequest,
+  unknown
+> =>
+  Effect.gen(function* () {
+    const encoded = new Response(form)
+    const buffer = yield* Effect.tryPromise(() => encoded.arrayBuffer())
+    return HttpClientRequest.bodyUint8Array(
+      new Uint8Array(buffer),
+      encoded.headers.get("content-type") ?? "multipart/form-data",
+    )
+  })

package/dist/Image-BK8-4H6s.d.mts

@@ -1,59 +0,0 @@
-import { i as MediaUrl, n as MediaBytes, r as MediaSource, t as MediaBase64 } from "./Media-DwgpifPD.mjs";
-import { Schema } from "effect";
-declare namespace Image_d_exports {
-  export { ImageBase64Source, ImageBytesSource, ImageMimeType, ImageSource, ImageUrlSource, imageBase64, imageBytes, imageUrl, isImageBase64, isImageBytes, isImageUrl };
-}
-/**
- * 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;
-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 { ImageUrlSource as a, imageBytes as c, isImageBytes as d, isImageUrl as f, ImageSource as i, imageUrl as l, ImageBytesSource as n, Image_d_exports as o, ImageMimeType as r, imageBase64 as s, ImageBase64Source as t, isImageBase64 as u };
-//# sourceMappingURL=Image-BK8-4H6s.d.mts.map

package/dist/Image-BK8-4H6s.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Image-BK8-4H6s.d.mts","names":[],"sources":["../src/domain/Image.ts"],"mappings":";;;;;;;;;;;;;KAWY;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;cAM3D,aAAU,GAAA,OAAA,MAAA,SAAA;;;;;cACV,gBAAa,GAAA,OAAA,MAAA,SAAA;;;;;cACb,eAAY,GAAA,OAAA,MAAA,SAAA"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"Items-SfUabNuB.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;;;;;;;cAQ9B,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,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"}