@tanstack/ai-byteplus 0.0.0

package/dist/esm/image/image-provider-options.js

@@ -0,0 +1,134 @@
+import { BYTEPLUS_IMAGE_MAX_REFERENCE_IMAGES } from "../model-meta.js";
+//#region src/image/image-provider-options.ts
+/**
+* Provider options and request validation for Seedream image generation.
+*
+* Field names, enums, defaults and ranges come from the harvested Ark
+* OpenAPI document for the `ImageGenerations` action; the Seedream 4.0
+* behaviour noted below was confirmed live on 2026-07-31.
+*/
+/**
+* BytePlus documents a 600-word ceiling on the image prompt. Word-based, so
+* it is only meaningful for space-separated scripts — the check below never
+* fires for Chinese or Japanese text, which is the intended behaviour.
+*/
+var BYTEPLUS_IMAGE_MAX_PROMPT_WORDS = 600;
+/**
+* Upper bound of `sequential_image_generation_options.max_images`, i.e. the
+* most images one request can return.
+*/
+var BYTEPLUS_IMAGE_MAX_SEQUENTIAL_IMAGES = 15;
+/**
+* Models that accept `output_format`.
+*
+* The Ark OpenAPI document's field note claims 5.0-lite only, but its own
+* request demo sends `output_format` on `seedream-5-0-260128`, so the whole
+* 5.0 family is treated as supporting it. The Seedream 4.x snapshots are
+* documented as not reading it, so `output_format` is omitted from their
+* provider-options type — but, as with `sequential_image_generation`, it is
+* not gated at runtime: a value that reaches a model which does not read it
+* comes back as an Ark error rather than a local rejection.
+*/
+var BYTEPLUS_OUTPUT_FORMAT_IMAGE_MODELS = [
+	"dola-seedream-5-0-pro-260628",
+	"seedream-5-0-260128",
+	"seedream-5-0-lite-260128"
+];
+var SIZE_TOKENS = [
+	"1K",
+	"2K",
+	"4K"
+];
+/**
+* Parses a Seedream `size` string. Accepts a shorthand token (case-insensitive
+* — `2k` normalizes to `2K`) or explicit `WIDTHxHEIGHT` pixels, and returns
+* `undefined` for anything else, including mixtures such as `2K x 1024`.
+*/
+function parseBytePlusImageSize(size) {
+	const trimmed = size.trim();
+	const token = SIZE_TOKENS.find((candidate) => candidate.toLowerCase() === trimmed.toLowerCase());
+	if (token) return {
+		kind: "token",
+		value: token
+	};
+	const pixels = /^(\d+)[xX](\d+)$/.exec(trimmed);
+	if (pixels) {
+		const width = Number(pixels[1]);
+		const height = Number(pixels[2]);
+		if (width > 0 && height > 0) return {
+			kind: "pixels",
+			width,
+			height
+		};
+	}
+}
+/**
+* Validates the generic `size` option and returns the string to put on the
+* wire (`2K`, `2048x2048`), or `undefined` when no size was requested.
+*
+* This checks the *form* only. Which pixel dimensions a given model actually
+* accepts is not encoded here, so the message deliberately makes no per-model
+* claim; an out-of-range size is left to the API to reject.
+*
+* @throws Error when the value is neither a size token nor `WIDTHxHEIGHT`.
+*/
+function resolveBytePlusImageSize(size) {
+	if (size === void 0) return void 0;
+	const parsed = parseBytePlusImageSize(size);
+	if (!parsed) throw new Error(`byteplus: size "${size}" is not a Seedream size. Use a size token (${SIZE_TOKENS.join(", ")}) or explicit pixels with an ASCII "x" ("2048x2048") — never a mix of the two.`);
+	return parsed.kind === "token" ? parsed.value : `${parsed.width}x${parsed.height}`;
+}
+/**
+* Validates the prompt text against BytePlus's documented limits.
+*
+* @throws Error when the prompt is empty or exceeds
+* {@link BYTEPLUS_IMAGE_MAX_PROMPT_WORDS} words.
+*/
+function validateBytePlusImagePrompt(model, prompt) {
+	if (prompt.trim().length === 0) throw new Error(`byteplus: model "${model}" requires prompt text. Seedream takes an instruction even when editing reference images.`);
+	const words = prompt.trim().split(/\s+/).length;
+	if (words > 600) throw new Error(`byteplus: prompt is ${words} words; model "${model}" accepts at most 600.`);
+}
+/**
+* Validates the reference-image count against the model's editing limit.
+*
+* A model this package has no limit for is left to Ark, deliberately and
+* explicitly. `model` is typed closed, but `wire-types.ts` documents that the
+* endpoint also accepts preconfigured endpoint ids (`ep-…`), so a JS caller
+* can reach an id that is not in the table. Reading `undefined` out of it and
+* comparing `count > undefined` — always false — would disable the guard by
+* accident and look identical to passing; the explicit early return says the
+* skip is intended.
+*
+* @throws Error when more references are supplied than a *known* model accepts.
+*/
+function validateBytePlusReferenceImages(model, count) {
+	const max = BYTEPLUS_IMAGE_MAX_REFERENCE_IMAGES[model];
+	if (max === void 0) return;
+	if (count > max) throw new Error(`byteplus: model "${model}" accepts at most ${max} reference images; received ${count}.`);
+}
+/**
+* Maps the generic `numberOfImages` option onto Seedream's group-image
+* parameters.
+*
+* The endpoint has no `n`: more than one image per request is only reachable
+* through `sequential_image_generation: 'auto'`, where `max_images` is an
+* upper bound and the model decides how many images the prompt actually
+* warrants. A request for N images can therefore come back with fewer — the
+* one place BytePlus cannot honour `numberOfImages` exactly.
+*
+* @throws Error when the count is not an integer in `[1, 15]`.
+*/
+function resolveBytePlusSequentialImages(model, numberOfImages) {
+	if (numberOfImages === void 0) return {};
+	if (!Number.isInteger(numberOfImages) || numberOfImages < 1 || numberOfImages > 15) throw new Error(`byteplus: numberOfImages must be a whole number between 1 and 15 on model "${model}"; received ${numberOfImages}.`);
+	if (numberOfImages === 1) return {};
+	return {
+		sequential_image_generation: "auto",
+		sequential_image_generation_options: { max_images: numberOfImages }
+	};
+}
+//#endregion
+export { BYTEPLUS_IMAGE_MAX_PROMPT_WORDS, BYTEPLUS_IMAGE_MAX_SEQUENTIAL_IMAGES, BYTEPLUS_OUTPUT_FORMAT_IMAGE_MODELS, parseBytePlusImageSize, resolveBytePlusImageSize, resolveBytePlusSequentialImages, validateBytePlusImagePrompt, validateBytePlusReferenceImages };
+
+//# sourceMappingURL=image-provider-options.js.map

