@bytesbrains/cruise-worker 0.12.0 → 0.13.0

package/emulator/worker.js

@@ -0,0 +1,506 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// exchange.ts
+var RESET = { kind: "reset" };
+var ABANDONED = { kind: "abandoned" };
+var respond = /* @__PURE__ */ __name((rendered, streamed = false) => ({ kind: "respond", rendered, streamed }), "respond");
+var json = /* @__PURE__ */ __name((status, body) => respond({ status, headers: { "content-type": "application/json" }, body: JSON.stringify(body) }), "json");
+var badJson = /* @__PURE__ */ __name(() => json(400, { error: { message: "invalid JSON body", type: "invalid_request_error" } }), "badJson");
+function stall(ms, signal) {
+  if (signal.aborted) return Promise.resolve("abandoned");
+  return new Promise((settled) => {
+    const finish = /* @__PURE__ */ __name((how) => {
+      clearTimeout(timer);
+      signal.removeEventListener("abort", onAbort);
+      settled(how);
+    }, "finish");
+    const onAbort = /* @__PURE__ */ __name(() => finish("abandoned"), "onAbort");
+    const timer = setTimeout(() => finish("elapsed"), ms);
+    signal.addEventListener("abort", onAbort, { once: true });
+  });
+}
+__name(stall, "stall");
+function framesOf(body) {
+  return body.split(/(?<=\n\n)/).filter((frame) => frame.length > 0);
+}
+__name(framesOf, "framesOf");
+var FRAME_GAP_MS = 5;
+var isStream = /* @__PURE__ */ __name((rendered) => rendered.headers["content-type"] === "text/event-stream", "isStream");
+
+// scenarios.ts
+var DEFAULT_USAGE = { prompt_tokens: 12, completion_tokens: 8, total_tokens: 20 };
+var CATALOGUE = {
+  /** The uncontroversial case. */
+  ok: { mode: "json", content: "Four.", usage: DEFAULT_USAGE },
+  /** Streaming, with usage where OpenAI puts it: on the frame before `[DONE]`. */
+  "ok-stream": { mode: "sse", content: "Four, and here is why.", chunks: 5, usage: DEFAULT_USAGE },
+  /**
+   * A stream that ends without usage. Cruise's only spend signal on a
+   * logging-off gateway is that late chunk, so this is the case where it has to
+   * fall back to its reservation rather than record a free request.
+   */
+  "stream-no-usage": { mode: "sse", content: "Answer.", chunks: 3, usageOnLastChunk: false, usage: null },
+  /** HTTP 200, no usage at all, non-streaming. */
+  "no-usage": { mode: "json", content: "Answer.", usage: null },
+  /** A refusal. Well formed, HTTP 200, and typically unbilled. */
+  refusal: {
+    mode: "json",
+    content: "",
+    refusal: "I can't help with that.",
+    finishReason: "stop",
+    usage: { prompt_tokens: 14, completion_tokens: 0, total_tokens: 14 }
+  },
+  /** Content-free with a stop reason — distinct from a refusal and from a tool call. */
+  empty: { mode: "json", content: "", finishReason: "stop", usage: DEFAULT_USAGE },
+  /**
+   * A tool call has no content either, and must not be counted as `empty`.
+   * Three of them, which is what DeepSeek and Mistral actually return where
+   * llama returns one (#10).
+   */
+  "tool-calls": {
+    mode: "json",
+    content: "",
+    finishReason: "tool_calls",
+    toolCalls: [
+      { id: "call_1", type: "function", function: { name: "get_weather", arguments: '{"city":"Paris"}' } },
+      { id: "call_2", type: "function", function: { name: "get_weather", arguments: '{"city":"Berlin"}' } },
+      { id: "call_3", type: "function", function: { name: "get_weather", arguments: '{"city":"Madrid"}' } }
+    ],
+    usage: { prompt_tokens: 96, completion_tokens: 64, total_tokens: 160 }
+  },
+  /** Reasoning tokens are completion tokens that produced no content. */
+  reasoning: {
+    mode: "json",
+    content: "42.",
+    usage: {
+      prompt_tokens: 20,
+      completion_tokens: 300,
+      total_tokens: 320,
+      completion_tokens_details: { reasoning_tokens: 288 }
+    }
+  },
+  /**
+   * Reasoning that consumed the whole output budget (#142): a 200, a bill,
+   * `finish_reason: length`, and not one content token. 31% of one day's
+   * production spend was this shape, and the caller was told nothing — now
+   * `x-cruise-warning: reasoning_exhausted`, which a demo caller can ask to
+   * see (#329).
+   */
+  "reasoning-exhausted": {
+    mode: "json",
+    content: "",
+    finishReason: "length",
+    usage: {
+      prompt_tokens: 20,
+      completion_tokens: 256,
+      total_tokens: 276,
+      completion_tokens_details: { reasoning_tokens: 256 }
+    }
+  },
+  /** Provider-side prompt caching, billed at its own rate where one is known. */
+  "cached-input": {
+    mode: "json",
+    content: "Cached.",
+    usage: {
+      prompt_tokens: 4e3,
+      completion_tokens: 10,
+      total_tokens: 4010,
+      prompt_tokens_details: { cached_tokens: 3900 }
+    }
+  },
+  /**
+   * A prompt template the caller never sees. Measured on `devstral`: 1,230
+   * prompt tokens for a ten-token message. Metering the request rather than the
+   * response would under-count this by two orders of magnitude.
+   */
+  "inflated-prompt": { mode: "json", content: "Hi.", usage: { prompt_tokens: 1230, completion_tokens: 6, total_tokens: 1236 } },
+  /** The three statuses a chain may fall over on. */
+  "rate-limited": { status: 429, headers: { "retry-after": "30" } },
+  timeout: { status: 408 },
+  "server-error": { status: 503 },
+  /** And the two it must not: a client error is not another provider's problem. */
+  "bad-request": { status: 400 },
+  /** Mistral's rejection of the OpenAI `user` field, which is why it is dropped. */
+  "unprocessable": { status: 422, body: JSON.stringify({ object: "error", message: "Extra inputs are not permitted: user" }) },
+  /** No reply at all: the socket dies before headers. */
+  "transport-reset": { mode: "reset" },
+  /** 200 with a body that will not parse. */
+  garbage: { mode: "garbage" },
+  /** Answers to a different name than it was called by — the alias drift #10 exists for. */
+  "aliased-model": { mode: "json", content: "Hi.", usage: DEFAULT_USAGE, reportedModel: "deepseek-v4-pro" },
+  /** Slow enough to observe, not slow enough to hang a suite. */
+  slow: { mode: "json", content: "Eventually.", usage: DEFAULT_USAGE, delayMs: 1500 }
+};
+function scenarioNamed(name) {
+  const found = Object.hasOwn(CATALOGUE, name) ? CATALOGUE[name] : void 0;
+  if (found === void 0) {
+    throw new Error(`No scenario '${name}'. Known: ${Object.keys(CATALOGUE).sort().join(", ")}`);
+  }
+  return found;
+}
+__name(scenarioNamed, "scenarioNamed");
+function splitInto(text, parts) {
+  if (parts <= 1 || text.length === 0) return [text];
+  const size = Math.ceil(text.length / parts);
+  const out = [];
+  for (let at = 0; at < text.length; at += size) out.push(text.slice(at, at + size));
+  return out;
+}
+__name(splitInto, "splitInto");
+function completion(scenario, model, sequence) {
+  const message = { role: "assistant", content: scenario.content ?? "" };
+  if (scenario.refusal !== void 0) message["refusal"] = scenario.refusal;
+  if (scenario.toolCalls !== void 0) message["tool_calls"] = scenario.toolCalls;
+  const body = {
+    id: `chatcmpl-emu-${sequence}`,
+    object: "chat.completion",
+    created: 176e7 + sequence,
+    model: scenario.reportedModel ?? model,
+    choices: [{ index: 0, message, finish_reason: scenario.finishReason ?? "stop", logprobs: null }]
+  };
+  if (scenario.usage !== null && scenario.usage !== void 0) body["usage"] = scenario.usage;
+  return body;
+}
+__name(completion, "completion");
+function eventStream(scenario, model, sequence) {
+  const id = `chatcmpl-emu-${sequence}`;
+  const created = 176e7 + sequence;
+  const reported = scenario.reportedModel ?? model;
+  const frames = [];
+  const frame = /* @__PURE__ */ __name((choice, extra = {}) => {
+    frames.push(
+      `data: ${JSON.stringify({ id, object: "chat.completion.chunk", created, model: reported, choices: [choice], ...extra })}
+
+`
+    );
+  }, "frame");
+  frame({ index: 0, delta: { role: "assistant", content: "" }, finish_reason: null });
+  if (scenario.toolCalls !== void 0) {
+    scenario.toolCalls.forEach((call, index) => {
+      frame({ index: 0, delta: { tool_calls: [{ index, ...call }] }, finish_reason: null });
+    });
+  }
+  for (const piece of splitInto(scenario.content ?? "", scenario.chunks ?? 3)) {
+    if (piece.length > 0) frame({ index: 0, delta: { content: piece }, finish_reason: null });
+  }
+  const usage = scenario.usage;
+  const withUsage = (scenario.usageOnLastChunk ?? true) && usage !== null && usage !== void 0;
+  frame(
+    { index: 0, delta: {}, finish_reason: scenario.finishReason ?? "stop" },
+    withUsage ? { usage } : {}
+  );
+  frames.push("data: [DONE]\n\n");
+  return frames.join("");
+}
+__name(eventStream, "eventStream");
+function render(scenario, model, sequence) {
+  const status = scenario.status ?? 200;
+  const headers = { ...scenario.headers };
+  if (scenario.body !== void 0) {
+    headers["content-type"] ??= "application/json";
+    return { status, headers, body: scenario.body };
+  }
+  if (status !== 200) {
+    headers["content-type"] = "application/json";
+    return {
+      status,
+      headers,
+      body: JSON.stringify({ error: { message: `emulated ${status}`, type: "emulated_error", code: null } })
+    };
+  }
+  if (scenario.mode === "garbage") {
+    headers["content-type"] = "application/json";
+    return { status, headers, body: "<html>upstream had a moment</html>" };
+  }
+  if (scenario.mode === "sse") {
+    headers["content-type"] = "text/event-stream";
+    headers["cache-control"] = "no-cache";
+    return { status, headers, body: eventStream(scenario, model, sequence) };
+  }
+  headers["content-type"] = "application/json";
+  return { status, headers, body: JSON.stringify(completion(scenario, model, sequence)) };
+}
+__name(render, "render");
+
+// state.ts
+var MAX_CACHE_ENTRIES = 500;
+function createState() {
+  return {
+    config: { cacheTtl: 0, requireAuth: true, token: null },
+    assignments: /* @__PURE__ */ new Map(),
+    fallbackAssignment: "ok",
+    requests: [],
+    cache: /* @__PURE__ */ new Map(),
+    sequence: 0
+  };
+}
+__name(createState, "createState");
+var state = createState();
+function nextScenario(state2, model) {
+  const assignment = state2.assignments.get(model) ?? state2.fallbackAssignment;
+  let chosen;
+  if (Array.isArray(assignment)) {
+    if (assignment.length === 0) {
+      chosen = "ok";
+    } else {
+      chosen = assignment.length === 1 ? assignment[0] : assignment.shift();
+    }
+  } else {
+    chosen = assignment;
+  }
+  return typeof chosen === "string" ? { scenario: scenarioNamed(chosen), name: chosen } : { scenario: chosen, name: "inline" };
+}
+__name(nextScenario, "nextScenario");
+
+// compat.ts
+async function handleCompat(request, state2, account, gateway, direct = false) {
+  const { body: raw, headers } = request;
+  let body = {};
+  try {
+    body = JSON.parse(raw);
+  } catch {
+    return badJson();
+  }
+  const model = typeof body["model"] === "string" ? body["model"] : "";
+  const streamed = body["stream"] === true;
+  const record = {
+    at: Date.now(),
+    account,
+    gateway,
+    model,
+    headers,
+    body,
+    raw,
+    scenario: "",
+    cache: "OFF",
+    status: 0
+  };
+  state2.requests.push(record);
+  if (state2.config.requireAuth && !direct) {
+    const presented = /^Bearer\s+(.+)$/i.exec(headers["cf-aig-authorization"] ?? "")?.[1];
+    if (presented === void 0 || state2.config.token !== null && presented !== state2.config.token) {
+      record.status = 401;
+      return json(401, { error: { message: "missing or invalid cf-aig-authorization" } });
+    }
+  }
+  const ttl = Number(headers["cf-aig-cache-ttl"] ?? state2.config.cacheTtl);
+  const skipped = headers["cf-aig-skip-cache"] === "true";
+  const caching = ttl > 0 && !skipped && !direct;
+  if (skipped) record.cache = "SKIP";
+  const key = headers["cf-aig-cache-key"] ?? `${account}/${gateway}:${raw}`;
+  if (caching) {
+    const hit = state2.cache.get(key);
+    if (hit !== void 0 && hit.storedAt + hit.ttl * 1e3 > Date.now()) {
+      record.scenario = "cache-hit";
+      record.cache = "HIT";
+      record.status = hit.status;
+      const rendered2 = { status: hit.status, headers: { ...hit.headers, "cf-aig-cache-status": "HIT" }, body: hit.body };
+      return respond(rendered2, isStream(rendered2));
+    }
+  }
+  const { scenario, name } = nextScenario(state2, model);
+  record.scenario = name;
+  if (scenario.delayMs !== void 0 && scenario.delayMs > 0) {
+    if (await stall(scenario.delayMs, request.signal) === "abandoned") {
+      record.status = 0;
+      record.scenario = `${name}(abandoned)`;
+      return ABANDONED;
+    }
+  }
+  if (scenario.mode === "reset") {
+    record.status = 0;
+    return RESET;
+  }
+  state2.sequence += 1;
+  const shape = scenario.mode === "garbage" ? scenario.mode : streamed ? "sse" : "json";
+  const rendered = render({ ...scenario, mode: shape }, model, state2.sequence);
+  record.status = rendered.status;
+  if (caching && rendered.status === 200) {
+    for (const [existing, entry] of state2.cache) {
+      if (entry.storedAt + entry.ttl * 1e3 <= Date.now()) state2.cache.delete(existing);
+    }
+    while (state2.cache.size >= MAX_CACHE_ENTRIES) {
+      const oldest = state2.cache.keys().next();
+      if (oldest.done === true) break;
+      state2.cache.delete(oldest.value);
+    }
+    state2.cache.set(key, { ...rendered, storedAt: Date.now(), ttl });
+    record.cache = "MISS";
+  }
+  const out = { ...rendered, headers: { ...rendered.headers, ...caching ? { "cf-aig-cache-status": "MISS" } : {} } };
+  return respond(out, isStream(out));
+}
+__name(handleCompat, "handleCompat");
+
+// images.ts
+var PIXEL = "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNkYAAAAAYAAjCB0C8AAAAASUVORK5CYII=";
+var OUTPUT_TOKENS = { "1024x1024": 100, "1536x1024": 400 };
+function handleImages(request, state2, account, gateway, provider) {
+  const { body: raw, headers } = request;
+  let body = {};
+  try {
+    body = JSON.parse(raw);
+  } catch {
+    return badJson();
+  }
+  const model = typeof body["model"] === "string" ? body["model"] : "";
+  const record = {
+    at: Date.now(),
+    account,
+    // Recorded as the gateway plus the provider segment, because on this route
+    // the provider is part of the address and a test that could not see it
+    // could not tell `/compat` from `/openai`.
+    gateway: `${gateway}/${provider}`,
+    model,
+    headers,
+    body,
+    raw,
+    scenario: "image",
+    cache: "OFF",
+    status: 0
+  };
+  state2.requests.push(record);
+  if (state2.config.requireAuth) {
+    const presented = /^Bearer\s+(.+)$/i.exec(headers["cf-aig-authorization"] ?? "")?.[1];
+    if (presented === void 0 || state2.config.token !== null && presented !== state2.config.token) {
+      record.status = 401;
+      return json(401, { error: { message: "missing or invalid cf-aig-authorization" } });
+    }
+  }
+  const size = typeof body["size"] === "string" ? body["size"] : "1024x1024";
+  const n = body["n"] === void 0 ? 1 : body["n"];
+  if (typeof n !== "number" || !Number.isSafeInteger(n) || n < 1 || n > 10) {
+    record.status = 400;
+    return json(400, {
+      error: { message: "n must be an integer between 1 and 10", type: "invalid_request_error", param: "n" }
+    });
+  }
+  const perImage = OUTPUT_TOKENS[size] ?? 100;
+  const inputTokens = String(body["prompt"] ?? "").length;
+  record.status = 200;
+  return json(200, {
+    created: Math.floor(Date.now() / 1e3),
+    data: Array.from({ length: n }, () => ({ b64_json: PIXEL })),
+    usage: {
+      total_tokens: inputTokens + perImage * n,
+      input_tokens: inputTokens,
+      output_tokens: perImage * n,
+      input_tokens_details: { text_tokens: inputTokens, image_tokens: 0 }
+    }
+  });
+}
+__name(handleImages, "handleImages");
+
+// routes.ts
+var CONTROL_PREFIX = "/_emu/";
+var COMPAT = /^\/v1\/([^/]+)\/([^/]+)\/compat\/chat\/completions$/;
+var DIRECT = /^\/direct\/chat\/completions$/;
+var IMAGES = /^\/v1\/([^/]+)\/([^/]+)\/([^/]+)\/images\/generations$/;
+async function route(request, state2) {
+  const { pathname, method } = request;
+  const compat = COMPAT.exec(pathname);
+  if (compat !== null && method === "POST") {
+    return handleCompat(request, state2, compat[1], compat[2]);
+  }
+  if (DIRECT.test(pathname) && method === "POST") {
+    return handleCompat(request, state2, "direct", "direct", true);
+  }
+  const image = IMAGES.exec(pathname);
+  if (image !== null && method === "POST") {
+    return handleImages(request, state2, image[1], image[2], image[3]);
+  }
+  return null;
+}
+__name(route, "route");
+var notFound = /* @__PURE__ */ __name((request) => json(404, { error: `no route for ${request.method} ${request.pathname}` }), "notFound");
+
+// worker.ts
+var SCENARIO_HEADER = "x-emu-scenario";
+function headerRecord(request) {
+  const out = {};
+  for (const [name, value] of request.headers) out[name.toLowerCase()] = value;
+  return out;
+}
+__name(headerRecord, "headerRecord");
+function streamOf(body) {
+  const encoder = new TextEncoder();
+  const frames = framesOf(body);
+  let next = 0;
+  return new ReadableStream({
+    async pull(controller) {
+      if (next >= frames.length) {
+        controller.close();
+        return;
+      }
+      controller.enqueue(encoder.encode(frames[next]));
+      next += 1;
+      if (next < frames.length) await new Promise((done) => setTimeout(done, FRAME_GAP_MS));
+    }
+  });
+}
+__name(streamOf, "streamOf");
+function toResponse(outcome) {
+  if (outcome.kind !== "respond") return new Response(null, { status: 502 });
+  const { rendered, streamed } = outcome;
+  const headers = new Headers(rendered.headers);
+  if (streamed) return new Response(streamOf(rendered.body), { status: rendered.status, headers });
+  return new Response(rendered.body, { status: rendered.status, headers });
+}
+__name(toResponse, "toResponse");
+var worker_default = {
+  async fetch(request, env) {
+    const url = new URL(request.url);
+    if (url.pathname === `${CONTROL_PREFIX}health`) {
+      return Response.json({ ok: true, worker: true });
+    }
+    if (url.pathname.startsWith(CONTROL_PREFIX)) {
+      return Response.json(
+        { error: "the demo emulator has no control API; name a scenario in x-emu-scenario instead" },
+        { status: 404 }
+      );
+    }
+    const emu = {
+      method: request.method,
+      pathname: url.pathname,
+      headers: headerRecord(request),
+      // Read whatever the method, so the two adapters build the same
+      // `EmuRequest` from the same request — the node one has always read
+      // unconditionally. Nothing but POST reaches a handler, so this changes no
+      // behaviour; what it removes is an asymmetry between the adapters, which
+      // is the one thing this file exists to avoid. Raised by review of PR #332.
+      body: await request.text(),
+      signal: request.signal
+    };
+    const state2 = createState();
+    state2.config.token = env.EMULATOR_TOKEN ?? null;
+    state2.config.requireAuth = env.EMULATOR_TOKEN !== void 0;
+    const asked = emu.headers[SCENARIO_HEADER];
+    if (asked !== void 0 && asked !== "") {
+      if (!Object.hasOwn(CATALOGUE, asked)) {
+        return Response.json(
+          {
+            error: {
+              message: `No scenario '${asked}'. Known: ${Object.keys(CATALOGUE).sort().join(", ")}.`,
+              type: "invalid_request_error",
+              param: SCENARIO_HEADER,
+              code: "unknown_scenario"
+            }
+          },
+          { status: 400 }
+        );
+      }
+      state2.fallbackAssignment = asked;
+    }
+    try {
+      return toResponse(await route(emu, state2) ?? notFound(emu));
+    } catch (cause) {
+      console.error("emulator error", { pathname: url.pathname, cause: String(cause) });
+      return Response.json({ error: { message: "emulator failure", type: "api_error" } }, { status: 500 });
+    }
+  }
+};
+export {
+  worker_default as default
+};
+//# sourceMappingURL=worker.js.map

