@proofai/sdk 1.0.0

package/README.md

@@ -0,0 +1,94 @@
+# proofai-sdk
+
+Cryptographic proof that AI thought before it answered.
+
+## Install
+
+```bash
+npm install proofai-sdk
+```
+
+## Quick Start — One Line Certification
+
+```typescript
+import { ProofAI } from 'proofai-sdk'
+
+const proofai = new ProofAI({ apiKey: 'your-api-key' })
+
+const cert = await proofai.certify(
+  'Analyse les risques juridiques de ce contrat SaaS',
+  { provider: 'anthropic' }
+)
+
+console.log(cert.verified)        // true
+console.log(cert.bundleId)        // bnd_8019b37a7f44_...
+console.log(cert.bundleHash)      // sha256 hash
+console.log(cert.explorerUrl)     // https://amoy.polygonscan.com/tx/0x...
+```
+
+## Step by Step
+
+```typescript
+const proofai = new ProofAI({ apiKey: 'your-api-key' })
+
+// 1. Compress prompt
+const compressed = await proofai.compress('Your prompt here', {
+  compressionLevel: 'medium',
+})
+
+// 2. Execute AI
+const execution = await proofai.execute(compressed.id, {
+  provider: 'anthropic',  // 'anthropic' | 'openai' | 'gemini'
+  temperature: 0.7,
+  maxTokens: 1024,
+})
+
+// 3. Cognitive analysis
+const analysis = await proofai.analyze(execution.id, execution.output)
+
+// 4. Sign with Ed25519
+const signature = await proofai.sign(execution)
+
+// 5. Create evidence bundle
+const bundle = await proofai.bundle(
+  compressed.id,
+  execution.id,
+  analysis.id,
+  signature.signatureId,
+  analysis.cognitiveHash,
+)
+
+// 6. Anchor to Polygon
+const anchor = await proofai.anchor(bundle.id, 'polygon')
+
+// 7. Verify
+const verification = await proofai.verify(bundle.id)
+console.log(verification.verified) // true
+```
+
+## Options
+
+### `certify(prompt, options?)`
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `provider` | `'anthropic' \| 'openai' \| 'gemini'` | `'anthropic'` | AI provider |
+| `modelId` | `string` | auto | Model override |
+| `temperature` | `number` | `0.7` | Generation temperature |
+| `maxTokens` | `number` | `1024` | Max output tokens |
+| `compressionLevel` | `'low' \| 'medium' \| 'high'` | `'medium'` | DSL compression level |
+| `network` | `'polygon' \| 'ethereum'` | `'polygon'` | Blockchain network |
+| `skipAnchor` | `boolean` | `false` | Skip blockchain anchoring |
+
+## Self-Hosted
+
+```typescript
+const proofai = new ProofAI({
+  apiKey: 'your-supabase-anon-key',
+  baseUrl: 'https://your-project.supabase.co/functions/v1',
+})
+```
+
+## License
+
+MIT

package/dist/index.d.mts

