axiomax-esg-sdk-client 1.0.0

package/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2026 AXIOMAX LLC, Salinas Puerto Rico
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+NOTE: The reference verifier code in this repository is MIT-licensed.
+The AXIOMAX ESG Carbon Shield system architecture, calibration coefficients,
+and brand are proprietary to AXIOMAX LLC and protected by USPTO Patent Pending
+Application 64/081,419 (filed June 3, 2026).
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.

package/README.md

@@ -0,0 +1,106 @@
+# axiomax-esg-sdk
+
+Official client SDK for [AXIOMAX ESG Carbon Shield](https://axiomaxllc.com). Cryptographically attest your AI inference workload carbon footprint with one line of code.
+
+> Patent Pending USPTO Application **64/081,419** (filed June 3, 2026).
+> Operated by **AXIOMAX LLC**, Salinas, Puerto Rico.
+
+## Install
+
+```bash
+pip install axiomax-esg-sdk
+```
+
+## Quick start with OpenAI
+
+```python
+from axiomax_esg_sdk import AxiomaxClient, wrap_openai
+import openai
+
+axe = AxiomaxClient(license_key="axe_lic_2026_acme_...")
+
+# One-line wrap — every chat completion now cryptographically attested
+client = wrap_openai(openai.OpenAI(api_key="..."), axe)
+
+# Use OpenAI normally
+response = client.chat.completions.create(
+    model="gpt-4",
+    messages=[{"role": "user", "content": "hello"}],
+)
+
+# Periodically issue a signed token from accumulated records
+token = axe.issue_token()
+print(token["signature_ed25519"])
+```
+
+## Quick start with Anthropic Claude
+
+```python
+from axiomax_esg_sdk import AxiomaxClient, wrap_anthropic
+import anthropic
+
+axe = AxiomaxClient(license_key="axe_lic_...")
+client = wrap_anthropic(anthropic.Anthropic(api_key="..."), axe)
+
+response = client.messages.create(
+    model="claude-3-5-sonnet-20241022",
+    max_tokens=1024,
+    messages=[{"role": "user", "content": "hello"}],
+)
+```
+
+## Quick start with AWS Bedrock
+
+```python
+import boto3
+from axiomax_esg_sdk import AxiomaxClient, wrap_bedrock
+
+axe = AxiomaxClient(license_key="axe_lic_...")
+bedrock = wrap_bedrock(boto3.client("bedrock-runtime"), axe)
+
+# every invoke_model is now attested (duration only — parse body for token counts)
+response = bedrock.invoke_model(modelId="anthropic.claude-3-sonnet-20240229-v1:0", body=...)
+```
+
+## Manual recording (any provider)
+
+```python
+from axiomax_esg_sdk import AxiomaxClient
+
+axe = AxiomaxClient(license_key="axe_lic_...", soc_profile="apple_m4_pro", region="us_east")
+
+# After your inference completes, record metrics:
+axe.record_inference(
+    model_id="gpt-4",
+    tokens_in=120,
+    tokens_out=340,
+    duration_ms=1800,
+)
+
+# Sign accumulated batch
+token = axe.issue_token()
+```
+
+## Auto-batching every N seconds
+
+```python
+axe = AxiomaxClient(
+    license_key="axe_lic_...",
+    batch_interval_sec=3600,  # auto-issue token every hour
+)
+```
+
+## Verification
+
+Every issued token is verifiable by any third party at https://verify.axiomaxllc.com or using our open-source verifier `pip install axiomax-esg-verify`.
+
+## License
+
+MIT for this SDK. The AXIOMAX ESG Carbon Shield system architecture, calibration coefficients, and brand are proprietary to AXIOMAX LLC (Patent Pending USPTO 64/081,419).
+
+## Links
+
+- Main: https://axiomaxllc.com
+- Public verifier: https://verify.axiomaxllc.com
+- Pricing: https://axiomaxllc.com/pricing.html
+- Open-source verifier spec: https://github.com/axiomaxllc/esg-carbon-shield

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "axiomax-esg-sdk-client",
+  "version": "1.0.0",
+  "description": "Official Node.js SDK for AXIOMAX ESG Carbon Shield. Cryptographically attest your AI inference workload carbon footprint with one line of code. Patent Pending USPTO 64/081,419.",
+  "main": "src/index.js",
+  "type": "module",
+  "exports": {
+    ".": "./src/index.js"
+  },
+  "scripts": {
+    "test": "node test/smoke.test.js"
+  },
+  "keywords": [
+    "esg",
+    "climate-tech",
+    "carbon-accounting",
+    "cryptography",
+    "ai",
+    "openai",
+    "anthropic",
+    "bedrock",
+    "sustainability",
+    "csrd",
+    "axiomax"
+  ],
+  "author": "Charles Santana <charles@axiomaxllc.com> (https://axiomaxllc.com)",
+  "license": "MIT",
+  "homepage": "https://github.com/axiomaxllc/esg-carbon-shield",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/axiomaxllc/esg-carbon-shield.git"
+  },
+  "bugs": {
+    "url": "https://github.com/axiomaxllc/esg-carbon-shield/issues"
+  },
+  "files": [
+    "src/",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}