package/dist/esm/image/image-provider-options.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"image-provider-options.js","names":[],"sources":["../../../src/image/image-provider-options.ts"],"sourcesContent":["/**\n * Provider options and request validation for Seedream image generation.\n *\n * Field names, enums, defaults and ranges come from the harvested Ark\n * OpenAPI document for the `ImageGenerations` action; the Seedream 4.0\n * behaviour noted below was confirmed live on 2026-07-31.\n */\nimport { BYTEPLUS_IMAGE_MAX_REFERENCE_IMAGES } from '../model-meta'\nimport type {\n  BytePlusImageOutputFormat,\n  BytePlusImageResponseFormat,\n  BytePlusOptimizePromptOptions,\n  BytePlusSequentialImageGeneration,\n  BytePlusSequentialImageGenerationOptions,\n} from './wire-types'\nimport type { BytePlusImageModel, BytePlusImageSize } from '../model-meta'\n\n/**\n * BytePlus documents a 600-word ceiling on the image prompt. Word-based, so\n * it is only meaningful for space-separated scripts — the check below never\n * fires for Chinese or Japanese text, which is the intended behaviour.\n */\nexport const BYTEPLUS_IMAGE_MAX_PROMPT_WORDS = 600\n\n/**\n * Upper bound of `sequential_image_generation_options.max_images`, i.e. the\n * most images one request can return.\n */\nexport const BYTEPLUS_IMAGE_MAX_SEQUENTIAL_IMAGES = 15\n\n/**\n * Models that accept `output_format`.\n *\n * The Ark OpenAPI document's field note claims 5.0-lite only, but its own\n * request demo sends `output_format` on `seedream-5-0-260128`, so the whole\n * 5.0 family is treated as supporting it. The Seedream 4.x snapshots are\n * documented as not reading it, so `output_format` is omitted from their\n * provider-options type — but, as with `sequential_image_generation`, it is\n * not gated at runtime: a value that reaches a model which does not read it\n * comes back as an Ark error rather than a local rejection.\n */\nexport const BYTEPLUS_OUTPUT_FORMAT_IMAGE_MODELS: ReadonlyArray<BytePlusImageModel> =\n  [\n    'dola-seedream-5-0-pro-260628',\n    'seedream-5-0-260128',\n    'seedream-5-0-lite-260128',\n  ]\n\n/**\n * Base provider options shared by every Seedream model.\n */\nexport interface BytePlusImageBaseProviderOptions {\n  /**\n   * Return images as expiring links (`url`, valid 24 hours) or inline base64\n   * (`b64_json`).\n   *\n   * @default 'url'\n   */\n  response_format?: BytePlusImageResponseFormat\n\n  /**\n   * Whether to stamp an \"AI generated\" watermark in the bottom-right corner.\n   *\n   * **BytePlus defaults this to `true`.** Pass `false` for a clean image.\n   */\n  watermark?: boolean\n\n  /**\n   * Group-image mode. Set to `auto` to let the model return a set of related\n   * images (bounded by {@link BytePlusImageBaseProviderOptions.sequential_image_generation_options}).\n   * `generateImage()`'s `numberOfImages` sets this for you; an explicit value\n   * here wins.\n   *\n   * Documented on Seedream 5.0-lite, 4.5 and 4.0. It is sent as given on\n   * every model rather than gated locally — the shipped 5.0 ids post-date the\n   * published parameter table, and an unsupported combination comes back as a\n   * clear Ark error.\n   *\n   * @default 'disabled'\n   */\n  sequential_image_generation?: BytePlusSequentialImageGeneration\n\n  /** Bounds for group-image mode. Only read when the mode is `auto`. */\n  sequential_image_generation_options?: BytePlusSequentialImageGenerationOptions\n\n  /**\n   * Prompt-rewriting configuration. Documented on Seedream 5.0-lite, 4.5 and\n   * 4.0; `mode: 'fast'` is unsupported on 5.0-lite and 4.5.\n   */\n  optimize_prompt_options?: BytePlusOptimizePromptOptions\n}\n\n/**\n * Provider options for the Seedream 5.0 family, which additionally chooses the\n * generated file format.\n */\nexport interface BytePlusSeedream5ImageProviderOptions extends BytePlusImageBaseProviderOptions {\n  /**\n   * File format of the generated image.\n   *\n   * @default 'jpeg'\n   */\n  output_format?: BytePlusImageOutputFormat\n}\n\n/**\n * Every Seedream provider option, used as the adapter's base option type.\n * Call sites are narrowed per model by\n * {@link BytePlusImageModelProviderOptionsByName}.\n */\nexport type BytePlusImageProviderOptions = BytePlusSeedream5ImageProviderOptions\n\n/**\n * Type-only map from image model name to its provider options.\n */\nexport type BytePlusImageModelProviderOptionsByName = {\n  'dola-seedream-5-0-pro-260628': BytePlusSeedream5ImageProviderOptions\n  'seedream-5-0-260128': BytePlusSeedream5ImageProviderOptions\n  'seedream-5-0-lite-260128': BytePlusSeedream5ImageProviderOptions\n  'seedream-4-5-251128': BytePlusImageBaseProviderOptions\n  'seedream-4-0-250828': BytePlusImageBaseProviderOptions\n}\n\n/**\n * Type-only map from image model name to the non-text prompt modalities it\n * accepts. Every shipped Seedream model takes reference images for\n * image-conditioned generation.\n */\nexport type BytePlusImageModelInputModalitiesByName = {\n  [K in BytePlusImageModel]: readonly ['image']\n}\n\n/**\n * A parsed `size` value: either the shorthand token form or explicit pixels.\n */\nexport type ParsedBytePlusImageSize =\n  | { kind: 'token'; value: '1K' | '2K' | '4K' }\n  | { kind: 'pixels'; width: number; height: number }\n\nconst SIZE_TOKENS = ['1K', '2K', '4K'] as const\n\n/**\n * Parses a Seedream `size` string. Accepts a shorthand token (case-insensitive\n * — `2k` normalizes to `2K`) or explicit `WIDTHxHEIGHT` pixels, and returns\n * `undefined` for anything else, including mixtures such as `2K x 1024`.\n */\nexport function parseBytePlusImageSize(\n  size: string,\n): ParsedBytePlusImageSize | undefined {\n  const trimmed = size.trim()\n\n  const token = SIZE_TOKENS.find(\n    (candidate) => candidate.toLowerCase() === trimmed.toLowerCase(),\n  )\n  if (token) return { kind: 'token', value: token }\n\n  // ASCII \"x\" only: the docs render the separator as U+00D7 (`2048×2048`),\n  // which the API does not accept, so it must not slip through here either.\n  const pixels = /^(\\d+)[xX](\\d+)$/.exec(trimmed)\n  if (pixels) {\n    const width = Number(pixels[1])\n    const height = Number(pixels[2])\n    if (width > 0 && height > 0) return { kind: 'pixels', width, height }\n  }\n\n  return undefined\n}\n\n/**\n * Validates the generic `size` option and returns the string to put on the\n * wire (`2K`, `2048x2048`), or `undefined` when no size was requested.\n *\n * This checks the *form* only. Which pixel dimensions a given model actually\n * accepts is not encoded here, so the message deliberately makes no per-model\n * claim; an out-of-range size is left to the API to reject.\n *\n * @throws Error when the value is neither a size token nor `WIDTHxHEIGHT`.\n */\nexport function resolveBytePlusImageSize(\n  size: BytePlusImageSize | string | undefined,\n): string | undefined {\n  if (size === undefined) return undefined\n\n  const parsed = parseBytePlusImageSize(size)\n  if (!parsed) {\n    throw new Error(\n      `byteplus: size \"${size}\" is not a Seedream size. Use a size token ` +\n        `(${SIZE_TOKENS.join(', ')}) or explicit pixels with an ASCII \"x\" ` +\n        `(\"2048x2048\") — never a mix of the two.`,\n    )\n  }\n\n  return parsed.kind === 'token'\n    ? parsed.value\n    : `${parsed.width}x${parsed.height}`\n}\n\n/**\n * Validates the prompt text against BytePlus's documented limits.\n *\n * @throws Error when the prompt is empty or exceeds\n * {@link BYTEPLUS_IMAGE_MAX_PROMPT_WORDS} words.\n */\nexport function validateBytePlusImagePrompt(\n  model: string,\n  prompt: string,\n): void {\n  if (prompt.trim().length === 0) {\n    throw new Error(\n      `byteplus: model \"${model}\" requires prompt text. Seedream takes an ` +\n        `instruction even when editing reference images.`,\n    )\n  }\n\n  const words = prompt.trim().split(/\\s+/).length\n  if (words > BYTEPLUS_IMAGE_MAX_PROMPT_WORDS) {\n    throw new Error(\n      `byteplus: prompt is ${words} words; model \"${model}\" accepts at most ` +\n        `${BYTEPLUS_IMAGE_MAX_PROMPT_WORDS}.`,\n    )\n  }\n}\n\n/**\n * Validates the reference-image count against the model's editing limit.\n *\n * A model this package has no limit for is left to Ark, deliberately and\n * explicitly. `model` is typed closed, but `wire-types.ts` documents that the\n * endpoint also accepts preconfigured endpoint ids (`ep-…`), so a JS caller\n * can reach an id that is not in the table. Reading `undefined` out of it and\n * comparing `count > undefined` — always false — would disable the guard by\n * accident and look identical to passing; the explicit early return says the\n * skip is intended.\n *\n * @throws Error when more references are supplied than a *known* model accepts.\n */\nexport function validateBytePlusReferenceImages(\n  model: BytePlusImageModel,\n  count: number,\n): void {\n  const max = BYTEPLUS_IMAGE_MAX_REFERENCE_IMAGES[model] as number | undefined\n  if (max === undefined) return\n  if (count > max) {\n    throw new Error(\n      `byteplus: model \"${model}\" accepts at most ${max} reference images; received ${count}.`,\n    )\n  }\n}\n\n/**\n * Maps the generic `numberOfImages` option onto Seedream's group-image\n * parameters.\n *\n * The endpoint has no `n`: more than one image per request is only reachable\n * through `sequential_image_generation: 'auto'`, where `max_images` is an\n * upper bound and the model decides how many images the prompt actually\n * warrants. A request for N images can therefore come back with fewer — the\n * one place BytePlus cannot honour `numberOfImages` exactly.\n *\n * @throws Error when the count is not an integer in `[1, 15]`.\n */\nexport function resolveBytePlusSequentialImages(\n  model: string,\n  numberOfImages: number | undefined,\n): {\n  sequential_image_generation?: BytePlusSequentialImageGeneration\n  sequential_image_generation_options?: BytePlusSequentialImageGenerationOptions\n} {\n  if (numberOfImages === undefined) return {}\n\n  if (\n    !Number.isInteger(numberOfImages) ||\n    numberOfImages < 1 ||\n    numberOfImages > BYTEPLUS_IMAGE_MAX_SEQUENTIAL_IMAGES\n  ) {\n    throw new Error(\n      `byteplus: numberOfImages must be a whole number between 1 and ` +\n        `${BYTEPLUS_IMAGE_MAX_SEQUENTIAL_IMAGES} on model \"${model}\"; received ${numberOfImages}.`,\n    )\n  }\n\n  if (numberOfImages === 1) return {}\n\n  return {\n    sequential_image_generation: 'auto',\n    sequential_image_generation_options: { max_images: numberOfImages },\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;AAsBA,IAAa,kCAAkC;;;;;AAM/C,IAAa,uCAAuC;;;;;;;;;;;;AAapD,IAAa,sCACX;CACE;CACA;CACA;AACF;AA6FF,IAAM,cAAc;CAAC;CAAM;CAAM;AAAI;;;;;;AAOrC,SAAgB,uBACd,MACqC;CACrC,MAAM,UAAU,KAAK,KAAK;CAE1B,MAAM,QAAQ,YAAY,MACvB,cAAc,UAAU,YAAY,MAAM,QAAQ,YAAY,CACjE;CACA,IAAI,OAAO,OAAO;EAAE,MAAM;EAAS,OAAO;CAAM;CAIhD,MAAM,SAAS,mBAAmB,KAAK,OAAO;CAC9C,IAAI,QAAQ;EACV,MAAM,QAAQ,OAAO,OAAO,EAAE;EAC9B,MAAM,SAAS,OAAO,OAAO,EAAE;EAC/B,IAAI,QAAQ,KAAK,SAAS,GAAG,OAAO;GAAE,MAAM;GAAU;GAAO;EAAO;CACtE;AAGF;;;;;;;;;;;AAYA,SAAgB,yBACd,MACoB;CACpB,IAAI,SAAS,KAAA,GAAW,OAAO,KAAA;CAE/B,MAAM,SAAS,uBAAuB,IAAI;CAC1C,IAAI,CAAC,QACH,MAAM,IAAI,MACR,mBAAmB,KAAK,8CAClB,YAAY,KAAK,IAAI,EAAE,+EAE/B;CAGF,OAAO,OAAO,SAAS,UACnB,OAAO,QACP,GAAG,OAAO,MAAM,GAAG,OAAO;AAChC;;;;;;;AAQA,SAAgB,4BACd,OACA,QACM;CACN,IAAI,OAAO,KAAK,CAAC,CAAC,WAAW,GAC3B,MAAM,IAAI,MACR,oBAAoB,MAAM,0FAE5B;CAGF,MAAM,QAAQ,OAAO,KAAK,CAAC,CAAC,MAAM,KAAK,CAAC,CAAC;CACzC,IAAI,QAAA,KACF,MAAM,IAAI,MACR,uBAAuB,MAAM,iBAAiB,MAAM,uBAEtD;AAEJ;;;;;;;;;;;;;;AAeA,SAAgB,gCACd,OACA,OACM;CACN,MAAM,MAAM,oCAAoC;CAChD,IAAI,QAAQ,KAAA,GAAW;CACvB,IAAI,QAAQ,KACV,MAAM,IAAI,MACR,oBAAoB,MAAM,oBAAoB,IAAI,8BAA8B,MAAM,EACxF;AAEJ;;;;;;;;;;;;;AAcA,SAAgB,gCACd,OACA,gBAIA;CACA,IAAI,mBAAmB,KAAA,GAAW,OAAO,CAAC;CAE1C,IACE,CAAC,OAAO,UAAU,cAAc,KAChC,iBAAiB,KACjB,iBAAA,IAEA,MAAM,IAAI,MACR,8EACuD,MAAM,cAAc,eAAe,EAC5F;CAGF,IAAI,mBAAmB,GAAG,OAAO,CAAC;CAElC,OAAO;EACL,6BAA6B;EAC7B,qCAAqC,EAAE,YAAY,eAAe;CACpE;AACF"}