@@ -0,0 +1,177 @@
+interface ProofAIConfig {
+    apiKey: string;
+    baseUrl?: string;
+}
+type Provider = 'anthropic' | 'openai' | 'gemini' | 'google';
+type CompressionLevel = 'low' | 'medium' | 'high';
+type Network = 'polygon' | 'ethereum';
+interface CompressOptions {
+    compressionLevel?: CompressionLevel;
+    preserveContext?: boolean;
+    targetModels?: string[];
+}
+interface CompressResult {
+    id: string;
+    originalPrompt: string;
+    compressedDsl: string;
+    metrics: {
+        originalTokens: number;
+        compressedTokens: number;
+        compressionRatio: number;
+        semanticLoss: number;
+    };
+    timestamp: string;
+}
+interface ExecuteOptions {
+    provider: Provider;
+    modelId?: string;
+    temperature?: number;
+    maxTokens?: number;
+}
+interface ExecuteResult {
+    id: string;
+    promptRef: string;
+    output: string;
+    metadata: {
+        provider: string;
+        model: string;
+        latency: number;
+        tokens: {
+            prompt: number;
+            completion: number;
+            total: number;
+        };
+    };
+    reasoning_trace?: Array<{
+        step_index: number;
+        type: string;
+        content: string;
+        thought_signature?: string;
+    }>;
+    trace_quality?: 'native' | 'structured' | 'inferred';
+    timestamp: string;
+}
+interface AnalyzeResult {
+    id: string;
+    executionId: string;
+    nodes: Array<{
+        id: string;
+        label: string;
+        type: string;
+        weight: number;
+    }>;
+    edges: Array<{
+        source: string;
+        target: string;
+        label: string;
+        weight: number;
+    }>;
+    metrics: {
+        nodeCount: number;
+        edgeCount: number;
+        consistencyScore: number;
+        complexityScore: number;
+    };
+    cognitiveHash: string;
+    timestamp: string;
+}
+interface SignResult {
+    signatureId: string;
+    signedPayload: Record<string, unknown>;
+    signature: {
+        algorithm: string;
+        signature: string;
+        signed_at: string;
+        signer_identity: string;
+        includes_thought_signatures: boolean;
+    };
+    timestampProof: {
+        rfc3161_timestamp: string;
+        verified: boolean;
+    } | null;
+    cognitive_trace?: Record<string, unknown>;
+}
+interface BundleResult {
+    id: string;
+    promptId: string;
+    executionId: string;
+    analysisId: string;
+    signatureId: string;
+    cognitiveHash: string;
+    bundleHash: string;
+    timeline: Array<{
+        event: string;
+        timestamp: string;
+        hash: string;
+    }>;
+    status: 'pending' | 'created' | 'anchored' | 'verified';
+    createdAt: string;
+}
+interface AnchorResult {
+    bundleId: string;
+    transactionHash: string;
+    blockNumber: number;
+    network: string;
+    explorerUrl: string;
+    status: 'pending' | 'confirmed' | 'failed';
+    timestamp: string;
+}
+interface VerifyResult {
+    bundleId: string;
+    verified: boolean;
+    checks: {
+        integrityValid: boolean;
+        timestampValid: boolean;
+        ledgerAnchored: boolean;
+        hashMatches: boolean;
+    };
+    ledgerInfo?: {
+        transactionHash: string;
+        blockNumber: number;
+        network: string;
+        confirmedAt: string;
+    };
+    timestamp: string;
+}
+interface CertifyOptions {
+    provider?: Provider;
+    modelId?: string;
+    temperature?: number;
+    maxTokens?: number;
+    compressionLevel?: CompressionLevel;
+    network?: Network;
+    skipAnchor?: boolean;
+}
+interface Certificate {
+    bundleId: string;
+    bundleHash: string;
+    verified: boolean;
+    explorerUrl?: string;
+    transactionHash?: string;
+    steps: {
+        compress: CompressResult;
+        execute: ExecuteResult;
+        analyze: AnalyzeResult;
+        sign: SignResult;
+        bundle: BundleResult;
+        anchor?: AnchorResult;
+        verify: VerifyResult;
+    };
+}
+
+declare class ProofAI {
+    private apiKey;
+    private baseUrl;
+    constructor(config: ProofAIConfig);
+    private call;
+    compress(prompt: string, options?: CompressOptions): Promise<CompressResult>;
+    execute(promptRef: string, options: ExecuteOptions): Promise<ExecuteResult>;
+    analyze(executionId: string, analysisText: string): Promise<AnalyzeResult>;
+    sign(execution: ExecuteResult): Promise<SignResult>;
+    bundle(promptId: string, executionId: string, analysisId: string, signatureId: string, cognitiveHash: string): Promise<BundleResult>;
+    anchor(bundleId: string, network?: 'polygon' | 'ethereum'): Promise<AnchorResult>;
+    verify(bundleId: string): Promise<VerifyResult>;
+    certify(prompt: string, options?: CertifyOptions): Promise<Certificate>;
+}
+
+export { type AnalyzeResult, type AnchorResult, type BundleResult, type Certificate, type CertifyOptions, type CompressOptions, type CompressResult, type CompressionLevel, type ExecuteOptions, type ExecuteResult, type Network, ProofAI, type ProofAIConfig, type Provider, type SignResult, type VerifyResult, ProofAI as default };

package/dist/index.d.ts