package/index.d.ts

@@ -2,6 +2,7 @@ export declare const packageDir: string;
 export declare const workerDir: string;
 export declare const mainModule: string;
 export declare const migrationsDir: string;
+export declare const emulatorModule: string;
 export declare const compatibilityDate: string;
 export declare const compatibilityFlags: readonly string[];
 export declare const bindings: {

package/index.mjs

@@ -19,6 +19,7 @@ var root = existsSync(path.join(here, "package.json")) ? here : path.join(here,
 var packageDir = root;
 var workerDir = path.join(root, "worker");
 var mainModule = path.join(root, "worker", "index.js");
+var emulatorModule = path.join(root, "emulator", "worker.js");
 var migrationsDir = path.join(root, "migrations");
 var compatibilityDate = COMPATIBILITY_DATE;
 var compatibilityFlags = COMPATIBILITY_FLAGS;
@@ -34,6 +35,7 @@ export {
   bindings,
   compatibilityDate,
   compatibilityFlags,
+  emulatorModule,
   mainModule,
   migrationsDir,
   packageDir,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bytesbrains/cruise-worker",
-  "version": "0.12.0",
+  "version": "0.13.0",
   "description": "The Cruise Worker, built and ready to deploy: one OpenAI-compatible endpoint in front of every model provider, with budgets that stop.",
   "license": "Apache-2.0",
   "type": "module",
@@ -15,6 +15,7 @@
     "index.mjs",
     "index.d.ts",
     "worker",
+    "emulator",
     "migrations",
     "wrangler.template.jsonc",
     "README.md",
@@ -25,7 +26,7 @@
   },
   "repository": {
     "type": "git",
-    "url": "https://gitlab.com/bytesbrains-oss/cruise.git",
+    "url": "git+https://gitlab.com/bytesbrains-oss/cruise.git",
     "directory": "packages/worker"
   },
   "homepage": "https://gitlab.com/bytesbrains-oss/cruise",

package/worker/VERSION

@@ -1 +1 @@
-0.12.0+c7b94bc
+0.13.0+659ef1b0