batchwork 0.0.0 → 1.0.1

package/dist/chunk-g481f961.js

@@ -0,0 +1,1212 @@
+// src/errors.ts
+class BatchworkError extends Error {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "BatchworkError";
+  }
+}
+
+class UnsupportedProviderError extends BatchworkError {
+  provider;
+  constructor(provider) {
+    super(`batchwork: provider "${provider}" is not supported yet. Supported providers: openai, anthropic, google, groq, mistral, together, xai.`);
+    this.name = "UnsupportedProviderError";
+    this.provider = provider;
+  }
+}
+
+class MissingDependencyError extends BatchworkError {
+  constructor(pkg, provider) {
+    super(`batchwork: install \`${pkg}\` to batch ${provider} models (\`npm install ${pkg}\`).`);
+    this.name = "MissingDependencyError";
+  }
+}
+
+// src/job.ts
+var DEFAULT_POLL_INTERVAL_MS = 15000;
+var TERMINAL_STATUSES = new Set([
+  "completed",
+  "failed",
+  "expired",
+  "cancelled"
+]);
+var isTerminalStatus = (status) => TERMINAL_STATUSES.has(status);
+var delay = (ms, signal) => new Promise((resolve, reject) => {
+  if (signal?.aborted) {
+    reject(new BatchworkError("batchwork: wait aborted."));
+    return;
+  }
+  const timer = setTimeout(resolve, ms);
+  signal?.addEventListener("abort", () => {
+    clearTimeout(timer);
+    reject(new BatchworkError("batchwork: wait aborted."));
+  }, { once: true });
+});
+
+class BatchJob {
+  provider;
+  id;
+  #adapter;
+  #credentials;
+  #snapshot;
+  constructor(adapter, credentials, snapshot) {
+    this.#adapter = adapter;
+    this.#credentials = credentials;
+    this.#snapshot = snapshot;
+    this.id = snapshot.id;
+    this.provider = snapshot.provider;
+  }
+  get status() {
+    return this.#snapshot.status;
+  }
+  get requestCounts() {
+    return this.#snapshot.requestCounts;
+  }
+  get snapshot() {
+    return this.#snapshot;
+  }
+  async poll() {
+    this.#snapshot = await this.#adapter.retrieve(this.id, this.#credentials);
+    return this.#snapshot;
+  }
+  async wait(options = {}) {
+    const interval = options.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;
+    const deadline = options.timeoutMs ? Date.now() + options.timeoutMs : undefined;
+    let snapshot = await this.poll();
+    options.onPoll?.(snapshot);
+    while (!isTerminalStatus(snapshot.status)) {
+      if (options.signal?.aborted) {
+        throw new BatchworkError("batchwork: wait aborted.");
+      }
+      if (deadline !== undefined && Date.now() > deadline) {
+        throw new BatchworkError(`batchwork: timed out waiting for batch "${this.id}".`);
+      }
+      await delay(interval, options.signal);
+      snapshot = await this.poll();
+      options.onPoll?.(snapshot);
+    }
+    return snapshot;
+  }
+  results() {
+    return this.#adapter.results(this.id, this.#credentials);
+  }
+  async collect() {
+    const out = [];
+    for await (const result of this.results()) {
+      out.push(result);
+    }
+    return out;
+  }
+  async cancel() {
+    await this.#adapter.cancel(this.id, this.#credentials);
+    return await this.poll();
+  }
+}
+
+// src/limits.ts
+var DEFAULT_LIMITS = {
+  captureConcurrency: 16,
+  maxRequestBytes: 20 * 1024 * 1024,
+  maxRequests: 50000,
+  maxUploadBytes: 200 * 1024 * 1024
+};
+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.`);
+  }
+  return value;
+};
+var resolveBatchLimits = (limits) => ({
+  captureConcurrency: positiveInteger("captureConcurrency", limits?.captureConcurrency ?? DEFAULT_LIMITS.captureConcurrency),
+  maxRequestBytes: positiveInteger("maxRequestBytes", limits?.maxRequestBytes ?? DEFAULT_LIMITS.maxRequestBytes),
+  maxRequests: positiveInteger("maxRequests", limits?.maxRequests ?? DEFAULT_LIMITS.maxRequests),
+  maxUploadBytes: positiveInteger("maxUploadBytes", limits?.maxUploadBytes ?? DEFAULT_LIMITS.maxUploadBytes)
+});
+var byteLength = (value) => encoder.encode(value).length;
+var assertByteLength = (label, value, maxBytes) => {
+  const bytes = byteLength(value);
+  if (bytes > maxBytes) {
+    throw new BatchworkError(`batchwork: ${label} is ${bytes} bytes, exceeding the ${maxBytes} byte limit.`);
+  }
+};
+var mapWithConcurrency = async (items, concurrency, mapper) => {
+  const results = [];
+  results.length = items.length;
+  let nextIndex = 0;
+  const workerCount = Math.min(concurrency, items.length);
+  const runNext = async () => {
+    const index = nextIndex;
+    nextIndex += 1;
+    if (index >= items.length) {
+      return;
+    }
+    results[index] = await mapper(items[index]);
+    await runNext();
+  };
+  await Promise.all(Array.from({ length: workerCount }, () => runNext()));
+  return results;
+};
+
+// src/http.ts
+var assertOk = (url, init, response) => {
+  if (!response.ok) {
+    throw new BatchworkError(`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();
+};
+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.`);
+  }
+  return response.body;
+};
+
+// src/jsonl.ts
+var NEWLINE = `
+`;
+var DEFAULT_MAX_JSONL_LINE_BYTES = 20 * 1024 * 1024;
+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.");
+  }
+  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.`);
+  }
+};
+var parseLine = (line, lineNumber, maxLineBytes) => {
+  assertLineSize(line, lineNumber, maxLineBytes);
+  const trimmed = line.trim();
+  if (trimmed.length === 0) {
+    return;
+  }
+  try {
+    return JSON.parse(trimmed);
+  } catch (error) {
+    throw new BatchworkError(`batchwork: invalid JSONL at line ${lineNumber}.`, { cause: error });
+  }
+};
+var encodeJsonl = (items) => {
+  if (items.length === 0) {
+    return "";
+  }
+  const body = items.map((item) => JSON.stringify(item)).join(NEWLINE);
+  return `${body}${NEWLINE}`;
+};
+var isReadableStream = (source) => ("getReader" in source) && typeof source.getReader === "function";
+async function* toByteIterable(source) {
+  if (isReadableStream(source)) {
+    const reader = source.getReader();
+    try {
+      let chunk = await reader.read();
+      while (!chunk.done) {
+        if (chunk.value) {
+          yield chunk.value;
+        }
+        chunk = await reader.read();
+      }
+    } finally {
+      reader.releaseLock();
+    }
+    return;
+  }
+  yield* source;
+}
+async function* streamJsonl(source, options) {
+  const decoder = new TextDecoder;
+  const maxLineBytes = resolveMaxLineBytes(options);
+  let buffer = "";
+  let lineNumber = 1;
+  for await (const chunk of toByteIterable(source)) {
+    buffer += decoder.decode(chunk, { stream: true });
+    let newlineIndex = buffer.indexOf(NEWLINE);
+    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;
+      }
+      lineNumber += 1;
+      newlineIndex = buffer.indexOf(NEWLINE);
+    }
+    assertLineSize(buffer, lineNumber, maxLineBytes);
+  }
+  buffer += decoder.decode();
+  const parsed = parseLine(buffer, lineNumber, maxLineBytes);
+  if (parsed !== undefined) {
+    yield parsed;
+  }
+}
+
+// src/util.ts
+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 omit = (obj, key) => {
+  const result = {};
+  for (const [k, v] of Object.entries(obj)) {
+    if (k !== key) {
+      result[k] = v;
+    }
+  }
+  return result;
+};
+var toDate = (value) => {
+  if (typeof value === "string") {
+    return new Date(value);
+  }
+  if (typeof value === "number") {
+    return new Date(value * 1000);
+  }
+};
+
+// src/providers/ids.ts
+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}.`);
+  }
+  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}.`);
+  }
+  return id;
+};
+
+// src/providers/anthropic.ts
+var ANTHROPIC_BASE = "https://api.anthropic.com";
+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`.");
+  }
+  return key;
+};
+var baseUrl = (credentials) => credentials.baseURL ?? ANTHROPIC_BASE;
+var validateResultsUrl = (rawUrl, credentials) => {
+  let resultsUrl;
+  let expectedBase;
+  try {
+    resultsUrl = new URL(rawUrl);
+    expectedBase = new URL(baseUrl(credentials));
+  } catch (error) {
+    throw new BatchworkError("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.");
+  }
+  if (resultsUrl.username || resultsUrl.password) {
+    throw new BatchworkError("batchwork: Anthropic results_url must not include credentials.");
+  }
+  return resultsUrl.toString();
+};
+var headers = (credentials) => ({
+  "anthropic-version": ANTHROPIC_VERSION,
+  "content-type": "application/json",
+  "x-api-key": apiKey(credentials),
+  ...credentials.headers
+});
+var mapStatus = (status) => {
+  if (status === "ended") {
+    return "completed";
+  }
+  if (status === "canceling") {
+    return "cancelling";
+  }
+  return "in_progress";
+};
+var normalizeSnapshot = (raw) => {
+  const obj = asRecord(raw);
+  const counts = asRecord(obj.request_counts);
+  const succeeded = asNumber(counts.succeeded) ?? 0;
+  const errored = asNumber(counts.errored) ?? 0;
+  const processing = asNumber(counts.processing) ?? 0;
+  const canceled = asNumber(counts.canceled) ?? 0;
+  const expired = asNumber(counts.expired) ?? 0;
+  return {
+    completedAt: toDate(obj.ended_at),
+    createdAt: toDate(obj.created_at),
+    expiresAt: toDate(obj.expires_at),
+    id: asString(obj.id) ?? "",
+    provider: "anthropic",
+    raw,
+    requestCounts: {
+      canceled,
+      completed: succeeded,
+      expired,
+      failed: errored,
+      processing,
+      total: succeeded + errored + processing + canceled + expired
+    },
+    status: mapStatus(asString(obj.processing_status))
+  };
+};
+var textFromMessage = (message) => {
+  const text = asArray(asRecord(message).content).map((block) => asRecord(block)).filter((block) => block.type === "text").map((block) => asString(block.text) ?? "").join("");
+  return text.length > 0 ? text : undefined;
+};
+var usageFromMessage = (message) => {
+  const usage = asRecord(asRecord(message).usage);
+  const inputTokens = asNumber(usage.input_tokens);
+  const outputTokens = asNumber(usage.output_tokens);
+  if (inputTokens === undefined && outputTokens === undefined) {
+    return;
+  }
+  return {
+    inputTokens,
+    outputTokens,
+    totalTokens: (inputTokens ?? 0) + (outputTokens ?? 0)
+  };
+};
+var normalizeResult = (line) => {
+  const obj = asRecord(line);
+  const customId = asString(obj.custom_id) ?? "";
+  const result = asRecord(obj.result);
+  const type = asString(result.type);
+  if (type === "succeeded") {
+    return {
+      customId,
+      response: result.message,
+      status: "succeeded",
+      text: textFromMessage(result.message),
+      usage: usageFromMessage(result.message)
+    };
+  }
+  if (type === "errored") {
+    const error = asRecord(result.error);
+    const nested = asRecord(error.error);
+    const source = Object.keys(nested).length > 0 ? nested : error;
+    return {
+      customId,
+      error: {
+        message: asString(source.message) ?? "Request errored.",
+        type: asString(source.type)
+      },
+      response: result.error,
+      status: "errored"
+    };
+  }
+  if (type === "expired") {
+    return { customId, status: "expired" };
+  }
+  return { customId, status: "canceled" };
+};
+var submit = async (input) => {
+  const limits = resolveBatchLimits(input.limits);
+  const requests = input.built.map((item) => ({
+    custom_id: item.customId,
+    params: omit(item.body, "stream")
+  }));
+  const body = JSON.stringify({ requests });
+  assertByteLength("batch upload payload", body, limits.maxUploadBytes);
+  const raw = await requestJson(`${baseUrl(input.credentials)}/v1/messages/batches`, {
+    body,
+    headers: headers(input.credentials),
+    method: "POST"
+  });
+  return normalizeSnapshot(raw);
+};
+var retrieve = async (id, credentials) => {
+  const batchId = assertSimpleProviderId("Anthropic batch id", id);
+  const raw = await requestJson(`${baseUrl(credentials)}/v1/messages/batches/${batchId}`, { headers: headers(credentials) });
+  return normalizeSnapshot(raw);
+};
+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}).`);
+  }
+  const stream = await requestStream(validateResultsUrl(resultsUrl, credentials), {
+    headers: headers(credentials)
+  });
+  for await (const line of streamJsonl(stream)) {
+    yield normalizeResult(line);
+  }
+}
+var cancel = async (id, credentials) => {
+  const batchId = assertSimpleProviderId("Anthropic batch id", id);
+  await requestJson(`${baseUrl(credentials)}/v1/messages/batches/${batchId}/cancel`, {
+    headers: headers(credentials),
+    method: "POST"
+  });
+};
+var anthropicAdapter = {
+  cancel,
+  id: "anthropic",
+  results,
+  retrieve,
+  submit
+};
+
+// src/providers/google.ts
+var GOOGLE_BASE = "https://generativelanguage.googleapis.com/v1beta";
+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`.");
+  }
+  return key;
+};
+var baseUrl2 = (credentials) => credentials.baseURL ?? GOOGLE_BASE;
+var headers2 = (credentials) => ({
+  "content-type": "application/json",
+  "x-goog-api-key": apiKey2(credentials),
+  ...credentials.headers
+});
+var mapState = (state, done) => {
+  if (state) {
+    if (state.endsWith("SUCCEEDED")) {
+      return "completed";
+    }
+    if (state.endsWith("FAILED")) {
+      return "failed";
+    }
+    if (state.endsWith("CANCELLED")) {
+      return "cancelled";
+    }
+    if (state.endsWith("EXPIRED")) {
+      return "expired";
+    }
+    if (state.endsWith("PENDING")) {
+      return "validating";
+    }
+    if (state.endsWith("RUNNING")) {
+      return "in_progress";
+    }
+  }
+  return done ? "completed" : "in_progress";
+};
+var inlinedResponses = (raw) => {
+  const obj = asRecord(raw);
+  const response = asRecord(obj.response);
+  const dest = asRecord(obj.dest);
+  const responseInline = response.inlinedResponses ?? response.inlined_responses;
+  const destInline = dest.inlinedResponses ?? dest.inlined_responses;
+  const nestedResponseInline = asRecord(responseInline);
+  const nestedDestInline = asRecord(destInline);
+  return [
+    ...asArray(responseInline),
+    ...asArray(nestedResponseInline.inlinedResponses),
+    ...asArray(nestedResponseInline.inlined_responses),
+    ...asArray(destInline),
+    ...asArray(nestedDestInline.inlinedResponses),
+    ...asArray(nestedDestInline.inlined_responses)
+  ];
+};
+var normalizeSnapshot2 = (raw) => {
+  const obj = asRecord(raw);
+  const items = inlinedResponses(raw);
+  const failed = items.filter((item) => asRecord(item).error).length;
+  const id = asString(obj.name) ?? "";
+  return {
+    id: id ? assertPrefixedProviderId("Google operation id", id, GOOGLE_BATCH_PREFIX) : "",
+    provider: "google",
+    raw,
+    requestCounts: {
+      completed: items.length - failed,
+      failed,
+      total: items.length
+    },
+    status: mapState(asString(obj.state) ?? asString(asRecord(obj.state).name) ?? asString(asRecord(obj.metadata).state), obj.done === true)
+  };
+};
+var textFromResponse = (response) => {
+  const candidate = asRecord(asArray(asRecord(response).candidates)[0]);
+  const text = asArray(asRecord(candidate.content).parts).map((part) => asString(asRecord(part).text) ?? "").join("");
+  return text.length > 0 ? text : undefined;
+};
+var usageFromResponse = (response) => {
+  const usage = asRecord(asRecord(response).usageMetadata);
+  const inputTokens = asNumber(usage.promptTokenCount);
+  const outputTokens = asNumber(usage.candidatesTokenCount);
+  const totalTokens = asNumber(usage.totalTokenCount);
+  if (inputTokens === undefined && outputTokens === undefined && totalTokens === undefined) {
+    return;
+  }
+  return {
+    inputTokens,
+    outputTokens,
+    totalTokens: totalTokens ?? (inputTokens ?? 0) + (outputTokens ?? 0)
+  };
+};
+var normalizeResult2 = (item) => {
+  const obj = asRecord(item);
+  const customId = asString(asRecord(obj.metadata).key) ?? asString(obj.key) ?? asString(obj.custom_id) ?? "";
+  if (obj.error) {
+    const error = asRecord(obj.error);
+    return {
+      customId,
+      error: {
+        code: asNumber(error.code) ?? asString(error.code),
+        message: asString(error.message) ?? "Request errored.",
+        type: asString(error.status)
+      },
+      response: obj.error,
+      status: "errored"
+    };
+  }
+  return {
+    customId,
+    response: obj.response,
+    status: "succeeded",
+    text: textFromResponse(obj.response),
+    usage: usageFromResponse(obj.response)
+  };
+};
+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 } }
+    }
+  });
+  assertByteLength("batch upload payload", body, limits.maxUploadBytes);
+  const raw = await requestJson(`${baseUrl2(input.credentials)}/models/${input.modelId}:batchGenerateContent`, {
+    body,
+    headers: headers2(input.credentials),
+    method: "POST"
+  });
+  return normalizeSnapshot2(raw);
+};
+var retrieve2 = async (id, credentials) => {
+  const operationId = assertPrefixedProviderId("Google operation id", id, GOOGLE_BATCH_PREFIX);
+  const raw = await requestJson(`${baseUrl2(credentials)}/${operationId}`, {
+    headers: headers2(credentials)
+  });
+  return normalizeSnapshot2(raw);
+};
+async function* results2(id, credentials) {
+  const snapshot = await retrieve2(id, credentials);
+  const raw = asRecord(snapshot.raw);
+  const response = asRecord(raw.response);
+  const dest = asRecord(raw.dest);
+  const responsesFile = asString(asRecord(response.responsesFile).name) ?? asString(response.responsesFile) ?? asString(asRecord(response.responses_file).name) ?? asString(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.`);
+  }
+  const items = inlinedResponses(raw);
+  if (items.length === 0) {
+    throw new BatchworkError(`batchwork: results are not ready for batch "${id}" (status: ${snapshot.status}).`);
+  }
+  for (const item of items) {
+    yield normalizeResult2(item);
+  }
+}
+var cancel2 = async (id, credentials) => {
+  const operationId = assertPrefixedProviderId("Google operation id", id, GOOGLE_BATCH_PREFIX);
+  await requestJson(`${baseUrl2(credentials)}/${operationId}:cancel`, {
+    headers: headers2(credentials),
+    method: "POST"
+  });
+};
+var googleAdapter = {
+  cancel: cancel2,
+  id: "google",
+  results: results2,
+  retrieve: retrieve2,
+  submit: submit2
+};
+
+// src/providers/shared.ts
+var HTTP_OK_MIN = 200;
+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\`.`);
+  }
+  return key;
+};
+var textFromBody = (body) => {
+  const obj = asRecord(body);
+  const choices = asArray(obj.choices);
+  if (choices.length > 0) {
+    const content = asString(asRecord(asRecord(choices[0]).message).content);
+    if (content) {
+      return content;
+    }
+  }
+  return asString(obj.output_text);
+};
+var usageFromBody = (body) => {
+  const usage = asRecord(asRecord(body).usage);
+  const inputTokens = asNumber(usage.prompt_tokens) ?? asNumber(usage.input_tokens);
+  const outputTokens = asNumber(usage.completion_tokens) ?? asNumber(usage.output_tokens);
+  const totalTokens = asNumber(usage.total_tokens);
+  if (inputTokens === undefined && outputTokens === undefined && totalTokens === undefined) {
+    return;
+  }
+  return {
+    inputTokens,
+    outputTokens,
+    totalTokens: totalTokens ?? (inputTokens ?? 0) + (outputTokens ?? 0)
+  };
+};
+var errorFromValue = (value, fallback) => {
+  const obj = asRecord(value);
+  const nested = asRecord(obj.error);
+  const source = nested.message ? nested : obj;
+  return {
+    code: asNumber(source.code) ?? asString(source.code),
+    message: asString(source.message) ?? fallback,
+    type: asString(source.type)
+  };
+};
+var normalizeOpenAIResult = (line) => {
+  const obj = asRecord(line);
+  const customId = asString(obj.custom_id) ?? "";
+  if (obj.error) {
+    return {
+      customId,
+      error: errorFromValue(obj.error, "Request errored."),
+      response: obj.error,
+      status: "errored"
+    };
+  }
+  const response = asRecord(obj.response);
+  const statusCode = asNumber(response.status_code) ?? 0;
+  if (statusCode >= HTTP_OK_MIN && statusCode < HTTP_OK_MAX) {
+    return {
+      customId,
+      response: response.body,
+      status: "succeeded",
+      text: textFromBody(response.body),
+      usage: usageFromBody(response.body)
+    };
+  }
+  return {
+    customId,
+    error: errorFromValue(response.body, `Request failed with status ${statusCode}.`),
+    response: response.body,
+    status: "errored"
+  };
+};
+var uploadInputFile = async (jsonl, baseUrl3, headers3, 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(`${baseUrl3}/files`, {
+    body: form,
+    headers: headers3,
+    method: "POST"
+  });
+  return raw.id;
+};
+async function* streamResultFile(fileId, baseUrl3, headers3) {
+  const stream = await requestStream(`${baseUrl3}/files/${fileId}/content`, {
+    headers: headers3
+  });
+  for await (const line of streamJsonl(stream)) {
+    yield normalizeOpenAIResult(line);
+  }
+}
+
+// src/providers/openai-compatible.ts
+var DEFAULT_COMPLETION_WINDOW = "24h";
+var mapStatus2 = (status) => {
+  const normalized = status?.toLowerCase();
+  switch (normalized) {
+    case "validating":
+    case "in_progress":
+    case "finalizing":
+    case "completed":
+    case "failed":
+    case "expired":
+    case "cancelling":
+    case "cancelled": {
+      return normalized;
+    }
+    default: {
+      return "in_progress";
+    }
+  }
+};
+var normalizeSnapshot3 = (raw, provider) => {
+  const outer = asRecord(raw);
+  const obj = asRecord(outer.job);
+  const source = Object.keys(obj).length > 0 ? obj : outer;
+  const counts = asRecord(source.request_counts);
+  return {
+    completedAt: toDate(source.completed_at),
+    createdAt: toDate(source.created_at),
+    expiresAt: toDate(source.expires_at),
+    id: asString(source.id) ?? "",
+    provider,
+    raw: source,
+    requestCounts: {
+      completed: asNumber(counts.completed) ?? 0,
+      failed: asNumber(counts.failed) ?? 0,
+      total: asNumber(counts.total) ?? 0
+    },
+    status: mapStatus2(asString(source.status))
+  };
+};
+var createOpenAICompatibleAdapter = (config) => {
+  const completionWindow = config.completionWindow ?? DEFAULT_COMPLETION_WINDOW;
+  const lineFormat = config.lineFormat ?? "method-url";
+  const baseUrl3 = (credentials) => credentials.baseURL ?? config.baseUrl;
+  const authHeaders = (credentials) => ({
+    Authorization: `Bearer ${resolveApiKey(credentials, config.apiKeyEnv, config.apiKeyLabel)}`,
+    ...credentials.headers
+  });
+  const submit3 = async (input) => {
+    const limits = resolveBatchLimits(input.limits);
+    const endpoint = config.normalizeEndpoint ? config.normalizeEndpoint(input.endpoint) : input.endpoint;
+    const jsonl = encodeJsonl(input.built.map((item) => {
+      const body = omit(item.body, "stream");
+      if (lineFormat === "body-only") {
+        return { body, custom_id: item.customId };
+      }
+      return {
+        body,
+        custom_id: item.customId,
+        method: "POST",
+        url: endpoint
+      };
+    }));
+    assertByteLength("batch upload JSONL", jsonl, limits.maxUploadBytes);
+    const headers3 = authHeaders(input.credentials);
+    const url = baseUrl3(input.credentials);
+    const purpose = config.filePurpose ?? "batch";
+    const inputFileId = await (config.uploadFile ? config.uploadFile({ baseUrl: url, headers: headers3, jsonl, purpose }) : uploadInputFile(jsonl, url, headers3, { purpose }));
+    const raw = await requestJson(`${url}/batches`, {
+      body: JSON.stringify({
+        completion_window: completionWindow,
+        endpoint,
+        input_file_id: inputFileId,
+        metadata: input.metadata
+      }),
+      headers: { ...headers3, "content-type": "application/json" },
+      method: "POST"
+    });
+    return normalizeSnapshot3(raw, config.id);
+  };
+  const retrieve3 = async (id, credentials) => {
+    const batchId = assertSimpleProviderId(`${config.id} batch id`, id);
+    const raw = await requestJson(`${baseUrl3(credentials)}/batches/${batchId}`, {
+      headers: authHeaders(credentials)
+    });
+    return normalizeSnapshot3(raw, config.id);
+  };
+  async function* results3(id, credentials) {
+    const snapshot = await retrieve3(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}).`);
+    }
+    const headers3 = authHeaders(credentials);
+    if (outputFileId) {
+      yield* streamResultFile(assertSimpleProviderId(`${config.id} output file id`, outputFileId), baseUrl3(credentials), headers3);
+    }
+    if (errorFileId) {
+      yield* streamResultFile(assertSimpleProviderId(`${config.id} error file id`, errorFileId), baseUrl3(credentials), headers3);
+    }
+  }
+  const cancel3 = async (id, credentials) => {
+    const batchId = assertSimpleProviderId(`${config.id} batch id`, id);
+    await requestJson(`${baseUrl3(credentials)}/batches/${batchId}/cancel`, {
+      headers: authHeaders(credentials),
+      method: "POST"
+    });
+  };
+  return { cancel: cancel3, id: config.id, results: results3, retrieve: retrieve3, submit: submit3 };
+};
+
+// src/providers/groq.ts
+var groqAdapter = createOpenAICompatibleAdapter({
+  apiKeyEnv: "GROQ_API_KEY",
+  apiKeyLabel: "Groq",
+  baseUrl: "https://api.groq.com/openai/v1",
+  id: "groq",
+  lineFormat: "method-url",
+  normalizeEndpoint: (endpoint) => endpoint.replace(/^\/openai/u, "")
+});
+
+// src/providers/mistral.ts
+var MISTRAL_BASE = "https://api.mistral.ai/v1";
+var apiKey3 = (credentials) => resolveApiKey(credentials, "MISTRAL_API_KEY", "Mistral");
+var baseUrl3 = (credentials) => credentials.baseURL ?? MISTRAL_BASE;
+var authHeaders = (credentials) => ({
+  Authorization: `Bearer ${apiKey3(credentials)}`,
+  ...credentials.headers
+});
+var mapStatus3 = (status) => {
+  switch (status) {
+    case "QUEUED": {
+      return "validating";
+    }
+    case "SUCCESS": {
+      return "completed";
+    }
+    case "FAILED": {
+      return "failed";
+    }
+    case "TIMEOUT_EXCEEDED": {
+      return "expired";
+    }
+    case "CANCELLATION_REQUESTED": {
+      return "cancelling";
+    }
+    case "CANCELLED": {
+      return "cancelled";
+    }
+    default: {
+      return "in_progress";
+    }
+  }
+};
+var normalizeSnapshot4 = (raw) => {
+  const obj = asRecord(raw);
+  const succeeded = asNumber(obj.succeeded_requests) ?? 0;
+  const failed = asNumber(obj.failed_requests) ?? 0;
+  const id = asString(obj.id) ?? "";
+  return {
+    completedAt: toDate(obj.completed_at),
+    createdAt: toDate(obj.created_at),
+    id: id ? assertSimpleProviderId("Mistral job id", id) : "",
+    provider: "mistral",
+    raw,
+    requestCounts: {
+      completed: succeeded,
+      failed,
+      total: asNumber(obj.total_requests) ?? succeeded + failed
+    },
+    status: mapStatus3(asString(obj.status))
+  };
+};
+var submit3 = async (input) => {
+  const limits = resolveBatchLimits(input.limits);
+  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);
+  const inputFileId = await uploadInputFile(jsonl, baseUrl3(input.credentials), authHeaders(input.credentials));
+  const raw = await requestJson(`${baseUrl3(input.credentials)}/batch/jobs`, {
+    body: JSON.stringify({
+      endpoint: input.endpoint,
+      input_files: [inputFileId],
+      metadata: input.metadata,
+      model: input.modelId
+    }),
+    headers: {
+      ...authHeaders(input.credentials),
+      "content-type": "application/json"
+    },
+    method: "POST"
+  });
+  return normalizeSnapshot4(raw);
+};
+var retrieve3 = async (id, credentials) => {
+  const jobId = assertSimpleProviderId("Mistral job id", id);
+  const raw = await requestJson(`${baseUrl3(credentials)}/batch/jobs/${jobId}`, {
+    headers: authHeaders(credentials)
+  });
+  return normalizeSnapshot4(raw);
+};
+async function* results3(id, credentials) {
+  const snapshot = await retrieve3(id, credentials);
+  const raw = asRecord(snapshot.raw);
+  const outputFileId = asString(raw.output_file);
+  const errorFileId = asString(raw.error_file);
+  const headers3 = authHeaders(credentials);
+  if (outputFileId) {
+    yield* streamResultFile(assertSimpleProviderId("Mistral output file id", outputFileId), baseUrl3(credentials), headers3);
+  }
+  if (errorFileId) {
+    yield* streamResultFile(assertSimpleProviderId("Mistral error file id", errorFileId), baseUrl3(credentials), headers3);
+  }
+  if (!(outputFileId || errorFileId)) {
+    throw new BatchworkError(`batchwork: results are not ready for batch "${id}" (status: ${snapshot.status}).`);
+  }
+}
+var cancel3 = async (id, credentials) => {
+  const jobId = assertSimpleProviderId("Mistral job id", id);
+  await requestJson(`${baseUrl3(credentials)}/batch/jobs/${jobId}/cancel`, {
+    headers: authHeaders(credentials),
+    method: "POST"
+  });
+};
+var mistralAdapter = {
+  cancel: cancel3,
+  id: "mistral",
+  results: results3,
+  retrieve: retrieve3,
+  submit: submit3
+};
+
+// src/providers/openai.ts
+var openaiAdapter = createOpenAICompatibleAdapter({
+  apiKeyEnv: "OPENAI_API_KEY",
+  apiKeyLabel: "OpenAI",
+  baseUrl: "https://api.openai.com/v1",
+  id: "openai",
+  lineFormat: "method-url"
+});
+
+// src/providers/together.ts
+var INPUT_FILE_NAME = "batchwork.jsonl";
+var HTTP_FOUND = 302;
+var parseIpv4 = (host) => {
+  if (!/^\d{1,3}(?:\.\d{1,3}){3}$/u.test(host)) {
+    return;
+  }
+  const parts = host.split(".").map(Number);
+  const valid = parts.every((part) => Number.isInteger(part) && part >= 0 && part <= 255);
+  return valid ? parts : undefined;
+};
+var isPrivateIpv4 = (parts) => {
+  const [a = 0, b = 0] = parts;
+  return a === 0 || a === 10 || a === 127 || a === 100 && b >= 64 && b <= 127 || a === 169 && b === 254 || a === 172 && b >= 16 && b <= 31 || a === 192 && b === 168 || a === 198 && (b === 18 || b === 19) || a >= 224;
+};
+var isPrivateIpv6 = (host) => {
+  const normalized = host.replace(/^\[/u, "").replace(/\]$/u, "").toLowerCase();
+  return normalized === "::" || normalized === "::1" || normalized.startsWith("fc") || normalized.startsWith("fd") || normalized.startsWith("fe80:");
+};
+var validateUploadLocation = (location) => {
+  let url;
+  try {
+    url = new URL(location);
+  } catch (error) {
+    throw new BatchworkError("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.");
+  }
+  if (url.username || url.password) {
+    throw new BatchworkError("batchwork: Together upload Location must not include credentials.");
+  }
+  const host = url.hostname.toLowerCase();
+  const ipv4 = parseIpv4(host);
+  if (host === "localhost" || host.endsWith(".localhost") || host.endsWith(".local") || ipv4 && isPrivateIpv4(ipv4) || isPrivateIpv6(host)) {
+    throw new BatchworkError("batchwork: Together upload Location must not target localhost or private networks.");
+  }
+  return url.toString();
+};
+var uploadTogetherFile = async (args) => {
+  const metadata = new FormData;
+  metadata.append("purpose", args.purpose);
+  metadata.append("file_name", INPUT_FILE_NAME);
+  metadata.append("file_type", "jsonl");
+  const init = await fetch(`${args.baseUrl}/files`, {
+    body: metadata,
+    headers: args.headers,
+    method: "POST",
+    redirect: "manual"
+  });
+  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}).`);
+  }
+  const uploadLocation = validateUploadLocation(location);
+  const upload = await fetch(uploadLocation, {
+    body: args.jsonl,
+    method: "PUT"
+  });
+  if (!upload.ok) {
+    throw new BatchworkError(`batchwork: Together file upload failed (${upload.status}).`);
+  }
+  const safeFileId = assertSimpleProviderId("Together file id", fileId);
+  await requestJson(`${args.baseUrl}/files/${safeFileId}/preprocess`, {
+    headers: args.headers,
+    method: "POST"
+  });
+  return safeFileId;
+};
+var togetherAdapter = createOpenAICompatibleAdapter({
+  apiKeyEnv: "TOGETHER_API_KEY",
+  apiKeyLabel: "Together AI",
+  baseUrl: "https://api.together.xyz/v1",
+  filePurpose: "batch-api",
+  id: "together",
+  lineFormat: "body-only",
+  uploadFile: uploadTogetherFile
+});
+
+// src/providers/xai.ts
+var XAI_BASE = "https://api.x.ai/v1";
+var RESULTS_PAGE_SIZE = 100;
+var apiKey4 = (credentials) => resolveApiKey(credentials, "XAI_API_KEY", "xAI");
+var baseUrl4 = (credentials) => credentials.baseURL ?? XAI_BASE;
+var authHeaders2 = (credentials) => ({
+  Authorization: `Bearer ${apiKey4(credentials)}`,
+  ...credentials.headers
+});
+var deriveStatus = (state) => {
+  const pending = asNumber(state.num_pending);
+  if (pending === undefined) {
+    return "in_progress";
+  }
+  const total = asNumber(state.num_requests) ?? 0;
+  const cancelled = asNumber(state.num_cancelled) ?? 0;
+  if (total === 0) {
+    return "in_progress";
+  }
+  if (pending > 0) {
+    return "in_progress";
+  }
+  if (cancelled > 0 && cancelled === total) {
+    return "cancelled";
+  }
+  return "completed";
+};
+var normalizeSnapshot5 = (raw) => {
+  const obj = asRecord(raw);
+  const state = asRecord(obj.state);
+  const id = asString(obj.batch_id) ?? asString(obj.id) ?? "";
+  return {
+    completedAt: toDate(obj.cancel_time),
+    createdAt: toDate(obj.create_time),
+    expiresAt: toDate(obj.expire_time ?? obj.expires_at),
+    id: id ? assertSimpleProviderId("xAI batch id", id) : "",
+    provider: "xai",
+    raw,
+    requestCounts: {
+      canceled: asNumber(state.num_cancelled) ?? 0,
+      completed: asNumber(state.num_success) ?? 0,
+      failed: asNumber(state.num_error) ?? 0,
+      processing: asNumber(state.num_pending) ?? 0,
+      total: asNumber(state.num_requests) ?? 0
+    },
+    status: deriveStatus(state)
+  };
+};
+var normalizeResult3 = (item) => {
+  const obj = asRecord(item);
+  const customId = asString(obj.batch_request_id) ?? "";
+  const batchResult = asRecord(obj.batch_result);
+  const resultError = batchResult.error;
+  const errorMessage = asString(obj.error_message) ?? asString(resultError) ?? asString(asRecord(resultError).message);
+  if (errorMessage) {
+    return {
+      customId,
+      error: {
+        message: errorMessage,
+        type: asString(asRecord(resultError).type)
+      },
+      response: obj,
+      status: "errored"
+    };
+  }
+  const response = asRecord(batchResult.response);
+  const completion = response.chat_get_completion ?? Object.values(response)[0];
+  return {
+    customId,
+    response: completion,
+    status: "succeeded",
+    text: textFromBody(completion),
+    usage: usageFromBody(completion)
+  };
+};
+var submit4 = async (input) => {
+  const limits = resolveBatchLimits(input.limits);
+  const jsonl = encodeJsonl(input.built.map((item) => ({
+    body: omit(item.body, "stream"),
+    custom_id: item.customId,
+    method: "POST",
+    url: input.endpoint
+  })));
+  assertByteLength("batch upload JSONL", jsonl, 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" }),
+    headers: {
+      ...authHeaders2(input.credentials),
+      "content-type": "application/json"
+    },
+    method: "POST"
+  });
+  return normalizeSnapshot5(raw);
+};
+var retrieve4 = async (id, credentials) => {
+  const batchId = assertSimpleProviderId("xAI batch id", id);
+  const raw = await requestJson(`${baseUrl4(credentials)}/batches/${batchId}`, {
+    headers: authHeaders2(credentials)
+  });
+  return normalizeSnapshot5(raw);
+};
+async function* results4(id, credentials) {
+  const batchId = assertSimpleProviderId("xAI batch id", id);
+  const headers3 = authHeaders2(credentials);
+  let token;
+  do {
+    const query = new URLSearchParams({ limit: String(RESULTS_PAGE_SIZE) });
+    if (token) {
+      query.set("pagination_token", token);
+    }
+    const raw = await requestJson(`${baseUrl4(credentials)}/batches/${batchId}/results?${query.toString()}`, { headers: headers3 });
+    const page = asRecord(raw);
+    for (const item of Array.isArray(page.results) ? page.results : []) {
+      yield normalizeResult3(item);
+    }
+    token = asString(page.pagination_token);
+  } while (token);
+}
+var cancel4 = async (id, credentials) => {
+  const batchId = assertSimpleProviderId("xAI batch id", id);
+  await requestJson(`${baseUrl4(credentials)}/batches/${batchId}:cancel`, {
+    headers: authHeaders2(credentials),
+    method: "POST"
+  });
+};
+var xaiAdapter = {
+  cancel: cancel4,
+  id: "xai",
+  results: results4,
+  retrieve: retrieve4,
+  submit: submit4
+};
+
+// src/providers/index.ts
+var adapters = {
+  anthropic: anthropicAdapter,
+  google: googleAdapter,
+  groq: groqAdapter,
+  mistral: mistralAdapter,
+  openai: openaiAdapter,
+  together: togetherAdapter,
+  xai: xaiAdapter
+};
+var getAdapter = (provider) => adapters[provider];
+
+export { BatchworkError, UnsupportedProviderError, MissingDependencyError, resolveBatchLimits, assertByteLength, mapWithConcurrency, isTerminalStatus, BatchJob, getAdapter };
+
+//# debugId=A38719FEA6433ECA64756E2164756E21
+//# sourceMappingURL=chunk-g481f961.js.map