@@ -0,0 +1,177 @@
+interface ProofAIConfig {
+    apiKey: string;
+    baseUrl?: string;
+}
+type Provider = 'anthropic' | 'openai' | 'gemini' | 'google';
+type CompressionLevel = 'low' | 'medium' | 'high';
+type Network = 'polygon' | 'ethereum';
+interface CompressOptions {
+    compressionLevel?: CompressionLevel;
+    preserveContext?: boolean;
+    targetModels?: string[];
+}
+interface CompressResult {
+    id: string;
+    originalPrompt: string;
+    compressedDsl: string;
+    metrics: {
+        originalTokens: number;
+        compressedTokens: number;
+        compressionRatio: number;
+        semanticLoss: number;
+    };
+    timestamp: string;
+}
+interface ExecuteOptions {
+    provider: Provider;
+    modelId?: string;
+    temperature?: number;
+    maxTokens?: number;
+}
+interface ExecuteResult {
+    id: string;
+    promptRef: string;
+    output: string;
+    metadata: {
+        provider: string;
+        model: string;
+        latency: number;
+        tokens: {
+            prompt: number;
+            completion: number;
+            total: number;
+        };
+    };
+    reasoning_trace?: Array<{
+        step_index: number;
+        type: string;
+        content: string;
+        thought_signature?: string;
+    }>;
+    trace_quality?: 'native' | 'structured' | 'inferred';
+    timestamp: string;
+}
+interface AnalyzeResult {
+    id: string;
+    executionId: string;
+    nodes: Array<{
+        id: string;
+        label: string;
+        type: string;
+        weight: number;
+    }>;
+    edges: Array<{
+        source: string;
+        target: string;
+        label: string;
+        weight: number;
+    }>;
+    metrics: {
+        nodeCount: number;
+        edgeCount: number;
+        consistencyScore: number;
+        complexityScore: number;
+    };
+    cognitiveHash: string;
+    timestamp: string;
+}
+interface SignResult {
+    signatureId: string;
+    signedPayload: Record<string, unknown>;
+    signature: {
+        algorithm: string;
+        signature: string;
+        signed_at: string;
+        signer_identity: string;
+        includes_thought_signatures: boolean;
+    };
+    timestampProof: {
+        rfc3161_timestamp: string;
+        verified: boolean;
+    } | null;
+    cognitive_trace?: Record<string, unknown>;
+}
+interface BundleResult {
+    id: string;
+    promptId: string;
+    executionId: string;
+    analysisId: string;
+    signatureId: string;
+    cognitiveHash: string;
+    bundleHash: string;
+    timeline: Array<{
+        event: string;
+        timestamp: string;
+        hash: string;
+    }>;
+    status: 'pending' | 'created' | 'anchored' | 'verified';
+    createdAt: string;
+}
+interface AnchorResult {
+    bundleId: string;
+    transactionHash: string;
+    blockNumber: number;
+    network: string;
+    explorerUrl: string;
+    status: 'pending' | 'confirmed' | 'failed';
+    timestamp: string;
+}
+interface VerifyResult {
+    bundleId: string;
+    verified: boolean;
+    checks: {
+        integrityValid: boolean;
+        timestampValid: boolean;
+        ledgerAnchored: boolean;
+        hashMatches: boolean;
+    };
+    ledgerInfo?: {
+        transactionHash: string;
+        blockNumber: number;
+        network: string;
+        confirmedAt: string;
+    };
+    timestamp: string;
+}
+interface CertifyOptions {
+    provider?: Provider;
+    modelId?: string;
+    temperature?: number;
+    maxTokens?: number;
+    compressionLevel?: CompressionLevel;
+    network?: Network;
+    skipAnchor?: boolean;
+}
+interface Certificate {
+    bundleId: string;
+    bundleHash: string;
+    verified: boolean;
+    explorerUrl?: string;
+    transactionHash?: string;
+    steps: {
+        compress: CompressResult;
+        execute: ExecuteResult;
+        analyze: AnalyzeResult;
+        sign: SignResult;
+        bundle: BundleResult;
+        anchor?: AnchorResult;
+        verify: VerifyResult;
+    };
+}
+
+declare class ProofAI {
+    private apiKey;
+    private baseUrl;
+    constructor(config: ProofAIConfig);
+    private call;
+    compress(prompt: string, options?: CompressOptions): Promise<CompressResult>;
+    execute(promptRef: string, options: ExecuteOptions): Promise<ExecuteResult>;
+    analyze(executionId: string, analysisText: string): Promise<AnalyzeResult>;
+    sign(execution: ExecuteResult): Promise<SignResult>;
+    bundle(promptId: string, executionId: string, analysisId: string, signatureId: string, cognitiveHash: string): Promise<BundleResult>;
+    anchor(bundleId: string, network?: 'polygon' | 'ethereum'): Promise<AnchorResult>;
+    verify(bundleId: string): Promise<VerifyResult>;
+    certify(prompt: string, options?: CertifyOptions): Promise<Certificate>;
+}
+
+export { type AnalyzeResult, type AnchorResult, type BundleResult, type Certificate, type CertifyOptions, type CompressOptions, type CompressResult, type CompressionLevel, type ExecuteOptions, type ExecuteResult, type Network, ProofAI, type ProofAIConfig, type Provider, type SignResult, type VerifyResult, ProofAI as default };