package/dist/esm/image/wire-types.d.ts

@@ -0,0 +1,149 @@
+/**
+ * Wire types for the BytePlus Ark image endpoint (`POST /images/generations`).
+ *
+ * Hand-written minimal shapes covering only the fields this adapter sends and
+ * reads. Provenance for every field is noted inline. Two sources:
+ *
+ * 1. The harvested OpenAPI 3.1 document for the `ark` service, action
+ *    `ImageGenerations` (`x-updated-time: 2026-06-08`) — authoritative for
+ *    field names, enum values, defaults and ranges.
+ * 2. A live `seedream-4-0-250828` call against
+ *    `https://ark.ap-southeast.bytepluses.com/api/v3` on 2026-07-31, which
+ *    pinned the actual response shape.
+ *
+ * The endpoint deviates from OpenAI's `/images/generations` in three ways that
+ * matter: there is no `n` parameter, `size` accepts a shorthand token as well
+ * as `WxH`, and input images for editing ride along in a top-level `image`
+ * field rather than a separate `/images/edits` endpoint.
+ */
+/** How generated images come back. `url` links expire 24 hours after generation. */
+export type BytePlusImageResponseFormat = 'url' | 'b64_json';
+/** File format of the generated image. Seedream 5.0 family only. */
+export type BytePlusImageOutputFormat = 'png' | 'jpeg';
+/**
+ * Group-image ("sequential generation") switch.
+ *
+ * - `auto` — the model decides whether to return a set of related images and
+ *   how many, bounded by `sequential_image_generation_options.max_images`.
+ * - `disabled` — exactly one image.
+ */
+export type BytePlusSequentialImageGeneration = 'auto' | 'disabled';
+/** Group-image bounds. Only read when `sequential_image_generation` is `auto`. */
+export interface BytePlusSequentialImageGenerationOptions {
+    /** Upper bound on images returned for this request. Range `[1, 15]`. */
+    max_images?: number;
+}
+/** Prompt-rewriting configuration. Seedream 5.0-lite / 4.5 / 4.0 only. */
+export interface BytePlusOptimizePromptOptions {
+    /**
+     * `standard` produces higher-quality results but is slower; `fast` is
+     * quicker with average quality (unsupported on Seedream 5.0-lite and 4.5).
+     */
+    mode: 'standard' | 'fast';
+}
+/**
+ * Request body for `POST /images/generations`.
+ *
+ * `model` and `prompt` are the only required fields.
+ */
+export interface BytePlusImageGenerationRequest {
+    /** Seedream model id (or a preconfigured endpoint id). */
+    model: string;
+    /**
+     * Instruction text. The BytePlus docs give the limit as 600 English words.
+     * That ceiling is documentation-derived, not probe-confirmed.
+     */
+    prompt: string;
+    /**
+     * Input images for image-conditioned generation (editing, reference-guided
+     * generation, multi-reference composition). Each entry is either a publicly
+     * reachable URL or a data URI of the form
+     * `data:image/<format>;base64,<data>` — BytePlus requires `<format>` to be
+     * **lowercase**. Typed as an array because that is the form the OpenAPI
+     * schema documents.
+     */
+    image?: Array<string>;
+    /**
+     * Output size, as either a shorthand token (`1K`, `2K`, `4K`) or explicit
+     * pixel dimensions (`2048x2048`) — never a mix of the two. Defaults to
+     * `2048x2048` server-side.
+     */
+    size?: string;
+    /** Defaults to `url` server-side. */
+    response_format?: BytePlusImageResponseFormat;
+    /**
+     * Generated file format. Only the Seedream 5.0 family accepts this; the
+     * live 4.0 response carried no `output_format` at all. Defaults to `jpeg`.
+     */
+    output_format?: BytePlusImageOutputFormat;
+    /**
+     * Whether to stamp an "AI generated" watermark in the bottom-right corner.
+     *
+     * **Defaults to `true`** — unlike most providers, BytePlus watermarks unless
+     * you explicitly opt out with `watermark: false`.
+     */
+    watermark?: boolean;
+    /** Defaults to `disabled` server-side. */
+    sequential_image_generation?: BytePlusSequentialImageGeneration;
+    /** Only effective when `sequential_image_generation` is `auto`. */
+    sequential_image_generation_options?: BytePlusSequentialImageGenerationOptions;
+    /** Prompt-rewriting configuration. */
+    optimize_prompt_options?: BytePlusOptimizePromptOptions;
+    /**
+     * Server-sent-events mode, emitting each image as it finishes. Not used by
+     * this adapter — `generateImage()` resolves a complete result, and the core
+     * `stream: true` path chunks that result itself.
+     */
+    stream?: boolean;
+}
+/**
+ * One entry of the `data` array — either a generated image or, in group-image
+ * mode, a per-image failure.
+ *
+ * `url` is present when `response_format` is `url`, `b64_json` when it is
+ * `b64_json`. `size` is the *actual* pixel size the model produced (a `1K`
+ * request came back as `1152x864` live), and is only returned by some models.
+ * `error` is set instead of the image fields when that particular image of a
+ * group failed (e.g. `OutputImageSensitiveContentDetected`) while others
+ * succeeded.
+ *
+ * The OpenAPI document contradicts itself here, describing `data` items as a
+ * nested `{error[], imagecontent[]}` wrapper; the live response is the flat
+ * shape modeled below, so that is what this adapter reads.
+ */
+export interface BytePlusImageData {
+    url?: string;
+    b64_json?: string;
+    size?: string;
+    error?: BytePlusImageErrorObject;
+}
+/**
+ * Usage block. BytePlus bills images, not input tokens: `total_tokens`
+ * currently equals `output_tokens` because input tokens are not counted, and
+ * `generated_images` counts only successful generations.
+ */
+export interface BytePlusImageUsage {
+    generated_images?: number;
+    output_tokens?: number;
+    total_tokens?: number;
+}
+/**
+ * Ark error object. Codes are dotted strings for transport-level failures
+ * (`InvalidEndpointOrModel.NotFound`) and bare identifiers for content
+ * failures (`OutputImageSensitiveContentDetected`,
+ * `InputTextSensitiveContentDetected`, `QuotaExceeded`).
+ */
+export interface BytePlusImageErrorObject {
+    code?: string;
+    message?: string;
+}
+/** Response body of `POST /images/generations`. */
+export interface BytePlusImageGenerationResponse {
+    model?: string;
+    /** Unix timestamp (seconds) of creation. */
+    created?: number;
+    data?: Array<BytePlusImageData>;
+    usage?: BytePlusImageUsage;
+    /** Present when the request as a whole failed. */
+    error?: BytePlusImageErrorObject;
+}

