@hraness/sys1 0.17.0

package/dist/client.js

@@ -0,0 +1,667 @@
+// src/http.ts
+class HttpBodyLimitError extends Error {
+  maxBytes;
+  constructor(maxBytes) {
+    super(`HTTP body exceeds ${maxBytes} bytes`);
+    this.maxBytes = maxBytes;
+    this.name = "HttpBodyLimitError";
+  }
+}
+async function readBoundedText(source, maxBytes, signal) {
+  signal?.throwIfAborted();
+  if (source.body === null)
+    return "";
+  const reader = source.body.getReader();
+  const chunks = [];
+  let bytes = 0;
+  let rejectAbort;
+  const aborted = new Promise((_, reject) => {
+    rejectAbort = reject;
+  });
+  const onAbort = () => {
+    rejectAbort?.(signal?.reason);
+    reader.cancel(signal?.reason).catch(() => {});
+  };
+  signal?.addEventListener("abort", onAbort, { once: true });
+  try {
+    for (;; ) {
+      signal?.throwIfAborted();
+      const next = await Promise.race([reader.read(), aborted]);
+      signal?.throwIfAborted();
+      if (next.done)
+        break;
+      bytes += next.value.byteLength;
+      if (bytes > maxBytes) {
+        const error = new HttpBodyLimitError(maxBytes);
+        reader.cancel(error).catch(() => {});
+        throw error;
+      }
+      chunks.push(next.value);
+    }
+    const body = new Uint8Array(bytes);
+    let offset = 0;
+    for (const chunk of chunks) {
+      body.set(chunk, offset);
+      offset += chunk.byteLength;
+    }
+    return new TextDecoder().decode(body);
+  } finally {
+    signal?.removeEventListener("abort", onAbort);
+    reader.releaseLock();
+  }
+}
+
+// src/protocol.ts
+import { z } from "zod";
+var PROTOCOL_LIMITS = {
+  maxBodyBytes: 1048576,
+  maxStateBytes: 262144,
+  maxQuestions: 64,
+  maxQuestionNameChars: 128,
+  maxInstructionsChars: 4096,
+  maxCriterionChars: 1024,
+  maxOptionChars: 256,
+  maxChoiceOptions: 255,
+  minScoreLevels: 2,
+  maxScoreLevels: 10,
+  maxModelChars: 128
+};
+var jsonValueSchema = z.lazy(() => z.union([
+  z.string(),
+  z.number(),
+  z.boolean(),
+  z.null(),
+  z.array(jsonValueSchema),
+  z.record(z.string(), jsonValueSchema)
+]));
+var entrySchema = z.union([
+  z.string(),
+  z.null(),
+  z.array(jsonValueSchema),
+  z.record(z.string(), jsonValueSchema)
+]);
+function boundedEntry(maxBytes, message) {
+  return entrySchema.refine((value) => {
+    const text = typeof value === "string" ? value : JSON.stringify(value);
+    return new TextEncoder().encode(text).byteLength <= maxBytes;
+  }, message);
+}
+var instructionsSchema = boundedEntry(PROTOCOL_LIMITS.maxInstructionsChars, "instructions exceeds 4096 bytes");
+var criterionSchema = boundedEntry(PROTOCOL_LIMITS.maxCriterionChars, "criterion exceeds 1024 bytes");
+var noulQuestionSchema = z.object({
+  type: z.literal("noul"),
+  instructions: instructionsSchema.optional(),
+  criteria: z.object({
+    true: criterionSchema.optional(),
+    false: criterionSchema.optional()
+  }).nullable().optional()
+});
+var choiceQuestionSchema = z.object({
+  type: z.literal("choice"),
+  instructions: instructionsSchema.optional(),
+  criteria: z.record(z.string().min(1).max(PROTOCOL_LIMITS.maxOptionChars), criterionSchema).refine((options) => {
+    const count = Object.keys(options).length;
+    return count >= 1 && count <= PROTOCOL_LIMITS.maxChoiceOptions;
+  }, { message: "choice criteria needs 1..255 options" })
+});
+var scoreQuestionSchema = z.object({
+  type: z.literal("score"),
+  instructions: instructionsSchema.optional(),
+  criteria: z.array(criterionSchema).min(PROTOCOL_LIMITS.minScoreLevels).max(PROTOCOL_LIMITS.maxScoreLevels)
+});
+var questionSchema = z.discriminatedUnion("type", [
+  noulQuestionSchema,
+  choiceQuestionSchema,
+  scoreQuestionSchema
+]);
+var systemOneRequestSchema = z.object({
+  model: z.string().min(1).max(PROTOCOL_LIMITS.maxModelChars).optional(),
+  state: entrySchema,
+  questions: z.record(z.string().min(1).max(PROTOCOL_LIMITS.maxQuestionNameChars), questionSchema).refine((questions) => {
+    const count = Object.keys(questions).length;
+    return count >= 1 && count <= PROTOCOL_LIMITS.maxQuestions;
+  }, { message: "questions needs 1..64 entries" })
+});
+var probabilitySchema = z.number().min(0).max(1);
+var noulAnswerSchema = z.object({
+  type: z.literal("noul"),
+  noul: probabilitySchema
+});
+var choiceAnswerSchema = z.object({
+  type: z.literal("choice"),
+  choice: z.string().min(1),
+  probabilities: z.record(z.string().min(1), probabilitySchema),
+  confidence: probabilitySchema
+}).superRefine((answer, ctx) => {
+  const count = Object.keys(answer.probabilities).length;
+  if (count < 1 || count > PROTOCOL_LIMITS.maxChoiceOptions) {
+    ctx.addIssue({ code: "custom", message: "choice probabilities needs 1..255 entries" });
+  }
+  if (!(answer.choice in answer.probabilities)) {
+    ctx.addIssue({ code: "custom", message: "choice is missing from probabilities" });
+  }
+});
+var scoreAnswerSchema = z.object({
+  type: z.literal("score"),
+  score: z.number().min(0),
+  legend: z.record(z.string().regex(/^(0|[1-9]\d*)$/), entrySchema),
+  probabilities: z.record(z.string().regex(/^(0|[1-9]\d*)$/), probabilitySchema),
+  confidence: probabilitySchema
+}).superRefine((answer, ctx) => {
+  const legendKeys = Object.keys(answer.legend);
+  const probabilityKeys = Object.keys(answer.probabilities);
+  if (legendKeys.length < PROTOCOL_LIMITS.minScoreLevels || legendKeys.length > PROTOCOL_LIMITS.maxScoreLevels) {
+    ctx.addIssue({ code: "custom", message: "score legend needs 2..10 entries" });
+  }
+  if (legendKeys.length !== probabilityKeys.length || legendKeys.some((key) => !(key in answer.probabilities))) {
+    ctx.addIssue({ code: "custom", message: "score legend and probabilities must have identical keys" });
+  }
+  if (legendKeys.some((key, index) => key !== String(index))) {
+    ctx.addIssue({ code: "custom", message: "score keys must be contiguous from zero" });
+  }
+  if (legendKeys.length > 0 && answer.score > legendKeys.length - 1) {
+    ctx.addIssue({ code: "custom", message: "score exceeds the legend range" });
+  }
+});
+var answerSchema = z.discriminatedUnion("type", [
+  noulAnswerSchema,
+  choiceAnswerSchema,
+  scoreAnswerSchema
+]);
+var systemOneResponseSchema = z.object({
+  model: z.string().min(1).max(PROTOCOL_LIMITS.maxModelChars),
+  answers: z.record(z.string().min(1).max(PROTOCOL_LIMITS.maxQuestionNameChars), answerSchema).refine((answers) => Object.keys(answers).length <= PROTOCOL_LIMITS.maxQuestions),
+  usage: z.object({
+    input_tokens: z.number().int().nonnegative(),
+    output_tokens: z.number().int().nonnegative()
+  })
+});
+function errorBody(type, message, details) {
+  return { error: { type, message, ...details === undefined ? {} : { details } } };
+}
+function serializedBytes(value) {
+  return new TextEncoder().encode(JSON.stringify(value)).byteLength;
+}
+
+// src/response.ts
+function sameEntry(left, right) {
+  if (left === right)
+    return true;
+  if (left === null || right === null || typeof left !== "object" || typeof right !== "object") {
+    return false;
+  }
+  if (Array.isArray(left) !== Array.isArray(right))
+    return false;
+  const a = left;
+  const b = right;
+  const keys = Object.keys(a);
+  return keys.length === Object.keys(b).length && keys.every((key) => Object.hasOwn(b, key) && sameEntry(a[key], b[key]));
+}
+function matchesRequest(request, response) {
+  const questionNames = Object.keys(request.questions);
+  if (questionNames.length !== Object.keys(response.answers).length)
+    return false;
+  return questionNames.every((name) => {
+    const question = request.questions[name];
+    if (!Object.hasOwn(response.answers, name))
+      return false;
+    const answer = response.answers[name];
+    if (question.type !== answer.type)
+      return false;
+    if (question.type === "choice" && answer.type === "choice") {
+      const options = Object.keys(question.criteria);
+      return Object.hasOwn(question.criteria, answer.choice) && options.length === Object.keys(answer.probabilities).length && options.every((option) => Object.hasOwn(answer.probabilities, option));
+    }
+    if (question.type === "score" && answer.type === "score") {
+      return question.criteria.length === Object.keys(answer.legend).length && question.criteria.every((criterion, index) => sameEntry(criterion, answer.legend[String(index)]));
+    }
+    return true;
+  });
+}
+function scoreEndpoint(bounds, lowerTotal, maximum) {
+  let expected = bounds.reduce((sum, bound, level) => sum + level * bound.lower, 0);
+  let remaining = Math.max(0, 1 - lowerTotal);
+  for (let position = 0;position < bounds.length && remaining > 0; position++) {
+    const level = maximum ? bounds.length - 1 - position : position;
+    const bound = bounds[level];
+    const added = Math.min(remaining, bound.upper - bound.lower);
+    expected += level * added;
+    remaining -= added;
+  }
+  return expected;
+}
+function validateResponseForRequest(request, value, roundingDecimals = 3) {
+  try {
+    if (roundingDecimals !== 2 && roundingDecimals !== 3)
+      throw new Error;
+    const rounding = 0.5 * 10 ** -roundingDecimals;
+    const response = systemOneResponseSchema.parse(value);
+    if (!matchesRequest(request, response))
+      throw new Error;
+    for (const answer of Object.values(response.answers)) {
+      if (answer.type === "noul")
+        continue;
+      const values = Object.values(answer.probabilities);
+      const total = values.reduce((sum, probability) => sum + probability, 0);
+      const bounds = values.map((probability) => ({
+        lower: Math.max(0, probability - rounding),
+        upper: Math.min(1, probability + rounding)
+      }));
+      const lowerTotal = bounds.reduce((sum, bound) => sum + bound.lower, 0);
+      const upperTotal = bounds.reduce((sum, bound) => sum + bound.upper, 0);
+      if (total <= 0 || lowerTotal > 1 + 0.000000001 || upperTotal < 1 - 0.000000001)
+        throw new Error;
+      if (answer.type === "choice") {
+        if (answer.probabilities[answer.choice] + 0.000000001 < Math.max(...values))
+          throw new Error;
+      } else {
+        const minimum = scoreEndpoint(bounds, lowerTotal, false);
+        const maximum = scoreEndpoint(bounds, lowerTotal, true);
+        if (answer.score + rounding < minimum - 0.000000001 || answer.score - rounding > maximum + 0.000000001) {
+          throw new Error;
+        }
+      }
+    }
+    return response;
+  } catch {
+    throw new Error("Invalid or mismatched System One response");
+  }
+}
+
+// src/kev.ts
+var pythonLeadingWhitespace = /^[\u0009-\u000d\u001c-\u0020\u0085\u00a0\u1680\u2000-\u200a\u2028\u2029\u202f\u205f\u3000]+/u;
+function renderNumber(value) {
+  const wire = JSON.stringify(value);
+  if (!/[.e]/i.test(wire))
+    return wire;
+  if (Math.abs(value) < 0.0001 || Math.abs(value) >= 10000000000000000) {
+    return value.toExponential().replace(/e([+-])(\d)$/u, "e$10$2");
+  }
+  return wire;
+}
+function render(value, indent = 0) {
+  if (value === null)
+    return "";
+  if (typeof value === "string")
+    return value;
+  if (typeof value === "boolean")
+    return value ? "True" : "False";
+  if (typeof value === "number")
+    return renderNumber(value);
+  const pad = "  ".repeat(indent);
+  if (Array.isArray(value)) {
+    return value.map((entry) => `${pad}- ${render(entry, indent + 1).replace(pythonLeadingWhitespace, "")}`).join(`
+`);
+  }
+  return Object.entries(value).map(([key, entry]) => entry !== null && typeof entry === "object" ? `${pad}${key}:
+${render(entry, indent + 1)}` : `${pad}${key}: ${render(entry)}`).join(`
+`);
+}
+function adaptKevRequest(request) {
+  const adapted = structuredClone(request);
+  for (const question of Object.values(adapted.questions)) {
+    if (question.instructions === undefined)
+      question.instructions = null;
+  }
+  return adapted;
+}
+function adaptKevResponse(request, value) {
+  try {
+    const response = systemOneResponseSchema.parse(value);
+    if (request.model !== undefined && response.model !== request.model)
+      throw new Error;
+    for (const [name, question] of Object.entries(request.questions)) {
+      if (question.type !== "score")
+        continue;
+      const answer = response.answers[name];
+      if (answer?.type !== "score" || Object.keys(answer.legend).length !== question.criteria.length) {
+        throw new Error;
+      }
+      if (!question.criteria.every((criterion, index) => answer.legend[String(index)] === render(criterion))) {
+        throw new Error;
+      }
+      answer.legend = Object.fromEntries(question.criteria.map((criterion, index) => [String(index), structuredClone(criterion)]));
+    }
+    return validateResponseForRequest(request, response, 2);
+  } catch {
+    throw new Error("Invalid or mismatched System One response");
+  }
+}
+// src/profile.ts
+import { z as z2 } from "zod";
+var identifier = z2.string().min(1).max(64).regex(/^[a-zA-Z0-9][a-zA-Z0-9._-]*$/).refine((value) => value === value.trim());
+var profileQuestionSchema = z2.discriminatedUnion("type", [
+  noulQuestionSchema.extend({
+    criteria: noulQuestionSchema.shape.criteria.unwrap().unwrap().strict().nullable().optional()
+  }).strict(),
+  choiceQuestionSchema.strict(),
+  scoreQuestionSchema.strict()
+]);
+var profileDefinitionSchema = z2.object({
+  version: z2.literal(1),
+  id: identifier,
+  revision: identifier,
+  model: systemOneRequestSchema.shape.model.unwrap().regex(/^[a-z0-9][a-z0-9.-]*\/\S+$/).refine((value) => value === value.trim()),
+  questions: z2.record(z2.string().min(1).max(PROTOCOL_LIMITS.maxQuestionNameChars), profileQuestionSchema).refine((questions) => {
+    const count = Object.keys(questions).length;
+    return count >= 1 && count <= PROTOCOL_LIMITS.maxQuestions;
+  })
+}).strict();
+
+class Sys1ProfileError extends Error {
+  code;
+  constructor(code) {
+    super(code === "invalid_profile" ? "Invalid Sys1 profile" : "Invalid Sys1 profile request");
+    this.name = "Sys1ProfileError";
+    this.code = code;
+  }
+}
+function snapshotJson(input, maxBytes) {
+  const ancestors = new Set;
+  const encoder = new TextEncoder;
+  let bytes = 0;
+  const account = (count) => {
+    bytes += count;
+    if (bytes > maxBytes)
+      throw new Error;
+  };
+  const copy = (value) => {
+    if (value === null || typeof value === "string" || typeof value === "boolean" || typeof value === "number") {
+      if (typeof value === "number" && !Number.isFinite(value))
+        throw new Error;
+      if (typeof value === "string" && value.length > maxBytes - bytes)
+        throw new Error;
+      account(encoder.encode(JSON.stringify(value)).byteLength);
+      return value;
+    }
+    if (typeof value !== "object" || ancestors.has(value))
+      throw new Error;
+    const array = Array.isArray(value);
+    const prototype = Object.getPrototypeOf(value);
+    if (prototype !== (array ? Array.prototype : Object.prototype) && !(prototype === null && !array))
+      throw new Error;
+    const descriptors = Object.getOwnPropertyDescriptors(value);
+    const keys = Reflect.ownKeys(descriptors);
+    if (keys.some((key) => typeof key !== "string"))
+      throw new Error;
+    ancestors.add(value);
+    account(2);
+    let result;
+    if (array) {
+      if (keys.length !== value.length + 1)
+        throw new Error;
+      const items = [];
+      for (let index = 0;index < value.length; index++) {
+        const descriptor = descriptors[String(index)];
+        if (descriptor === undefined || !descriptor.enumerable || !("value" in descriptor))
+          throw new Error;
+        if (index > 0)
+          account(1);
+        items.push(copy(descriptor.value));
+      }
+      result = items;
+    } else {
+      const object = Object.create(null);
+      for (let index = 0;index < keys.length; index++) {
+        const key = keys[index];
+        const descriptor = descriptors[key];
+        if (descriptor === undefined || !descriptor.enumerable || !("value" in descriptor))
+          throw new Error;
+        if (index > 0)
+          account(1);
+        account(encoder.encode(JSON.stringify(key)).byteLength + 1);
+        object[key] = copy(descriptor.value);
+      }
+      result = object;
+    }
+    ancestors.delete(value);
+    return result;
+  };
+  return copy(input);
+}
+function freezeDeep(value) {
+  if (value !== null && typeof value === "object") {
+    for (const child of Object.values(value))
+      freezeDeep(child);
+    Object.freeze(value);
+  }
+  return value;
+}
+function createProfile(input) {
+  let definition;
+  try {
+    definition = freezeDeep(profileDefinitionSchema.parse(snapshotJson(input, PROTOCOL_LIMITS.maxBodyBytes)));
+  } catch {
+    throw new Sys1ProfileError("invalid_profile");
+  }
+  return Object.freeze({
+    definition,
+    request(state) {
+      try {
+        const request = systemOneRequestSchema.parse(snapshotJson({
+          model: definition.model,
+          state,
+          questions: definition.questions
+        }, PROTOCOL_LIMITS.maxBodyBytes));
+        if (serializedBytes(request.state) > PROTOCOL_LIMITS.maxStateBytes)
+          throw new Error;
+        return request;
+      } catch {
+        throw new Sys1ProfileError("invalid_request");
+      }
+    }
+  });
+}
+
+// src/client.ts
+var DEFAULT_BASE_URL = "http://127.0.0.1:13900";
+var MAX_RESPONSE_BYTES = 4194304;
+var ERROR_MESSAGES = {
+  invalid_options: "Invalid Sys1 client options",
+  invalid_request: "Invalid System One request",
+  aborted: "Sys1 request aborted",
+  timeout: "Sys1 request timed out",
+  transport_error: "Sys1 transport failed",
+  http_error: "Sys1 endpoint returned an HTTP error",
+  response_too_large: "Sys1 response exceeded the byte limit",
+  invalid_response: "Sys1 endpoint returned an invalid or mismatched response"
+};
+
+class Sys1ClientError extends Error {
+  code;
+  status;
+  constructor(code, status) {
+    super(ERROR_MESSAGES[code]);
+    this.name = "Sys1ClientError";
+    this.code = code;
+    this.status = status;
+  }
+}
+function metadata(headers) {
+  const result = {};
+  const adapter = headers.get("x-sys1-adapter");
+  const decimals = headers.get("x-sys1-probability-decimals");
+  if (adapter !== null || decimals !== null) {
+    if (adapter !== "kev" || decimals !== "2")
+      throw new Sys1ClientError("invalid_response");
+    result.adapter = "kev";
+    result.probabilityDecimals = 2;
+  }
+  const name = (key) => {
+    const value = headers.get(key);
+    if (value === null)
+      return;
+    if (!/^[a-zA-Z0-9_.:/-]{1,128}$/.test(value))
+      throw new Sys1ClientError("invalid_response");
+    return value;
+  };
+  const backend = name("x-sys1-backend");
+  if (backend !== undefined)
+    result.backend = backend;
+  const attempts = headers.get("x-sys1-attempts");
+  if (attempts !== null) {
+    if (!/^[1-9]\d{0,5}$/.test(attempts))
+      throw new Sys1ClientError("invalid_response");
+    result.attempts = Number(attempts);
+  }
+  const localAdapter = name("x-sys1-local-adapter");
+  if (localAdapter !== undefined) {
+    result.local = { adapter: localAdapter };
+    for (const [header, key] of [
+      ["x-sys1-local-min-coverage", "minCoverage"],
+      ["x-sys1-local-min-concentration", "minConcentration"]
+    ]) {
+      const value = headers.get(header);
+      if (value === null)
+        continue;
+      if (!/^(0(?:\.\d{1,16})?|1(?:\.0{1,16})?)$/.test(value)) {
+        throw new Sys1ClientError("invalid_response");
+      }
+      result.local[key] = Number(value);
+    }
+  }
+  return result;
+}
+function cancelBody(response) {
+  response.body?.cancel().catch(() => {
+    return;
+  });
+}
+function fetchUntilAborted(fetchFn, url, init, signal) {
+  return new Promise((resolve, reject) => {
+    const abort = () => reject(new Sys1ClientError("aborted"));
+    signal.addEventListener("abort", abort, { once: true });
+    if (signal.aborted) {
+      signal.removeEventListener("abort", abort);
+      abort();
+      return;
+    }
+    Promise.resolve().then(() => fetchFn(url, init)).then((response) => {
+      if (signal.aborted)
+        cancelBody(response);
+      resolve(response);
+    }, reject).finally(() => signal.removeEventListener("abort", abort));
+  });
+}
+function createClient(options = {}) {
+  let endpoint;
+  let headers;
+  const timeoutMs = options.timeoutMs ?? 30000;
+  const fetchFn = options.fetch ?? globalThis.fetch;
+  const adapter = options.adapter ?? "systemone";
+  try {
+    if (adapter !== "systemone" && adapter !== "kev")
+      throw new Error;
+    const base = options.baseUrl ?? DEFAULT_BASE_URL;
+    if (base.length > 2048)
+      throw new Error;
+    const url = new URL(base);
+    if (!["http:", "https:"].includes(url.protocol) || url.username || url.password || url.search || url.hash) {
+      throw new Error;
+    }
+    url.pathname = `${url.pathname.replace(/\/+$/, "")}/v1/systemone`;
+    endpoint = url.href;
+    headers = new Headers(options.headers);
+    headers.set("content-type", "application/json");
+    headers.set("accept", "application/json");
+    let headerBytes = 0;
+    headers.forEach((value, key) => {
+      headerBytes += new TextEncoder().encode(key + value).byteLength;
+    });
+    if (headerBytes > 16384 || !Number.isInteger(timeoutMs) || timeoutMs < 1 || timeoutMs > 300000 || typeof fetchFn !== "function") {
+      throw new Error;
+    }
+  } catch {
+    throw new Sys1ClientError("invalid_options");
+  }
+  return {
+    async evaluate(input, evaluation = {}) {
+      if (evaluation.signal?.aborted)
+        throw new Sys1ClientError("aborted");
+      let request;
+      let body;
+      try {
+        const serialized = JSON.stringify(input);
+        if (new TextEncoder().encode(serialized).byteLength > PROTOCOL_LIMITS.maxBodyBytes)
+          throw new Error;
+        request = systemOneRequestSchema.parse(JSON.parse(serialized));
+        const state = typeof request.state === "string" ? request.state : JSON.stringify(request.state);
+        if (new TextEncoder().encode(state).byteLength > PROTOCOL_LIMITS.maxStateBytes)
+          throw new Error;
+        body = JSON.stringify(adapter === "kev" ? adaptKevRequest(request) : request);
+        if (new TextEncoder().encode(body).byteLength > PROTOCOL_LIMITS.maxBodyBytes)
+          throw new Error;
+      } catch {
+        throw new Sys1ClientError("invalid_request");
+      }
+      const controller = new AbortController;
+      let timedOut = false;
+      const onAbort = () => controller.abort();
+      evaluation.signal?.addEventListener("abort", onAbort, { once: true });
+      const timer = setTimeout(() => {
+        timedOut = true;
+        controller.abort();
+      }, timeoutMs);
+      try {
+        const response = await fetchUntilAborted(fetchFn, endpoint, {
+          method: "POST",
+          headers: new Headers(headers),
+          body,
+          signal: controller.signal,
+          redirect: "error",
+          credentials: "omit"
+        }, controller.signal);
+        if (!response.ok) {
+          cancelBody(response);
+          throw new Sys1ClientError("http_error", response.status);
+        }
+        const text = await readBoundedText(response, MAX_RESPONSE_BYTES, controller.signal);
+        let parsed;
+        let route;
+        try {
+          route = metadata(response.headers);
+          const value = JSON.parse(text);
+          if (adapter === "kev") {
+            parsed = adaptKevResponse(request, value);
+            route.adapter = "kev";
+            route.probabilityDecimals = 2;
+          } else {
+            parsed = validateResponseForRequest(request, value, route.probabilityDecimals ?? 3);
+          }
+        } catch {
+          throw new Sys1ClientError("invalid_response");
+        }
+        return { response: parsed, metadata: route };
+      } catch (error) {
+        if (controller.signal.aborted)
+          throw new Sys1ClientError(timedOut ? "timeout" : "aborted");
+        if (error instanceof Sys1ClientError)
+          throw error;
+        if (error instanceof HttpBodyLimitError)
+          throw new Sys1ClientError("response_too_large");
+        throw new Sys1ClientError("transport_error");
+      } finally {
+        clearTimeout(timer);
+        evaluation.signal?.removeEventListener("abort", onAbort);
+      }
+    }
+  };
+}
+export {
+  systemOneResponseSchema,
+  systemOneRequestSchema,
+  scoreQuestionSchema,
+  scoreAnswerSchema,
+  questionSchema,
+  noulQuestionSchema,
+  noulAnswerSchema,
+  createProfile,
+  createClient,
+  choiceQuestionSchema,
+  choiceAnswerSchema,
+  answerSchema,
+  Sys1ProfileError,
+  Sys1ClientError,
+  PROTOCOL_LIMITS,
+  DEFAULT_BASE_URL
+};