pareta 0.1.0

package/dist/index.mjs

@@ -0,0 +1,1082 @@
+// src/errors.ts
+var ParetaError = class extends Error {
+  constructor(message, options) {
+    super(message);
+    this.name = "ParetaError";
+    if (options && options.cause !== void 0) this.cause = options.cause;
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+var APIConnectionError = class extends ParetaError {
+  constructor(message = "connection error", options) {
+    super(message, options);
+    this.name = "APIConnectionError";
+  }
+};
+var APITimeoutError = class extends APIConnectionError {
+  constructor(message = "request timed out", options) {
+    super(message, options);
+    this.name = "APITimeoutError";
+  }
+};
+var APIStatusError = class extends ParetaError {
+  /** The HTTP status code. */
+  status;
+  /** The server's `detail` (string, or an array of validation items for 422). */
+  detail;
+  /** Value of the `x-request-id` response header, if present. */
+  requestId;
+  /** The underlying `Response` (for advanced use). */
+  response;
+  constructor(message, init) {
+    super(message);
+    this.name = "APIStatusError";
+    this.status = init.status;
+    this.detail = init.detail;
+    this.requestId = init.requestId ?? null;
+    this.response = init.response;
+  }
+};
+var BadRequestError = class extends APIStatusError {
+  constructor(message, init) {
+    super(message, init);
+    this.name = "BadRequestError";
+  }
+};
+var AuthenticationError = class extends APIStatusError {
+  constructor(message, init) {
+    super(message, init);
+    this.name = "AuthenticationError";
+  }
+};
+var PermissionDeniedError = class extends APIStatusError {
+  constructor(message, init) {
+    super(message, init);
+    this.name = "PermissionDeniedError";
+  }
+};
+var NotFoundError = class extends APIStatusError {
+  constructor(message, init) {
+    super(message, init);
+    this.name = "NotFoundError";
+  }
+};
+var ConflictError = class extends APIStatusError {
+  constructor(message, init) {
+    super(message, init);
+    this.name = "ConflictError";
+  }
+};
+var InsufficientCreditsError = class extends APIStatusError {
+  constructor(message, init) {
+    super(message, init);
+    this.name = "InsufficientCreditsError";
+  }
+};
+var RateLimitError = class extends APIStatusError {
+  constructor(message, init) {
+    super(message, init);
+    this.name = "RateLimitError";
+  }
+};
+var EndpointNotReadyError = class extends APIStatusError {
+  constructor(message, init) {
+    super(message, init);
+    this.name = "EndpointNotReadyError";
+  }
+};
+var STATUS_MAP = {
+  400: BadRequestError,
+  401: AuthenticationError,
+  402: InsufficientCreditsError,
+  403: PermissionDeniedError,
+  404: NotFoundError,
+  409: ConflictError,
+  422: BadRequestError,
+  429: RateLimitError,
+  503: EndpointNotReadyError
+};
+function errorFromResponse(status, opts) {
+  const { detail, requestId, response } = opts;
+  const message = typeof detail === "string" && detail ? detail : `HTTP ${status}`;
+  let cls = STATUS_MAP[status];
+  if (!cls) cls = status === 429 ? RateLimitError : APIStatusError;
+  return new cls(message, { status, detail, requestId, response });
+}
+
+// src/streaming.ts
+function normalize(s) {
+  return s.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+}
+async function* iterLines(reader) {
+  const decoder = new TextDecoder();
+  let buffer = "";
+  for (; ; ) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    buffer = normalize(buffer + decoder.decode(value, { stream: true }));
+    let idx;
+    while ((idx = buffer.indexOf("\n")) >= 0) {
+      yield buffer.slice(0, idx);
+      buffer = buffer.slice(idx + 1);
+    }
+  }
+  buffer = normalize(buffer + decoder.decode());
+  if (buffer.length > 0) {
+    for (const line of buffer.split("\n")) yield line;
+  }
+}
+async function* parseDataOnly(lines) {
+  for await (const rawLine of lines) {
+    let line = rawLine.trim();
+    if (!line || line.startsWith(":")) continue;
+    if (line.startsWith("data:")) line = line.slice("data:".length).trim();
+    if (!line || line === "[DONE]") {
+      if (line === "[DONE]") return;
+      continue;
+    }
+    try {
+      yield JSON.parse(line);
+    } catch {
+      continue;
+    }
+  }
+}
+async function* parseNamedEvent(lines) {
+  let event = "message";
+  for await (const rawLine of lines) {
+    const line = rawLine.replace(/\n+$/, "");
+    if (!line) {
+      event = "message";
+      continue;
+    }
+    if (line.startsWith(":")) continue;
+    if (line.startsWith("event:")) {
+      event = line.slice("event:".length).trim();
+    } else if (line.startsWith("data:")) {
+      const raw = line.slice("data:".length).trim();
+      if (raw === "[DONE]") return;
+      let data;
+      try {
+        data = JSON.parse(raw);
+      } catch {
+        data = raw;
+      }
+      yield { event, data };
+    }
+  }
+}
+function parseSSE(reader, opts) {
+  const lines = iterLines(reader);
+  return opts?.events ? parseNamedEvent(lines) : parseDataOnly(lines);
+}
+
+// src/version.ts
+var VERSION = "0.1.0";
+
+// src/money.ts
+var MICRO_PER_CENT = 10000n;
+function dollarsFlooredToCents(microUsd) {
+  const micro = typeof microUsd === "bigint" ? microUsd : BigInt(Math.trunc(Number(microUsd ?? 0)));
+  const cents = micro / MICRO_PER_CENT;
+  const negative = cents < 0n;
+  const abs = negative ? -cents : cents;
+  const dollars = abs / 100n;
+  const remainder = abs % 100n;
+  return `${negative ? "-" : ""}${dollars.toString()}.${remainder.toString().padStart(2, "0")}`;
+}
+
+// src/models.ts
+var BaseModel = class {
+  /** The raw server JSON, untouched. */
+  raw;
+  constructor(raw) {
+    this.raw = raw ?? {};
+  }
+  /** The raw server JSON (alias of `.raw`, mirrors Python `.to_dict()`). */
+  toDict() {
+    return this.raw;
+  }
+  /** Read an arbitrary key off the raw payload. */
+  get(key, fallback) {
+    const v = this.raw[key];
+    return v === void 0 ? fallback : v;
+  }
+};
+var Usage = class extends BaseModel {
+  get promptTokens() {
+    return this.raw.prompt_tokens ?? null;
+  }
+  get completionTokens() {
+    return this.raw.completion_tokens ?? null;
+  }
+  get totalTokens() {
+    return this.raw.total_tokens ?? null;
+  }
+};
+var Message = class extends BaseModel {
+  get role() {
+    return this.raw.role ?? null;
+  }
+  get content() {
+    return this.raw.content ?? null;
+  }
+};
+var Choice = class extends BaseModel {
+  get index() {
+    return this.raw.index ?? null;
+  }
+  get finishReason() {
+    return this.raw.finish_reason ?? null;
+  }
+  get message() {
+    return new Message(this.raw.message ?? {});
+  }
+  /** Streaming chunks carry `delta` instead of `message`. */
+  get delta() {
+    return new Message(this.raw.delta ?? {});
+  }
+};
+var ChatCompletion = class extends BaseModel {
+  get id() {
+    return this.raw.id ?? null;
+  }
+  get model() {
+    return this.raw.model ?? null;
+  }
+  get created() {
+    return this.raw.created ?? null;
+  }
+  get choices() {
+    return (this.raw.choices ?? []).map((c) => new Choice(c));
+  }
+  get usage() {
+    return new Usage(this.raw.usage ?? {});
+  }
+};
+var ChatCompletionChunk = class extends ChatCompletion {
+};
+var Model = class extends BaseModel {
+  get id() {
+    return this.raw.id ?? null;
+  }
+  get ownedBy() {
+    return this.raw.owned_by ?? null;
+  }
+  get created() {
+    return this.raw.created ?? null;
+  }
+};
+var ModelList = class extends BaseModel {
+  get data() {
+    return (this.raw.data ?? []).map((m) => new Model(m));
+  }
+  get length() {
+    return (this.raw.data ?? []).length;
+  }
+  [Symbol.iterator]() {
+    return this.data[Symbol.iterator]();
+  }
+};
+var Endpoint = class extends BaseModel {
+  get id() {
+    return this.raw.id ?? this.raw.name ?? null;
+  }
+  get name() {
+    return this.raw.name ?? null;
+  }
+  get model() {
+    return this.raw.model ?? null;
+  }
+  get status() {
+    return this.raw.status ?? null;
+  }
+  // Live list sends camelCase `taskName`; the detail record sends `task`.
+  get task() {
+    return this.raw.taskName ?? this.raw.task ?? null;
+  }
+  get url() {
+    return this.raw.url ?? null;
+  }
+  get isLive() {
+    return this.raw.status === "live";
+  }
+};
+function endpointList(raw) {
+  return (raw ?? []).map((e) => new Endpoint(e));
+}
+var Task = class extends BaseModel {
+  get id() {
+    return this.raw.id ?? null;
+  }
+  get defaultScorer() {
+    return this.raw.default_scorer ?? null;
+  }
+  get hasBlobInput() {
+    return Boolean(this.raw.has_blob_input);
+  }
+};
+function taskList(raw) {
+  return (raw?.tasks ?? []).map((t) => new Task(t));
+}
+var TaskMatchCandidate = class extends BaseModel {
+  get taskId() {
+    return this.raw.task_id ?? null;
+  }
+  get score() {
+    return this.raw.score ?? null;
+  }
+  get confidence() {
+    return this.raw.confidence ?? null;
+  }
+};
+var TaskMatch = class extends BaseModel {
+  get query() {
+    return this.raw.query ?? null;
+  }
+  get matched() {
+    return Boolean(this.raw.matched);
+  }
+  get chosen() {
+    return this.raw.chosen ? new TaskMatchCandidate(this.raw.chosen) : null;
+  }
+  get candidates() {
+    return (this.raw.candidates ?? []).map((c) => new TaskMatchCandidate(c));
+  }
+  get ambiguous() {
+    return Boolean(this.raw.ambiguous);
+  }
+  get matcher() {
+    return this.raw.matcher ?? null;
+  }
+};
+var EvalSet = class extends BaseModel {
+  get id() {
+    return this.raw.id ?? null;
+  }
+  get taskId() {
+    return this.raw.task_id ?? null;
+  }
+  get name() {
+    return this.raw.name ?? null;
+  }
+  get itemCount() {
+    return this.raw.item_count ?? null;
+  }
+  get scoringStrategy() {
+    return this.raw.scoring_strategy ?? null;
+  }
+};
+function evalSetFromCreate(raw) {
+  return new EvalSet(raw?.eval_set ?? {});
+}
+function evalSetList(raw) {
+  return (raw?.eval_sets ?? []).map((e) => new EvalSet(e));
+}
+var EvalResult = class extends BaseModel {
+  get modelId() {
+    return this.raw.model_id ?? null;
+  }
+  get kind() {
+    return this.raw.kind ?? null;
+  }
+  get qualityMean() {
+    return this.raw.quality_mean ?? null;
+  }
+  get qualityCiLow() {
+    return this.raw.quality_ci_low ?? null;
+  }
+  get qualityCiHigh() {
+    return this.raw.quality_ci_high ?? null;
+  }
+  // Raw integer — sub-cent unit rate, NOT floored (see money.ts).
+  get meanCostMicroUsd() {
+    return this.raw.mean_cost_micro_usd ?? null;
+  }
+  get nSucceeded() {
+    return this.raw.n_succeeded ?? null;
+  }
+  get errorCount() {
+    return this.raw.error_count ?? null;
+  }
+};
+var LeaderboardEntry = class extends BaseModel {
+  get name() {
+    return this.raw.name ?? null;
+  }
+  get kind() {
+    return this.raw.kind ?? null;
+  }
+  get quality() {
+    return this.raw.quality ?? null;
+  }
+  // Raw integer — sub-cent unit rate, NOT floored (see money.ts).
+  get costPerRequestMicroUsd() {
+    return this.raw.cost_per_request_micro_usd ?? null;
+  }
+  get contextK() {
+    return this.raw.context_k ?? null;
+  }
+  get runMode() {
+    return this.raw.run_mode ?? null;
+  }
+};
+var Leaderboard = class extends BaseModel {
+  get taskId() {
+    return this.raw.task_id ?? null;
+  }
+  get metric() {
+    return this.raw.metric ?? null;
+  }
+  get costUnit() {
+    return this.raw.cost_unit ?? null;
+  }
+  get recommended() {
+    return this.raw.recommended ?? null;
+  }
+  get models() {
+    return (this.raw.models ?? []).map((m) => new LeaderboardEntry(m));
+  }
+  get frontier() {
+    return this.raw.frontier ? new LeaderboardEntry(this.raw.frontier) : null;
+  }
+};
+var FrontierModel = class extends BaseModel {
+  get id() {
+    return this.raw.id ?? null;
+  }
+  get vendor() {
+    return this.raw.vendor ?? null;
+  }
+  get vision() {
+    return Boolean(this.raw.vision);
+  }
+  /** Only meaningful when a task was given: it's on that task's leaderboard. */
+  get benchmarked() {
+    return Boolean(this.raw.benchmarked);
+  }
+};
+function leaderboardFrom(raw) {
+  return new Leaderboard(raw ?? {});
+}
+function frontierModels(raw) {
+  return (raw?.frontier_models ?? []).map((m) => new FrontierModel(m));
+}
+var EvalRun = class extends BaseModel {
+  get run() {
+    return this.raw.run ?? {};
+  }
+  get id() {
+    return this.run.id ?? null;
+  }
+  get evalSetId() {
+    return this.run.eval_set_id ?? null;
+  }
+  get status() {
+    return this.run.status ?? null;
+  }
+  get isTerminal() {
+    return this.run.status === "completed" || this.run.status === "failed";
+  }
+  get candidateModels() {
+    return [...this.run.candidate_model_ids ?? []];
+  }
+  get errorDetail() {
+    return this.run.error_detail ?? null;
+  }
+  /** Raw billed micro-USD integer. */
+  get costMicroUsd() {
+    return Number(this.run.total_cost_micro_usd ?? 0);
+  }
+  /** Billed total, floored to whole cents, as a fixed-2dp dollar string ("1.23"). */
+  get cost() {
+    return dollarsFlooredToCents(this.run.total_cost_micro_usd);
+  }
+  get results() {
+    return (this.raw.results ?? []).map((r) => new EvalResult(r));
+  }
+};
+
+// src/resources/chat.ts
+var PATH = "/v1/chat/completions";
+function buildBody(params) {
+  const { model, messages, stream, ...extra } = params;
+  if (!model) throw new ParetaError("model is required (an endpoint id from endpoints.deploy)");
+  if (!messages || messages.length === 0) {
+    throw new ParetaError("messages is required and must be non-empty");
+  }
+  const body = { model, messages, ...extra };
+  if (stream) body.stream = true;
+  return body;
+}
+var Completions = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  create(params) {
+    const body = buildBody(params);
+    if (params.stream) {
+      return this.client.stream("POST", PATH, {
+        body,
+        cast: (raw) => new ChatCompletionChunk(raw)
+      });
+    }
+    return this.client.request("POST", PATH, {
+      body,
+      cast: (raw) => new ChatCompletion(raw)
+    });
+  }
+};
+var Chat = class {
+  completions;
+  constructor(client) {
+    this.completions = new Completions(client);
+  }
+};
+
+// src/resources/models.ts
+var PATH2 = "/v1/models";
+var Models = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  list() {
+    return this.client.request("GET", PATH2, {
+      cast: (raw) => new ModelList(raw)
+    });
+  }
+};
+
+// src/resources/endpoints.ts
+var BASE = "/v1/endpoints";
+function buildDeployBody(params) {
+  const { task, model, name, wait: _wait, ...extra } = params;
+  if (!task) throw new ParetaError("task is required");
+  const body = { task, model: model || "recommended", ...extra };
+  if (name !== void 0) body.name = name;
+  return body;
+}
+function endpointFromComplete(data) {
+  const ep = data && typeof data === "object" ? data.endpoint : null;
+  return new Endpoint(ep ?? {});
+}
+function deployError(data) {
+  const msg = data && typeof data === "object" ? data.message : String(data);
+  return new ParetaError(`deploy failed: ${msg || "unknown error"}`);
+}
+var EndpointMetrics = class {
+  constructor(client, id) {
+    this.client = client;
+    this.id = id;
+  }
+  client;
+  id;
+  performance(params) {
+    return this.client.request("GET", `${BASE}/${this.id}/performance`, { params });
+  }
+  uptime(params) {
+    return this.client.request("GET", `${BASE}/${this.id}/uptime`, { params });
+  }
+  cost(params) {
+    return this.client.request("GET", `${BASE}/${this.id}/cost`, { params });
+  }
+  quality(params) {
+    return this.client.request("GET", `${BASE}/${this.id}/quality`, { params });
+  }
+  activity(params) {
+    return this.client.request("GET", `${BASE}/${this.id}/activity`, { params });
+  }
+};
+var Endpoints = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  deploy(params) {
+    const body = buildDeployBody(params);
+    const stream = this.client.stream("POST", BASE, { body, events: true });
+    if (!params.wait) return stream;
+    return this.waitForDeploy(stream);
+  }
+  async waitForDeploy(stream) {
+    for await (const ev of stream) {
+      if (ev.event === "complete") return endpointFromComplete(ev.data);
+      if (ev.event === "error") throw deployError(ev.data);
+    }
+    throw new ParetaError("deploy stream ended without a 'complete' event");
+  }
+  list() {
+    return this.client.request("GET", BASE, { cast: endpointList });
+  }
+  retrieve(endpointId) {
+    return this.client.request("GET", `${BASE}/${endpointId}`, {
+      cast: (raw) => new Endpoint(raw)
+    });
+  }
+  start(endpointId) {
+    return this.client.request("POST", `${BASE}/${endpointId}/start`);
+  }
+  stop(endpointId) {
+    return this.client.request("POST", `${BASE}/${endpointId}/stop`);
+  }
+  async delete(endpointId) {
+    await this.client.request("DELETE", `${BASE}/${endpointId}`);
+  }
+  metrics(endpointId) {
+    return new EndpointMetrics(this.client, endpointId);
+  }
+};
+
+// src/resources/tasks.ts
+var BASE2 = "/v1/tasks";
+var Tasks = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  list() {
+    return this.client.request("GET", BASE2, { cast: taskList });
+  }
+  retrieve(taskId, opts = {}) {
+    const params = opts.examplesN !== void 0 ? { examples_n: opts.examplesN } : void 0;
+    return this.client.request("GET", `${BASE2}/${taskId}`, {
+      params,
+      cast: (raw) => new Task(raw)
+    });
+  }
+  /** Free-text intent → ranked candidate tasks (the Step-0 backend matcher). */
+  match(query, opts = {}) {
+    if (!query || !query.trim()) throw new ParetaError("query is required");
+    return this.client.request("POST", `${BASE2}/match`, {
+      body: { query, top_k: opts.topK ?? 5 },
+      cast: (raw) => new TaskMatch(raw)
+    });
+  }
+  /** Models ranked by quality/cost for a task (+ recommended + frontier baseline). */
+  leaderboard(taskId) {
+    return this.client.request("GET", `${BASE2}/${taskId}/leaderboard`, {
+      cast: leaderboardFrom
+    });
+  }
+  /** The task's recommended deployable model — what deploy(model:"recommended") resolves to. */
+  async recommended(taskId) {
+    return (await this.leaderboard(taskId)).recommended;
+  }
+};
+
+// src/resources/evals.ts
+var BASE3 = "/v1/eval-sets";
+var RUNS = "/v1/eval-runs";
+var FRONTIER = "/v1/eval/frontier-models";
+var INLINE_MAX = 5 * 1024 * 1024;
+var MIME_BY_EXT = {
+  pdf: "application/pdf",
+  png: "image/png",
+  jpg: "image/jpeg",
+  jpeg: "image/jpeg",
+  gif: "image/gif",
+  webp: "image/webp",
+  tiff: "image/tiff",
+  tif: "image/tiff",
+  bmp: "image/bmp",
+  txt: "text/plain",
+  json: "application/json",
+  jsonl: "application/jsonl",
+  csv: "text/csv"
+};
+function guessMime(filename, override) {
+  if (override) return override;
+  const ext = filename.split(".").pop()?.toLowerCase();
+  return ext && MIME_BY_EXT[ext] || "application/octet-stream";
+}
+async function toBlob(file, mimeOverride) {
+  if (typeof file === "string") {
+    const [{ readFile }, { basename }] = await Promise.all([
+      import('fs/promises'),
+      import('path')
+    ]);
+    const buf = await readFile(file);
+    const filename = basename(file);
+    const mime2 = guessMime(filename, mimeOverride);
+    return { blob: new Blob([buf], { type: mime2 }), filename, size: buf.byteLength, mime: mime2 };
+  }
+  if (file instanceof Blob) {
+    const mime2 = mimeOverride || file.type || "application/octet-stream";
+    const blob = mimeOverride ? new Blob([file], { type: mime2 }) : file;
+    return { blob, filename: "upload", size: file.size, mime: mime2 };
+  }
+  const bytes = file instanceof Uint8Array ? file : new Uint8Array(file);
+  const mime = mimeOverride || "application/octet-stream";
+  return { blob: new Blob([bytes], { type: mime }), filename: "upload", size: bytes.byteLength, mime };
+}
+function itemsJsonl(task, items, name) {
+  if (!items || items.length === 0) throw new ParetaError("items is required and must be non-empty");
+  const jsonl = items.map((it) => JSON.stringify(it)).join("\n");
+  return {
+    files: { items: { filename: `items.${task}.jsonl`, content: jsonl, contentType: "application/jsonl" } },
+    data: { task_id: task, name: name || `sdk eval set (${items.length} items)` }
+  };
+}
+function mergeCandidates(models, frontierIds) {
+  const cands = [...models ?? [], ...frontierIds ?? []];
+  if (cands.length === 0) throw new ParetaError("models is required (the open candidates to evaluate)");
+  return cands;
+}
+function resolveFrontierFromRoster(frontier, roster) {
+  if (frontier === "all") return roster.map((m) => m.id).filter((x) => x != null);
+  if (frontier === "benchmarked") {
+    return roster.filter((m) => m.benchmarked).map((m) => m.id).filter((x) => x != null);
+  }
+  throw new ParetaError(
+    `unknown frontier keyword '${frontier}' (use 'all'/'benchmarked'/'none' or a list)`
+  );
+}
+var sleep = (seconds) => new Promise((r) => setTimeout(r, seconds * 1e3));
+var EvalSets = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  create(params) {
+    const { files, data } = itemsJsonl(params.task, params.items, params.name);
+    return this.client.request("POST", BASE3, { files, data, cast: evalSetFromCreate });
+  }
+  list() {
+    return this.client.request("GET", BASE3, { cast: evalSetList });
+  }
+  async retrieve(evalSetId) {
+    const raw = await this.client.request("GET", `${BASE3}/${evalSetId}`);
+    return new EvalSet((raw ?? {}).eval_set ?? {});
+  }
+  async delete(evalSetId) {
+    await this.client.request("DELETE", `${BASE3}/${evalSetId}`);
+  }
+  /**
+   * Attach a binary doc (PDF/image) to one row's blob field. Collapses the
+   * 3-call signed-URL flow (or the inline path for small files) into one call.
+   * `idx` is the 0-based row, `fieldName` the blob input field.
+   */
+  async uploadDocument(evalSetId, file, opts) {
+    const { blob, filename, size, mime } = await toBlob(file, opts.mime);
+    if (size < INLINE_MAX) {
+      return this.client.request("POST", `${BASE3}/${evalSetId}/attach-blob`, {
+        files: { file: { filename, content: blob, contentType: mime } },
+        data: { idx: String(opts.idx), field_name: opts.fieldName, mime }
+      });
+    }
+    const minted = await this.client.request(
+      "POST",
+      `${BASE3}/${evalSetId}/blob-upload-url`,
+      { body: { idx: opts.idx, field_name: opts.fieldName, mime, file_size: size } }
+    );
+    const put = await globalThis.fetch(minted.upload_url, {
+      method: "PUT",
+      body: blob,
+      headers: { "Content-Type": mime },
+      signal: AbortSignal.timeout(6e5)
+    });
+    if (put.status !== 200 && put.status !== 201) {
+      throw new ParetaError(`blob upload PUT failed: ${put.status}`);
+    }
+    return this.client.request("POST", `${BASE3}/${evalSetId}/blob-upload-complete`, {
+      body: { idx: opts.idx, field_name: opts.fieldName, storage_uri: minted.storage_uri, mime }
+    });
+  }
+};
+var EvalRuns = class {
+  constructor(client, sets) {
+    this.client = client;
+    this.sets = sets;
+  }
+  client;
+  sets;
+  async frontierIds(frontier, evalSet, task) {
+    if (frontier == null || frontier === "none") return [];
+    if (Array.isArray(frontier)) return [...frontier];
+    if (typeof frontier !== "string") {
+      throw new TypeError("frontier must be null, a list of ids, or 'all'/'benchmarked'/'none'");
+    }
+    let resolveTask = task;
+    if (!resolveTask && evalSet) resolveTask = (await this.sets.retrieve(evalSet)).taskId ?? void 0;
+    if (!resolveTask) throw new ParetaError("cannot resolve a frontier keyword without a task");
+    const roster = await this.client.request("GET", FRONTIER, {
+      params: { task: resolveTask },
+      cast: frontierModels
+    });
+    return resolveFrontierFromRoster(frontier, roster);
+  }
+  async create(params) {
+    let evalSet = params.evalSet;
+    if (evalSet == null) {
+      if (!(params.task && params.items)) {
+        throw new ParetaError("pass evalSet: <id>, or task + items to create one");
+      }
+      evalSet = (await this.sets.create({ task: params.task, items: params.items, name: params.name })).id ?? void 0;
+    }
+    const frontierIds = await this.frontierIds(params.frontier, evalSet, params.task);
+    const candidateModelIds = mergeCandidates(params.models, frontierIds);
+    const started = await this.client.request("POST", RUNS, {
+      body: { eval_set_id: evalSet, candidate_model_ids: candidateModelIds }
+    });
+    if (params.wait) {
+      return this.wait(started.run_id, { pollInterval: params.pollInterval, timeout: params.timeout });
+    }
+    return new EvalRun({ run: { id: started.run_id, status: started.status } });
+  }
+  retrieve(runId) {
+    return this.client.request("GET", `${RUNS}/${runId}`, {
+      cast: (raw) => new EvalRun(raw)
+    });
+  }
+  async wait(runId, opts = {}) {
+    const pollInterval = opts.pollInterval ?? 3;
+    const timeout = opts.timeout ?? 900;
+    const deadline = Date.now() + timeout * 1e3;
+    for (; ; ) {
+      const run = await this.retrieve(runId);
+      if (run.isTerminal) return run;
+      if (Date.now() >= deadline) {
+        throw new ParetaError(`eval run ${runId} did not finish within ${Math.round(timeout)}s`);
+      }
+      await sleep(pollInterval);
+    }
+  }
+};
+var Evals = class {
+  sets;
+  runs;
+  constructor(client) {
+    this.sets = new EvalSets(client);
+    this.runs = new EvalRuns(client, this.sets);
+    this.client = client;
+  }
+  client;
+  /**
+   * The frontier (vendor) roster you can evaluate against. With `task`, each is
+   * annotated `benchmarked` + the roster is vision-filtered for document tasks.
+   */
+  frontierModels(task) {
+    const params = task ? { task } : void 0;
+    return this.client.request("GET", FRONTIER, { params, cast: frontierModels });
+  }
+};
+
+// src/client.ts
+var DEFAULT_BASE_URL = "https://api.pareta.ai";
+var DEFAULT_TIMEOUT_MS = 6e4;
+var DEFAULT_MAX_RETRIES = 2;
+var RETRY_STATUSES = /* @__PURE__ */ new Set([408, 409, 429, 500, 502, 503, 504]);
+function normalizeBaseURL(url) {
+  return url.replace(/\/+$/, "");
+}
+var Pareta = class _Pareta {
+  apiKey;
+  baseURL;
+  timeout;
+  maxRetries;
+  fetchImpl;
+  // Resource namespaces (assigned in the constructor; filled in slice by slice).
+  chat;
+  models;
+  endpoints;
+  tasks;
+  evals;
+  constructor(options = {}) {
+    if (!options.apiKey) {
+      throw new ParetaError(
+        "missing API key. Pass apiKey: \u2026 or use Pareta.fromEnv() with PARETA_API_KEY (mint a pareta_sk_ key in the dashboard)."
+      );
+    }
+    this.apiKey = options.apiKey;
+    this.baseURL = normalizeBaseURL(options.baseURL || DEFAULT_BASE_URL);
+    this.timeout = options.timeout ?? DEFAULT_TIMEOUT_MS;
+    this.maxRetries = Math.max(0, Math.trunc(options.maxRetries ?? DEFAULT_MAX_RETRIES));
+    const f = options.fetch ?? globalThis.fetch;
+    if (typeof f !== "function") {
+      throw new ParetaError("no fetch implementation found \u2014 pass fetch: \u2026 (Node < 18 needs a polyfill).");
+    }
+    this.fetchImpl = options.fetch ? f : f.bind(globalThis);
+    this.chat = new Chat(this);
+    this.models = new Models(this);
+    this.endpoints = new Endpoints(this);
+    this.tasks = new Tasks(this);
+    this.evals = new Evals(this);
+  }
+  /** Build from PARETA_API_KEY (+ optional PARETA_BASE_URL); explicit opts win. */
+  static fromEnv(options = {}) {
+    const env = typeof process !== "undefined" && process.env ? process.env : {};
+    return new _Pareta({
+      ...options,
+      apiKey: options.apiKey || env.PARETA_API_KEY,
+      baseURL: options.baseURL || env.PARETA_BASE_URL
+    });
+  }
+  // ── header / url / retry helpers ─────────────────────────────────────
+  headers(opts) {
+    const h = {
+      Authorization: `Bearer ${this.apiKey}`,
+      Accept: opts.stream ? "text/event-stream" : "application/json",
+      "User-Agent": `pareta-typescript/${VERSION}`
+    };
+    if (opts.jsonBody) h["Content-Type"] = "application/json";
+    return h;
+  }
+  shouldRetry(status) {
+    return RETRY_STATUSES.has(status);
+  }
+  /** Seconds to wait before retry `attempt` (0-indexed). Overridable in tests. */
+  _backoff(attempt, retryAfter) {
+    if (retryAfter !== null && retryAfter >= 0) return Math.min(retryAfter, 30);
+    return Math.min(0.5 * 2 ** attempt, 8) + Math.random() * 0.25;
+  }
+  /** Sleep `seconds`. Overridable in tests to skip real waits. */
+  _sleep(seconds) {
+    return new Promise((resolve) => setTimeout(resolve, seconds * 1e3));
+  }
+  retryAfterSeconds(res) {
+    const val = res.headers.get("retry-after");
+    if (!val) return null;
+    const n = Number.parseFloat(val);
+    return Number.isNaN(n) ? null : n;
+  }
+  buildURL(path, params) {
+    let url = `${this.baseURL}${path}`;
+    if (params) {
+      const qs = new URLSearchParams();
+      for (const [k, v] of Object.entries(params)) {
+        if (v !== void 0 && v !== null) qs.append(k, String(v));
+      }
+      const s = qs.toString();
+      if (s) url += `?${s}`;
+    }
+    return url;
+  }
+  buildFormData(files, data) {
+    const fd = new FormData();
+    if (data) for (const [k, v] of Object.entries(data)) fd.append(k, v);
+    if (files) {
+      for (const [k, f] of Object.entries(files)) {
+        const blob = f.content instanceof Blob ? f.content : new Blob([f.content], f.contentType ? { type: f.contentType } : void 0);
+        fd.append(k, blob, f.filename);
+      }
+    }
+    return fd;
+  }
+  wrapFetchError(e) {
+    const name = e?.name;
+    if (name === "TimeoutError" || name === "AbortError") {
+      return new APITimeoutError(void 0, { cause: e });
+    }
+    const msg = e?.message || "connection error";
+    return new APIConnectionError(msg, { cause: e });
+  }
+  async parseError(res) {
+    const requestId = res.headers.get("x-request-id");
+    let detail;
+    try {
+      const body = await res.json();
+      detail = body && typeof body === "object" && !Array.isArray(body) ? body.detail : body;
+    } catch {
+      detail = void 0;
+    }
+    return errorFromResponse(res.status, { detail, requestId, response: res });
+  }
+  // ── transport ────────────────────────────────────────────────────────
+  async request(method, path, opts = {}) {
+    const { body, params, files, data, cast } = opts;
+    const url = this.buildURL(path, params);
+    const isMultipart = files != null || data != null;
+    const headers = this.headers({ jsonBody: body != null && !isMultipart });
+    let payload;
+    if (isMultipart) {
+      payload = this.buildFormData(files, data);
+    } else if (body != null) {
+      payload = JSON.stringify(body);
+    }
+    let lastExc;
+    for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
+      let res;
+      try {
+        res = await this.fetchImpl(url, {
+          method,
+          headers,
+          body: payload,
+          signal: AbortSignal.timeout(this.timeout)
+        });
+      } catch (e) {
+        lastExc = this.wrapFetchError(e);
+        if (attempt < this.maxRetries) {
+          await this._sleep(this._backoff(attempt, null));
+          continue;
+        }
+        break;
+      }
+      if (res.ok) {
+        const text = await res.text();
+        const raw = text ? JSON.parse(text) : {};
+        return cast ? cast(raw) : raw;
+      }
+      if (attempt < this.maxRetries && this.shouldRetry(res.status)) {
+        await res.text().catch(() => void 0);
+        await this._sleep(this._backoff(attempt, this.retryAfterSeconds(res)));
+        continue;
+      }
+      throw await this.parseError(res);
+    }
+    throw lastExc;
+  }
+  /**
+   * Yield parsed SSE objects. Retries ONLY the initial connect/handshake — once
+   * bytes are flowing a mid-stream drop raises (re-issuing would re-run a
+   * metered generation / re-trigger a deploy). `events:true` → `{event,data}`.
+   */
+  async *stream(method, path, opts = {}) {
+    const { body, params, cast, events } = opts;
+    const url = this.buildURL(path, params);
+    const headers = this.headers({ stream: true, jsonBody: body != null });
+    const payload = body != null ? JSON.stringify(body) : void 0;
+    for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
+      let started = false;
+      try {
+        const res = await this.fetchImpl(url, {
+          method,
+          headers,
+          body: payload,
+          signal: AbortSignal.timeout(this.timeout)
+        });
+        if (!res.ok) {
+          if (attempt < this.maxRetries && this.shouldRetry(res.status)) {
+            await res.text().catch(() => void 0);
+            await this._sleep(this._backoff(attempt, this.retryAfterSeconds(res)));
+            continue;
+          }
+          throw await this.parseError(res);
+        }
+        if (!res.body) throw new APIConnectionError("response had no body to stream");
+        started = true;
+        const reader = res.body.getReader();
+        if (events) {
+          for await (const ev of parseSSE(reader, { events: true })) {
+            yield ev;
+          }
+        } else {
+          for await (const obj of parseSSE(reader)) {
+            yield cast ? cast(obj) : obj;
+          }
+        }
+        return;
+      } catch (e) {
+        if (e instanceof ParetaError && e.status !== void 0) throw e;
+        const wrapped = this.wrapFetchError(e);
+        if (started || attempt >= this.maxRetries) throw wrapped;
+        await this._sleep(this._backoff(attempt, null));
+      }
+    }
+  }
+};
+
+export { APIConnectionError, APIStatusError, APITimeoutError, AuthenticationError, BadRequestError, BaseModel, ChatCompletion, ChatCompletionChunk, Choice, ConflictError, Endpoint, EndpointMetrics, EndpointNotReadyError, EvalResult, EvalRun, EvalRuns, EvalSet, EvalSets, FrontierModel, InsufficientCreditsError, Leaderboard, LeaderboardEntry, Message, Model, ModelList, NotFoundError, Pareta, ParetaError, PermissionDeniedError, RateLimitError, Task, TaskMatch, TaskMatchCandidate, Usage, VERSION };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map