package/dist/esm/index.d.ts

@@ -0,0 +1,25 @@
+export { BytePlusVideoAdapter, byteplusVideo, createBytePlusVideo, } from './adapters/video.js';
+export type { BytePlusVideoConfig } from './adapters/video.js';
+export { parseBytePlusVideoSize, resolveBytePlusVideoResolution, resolveBytePlusVideoSize, supportsLastFrame, supportsReferenceMedia, } from './video/video-provider-options.js';
+export type { BytePlusVideoModelProviderOptionsByName, BytePlusVideoProviderOptions, BytePlusVideoServiceTier, } from './video/video-provider-options.js';
+export type { BytePlusVideoContentPart, BytePlusVideoContentRole, BytePlusVideoCreateRequest, BytePlusVideoCreateResponse, BytePlusVideoTask, BytePlusVideoTaskContent, BytePlusVideoTaskError, BytePlusVideoTaskListItem, BytePlusVideoTaskListResponse, BytePlusVideoTaskStatus, BytePlusVideoTaskUsage, } from './video/wire-types.js';
+export { BYTEPLUS_DEFAULT_TTS_SPEAKER, BYTEPLUS_TTS_MAX_OUTPUT_SECONDS, BytePlusTTSAdapter, byteplusSpeech, createBytePlusSpeech, toSpeechRate, } from './adapters/tts.js';
+export type { BytePlusTTSProviderOptions, BytePlusTTSResult, BytePlusTTSVoice, } from './audio/tts-provider-options.js';
+export { BytePlusTranscriptionAdapter, byteplusTranscription, createBytePlusTranscription, } from './adapters/transcription.js';
+export type { BytePlusTranscriptionWord } from './adapters/transcription.js';
+export type { BytePlusTranscriptionProviderOptions } from './audio/transcription-provider-options.js';
+export { BYTEPLUS_ASR_RESOURCE_HEADER, BYTEPLUS_ASR_RESOURCE_ID, BYTEPLUS_TTS_SAMPLE_RATES, } from './audio/wire-types.js';
+export type { BytePlusASRAudio, BytePlusASRRecognizeRequest, BytePlusASRRecognizeResponse, BytePlusASRResult, BytePlusASRUtterance, BytePlusASRWord, BytePlusTTSAudioConfig, BytePlusTTSAudioFormat, BytePlusTTSCreateRequest, BytePlusTTSCreateResponse, BytePlusTTSReference, BytePlusTTSSampleRate, BytePlusTTSSubtitle, BytePlusTTSSubtitleEntry, BytePlusVoiceErrorBody, } from './audio/wire-types.js';
+export { BytePlusImageAdapter, byteplusImage, createBytePlusImage, } from './adapters/image.js';
+export type { BytePlusImageConfig } from './adapters/image.js';
+export { BYTEPLUS_IMAGE_MAX_PROMPT_WORDS, BYTEPLUS_IMAGE_MAX_SEQUENTIAL_IMAGES, BYTEPLUS_OUTPUT_FORMAT_IMAGE_MODELS, parseBytePlusImageSize, } from './image/image-provider-options.js';
+export type { BytePlusImageBaseProviderOptions, BytePlusImageModelInputModalitiesByName, BytePlusImageModelProviderOptionsByName, BytePlusImageProviderOptions, BytePlusSeedream5ImageProviderOptions, ParsedBytePlusImageSize, } from './image/image-provider-options.js';
+export type { BytePlusImageData, BytePlusImageErrorObject, BytePlusImageGenerationRequest, BytePlusImageGenerationResponse, BytePlusImageOutputFormat, BytePlusImageResponseFormat, BytePlusImageUsage, BytePlusOptimizePromptOptions, BytePlusSequentialImageGeneration, BytePlusSequentialImageGenerationOptions, } from './image/wire-types.js';
+export { BytePlusTextAdapter, byteplusText, createBytePlusText, } from './adapters/text.js';
+export type { BytePlusTextConfig } from './adapters/text.js';
+export type { BytePlusAudioMetadata, BytePlusChatContentPart, BytePlusDocumentMetadata, BytePlusEncryptedContentFields, BytePlusImageMetadata, BytePlusImagePixelLimit, BytePlusImageUrlContentPart, BytePlusInputAudioContentPart, BytePlusMessageMetadataByModality, BytePlusStreamDeltaExtras, BytePlusTextMetadata, BytePlusVideoMetadata, BytePlusVideoUrlContentPart, } from './message-types.js';
+export { BYTEPLUS_ARK_BASE_URL, BYTEPLUS_VOICE_BASE_URL, bytePlusArkError, bytePlusArkHeaders, bytePlusVoiceError, bytePlusVoiceHeaders, getBytePlusArkApiKeyFromEnv, getBytePlusVoiceApiKeyFromEnv, withBytePlusArkDefaults, withBytePlusVoiceDefaults, } from './utils/client.js';
+export type { BytePlusArkConfig, BytePlusVoiceConfig } from './utils/client.js';
+export type { BytePlusNamedToolChoice, BytePlusReasoningEffort, BytePlusServiceTier, BytePlusTextProviderOptions, BytePlusThinkingOption, BytePlusToolChoice, } from './text/text-provider-options.js';
+export { BYTEPLUS_CHAT_MODELS, BYTEPLUS_IMAGE_MAX_REFERENCE_IMAGES, BYTEPLUS_IMAGE_MODELS, BYTEPLUS_STRUCTURED_OUTPUT_CHAT_MODELS, BYTEPLUS_THINKING_SUMMARY_MODELS, BYTEPLUS_TRANSCRIPTION_MODELS, BYTEPLUS_TTS_MODELS, BYTEPLUS_VIDEO_DURATIONS, BYTEPLUS_VIDEO_FALLBACK_DURATIONS, BYTEPLUS_VIDEO_MODELS, emitsEncryptedContent, getBytePlusVideoDurationOptions, isKnownBytePlusVideoModel, supportsStructuredOutput, } from './model-meta.js';
+export type { BytePlusChatModel, BytePlusChatModelProviderOptionsByName, BytePlusChatModelStructuredOutputByName, BytePlusChatModelToolCapabilitiesByName, BytePlusImageModel, BytePlusImageModelSizeByName, BytePlusImageSize, BytePlusImageSizeToken, BytePlusModelInputModalitiesByName, BytePlusProviderToolKind, BytePlusStructuredOutputChatModel, BytePlusThinkingSummaryModel, BytePlusTranscriptionModel, BytePlusTTSModel, BytePlusVideoModel, BytePlusVideoModelDurationByName, BytePlusVideoModelInputModalitiesByName, BytePlusVideoModelOrString, BytePlusVideoModelResolutionByName, BytePlusVideoModelSizeByName, BytePlusVideoRatio, BytePlusVideoResolution, BytePlusVideoSize, ResolveBytePlusVideoInputModalities, ResolveBytePlusVideoSize, ResolveInputModalities, ResolveProviderOptions, } from './model-meta.js';

