@silmaril-security/sdk 0.4.1 → 0.5.0

package/dist/index.cjs

@@ -5,8 +5,13 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+var __esm = (fn, res, err) => function __init() {
+  if (err) throw err[0];
+  try {
+    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+  } catch (e) {
+    throw err = [e], e;
+  }
 };
 var __export = (target, all) => {
   for (var name in all)
@@ -295,7 +300,7 @@ async function createLangChainHandler(firewall, options = {}) {
       return;
     }
     const threshold = result.threshold;
-    const blocked = result.score >= threshold;
+    const blocked = result.prediction === "MALICIOUS";
     const commonEventFields = {
       hook: hookLabel,
       ...toolName !== void 0 ? { toolName } : {},
@@ -426,29 +431,29 @@ var init_langchain = __esm({
 var src_exports = {};
 __export(src_exports, {
   ALL_HOOKS: () => ALL_HOOKS,
-  CHUNK_OVERLAP: () => CHUNK_OVERLAP,
-  CHUNK_OVERLAP_CHARS: () => CHUNK_OVERLAP_CHARS,
-  CHUNK_WINDOW: () => CHUNK_WINDOW,
-  CHUNK_WINDOW_CHARS: () => CHUNK_WINDOW_CHARS,
-  DEFAULT_CHUNK_CONCURRENCY: () => DEFAULT_CHUNK_CONCURRENCY,
   DEFAULT_HOOKS: () => DEFAULT_HOOKS,
   DEFAULT_TIMEOUT_MS: () => DEFAULT_TIMEOUT_MS,
   FIREWALL_HOOK_TO_LABEL: () => FIREWALL_HOOK_TO_LABEL,
   Firewall: () => Firewall,
   FirewallBlockedException: () => FirewallBlockedException,
   FirewallHook: () => FirewallHook,
+  HARMFUL_OUTCOMES: () => HARMFUL_OUTCOMES,
   HookLabel: () => HookLabel,
   INPUT_HOOKS: () => INPUT_HOOKS,
-  MAX_INPUT_CHARS: () => MAX_INPUT_CHARS,
-  MAX_INPUT_TOKENS: () => MAX_INPUT_TOKENS,
+  OUTCOME_DESCRIPTIONS: () => OUTCOME_DESCRIPTIONS,
   OUTPUT_HOOKS: () => OUTPUT_HOOKS,
+  Outcome: () => Outcome,
+  PRIMARY_OUTCOMES: () => PRIMARY_OUTCOMES,
   PromptBlockedException: () => PromptBlockedException,
   SilmarilApiError: () => SilmarilApiError,
-  chunkText: () => chunkText,
+  isHarmfulOutcome: () => isHarmfulOutcome,
+  isPrimaryOutcome: () => isPrimaryOutcome,
+  normalizeHarmfulOutcome: () => normalizeHarmfulOutcome,
+  normalizeHarmfulOutcomeMap: () => normalizeHarmfulOutcomeMap,
+  normalizePrimaryOutcome: () => normalizePrimaryOutcome,
   prependHook: () => prependHook,
   prependToolName: () => prependToolName,
-  resolveHooks: () => resolveHooks,
-  sanitizeText: () => sanitizeText
+  resolveHooks: () => resolveHooks
 });
 module.exports = __toCommonJS(src_exports);
 
@@ -544,7 +549,7 @@ function createMiddleware(firewall, options = {}) {
       toolName !== void 0 ? { hook, toolName } : { hook }
     );
     const threshold = result.threshold;
-    const blocked = result.score >= threshold;
+    const blocked = result.prediction === "MALICIOUS";
     const commonEventFields = {
       hook,
       ...toolName !== void 0 ? { toolName } : {},
@@ -670,15 +675,80 @@ function createMiddleware(firewall, options = {}) {
   };
 }
 
-// src/chunking.ts
-var CHARS_PER_TOKEN = 4;
-var MAX_INPUT_TOKENS = 81920;
-var CHUNK_WINDOW = 400;
-var CHUNK_OVERLAP = 64;
-var MAX_INPUT_CHARS = MAX_INPUT_TOKENS * CHARS_PER_TOKEN;
-var CHUNK_WINDOW_CHARS = CHUNK_WINDOW * CHARS_PER_TOKEN;
-var CHUNK_OVERLAP_CHARS = CHUNK_OVERLAP * CHARS_PER_TOKEN;
-var CHUNK_STRIDE_CHARS = CHUNK_WINDOW_CHARS - CHUNK_OVERLAP_CHARS;
+// src/firewall.ts
+init_exceptions();
+
+// src/outcomes.ts
+var Outcome = {
+  Benign: "benign",
+  InformationDisclosure: "information_disclosure",
+  SecretExposure: "secret_exposure",
+  ControlAbuse: "control_abuse",
+  SystemCompromise: "system_compromise",
+  ServiceDisruption: "service_disruption"
+};
+var PRIMARY_OUTCOMES = [
+  Outcome.Benign,
+  Outcome.InformationDisclosure,
+  Outcome.SecretExposure,
+  Outcome.ControlAbuse,
+  Outcome.SystemCompromise,
+  Outcome.ServiceDisruption
+];
+var HARMFUL_OUTCOMES = [
+  Outcome.InformationDisclosure,
+  Outcome.SecretExposure,
+  Outcome.ControlAbuse,
+  Outcome.SystemCompromise,
+  Outcome.ServiceDisruption
+];
+var OUTCOME_DESCRIPTIONS = {
+  [Outcome.Benign]: "No harmful firewall outcome detected.",
+  [Outcome.InformationDisclosure]: "Exposes private data, documents, internal context, logs, traces, customer data, SQL rows, topology, or similar non-secret sensitive information.",
+  [Outcome.SecretExposure]: "Exposes credentials, tokens, API keys, cookies, passwords, signing keys, OAuth secrets, session material, or webhook secrets.",
+  [Outcome.ControlAbuse]: "Misuses authorized tools or user privileges to send, change, approve, delete, operate, or bypass policy/RBAC without a stronger outcome.",
+  [Outcome.SystemCompromise]: "Enables privilege escalation, account takeover, hostile integration or plugin takeover, persistence, lateral movement, attacker webhook registration, or code/plugin execution.",
+  [Outcome.ServiceDisruption]: "Causes downtime, lockout, degradation, alert suppression, destructive loops, resource exhaustion, cost spikes, or hidden outage evidence."
+};
+var PRIMARY_OUTCOME_SET = new Set(PRIMARY_OUTCOMES);
+var HARMFUL_OUTCOME_SET = new Set(HARMFUL_OUTCOMES);
+function isPrimaryOutcome(value) {
+  return typeof value === "string" && PRIMARY_OUTCOME_SET.has(value);
+}
+function isHarmfulOutcome(value) {
+  return typeof value === "string" && HARMFUL_OUTCOME_SET.has(value);
+}
+function normalizePrimaryOutcome(value, fieldName = "primary_outcome") {
+  if (typeof value !== "string") {
+    throw new Error(`Firewall: invalid ${fieldName} ${JSON.stringify(value)}`);
+  }
+  return isPrimaryOutcome(value) ? value : value;
+}
+function normalizeHarmfulOutcome(value, fieldName = "outcome") {
+  if (typeof value !== "string" || value === Outcome.Benign) {
+    throw new Error(`Firewall: invalid ${fieldName} ${JSON.stringify(value)}`);
+  }
+  return isHarmfulOutcome(value) ? value : value;
+}
+function normalizeHarmfulOutcomeMap(values, fieldName) {
+  if (values === void 0 || values === null) {
+    return void 0;
+  }
+  if (typeof values !== "object" || Array.isArray(values)) {
+    throw new Error(`Firewall: invalid ${fieldName} ${JSON.stringify(values)}`);
+  }
+  const out = {};
+  for (const [key, value] of Object.entries(values)) {
+    const normalizedKey = normalizeHarmfulOutcome(key, `${fieldName} key`);
+    if (typeof value !== "number") {
+      throw new Error(`Firewall: invalid ${fieldName} value for ${JSON.stringify(key)}`);
+    }
+    out[normalizedKey] = value;
+  }
+  return Object.freeze(out);
+}
+
+// src/sanitization.ts
 function isHighSurrogate(code) {
   return code >= 55296 && code <= 56319;
 }
@@ -697,82 +767,48 @@ function sanitizeText(text) {
       }
       continue;
     }
-    if (isLowSurrogate(code)) {
-      continue;
+    if (!isLowSurrogate(code)) {
+      out += text[i];
     }
-    out += text[i];
   }
   return out;
 }
-function safeChunkStart(text, start) {
-  if (start > 0 && start < text.length && isLowSurrogate(text.charCodeAt(start)) && isHighSurrogate(text.charCodeAt(start - 1))) {
-    return start + 1;
-  }
-  return start;
-}
-function safeChunkEnd(text, end) {
-  if (end > 0 && end < text.length && isHighSurrogate(text.charCodeAt(end - 1)) && isLowSurrogate(text.charCodeAt(end))) {
-    return end - 1;
-  }
-  return end;
-}
-function chunkText(text) {
-  text = sanitizeText(text);
-  const n = text.length;
-  if (n > MAX_INPUT_CHARS) {
-    throw new Error(
-      `Input has ~${Math.floor(n / CHARS_PER_TOKEN)} tokens (${n} chars); max is ${MAX_INPUT_TOKENS} tokens (${MAX_INPUT_CHARS} chars)`
-    );
-  }
-  if (n <= CHUNK_WINDOW_CHARS) {
-    return [text];
-  }
-  const chunks = [];
-  for (let start = 0; start < n; start += CHUNK_STRIDE_CHARS) {
-    const safeStart = safeChunkStart(text, start);
-    if (safeStart >= n) {
-      break;
-    }
-    const end = safeChunkEnd(text, safeStart + CHUNK_WINDOW_CHARS);
-    chunks.push(text.slice(safeStart, end));
-    if (end >= n) {
-      break;
-    }
-  }
-  return chunks;
-}
 
 // src/firewall.ts
-init_exceptions();
-var SDK_VERSION = "0.4.1";
+var SDK_VERSION = "0.5.0";
 var DEFAULT_TIMEOUT_MS = 1e4;
-var DEFAULT_CHUNK_CONCURRENCY = 8;
 var DEFAULT_MAX_RETRIES = 5;
 var MAX_BACKOFF_SECONDS = 30;
 var MAX_ERROR_BODY_BYTES = 1 << 16;
 function blockResultFromResponse(data) {
+  if (data.prediction !== "BENIGN" && data.prediction !== "MALICIOUS") {
+    throw new Error("Firewall: response prediction must be BENIGN or MALICIOUS");
+  }
   const result = {
     prediction: data.prediction,
     score: Number(data.score),
     threshold: Number(data.threshold)
   };
   if (data.primary_outcome !== void 0) {
-    result.primaryOutcome = data.primary_outcome;
+    result.primaryOutcome = normalizePrimaryOutcome(data.primary_outcome);
   }
   if (data.outcome_scores !== void 0) {
-    result.outcomeScores = Object.freeze(
-      Object.fromEntries(Object.entries(data.outcome_scores).map(([k, v]) => [k, Number(v)]))
-    );
+    const outcomeScores = normalizeHarmfulOutcomeMap(data.outcome_scores, "outcome_scores");
+    if (outcomeScores !== void 0) {
+      result.outcomeScores = outcomeScores;
+    }
   }
   if (data.detector_scores !== void 0) {
-    result.detectorScores = Object.freeze(
-      Object.fromEntries(Object.entries(data.detector_scores).map(([k, v]) => [k, Number(v)]))
-    );
+    const detectorScores = normalizeHarmfulOutcomeMap(data.detector_scores, "detector_scores");
+    if (detectorScores !== void 0) {
+      result.detectorScores = detectorScores;
+    }
   }
   if (data.detector_counts !== void 0) {
-    result.detectorCounts = Object.freeze(
-      Object.fromEntries(Object.entries(data.detector_counts).map(([k, v]) => [k, Number(v)]))
-    );
+    const detectorCounts = normalizeHarmfulOutcomeMap(data.detector_counts, "detector_counts");
+    if (detectorCounts !== void 0) {
+      result.detectorCounts = detectorCounts;
+    }
   }
   return Object.freeze(result);
 }
@@ -790,9 +826,7 @@ function withSdkMetadata(metadata, info) {
     sdk_language: "typescript",
     sdk_version: SDK_VERSION,
     request_id: info.requestId,
-    input_index: info.inputIndex,
-    chunk_index: info.chunkIndex,
-    chunk_count: info.chunkCount
+    ...info.inputIndex === void 0 ? {} : { input_index: info.inputIndex }
   };
   return payload;
 }
@@ -833,36 +867,10 @@ async function readCappedErrorBody(response) {
   }
   return new TextDecoder().decode(body);
 }