package/src/index.js

@@ -0,0 +1,206 @@
+/**
+ * AXIOMAX ESG Carbon Shield — Official Node.js SDK.
+ *
+ * Cryptographically attest your AI inference workload carbon footprint with one line of code.
+ *
+ * Patent Pending USPTO 64/081,419. AXIOMAX LLC, Salinas Puerto Rico. MIT License.
+ */
+
+const DEFAULT_API_BASE = "https://calc.axiomaxllc.com/v1";
+
+export class AxiomaxClient {
+  /**
+   * @param {object} opts
+   * @param {string} opts.licenseKey - AXIOMAX license key (axe_lic_*)
+   * @param {string} [opts.apiBase] - API base URL (default production)
+   * @param {string} [opts.socProfile] - Hardware profile (default "default")
+   * @param {string} [opts.region] - Cloud region equivalent (default "default")
+   * @param {string} [opts.clientId] - Override (auto from license)
+   * @param {number} [opts.batchIntervalSec] - Auto-issue token every N seconds
+   */
+  constructor({
+    licenseKey,
+    apiBase = DEFAULT_API_BASE,
+    socProfile = "default",
+    region = "default",
+    clientId = null,
+    batchIntervalSec = 0,
+  }) {
+    if (!licenseKey || !licenseKey.startsWith("axe_lic_")) {
+      throw new Error("invalid licenseKey format (must start with 'axe_lic_')");
+    }
+    this.licenseKey = licenseKey;
+    this.apiBase = apiBase.replace(/\/$/, "");
+    this.socProfile = socProfile;
+    this.region = region;
+    this.clientId = clientId || this._deriveClientIdFromLicense(licenseKey);
+    this.batchIntervalSec = batchIntervalSec;
+
+    this._seq = 0;
+    this._prevHash = "0".repeat(64);
+    this._records = [];
+    this._lastBatchAt = Date.now() / 1000;
+  }
+
+  _deriveClientIdFromLicense(key) {
+    const parts = key.split("_");
+    return parts.length >= 4 ? parts[3] : "unknown";
+  }
+
+  /**
+   * Report a single inference. Server applies trade-secret calibration
+   * and returns SHA-256 hash + sequence number.
+   */
+  async recordInference({ modelId, tokensIn, tokensOut, durationMs }) {
+    this._seq += 1;
+    const payload = {
+      client_id: this.clientId,
+      api_key: this.licenseKey,
+      soc_profile: this.socProfile,
+      region: this.region,
+      model_id: modelId,
+      tokens_in: parseInt(tokensIn),
+      tokens_out: parseInt(tokensOut),
+      duration_ms: parseInt(durationMs),
+      inference_seq: this._seq,
+      prev_hash: this._prevHash,
+    };
+    const r = await fetch(`${this.apiBase}/inference/record`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(payload),
+    });
+    if (!r.ok) throw new Error(`record_inference failed: ${r.status} ${await r.text()}`);
+    const result = await r.json();
+    this._prevHash = result.hash || this._prevHash;
+    this._records.push({
+      seq: result.seq || this._seq,
+      hash: this._prevHash,
+      tokens_in: tokensIn,
+      tokens_out: tokensOut,
+      duration_ms: durationMs,
+      model_id: modelId,
+    });
+
+    if (this.batchIntervalSec > 0) {
+      if (Date.now() / 1000 - this._lastBatchAt >= this.batchIntervalSec) {
+        await this.issueToken();
+      }
+    }
+    return result;
+  }
+
+  /**
+   * Sign accumulated records into a verifiable ed25519 token. Returns the
+   * signed token, or null if no records pending.
+   */
+  async issueToken() {
+    if (this._records.length === 0) return null;
+    const payload = {
+      client_id: this.clientId,
+      api_key: this.licenseKey,
+      records: this._records,
+    };
+    const r = await fetch(`${this.apiBase}/token/issue`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(payload),
+    });
+    if (!r.ok) throw new Error(`issue_token failed: ${r.status} ${await r.text()}`);
+    const token = await r.json();
+    this._records = [];
+    this._lastBatchAt = Date.now() / 1000;
+    return token;
+  }
+
+  status() {
+    return {
+      clientId: this.clientId,
+      seq: this._seq,
+      pendingRecords: this._records.length,
+      prevHash: this._prevHash,
+      apiBase: this.apiBase,
+    };
+  }
+}
+
+/**
+ * Wrap an OpenAI client so every chat completion is auto-attested.
+ *
+ * @example
+ * import OpenAI from 'openai';
+ * import { AxiomaxClient, wrapOpenAI } from '@axiomax/esg-sdk';
+ *
+ * const axe = new AxiomaxClient({ licenseKey: 'axe_lic_...' });
+ * const client = wrapOpenAI(new OpenAI({apiKey: '...'}), axe);
+ * const response = await client.chat.completions.create({model: 'gpt-4', messages: [...]});
+ */
+export function wrapOpenAI(openaiClient, axe) {
+  const origCreate = openaiClient.chat.completions.create.bind(openaiClient.chat.completions);
+  openaiClient.chat.completions.create = async (...args) => {
+    const t0 = Date.now();
+    const resp = await origCreate(...args);
+    const durationMs = Date.now() - t0;
+    try {
+      const u = resp.usage || {};
+      await axe.recordInference({
+        modelId: resp.model || args[0]?.model || "unknown",
+        tokensIn: u.prompt_tokens || 0,
+        tokensOut: u.completion_tokens || 0,
+        durationMs,
+      });
+    } catch (e) {
+      // never break user pipeline
+    }
+    return resp;
+  };
+  return openaiClient;
+}
+
+/**
+ * Wrap an Anthropic client so every messages.create is auto-attested.
+ */
+export function wrapAnthropic(anthropicClient, axe) {
+  const origCreate = anthropicClient.messages.create.bind(anthropicClient.messages);
+  anthropicClient.messages.create = async (...args) => {
+    const t0 = Date.now();
+    const resp = await origCreate(...args);
+    const durationMs = Date.now() - t0;
+    try {
+      const u = resp.usage || {};
+      await axe.recordInference({
+        modelId: resp.model || args[0]?.model || "unknown",
+        tokensIn: u.input_tokens || 0,
+        tokensOut: u.output_tokens || 0,
+        durationMs,
+      });
+    } catch (e) {}
+    return resp;
+  };
+  return anthropicClient;
+}
+
+/**
+ * Wrap an AWS Bedrock runtime so every invokeModel is auto-attested (duration only).
+ */
+export function wrapBedrock(bedrockClient, axe) {
+  const orig = bedrockClient.invokeModel ? bedrockClient.invokeModel.bind(bedrockClient) : null;
+  if (!orig) throw new Error("bedrockClient.invokeModel not found");
+  bedrockClient.invokeModel = async (...args) => {
+    const t0 = Date.now();
+    const resp = await orig(...args);
+    const durationMs = Date.now() - t0;
+    try {
+      await axe.recordInference({
+        modelId: args[0]?.modelId || "unknown",
+        tokensIn: 0,
+        tokensOut: 0,
+        durationMs,
+      });
+    } catch (e) {}
+    return resp;
+  };
+  return bedrockClient;
+}
+
+export default { AxiomaxClient, wrapOpenAI, wrapAnthropic, wrapBedrock };