@felspar/sdk 0.0.0-stage → 0.1.0

package/dist/chunks/chunk-6EZBI7O6.js

@@ -0,0 +1,583 @@
+import {
+  createHostedFelsparClient
+} from "./chunk-C2VMKF3S.js";
+
+// src/draft-action-gate-outputs.ts
+var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+function parsedJson(text2) {
+  try {
+    return JSON.parse(text2);
+  } catch {
+    return null;
+  }
+}
+function replyOf(output) {
+  let value = output;
+  for (let depth = 0; depth < 5; depth += 1) {
+    if (typeof value === "string") {
+      value = parsedJson(value);
+    } else if (Array.isArray(value)) {
+      value = value.find((part) => isRecord(part) && part.type === "text");
+    } else if (!isRecord(value) || value.isError === true) {
+      return null;
+    } else if (typeof value.checkId === "string") {
+      return value;
+    } else if (isRecord(value.structuredContent)) {
+      value = value.structuredContent;
+    } else {
+      value = Array.isArray(value.content) ? value.content : value.text;
+    }
+  }
+  return null;
+}
+var text = (value) => typeof value === "string" ? value : null;
+function outputCheckFromResult(jobId, output) {
+  const reply = replyOf(output);
+  const receipt = isRecord(reply?.receipt) ? reply.receipt : null;
+  const decision = isRecord(reply?.decision) ? reply.decision : null;
+  const fields = {
+    checkId: text(reply?.checkId),
+    output: text(reply?.output),
+    decisionReceiptDigest: text(decision?.receiptDigest),
+    artifactDigest: text(receipt?.artifactDigest),
+    receiptDigest: text(receipt?.receiptDigest)
+  };
+  if (reply?.status !== "pass" || Object.values(fields).includes(null)) {
+    return null;
+  }
+  return {
+    checkId: fields.checkId ?? "",
+    jobId,
+    output: fields.output ?? "",
+    status: "pass",
+    decisionReceiptDigest: fields.decisionReceiptDigest ?? "",
+    artifactDigest: fields.artifactDigest ?? "",
+    receiptDigest: fields.receiptDigest ?? ""
+  };
+}
+async function outputTextDigest(value) {
+  const encoder = new TextEncoder();
+  const hash = new Uint8Array(await crypto.subtle.digest("SHA-256", encoder.encode(value)));
+  return `sha256:${Array.from(hash, (byte) => byte.toString(16).padStart(2, "0")).join("")}`;
+}
+function checkedText(rule, input) {
+  const wanted = new Set(rule.fields.map((field) => field.toLowerCase()));
+  const values = Object.entries(input).filter(([field]) => wanted.has(field.toLowerCase())).map(([, value]) => value);
+  const [only] = values;
+  return typeof only === "string" && values.length === 1 ? only : null;
+}
+async function outputCheckProblem(rule, call) {
+  const value = checkedText(rule, call.input);
+  if (value === null) {
+    return `the call must set exactly one text field of ${rule.fields.join(", ")}`;
+  }
+  const digest = await outputTextDigest(value);
+  let check;
+  for (const row of call.checks) {
+    const isOutput = rule.output === void 0 || row.output === rule.output;
+    const isText = row.artifactDigest === digest;
+    const isDecision = row.decisionReceiptDigest === call.decisionReceiptDigest;
+    const isPass = row.status === "pass";
+    if (isPass && isText && isDecision && isOutput) {
+      check = row;
+    }
+  }
+  if (check === void 0) {
+    return "Felspar has not passed this exact text for this decision; call check_output first";
+  }
+  if (call.verify === void 0) {
+    return "no output-check verifier is configured";
+  }
+  const confirmed = await call.verify(check);
+  const isConfirmed = confirmed?.status === "pass" && confirmed.receiptDigest === check.receiptDigest && confirmed.artifactDigest === check.artifactDigest && confirmed.decisionReceiptDigest === check.decisionReceiptDigest;
+  return isConfirmed ? null : "Felspar did not confirm the output check";
+}
+function felsparOutputCheckVerifier(configuration) {
+  let client;
+  return async (check) => {
+    client ??= createHostedFelsparClient(configuration);
+    const kept = await client.readOutputCheck(check.jobId, check.checkId);
+    return {
+      status: kept.status,
+      receiptDigest: kept.receipt?.receiptDigest ?? null,
+      artifactDigest: kept.receipt?.artifactDigest ?? null,
+      decisionReceiptDigest: kept.decision.receiptDigest
+    };
+  };
+}
+
+// src/draft-action-gate-decisions.ts
+var isRecord2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+function parsedJson2(text2) {
+  try {
+    return JSON.parse(text2);
+  } catch {
+    return null;
+  }
+}
+function innerValue(value) {
+  if (typeof value === "string") {
+    return parsedJson2(value);
+  }
+  if (Array.isArray(value)) {
+    return value.find((part) => isRecord2(part) && part.type === "text") ?? null;
+  }
+  if (!isRecord2(value)) {
+    return void 0;
+  }
+  if (value.isError === true) {
+    return null;
+  }
+  if (isRecord2(value.structuredContent)) {
+    return value.structuredContent;
+  }
+  if (Array.isArray(value.content)) {
+    return value.content;
+  }
+  return value.type === "text" && typeof value.text === "string" ? value.text : void 0;
+}
+function jobResponse(output) {
+  let value = output;
+  for (let depth = 0; depth < 5; depth += 1) {
+    const inner = innerValue(value);
+    if (inner === void 0) {
+      return isRecord2(value) && isRecord2(value.result) ? value : null;
+    }
+    value = inner;
+  }
+  return null;
+}
+function jobOf(input) {
+  return isRecord2(input) && typeof input.job === "string" ? input.job : void 0;
+}
+function entityIdOf(input) {
+  return isRecord2(input) && typeof input.entity_id === "string" ? input.entity_id : void 0;
+}
+function freshnessOf(explanation) {
+  return isRecord2(explanation) && typeof explanation.evidenceFreshUntil === "string" ? explanation.evidenceFreshUntil : null;
+}
+function decisionFromResult(entity, output) {
+  const result = jobResponse(output)?.result;
+  if (!isRecord2(result) || entity.length === 0) {
+    return null;
+  }
+  const { receipt } = result;
+  if (typeof result.outcome !== "string" || typeof result.executionObjectId !== "string" || !isRecord2(receipt) || typeof receipt.receiptDigest !== "string") {
+    return null;
+  }
+  return {
+    entity,
+    outcome: result.outcome,
+    executionObjectId: result.executionObjectId,
+    receipt: { ...receipt, receiptDigest: receipt.receiptDigest },
+    context: result.context ?? null,
+    evidenceFreshUntil: freshnessOf(result.explanation)
+  };
+}
+function trim(map, limit) {
+  for (const key of map.keys()) {
+    if (map.size <= limit) {
+      return;
+    }
+    map.delete(key);
+  }
+}
+function createDecisionRecorder(limits = {}) {
+  const maxSessions = limits.sessions ?? 1e3;
+  const maxDecisions = limits.decisionsPerSession ?? 200;
+  const maxPending = limits.pendingRequests ?? 1e3;
+  const requested = /* @__PURE__ */ new Map();
+  const decided = /* @__PURE__ */ new Map();
+  const checked = /* @__PURE__ */ new Map();
+  function record(sessionId, entity, output) {
+    const decision = decisionFromResult(entity, output);
+    if (decision === null) {
+      return null;
+    }
+    const rows = [...decided.get(sessionId) ?? [], decision].slice(-maxDecisions);
+    decided.delete(sessionId);
+    decided.set(sessionId, rows);
+    trim(decided, maxSessions);
+    return decision;
+  }
+  return {
+    record,
+    noteRequest(callId, entity) {
+      requested.set(callId, entity);
+      trim(requested, maxPending);
+    },
+    noteResult(sessionId, callId, output) {
+      const entity = requested.get(callId);
+      requested.delete(callId);
+      return entity === void 0 ? null : record(sessionId, entity, output);
+    },
+    decisionsIn: (sessionId) => decided.get(sessionId) ?? [],
+    recordOutputCheck(sessionId, jobId, output) {
+      const check = outputCheckFromResult(jobId, output);
+      if (check === null) {
+        return null;
+      }
+      const rows = [...checked.get(sessionId) ?? [], check].slice(-maxDecisions);
+      checked.delete(sessionId);
+      checked.set(sessionId, rows);
+      trim(checked, maxSessions);
+      return check;
+    },
+    outputChecksIn: (sessionId) => checked.get(sessionId) ?? [],
+    forget(sessionId) {
+      decided.delete(sessionId);
+      checked.delete(sessionId);
+    }
+  };
+}
+
+// src/draft-action-gate-domains.ts
+var publicSuffixes = [
+  "ac.uk",
+  "co.uk",
+  "gov.uk",
+  "ltd.uk",
+  "me.uk",
+  "net.uk",
+  "org.uk",
+  "plc.uk",
+  "sch.uk",
+  "com.au",
+  "edu.au",
+  "gov.au",
+  "net.au",
+  "org.au",
+  "co.nz",
+  "net.nz",
+  "org.nz",
+  "ac.jp",
+  "co.jp",
+  "ne.jp",
+  "or.jp",
+  "co.kr",
+  "or.kr",
+  "co.in",
+  "net.in",
+  "org.in",
+  "co.za",
+  "org.za",
+  "co.il",
+  "co.id",
+  "co.ke",
+  "co.th",
+  "com.ar",
+  "com.br",
+  "com.cn",
+  "com.co",
+  "com.eg",
+  "com.hk",
+  "com.mx",
+  "com.my",
+  "com.ng",
+  "com.ph",
+  "com.pk",
+  "com.sa",
+  "com.sg",
+  "com.tr",
+  "com.tw",
+  "com.ua",
+  "com.vn",
+  "net.cn",
+  "org.cn",
+  "gov.cn",
+  "edu.cn",
+  "appspot.com",
+  "azurewebsites.net",
+  "blogspot.com",
+  "cloudfront.net",
+  "firebaseapp.com",
+  "github.io",
+  "herokuapp.com",
+  "netlify.app",
+  "pages.dev",
+  "vercel.app",
+  "web.app",
+  "workers.dev"
+];
+var freeMail = [
+  "126.com",
+  "163.com",
+  "aol.com",
+  "fastmail.com",
+  "gmail.com",
+  "googlemail.com",
+  "gmx.com",
+  "gmx.de",
+  "gmx.net",
+  "hey.com",
+  "hotmail.co.uk",
+  "hotmail.com",
+  "icloud.com",
+  "live.com",
+  "mac.com",
+  "mail.com",
+  "mail.ru",
+  "me.com",
+  "msn.com",
+  "outlook.com",
+  "pm.me",
+  "proton.me",
+  "protonmail.com",
+  "qq.com",
+  "tuta.io",
+  "tutanota.com",
+  "web.de",
+  "yahoo.co.uk",
+  "yahoo.com",
+  "yandex.com",
+  "yandex.ru",
+  "ymail.com",
+  "zoho.com"
+];
+var sharedDomains = [...publicSuffixes, ...freeMail];
+var builtIn = new Set(sharedDomains);
+var domainShape = /^[a-z0-9-]+(?:\.[a-z0-9-]+)+$/u;
+function isCompanyDomain(entity, extraShared = []) {
+  return domainShape.test(entity) && !builtIn.has(entity) && extraShared.every((domain) => domain.toLowerCase() !== entity);
+}
+
+// src/draft-action-gate-verifier.ts
+function felsparVerifier(configuration) {
+  let client;
+  return async (decision) => {
+    client ??= createHostedFelsparClient(configuration);
+    const verification = await client.verifyReceipt(decision.executionObjectId, {
+      receipt: decision.receipt,
+      expectedReceiptDigest: decision.receipt.receiptDigest,
+      deliveredCapsule: decision.context ?? null
+    });
+    return verification.status === "reproduced" && verification.decided !== void 0 ? verification.decided : null;
+  };
+}
+
+// src/draft-action-gate.ts
+var emailRecipientFields = ["to", "cc", "bcc", "replyTo", "reply_to"];
+var emailSubjectFields = ["subject"];
+function gatedRule(rules, toolName) {
+  return Object.hasOwn(rules.tools, toolName) ? rules.tools[toolName] : void 0;
+}
+var isInput = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var sameField = (names) => {
+  const lower = new Set(names.map((name) => name.toLowerCase()));
+  return (field) => lower.has(field.toLowerCase());
+};
+function fieldProblem(rules, rule, input) {
+  const isAllowed = sameField(rule.fields);
+  const isRefused = sameField(rules.refuse ?? []);
+  const unknown = Object.keys(input).filter((field) => !isAllowed(field));
+  if (unknown.length > 0) {
+    return `the call sets ${unknown.join(", ")}, which this tool's rule doesn't allow`;
+  }
+  const refused = Object.keys(input).filter((field) => isRefused(field));
+  return refused.length > 0 ? `the call sets ${refused.join(", ")}` : null;
+}
+function fieldValues(input, names) {
+  const isWanted = sameField(names);
+  const values = [];
+  const unreadable = [];
+  for (const [field, value] of Object.entries(input)) {
+    if (!isWanted(field)) {
+      continue;
+    }
+    for (const item of [value].flat()) {
+      if (typeof item === "string") {
+        values.push(item.trim());
+      } else if (item !== void 0 && item !== null) {
+        unreadable.push(field);
+      }
+    }
+  }
+  return { values, unreadable };
+}
+var isAscii = (text2) => /^[!-~]+$/u.test(text2);
+var plainAddress = /^[a-z0-9._+-]+@([a-z0-9-]+(?:\.[a-z0-9-]+)+)$/u;
+var isUnder = (domain, entity) => domain === entity || domain.endsWith(`.${entity}`);
+function domainsIn(text2, entities) {
+  return entities.filter((entity) => {
+    const escaped = entity.replaceAll(".", String.raw`\.`);
+    const whole = new RegExp(`(?:^|[^a-z0-9.-])${escaped}(?:$|[^a-z0-9-])`, "u");
+    return whole.test(text2);
+  });
+}
+function testCompany(recipients, subject, scope) {
+  const listed = new Set((scope.rules.testRecipients ?? []).map((address) => address.trim().toLowerCase()));
+  const outside = recipients.filter((address) => !listed.has(address));
+  if (outside.length > 0) {
+    return { reason: `recipient not on the test list: ${outside.join(", ")}` };
+  }
+  const named = domainsIn(subject.toLowerCase(), scope.entities);
+  return named.length === 1 ? { company: named[0] } : { reason: `the subject names ${named.length} decided companies, not one` };
+}
+function recipientCompany(recipients, entities) {
+  const companies = /* @__PURE__ */ new Set();
+  for (const address of recipients) {
+    const domain = plainAddress.exec(address)?.[1] ?? "";
+    const owners = entities.filter((entity) => isUnder(domain, entity));
+    if (owners.length === 0) {
+      return { reason: `${address} is not at a company Felspar decided on` };
+    }
+    for (const owner of owners) {
+      companies.add(owner);
+    }
+  }
+  return companies.size === 1 ? { company: [...companies][0] } : { reason: "the recipients belong to more than one company" };
+}
+function companyFor(scope, input) {
+  const { rules, rule } = scope;
+  const recipientFields = rule.recipientFields ?? rules.recipientFields ?? emailRecipientFields;
+  const recipients = fieldValues(input, recipientFields);
+  if (recipients.unreadable.length > 0) {
+    return { reason: `${recipients.unreadable.join(", ")} holds a value that is not an address` };
+  }
+  if (recipients.values.length === 0) {
+    return { reason: "the call has no recipients" };
+  }
+  const malformed = recipients.values.find((address) => !isAscii(address) || !plainAddress.test(address.toLowerCase()));
+  if (malformed !== void 0) {
+    return { reason: `"${malformed}" is not one plain address` };
+  }
+  const addresses = recipients.values.map((address) => address.toLowerCase());
+  if (rules.testRecipients === void 0) {
+    return recipientCompany(addresses, scope.entities);
+  }
+  const subjectFields = rule.subjectFields ?? rules.subjectFields ?? emailSubjectFields;
+  const subject = fieldValues(input, subjectFields).values.join("\n");
+  return testCompany(addresses, subject, scope);
+}
+function replayProblem(rules, company, verified) {
+  if (verified.jobId !== rules.job) {
+    return `the receipt is for job ${verified.jobId}, not ${rules.job}`;
+  }
+  if (verified.entityId.toLowerCase() !== company) {
+    return `the receipt is for ${verified.entityId}, not ${company}`;
+  }
+  const { releases } = rules;
+  const isUnpinned = releases !== void 0 && !releases.includes(verified.releaseId ?? "");
+  return isUnpinned ? `the receipt is for release ${verified.releaseId ?? "(none)"}, which is not allowed` : null;
+}
+function staleness(decision, now) {
+  const until = decision.evidenceFreshUntil;
+  if (typeof until !== "string") {
+    return null;
+  }
+  return Date.parse(until) > now ? null : `the decision's evidence went stale at ${until}`;
+}
+async function verifiedFor(scope, found, request) {
+  const { rules, rule } = scope;
+  const { company, decision } = found;
+  const stale = staleness(decision, (request.now ?? Date.now)());
+  if (stale !== null) {
+    return { allow: false, reason: stale };
+  }
+  const verified = await request.verify(decision);
+  if (verified === null) {
+    return { allow: false, reason: `Felspar did not reproduce ${company}'s receipt` };
+  }
+  const problem = replayProblem(rules, company, verified);
+  if (problem !== null) {
+    return { allow: false, reason: problem };
+  }
+  if (verified.outcome === null || !rule.outcomes.includes(verified.outcome)) {
+    const decided = verified.outcome ?? "undecided";
+    return { allow: false, reason: `${verified.entityId} is ${decided}, which doesn't allow this` };
+  }
+  if (rule.outputCheck !== void 0) {
+    const checked = await outputCheckProblem(rule.outputCheck, {
+      input: found.input,
+      decisionReceiptDigest: decision.receipt.receiptDigest,
+      checks: request.outputChecks ?? [],
+      verify: request.verifyOutputCheck
+    });
+    if (checked !== null) {
+      return { allow: false, reason: checked };
+    }
+  }
+  return {
+    allow: true,
+    reason: `${company} is ${verified.outcome}; Felspar reproduced the receipt`,
+    decision: { ...decision, outcome: verified.outcome }
+  };
+}
+async function decide(request) {
+  const { rules, toolName, decisions } = request;
+  const rule = gatedRule(rules, toolName);
+  if (rule === void 0) {
+    return { allow: false, reason: "not a gated tool" };
+  }
+  const input = isInput(request.input) ? request.input : {};
+  const problem = fieldProblem(rules, rule, input);
+  if (problem !== null) {
+    return { allow: false, reason: problem };
+  }
+  const entities = [...new Set(decisions.map((row) => row.entity.toLowerCase()))].filter((entity) => isCompanyDomain(entity, rules.sharedDomains));
+  const scope = { rules, rule, entities };
+  const { company, reason } = companyFor(scope, input);
+  if (company === void 0) {
+    return { allow: false, reason: reason ?? "no company" };
+  }
+  const decision = decisions.filter((row) => row.entity.toLowerCase() === company).at(-1);
+  return decision === void 0 ? { allow: false, reason: `no decision for ${company}` } : await verifiedFor(scope, { company, decision, input }, request);
+}
+async function checkAction(request) {
+  try {
+    return await decide(request);
+  } catch (error) {
+    return { allow: false, reason: `gate error: ${String(error)}` };
+  }
+}
+function report(onVerdict, toolName, verdict) {
+  if (onVerdict === void 0) {
+    return;
+  }
+  try {
+    onVerdict(toolName, verdict);
+  } catch {
+  }
+}
+function createActionGate(config) {
+  const { verify, decisions = createDecisionRecorder(), decisionTool, outputCheckTool, verifyOutputCheck, now, onVerdict, ...rules } = config;
+  return {
+    rules,
+    decisions,
+    isGated: (toolName) => gatedRule(rules, toolName) !== void 0,
+    isDecisionTool: (toolName) => toolName === decisionTool,
+    isOutputCheckTool: (toolName) => outputCheckTool !== void 0 && toolName === outputCheckTool,
+    async check(sessionId, toolName, input) {
+      const verdict = await checkAction({
+        rules,
+        toolName,
+        input,
+        decisions: decisions.decisionsIn(sessionId),
+        verify,
+        outputChecks: decisions.outputChecksIn(sessionId),
+        ...verifyOutputCheck !== void 0 && { verifyOutputCheck },
+        ...now !== void 0 && { now }
+      });
+      report(onVerdict, toolName, verdict);
+      return verdict;
+    }
+  };
+}
+
+export {
+  outputCheckFromResult,
+  outputTextDigest,
+  felsparOutputCheckVerifier,
+  jobOf,
+  entityIdOf,
+  decisionFromResult,
+  createDecisionRecorder,
+  sharedDomains,
+  isCompanyDomain,
+  felsparVerifier,
+  emailRecipientFields,
+  emailSubjectFields,
+  gatedRule,
+  checkAction,
+  createActionGate
+};