@creedspace/sdk 1.0.0

package/dist/index.js

@@ -0,0 +1,146 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  CreedError: () => CreedError,
+  computeArgsHash: () => computeArgsHash,
+  createClient: () => createClient,
+  default: () => index_default,
+  isTokenExpired: () => isTokenExpired
+});
+module.exports = __toCommonJS(index_exports);
+var CreedError = class extends Error {
+  constructor(message, code, statusCode) {
+    super(message);
+    this.code = code;
+    this.statusCode = statusCode;
+    this.name = "CreedError";
+  }
+};
+function createClient(options) {
+  const {
+    apiKey,
+    baseUrl = "https://api.creed.space",
+    fetch: customFetch = fetch,
+    timeoutMs = 3e4
+  } = options;
+  if (!apiKey) {
+    throw new CreedError("API key is required", "MISSING_API_KEY");
+  }
+  async function request(endpoint, method, body) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+      const response = await customFetch(`${baseUrl}${endpoint}`, {
+        method,
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${apiKey}`,
+          "X-Creed-SDK": "typescript/1.0.0"
+        },
+        body: body ? JSON.stringify(body) : void 0,
+        signal: controller.signal
+      });
+      if (!response.ok) {
+        const errorBody = await response.text();
+        throw new CreedError(
+          errorBody || `Request failed with status ${response.status}`,
+          "REQUEST_FAILED",
+          response.status
+        );
+      }
+      return response.json();
+    } catch (error) {
+      if (error instanceof CreedError) throw error;
+      if (error.name === "AbortError") {
+        throw new CreedError("Request timed out", "TIMEOUT");
+      }
+      throw new CreedError(error.message, "NETWORK_ERROR");
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+  return {
+    async decide(req) {
+      const response = await request("/v1/decide", "POST", {
+        tool_name: req.toolName,
+        arguments: req.arguments,
+        constitution_id: req.constitutionId || "default",
+        context: req.context || {}
+      });
+      if (response.decision === "ALLOW" && req.onAllow) {
+        await req.onAllow(response);
+      } else if (response.decision === "DENY" && req.onDeny) {
+        await req.onDeny(response);
+      } else if (response.decision === "REQUIRE_HUMAN" && req.onRequireHuman) {
+        const humanDecision = {
+          ...response,
+          featureStatus: "planned"
+        };
+        await req.onRequireHuman(humanDecision);
+      }
+      return response;
+    },
+    async authorize(req) {
+      return request("/v1/authorize", "POST", {
+        decision_token: req.decisionToken,
+        tool_name: req.toolName,
+        args_hash: req.argsHash
+      });
+    },
+    async audit(req) {
+      return request("/v1/audit", "POST", {
+        run_id: req.runId,
+        action_id: req.actionId,
+        limit: req.limit || 50
+      });
+    },
+    async status() {
+      return request("/v1/status", "GET");
+    }
+  };
+}
+async function computeArgsHash(args) {
+  const canonical = JSON.stringify(args, Object.keys(args).sort());
+  const encoder = new TextEncoder();
+  const data = encoder.encode(canonical);
+  const hashBuffer = await crypto.subtle.digest("SHA-256", data);
+  const hashArray = Array.from(new Uint8Array(hashBuffer));
+  return "sha256:" + hashArray.map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+function isTokenExpired(token) {
+  try {
+    const parts = token.split(".");
+    if (parts.length !== 3) return true;
+    const payload = JSON.parse(atob(parts[1]));
+    return payload.exp * 1e3 < Date.now();
+  } catch {
+    return true;
+  }
+}
+var index_default = createClient;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CreedError,
+  computeArgsHash,
+  createClient,
+  isTokenExpired
+});

package/dist/index.mjs

@@ -0,0 +1,118 @@
+// src/index.ts
+var CreedError = class extends Error {
+  constructor(message, code, statusCode) {
+    super(message);
+    this.code = code;
+    this.statusCode = statusCode;
+    this.name = "CreedError";
+  }
+};
+function createClient(options) {
+  const {
+    apiKey,
+    baseUrl = "https://api.creed.space",
+    fetch: customFetch = fetch,
+    timeoutMs = 3e4
+  } = options;
+  if (!apiKey) {
+    throw new CreedError("API key is required", "MISSING_API_KEY");
+  }
+  async function request(endpoint, method, body) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+      const response = await customFetch(`${baseUrl}${endpoint}`, {
+        method,
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${apiKey}`,
+          "X-Creed-SDK": "typescript/1.0.0"
+        },
+        body: body ? JSON.stringify(body) : void 0,
+        signal: controller.signal
+      });
+      if (!response.ok) {
+        const errorBody = await response.text();
+        throw new CreedError(
+          errorBody || `Request failed with status ${response.status}`,
+          "REQUEST_FAILED",
+          response.status
+        );
+      }
+      return response.json();
+    } catch (error) {
+      if (error instanceof CreedError) throw error;
+      if (error.name === "AbortError") {
+        throw new CreedError("Request timed out", "TIMEOUT");
+      }
+      throw new CreedError(error.message, "NETWORK_ERROR");
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+  return {
+    async decide(req) {
+      const response = await request("/v1/decide", "POST", {
+        tool_name: req.toolName,
+        arguments: req.arguments,
+        constitution_id: req.constitutionId || "default",
+        context: req.context || {}
+      });
+      if (response.decision === "ALLOW" && req.onAllow) {
+        await req.onAllow(response);
+      } else if (response.decision === "DENY" && req.onDeny) {
+        await req.onDeny(response);
+      } else if (response.decision === "REQUIRE_HUMAN" && req.onRequireHuman) {
+        const humanDecision = {
+          ...response,
+          featureStatus: "planned"
+        };
+        await req.onRequireHuman(humanDecision);
+      }
+      return response;
+    },
+    async authorize(req) {
+      return request("/v1/authorize", "POST", {
+        decision_token: req.decisionToken,
+        tool_name: req.toolName,
+        args_hash: req.argsHash
+      });
+    },
+    async audit(req) {
+      return request("/v1/audit", "POST", {
+        run_id: req.runId,
+        action_id: req.actionId,
+        limit: req.limit || 50
+      });
+    },
+    async status() {
+      return request("/v1/status", "GET");
+    }
+  };
+}
+async function computeArgsHash(args) {
+  const canonical = JSON.stringify(args, Object.keys(args).sort());
+  const encoder = new TextEncoder();
+  const data = encoder.encode(canonical);
+  const hashBuffer = await crypto.subtle.digest("SHA-256", data);
+  const hashArray = Array.from(new Uint8Array(hashBuffer));
+  return "sha256:" + hashArray.map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+function isTokenExpired(token) {
+  try {
+    const parts = token.split(".");
+    if (parts.length !== 3) return true;
+    const payload = JSON.parse(atob(parts[1]));
+    return payload.exp * 1e3 < Date.now();
+  } catch {
+    return true;
+  }
+}
+var index_default = createClient;
+export {
+  CreedError,
+  computeArgsHash,
+  createClient,
+  index_default as default,
+  isTokenExpired
+};

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "@creedspace/sdk",
+  "version": "1.0.0",
+  "description": "Creed Space SDK - Governance infrastructure for AI agents",
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "src"
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts --format cjs,esm --dts",
+    "dev": "tsup src/index.ts --format cjs,esm --dts --watch",
+    "lint": "eslint src --ext .ts",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
+  "keywords": [
+    "creed",
+    "ai",
+    "agents",
+    "governance",
+    "safety",
+    "constitutional-ai",
+    "tool-calling"
+  ],
+  "author": "Creed Space <support@creed.space>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/creed-space/sdk-typescript"
+  },
+  "homepage": "https://creed.space/docs/sdk",
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "tsup": "^8.0.0",
+    "typescript": "^5.3.0",
+    "vitest": "^1.0.0",
+    "eslint": "^8.0.0",
+    "@typescript-eslint/eslint-plugin": "^6.0.0",
+    "@typescript-eslint/parser": "^6.0.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}