batchwork 1.0.1 → 1.2.0

package/dist/{chunk-g481f961.js → chunk-h2he3d16.js}

@@ -8,8 +8,8 @@ class BatchworkError extends Error {
 
 class UnsupportedProviderError extends BatchworkError {
   provider;
-  constructor(provider) {
-    super(`batchwork: provider "${provider}" is not supported yet. Supported providers: openai, anthropic, google, groq, mistral, together, xai.`);
+  constructor(provider, detail) {
+    super(detail ?? `batchwork: provider "${provider}" is not supported yet. Supported providers: openai, anthropic, google, groq, mistral, together, xai.`);
     this.name = "UnsupportedProviderError";
     this.provider = provider;
   }
@@ -36,11 +36,16 @@ var delay = (ms, signal) => new Promise((resolve, reject) => {
     reject(new BatchworkError("batchwork: wait aborted."));
     return;
   }
-  const timer = setTimeout(resolve, ms);
-  signal?.addEventListener("abort", () => {
+  let timer;
+  const onAbort = () => {
     clearTimeout(timer);
     reject(new BatchworkError("batchwork: wait aborted."));
-  }, { once: true });
+  };
+  timer = setTimeout(() => {
+    signal?.removeEventListener("abort", onAbort);
+    resolve();
+  }, ms);
+  signal?.addEventListener("abort", onAbort, { once: true });
 });
 
 class BatchJob {
@@ -124,12 +129,14 @@ var resolveBatchLimits = (limits) => ({
   maxUploadBytes: positiveInteger("maxUploadBytes", limits?.maxUploadBytes ?? DEFAULT_LIMITS.maxUploadBytes)
 });
 var byteLength = (value) => encoder.encode(value).length;
-var assertByteLength = (label, value, maxBytes) => {
-  const bytes = byteLength(value);
+var assertByteCount = (label, bytes, maxBytes) => {
   if (bytes > maxBytes) {
     throw new BatchworkError(`batchwork: ${label} is ${bytes} bytes, exceeding the ${maxBytes} byte limit.`);
   }
 };
+var assertByteLength = (label, value, maxBytes) => {
+  assertByteCount(label, byteLength(value), maxBytes);
+};
 var mapWithConcurrency = async (items, concurrency, mapper) => {
   const results = [];
   results.length = items.length;
@@ -172,6 +179,7 @@ var requestStream = async (url, init) => {
 var NEWLINE = `
 `;
 var DEFAULT_MAX_JSONL_LINE_BYTES = 20 * 1024 * 1024;
+var NEWLINE_BYTES = byteLength(NEWLINE);
 var resolveMaxLineBytes = (options) => {
   const maxLineBytes = options?.maxLineBytes ?? DEFAULT_MAX_JSONL_LINE_BYTES;
   if (!(Number.isInteger(maxLineBytes) && maxLineBytes > 0)) {
@@ -197,12 +205,33 @@ var parseLine = (line, lineNumber, maxLineBytes) => {
     throw new BatchworkError(`batchwork: invalid JSONL at line ${lineNumber}.`, { cause: error });
   }
 };
-var encodeJsonl = (items) => {
+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.");
+  }
+  return maxBytes;
+};
+var encodeJsonl = (items, options) => {
   if (items.length === 0) {
     return "";
   }
-  const body = items.map((item) => JSON.stringify(item)).join(NEWLINE);
-  return `${body}${NEWLINE}`;
+  const lines = [];
+  const maxBytes = resolveMaxBytes(options);
+  const label = options?.label ?? "JSONL";
+  let bytes = 0;
+  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.`);
+    }
+    bytes += byteLength(line) + NEWLINE_BYTES;
+    if (maxBytes !== undefined) {
+      assertByteCount(label, bytes, maxBytes);
+    }
+    lines.push(line);
+  }
+  return `${lines.join(NEWLINE)}${NEWLINE}`;
 };
 var isReadableStream = (source) => ("getReader" in source) && typeof source.getReader === "function";
 async function* toByteIterable(source) {
@@ -250,6 +279,32 @@ async function* streamJsonl(source, options) {
   }
 }
 
+// src/payload.ts
+var encodeJsonArrayPayload = ({
+  items,
+  label,
+  maxBytes,
+  prefix,
+  suffix
+}) => {
+  const encodedItems = [];
+  let bytes = byteLength(prefix) + byteLength(suffix);
+  assertByteCount(label, bytes, maxBytes);
+  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.`);
+    }
+    bytes += byteLength(encoded);
+    if (index > 0) {
+      bytes += 1;
+    }
+    assertByteCount(label, bytes, maxBytes);
+    encodedItems.push(encoded);
+  }
+  return `${prefix}${encodedItems.join(",")}${suffix}`;
+};
+
 // src/util.ts
 var asRecord = (value) => {
   if (typeof value === "object" && value !== null) {
@@ -260,6 +315,13 @@ var asRecord = (value) => {
 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)) {
@@ -269,12 +331,13 @@ var omit = (obj, key) => {
   }
   return result;
 };
+var validDate = (date) => Number.isNaN(date.getTime()) ? undefined : date;
 var toDate = (value) => {
   if (typeof value === "string") {
-    return new Date(value);
+    return validDate(new Date(value));
   }
   if (typeof value === "number") {
-    return new Date(value * 1000);
+    return validDate(new Date(value * 1000));
   }
 };
 
@@ -421,8 +484,13 @@ var submit = async (input) => {
     custom_id: item.customId,
     params: omit(item.body, "stream")
   }));
-  const body = JSON.stringify({ requests });
-  assertByteLength("batch upload payload", body, limits.maxUploadBytes);
+  const body = encodeJsonArrayPayload({
+    items: requests,
+    label: "batch upload payload",
+    maxBytes: limits.maxUploadBytes,
+    prefix: '{"requests":[',
+    suffix: "]}"
+  });
   const raw = await requestJson(`${baseUrl(input.credentials)}/v1/messages/batches`, {
     body,
     headers: headers(input.credentials),
@@ -442,7 +510,8 @@ async function* results(id, credentials) {
     throw new BatchworkError(`batchwork: results are not ready for batch "${id}" (status: ${snapshot.status}).`);
   }
   const stream = await requestStream(validateResultsUrl(resultsUrl, credentials), {
-    headers: headers(credentials)
+    headers: headers(credentials),
+    redirect: "manual"
   });
   for await (const line of streamJsonl(stream)) {
     yield normalizeResult(line);
@@ -541,6 +610,21 @@ var textFromResponse = (response) => {
   const text = asArray(asRecord(candidate.content).parts).map((part) => asString(asRecord(part).text) ?? "").join("");
   return text.length > 0 ? text : undefined;
 };
+var embeddingFromResponse = (response) => asNumberArray(asRecord(asRecord(response).embedding).values);
+var imagesFromResponse = (response) => {
+  const candidate = asRecord(asArray(asRecord(response).candidates)[0]);
+  const images = [];
+  for (const part of asArray(asRecord(candidate.content).parts)) {
+    const partObj = asRecord(part);
+    const inline = asRecord(partObj.inlineData ?? partObj.inline_data);
+    const data = asString(inline.data);
+    const mediaType = asString(inline.mimeType) ?? asString(inline.mime_type);
+    if (data && mediaType?.startsWith("image/")) {
+      images.push({ data, mediaType });
+    }
+  }
+  return images.length > 0 ? images : undefined;
+};
 var usageFromResponse = (response) => {
   const usage = asRecord(asRecord(response).usageMetadata);
   const inputTokens = asNumber(usage.promptTokenCount);
@@ -573,26 +657,53 @@ var normalizeResult2 = (item) => {
   }
   return {
     customId,
+    embedding: embeddingFromResponse(obj.response),
+    images: imagesFromResponse(obj.response),
     response: obj.response,
     status: "succeeded",
     text: textFromResponse(obj.response),
     usage: usageFromResponse(obj.response)
   };
 };
+var EMBED_CONFIG_KEYS = new Set([
+  "outputDimensionality",
+  "taskType",
+  "title"
+]);
+var toEmbedRequest = (body) => {
+  const request = {};
+  const config = {};
+  for (const [key, value] of Object.entries(body)) {
+    if (EMBED_CONFIG_KEYS.has(key)) {
+      config[key] = value;
+    } else {
+      request[key] = value;
+    }
+  }
+  if (Object.keys(config).length > 0) {
+    request.embedContentConfig = config;
+  }
+  return request;
+};
 var submit2 = async (input) => {
   const limits = resolveBatchLimits(input.limits);
-  const requests = input.built.map((item) => ({
-    metadata: { key: item.customId },
-    request: omit(item.body, "stream")
-  }));
-  const body = JSON.stringify({
-    batch: {
-      display_name: "batchwork",
-      input_config: { requests: { requests } }
-    }
+  const isEmbedding = input.endpoint.toLowerCase().includes("embedcontent");
+  const method = isEmbedding ? "asyncBatchEmbedContent" : "batchGenerateContent";
+  const requests = input.built.map((item) => {
+    const payload = omit(item.body, "stream");
+    return {
+      metadata: { key: item.customId },
+      request: isEmbedding ? toEmbedRequest(payload) : payload
+    };
+  });
+  const body = encodeJsonArrayPayload({
+    items: requests,
+    label: "batch upload payload",
+    maxBytes: limits.maxUploadBytes,
+    prefix: '{"batch":{"display_name":"batchwork","input_config":{"requests":{"requests":[',
+    suffix: "]}}}}"
   });
-  assertByteLength("batch upload payload", body, limits.maxUploadBytes);
-  const raw = await requestJson(`${baseUrl2(input.credentials)}/models/${input.modelId}:batchGenerateContent`, {
+  const raw = await requestJson(`${baseUrl2(input.credentials)}/models/${input.modelId}:${method}`, {
     body,
     headers: headers2(input.credentials),
     method: "POST"
@@ -659,6 +770,25 @@ var textFromBody = (body) => {
   }
   return asString(obj.output_text);
 };
+var embeddingFromBody = (body) => {
+  const data = asArray(asRecord(body).data);
+  if (data.length === 0) {
+    return;
+  }
+  return asNumberArray(asRecord(data[0]).embedding);
+};
+var imagesFromBody = (body) => {
+  const obj = asRecord(body);
+  const mediaType = `image/${asString(obj.output_format) ?? "png"}`;
+  const images = [];
+  for (const item of asArray(obj.data)) {
+    const b64 = asString(asRecord(item).b64_json);
+    if (b64) {
+      images.push({ data: b64, mediaType });
+    }
+  }
+  return images.length > 0 ? images : undefined;
+};
 var usageFromBody = (body) => {
   const usage = asRecord(asRecord(body).usage);
   const inputTokens = asNumber(usage.prompt_tokens) ?? asNumber(usage.input_tokens);
@@ -699,6 +829,8 @@ var normalizeOpenAIResult = (line) => {
   if (statusCode >= HTTP_OK_MIN && statusCode < HTTP_OK_MAX) {
     return {
       customId,
+      embedding: embeddingFromBody(response.body),
+      images: imagesFromBody(response.body),
       response: response.body,
       status: "succeeded",
       text: textFromBody(response.body),
@@ -722,13 +854,15 @@ var uploadInputFile = async (jsonl, baseUrl3, headers3, options = {}) => {
   const raw = await requestJson(`${baseUrl3}/files`, {
     body: form,
     headers: headers3,
-    method: "POST"
+    method: "POST",
+    redirect: "manual"
   });
   return raw.id;
 };
 async function* streamResultFile(fileId, baseUrl3, headers3) {
   const stream = await requestStream(`${baseUrl3}/files/${fileId}/content`, {
-    headers: headers3
+    headers: headers3,
+    redirect: "manual"
   });
   for await (const line of streamJsonl(stream)) {
     yield normalizeOpenAIResult(line);
@@ -797,8 +931,7 @@ var createOpenAICompatibleAdapter = (config) => {
         method: "POST",
         url: endpoint
       };
-    }));
-    assertByteLength("batch upload JSONL", jsonl, limits.maxUploadBytes);
+    }), { label: "batch upload JSONL", maxBytes: limits.maxUploadBytes });
     const headers3 = authHeaders(input.credentials);
     const url = baseUrl3(input.credentials);
     const purpose = config.filePurpose ?? "batch";
@@ -915,8 +1048,7 @@ var submit3 = async (input) => {
   const jsonl = encodeJsonl(input.built.map((item) => ({
     body: omit(omit(item.body, "stream"), "model"),
     custom_id: item.customId
-  })));
-  assertByteLength("batch upload JSONL", jsonl, limits.maxUploadBytes);
+  })), { label: "batch upload JSONL", maxBytes: limits.maxUploadBytes });
   const inputFileId = await uploadInputFile(jsonl, baseUrl3(input.credentials), authHeaders(input.credentials));
   const raw = await requestJson(`${baseUrl3(input.credentials)}/batch/jobs`, {
     body: JSON.stringify({
@@ -997,6 +1129,9 @@ var isPrivateIpv4 = (parts) => {
 };
 var isPrivateIpv6 = (host) => {
   const normalized = host.replace(/^\[/u, "").replace(/\]$/u, "").toLowerCase();
+  if (!normalized.includes(":")) {
+    return false;
+  }
   return normalized === "::" || normalized === "::1" || normalized.startsWith("fc") || normalized.startsWith("fd") || normalized.startsWith("fe80:");
 };
 var validateUploadLocation = (location) => {
@@ -1038,7 +1173,8 @@ var uploadTogetherFile = async (args) => {
   const uploadLocation = validateUploadLocation(location);
   const upload = await fetch(uploadLocation, {
     body: args.jsonl,
-    method: "PUT"
+    method: "PUT",
+    redirect: "manual"
   });
   if (!upload.ok) {
     throw new BatchworkError(`batchwork: Together file upload failed (${upload.status}).`);
@@ -1092,7 +1228,7 @@ var normalizeSnapshot5 = (raw) => {
   const state = asRecord(obj.state);
   const id = asString(obj.batch_id) ?? asString(obj.id) ?? "";
   return {
-    completedAt: toDate(obj.cancel_time),
+    completedAt: toDate(obj.finish_time ?? obj.completed_at),
     createdAt: toDate(obj.create_time),
     expiresAt: toDate(obj.expire_time ?? obj.expires_at),
     id: id ? assertSimpleProviderId("xAI batch id", id) : "",
@@ -1108,6 +1244,24 @@ var normalizeSnapshot5 = (raw) => {
     status: deriveStatus(state)
   };
 };
+var imagesFromXaiCompletion = (completion) => {
+  const obj = asRecord(completion);
+  const entries = asArray(obj.data);
+  const sources = entries.length > 0 ? entries : [obj];
+  const images = [];
+  for (const source of sources) {
+    const record = asRecord(source);
+    const data = asString(record.base64) ?? asString(record.b64_json);
+    const url = asString(record.url);
+    if (data || url) {
+      images.push({
+        ...data ? { data } : {},
+        ...url ? { url } : {}
+      });
+    }
+  }
+  return images.length > 0 ? images : undefined;
+};
 var normalizeResult3 = (item) => {
   const obj = asRecord(item);
   const customId = asString(obj.batch_request_id) ?? "";
@@ -1129,6 +1283,7 @@ var normalizeResult3 = (item) => {
   const completion = response.chat_get_completion ?? Object.values(response)[0];
   return {
     customId,
+    images: imagesFromXaiCompletion(completion),
     response: completion,
     status: "succeeded",
     text: textFromBody(completion),
@@ -1142,8 +1297,7 @@ var submit4 = async (input) => {
     custom_id: item.customId,
     method: "POST",
     url: input.endpoint
-  })));
-  assertByteLength("batch upload JSONL", jsonl, limits.maxUploadBytes);
+  })), { label: "batch upload JSONL", maxBytes: limits.maxUploadBytes });
   const inputFileId = await uploadInputFile(jsonl, baseUrl4(input.credentials), authHeaders2(input.credentials), { purpose: null });
   const raw = await requestJson(`${baseUrl4(input.credentials)}/batches`, {
     body: JSON.stringify({ input_file_id: inputFileId, name: "batchwork" }),
@@ -1208,5 +1362,5 @@ var getAdapter = (provider) => adapters[provider];
 
 export { BatchworkError, UnsupportedProviderError, MissingDependencyError, resolveBatchLimits, assertByteLength, mapWithConcurrency, isTerminalStatus, BatchJob, getAdapter };
 
-//# debugId=A38719FEA6433ECA64756E2164756E21
-//# sourceMappingURL=chunk-g481f961.js.map
+//# debugId=308C7FBEE03E10E564756E2164756E21
+//# sourceMappingURL=chunk-h2he3d16.js.map