package/dist/esm/index.js

@@ -0,0 +1,11 @@
+import { BYTEPLUS_ARK_BASE_URL, BYTEPLUS_VOICE_BASE_URL, bytePlusArkError, bytePlusArkHeaders, bytePlusVoiceError, bytePlusVoiceHeaders, getBytePlusArkApiKeyFromEnv, getBytePlusVoiceApiKeyFromEnv, withBytePlusArkDefaults, withBytePlusVoiceDefaults } from "./utils/client.js";
+import { BYTEPLUS_CHAT_MODELS, BYTEPLUS_IMAGE_MAX_REFERENCE_IMAGES, BYTEPLUS_IMAGE_MODELS, BYTEPLUS_STRUCTURED_OUTPUT_CHAT_MODELS, BYTEPLUS_THINKING_SUMMARY_MODELS, BYTEPLUS_TRANSCRIPTION_MODELS, BYTEPLUS_TTS_MODELS, BYTEPLUS_VIDEO_DURATIONS, BYTEPLUS_VIDEO_FALLBACK_DURATIONS, BYTEPLUS_VIDEO_MODELS, emitsEncryptedContent, getBytePlusVideoDurationOptions, isKnownBytePlusVideoModel, supportsStructuredOutput } from "./model-meta.js";
+import { parseBytePlusVideoSize, resolveBytePlusVideoResolution, resolveBytePlusVideoSize, supportsLastFrame, supportsReferenceMedia } from "./video/video-provider-options.js";
+import { BytePlusVideoAdapter, byteplusVideo, createBytePlusVideo } from "./adapters/video.js";
+import { BYTEPLUS_DEFAULT_TTS_SPEAKER, BYTEPLUS_TTS_MAX_OUTPUT_SECONDS, BytePlusTTSAdapter, byteplusSpeech, createBytePlusSpeech, toSpeechRate } from "./adapters/tts.js";
+import { BYTEPLUS_ASR_RESOURCE_HEADER, BYTEPLUS_ASR_RESOURCE_ID, BYTEPLUS_TTS_SAMPLE_RATES } from "./audio/wire-types.js";
+import { BytePlusTranscriptionAdapter, byteplusTranscription, createBytePlusTranscription } from "./adapters/transcription.js";
+import { BYTEPLUS_IMAGE_MAX_PROMPT_WORDS, BYTEPLUS_IMAGE_MAX_SEQUENTIAL_IMAGES, BYTEPLUS_OUTPUT_FORMAT_IMAGE_MODELS, parseBytePlusImageSize } from "./image/image-provider-options.js";
+import { BytePlusImageAdapter, byteplusImage, createBytePlusImage } from "./adapters/image.js";
+import { BytePlusTextAdapter, byteplusText, createBytePlusText } from "./adapters/text.js";
+export { BYTEPLUS_ARK_BASE_URL, BYTEPLUS_ASR_RESOURCE_HEADER, BYTEPLUS_ASR_RESOURCE_ID, BYTEPLUS_CHAT_MODELS, BYTEPLUS_DEFAULT_TTS_SPEAKER, BYTEPLUS_IMAGE_MAX_PROMPT_WORDS, BYTEPLUS_IMAGE_MAX_REFERENCE_IMAGES, BYTEPLUS_IMAGE_MAX_SEQUENTIAL_IMAGES, BYTEPLUS_IMAGE_MODELS, BYTEPLUS_OUTPUT_FORMAT_IMAGE_MODELS, BYTEPLUS_STRUCTURED_OUTPUT_CHAT_MODELS, BYTEPLUS_THINKING_SUMMARY_MODELS, BYTEPLUS_TRANSCRIPTION_MODELS, BYTEPLUS_TTS_MAX_OUTPUT_SECONDS, BYTEPLUS_TTS_MODELS, BYTEPLUS_TTS_SAMPLE_RATES, BYTEPLUS_VIDEO_DURATIONS, BYTEPLUS_VIDEO_FALLBACK_DURATIONS, BYTEPLUS_VIDEO_MODELS, BYTEPLUS_VOICE_BASE_URL, BytePlusImageAdapter, BytePlusTTSAdapter, BytePlusTextAdapter, BytePlusTranscriptionAdapter, BytePlusVideoAdapter, bytePlusArkError, bytePlusArkHeaders, bytePlusVoiceError, bytePlusVoiceHeaders, byteplusImage, byteplusSpeech, byteplusText, byteplusTranscription, byteplusVideo, createBytePlusImage, createBytePlusSpeech, createBytePlusText, createBytePlusTranscription, createBytePlusVideo, emitsEncryptedContent, getBytePlusArkApiKeyFromEnv, getBytePlusVideoDurationOptions, getBytePlusVoiceApiKeyFromEnv, isKnownBytePlusVideoModel, parseBytePlusImageSize, parseBytePlusVideoSize, resolveBytePlusVideoResolution, resolveBytePlusVideoSize, supportsLastFrame, supportsReferenceMedia, supportsStructuredOutput, toSpeechRate, withBytePlusArkDefaults, withBytePlusVoiceDefaults };