package/dist/index.js

@@ -0,0 +1,147 @@
+"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, {
+  ProofAI: () => ProofAI,
+  default: () => index_default
+});
+module.exports = __toCommonJS(index_exports);
+var DEFAULT_BASE_URL = "https://apzgbajvwzykygrxxrwm.supabase.co/functions/v1";
+var ProofAI = class {
+  constructor(config) {
+    if (!config.apiKey) throw new Error("ProofAI: apiKey is required");
+    this.apiKey = config.apiKey;
+    this.baseUrl = config.baseUrl?.replace(/\/$/, "") || DEFAULT_BASE_URL;
+  }
+  async call(path, body) {
+    const res = await fetch(`${this.baseUrl}/${path}`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${this.apiKey}`
+      },
+      body: JSON.stringify(body)
+    });
+    if (!res.ok) {
+      const text = await res.text();
+      throw new Error(`ProofAI API error ${res.status}: ${text}`);
+    }
+    return res.json();
+  }
+  // --- Individual steps ---
+  async compress(prompt, options = {}) {
+    return this.call("compress", { prompt, options });
+  }
+  async execute(promptRef, options) {
+    const modelDefaults = {
+      anthropic: "claude-sonnet-4-20250514",
+      openai: "gpt-4-turbo",
+      gemini: "gemini-2.0-flash",
+      google: "gemini-2.0-flash"
+    };
+    return this.call("execute", {
+      promptRef,
+      options: {
+        provider: options.provider,
+        modelId: options.modelId || modelDefaults[options.provider] || "gpt-4-turbo",
+        temperature: options.temperature ?? 0.7,
+        maxTokens: options.maxTokens ?? 1024
+      }
+    });
+  }
+  async analyze(executionId, analysisText) {
+    return this.call("analyze", { executionId, analysisText });
+  }
+  async sign(execution) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    return this.call("sign", {
+      executionId: execution.id,
+      rawOutput: execution.output,
+      modelProvider: execution.metadata.provider,
+      modelId: execution.metadata.model,
+      modelVersion: "latest",
+      modelParameters: { temperature: 0.7 },
+      executionMetrics: { latency_ms: execution.metadata.latency, tokens: execution.metadata.tokens.total },
+      requesterInfo: { source: "proofai-sdk" },
+      timestamps: { request_received: now, execution_completed: now }
+    });
+  }
+  async bundle(promptId, executionId, analysisId, signatureId, cognitiveHash) {
+    return this.call("bundle", { promptId, executionId, analysisId, signatureId, cognitiveHash });
+  }
+  async anchor(bundleId, network = "polygon") {
+    return this.call("anchor", { bundleId, network });
+  }
+  async verify(bundleId) {
+    return this.call("verify", { bundleId });
+  }
+  // --- Full pipeline in one call ---
+  async certify(prompt, options = {}) {
+    const provider = options.provider || "anthropic";
+    const compressed = await this.compress(prompt, {
+      compressionLevel: options.compressionLevel || "medium"
+    });
+    const execution = await this.execute(compressed.id, {
+      provider,
+      modelId: options.modelId,
+      temperature: options.temperature,
+      maxTokens: options.maxTokens
+    });
+    const analysis = await this.analyze(execution.id, execution.output);
+    const signature = await this.sign(execution);
+    const evidenceBundle = await this.bundle(
+      compressed.id,
+      execution.id,
+      analysis.id,
+      signature.signatureId,
+      analysis.cognitiveHash
+    );
+    let anchorResult;
+    if (!options.skipAnchor) {
+      try {
+        anchorResult = await this.anchor(evidenceBundle.id, options.network || "polygon");
+      } catch {
+      }
+    }
+    const verification = await this.verify(evidenceBundle.id);
+    return {
+      bundleId: evidenceBundle.id,
+      bundleHash: evidenceBundle.bundleHash,
+      verified: verification.verified,
+      explorerUrl: anchorResult?.explorerUrl,
+      transactionHash: anchorResult?.transactionHash,
+      steps: {
+        compress: compressed,
+        execute: execution,
+        analyze: analysis,
+        sign: signature,
+        bundle: evidenceBundle,
+        anchor: anchorResult,
+        verify: verification
+      }
+    };
+  }
+};
+var index_default = ProofAI;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ProofAI
+});

package/dist/index.mjs

@@ -0,0 +1,122 @@
+// src/index.ts
+var DEFAULT_BASE_URL = "https://apzgbajvwzykygrxxrwm.supabase.co/functions/v1";
+var ProofAI = class {
+  constructor(config) {
+    if (!config.apiKey) throw new Error("ProofAI: apiKey is required");
+    this.apiKey = config.apiKey;
+    this.baseUrl = config.baseUrl?.replace(/\/$/, "") || DEFAULT_BASE_URL;
+  }
+  async call(path, body) {
+    const res = await fetch(`${this.baseUrl}/${path}`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${this.apiKey}`
+      },
+      body: JSON.stringify(body)
+    });
+    if (!res.ok) {
+      const text = await res.text();
+      throw new Error(`ProofAI API error ${res.status}: ${text}`);
+    }
+    return res.json();
+  }
+  // --- Individual steps ---
+  async compress(prompt, options = {}) {
+    return this.call("compress", { prompt, options });
+  }
+  async execute(promptRef, options) {
+    const modelDefaults = {
+      anthropic: "claude-sonnet-4-20250514",
+      openai: "gpt-4-turbo",
+      gemini: "gemini-2.0-flash",
+      google: "gemini-2.0-flash"
+    };
+    return this.call("execute", {
+      promptRef,
+      options: {
+        provider: options.provider,
+        modelId: options.modelId || modelDefaults[options.provider] || "gpt-4-turbo",
+        temperature: options.temperature ?? 0.7,
+        maxTokens: options.maxTokens ?? 1024
+      }
+    });
+  }
+  async analyze(executionId, analysisText) {
+    return this.call("analyze", { executionId, analysisText });
+  }
+  async sign(execution) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    return this.call("sign", {
+      executionId: execution.id,
+      rawOutput: execution.output,
+      modelProvider: execution.metadata.provider,
+      modelId: execution.metadata.model,
+      modelVersion: "latest",
+      modelParameters: { temperature: 0.7 },
+      executionMetrics: { latency_ms: execution.metadata.latency, tokens: execution.metadata.tokens.total },
+      requesterInfo: { source: "proofai-sdk" },
+      timestamps: { request_received: now, execution_completed: now }
+    });
+  }
+  async bundle(promptId, executionId, analysisId, signatureId, cognitiveHash) {
+    return this.call("bundle", { promptId, executionId, analysisId, signatureId, cognitiveHash });
+  }
+  async anchor(bundleId, network = "polygon") {
+    return this.call("anchor", { bundleId, network });
+  }
+  async verify(bundleId) {
+    return this.call("verify", { bundleId });
+  }
+  // --- Full pipeline in one call ---
+  async certify(prompt, options = {}) {
+    const provider = options.provider || "anthropic";
+    const compressed = await this.compress(prompt, {
+      compressionLevel: options.compressionLevel || "medium"
+    });
+    const execution = await this.execute(compressed.id, {
+      provider,
+      modelId: options.modelId,
+      temperature: options.temperature,
+      maxTokens: options.maxTokens
+    });
+    const analysis = await this.analyze(execution.id, execution.output);
+    const signature = await this.sign(execution);
+    const evidenceBundle = await this.bundle(
+      compressed.id,
+      execution.id,
+      analysis.id,
+      signature.signatureId,
+      analysis.cognitiveHash
+    );
+    let anchorResult;
+    if (!options.skipAnchor) {
+      try {
+        anchorResult = await this.anchor(evidenceBundle.id, options.network || "polygon");
+      } catch {
+      }
+    }
+    const verification = await this.verify(evidenceBundle.id);
+    return {
+      bundleId: evidenceBundle.id,
+      bundleHash: evidenceBundle.bundleHash,
+      verified: verification.verified,
+      explorerUrl: anchorResult?.explorerUrl,
+      transactionHash: anchorResult?.transactionHash,
+      steps: {
+        compress: compressed,
+        execute: execution,
+        analyze: analysis,
+        sign: signature,
+        bundle: evidenceBundle,
+        anchor: anchorResult,
+        verify: verification
+      }
+    };
+  }
+};
+var index_default = ProofAI;
+export {
+  ProofAI,
+  index_default as default
+};

package/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "@proofai/sdk",
+  "version": "1.0.0",
+  "description": "ProofAI SDK — Cryptographic proof that AI thought before it answered",
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "files": ["dist"],
+  "scripts": {
+    "build": "tsup src/index.ts --format cjs,esm --dts",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": ["ai", "proof", "blockchain", "ed25519", "evidence", "compliance", "audit"],
+  "author": "HIRAM",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/scorentab-afk/proofai"
+  },
+  "devDependencies": {
+    "tsup": "^8.0.0",
+    "typescript": "^5.8.0"
+  }
+}