@bytesbrains/cruise 0.0.0-stage → 0.12.0

package/dist/chunk-FGLMW5IY.mjs

@@ -0,0 +1,575 @@
+#!/usr/bin/env node
+// Built by packages/cli/build.ts.
+import {
+  outcomeOf
+} from "./chunk-XOH3XKM3.mjs";
+import {
+  tokenCount,
+  usageFromJson
+} from "./chunk-ICJVJSTC.mjs";
+import {
+  checkLimits,
+  requiredCapabilities
+} from "./chunk-LALZUKEC.mjs";
+
+// src/reservation-search.ts
+function searchInputBound(model, body, promptTokens) {
+  const search = webSearch(body);
+  if (!search.present) return promptTokens;
+  const window = model.maxContext;
+  if (!searchBoundedByHost(model) || search.maxUses === null || typeof window !== "number" || window <= 0) return null;
+  return Math.min(promptTokens, window) + search.maxUses * window;
+}
+
+// src/reservation.ts
+var TOKENS_PER_MTOK = 1e6;
+function promptTokenBound(raw) {
+  return new TextEncoder().encode(raw).byteLength;
+}
+function projectCapFor(model, projectDefault) {
+  if (projectDefault === null) return null;
+  return model.maxOutput === null ? projectDefault : Math.min(projectDefault, model.maxOutput);
+}
+function requestedOutput(body) {
+  const requested = body.max_tokens ?? body.max_completion_tokens;
+  return typeof requested === "number" && Number.isInteger(requested) && requested >= 0 ? requested : null;
+}
+function dearestRates(rows) {
+  let input = 0;
+  let output = 0;
+  for (const row of rows) {
+    input = Math.max(input, row.input_micros_per_mtok);
+    output = Math.max(output, row.output_micros_per_mtok);
+  }
+  return { input, output };
+}
+function boundFor(candidates, priceRows, body, raw, projectDefault = null) {
+  const bodyTokens = promptTokenBound(raw);
+  const stated = requestedOutput(body);
+  let micros = 0;
+  let dearest = "";
+  let promptTokens = bodyTokens;
+  let outputTokens = 0;
+  for (const model of candidates) {
+    const rows = priceRows.get(model.id);
+    if (rows === void 0 || rows.length === 0) return { ok: false, model: model.id, reason: "unpriced" };
+    const rates = dearestRates(rows);
+    const input = searchInputBound(model, body, bodyTokens);
+    if (input === null) return { ok: false, model: model.id, reason: "search_input_unbounded" };
+    const output = stated ?? projectCapFor(model, projectDefault) ?? model.defaultOutput ?? model.maxOutput;
+    if (output === null || output === void 0) {
+      return { ok: false, model: model.id, reason: "no_output_limit" };
+    }
+    const worst = Math.ceil((input * rates.input + output * rates.output) / TOKENS_PER_MTOK);
+    if (worst > micros) {
+      micros = worst;
+      dearest = model.id;
+      promptTokens = input;
+      outputTokens = output;
+    }
+  }
+  return { ok: true, micros, dearest, promptTokens, outputTokens };
+}
+
+// src/lanes.ts
+var LANE_PREFIX = "bb/";
+var CONTRIBUTOR_LANE_PREFIX = "oss/";
+var SLUG = /^[a-z0-9][a-z0-9-]{0,63}$/;
+
+// src/routing-image.ts
+var TOKENS_PER_MTOK2 = 1e6;
+var AUTO = "auto";
+var MAX_IMAGES_PER_REQUEST = 10;
+function imageRequestOf(body) {
+  const size = body.size === void 0 || body.size === null ? AUTO : body.size;
+  const quality = body.quality === void 0 || body.quality === null ? AUTO : body.quality;
+  if (typeof size !== "string" || typeof quality !== "string") return null;
+  const asked = body.n;
+  if (asked === void 0 || asked === null) return { size, quality, n: 1 };
+  if (typeof asked !== "number" || !Number.isSafeInteger(asked) || asked < 1) return null;
+  return { size, quality, n: asked };
+}
+async function variantsFor(db, modelIds) {
+  const byModel = /* @__PURE__ */ new Map();
+  if (modelIds.length === 0) return byModel;
+  const placeholders = modelIds.map(() => "?").join(", ");
+  const { results } = await db.prepare(
+    `SELECT model, size, quality, output_tokens, measured_at
+         FROM model_image_variants
+        WHERE model IN (${placeholders})
+        ORDER BY model, output_tokens`
+  ).bind(...modelIds).all();
+  for (const row of results) {
+    const list = byModel.get(row.model) ?? [];
+    list.push({
+      size: row.size,
+      quality: row.quality,
+      outputTokens: row.output_tokens,
+      measuredAt: row.measured_at
+    });
+    byModel.set(row.model, list);
+  }
+  return byModel;
+}
+function resolveVariant(model, variants, asked) {
+  const measured = variants.filter((v) => v.outputTokens !== null);
+  if (measured.length === 0) {
+    return {
+      ok: false,
+      message: `Model '${model.id}' has no measured image variants, so an image request to it cannot be bounded. Variants are measured by the conformance suite (#10, #227).`
+    };
+  }
+  if (asked.size === AUTO || asked.quality === AUTO) {
+    const dearest = measured.reduce((worst, v) => (v.outputTokens ?? 0) > (worst.outputTokens ?? 0) ? v : worst);
+    return { ok: true, outputTokens: dearest.outputTokens, variant: `${dearest.size}/${dearest.quality}` };
+  }
+  const exact = measured.find((v) => v.size === asked.size && v.quality === asked.quality);
+  if (exact === void 0) {
+    const offered = measured.map((v) => `${v.size}/${v.quality}`).join(", ");
+    return {
+      ok: false,
+      message: `Model '${model.id}' has no measured cost for size '${asked.size}' at quality '${asked.quality}', so a request for it cannot be bounded. Measured variants: ${offered}.`
+    };
+  }
+  return { ok: true, outputTokens: exact.outputTokens, variant: `${exact.size}/${exact.quality}` };
+}
+function resolveComponentImageVariant(model, rows, asked) {
+  const imageRows = rows.filter((row) => row.component === "image");
+  if (imageRows.length === 0) {
+    return {
+      ok: false,
+      message: `Model '${model.id}' has no image component price in force, so an image request to it cannot be bounded (#240).`
+    };
+  }
+  if (asked.size === AUTO || asked.quality === AUTO) return { ok: true };
+  if (imageRows.some((row) => row.variant === "" || row.variant === `${asked.size}/${asked.quality}`)) {
+    return { ok: true };
+  }
+  const offered = imageRows.map((row) => row.variant === "" ? "(flat)" : row.variant).join(", ");
+  return {
+    ok: false,
+    message: `Model '${model.id}' has no image price for size '${asked.size}' at quality '${asked.quality}'. Priced variants: ${offered}.`
+  };
+}
+function imageBoundFor(candidates, priceRows, variants, asked, raw) {
+  const promptTokens = promptTokenBound(raw);
+  let micros = 0;
+  let dearest = "";
+  let outputTokens = 0;
+  for (const model of candidates) {
+    const rows = priceRows.get(model.id);
+    if (rows === void 0 || rows.length === 0) return { ok: false, model: model.id, reason: "unpriced" };
+    const variant = resolveVariant(model, variants.get(model.id) ?? [], asked);
+    if (!variant.ok) return { ok: false, model: model.id, reason: "unmeasured_variant" };
+    const rates = dearestRates(rows);
+    const output = variant.outputTokens * asked.n;
+    const worst = Math.ceil((promptTokens * rates.input + output * rates.output) / TOKENS_PER_MTOK2);
+    if (worst > micros) {
+      micros = worst;
+      dearest = model.id;
+      outputTokens = output;
+    }
+  }
+  return { ok: true, micros, dearest, promptTokens, outputTokens };
+}
+function componentImageBoundFor(candidates, componentRows) {
+  for (const model of candidates) {
+    const rows = componentRows.get(model.id) ?? [];
+    if (!rows.some((row) => row.component === "image")) {
+      return { ok: false, model: model.id, reason: "unpriced" };
+    }
+  }
+  return { ok: true, micros: 0, dearest: candidates[0]?.id ?? "", promptTokens: 0, outputTokens: 0 };
+}
+
+// src/reading-image.ts
+function usageFromImageJson(body) {
+  const usage = body?.usage;
+  if (!usage) return null;
+  const input = tokenCount(usage.input_tokens);
+  const output = tokenCount(usage.output_tokens);
+  if (input === null || output === null) {
+    console.warn(
+      `Refusing implausible image usage from upstream: input=${String(usage.input_tokens)} output=${String(usage.output_tokens)}. Recorded as no_usage and charged the reservation.`
+    );
+    return null;
+  }
+  const rawImageInput = usage.input_tokens_details?.image_tokens;
+  const imageInput = rawImageInput === void 0 || rawImageInput === null ? 0 : tokenCount(rawImageInput);
+  if (imageInput === null || imageInput > 0) {
+    console.warn(
+      `Image request reported ${String(rawImageInput)} image input token(s), which this ledger has no rate for (#228). Recorded as no_usage and charged the reservation rather than billed at the text rate.`
+    );
+    return null;
+  }
+  return { prompt_tokens: input, completion_tokens: output, reasoning_tokens: 0, cached_input_tokens: 0 };
+}
+function imageOutcomeOf(body, priced, hadUsage) {
+  const data = body?.data;
+  const images = Array.isArray(data) ? data.filter((entry) => {
+    const image = entry;
+    return typeof image?.b64_json === "string" && image.b64_json !== "" || typeof image?.url === "string" && image.url !== "";
+  }) : [];
+  if (images.length === 0) return "empty";
+  if (!hadUsage) return "no_usage";
+  return priced ? "served" : "unpriced";
+}
+
+// src/speech-elevenlabs.ts
+var ELEVENLABS = "elevenlabs";
+var FORMATS = {
+  mp3: "mp3_44100_128",
+  opus: "opus_48000_128",
+  pcm: "pcm_24000",
+  wav: "wav_24000"
+};
+function elevenLabsFormat(format) {
+  return FORMATS[format] ?? null;
+}
+function elevenLabsVoiceOk(voice) {
+  return typeof voice === "string" && /^[A-Za-z0-9_-]{1,64}$/.test(voice);
+}
+
+// src/routing-speech.ts
+var OPENAI_FORMATS = ["mp3", "opus", "aac", "flac", "wav", "pcm"];
+var DEFAULT_FORMAT = "mp3";
+function speechRequestOf(body) {
+  if (typeof body.input !== "string" || body.input.length === 0) return null;
+  const raw = body.response_format;
+  if (raw !== void 0 && raw !== null && !OPENAI_FORMATS.includes(raw)) return null;
+  return {
+    input: body.input,
+    characters: characterCount(body),
+    voice: body.voice,
+    format: raw === void 0 || raw === null ? DEFAULT_FORMAT : raw
+  };
+}
+function checkSpeechLimits(model, body) {
+  if (body.stream_format === "sse") {
+    return {
+      ok: false,
+      code: "unsupported_capability",
+      message: `'stream_format: sse' is not served on /v1/audio/speech. Audio is passed through as bytes and nothing is parsed from it; an event stream is a shape this route does not carry (#229).`
+    };
+  }
+  const asked = speechRequestOf(body);
+  if (asked === null) {
+    return {
+      ok: false,
+      message: `'input' must be a non-empty string and 'response_format', when present, one of ${OPENAI_FORMATS.join(", ")}. The length of 'input' is the bill, so a value that cannot be counted is a request that cannot be bounded.`
+    };
+  }
+  if (model.maxInputChars !== null && asked.characters > model.maxInputChars) {
+    return {
+      ok: false,
+      message: `Model '${model.id}' accepts at most ${model.maxInputChars} characters of input, and ${asked.characters} were sent. Refused here rather than reserved for and then refused upstream, since the count is the bill.`
+    };
+  }
+  if (model.upstreamId === ELEVENLABS) {
+    if (!elevenLabsVoiceOk(asked.voice)) {
+      return {
+        ok: false,
+        message: `'voice' must be an ElevenLabs voice id \u2014 letters, digits, '-' and '_' \u2014 for model '${model.id}'. It is sent as a path segment, so nothing else can be.`
+      };
+    }
+    if (elevenLabsFormat(asked.format) === null) {
+      return {
+        ok: false,
+        code: "unsupported_capability",
+        message: `Model '${model.id}' cannot produce '${asked.format}'. ElevenLabs serves mp3, opus, pcm and wav; aac and flac have no output format there and are refused before anything is sent (#229).`
+      };
+    }
+    return { ok: true };
+  }
+  if (asked.voice === void 0 || asked.voice === null) {
+    return { ok: false, message: `'voice' is required.` };
+  }
+  return { ok: true };
+}
+function speechBoundFor(candidates, characterRows) {
+  for (const model of candidates) {
+    const rows = characterRows.get(model.id) ?? [];
+    if (!rows.some((row) => row.component === "character")) {
+      return { ok: false, model: model.id, reason: "unpriced" };
+    }
+  }
+  return { ok: true, micros: 0, dearest: candidates[0]?.id ?? "", promptTokens: 0, outputTokens: 0 };
+}
+function usageFromSpeech(_parsed) {
+  return { prompt_tokens: 0, completion_tokens: 0, reasoning_tokens: 0, cached_input_tokens: 0 };
+}
+function speechOutcomeOf(parsed, priced, _hadUsage) {
+  if (typeof parsed !== "number" || parsed <= 0) return "empty";
+  return priced ? "served" : "unpriced";
+}
+
+// src/routing-embeddings.ts
+var TOKENS_PER_MTOK3 = 1e6;
+function hasInput(body) {
+  const input = body.input;
+  if (typeof input === "string") return input.length > 0;
+  return Array.isArray(input) && input.length > 0;
+}
+function checkEmbeddingLimits(_model, body) {
+  if (body.stream === true) {
+    return {
+      ok: false,
+      code: "unsupported_capability",
+      message: `Streaming is not served on /v1/embeddings. No host here streams an embedding, and a route that half works over-bills (#230).`
+    };
+  }
+  if (!hasInput(body)) {
+    return {
+      ok: false,
+      message: `'input' must be a non-empty string, or a non-empty array of strings or token ids. A request with nothing to embed cannot produce a vector, and is refused before it holds a reservation.`
+    };
+  }
+  return { ok: true };
+}
+function embeddingBoundFor(candidates, priceRows, raw) {
+  const promptTokens = promptTokenBound(raw);
+  let micros = 0;
+  let dearest = "";
+  for (const model of candidates) {
+    const rows = priceRows.get(model.id);
+    if (rows === void 0 || rows.length === 0) return { ok: false, model: model.id, reason: "unpriced" };
+    const worst = Math.ceil(promptTokens * dearestRates(rows).input / TOKENS_PER_MTOK3);
+    if (worst > micros || dearest === "") {
+      micros = worst;
+      dearest = model.id;
+    }
+  }
+  return { ok: true, micros, dearest, promptTokens, outputTokens: 0 };
+}
+function usageFromEmbedding(body) {
+  const usage = body?.usage;
+  if (!usage) return null;
+  const prompt = tokenCount(usage.prompt_tokens);
+  if (prompt === null) {
+    console.warn(
+      `Refusing implausible embedding usage from upstream: prompt=${String(usage.prompt_tokens)}. Recorded as no_usage and charged the reservation.`
+    );
+    return null;
+  }
+  const total = tokenCount(usage.total_tokens) ?? 0;
+  return { prompt_tokens: Math.max(prompt, total), completion_tokens: 0, reasoning_tokens: 0, cached_input_tokens: 0 };
+}
+function embeddingOutcomeOf(body, priced, hadUsage) {
+  const data = body?.data;
+  const vectors = Array.isArray(data) ? data.filter((entry) => {
+    const vector = entry?.embedding;
+    return Array.isArray(vector) && vector.length > 0 || typeof vector === "string" && vector !== "";
+  }) : [];
+  if (vectors.length === 0) return "empty";
+  if (!hadUsage) return "no_usage";
+  return priced ? "served" : "unpriced";
+}
+
+// src/route-spec.ts
+var ROUTES = {};
+var CHAT_ROUTE = {
+  modality: "chat",
+  path: "/v1/chat/completions",
+  capabilities: requiredCapabilities,
+  limits: (_db, model, body) => Promise.resolve(checkLimits(model, body)),
+  bound: (_db, candidates, priceRows, body, raw, projectDefault) => Promise.resolve(boundFor([...candidates], priceRows, body, raw, projectDefault)),
+  reading: { usage: usageFromJson, outcome: outcomeOf }
+};
+var IMAGE_ROUTE = {
+  modality: "image",
+  path: "/v1/images/generations",
+  capabilities: () => [],
+  async limits(db, model, body) {
+    if (body.stream === true) {
+      return {
+        ok: false,
+        code: "unsupported_capability",
+        message: `Streaming is not served on /v1/images/generations. The host does serve a partial-image stream there and nothing has measured it, so it is a route that does not exist yet rather than one that half works (#227).`
+      };
+    }
+    const asked = imageRequestOf(body);
+    if (asked === null) {
+      return {
+        ok: false,
+        message: `'size' and 'quality' must be strings and 'n' a positive integer. 'n' multiplies what the request is allowed to cost, so a value that cannot be read is a bill that cannot be bounded.`
+      };
+    }
+    if (asked.n > MAX_IMAGES_PER_REQUEST) {
+      return {
+        ok: false,
+        message: `'n' is ${asked.n}; the host generates at most ${MAX_IMAGES_PER_REQUEST} images per request. Refused here rather than reserved for and then refused upstream, since 'n' multiplies the bound.`
+      };
+    }
+    if (model.pricedBy === "component") {
+      const rows = await componentRowsInForce(db, model.id, /* @__PURE__ */ new Date());
+      const verdict2 = resolveComponentImageVariant(model, rows, asked);
+      return verdict2.ok ? { ok: true } : { ok: false, message: verdict2.message };
+    }
+    const variants = await variantsFor(db, [model.id]);
+    const verdict = resolveVariant(model, variants.get(model.id) ?? [], asked);
+    return verdict.ok ? { ok: true } : { ok: false, message: verdict.message };
+  },
+  async bound(db, candidates, priceRows, body, raw) {
+    const asked = imageRequestOf(body);
+    if (asked === null) return { ok: false, model: candidates[0]?.id ?? "", reason: "no_output_limit" };
+    const component = candidates.filter((c) => c.pricedBy === "component");
+    const token = candidates.filter((c) => c.pricedBy !== "component");
+    if (component.length > 0) {
+      const rows = await componentRowsInForceFor(
+        db,
+        component.map((c) => c.id),
+        /* @__PURE__ */ new Date()
+      );
+      const part = componentImageBoundFor(component, rows);
+      if (!part.ok) return part;
+    }
+    if (token.length === 0) {
+      return { ok: true, micros: 0, dearest: candidates[0]?.id ?? "", promptTokens: 0, outputTokens: 0 };
+    }
+    const variants = await variantsFor(
+      db,
+      token.map((c) => c.id)
+    );
+    return imageBoundFor(token, priceRows, variants, asked, raw);
+  },
+  reading: { usage: usageFromImageJson, outcome: imageOutcomeOf }
+};
+ROUTES[CHAT_ROUTE.modality] = CHAT_ROUTE;
+ROUTES[IMAGE_ROUTE.modality] = IMAGE_ROUTE;
+var SPEECH_ROUTE = {
+  modality: "speech",
+  path: "/v1/audio/speech",
+  capabilities: () => [],
+  limits: (_db, model, body) => Promise.resolve(checkSpeechLimits(model, body)),
+  async bound(db, candidates) {
+    const rows = await componentRowsInForceFor(db, candidates.map((c) => c.id), /* @__PURE__ */ new Date());
+    return speechBoundFor(candidates, rows);
+  },
+  reading: { body: "bytes", usage: usageFromSpeech, outcome: speechOutcomeOf }
+};
+ROUTES[SPEECH_ROUTE.modality] = SPEECH_ROUTE;
+var EMBEDDING_ROUTE = {
+  modality: "embedding",
+  path: "/v1/embeddings",
+  capabilities: () => [],
+  limits: (_db, model, body) => Promise.resolve(checkEmbeddingLimits(model, body)),
+  bound: (_db, candidates, priceRows, _body, raw) => Promise.resolve(embeddingBoundFor(candidates, priceRows, raw)),
+  reading: { usage: usageFromEmbedding, outcome: embeddingOutcomeOf }
+};
+ROUTES[EMBEDDING_ROUTE.modality] = EMBEDDING_ROUTE;
+
+// src/chat-openai-responses-stream.ts
+var encoder = new TextEncoder();
+
+// src/chat-perplexity-agent.ts
+var PERPLEXITY_UPSTREAM = "perplexity";
+function wantsPerplexityAgent(candidate) {
+  return candidate.upstreamId === PERPLEXITY_UPSTREAM;
+}
+function searchBoundedByHost(candidate) {
+  return !wantsPerplexityAgent(candidate);
+}
+
+// src/pricing-components.ts
+var DEAREST = "\0dearest";
+function contextSize(body) {
+  const options = body.web_search_options;
+  return typeof options?.search_context_size === "string" ? options.search_context_size : null;
+}
+function webSearch(body) {
+  let present = false;
+  let maxUses = 0;
+  const types = /* @__PURE__ */ new Set();
+  if (Array.isArray(body.tools)) {
+    for (const tool of body.tools) {
+      if (typeof tool?.type !== "string" || !tool.type.startsWith("web_search")) continue;
+      present = true;
+      const max = tool.max_uses;
+      const uses = typeof max === "number" && Number.isSafeInteger(max) && max >= 0 ? max : null;
+      maxUses = maxUses === null || uses === null ? null : maxUses + uses;
+      types.add(typeof tool.search_type === "string" ? tool.search_type : "");
+    }
+  }
+  if (present) return { present, maxUses, searchType: types.size === 1 ? [...types][0] : DEAREST };
+  if (body.web_search_options !== void 0 && body.web_search_options !== null) {
+    return { present: true, maxUses: null, searchType: "" };
+  }
+  return { present: false, maxUses: 0, searchType: "" };
+}
+function characterCount(body) {
+  return typeof body.input === "string" ? [...body.input].length : 0;
+}
+var READERS = {
+  request: {
+    variant: (body) => contextSize(body) ?? "",
+    // Perplexity reports `search_context_size` in its usage, so the size that
+    // was billed is the host's answer and not the body's ask.
+    hostChoosesVariant: true,
+    bound: () => 1,
+    settle: (body, usage) => ({ count: 1, variant: usage.search_context_size ?? contextSize(body) ?? "" })
+  },
+  search: {
+    variant: (body) => webSearch(body).searchType,
+    bound: (body, model) => {
+      const search = webSearch(body);
+      return search.present && !searchBoundedByHost(model) ? null : search.maxUses;
+    },
+    settle: (body, usage) => {
+      if (usage.web_search_requests !== void 0) return { count: usage.web_search_requests };
+      return webSearch(body).present ? null : { count: 0 };
+    }
+  },
+  character: {
+    variant: () => "",
+    bound: (body) => characterCount(body),
+    settle: (body) => ({ count: characterCount(body) })
+  },
+  image: {
+    variant: (body) => {
+      const asked = imageRequestOf(body);
+      return asked === null ? "" : `${asked.size}/${asked.quality}`;
+    },
+    bound: (body) => imageRequestOf(body)?.n ?? null,
+    settle: (body) => {
+      const asked = imageRequestOf(body);
+      return asked === null ? null : { count: asked.n };
+    }
+  }
+};
+var READ_COMPONENTS = new Set(Object.keys(READERS));
+async function componentRowsInForceFor(db, models, at) {
+  const rows = /* @__PURE__ */ new Map();
+  if (models.length === 0) return rows;
+  const day = at.toISOString().slice(0, 10);
+  const placeholders = models.map(() => "?").join(", ");
+  const { results } = await db.prepare(
+    `SELECT c.model, c.component, c.variant, c.micros, c.per
+         FROM model_components c
+         JOIN (SELECT model, component, max(effective_from) AS effective_from
+                 FROM model_components
+                WHERE effective_from <= ?1 AND model IN (${placeholders})
+                GROUP BY model, component) latest
+           ON latest.model = c.model AND latest.component = c.component
+          AND latest.effective_from = c.effective_from
+        ORDER BY c.model, c.component, c.variant`
+  ).bind(day, ...models).all();
+  for (const { model, ...row } of results) {
+    const list = rows.get(model);
+    if (list === void 0) rows.set(model, [row]);
+    else list.push(row);
+  }
+  return rows;
+}
+async function componentRowsInForce(db, model, at) {
+  return (await componentRowsInForceFor(db, [model], at)).get(model) ?? [];
+}
+
+// src/fallback.ts
+var MAX_CHAIN = 3;
+
+export {
+  MAX_CHAIN,
+  LANE_PREFIX,
+  CONTRIBUTOR_LANE_PREFIX,
+  SLUG
+};