batchwork 1.4.1 → 1.5.0

package/dist/{chunk-n50t31ca.js → chunk-7y95mhvm.js}

@@ -1,12 +1,25 @@
+import {
+  isBoolean,
+  trimTrailingSlashes,
+  parseJson,
+  asRecord,
+  asString,
+  asNumber,
+  asArray,
+  asNumberArray,
+  omit,
+  toDate
+} from "./chunk-6jgvqdpc.js";
+
 // src/errors.ts
-class BatchworkError extends Error {
+class BatchworkError2 extends Error {
   constructor(message, options) {
     super(message, options);
     this.name = "BatchworkError";
   }
 }
 
-class UnsupportedProviderError extends BatchworkError {
+class UnsupportedProviderError2 extends BatchworkError2 {
   provider;
   constructor(provider, detail) {
     super(detail ?? `batchwork: provider "${provider}" is not supported yet. Supported providers: openai, azure, anthropic, google, groq, mistral, together, xai.`);
@@ -15,7 +28,7 @@ class UnsupportedProviderError extends BatchworkError {
   }
 }
 
-class MissingDependencyError extends BatchworkError {
+class MissingDependencyError2 extends BatchworkError2 {
   constructor(pkg, provider) {
     super(`batchwork: install \`${pkg}\` to batch ${provider} models (\`npm install ${pkg}\`).`);
     this.name = "MissingDependencyError";
@@ -31,16 +44,16 @@ var TERMINAL_STATUSES = new Set([
   "expired",
   "cancelled"
 ]);
-var isTerminalStatus = (status) => TERMINAL_STATUSES.has(status);
+var isTerminalStatus2 = (status) => TERMINAL_STATUSES.has(status);
 var delay = (ms, signal) => new Promise((resolve, reject) => {
   if (signal?.aborted) {
-    reject(new BatchworkError(WAIT_ABORTED_MESSAGE));
+    reject(new BatchworkError2(WAIT_ABORTED_MESSAGE));
     return;
   }
   let timer;
   const onAbort = () => {
     clearTimeout(timer);
-    reject(new BatchworkError(WAIT_ABORTED_MESSAGE));
+    reject(new BatchworkError2(WAIT_ABORTED_MESSAGE));
   };
   timer = setTimeout(() => {
     signal?.removeEventListener("abort", onAbort);
@@ -49,7 +62,7 @@ var delay = (ms, signal) => new Promise((resolve, reject) => {
   signal?.addEventListener("abort", onAbort, { once: true });
 });
 
-class BatchJob {
+class BatchJob2 {
   provider;
   id;
   #adapter;
@@ -80,12 +93,12 @@ class BatchJob {
     const deadline = options.timeoutMs ? Date.now() + options.timeoutMs : undefined;
     let snapshot = await this.poll();
     options.onPoll?.(snapshot);
-    while (!isTerminalStatus(snapshot.status)) {
+    while (!isTerminalStatus2(snapshot.status)) {
       if (options.signal?.aborted) {
-        throw new BatchworkError(WAIT_ABORTED_MESSAGE);
+        throw new BatchworkError2(WAIT_ABORTED_MESSAGE);
       }
       if (deadline !== undefined && Date.now() > deadline) {
-        throw new BatchworkError(`batchwork: timed out waiting for batch "${this.id}".`);
+        throw new BatchworkError2(`batchwork: timed out waiting for batch "${this.id}".`);
       }
       await delay(interval, options.signal);
       snapshot = await this.poll();
@@ -119,7 +132,7 @@ var DEFAULT_LIMITS = {
 var encoder = new TextEncoder;
 var positiveInteger = (name, value) => {
   if (!(Number.isInteger(value) && value > 0)) {
-    throw new BatchworkError(`batchwork: limits.${name} must be a positive integer.`);
+    throw new BatchworkError2(`batchwork: limits.${name} must be a positive integer.`);
   }
   return value;
 };
@@ -132,72 +145,29 @@ var resolveBatchLimits = (limits) => ({
 var byteLength = (value) => encoder.encode(value).length;
 var assertByteCount = (label, bytes, maxBytes) => {
   if (bytes > maxBytes) {
-    throw new BatchworkError(`batchwork: ${label} is ${bytes} bytes, exceeding the ${maxBytes} byte limit.`);
+    throw new BatchworkError2(`batchwork: ${label} is ${bytes} bytes, exceeding the ${maxBytes} byte limit.`);
   }
 };
 var assertByteLength = (label, value, maxBytes) => {
   assertByteCount(label, byteLength(value), maxBytes);
 };
 
-// src/util.ts
-var trimTrailingSlashes = (value) => {
-  let end = value.length;
-  while (end > 0 && value[end - 1] === "/") {
-    end -= 1;
-  }
-  return value.slice(0, end);
-};
-var asRecord = (value) => {
-  if (typeof value === "object" && value !== null) {
-    return value;
-  }
-  return {};
-};
-var asString = (value) => typeof value === "string" ? value : undefined;
-var asNumber = (value) => typeof value === "number" ? value : undefined;
-var asArray = (value) => Array.isArray(value) ? value : [];
-var asNumberArray = (value) => {
-  if (!Array.isArray(value) || value.length === 0) {
-    return;
-  }
-  const numbers = value.filter((item) => typeof item === "number");
-  return numbers.length === value.length ? numbers : undefined;
-};
-var omit = (obj, key) => {
-  const result = {};
-  for (const [k, v] of Object.entries(obj)) {
-    if (k !== key) {
-      result[k] = v;
-    }
-  }
-  return result;
-};
-var validDate = (date) => Number.isNaN(date.getTime()) ? undefined : date;
-var toDate = (value) => {
-  if (typeof value === "string") {
-    return validDate(new Date(value));
-  }
-  if (typeof value === "number") {
-    return validDate(new Date(value * 1000));
-  }
-};
-
 // src/http.ts
 var assertOk = (url, init, response) => {
   if (!response.ok) {
-    throw new BatchworkError(`batchwork: ${init.method ?? "GET"} ${url} failed with ${response.status}.`);
+    throw new BatchworkError2(`batchwork: ${init.method ?? "GET"} ${url} failed with ${response.status}.`);
   }
 };
 var requestJson = async (url, init) => {
   const response = await fetch(url, init);
   assertOk(url, init, response);
-  return await response.json();
+  return parseJson(await response.text());
 };
 var requestStream = async (url, init) => {
   const response = await fetch(url, init);
   assertOk(url, init, response);
   if (!response.body) {
-    throw new BatchworkError(`batchwork: ${url} returned an empty body.`);
+    throw new BatchworkError2(`batchwork: ${url} returned an empty body.`);
   }
   return response.body;
 };
@@ -210,14 +180,14 @@ var NEWLINE_BYTES = byteLength(NEWLINE);
 var resolveMaxLineBytes = (options) => {
   const maxLineBytes = options?.maxLineBytes ?? DEFAULT_MAX_JSONL_LINE_BYTES;
   if (!(Number.isInteger(maxLineBytes) && maxLineBytes > 0)) {
-    throw new BatchworkError("batchwork: JSONL maxLineBytes must be a positive integer.");
+    throw new BatchworkError2("batchwork: JSONL maxLineBytes must be a positive integer.");
   }
   return maxLineBytes;
 };
 var assertLineSize = (line, lineNumber, maxLineBytes) => {
   const bytes = byteLength(line);
   if (bytes > maxLineBytes) {
-    throw new BatchworkError(`batchwork: JSONL line ${lineNumber} is ${bytes} bytes, exceeding the ${maxLineBytes} byte limit.`);
+    throw new BatchworkError2(`batchwork: JSONL line ${lineNumber} is ${bytes} bytes, exceeding the ${maxLineBytes} byte limit.`);
   }
 };
 var parseLine = (line, lineNumber, maxLineBytes) => {
@@ -227,15 +197,15 @@ var parseLine = (line, lineNumber, maxLineBytes) => {
     return;
   }
   try {
-    return JSON.parse(trimmed);
+    return parseJson(trimmed);
   } catch (error) {
-    throw new BatchworkError(`batchwork: invalid JSONL at line ${lineNumber}.`, { cause: error });
+    throw new BatchworkError2(`batchwork: invalid JSONL at line ${lineNumber}.`, { cause: error });
   }
 };
 var resolveMaxBytes = (options) => {
   const maxBytes = options?.maxBytes;
   if (maxBytes !== undefined && !(Number.isInteger(maxBytes) && maxBytes > 0)) {
-    throw new BatchworkError("batchwork: JSONL maxBytes must be a positive integer.");
+    throw new BatchworkError2("batchwork: JSONL maxBytes must be a positive integer.");
   }
   return maxBytes;
 };
@@ -250,7 +220,7 @@ var encodeJsonl = (items, options) => {
   for (const item of items) {
     const line = JSON.stringify(item);
     if (line === undefined) {
-      throw new BatchworkError(`batchwork: ${label} contains a value that cannot be JSON encoded.`);
+      throw new BatchworkError2(`batchwork: ${label} contains a value that cannot be JSON encoded.`);
     }
     bytes += byteLength(line) + NEWLINE_BYTES;
     if (maxBytes !== undefined) {
@@ -290,9 +260,9 @@ async function* streamJsonl(source, options) {
     while (newlineIndex !== -1) {
       const line = buffer.slice(0, newlineIndex);
       buffer = buffer.slice(newlineIndex + 1);
-      const parsed2 = parseLine(line, lineNumber, maxLineBytes);
-      if (parsed2 !== undefined) {
-        yield parsed2;
+      const parsed = parseLine(line, lineNumber, maxLineBytes);
+      if (parsed !== undefined) {
+        yield parsed;
       }
       lineNumber += 1;
       newlineIndex = buffer.indexOf(NEWLINE);
@@ -320,7 +290,7 @@ var encodeJsonArrayPayload = ({
   for (const [index, item] of items.entries()) {
     const encoded = JSON.stringify(item);
     if (encoded === undefined) {
-      throw new BatchworkError(`batchwork: ${label} contains a value that cannot be JSON encoded.`);
+      throw new BatchworkError2(`batchwork: ${label} contains a value that cannot be JSON encoded.`);
     }
     bytes += byteLength(encoded);
     if (index > 0) {
@@ -336,14 +306,14 @@ var encodeJsonArrayPayload = ({
 var SIMPLE_PROVIDER_ID = /^[A-Za-z0-9_-]+$/u;
 var assertSimpleProviderId = (label, id) => {
   if (!SIMPLE_PROVIDER_ID.test(id)) {
-    throw new BatchworkError(`batchwork: invalid ${label}.`);
+    throw new BatchworkError2(`batchwork: invalid ${label}.`);
   }
   return id;
 };
 var assertPrefixedProviderId = (label, id, prefix) => {
   const [actualPrefix, value, ...rest] = id.split("/");
   if (rest.length > 0 || actualPrefix !== prefix || !value || !SIMPLE_PROVIDER_ID.test(value)) {
-    throw new BatchworkError(`batchwork: invalid ${label}.`);
+    throw new BatchworkError2(`batchwork: invalid ${label}.`);
   }
   return id;
 };
@@ -354,7 +324,7 @@ var ANTHROPIC_VERSION = "2023-06-01";
 var apiKey = (credentials) => {
   const key = credentials.apiKey ?? process.env.ANTHROPIC_API_KEY;
   if (!key) {
-    throw new BatchworkError("batchwork: missing Anthropic API key. Set ANTHROPIC_API_KEY or pass `apiKey`.");
+    throw new BatchworkError2("batchwork: missing Anthropic API key. Set ANTHROPIC_API_KEY or pass `apiKey`.");
   }
   return key;
 };
@@ -366,15 +336,15 @@ var validateResultsUrl = (rawUrl, credentials) => {
     resultsUrl = new URL(rawUrl);
     expectedBase = new URL(baseUrl(credentials));
   } catch (error) {
-    throw new BatchworkError("batchwork: invalid Anthropic results_url.", {
+    throw new BatchworkError2("batchwork: invalid Anthropic results_url.", {
       cause: error
     });
   }
   if (resultsUrl.origin !== expectedBase.origin) {
-    throw new BatchworkError("batchwork: Anthropic results_url must match the configured API origin.");
+    throw new BatchworkError2("batchwork: Anthropic results_url must match the configured API origin.");
   }
   if (resultsUrl.username || resultsUrl.password) {
-    throw new BatchworkError("batchwork: Anthropic results_url must not include credentials.");
+    throw new BatchworkError2("batchwork: Anthropic results_url must not include credentials.");
   }
   return resultsUrl.toString();
 };
@@ -504,7 +474,7 @@ async function* results(id, credentials) {
   const snapshot = await retrieve(id, credentials);
   const resultsUrl = asString(asRecord(snapshot.raw).results_url);
   if (!resultsUrl) {
-    throw new BatchworkError(`batchwork: results are not ready for batch "${id}" (status: ${snapshot.status}).`);
+    throw new BatchworkError2(`batchwork: results are not ready for batch "${id}" (status: ${snapshot.status}).`);
   }
   const stream = await requestStream(validateResultsUrl(resultsUrl, credentials), {
     headers: headers(credentials),
@@ -535,7 +505,7 @@ var HTTP_OK_MAX = 300;
 var resolveApiKey = (credentials, envVar, label) => {
   const key = credentials.apiKey ?? process.env[envVar];
   if (!key) {
-    throw new BatchworkError(`batchwork: missing ${label} API key. Set ${envVar} or pass \`apiKey\`.`);
+    throw new BatchworkError2(`batchwork: missing ${label} API key. Set ${envVar} or pass \`apiKey\`.`);
   }
   return key;
 };
@@ -612,14 +582,14 @@ var imagesFromBody = (body) => {
   return images.length > 0 ? images : undefined;
 };
 var moderationFromBody = (body) => {
-  const results2 = asArray(asRecord(body).results);
-  if (results2.length === 0) {
+  const results = asArray(asRecord(body).results);
+  if (results.length === 0) {
     return;
   }
-  const first = asRecord(results2[0]);
+  const first = asRecord(results[0]);
   const categories = {};
   for (const [key, value] of Object.entries(asRecord(first.categories))) {
-    if (typeof value === "boolean") {
+    if (isBoolean(value)) {
       categories[key] = value;
     }
   }
@@ -633,7 +603,7 @@ var moderationFromBody = (body) => {
       categoryScores[key] = score;
     }
   }
-  const flagged = typeof first.flagged === "boolean" ? first.flagged : Object.values(categories).some(Boolean);
+  const flagged = isBoolean(first.flagged) ? first.flagged : Object.values(categories).some(Boolean);
   return { categories, categoryScores, flagged };
 };
 var usageFromBody = (body) => {
@@ -693,24 +663,28 @@ var normalizeOpenAIResult = (line) => {
     status: "errored"
   };
 };
-var uploadInputFile = async (jsonl, baseUrl2, headers2, options = {}) => {
+var uploadInputFile = async (jsonl, baseUrl, headers, options = {}) => {
   const form = new FormData;
   const purpose = options.purpose === undefined ? "batch" : options.purpose;
   if (purpose !== null) {
     form.append("purpose", purpose);
   }
   form.append("file", new Blob([jsonl], { type: "application/jsonl" }), "batchwork.jsonl");
-  const raw = await requestJson(`${baseUrl2}/files`, {
+  const raw = await requestJson(`${baseUrl}/files`, {
     body: form,
-    headers: headers2,
+    headers,
     method: "POST",
     redirect: "manual"
   });
-  return raw.id;
+  const id = asString(asRecord(raw).id);
+  if (!id) {
+    throw new BatchworkError2("batchwork: the file upload response carried no file id.");
+  }
+  return id;
 };
-async function* streamResultFile(fileId, baseUrl2, headers2) {
-  const stream = await requestStream(`${baseUrl2}/files/${fileId}/content`, {
-    headers: headers2,
+async function* streamResultFile(fileId, baseUrl, headers) {
+  const stream = await requestStream(`${baseUrl}/files/${fileId}/content`, {
+    headers,
     redirect: "manual"
   });
   for await (const line of streamJsonl(stream)) {
@@ -761,8 +735,8 @@ var normalizeSnapshot2 = (raw, provider) => {
 var createOpenAICompatibleAdapter = (config) => {
   const completionWindow = config.completionWindow ?? DEFAULT_COMPLETION_WINDOW;
   const lineFormat = config.lineFormat ?? "method-url";
-  const baseUrl2 = (credentials) => config.resolveBaseUrl?.(credentials) ?? credentials.baseURL ?? config.baseUrl ?? (() => {
-    throw new BatchworkError(`batchwork: missing ${config.apiKeyLabel} base URL. Pass \`baseURL\`.`);
+  const baseUrl = (credentials) => config.resolveBaseUrl?.(credentials) ?? credentials.baseURL ?? config.baseUrl ?? (() => {
+    throw new BatchworkError2(`batchwork: missing ${config.apiKeyLabel} base URL. Pass \`baseURL\`.`);
   })();
   const authHeaders = (credentials) => ({
     ...config.authHeaders ? config.authHeaders(credentials) : {
@@ -770,7 +744,7 @@ var createOpenAICompatibleAdapter = (config) => {
     },
     ...credentials.headers
   });
-  const submit2 = async (input) => {
+  const submit = async (input) => {
     const limits = resolveBatchLimits(input.limits);
     const endpoint = config.normalizeEndpoint ? config.normalizeEndpoint(input.endpoint) : input.endpoint;
     const batchEndpoint = config.batchEndpoint?.(endpoint) ?? endpoint;
@@ -790,10 +764,10 @@ var createOpenAICompatibleAdapter = (config) => {
         url: endpoint
       };
     }), { label: "batch upload JSONL", maxBytes: limits.maxUploadBytes });
-    const headers2 = authHeaders(input.credentials);
-    const url = baseUrl2(input.credentials);
+    const headers = authHeaders(input.credentials);
+    const url = baseUrl(input.credentials);
     const purpose = config.filePurpose ?? "batch";
-    const inputFileId = await (config.uploadFile ? config.uploadFile({ baseUrl: url, headers: headers2, jsonl, purpose }) : uploadInputFile(jsonl, url, headers2, { purpose }));
+    const inputFileId = await (config.uploadFile ? config.uploadFile({ baseUrl: url, headers, jsonl, purpose }) : uploadInputFile(jsonl, url, headers, { purpose }));
     const raw = await requestJson(`${url}/batches`, {
       body: JSON.stringify({
         completion_window: completionWindow,
@@ -801,42 +775,42 @@ var createOpenAICompatibleAdapter = (config) => {
         input_file_id: inputFileId,
         metadata: input.metadata
       }),
-      headers: { ...headers2, "content-type": "application/json" },
+      headers: { ...headers, "content-type": "application/json" },
       method: "POST"
     });
     return normalizeSnapshot2(raw, config.id);
   };
-  const retrieve2 = async (id, credentials) => {
+  const retrieve = async (id, credentials) => {
     const batchId = assertSimpleProviderId(`${config.id} batch id`, id);
-    const raw = await requestJson(`${baseUrl2(credentials)}/batches/${batchId}`, {
+    const raw = await requestJson(`${baseUrl(credentials)}/batches/${batchId}`, {
       headers: authHeaders(credentials)
     });
     return normalizeSnapshot2(raw, config.id);
   };
-  async function* results2(id, credentials) {
-    const snapshot = await retrieve2(id, credentials);
+  async function* results(id, credentials) {
+    const snapshot = await retrieve(id, credentials);
     const raw = asRecord(snapshot.raw);
     const outputFileId = asString(raw.output_file_id);
     const errorFileId = asString(raw.error_file_id);
     if (!(outputFileId || errorFileId)) {
-      throw new BatchworkError(`batchwork: results are not ready for batch "${id}" (status: ${snapshot.status}).`);
+      throw new BatchworkError2(`batchwork: results are not ready for batch "${id}" (status: ${snapshot.status}).`);
     }
-    const headers2 = authHeaders(credentials);
+    const headers = authHeaders(credentials);
     if (outputFileId) {
-      yield* streamResultFile(assertSimpleProviderId(`${config.id} output file id`, outputFileId), baseUrl2(credentials), headers2);
+      yield* streamResultFile(assertSimpleProviderId(`${config.id} output file id`, outputFileId), baseUrl(credentials), headers);
     }
     if (errorFileId) {
-      yield* streamResultFile(assertSimpleProviderId(`${config.id} error file id`, errorFileId), baseUrl2(credentials), headers2);
+      yield* streamResultFile(assertSimpleProviderId(`${config.id} error file id`, errorFileId), baseUrl(credentials), headers);
     }
   }
-  const cancel2 = async (id, credentials) => {
+  const cancel = async (id, credentials) => {
     const batchId = assertSimpleProviderId(`${config.id} batch id`, id);
-    await requestJson(`${baseUrl2(credentials)}/batches/${batchId}/cancel`, {
+    await requestJson(`${baseUrl(credentials)}/batches/${batchId}/cancel`, {
       headers: authHeaders(credentials),
       method: "POST"
     });
   };
-  return { cancel: cancel2, id: config.id, results: results2, retrieve: retrieve2, submit: submit2 };
+  return { cancel, id: config.id, results, retrieve, submit };
 };
 
 // src/providers/azure.ts
@@ -850,7 +824,7 @@ var isAzureOpenAIUrl = (value) => {
 var baseUrl2 = (credentials) => {
   const configured = credentials.baseURL ?? (process.env.AZURE_RESOURCE_NAME ? `https://${process.env.AZURE_RESOURCE_NAME}.openai.azure.com/openai` : undefined);
   if (!configured) {
-    throw new BatchworkError("batchwork: missing Azure OpenAI resource. Set AZURE_RESOURCE_NAME or pass `baseURL`.");
+    throw new BatchworkError2("batchwork: missing Azure OpenAI resource. Set AZURE_RESOURCE_NAME or pass `baseURL`.");
   }
   const normalized = trimTrailingSlashes(configured);
   if (!isAzureOpenAIUrl(normalized)) {
@@ -861,7 +835,7 @@ var baseUrl2 = (credentials) => {
   }
   return normalized.endsWith("/openai") ? `${normalized}/v1` : `${normalized}/openai/v1`;
 };
-var hasCallerAuth = (headers2) => Object.keys(headers2 ?? {}).some((name) => {
+var hasCallerAuth = (headers) => Object.keys(headers ?? {}).some((name) => {
   const normalized = name.toLowerCase();
   return normalized === "api-key" || normalized === "authorization";
 });
@@ -872,11 +846,11 @@ var authHeaders = (credentials) => {
   if (hasCallerAuth(credentials.headers)) {
     return {};
   }
-  const apiKey2 = process.env.AZURE_API_KEY ?? process.env.AZURE_OPENAI_API_KEY;
-  if (apiKey2) {
-    return { "api-key": apiKey2 };
+  const apiKey = process.env.AZURE_API_KEY ?? process.env.AZURE_OPENAI_API_KEY;
+  if (apiKey) {
+    return { "api-key": apiKey };
   }
-  throw new BatchworkError("batchwork: missing Azure OpenAI API key. Set AZURE_API_KEY or pass `apiKey`.");
+  throw new BatchworkError2("batchwork: missing Azure OpenAI API key. Set AZURE_API_KEY or pass `apiKey`.");
 };
 var azureAdapter = createOpenAICompatibleAdapter({
   apiKeyEnv: "AZURE_API_KEY",
@@ -895,7 +869,7 @@ var GOOGLE_BATCH_PREFIX = "batches";
 var apiKey2 = (credentials) => {
   const key = credentials.apiKey ?? process.env.GOOGLE_GENERATIVE_AI_API_KEY ?? process.env.GEMINI_API_KEY;
   if (!key) {
-    throw new BatchworkError("batchwork: missing Google Gemini API key. Set GOOGLE_GENERATIVE_AI_API_KEY (or GEMINI_API_KEY) or pass `apiKey`.");
+    throw new BatchworkError2("batchwork: missing Google Gemini API key. Set GOOGLE_GENERATIVE_AI_API_KEY (or GEMINI_API_KEY) or pass `apiKey`.");
   }
   return key;
 };
@@ -1082,11 +1056,11 @@ async function* results2(id, credentials) {
   const dest = asRecord(raw.dest);
   const responsesFile = fileNameFrom(response.responsesFile) ?? fileNameFrom(response.responses_file) ?? asString(dest.fileName) ?? asString(dest.file_name);
   if (responsesFile) {
-    throw new BatchworkError(`batchwork: batch "${id}" returned file-mode results, which are not supported yet.`);
+    throw new BatchworkError2(`batchwork: batch "${id}" returned file-mode results, which are not supported yet.`);
   }
   const items = inlinedResponses(raw);
   if (items.length === 0) {
-    throw new BatchworkError(`batchwork: results are not ready for batch "${id}" (status: ${snapshot.status}).`);
+    throw new BatchworkError2(`batchwork: results are not ready for batch "${id}" (status: ${snapshot.status}).`);
   }
   for (const item of items) {
     yield normalizeResult2(item);
@@ -1204,15 +1178,15 @@ async function* results3(id, credentials) {
   const raw = asRecord(snapshot.raw);
   const outputFileId = asString(raw.output_file);
   const errorFileId = asString(raw.error_file);
-  const headers3 = authHeaders2(credentials);
+  const headers = authHeaders2(credentials);
   if (outputFileId) {
-    yield* streamResultFile(assertSimpleProviderId("Mistral output file id", outputFileId), baseUrl4(credentials), headers3);
+    yield* streamResultFile(assertSimpleProviderId("Mistral output file id", outputFileId), baseUrl4(credentials), headers);
   }
   if (errorFileId) {
-    yield* streamResultFile(assertSimpleProviderId("Mistral error file id", errorFileId), baseUrl4(credentials), headers3);
+    yield* streamResultFile(assertSimpleProviderId("Mistral error file id", errorFileId), baseUrl4(credentials), headers);
   }
   if (!(outputFileId || errorFileId)) {
-    throw new BatchworkError(`batchwork: results are not ready for batch "${id}" (status: ${snapshot.status}).`);
+    throw new BatchworkError2(`batchwork: results are not ready for batch "${id}" (status: ${snapshot.status}).`);
   }
 }
 var cancel3 = async (id, credentials) => {
@@ -1298,16 +1272,16 @@ var validateUploadLocation = (location) => {
   try {
     url = new URL(location);
   } catch (error) {
-    throw new BatchworkError("batchwork: Together upload Location must be a valid URL.", { cause: error });
+    throw new BatchworkError2("batchwork: Together upload Location must be a valid URL.", { cause: error });
   }
   if (url.protocol !== "https:") {
-    throw new BatchworkError("batchwork: Together upload Location must use https.");
+    throw new BatchworkError2("batchwork: Together upload Location must use https.");
   }
   if (url.username || url.password) {
-    throw new BatchworkError("batchwork: Together upload Location must not include credentials.");
+    throw new BatchworkError2("batchwork: Together upload Location must not include credentials.");
   }
   if (isPrivateHost(url.hostname.toLowerCase())) {
-    throw new BatchworkError("batchwork: Together upload Location must not target localhost or private networks.");
+    throw new BatchworkError2("batchwork: Together upload Location must not target localhost or private networks.");
   }
   return url.toString();
 };
@@ -1325,7 +1299,7 @@ var uploadTogetherFile = async (args) => {
   const location = init.headers.get("location");
   const fileId = init.headers.get("x-together-file-id");
   if (init.status !== HTTP_FOUND || !(location && fileId)) {
-    throw new BatchworkError(`batchwork: Together upload could not be initiated (${init.status}).`);
+    throw new BatchworkError2(`batchwork: Together upload could not be initiated (${init.status}).`);
   }
   const uploadLocation = validateUploadLocation(location);
   const upload = await fetch(uploadLocation, {
@@ -1334,7 +1308,7 @@ var uploadTogetherFile = async (args) => {
     redirect: "manual"
   });
   if (!upload.ok) {
-    throw new BatchworkError(`batchwork: Together file upload failed (${upload.status}).`);
+    throw new BatchworkError2(`batchwork: Together file upload failed (${upload.status}).`);
   }
   const safeFileId = assertSimpleProviderId("Together file id", fileId);
   await requestJson(`${args.baseUrl}/files/${safeFileId}/preprocess`, {
@@ -1413,10 +1387,14 @@ var imagesFromXaiCompletion = (completion) => {
     const data = asString(record.base64) ?? asString(record.b64_json);
     const url = asString(record.url);
     if (data || url) {
-      images.push({
-        ...data ? { data } : {},
-        ...url ? { url } : {}
-      });
+      const image = {};
+      if (data) {
+        image.data = data;
+      }
+      if (url) {
+        image.url = url;
+      }
+      images.push(image);
     }
   }
   return images.length > 0 ? images : undefined;
@@ -1431,11 +1409,12 @@ var videosFromXaiCompletion = (completion) => {
     const video = asRecord(record.video);
     const url = asString(video.url) ?? asString(record.url);
     if (url) {
+      const entry = { url };
       const duration = asNumber(video.duration) ?? asNumber(record.duration);
-      videos.push({
-        ...duration === undefined ? {} : { durationSeconds: duration },
-        url
-      });
+      if (duration !== undefined) {
+        entry.durationSeconds = duration;
+      }
+      videos.push(entry);
     }
   }
   return videos.length > 0 ? videos : undefined;
@@ -1498,16 +1477,16 @@ var retrieve4 = async (id, credentials) => {
 };
 async function* results4(id, credentials) {
   const batchId = assertSimpleProviderId(BATCH_ID_LABEL, id);
-  const headers3 = authHeaders3(credentials);
+  const headers = authHeaders3(credentials);
   let token;
   do {
     const query = new URLSearchParams({ limit: String(RESULTS_PAGE_SIZE) });
     if (token) {
       query.set("pagination_token", token);
     }
-    const raw = await requestJson(`${baseUrl5(credentials)}/batches/${batchId}/results?${query.toString()}`, { headers: headers3 });
+    const raw = await requestJson(`${baseUrl5(credentials)}/batches/${batchId}/results?${query.toString()}`, { headers });
     const page = asRecord(raw);
-    for (const item of Array.isArray(page.results) ? page.results : []) {
+    for (const item of asArray(page.results)) {
       yield normalizeResult3(item);
     }
     token = asString(page.pagination_token);
@@ -1541,7 +1520,7 @@ var adapters = {
 };
 var getAdapter = (provider) => adapters[provider];
 
-export { BatchworkError, UnsupportedProviderError, MissingDependencyError, resolveBatchLimits, assertByteLength, trimTrailingSlashes, isTerminalStatus, BatchJob, getAdapter };
+export { BatchworkError2, UnsupportedProviderError2, MissingDependencyError2, resolveBatchLimits, assertByteLength, isTerminalStatus2, BatchJob2, getAdapter };
 
-//# debugId=C29D2DE3DBB0695664756E2164756E21
-//# sourceMappingURL=chunk-n50t31ca.js.map
+//# debugId=7B0EC738FEADB97E64756E2164756E21
+//# sourceMappingURL=chunk-7y95mhvm.js.map