package/dist/esm/message-types.d.ts

@@ -0,0 +1,154 @@
+/**
+ * BytePlus ModelArk chat message types.
+ *
+ * Ark's `/chat/completions` wire format is OpenAI Chat Completions plus a few
+ * Ark-only extensions, so the OpenAI SDK types (via `@tanstack/openai-base`)
+ * cover everything except the fields below. This file is the source of truth
+ * for the Ark-only parts of a chat message:
+ *
+ * - `encrypted_content` on the assistant message (thinking-summary models)
+ * - `video_url` content parts (no OpenAI equivalent)
+ * - `input_audio` accepting a `url` as well as inline base64
+ *
+ * Field shapes verified live against
+ * `https://ark.ap-southeast.bytepluses.com/api/v3` on 2026-07-31 — see the
+ * probe findings referenced from `model-meta.ts`.
+ */
+/**
+ * Opaque signature blob emitted alongside `reasoning_content` by the
+ * thinking-summary models (see `BYTEPLUS_THINKING_SUMMARY_MODELS`).
+ *
+ * Non-streaming responses carry it on `choices[].message.encrypted_content`;
+ * streaming delivers the whole blob as one dedicated chunk
+ * (`delta.encrypted_content`, with empty `content` / `reasoning_content`)
+ * between the reasoning deltas and the content deltas.
+ *
+ * When present it should be echoed back verbatim on the assistant message in
+ * the next turn. Probing showed omitting it does *not* fail a request, so it
+ * is preserved-and-replayed rather than required.
+ */
+export interface BytePlusEncryptedContentFields {
+    encrypted_content?: string;
+}
+/**
+ * Streaming delta fields Ark adds on top of the OpenAI chunk shape.
+ */
+export interface BytePlusStreamDeltaExtras extends BytePlusEncryptedContentFields {
+    reasoning_content?: string;
+}
+/**
+ * Bounds on how large an image is scaled to before tokenization.
+ *
+ * Probe-verified to live *inside* `image_url` (a number at the content-part
+ * level is silently ignored; Ark validates the object form — asking for
+ * `min_pixels` below the model's floor is rejected with a specific error).
+ */
+export interface BytePlusImagePixelLimit {
+    max_pixels?: number;
+    min_pixels?: number;
+}
+/**
+ * Image content part. Ark's `image_url` extends OpenAI's with an `xhigh`
+ * detail level and {@link BytePlusImagePixelLimit}.
+ */
+export interface BytePlusImageUrlContentPart {
+    type: 'image_url';
+    image_url: {
+        url: string;
+        detail?: 'auto' | 'low' | 'high' | 'xhigh';
+        image_pixel_limit?: BytePlusImagePixelLimit;
+    };
+}
+/**
+ * Video content part. Ark accepts a public URL or a `data:` URI; there is no
+ * OpenAI Chat Completions equivalent, so this shape is defined here.
+ */
+export interface BytePlusVideoUrlContentPart {
+    type: 'video_url';
+    video_url: {
+        url: string;
+        /**
+         * Frame sampling rate in frames per second. Omitted by the adapter unless
+         * the caller sets it through content-part metadata.
+         */
+        fps?: number;
+    };
+}
+/**
+ * Audio content part. Ark extends OpenAI's `input_audio` (inline base64 +
+ * `format`) with a `url` alternative.
+ */
+export interface BytePlusInputAudioContentPart {
+    type: 'input_audio';
+    input_audio: {
+        /** Base64 audio payload. Mutually exclusive with `url`. */
+        data?: string;
+        /** Container format of `data`. Required whenever `data` is set. */
+        format?: 'wav' | 'mp3' | 'ogg' | 'flac' | 'm4a' | 'aac' | 'pcm';
+        /** Public audio URL. Mutually exclusive with `data`. */
+        url?: string;
+    };
+}
+/**
+ * The Ark-only content parts, as a single union. The adapter funnels these
+ * through one documented cast when handing them to the OpenAI SDK, whose
+ * content-part union has no arm for `video_url`, for URL-addressed audio, or
+ * for the extra `image_url` fields.
+ */
+export type BytePlusChatContentPart = BytePlusImageUrlContentPart | BytePlusVideoUrlContentPart | BytePlusInputAudioContentPart;
+/**
+ * Metadata for BytePlus text content parts. Ark has no text-part options.
+ */
+export interface BytePlusTextMetadata {
+}
+/**
+ * Metadata for BytePlus image content parts.
+ */
+export interface BytePlusImageMetadata {
+    /**
+     * Processing detail for the image. Ark adds `xhigh` to OpenAI's set.
+     *
+     * @default 'auto'
+     */
+    detail?: 'auto' | 'low' | 'high' | 'xhigh';
+    /**
+     * Bounds the pixel count the image is scaled to before tokenization —
+     * see {@link BytePlusImagePixelLimit}. Lower `max_pixels` trades detail for
+     * input tokens.
+     */
+    image_pixel_limit?: BytePlusImagePixelLimit;
+}
+/**
+ * Metadata for BytePlus audio content parts.
+ */
+export interface BytePlusAudioMetadata {
+    /**
+     * Container format for inline base64 audio. Inferred from the part's
+     * `mimeType` when omitted.
+     */
+    format?: BytePlusInputAudioContentPart['input_audio']['format'];
+}
+/**
+ * Metadata for BytePlus video content parts.
+ */
+export interface BytePlusVideoMetadata {
+    /** Frame sampling rate in frames per second. */
+    fps?: number;
+}
+/**
+ * Metadata for BytePlus document content parts. Ark's chat API takes no
+ * document parts — the field exists so the modality map stays total.
+ */
+export interface BytePlusDocumentMetadata {
+}
+/**
+ * Map of modality to BytePlus-specific content-part metadata. Used for type
+ * inference when constructing multimodal messages.
+ */
+export interface BytePlusMessageMetadataByModality {
+    text: BytePlusTextMetadata;
+    image: BytePlusImageMetadata;
+    audio: BytePlusAudioMetadata;
+    video: BytePlusVideoMetadata;
+    document: BytePlusDocumentMetadata;
+}