@zensorum/sdk 0.1.0 → 0.1.1

package/dist/index.d.ts

@@ -31,6 +31,19 @@ export interface AIInput<TRecommendation = unknown> {
     readonly source: string;
     readonly recommendation: TRecommendation;
 }
+export type PolicyConditionOperator = "eq" | "neq" | "lt" | "lte" | "gt" | "gte";
+export interface PolicyCondition {
+    readonly path: string;
+    readonly operator: PolicyConditionOperator;
+    readonly value: string | number | boolean | null;
+}
+export interface PolicySpecification {
+    readonly all?: readonly PolicyCondition[];
+    readonly executionPermitted?: boolean;
+    readonly requiredCondition?: string;
+    readonly internalCapacityRequired?: boolean;
+    readonly externalCapacityRequired?: boolean;
+}
 export interface Policy {
     readonly id: string;
     readonly name: string;

package/dist/index.js

@@ -15,6 +15,71 @@ function createExecutionId() {
         .toString(36)
         .slice(2, 10)}`;
 }
+function isRecord(value) {
+    return typeof value === "object" && value !== null;
+}
+function readContextValue(context, path) {
+    if (!path) {
+        return undefined;
+    }
+    const segments = path.split(".");
+    let current = context;
+    for (const segment of segments) {
+        if (!isRecord(current) || !Object.prototype.hasOwnProperty.call(current, segment)) {
+            return undefined;
+        }
+        current = current[segment];
+    }
+    return current;
+}
+function evaluateCondition(context, condition) {
+    const actual = readContextValue(context, condition.path);
+    if (actual === undefined) {
+        return false;
+    }
+    switch (condition.operator) {
+        case "eq":
+            return actual === condition.value;
+        case "neq":
+            return actual !== condition.value;
+        case "lt":
+            return (typeof actual === "number" &&
+                typeof condition.value === "number" &&
+                actual < condition.value);
+        case "lte":
+            return (typeof actual === "number" &&
+                typeof condition.value === "number" &&
+                actual <= condition.value);
+        case "gt":
+            return (typeof actual === "number" &&
+                typeof condition.value === "number" &&
+                actual > condition.value);
+        case "gte":
+            return (typeof actual === "number" &&
+                typeof condition.value === "number" &&
+                actual >= condition.value);
+        default:
+            return false;
+    }
+}
+function evaluateContextualConditions(context, policyId, conditions) {
+    for (const condition of conditions) {
+        if (!condition.path ||
+            !["eq", "neq", "lt", "lte", "gt", "gte"].includes(condition.operator)) {
+            return {
+                status: "blocked",
+                reason: `Invalid contextual governance condition in institutional policy '${policyId}'.`,
+            };
+        }
+        if (!evaluateCondition(context, condition)) {
+            return {
+                status: "blocked",
+                reason: `Institutional context does not satisfy policy '${policyId}' at '${condition.path}'.`,
+            };
+        }
+    }
+    return undefined;
+}
 function evaluateGovernance(request) {
     if (request.governance.policies.length === 0) {
         return {
@@ -30,61 +95,56 @@ function evaluateGovernance(request) {
     }
     for (const policy of request.governance.policies) {
         const specification = policy.specification;
-        if (typeof specification === "object" &&
-            specification !== null &&
-            "executionPermitted" in specification &&
-            specification
-                .executionPermitted === false) {
+        if (!isRecord(specification)) {
+            continue;
+        }
+        if ("executionPermitted" in specification &&
+            specification.executionPermitted === false) {
             return {
                 status: "blocked",
                 reason: `Execution is prohibited by institutional policy '${policy.id}'.`,
             };
         }
-        if (typeof specification === "object" &&
-            specification !== null &&
-            "requiredCondition" in specification) {
+        if ("all" in specification) {
+            const conditions = specification.all;
+            if (!Array.isArray(conditions)) {
+                return {
+                    status: "blocked",
+                    reason: `Invalid contextual governance specification in institutional policy '${policy.id}'.`,
+                };
+            }
+            const contextualDecision = evaluateContextualConditions(request.context, policy.id, conditions);
+            if (contextualDecision) {
+                return contextualDecision;
+            }
+        }
+        if ("requiredCondition" in specification) {
             const requiredCondition = specification.requiredCondition;
-            const context = request.context;
-            if (typeof context === "object" &&
-                context !== null &&
-                "operationalCondition" in context &&
-                requiredCondition !==
-                    context
-                        .operationalCondition) {
+            if (isRecord(request.context) &&
+                Object.prototype.hasOwnProperty.call(request.context, "operationalCondition") &&
+                requiredCondition !== request.context.operationalCondition) {
                 return {
                     status: "blocked",
                     reason: `Institutional context does not satisfy policy '${policy.id}'.`,
                 };
             }
         }
-        if (typeof specification === "object" &&
-            specification !== null &&
-            "internalCapacityRequired" in specification) {
-            const required = specification.internalCapacityRequired;
-            const context = request.context;
-            if (required === true &&
-                typeof context === "object" &&
-                context !== null &&
-                "internalResponseCapacity" in context &&
-                context
-                    .internalResponseCapacity !== "available") {
+        if ("internalCapacityRequired" in specification) {
+            if (specification.internalCapacityRequired === true &&
+                isRecord(request.context) &&
+                Object.prototype.hasOwnProperty.call(request.context, "internalResponseCapacity") &&
+                request.context.internalResponseCapacity !== "available") {
                 return {
                     status: "blocked",
                     reason: "Institutional context does not provide the required internal response capacity.",
                 };
             }
         }
-        if (typeof specification === "object" &&
-            specification !== null &&
-            "externalCapacityRequired" in specification) {
-            const required = specification.externalCapacityRequired;
-            const context = request.context;
-            if (required === true &&
-                typeof context === "object" &&
-                context !== null &&
-                "externalResponseCapacity" in context &&
-                context
-                    .externalResponseCapacity !== "available") {
+        if ("externalCapacityRequired" in specification) {
+            if (specification.externalCapacityRequired === true &&
+                isRecord(request.context) &&
+                Object.prototype.hasOwnProperty.call(request.context, "externalResponseCapacity") &&
+                request.context.externalResponseCapacity !== "available") {
                 return {
                     status: "blocked",
                     reason: "Institutional context does not provide the required external response capacity.",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zensorum/sdk",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Developer SDK for building governed institutional applications with Zensorum.",
   "license": "Apache-2.0",
   "repository": {
@@ -24,7 +24,8 @@
   },
   "scripts": {
     "build": "tsc",
-    "typecheck": "tsc --noEmit"
+    "typecheck": "tsc --noEmit",
+    "test": "pnpm build && node --test tests/index.test.js"
   },
   "devDependencies": {
     "typescript": "^5.0.0"