@cimplify/sdk 0.108.0 → 0.110.2

package/dist/chunk-OKC2B4O3.mjs

@@ -0,0 +1,312 @@
+import { CTX_LIMITS } from './chunk-SPCRQ6NO.mjs';
+
+// src/interactives/generate/schema.ts
+function make(json, optional = false) {
+  return { json, optional };
+}
+function withNote(json, note) {
+  return note === void 0 ? json : { ...json, description: note };
+}
+function bound(value, fallback, cap) {
+  return Math.min(Math.max(0, Math.floor(value ?? fallback)), cap);
+}
+var t = {
+  string(options = {}) {
+    let json = {
+      type: "string",
+      maxLength: bound(options.max, 200, 2e3)
+    };
+    return options.min !== void 0 && (json.minLength = bound(options.min, 0, 2e3)), make(withNote(json, options.note));
+  },
+  integer(options = {}) {
+    let json = { type: "integer" };
+    return options.min !== void 0 && (json.minimum = options.min), options.max !== void 0 && (json.maximum = options.max), make(withNote(json, options.note));
+  },
+  number(options = {}) {
+    let json = { type: "number" };
+    return options.min !== void 0 && (json.minimum = options.min), options.max !== void 0 && (json.maximum = options.max), make(withNote(json, options.note));
+  },
+  boolean(note) {
+    return make(withNote({ type: "boolean" }, note));
+  },
+  literal(value) {
+    return make({ const: value });
+  },
+  enum(values, note) {
+    return make(withNote({ enum: values }, note));
+  },
+  array(items, options = {}) {
+    let json = {
+      type: "array",
+      items: items.json,
+      maxItems: bound(options.max, 16, 64)
+    };
+    return options.min !== void 0 && (json.minItems = bound(options.min, 0, 64)), make(withNote(json, options.note));
+  },
+  object(shape, note) {
+    let properties = {}, required = [];
+    for (let [name, field] of Object.entries(shape))
+      properties[name] = field.json, field.optional || required.push(name);
+    return make(
+      withNote({ type: "object", additionalProperties: false, properties, required }, note)
+    );
+  },
+  union(...choices) {
+    return make({ anyOf: choices.map((choice) => choice.json) });
+  },
+  optional(schema) {
+    return { json: schema.json, optional: true };
+  }
+}, dialogueSchema = t.object({
+  speaker: t.optional(t.string({ max: 40 })),
+  lines: t.array(t.string({ max: 240 }), { min: 1, max: 6 })
+});
+
+// src/interactives/generate/validate.ts
+function isNode(value) {
+  return value !== null && typeof value == "object" && !Array.isArray(value);
+}
+function typeMatches(kind, value) {
+  switch (kind) {
+    case "object":
+      return value !== null && typeof value == "object" && !Array.isArray(value);
+    case "array":
+      return Array.isArray(value);
+    case "string":
+      return typeof value == "string";
+    case "integer":
+      return typeof value == "number" && Number.isInteger(value);
+    case "number":
+      return typeof value == "number" && Number.isFinite(value);
+    case "boolean":
+      return typeof value == "boolean";
+    case "null":
+      return value === null;
+    default:
+      return false;
+  }
+}
+function same(a, b) {
+  return JSON.stringify(a) === JSON.stringify(b);
+}
+function validateValue(schema, value, at = "$") {
+  let values = schema.enum;
+  if (Array.isArray(values))
+    return values.some((allowed) => same(allowed, value)) ? null : `${at} is not one of the allowed values`;
+  if ("const" in schema)
+    return same(schema.const, value) ? null : `${at} must be ${JSON.stringify(schema.const)}`;
+  let choices = schema.anyOf;
+  if (Array.isArray(choices))
+    return choices.some((choice) => isNode(choice) && validateValue(choice, value, at) === null) ? null : `${at} matches none of the allowed shapes`;
+  if (schema.type !== void 0 && !typeMatches(schema.type, value))
+    return `${at} must be a ${String(schema.type)}`;
+  if (Array.isArray(value)) {
+    let min = schema.minItems, max = schema.maxItems;
+    if (typeof min == "number" && value.length < min) return `${at} has too few items`;
+    if (typeof max == "number" && value.length > max) return `${at} has too many items`;
+    let items = schema.items;
+    if (isNode(items))
+      for (let index = 0; index < value.length; index++) {
+        let problem = validateValue(items, value[index], `${at}[${index}]`);
+        if (problem !== null) return problem;
+      }
+    return null;
+  }
+  if (value !== null && typeof value == "object") {
+    let fields = value, properties = isNode(schema.properties) ? schema.properties : {}, required = Array.isArray(schema.required) ? schema.required : [];
+    for (let name of required)
+      if (typeof name == "string" && !(name in fields)) return `${at}.${name} is missing`;
+    for (let [name, field] of Object.entries(fields)) {
+      let child = properties[name];
+      if (isNode(child)) {
+        let problem = validateValue(child, field, `${at}.${name}`);
+        if (problem !== null) return problem;
+      } else if (schema.additionalProperties === false)
+        return `${at}.${name} is not allowed`;
+    }
+    return null;
+  }
+  if (typeof value == "string") {
+    let chars = [...value].length;
+    return typeof schema.minLength == "number" && chars < schema.minLength ? `${at} is too short` : typeof schema.maxLength == "number" && chars > schema.maxLength ? `${at} is too long` : null;
+  }
+  if (typeof value == "number") {
+    if (typeof schema.minimum == "number" && value < schema.minimum)
+      return `${at} is below its minimum`;
+    if (typeof schema.maximum == "number" && value > schema.maximum)
+      return `${at} is above its maximum`;
+  }
+  return null;
+}
+function select(value, path) {
+  let found = [value];
+  for (let segment of path.split(".")) {
+    let next = [];
+    for (let item of found)
+      if (segment === "*")
+        Array.isArray(item) ? next.push(...item) : item !== null && typeof item == "object" && next.push(...Object.values(item));
+      else if (Array.isArray(item)) {
+        let index = Number(segment);
+        Number.isInteger(index) && index >= 0 && index < item.length && next.push(item[index]);
+      } else item !== null && typeof item == "object" && segment in item && next.push(item[segment]);
+    found = next;
+  }
+  return found;
+}
+function applyRules(rules, value) {
+  for (let rule2 of rules) {
+    let found = select(value, rule2.path);
+    switch (rule2.kind) {
+      case "range":
+        if (found.some((item) => typeof item != "number" || item < rule2.min || item > rule2.max))
+          return `${rule2.path} must stay between ${rule2.min} and ${rule2.max}`;
+        break;
+      case "total": {
+        let total = 0;
+        for (let item of found) {
+          if (typeof item != "number") return `${rule2.path} must be a number`;
+          total += item;
+        }
+        if (total > rule2.max) return `${rule2.path} must add up to at most ${rule2.max}`;
+        break;
+      }
+      case "count":
+        if (found.length < rule2.min || found.length > rule2.max)
+          return `${rule2.path} must appear ${rule2.min} to ${rule2.max} times`;
+        break;
+      case "one_of":
+        if (found.some((item) => typeof item != "string" || !rule2.values.includes(item)))
+          return `${rule2.path} must be one of the game's values`;
+        break;
+      case "distinct": {
+        if (new Set(found.map((item) => JSON.stringify(item))).size !== found.length) return `${rule2.path} must not repeat`;
+        break;
+      }
+    }
+  }
+  return null;
+}
+var rule = {
+  range: (path, min, max) => ({
+    kind: "range",
+    path,
+    min,
+    max
+  }),
+  total: (path, max) => ({ kind: "total", path, max }),
+  count: (path, min, max) => ({
+    kind: "count",
+    path,
+    min,
+    max
+  }),
+  oneOf: (path, values) => ({
+    kind: "one_of",
+    path,
+    values: [...values]
+  }),
+  distinct: (path) => ({ kind: "distinct", path })
+};
+
+// src/interactives/generate/generate.ts
+var DEFAULT_TIMEOUT_MS = 4e3, MIN_TIMEOUT_MS = CTX_LIMITS.min_ai_content_timeout_ms, MAX_TIMEOUT_MS = CTX_LIMITS.max_ai_content_timeout_ms, DEFAULT_RETRIES = CTX_LIMITS.max_ai_content_retries, TIMEOUT_GRACE_MS = 250, sequence = 0;
+function resolveFallback(fallback) {
+  return typeof fallback == "function" ? fallback() : fallback;
+}
+function clampTimeout(timeoutMs) {
+  return Math.min(
+    Math.max(Math.round(timeoutMs ?? (4e3)), MIN_TIMEOUT_MS),
+    MAX_TIMEOUT_MS
+  );
+}
+function fallbackOf(request, reason, seed) {
+  return {
+    value: resolveFallback(request.fallback),
+    source: "fallback",
+    reason,
+    seed,
+    runId: null,
+    digest: null
+  };
+}
+function reasonOfError(error) {
+  switch (error !== null && typeof error == "object" && "code" in error ? error.code : null) {
+    case "meter_exhausted":
+      return "budget";
+    case "denied":
+    case "consent_required":
+      return "denied";
+    case "invalid_arguments":
+      return "invalid_request";
+    default:
+      return "unavailable";
+  }
+}
+function schemaFor(kind, schema) {
+  return schema !== void 0 ? schema.json : kind === "dialogue" ? dialogueSchema.json : null;
+}
+function contentRequest(kind, request, scope, key) {
+  let schema = kind === "dialogue" && request.schema === void 0 ? void 0 : request.schema?.json;
+  return {
+    request_key: key,
+    kind,
+    prompt: request.prompt,
+    schema: schema ?? null,
+    rules: [...request.rules ?? []],
+    slots: [...request.slots ?? []],
+    context: request.context ?? null,
+    scope: scope === null ? { kind: "player" } : { kind: "room", room_id: scope.room_id, key: scope.key },
+    language: request.language ?? null,
+    variant: request.variant ?? 0,
+    seed: request.seed ?? null,
+    retries: request.retries ?? DEFAULT_RETRIES,
+    timeout_ms: clampTimeout(request.timeoutMs),
+    payment: request.payment ?? null
+  };
+}
+function acceptContent(kind, request, content) {
+  if (content.outcome === "fallback" || content.value === void 0 || content.value === null)
+    return fallbackOf(request, content.fallback ?? "unavailable", content.seed);
+  let value = content.value, schema = schemaFor(kind, request.schema);
+  return schema !== null && validateValue(schema, value) !== null || applyRules(request.rules ?? [], value) !== null ? fallbackOf(request, "invalid", content.seed) : request.check !== void 0 && request.check(value) !== true ? fallbackOf(request, "check", content.seed) : {
+    value,
+    source: content.outcome,
+    reason: null,
+    seed: content.seed,
+    runId: content.run_id,
+    digest: content.output_digest ?? null
+  };
+}
+function timer(ms) {
+  let handle;
+  return { done: new Promise((resolve) => {
+    handle = setTimeout(() => resolve("timeout"), ms);
+  }), cancel: () => clearTimeout(handle) };
+}
+async function runContent(ai, kind, request, scope, key) {
+  let wire = contentRequest(kind, request, scope, key), clock = timer(wire.timeout_ms + (250));
+  try {
+    let answer = await Promise.race([ai.content(wire), clock.done]);
+    return answer === "timeout" ? fallbackOf(request, "timed_out", request.seed ?? 0) : acceptContent(kind, request, answer);
+  } catch (error) {
+    return fallbackOf(request, reasonOfError(error), request.seed ?? 0);
+  } finally {
+    clock.cancel();
+  }
+}
+function createGenerate(ai, options = {}) {
+  let prefix = options.keyPrefix ?? "gen", nextKey = (explicit) => explicit !== void 0 ? explicit : (sequence += 1, `${prefix}-${sequence}`), generate = ((kind, request) => runContent(ai, kind, request, null, nextKey(request.key)));
+  return generate.dialogue = (request) => runContent(ai, "dialogue", request, null, nextKey(request.key)), generate.text = (request) => runContent(ai, "text", request, null, nextKey(request.key)), generate.item = (request) => runContent(ai, "item", request, null, nextKey(request.key)), generate.quest = (request) => runContent(ai, "quest", request, null, nextKey(request.key)), generate.room = (request) => runContent(ai, "room", request, null, nextKey(request.key)), generate.prefetch = async (entries) => {
+    try {
+      return await ai.content_prefetch({
+        requests: entries.map(
+          (entry) => contentRequest(entry.kind, entry, null, nextKey(entry.key))
+        )
+      });
+    } catch {
+      return { accepted: 0, already_cached: 0, refused: entries.length };
+    }
+  }, generate;
+}
+
+export { DEFAULT_RETRIES, DEFAULT_TIMEOUT_MS, MAX_TIMEOUT_MS, MIN_TIMEOUT_MS, acceptContent, applyRules, contentRequest, createGenerate, dialogueSchema, rule, runContent, select, t, validateValue };