batchwork 1.4.0 → 1.5.0

package/dist/{chunk-2ea62n95.js → chunk-zss8h417.js}

@@ -1,16 +1,18 @@
 import {
-  BatchJob,
-  BatchworkError,
-  MissingDependencyError,
-  UnsupportedProviderError,
+  BatchworkError2,
+  UnsupportedProviderError2,
+  MissingDependencyError2,
+  resolveBatchLimits,
   assertByteLength,
-  getAdapter,
-  mapWithConcurrency,
-  resolveBatchLimits
-} from "./chunk-vy4w8mpb.js";
+  BatchJob2,
+  getAdapter
+} from "./chunk-7y95mhvm.js";
 import {
-  __require
-} from "./chunk-v0bahtg2.js";
+  isString,
+  trimTrailingSlashes,
+  isJsonObject,
+  parseJson
+} from "./chunk-6jgvqdpc.js";
 
 // src/model.ts
 var CAPTURE_API_KEY = "batchwork-capture";
@@ -18,7 +20,7 @@ var azureCaptureBaseUrl = (baseURL) => {
   if (!baseURL) {
     return;
   }
-  const normalized = baseURL.replace(/\/+$/u, "");
+  const normalized = trimTrailingSlashes(baseURL);
   try {
     if (new URL(normalized).hostname.endsWith(".openai.azure.com")) {
       const root = normalized.replace(/\/v1$/u, "");
@@ -37,21 +39,21 @@ var PACKAGE_BY_PROVIDER = {
   together: { label: "Together AI", specifier: "@ai-sdk/togetherai" },
   xai: { label: "xAI", specifier: "@ai-sdk/xai" }
 };
-var PROVIDER_BY_FAMILY = {
-  anthropic: "anthropic",
-  azure: "azure",
-  google: "google",
-  groq: "groq",
-  mistral: "mistral",
-  openai: "openai",
-  together: "together",
-  togetherai: "together",
-  xai: "xai"
-};
-var PROVIDER_BY_ALIAS = {
+var PROVIDER_BY_FAMILY = new Map([
+  ["anthropic", "anthropic"],
+  ["azure", "azure"],
+  ["google", "google"],
+  ["groq", "groq"],
+  ["mistral", "mistral"],
+  ["openai", "openai"],
+  ["together", "together"],
+  ["togetherai", "together"],
+  ["xai", "xai"]
+]);
+var PROVIDER_BY_ALIAS = new Map([
   ...PROVIDER_BY_FAMILY,
-  gemini: "google"
-};
+  ["gemini", "google"]
+]);
 var splitOnce = (value, separator) => {
   const index = value.indexOf(separator);
   if (index === -1) {
@@ -71,20 +73,20 @@ var openaiKind = (suffix) => {
 var resolveModelString = (value) => {
   const [providerId, modelId] = splitOnce(value, "/");
   if (modelId === "") {
-    throw new UnsupportedProviderError(value);
+    throw new UnsupportedProviderError2(value);
   }
-  const provider = PROVIDER_BY_ALIAS[providerId];
+  const provider = PROVIDER_BY_ALIAS.get(providerId);
   if (!provider) {
-    throw new UnsupportedProviderError(providerId);
+    throw new UnsupportedProviderError2(providerId);
   }
   return { kind: "chat", modelId, provider };
 };
-var resolveModel = (model) => {
-  if (typeof model === "string") {
+var resolveModel2 = (model) => {
+  if (isString(model)) {
     return resolveModelString(model);
   }
   const [family, suffix] = splitOnce(model.provider, ".");
-  const provider = PROVIDER_BY_FAMILY[family];
+  const provider = PROVIDER_BY_FAMILY.get(family);
   if (provider === "openai" || provider === "azure") {
     return { kind: openaiKind(suffix), modelId: model.modelId, provider };
   }
@@ -94,48 +96,34 @@ var resolveModel = (model) => {
   if (model.modelId.includes("/")) {
     return resolveModelString(model.modelId);
   }
-  throw new UnsupportedProviderError(model.provider);
+  throw new UnsupportedProviderError2(model.provider);
+};
+var importers = {
+  anthropic: () => import("@ai-sdk/anthropic"),
+  azure: () => import("@ai-sdk/azure"),
+  google: () => import("@ai-sdk/google"),
+  groq: () => import("@ai-sdk/groq"),
+  mistral: () => import("@ai-sdk/mistral"),
+  openai: () => import("@ai-sdk/openai"),
+  together: () => import("@ai-sdk/togetherai"),
+  xai: () => import("@ai-sdk/xai")
 };
 var importProvider = (provider) => {
-  switch (provider) {
-    case "anthropic": {
-      return import("@ai-sdk/anthropic");
-    }
-    case "azure": {
-      return import("@ai-sdk/azure");
-    }
-    case "google": {
-      return import("@ai-sdk/google");
-    }
-    case "groq": {
-      return import("@ai-sdk/groq");
-    }
-    case "mistral": {
-      return import("@ai-sdk/mistral");
-    }
-    case "openai": {
-      return import("@ai-sdk/openai");
-    }
-    case "together": {
-      return import("@ai-sdk/togetherai");
-    }
-    case "xai": {
-      return import("@ai-sdk/xai");
-    }
-    default: {
-      return Promise.reject(new UnsupportedProviderError(provider));
-    }
+  const importer = importers[provider];
+  if (importer === undefined) {
+    return Promise.reject(new UnsupportedProviderError2(provider));
   }
+  return importer();
 };
 var loadProvider = async (provider, load = importProvider) => {
   try {
     return await load(provider);
   } catch (error) {
-    if (error instanceof UnsupportedProviderError) {
+    if (error instanceof UnsupportedProviderError2) {
       throw error;
     }
     const { specifier, label } = PACKAGE_BY_PROVIDER[provider];
-    throw new MissingDependencyError(specifier, label);
+    throw new MissingDependencyError2(specifier, label);
   }
 };
 var createCaptureModel = async (resolved, credentials, fetchImpl) => {
@@ -196,7 +184,7 @@ var createCaptureModel = async (resolved, credentials, fetchImpl) => {
       return createTogetherAI(settings).languageModel(resolved.modelId);
     }
     default: {
-      throw new UnsupportedProviderError(resolved.provider);
+      throw new UnsupportedProviderError2(resolved.provider);
     }
   }
 };
@@ -205,7 +193,7 @@ var EMBEDDING_PROVIDERS = new Set([
   "mistral",
   "openai"
 ]);
-var unsupportedEmbeddingProvider = (provider) => new UnsupportedProviderError(provider, `batchwork: provider "${provider}" does not offer batch embeddings. Embeddings are supported for: openai, mistral, google.`);
+var unsupportedEmbeddingProvider = (provider) => new UnsupportedProviderError2(provider, `batchwork: provider "${provider}" does not offer batch embeddings. Embeddings are supported for: openai, mistral, google.`);
 var createCaptureEmbeddingModel = async (resolved, credentials, fetchImpl) => {
   const settings = {
     apiKey: credentials.apiKey ?? CAPTURE_API_KEY,
@@ -232,9 +220,9 @@ var createCaptureEmbeddingModel = async (resolved, credentials, fetchImpl) => {
   }
 };
 var IMAGE_EDIT_PROVIDERS = new Set(["openai", "xai"]);
-var unsupportedImageEditProvider = (provider) => new UnsupportedProviderError(provider, `batchwork: provider "${provider}" does not offer batch image editing. Image edits are supported for: openai, xai.`);
+var unsupportedImageEditProvider = (provider) => new UnsupportedProviderError2(provider, `batchwork: provider "${provider}" does not offer batch image editing. Image edits are supported for: openai, xai.`);
 var VIDEO_PROVIDERS = new Set(["xai"]);
-var unsupportedVideoProvider = (provider) => new UnsupportedProviderError(provider, `batchwork: provider "${provider}" does not offer batch video generation. Videos are supported for: xai.`);
+var unsupportedVideoProvider = (provider) => new UnsupportedProviderError2(provider, `batchwork: provider "${provider}" does not offer batch video generation. Videos are supported for: xai.`);
 var createCaptureVideoModel = async (resolved, credentials, fetchImpl) => {
   if (resolved.provider !== "xai") {
     throw unsupportedVideoProvider(resolved.provider);
@@ -251,24 +239,24 @@ var TRANSLATION_PROVIDERS = new Set([
   "groq",
   "together"
 ]);
-var unsupportedTranslationProvider = (provider) => new UnsupportedProviderError(provider, `batchwork: provider "${provider}" does not offer batch translation. Translations are supported for: groq, together.`);
+var unsupportedTranslationProvider = (provider) => new UnsupportedProviderError2(provider, `batchwork: provider "${provider}" does not offer batch translation. Translations are supported for: groq, together.`);
 var MODERATION_PROVIDERS = new Set([
   "mistral",
   "openai"
 ]);
-var unsupportedModerationProvider = (provider) => new UnsupportedProviderError(provider, `batchwork: provider "${provider}" does not offer batch moderation. Moderations are supported for: openai, mistral.`);
+var unsupportedModerationProvider = (provider) => new UnsupportedProviderError2(provider, `batchwork: provider "${provider}" does not offer batch moderation. Moderations are supported for: openai, mistral.`);
 var TRANSCRIPTION_PROVIDERS = new Set([
   "groq",
   "mistral",
   "together"
 ]);
-var unsupportedTranscriptionProvider = (provider) => new UnsupportedProviderError(provider, `batchwork: provider "${provider}" does not offer batch transcription. Transcriptions are supported for: groq, mistral, together.`);
+var unsupportedTranscriptionProvider = (provider) => new UnsupportedProviderError2(provider, `batchwork: provider "${provider}" does not offer batch transcription. Transcriptions are supported for: groq, mistral, together.`);
 var IMAGE_PROVIDERS = new Set([
   "google",
   "openai",
   "xai"
 ]);
-var unsupportedImageProvider = (provider) => new UnsupportedProviderError(provider, `batchwork: provider "${provider}" does not offer batch image generation. Image batches are supported for: openai, google, xai.`);
+var unsupportedImageProvider = (provider) => new UnsupportedProviderError2(provider, `batchwork: provider "${provider}" does not offer batch image generation. Image batches are supported for: openai, google, xai.`);
 var createCaptureImageModel = async (resolved, credentials, fetchImpl) => {
   const settings = {
     apiKey: credentials.apiKey ?? CAPTURE_API_KEY,
@@ -302,6 +290,7 @@ import {
   generateImage,
   generateText
 } from "ai";
+import pMap from "p-map";
 var MAX_CAUSE_DEPTH = 10;
 
 class CaptureSignalError extends Error {
@@ -315,35 +304,36 @@ class CaptureSignalError extends Error {
   }
 }
 var resolveUrl = (input) => {
-  if (typeof input === "string") {
-    return input;
-  }
   if (input instanceof URL) {
     return input.toString();
   }
-  return input.url;
+  if (input instanceof Request) {
+    return input.url;
+  }
+  return input;
 };
 var extractBody = (init) => {
   const body = init?.body;
-  if (typeof body === "string") {
+  if (isString(body)) {
     return body;
   }
   if (body instanceof Uint8Array) {
     return new TextDecoder().decode(body);
   }
-  throw new BatchworkError("batchwork: unable to read the provider request body during capture.");
+  throw new BatchworkError2("batchwork: unable to read the provider request body during capture.");
 };
-var captureFetch = (input, init) => Promise.reject(new CaptureSignalError(resolveUrl(input), extractBody(init)));
-var findCapture = (error) => {
-  let current = error;
-  let depth = 0;
-  while (current && depth < MAX_CAUSE_DEPTH) {
-    if (current instanceof CaptureSignalError) {
-      return current;
-    }
-    current = current.cause;
-    depth += 1;
+var captureFetch = Object.assign((input, init) => Promise.reject(new CaptureSignalError(resolveUrl(input), extractBody(init))), {
+  preconnect: () => {}
+});
+var hasCause = (value) => typeof value === "object" && value !== null && ("cause" in value);
+var findCapture = (cause, depth = 0) => {
+  if (depth >= MAX_CAUSE_DEPTH) {
+    return;
+  }
+  if (cause instanceof CaptureSignalError) {
+    return cause;
   }
+  return hasCause(cause) ? findCapture(cause.cause, depth + 1) : undefined;
 };
 var endpointFromUrl = (url) => {
   try {
@@ -376,25 +366,25 @@ var toGenerateInput = (model, request) => ({
   topK: request.topK,
   topP: request.topP
 });
-var bodyFromCapture = (error, customId, maxRequestBytes) => {
-  const capture = findCapture(error);
-  if (capture) {
-    assertByteLength(`request "${customId}"`, capture.rawBody, maxRequestBytes);
-    return {
-      body: JSON.parse(capture.rawBody),
-      customId,
-      endpoint: endpointFromUrl(capture.url)
-    };
+var bodyFromCapture = (capture, customId, maxRequestBytes) => {
+  assertByteLength(`request "${customId}"`, capture.rawBody, maxRequestBytes);
+  const body = parseJson(capture.rawBody);
+  if (!isJsonObject(body)) {
+    throw new BatchworkError2(`batchwork: the captured body for request "${customId}" is not a JSON object.`);
   }
-  throw error;
+  return { body, customId, endpoint: endpointFromUrl(capture.url) };
 };
 var captureOne = async (model, request, customId, maxRequestBytes) => {
   try {
     await generateText(toGenerateInput(model, request));
   } catch (error) {
-    return bodyFromCapture(error, customId, maxRequestBytes);
+    const capture = findCapture(error);
+    if (!capture) {
+      throw error;
+    }
+    return bodyFromCapture(capture, customId, maxRequestBytes);
   }
-  throw new BatchworkError("batchwork: the request was not intercepted while building the batch body.");
+  throw new BatchworkError2("batchwork: the request was not intercepted while building the batch body.");
 };
 var captureEmbeddingOne = async (model, request, customId, maxRequestBytes) => {
   try {
@@ -405,9 +395,13 @@ var captureEmbeddingOne = async (model, request, customId, maxRequestBytes) => {
       value: request.value
     });
   } catch (error) {
-    return bodyFromCapture(error, customId, maxRequestBytes);
+    const capture = findCapture(error);
+    if (!capture) {
+      throw error;
+    }
+    return bodyFromCapture(capture, customId, maxRequestBytes);
   }
-  throw new BatchworkError("batchwork: the request was not intercepted while building the embedding body.");
+  throw new BatchworkError2("batchwork: the request was not intercepted while building the embedding body.");
 };
 var captureImageOne = async (model, request, customId, maxRequestBytes) => {
   try {
@@ -423,16 +417,20 @@ var captureImageOne = async (model, request, customId, maxRequestBytes) => {
       size: request.size
     });
   } catch (error) {
-    return bodyFromCapture(error, customId, maxRequestBytes);
+    const capture = findCapture(error);
+    if (!capture) {
+      throw error;
+    }
+    return bodyFromCapture(capture, customId, maxRequestBytes);
   }
-  throw new BatchworkError("batchwork: the request was not intercepted while building the image body.");
+  throw new BatchworkError2("batchwork: the request was not intercepted while building the image body.");
 };
 var assignCustomIds = (requests) => {
   const seen = new Set;
   return requests.map((request, index) => {
     const customId = request.customId ?? `request-${index}`;
     if (seen.has(customId)) {
-      throw new BatchworkError(`batchwork: duplicate customId "${customId}". customId values must be unique within a batch.`);
+      throw new BatchworkError2(`batchwork: duplicate customId "${customId}". customId values must be unique within a batch.`);
     }
     seen.add(customId);
     return { customId, request };
@@ -441,64 +439,63 @@ var assignCustomIds = (requests) => {
 var buildRequestBodies = async (resolved, requests, defaults, credentials, rawLimits) => {
   const limits = resolveBatchLimits(rawLimits);
   if (requests.length > limits.maxRequests) {
-    throw new BatchworkError(`batchwork: requests length ${requests.length} exceeds the ${limits.maxRequests} request limit.`);
+    throw new BatchworkError2(`batchwork: requests length ${requests.length} exceeds the ${limits.maxRequests} request limit.`);
   }
   const model = await createCaptureModel(resolved, credentials, captureFetch);
   const items = assignCustomIds(requests);
-  return await mapWithConcurrency(items, limits.captureConcurrency, async (item) => {
+  return await pMap(items, async (item) => {
     const built = await captureOne(model, mergeDefaults(item.request, defaults), item.customId, limits.maxRequestBytes);
     assertByteLength(`request "${item.customId}"`, JSON.stringify(built.body), limits.maxRequestBytes);
     return built;
-  });
+  }, { concurrency: limits.captureConcurrency });
 };
 var buildEmbeddingBodies = async (resolved, requests, credentials, rawLimits) => {
   const limits = resolveBatchLimits(rawLimits);
   if (requests.length > limits.maxRequests) {
-    throw new BatchworkError(`batchwork: requests length ${requests.length} exceeds the ${limits.maxRequests} request limit.`);
+    throw new BatchworkError2(`batchwork: requests length ${requests.length} exceeds the ${limits.maxRequests} request limit.`);
   }
   const model = await createCaptureEmbeddingModel(resolved, credentials, captureFetch);
   const items = assignCustomIds(requests);
-  return await mapWithConcurrency(items, limits.captureConcurrency, async (item) => {
+  return await pMap(items, async (item) => {
     const built = await captureEmbeddingOne(model, item.request, item.customId, limits.maxRequestBytes);
     assertByteLength(`request "${item.customId}"`, JSON.stringify(built.body), limits.maxRequestBytes);
     return built;
-  });
+  }, { concurrency: limits.captureConcurrency });
 };
 var MODERATION_ENDPOINT = "/v1/moderations";
-var moderationInput = (request) => {
-  const imageUrls = request.imageUrls ?? [];
-  if (imageUrls.length === 0) {
-    return request.value;
+var moderationParts = (value, imageUrls) => {
+  const parts = [];
+  if (value !== undefined) {
+    parts.push({ text: value, type: "text" });
+  }
+  for (const url of imageUrls) {
+    parts.push({ image_url: { url }, type: "image_url" });
   }
-  return [
-    ...request.value === undefined ? [] : [{ text: request.value, type: "text" }],
-    ...imageUrls.map((url) => ({ image_url: { url }, type: "image_url" }))
-  ];
+  return parts;
 };
 var moderationBody = (resolved, request, customId) => {
-  if (request.value === undefined && !request.imageUrls?.length) {
-    throw new BatchworkError(`batchwork: moderation request "${customId}" needs \`value\` or \`imageUrls\`.`);
+  const { value } = request;
+  const imageUrls = request.imageUrls ?? [];
+  if (value === undefined && imageUrls.length === 0) {
+    throw new BatchworkError2(`batchwork: moderation request "${customId}" needs \`value\` or \`imageUrls\`.`);
   }
   const options = request.providerOptions?.[resolved.provider];
   if (resolved.provider === "openai") {
-    return {
-      input: moderationInput(request),
-      model: resolved.modelId,
-      ...options
-    };
+    const input = imageUrls.length === 0 && value !== undefined ? value : moderationParts(value, imageUrls);
+    return { input, model: resolved.modelId, ...options };
   }
   if (resolved.provider === "mistral") {
-    if (request.imageUrls?.length) {
-      throw new BatchworkError(`batchwork: moderation request "${customId}" has \`imageUrls\`, but Mistral moderation is text-only.`);
+    if (imageUrls.length > 0) {
+      throw new BatchworkError2(`batchwork: moderation request "${customId}" has \`imageUrls\`, but Mistral moderation is text-only.`);
     }
-    return { input: request.value, model: resolved.modelId, ...options };
+    return { input: value ?? "", model: resolved.modelId, ...options };
   }
   throw unsupportedModerationProvider(resolved.provider);
 };
 var buildModerationBodies = (resolved, requests, rawLimits) => {
   const limits = resolveBatchLimits(rawLimits);
   if (requests.length > limits.maxRequests) {
-    throw new BatchworkError(`batchwork: requests length ${requests.length} exceeds the ${limits.maxRequests} request limit.`);
+    throw new BatchworkError2(`batchwork: requests length ${requests.length} exceeds the ${limits.maxRequests} request limit.`);
   }
   return assignCustomIds(requests).map((item) => {
     const body = moderationBody(resolved, item.request, item.customId);
@@ -507,17 +504,26 @@ var buildModerationBodies = (resolved, requests, rawLimits) => {
   });
 };
 var TRANSCRIPTION_ENDPOINT = "/v1/audio/transcriptions";
+var audioOptions = (request, verboseTimestamps) => {
+  const fields = {};
+  if (request.language) {
+    fields.language = request.language;
+  }
+  if (request.timestampGranularities) {
+    if (verboseTimestamps) {
+      fields.response_format = "verbose_json";
+    }
+    fields.timestamp_granularities = request.timestampGranularities;
+  }
+  return fields;
+};
 var transcriptionBody = (resolved, request) => {
   const options = request.providerOptions?.[resolved.provider];
   if (resolved.provider === "groq") {
     return {
       model: resolved.modelId,
       url: request.audioUrl,
-      ...request.language ? { language: request.language } : {},
-      ...request.timestampGranularities ? {
-        response_format: "verbose_json",
-        timestamp_granularities: request.timestampGranularities
-      } : {},
+      ...audioOptions(request, true),
       ...options
     };
   }
@@ -525,8 +531,7 @@ var transcriptionBody = (resolved, request) => {
     return {
       file_url: request.audioUrl,
       model: resolved.modelId,
-      ...request.language ? { language: request.language } : {},
-      ...request.timestampGranularities ? { timestamp_granularities: request.timestampGranularities } : {},
+      ...audioOptions(request, false),
       ...options
     };
   }
@@ -534,11 +539,7 @@ var transcriptionBody = (resolved, request) => {
     return {
       file: request.audioUrl,
       model: resolved.modelId,
-      ...request.language ? { language: request.language } : {},
-      ...request.timestampGranularities ? {
-        response_format: "verbose_json",
-        timestamp_granularities: request.timestampGranularities
-      } : {},
+      ...audioOptions(request, true),
       ...options
     };
   }
@@ -547,7 +548,7 @@ var transcriptionBody = (resolved, request) => {
 var buildAudioBodies = (resolved, requests, defaults, endpoint, rawLimits) => {
   const limits = resolveBatchLimits(rawLimits);
   if (requests.length > limits.maxRequests) {
-    throw new BatchworkError(`batchwork: requests length ${requests.length} exceeds the ${limits.maxRequests} request limit.`);
+    throw new BatchworkError2(`batchwork: requests length ${requests.length} exceeds the ${limits.maxRequests} request limit.`);
   }
   return assignCustomIds(requests).map((item) => {
     const body = transcriptionBody(resolved, mergeDefaults(item.request, defaults));
@@ -560,61 +561,69 @@ var buildTranslationBodies = (resolved, requests, defaults, rawLimits) => buildA
 var buildImageBodies = async (resolved, requests, defaults, credentials, rawLimits) => {
   const limits = resolveBatchLimits(rawLimits);
   if (requests.length > limits.maxRequests) {
-    throw new BatchworkError(`batchwork: requests length ${requests.length} exceeds the ${limits.maxRequests} request limit.`);
+    throw new BatchworkError2(`batchwork: requests length ${requests.length} exceeds the ${limits.maxRequests} request limit.`);
   }
   const model = await createCaptureImageModel(resolved, credentials, captureFetch);
   const items = assignCustomIds(requests);
-  return await mapWithConcurrency(items, limits.captureConcurrency, async (item) => {
+  return await pMap(items, async (item) => {
     const built = await captureImageOne(model, mergeDefaults(item.request, defaults), item.customId, limits.maxRequestBytes);
     assertByteLength(`request "${item.customId}"`, JSON.stringify(built.body), limits.maxRequestBytes);
     return built;
-  });
+  }, { concurrency: limits.captureConcurrency });
 };
 var IMAGE_EDIT_ENDPOINT = "/v1/images/edits";
 var openaiImageRef = (ref) => ("fileId" in ref) ? { file_id: ref.fileId } : { image_url: ref.imageUrl };
 var imageEditBody = (resolved, request, customId) => {
   if (request.images.length === 0) {
-    throw new BatchworkError(`batchwork: image-edit request "${customId}" needs at least one entry in \`images\`.`);
+    throw new BatchworkError2(`batchwork: image-edit request "${customId}" needs at least one entry in \`images\`.`);
   }
   const options = request.providerOptions?.[resolved.provider];
   if (resolved.provider === "openai") {
-    return {
+    const body = {
       images: request.images.map(openaiImageRef),
       model: resolved.modelId,
-      prompt: request.prompt,
-      ...request.mask ? { mask: openaiImageRef(request.mask) } : {},
-      ...request.n === undefined ? {} : { n: request.n },
-      ...request.size ? { size: request.size } : {},
-      ...options
+      prompt: request.prompt
     };
+    if (request.mask) {
+      body.mask = openaiImageRef(request.mask);
+    }
+    if (request.n !== undefined) {
+      body.n = request.n;
+    }
+    if (request.size) {
+      body.size = request.size;
+    }
+    return { ...body, ...options };
   }
   if (resolved.provider === "xai") {
     if (request.mask) {
-      throw new BatchworkError(`batchwork: image-edit request "${customId}" has a \`mask\`, but xAI image edits do not support masks.`);
+      throw new BatchworkError2(`batchwork: image-edit request "${customId}" has a \`mask\`, but xAI image edits do not support masks.`);
     }
     if (request.size) {
-      throw new BatchworkError(`batchwork: image-edit request "${customId}" has \`size\`, but xAI image edits take \`providerOptions.xai.aspect_ratio\` instead.`);
+      throw new BatchworkError2(`batchwork: image-edit request "${customId}" has \`size\`, but xAI image edits take \`providerOptions.xai.aspect_ratio\` instead.`);
     }
     const urls = request.images.map((ref) => {
       if ("fileId" in ref) {
-        throw new BatchworkError(`batchwork: image-edit request "${customId}" uses a \`fileId\` reference, but xAI image edits accept image URLs only.`);
+        throw new BatchworkError2(`batchwork: image-edit request "${customId}" uses a \`fileId\` reference, but xAI image edits accept image URLs only.`);
       }
       return ref.imageUrl;
     });
-    return {
+    const body = {
       model: resolved.modelId,
       prompt: request.prompt,
-      ...urls.length === 1 ? { image: { url: urls[0] } } : { images: urls.map((url) => ({ url })) },
-      ...request.n === undefined ? {} : { n: request.n },
-      ...options
+      ...urls.length === 1 ? { image: { url: urls[0] } } : { images: urls.map((url) => ({ url })) }
     };
+    if (request.n !== undefined) {
+      body.n = request.n;
+    }
+    return { ...body, ...options };
   }
   throw unsupportedImageEditProvider(resolved.provider);
 };
 var buildImageEditBodies = (resolved, requests, defaults, rawLimits) => {
   const limits = resolveBatchLimits(rawLimits);
   if (requests.length > limits.maxRequests) {
-    throw new BatchworkError(`batchwork: requests length ${requests.length} exceeds the ${limits.maxRequests} request limit.`);
+    throw new BatchworkError2(`batchwork: requests length ${requests.length} exceeds the ${limits.maxRequests} request limit.`);
   }
   return assignCustomIds(requests).map((item) => {
     const body = imageEditBody(resolved, mergeDefaults(item.request, defaults), item.customId);
@@ -634,22 +643,26 @@ var captureVideoOne = async (model, request, customId, maxRequestBytes) => {
       resolution: request.resolution
     });
   } catch (error) {
-    return bodyFromCapture(error, customId, maxRequestBytes);
+    const capture = findCapture(error);
+    if (!capture) {
+      throw error;
+    }
+    return bodyFromCapture(capture, customId, maxRequestBytes);
   }
-  throw new BatchworkError("batchwork: the request was not intercepted while building the video body.");
+  throw new BatchworkError2("batchwork: the request was not intercepted while building the video body.");
 };
 var buildVideoBodies = async (resolved, requests, defaults, credentials, rawLimits) => {
   const limits = resolveBatchLimits(rawLimits);
   if (requests.length > limits.maxRequests) {
-    throw new BatchworkError(`batchwork: requests length ${requests.length} exceeds the ${limits.maxRequests} request limit.`);
+    throw new BatchworkError2(`batchwork: requests length ${requests.length} exceeds the ${limits.maxRequests} request limit.`);
   }
   const model = await createCaptureVideoModel(resolved, credentials, captureFetch);
   const items = assignCustomIds(requests);
-  return await mapWithConcurrency(items, limits.captureConcurrency, async (item) => {
+  return await pMap(items, async (item) => {
     const built = await captureVideoOne(model, mergeDefaults(item.request, defaults), item.customId, limits.maxRequestBytes);
     assertByteLength(`request "${item.customId}"`, JSON.stringify(built.body), limits.maxRequestBytes);
     return built;
-  });
+  }, { concurrency: limits.captureConcurrency });
 };
 
 // src/batch.ts
@@ -664,15 +677,15 @@ var providerFromRef = (ref) => {
     return ref.provider;
   }
   if (ref.model !== undefined) {
-    return resolveModel(ref.model).provider;
+    return resolveModel2(ref.model).provider;
   }
-  throw new BatchworkError("batchwork: provide `provider` or `model` to identify the batch.");
+  throw new BatchworkError2("batchwork: provide `provider` or `model` to identify the batch.");
 };
 var submitText = async (options) => {
   if (options.requests.length === 0) {
-    throw new BatchworkError(EMPTY_REQUESTS_MESSAGE);
+    throw new BatchworkError2(EMPTY_REQUESTS_MESSAGE);
   }
-  const resolved = resolveModel(options.model);
+  const resolved = resolveModel2(options.model);
   const credentials = pickCredentials(options);
   const limits = resolveBatchLimits(options.limits);
   const adapter = getAdapter(resolved.provider);
@@ -685,13 +698,13 @@ var submitText = async (options) => {
     metadata: options.metadata,
     modelId: resolved.modelId
   });
-  return new BatchJob(adapter, credentials, snapshot);
+  return new BatchJob2(adapter, credentials, snapshot);
 };
 var submitEmbeddings = async (options) => {
   if (options.requests.length === 0) {
-    throw new BatchworkError(EMPTY_REQUESTS_MESSAGE);
+    throw new BatchworkError2(EMPTY_REQUESTS_MESSAGE);
   }
-  const resolved = resolveModel(options.model);
+  const resolved = resolveModel2(options.model);
   if (!EMBEDDING_PROVIDERS.has(resolved.provider)) {
     throw unsupportedEmbeddingProvider(resolved.provider);
   }
@@ -707,13 +720,13 @@ var submitEmbeddings = async (options) => {
     metadata: options.metadata,
     modelId: resolved.modelId
   });
-  return new BatchJob(adapter, credentials, snapshot);
+  return new BatchJob2(adapter, credentials, snapshot);
 };
 var submitImages = async (options) => {
   if (options.requests.length === 0) {
-    throw new BatchworkError(EMPTY_REQUESTS_MESSAGE);
+    throw new BatchworkError2(EMPTY_REQUESTS_MESSAGE);
   }
-  const resolved = resolveModel(options.model);
+  const resolved = resolveModel2(options.model);
   if (!IMAGE_PROVIDERS.has(resolved.provider)) {
     throw unsupportedImageProvider(resolved.provider);
   }
@@ -729,13 +742,13 @@ var submitImages = async (options) => {
     metadata: options.metadata,
     modelId: resolved.modelId
   });
-  return new BatchJob(adapter, credentials, snapshot);
+  return new BatchJob2(adapter, credentials, snapshot);
 };
 var submitImageEdits = async (options) => {
   if (options.requests.length === 0) {
-    throw new BatchworkError(EMPTY_REQUESTS_MESSAGE);
+    throw new BatchworkError2(EMPTY_REQUESTS_MESSAGE);
   }
-  const resolved = resolveModel(options.model);
+  const resolved = resolveModel2(options.model);
   if (!IMAGE_EDIT_PROVIDERS.has(resolved.provider)) {
     throw unsupportedImageEditProvider(resolved.provider);
   }
@@ -751,13 +764,13 @@ var submitImageEdits = async (options) => {
     metadata: options.metadata,
     modelId: resolved.modelId
   });
-  return new BatchJob(adapter, credentials, snapshot);
+  return new BatchJob2(adapter, credentials, snapshot);
 };
 var submitModerations = async (options) => {
   if (options.requests.length === 0) {
-    throw new BatchworkError(EMPTY_REQUESTS_MESSAGE);
+    throw new BatchworkError2(EMPTY_REQUESTS_MESSAGE);
   }
-  const resolved = resolveModel(options.model);
+  const resolved = resolveModel2(options.model);
   if (!MODERATION_PROVIDERS.has(resolved.provider)) {
     throw unsupportedModerationProvider(resolved.provider);
   }
@@ -773,13 +786,13 @@ var submitModerations = async (options) => {
     metadata: options.metadata,
     modelId: resolved.modelId
   });
-  return new BatchJob(adapter, credentials, snapshot);
+  return new BatchJob2(adapter, credentials, snapshot);
 };
 var submitTranscriptions = async (options) => {
   if (options.requests.length === 0) {
-    throw new BatchworkError(EMPTY_REQUESTS_MESSAGE);
+    throw new BatchworkError2(EMPTY_REQUESTS_MESSAGE);
   }
-  const resolved = resolveModel(options.model);
+  const resolved = resolveModel2(options.model);
   if (!TRANSCRIPTION_PROVIDERS.has(resolved.provider)) {
     throw unsupportedTranscriptionProvider(resolved.provider);
   }
@@ -795,13 +808,13 @@ var submitTranscriptions = async (options) => {
     metadata: options.metadata,
     modelId: resolved.modelId
   });
-  return new BatchJob(adapter, credentials, snapshot);
+  return new BatchJob2(adapter, credentials, snapshot);
 };
 var submitVideos = async (options) => {
   if (options.requests.length === 0) {
-    throw new BatchworkError(EMPTY_REQUESTS_MESSAGE);
+    throw new BatchworkError2(EMPTY_REQUESTS_MESSAGE);
   }
-  const resolved = resolveModel(options.model);
+  const resolved = resolveModel2(options.model);
   if (!VIDEO_PROVIDERS.has(resolved.provider)) {
     throw unsupportedVideoProvider(resolved.provider);
   }
@@ -817,13 +830,13 @@ var submitVideos = async (options) => {
     metadata: options.metadata,
     modelId: resolved.modelId
   });
-  return new BatchJob(adapter, credentials, snapshot);
+  return new BatchJob2(adapter, credentials, snapshot);
 };
 var submitTranslations = async (options) => {
   if (options.requests.length === 0) {
-    throw new BatchworkError(EMPTY_REQUESTS_MESSAGE);
+    throw new BatchworkError2(EMPTY_REQUESTS_MESSAGE);
   }
-  const resolved = resolveModel(options.model);
+  const resolved = resolveModel2(options.model);
   if (!TRANSLATION_PROVIDERS.has(resolved.provider)) {
     throw unsupportedTranslationProvider(resolved.provider);
   }
@@ -839,9 +852,9 @@ var submitTranslations = async (options) => {
     metadata: options.metadata,
     modelId: resolved.modelId
   });
-  return new BatchJob(adapter, credentials, snapshot);
+  return new BatchJob2(adapter, credentials, snapshot);
 };
-var batch = Object.assign(submitText, {
+var batch2 = Object.assign(submitText, {
   embeddings: submitEmbeddings,
   images: Object.assign(submitImages, {
     create: submitImages,
@@ -853,24 +866,24 @@ var batch = Object.assign(submitText, {
   translations: submitTranslations,
   videos: submitVideos
 });
-var batchEmbeddings = submitEmbeddings;
-var batchImages = submitImages;
-var getBatch = async (ref) => {
+var batchEmbeddings2 = submitEmbeddings;
+var batchImages2 = submitImages;
+var getBatch2 = async (ref) => {
   const adapter = getAdapter(providerFromRef(ref));
   const credentials = pickCredentials(ref);
   const snapshot = await adapter.retrieve(ref.id, credentials);
-  return new BatchJob(adapter, credentials, snapshot);
+  return new BatchJob2(adapter, credentials, snapshot);
 };
-var getBatchResults = (ref) => {
+var getBatchResults2 = (ref) => {
   const adapter = getAdapter(providerFromRef(ref));
   return adapter.results(ref.id, pickCredentials(ref));
 };
-var cancelBatch = async (ref) => {
+var cancelBatch2 = async (ref) => {
   const adapter = getAdapter(providerFromRef(ref));
   await adapter.cancel(ref.id, pickCredentials(ref));
 };
 
-export { resolveModel, batch, batchEmbeddings, batchImages, getBatch, getBatchResults, cancelBatch };
+export { resolveModel2, batch2, batchEmbeddings2, batchImages2, getBatch2, getBatchResults2, cancelBatch2 };
 
-//# debugId=1B451ACF41BE2A3C64756E2164756E21
-//# sourceMappingURL=chunk-2ea62n95.js.map
+//# debugId=555DA8E4F0C86CA964756E2164756E21
+//# sourceMappingURL=chunk-zss8h417.js.map