-async function mapWithConcurrency(items, concurrency, task) {
-  const results = new Array(items.length);
-  let nextIndex = 0;
-  let firstError;
-  const workerCount = Math.min(concurrency, items.length);
-  async function worker() {
-    for (; ; ) {
-      const index = nextIndex;
-      nextIndex += 1;
-      if (index >= items.length) {
-        return;
-      }
-      try {
-        results[index] = await task(items[index], index);
-      } catch (err) {
-        firstError ??= err;
-      }
-    }
-  }
-  await Promise.all(Array.from({ length: workerCount }, () => worker()));
-  if (firstError !== void 0) {
-    throw firstError;
-  }
-  return results;
-}
 var Firewall = class {
   apiKey;
   apiUrl;
   timeoutMs;
-  chunkConcurrency;
   shadowMode;
   headers;
   constructor(options) {
@@ -878,12 +886,6 @@ var Firewall = class {
     if (typeof this.timeoutMs !== "number" || !Number.isFinite(this.timeoutMs) || this.timeoutMs < 0) {
       throw new Error(`Firewall: timeoutMs must be a finite non-negative number, got ${this.timeoutMs}`);
     }
-    this.chunkConcurrency = options.chunkConcurrency ?? DEFAULT_CHUNK_CONCURRENCY;
-    if (!Number.isInteger(this.chunkConcurrency) || this.chunkConcurrency < 1) {
-      throw new Error(
-        `Firewall: chunkConcurrency must be an integer >= 1, got ${this.chunkConcurrency}`
-      );
-    }
     this.shadowMode = options.shadowMode ?? false;
     this.headers = Object.freeze({
       "x-api-key": this.apiKey,
@@ -891,27 +893,8 @@ var Firewall = class {
     });
   }
   async classify(text, options = {}) {
-    const chunks = chunkText(text);
     const requestId = options.requestId ?? (0, import_node_crypto.randomUUID)();
-    if (chunks.length === 1) {
-      return this.classifySingleChunk(chunks[0], options, {
-        requestId,
-        inputIndex: 0,
-        chunkIndex: 0,
-        chunkCount: 1
-      });
-    }
-    const results = await mapWithConcurrency(
-      chunks,
-      this.chunkConcurrency,
-      (chunk, index) => this.classifySingleChunk(chunk, options, {
-        requestId,
-        inputIndex: 0,
-        chunkIndex: index,
-        chunkCount: chunks.length
-      })
-    );
-    return results.reduce((best, r) => r.score > best.score ? r : best);
+    return this.classifySingle(sanitizeText(text), options, { requestId });
   }
   async classifyBatch(texts, options = {}) {
     if (texts.length === 0) {
@@ -945,9 +928,7 @@ var Firewall = class {
     payload.metadata = texts.map(
       (_, index) => withSdkMetadata(options.metadata?.[index], {
         requestId,
-        inputIndex: index,
-        chunkIndex: 0,
-        chunkCount: 1
+        inputIndex: index
       })
     );
     const data = await this.postWithRetry(payload);
@@ -986,7 +967,7 @@ var Firewall = class {
     }
     throw new Error("Firewall: exhausted retries (unreachable)");
   }
-  async classifySingleChunk(text, options, metadataInfo) {
+  async classifySingle(text, options, metadataInfo) {
     const payload = { text };
     if (options.hook !== void 0) {
       payload.hook = options.hook;
@@ -1006,28 +987,28 @@ init_hooks();
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ALL_HOOKS,
-  CHUNK_OVERLAP,
-  CHUNK_OVERLAP_CHARS,
-  CHUNK_WINDOW,
-  CHUNK_WINDOW_CHARS,
-  DEFAULT_CHUNK_CONCURRENCY,
   DEFAULT_HOOKS,
   DEFAULT_TIMEOUT_MS,
   FIREWALL_HOOK_TO_LABEL,
   Firewall,
   FirewallBlockedException,
   FirewallHook,
+  HARMFUL_OUTCOMES,
   HookLabel,
   INPUT_HOOKS,
-  MAX_INPUT_CHARS,
-  MAX_INPUT_TOKENS,
+  OUTCOME_DESCRIPTIONS,
   OUTPUT_HOOKS,
+  Outcome,
+  PRIMARY_OUTCOMES,
   PromptBlockedException,
   SilmarilApiError,
-  chunkText,
+  isHarmfulOutcome,
+  isPrimaryOutcome,
+  normalizeHarmfulOutcome,
+  normalizeHarmfulOutcomeMap,
+  normalizePrimaryOutcome,
   prependHook,
   prependToolName,
-  resolveHooks,
-  sanitizeText
+  resolveHooks
 });
 //# sourceMappingURL=index.cjs.map