@yourgpt/llm-sdk 2.6.0-beta.3 → 2.6.0

package/dist/providers/typesafe/index.js

@@ -0,0 +1,735 @@
+'use strict';
+
+var crypto = require('crypto');
+
+// src/providers/decisions/model.ts
+
+// src/core/decisions.ts
+var decisionErrorMarker = /* @__PURE__ */ Symbol.for("yourgpt.llm-sdk.DecisionAPIError");
+var _a, _b;
+var DecisionAPIError = class extends (_b = Error, _a = decisionErrorMarker, _b) {
+  constructor(message, code, status, requestId) {
+    super(message);
+    this.code = code;
+    this.status = status;
+    this.requestId = requestId;
+    this.name = "DecisionAPIError";
+    this[_a] = true;
+  }
+  /** Works across CJS/ESM and separately bundled provider entry points. */
+  static isInstance(error) {
+    return typeof error === "object" && error !== null && /* @__PURE__ */ Symbol.for("yourgpt.llm-sdk.DecisionAPIError") in error;
+  }
+  /** Advisory only: this SDK does not retry Decisions automatically. */
+  get retryable() {
+    return this.code === "network_error" || this.code === "http_error" && (this.status === 408 || this.status === 429 || this.status != null && this.status >= 500);
+  }
+};
+
+// src/core/decision-validation.ts
+function decisionInputError(message) {
+  throw new DecisionAPIError(message, "invalid_input");
+}
+function decisionResponseError(message) {
+  throw new DecisionAPIError(message, "invalid_response");
+}
+function isDecisionRecord(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value))
+    return false;
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+}
+function json(value, seen = /* @__PURE__ */ new Set(), depth = 0) {
+  if (depth > 64) return false;
+  if (value === null || typeof value === "string" || typeof value === "boolean")
+    return true;
+  if (typeof value === "number") return Number.isFinite(value);
+  if (typeof value !== "object" || !Array.isArray(value) && !isDecisionRecord(value) || seen.has(value))
+    return false;
+  seen.add(value);
+  const valid = Object.getOwnPropertySymbols(value).length === 0 && (Array.isArray(value) ? Array.from(value) : Object.values(value)).every(
+    (item) => json(item, seen, depth + 1)
+  );
+  seen.delete(value);
+  return valid;
+}
+function input(value) {
+  return (typeof value === "string" || Array.isArray(value) || isDecisionRecord(value)) && json(value);
+}
+function assertDecisionKeys(value, allowed, label) {
+  if (Object.keys(value).some((key) => !allowed.includes(key)))
+    decisionInputError(`${label} contains an unsupported field`);
+}
+function validateDecisionInput(options) {
+  if (!isDecisionRecord(options))
+    decisionInputError("Decisions options must be an object");
+  assertDecisionKeys(
+    options,
+    ["state", "questions", "images", "signal", "timeoutMs", "providerOptions"],
+    "Decisions options"
+  );
+  if (!input(options.state))
+    decisionInputError(
+      "state must be finite, acyclic JSON text, object, or array (maximum depth 64)"
+    );
+  if (!isDecisionRecord(options.questions) || Object.keys(options.questions).length === 0)
+    decisionInputError("questions must be a nonempty map");
+  for (const [id, question] of Object.entries(options.questions)) {
+    if (!id.length || !isDecisionRecord(question) || !input(question.instructions))
+      decisionInputError(
+        "Every question needs a nonempty ID and JSON-compatible instructions"
+      );
+    assertDecisionKeys(
+      question,
+      ["type", "instructions", "criteria"],
+      "Question"
+    );
+    if (question.type === "boolean") {
+      if (question.criteria !== void 0 && (!isDecisionRecord(question.criteria) || Object.entries(question.criteria).some(
+        ([key, value]) => !["true", "false"].includes(key) || !input(value)
+      )))
+        decisionInputError("Boolean criteria may describe only true and false");
+    } else if (question.type === "choice") {
+      if (!isDecisionRecord(question.criteria) || Object.keys(question.criteria).length < 2 || Object.keys(question.criteria).length > 255 || Object.entries(question.criteria).some(
+        ([key, value]) => !key.length || value !== null && !input(value)
+      ))
+        decisionInputError(
+          "Choice criteria require 2\u2013255 named options with JSON descriptions or null"
+        );
+    } else if (question.type === "score") {
+      if (!Array.isArray(question.criteria) || question.criteria.length < 2 || !Array.from(question.criteria).every(input))
+        decisionInputError(
+          "Score criteria require at least two ordered JSON descriptions"
+        );
+    } else
+      decisionInputError("Question type must be boolean, choice, or score");
+  }
+  if (options.timeoutMs !== void 0 && (!Number.isInteger(options.timeoutMs) || options.timeoutMs < 1 || options.timeoutMs > 2147483647))
+    decisionInputError("timeoutMs must be a positive 32-bit integer");
+  if (options.providerOptions !== void 0 && (!isDecisionRecord(options.providerOptions) || !json(options.providerOptions)))
+    decisionInputError("providerOptions must be a JSON object");
+  if (options.images !== void 0 && (!Array.isArray(options.images) || !Array.from(options.images).every(
+    (image) => isDecisionRecord(image) && image.data instanceof Uint8Array
+  )))
+    decisionInputError(
+      "Decision images must contain encoded bytes; hosted image URLs are unsupported"
+    );
+}
+function probability(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0 && value <= 1;
+}
+function exactKeys(value, keys) {
+  return Object.keys(value).length === keys.length && keys.every((key) => Object.prototype.hasOwnProperty.call(value, key));
+}
+function validateDecisionResult(questions, result) {
+  if (!isDecisionRecord(result) || !isDecisionRecord(result.answers) || !exactKeys(result.answers, Object.keys(questions)))
+    decisionResponseError(
+      "Decisions must return exactly one answer per question"
+    );
+  const rounding = result.rounding;
+  let pError = 0, sError = 0;
+  if (rounding !== void 0) {
+    if (!isDecisionRecord(rounding) || ![rounding.probabilityDecimals, rounding.scoreDecimals].every(
+      (v) => typeof v === "number" && Number.isInteger(v) && v >= 0 && v <= 15
+    ))
+      decisionResponseError("Invalid decision rounding precision");
+    pError = 0.5 * 10 ** -rounding.probabilityDecimals;
+    sError = 0.5 * 10 ** -rounding.scoreDecimals;
+  }
+  const epsilon = 1e-6;
+  for (const [id, question] of Object.entries(questions)) {
+    const answer = result.answers[id];
+    if (!isDecisionRecord(answer))
+      decisionResponseError("Invalid decision answer");
+    if (answer.type === "refusal") continue;
+    if (answer.type !== question.type)
+      decisionResponseError("Decision answer type does not match its question");
+    if (answer.confidence !== void 0 && !probability(answer.confidence))
+      decisionResponseError(
+        "Confidence must be finite and between zero and one"
+      );
+    if (question.type === "boolean") {
+      if (!probability(answer.probability))
+        decisionResponseError(
+          "Boolean probability must be between zero and one"
+        );
+      continue;
+    }
+    const keys = question.type === "choice" ? Object.keys(question.criteria) : question.criteria.map((_, index) => String(index));
+    if (question.type === "choice" && (typeof answer.choice !== "string" || !keys.includes(answer.choice)))
+      decisionResponseError("Decision selected an unknown choice");
+    if (question.type === "score" && (typeof answer.score !== "number" || !Number.isFinite(answer.score) || answer.score < 0 || answer.score > keys.length - 1))
+      decisionResponseError("Decision score is outside its ordered levels");
+    if (answer.probabilities === void 0) continue;
+    const distribution2 = answer.probabilities;
+    if (!isDecisionRecord(distribution2) || !exactKeys(distribution2, keys) || !Object.values(distribution2).every(probability))
+      decisionResponseError(
+        "Decision distribution must contain every option exactly once with finite probabilities"
+      );
+    const values = Object.values(distribution2);
+    if (Math.abs(values.reduce((a, b) => a + b, 0) - 1) > epsilon + keys.length * pError)
+      decisionResponseError("Decision probabilities do not sum to one");
+    if (question.type === "choice") {
+      if (values.some(
+        (v) => v > distribution2[answer.choice] + epsilon + 2 * pError
+      ))
+        decisionResponseError(
+          "Decision choice is not a highest-probability option"
+        );
+    } else {
+      const mean = keys.reduce(
+        (sum, key) => sum + Number(key) * distribution2[key],
+        0
+      );
+      const tolerance = epsilon + sError + pError * keys.reduce((sum, key) => sum + Number(key), 0);
+      if (Math.abs(answer.score - mean) > tolerance)
+        decisionResponseError(
+          "Decision score does not match its probability-weighted levels"
+        );
+    }
+  }
+}
+
+// src/providers/decisions/http.ts
+async function postDecision(url, headers, body, options, fetchFn, maxBytes) {
+  const encoded = JSON.stringify(body);
+  if (Buffer.byteLength(encoded, "utf8") > maxBytes)
+    decisionInputError("Decision request exceeds the provider's byte limit");
+  options.signal?.throwIfAborted();
+  const controller = new AbortController();
+  const relay = () => controller.abort(options.signal?.reason);
+  options.signal?.addEventListener("abort", relay, { once: true });
+  const timer = setTimeout(
+    () => controller.abort(
+      new DOMException("Decision request timed out", "TimeoutError")
+    ),
+    options.timeoutMs ?? 6e4
+  );
+  let rejectAbort = () => {
+  };
+  const aborted = new Promise((_, reject) => {
+    rejectAbort = () => reject(controller.signal.reason);
+    controller.signal.addEventListener("abort", rejectAbort, { once: true });
+  });
+  const perform = async () => {
+    let response;
+    try {
+      response = await fetchFn(url, {
+        method: "POST",
+        headers,
+        body: encoded,
+        signal: controller.signal,
+        redirect: "error"
+      });
+    } catch {
+      controller.signal.throwIfAborted();
+      throw new DecisionAPIError(
+        "Decision request failed before receiving a response",
+        "network_error"
+      );
+    }
+    const requestId = response.headers.get("x-request-id") ?? response.headers.get("cf-ray") ?? void 0;
+    if (controller.signal.aborted) {
+      void response.body?.cancel().catch(() => {
+      });
+      controller.signal.throwIfAborted();
+    }
+    if (!response.ok) {
+      void response.body?.cancel().catch(() => {
+      });
+      throw new DecisionAPIError(
+        `Decision API returned HTTP ${response.status}`,
+        "http_error",
+        response.status,
+        requestId
+      );
+    }
+    if (!response.body)
+      decisionResponseError("Decision API returned an empty body");
+    const reader = response.body.getReader();
+    const cancel = () => {
+      void reader.cancel().catch(() => {
+      });
+    };
+    controller.signal.addEventListener("abort", cancel, { once: true });
+    const chunks = [];
+    let size = 0;
+    try {
+      while (true) {
+        controller.signal.throwIfAborted();
+        const { value: value2, done } = await reader.read();
+        if (done) break;
+        size += value2.byteLength;
+        if (size > 8 * 1024 * 1024) {
+          cancel();
+          decisionResponseError("Decision API response exceeds 8 MiB");
+        }
+        chunks.push(value2);
+      }
+    } catch (error) {
+      controller.signal.throwIfAborted();
+      if (error instanceof DecisionAPIError) throw error;
+      throw new DecisionAPIError(
+        "Decision response could not be read",
+        "network_error",
+        response.status,
+        requestId
+      );
+    } finally {
+      controller.signal.removeEventListener("abort", cancel);
+      reader.releaseLock();
+    }
+    controller.signal.throwIfAborted();
+    let value;
+    try {
+      value = JSON.parse(Buffer.concat(chunks).toString("utf8"));
+    } catch {
+      decisionResponseError("Decision API did not return valid JSON");
+    }
+    return { value, status: response.status, requestId };
+  };
+  try {
+    return await Promise.race([perform(), aborted]);
+  } finally {
+    clearTimeout(timer);
+    options.signal?.removeEventListener("abort", relay);
+    controller.signal.removeEventListener("abort", rejectAbort);
+  }
+}
+
+// src/providers/decisions/images.ts
+function unsupportedDecision(message) {
+  throw new DecisionAPIError(message, "unsupported_option");
+}
+function prepareDecisionImages(images, provider) {
+  if (provider === "openrouter" && images.length)
+    unsupportedDecision(
+      "OpenRouter's native Decisions schema does not support image inputs"
+    );
+  if (provider === "cloudflare" && images.length > 4)
+    decisionInputError("Cloudflare Decisions supports at most four images");
+  if (provider === "openai" && images.length > 128)
+    decisionInputError("OpenAI Decisions supports at most 128 images");
+  let total = 0;
+  return images.map((image) => {
+    assertDecisionKeys(
+      image,
+      ["data", "mediaType", "detail"],
+      "Decision image"
+    );
+    if (image.detail !== void 0) {
+      if (provider !== "openai")
+        unsupportedDecision(
+          "Image detail is only supported by OpenAI Decisions"
+        );
+      if (!["auto", "low", "high", "original"].includes(image.detail))
+        decisionInputError("Invalid image detail");
+    }
+    const data = Buffer.from(image.data);
+    const signature = data.subarray(0, 12).toString("latin1");
+    const mediaType = signature.startsWith("\x89PNG\r\n\n") ? "image/png" : data[0] === 255 && data[1] === 216 && data[2] === 255 ? "image/jpeg" : signature.startsWith("RIFF") && signature.slice(8) === "WEBP" ? "image/webp" : /^GIF8[79]a/.test(signature) ? "image/gif" : void 0;
+    if (!mediaType || image.mediaType !== void 0 && image.mediaType !== mediaType)
+      decisionInputError(
+        "Decision image bytes must match a supported encoded image format"
+      );
+    if (provider === "typesafe" && !["image/png", "image/jpeg"].includes(mediaType))
+      unsupportedDecision("Jev images must be PNG or JPEG");
+    if (provider === "cloudflare" && mediaType === "image/gif")
+      unsupportedDecision("Cloudflare Decisions does not accept GIF images");
+    const limit = provider === "cloudflare" ? 4 : provider === "typesafe" ? 16 : 20;
+    if (data.length > limit * 1024 * 1024)
+      decisionInputError("Decision image exceeds this provider's file limit");
+    total += data.length;
+    if (provider === "cloudflare" && total > 8 * 1024 * 1024)
+      decisionInputError("Cloudflare Decisions images exceed 8 MiB total");
+    const base64 = data.toString("base64");
+    return {
+      url: `data:${mediaType};base64,${base64}`,
+      base64,
+      mediaType,
+      detail: image.detail
+    };
+  });
+}
+
+// src/providers/decisions/response.ts
+function distribution(value, score) {
+  if (!Array.isArray(value))
+    decisionResponseError(
+      "OpenAI Decisions omitted its probability distribution"
+    );
+  const entries = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const item of value) {
+    if (!isDecisionRecord(item) || (score ? typeof item.value !== "number" || !Number.isInteger(item.value) || item.value < 0 : typeof item.value !== "string"))
+      decisionResponseError("Invalid decision probability option");
+    const key = String(item.value);
+    if (seen.has(key))
+      decisionResponseError("Duplicate option in decision probabilities");
+    seen.add(key);
+    entries.push([key, item.probability]);
+  }
+  return Object.fromEntries(entries);
+}
+function parseDecisionResponse(raw, provider, questions, status, requestId) {
+  if (!isDecisionRecord(raw))
+    decisionResponseError("Decision response must be an object");
+  let payload = raw;
+  if (provider === "cloudflare") {
+    if (raw.success === false)
+      throw new DecisionAPIError(
+        "Cloudflare reported an unsuccessful decision request",
+        "http_error",
+        status,
+        requestId
+      );
+    if (raw.success !== true || !isDecisionRecord(raw.result))
+      decisionResponseError(
+        "Cloudflare Decisions returned an invalid result envelope"
+      );
+    payload = raw.result;
+  }
+  if (typeof payload.model !== "string" || !payload.model)
+    decisionResponseError("Decision response omitted its model identity");
+  const entries = [];
+  if (provider === "openai") {
+    if (!Array.isArray(payload.answers))
+      decisionResponseError("OpenAI Decisions answers must be an array");
+    const seen = /* @__PURE__ */ new Set();
+    for (const answer of payload.answers) {
+      if (!isDecisionRecord(answer))
+        decisionResponseError("Invalid OpenAI decision answer");
+      if (answer.type === "refusal" && answer.name == null)
+        throw new DecisionAPIError(
+          "OpenAI refused an unnamed decision question",
+          "refusal",
+          status,
+          requestId
+        );
+      if (typeof answer.name !== "string" || seen.has(answer.name))
+        decisionResponseError(
+          "OpenAI decision answers have missing or duplicate question identities"
+        );
+      seen.add(answer.name);
+      entries.push([answer.name, answer]);
+    }
+  } else {
+    if (!isDecisionRecord(payload.answers))
+      decisionResponseError("Decisions answers must be a named map");
+    entries.push(...Object.entries(payload.answers));
+  }
+  const answers = Object.fromEntries(
+    entries.map(([id, value]) => {
+      if (!isDecisionRecord(value))
+        decisionResponseError("Invalid decision answer");
+      if (value.type === "refusal" && provider === "openai")
+        return [id, { type: "refusal" }];
+      const booleanType = provider === "openai" ? "predicate" : "noul";
+      if (value.type === booleanType)
+        return [
+          id,
+          {
+            type: "boolean",
+            probability: provider === "openai" ? value.probability : value.noul
+          }
+        ];
+      if (value.type !== "choice" && value.type !== "score")
+        decisionResponseError(
+          "Provider returned an unsupported decision answer type"
+        );
+      if (provider !== "openrouter" && value.probabilities == null)
+        decisionResponseError(
+          "Provider omitted a required decision distribution"
+        );
+      const probabilities = provider === "openai" ? distribution(value.probabilities, value.type === "score") : value.probabilities;
+      const fields = {
+        ...probabilities !== void 0 && {
+          probabilities
+        },
+        ...value.confidence != null && {
+          confidence: value.confidence
+        }
+      };
+      return [
+        id,
+        value.type === "choice" ? { type: "choice", choice: value.choice, ...fields } : { type: "score", score: value.score, ...fields }
+      ];
+    })
+  );
+  const result = {
+    answers,
+    response: {
+      provider,
+      modelId: payload.model,
+      status,
+      requestId: requestId ?? (typeof payload.id === "string" ? payload.id : void 0),
+      body: raw
+    }
+  };
+  const typesafe = provider === "typesafe" || provider === "openrouter" && (payload.model.startsWith("typesafe/") || payload.provider === "TypeSafe");
+  if (typesafe) result.rounding = { probabilityDecimals: 2, scoreDecimals: 2 };
+  if (payload.usage != null) {
+    if (!isDecisionRecord(payload.usage))
+      decisionResponseError("Invalid decision usage");
+    const usage = payload.usage;
+    const details = isDecisionRecord(usage.input_tokens_details) ? usage.input_tokens_details : {};
+    result.usage = {};
+    const mapped = {
+      inputTokens: usage.input_tokens,
+      outputTokens: usage.output_tokens,
+      totalTokens: usage.total_tokens,
+      cachedInputTokens: details.cached_tokens,
+      cacheWriteTokens: details.cache_write_tokens,
+      costUsd: usage.cost
+    };
+    for (const [key, value] of Object.entries(mapped)) {
+      if (value == null) continue;
+      if (typeof value !== "number" || !Number.isFinite(value) || value < 0 || key !== "costUsd" && !Number.isInteger(value))
+        decisionResponseError("Invalid decision usage count");
+      result.usage[key] = value;
+    }
+  }
+  validateDecisionResult(questions, result);
+  return result;
+}
+
+// src/providers/decisions/model.ts
+function asText(value) {
+  return typeof value === "string" ? value : JSON.stringify(value);
+}
+function requestOptions(options, provider) {
+  for (const key of Object.keys(options.providerOptions ?? {})) {
+    if (key !== provider)
+      unsupportedDecision(
+        "Decision providerOptions must match the selected provider"
+      );
+  }
+  const opts = options.providerOptions?.[provider] ?? {};
+  if (!isDecisionRecord(opts))
+    decisionInputError("Decision provider options must be an object");
+  const allowed = provider === "openai" ? ["safetyIdentifier", "promptCacheKey"] : provider === "typesafe" ? ["longContext"] : provider === "openrouter" ? ["sessionId", "provider"] : [];
+  assertDecisionKeys(opts, allowed, "Decision provider options");
+  for (const [key, limit] of [
+    ["safetyIdentifier", 128],
+    ["promptCacheKey", 64],
+    ["sessionId", 256]
+  ]) {
+    if (opts[key] !== void 0 && (typeof opts[key] !== "string" || opts[key].length > limit))
+      decisionInputError("Invalid decision identifier or cache key");
+  }
+  if (opts.longContext !== void 0 && typeof opts.longContext !== "boolean")
+    decisionInputError("longContext must be boolean");
+  if (opts.provider !== void 0) {
+    if (!isDecisionRecord(opts.provider))
+      decisionInputError("OpenRouter routing preferences must be an object");
+    assertDecisionKeys(
+      opts.provider,
+      ["order", "allowFallbacks"],
+      "OpenRouter routing preferences"
+    );
+    if (opts.provider.allowFallbacks !== void 0 && typeof opts.provider.allowFallbacks !== "boolean")
+      decisionInputError("allowFallbacks must be boolean");
+    if (opts.provider.order !== void 0 && (!Array.isArray(opts.provider.order) || !opts.provider.order.every(
+      (value) => typeof value === "string" && value.length
+    )))
+      decisionInputError("Provider order must be an array of provider names");
+  }
+  return opts;
+}
+function nativeDecisionModel(modelId, config) {
+  if (typeof modelId !== "string" || !modelId.trim())
+    decisionInputError("Decision model ID is required");
+  const provider = config.provider;
+  return {
+    provider,
+    modelId,
+    async doDecide(options) {
+      validateDecisionInput(options);
+      options.signal?.throwIfAborted();
+      const opts = requestOptions(options, provider);
+      const questions = Object.entries(options.questions);
+      if (provider === "openai" && questions.length > 200)
+        decisionInputError("OpenAI Decisions supports at most 200 questions");
+      if (provider === "cloudflare" && (questions.length > 64 || questions.some(([id]) => !/^[A-Za-z0-9_.-]{1,100}$/.test(id))))
+        decisionInputError(
+          "Cloudflare supports 1\u201364 questions with IDs of 1\u2013100 letters, digits, underscores, dots, or hyphens"
+        );
+      for (const [, question] of questions) {
+        if (provider !== "openai" && question.type === "score" && question.criteria.length > 10)
+          decisionInputError(
+            "System One adapters support at most ten score levels"
+          );
+        if (provider === "cloudflare" && typeof question.instructions === "string" && !question.instructions.trim())
+          decisionInputError("Cloudflare requires nonempty instructions");
+        if (provider === "openrouter" && question.type === "boolean" && question.criteria !== void 0 && (question.criteria.true === void 0 || question.criteria.false === void 0))
+          decisionInputError(
+            "OpenRouter boolean criteria must describe both true and false when supplied"
+          );
+      }
+      const images = prepareDecisionImages(options.images ?? [], provider);
+      const headers = Object.fromEntries(
+        Object.entries(config.headers ?? {}).filter(
+          ([name]) => !["authorization", "content-type"].includes(name.toLowerCase())
+        )
+      );
+      headers["Content-Type"] = "application/json";
+      const key = config.apiKey ?? process.env[config.keyEnv];
+      if (!key?.trim())
+        decisionInputError(`Missing ${config.keyEnv} for Decisions`);
+      headers.Authorization = `Bearer ${key}`;
+      let body;
+      if (provider === "openai") {
+        body = {
+          model: modelId,
+          input: [
+            {
+              role: "user",
+              content: [
+                { type: "input_text", text: asText(options.state) },
+                ...images.map((image) => ({
+                  type: "input_image",
+                  image_url: image.url,
+                  ...image.detail !== void 0 && { detail: image.detail }
+                }))
+              ]
+            }
+          ],
+          questions: questions.map(([name, question]) => {
+            const instructions = asText(question.instructions);
+            if (question.type === "boolean")
+              return {
+                type: "predicate",
+                name,
+                instructions: [
+                  instructions,
+                  ...Object.entries(question.criteria ?? {}).map(
+                    ([key2, value]) => `Criteria for ${key2}:
+${asText(value)}`
+                  )
+                ].join("\n\n")
+              };
+            if (question.type === "choice")
+              return {
+                type: "choice",
+                name,
+                instructions,
+                choices: Object.entries(question.criteria).map(
+                  ([value, description]) => ({
+                    value,
+                    ...description !== null && {
+                      description: asText(description)
+                    }
+                  })
+                )
+              };
+            return {
+              type: "score",
+              name,
+              instructions,
+              levels: question.criteria.map((description, index) => ({
+                label: String(index),
+                description: asText(description)
+              }))
+            };
+          }),
+          ...opts.safetyIdentifier !== void 0 && {
+            safety_identifier: opts.safetyIdentifier
+          },
+          ...opts.promptCacheKey !== void 0 && {
+            prompt_cache_key: opts.promptCacheKey
+          }
+        };
+      } else {
+        body = {
+          model: config.bodyModel ?? modelId,
+          state: options.state,
+          questions: Object.fromEntries(
+            questions.map(([id, question]) => [
+              id,
+              {
+                ...question,
+                type: question.type === "boolean" ? "noul" : question.type
+              }
+            ])
+          )
+        };
+        if (provider === "typesafe") {
+          if (opts.longContext)
+            headers["TypeSafe-Danger-Zone-Long-Context"] = "true";
+          if (images.length) {
+            const refs = images.map(() => crypto.randomUUID());
+            body.state = { state: options.state, images: refs };
+            body.assets = Object.fromEntries(
+              images.map((image, index) => [
+                refs[index],
+                {
+                  type: "image",
+                  data_base64: image.base64,
+                  format: image.mediaType === "image/png" ? "png" : "jpeg"
+                }
+              ])
+            );
+            headers["TypeSafe-Danger-Zone-Images"] = "true";
+          }
+        } else if (provider === "cloudflare" && images.length) {
+          body.images = images.map((image) => ({
+            content_type: image.mediaType,
+            base64: image.base64
+          }));
+        } else if (provider === "openrouter") {
+          if (opts.sessionId !== void 0) body.session_id = opts.sessionId;
+          if (isDecisionRecord(opts.provider))
+            body.provider = {
+              ...opts.provider.order !== void 0 && {
+                order: opts.provider.order
+              },
+              ...opts.provider.allowFallbacks !== void 0 && {
+                allow_fallbacks: opts.provider.allowFallbacks
+              }
+            };
+        }
+      }
+      const base = config.baseUrl ?? config.defaultBaseUrl;
+      let url;
+      try {
+        url = new URL(`${base.replace(/\/+$/, "")}${config.path}`);
+      } catch {
+        decisionInputError("Invalid Decisions base URL");
+      }
+      if (!["https:", "http:"].includes(url.protocol) || url.username || url.password || url.search || url.hash)
+        decisionInputError(
+          "Decisions base URL must be an HTTP(S) API root without credentials, query, or fragment"
+        );
+      const response = await postDecision(
+        url.href,
+        headers,
+        body,
+        options,
+        config.fetch ?? globalThis.fetch,
+        (provider === "cloudflare" ? 13 : 32) * 1024 * 1024
+      );
+      return parseDecisionResponse(
+        response.value,
+        provider,
+        options.questions,
+        response.status,
+        response.requestId
+      );
+    }
+  };
+}
+
+// src/providers/typesafe/index.ts
+function typesafeDecision(modelId = "jev-latest", options = {}) {
+  return nativeDecisionModel(modelId, {
+    ...options,
+    provider: "typesafe",
+    keyEnv: "TYPESAFE_AI_API_KEY",
+    defaultBaseUrl: "https://api.typesafe.ai/v1",
+    path: "/systemone"
+  });
+}
+
+exports.typesafeDecision = typesafeDecision;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map