nuabase 2.3.7 → 3.0.0

package/dist/esm/chunks/strict-json-schema-Du2LLrVP.mjs

@@ -0,0 +1,138 @@
+class ConsoleLogger {
+  debug(message, context) {
+    console.debug(`[DEBUG] ${message}`, context || "");
+  }
+  info(message, context) {
+    console.info(`[INFO] ${message}`, context || "");
+  }
+  warn(message, context) {
+    console.warn(`[WARN] ${message}`, context || "");
+  }
+  error(message, context) {
+    console.error(`[ERROR] ${message}`, context || "");
+  }
+}
+const generateSpanId = () => crypto.randomUUID();
+function pickHeaders(headers, allowlist, redactSet) {
+  const result = {};
+  for (const [key, value] of Object.entries(headers)) {
+    const lowerKey = key.toLowerCase();
+    if (allowlist.has(lowerKey)) {
+      result[key] = Array.isArray(value) ? value.join(", ") : value ?? "";
+    }
+  }
+  return result;
+}
+function normalizeError(error) {
+  return error instanceof Error ? { message: error.message, stack: error.stack } : String(error);
+}
+const LLM_RESPONSE_HEADER_ALLOWLIST = /* @__PURE__ */ new Set([
+  "x-request-id",
+  "x-ratelimit-limit-requests",
+  "x-ratelimit-limit-tokens",
+  "x-ratelimit-remaining-requests",
+  "x-ratelimit-remaining-tokens",
+  "x-groq-region"
+]);
+const logLlmCallStart = (logger, spanId, service, method, request) => {
+  logger.info("LLM call started", {
+    type: "llm_call_start",
+    span_id: spanId,
+    service,
+    method,
+    ...request
+  });
+};
+const logLlmCallComplete = (logger, spanId, service, method, response, duration) => {
+  const { headers, ...rest } = response;
+  logger.info("LLM call completed", {
+    type: "llm_call_complete",
+    span_id: spanId,
+    service,
+    method,
+    ...rest,
+    ...pickHeaders(headers, LLM_RESPONSE_HEADER_ALLOWLIST),
+    duration_ms: duration
+  });
+};
+const logLlmCallError = (logger, spanId, service, method, error, duration) => {
+  logger.error("LLM call failed", {
+    type: "llm_call_error",
+    span_id: spanId,
+    service,
+    method,
+    error: normalizeError(error),
+    duration_ms: duration
+  });
+};
+
+const STRICT_UNSUPPORTED_KEYWORDS = /* @__PURE__ */ new Set([
+  "patternProperties",
+  "propertyNames",
+  "unevaluatedProperties",
+  "dependentRequired",
+  "dependentSchemas",
+  "if",
+  "then",
+  "else",
+  "not",
+  "allOf",
+  "oneOf"
+]);
+function toStrictSchema(schema) {
+  return strictNode(schema);
+}
+function strictNode(node) {
+  if (typeof node !== "object" || node === null || Array.isArray(node)) {
+    return null;
+  }
+  const schema = node;
+  for (const key of Object.keys(schema)) {
+    if (STRICT_UNSUPPORTED_KEYWORDS.has(key)) return null;
+  }
+  const result = { ...schema };
+  delete result.$schema;
+  const isObject = schema.type === "object" || Array.isArray(schema.type) && schema.type.includes("object") || schema.properties !== void 0;
+  if (isObject) {
+    const properties = schema.properties ?? {};
+    if (schema.additionalProperties !== void 0 && schema.additionalProperties !== false) {
+      return null;
+    }
+    const required = new Set(schema.required ?? []);
+    const shapedProperties = {};
+    for (const [name, child] of Object.entries(properties)) {
+      if (!required.has(name)) return null;
+      const shaped = strictNode(child);
+      if (!shaped) return null;
+      shapedProperties[name] = shaped;
+    }
+    result.properties = shapedProperties;
+    result.required = Object.keys(shapedProperties);
+    result.additionalProperties = false;
+  }
+  if (schema.items !== void 0) {
+    const shaped = strictNode(schema.items);
+    if (!shaped) return null;
+    result.items = shaped;
+  }
+  if (schema.prefixItems !== void 0) return null;
+  if (schema.anyOf !== void 0) {
+    const variants = schema.anyOf.map(strictNode);
+    if (variants.some((v) => v === null)) return null;
+    result.anyOf = variants;
+  }
+  for (const defsKey of ["$defs", "definitions"]) {
+    if (schema[defsKey] !== void 0) {
+      const defs = {};
+      for (const [name, child] of Object.entries(schema[defsKey])) {
+        const shaped = strictNode(child);
+        if (!shaped) return null;
+        defs[name] = shaped;
+      }
+      result[defsKey] = defs;
+    }
+  }
+  return result;
+}
+
+export { ConsoleLogger as C, logLlmCallComplete as a, logLlmCallError as b, generateSpanId as g, logLlmCallStart as l, toStrictSchema as t };