AuthProof SDK

AuthProof एजेंटिक AI के लिए एक क्रिप्टोग्राफिक डेलीगेशन प्रोटोकॉल है। इस क्षेत्र के अधिकांश प्रोटोकॉल ऑपरेटर-परिभाषित नीति के विरुद्ध प्रवर्तन करते हैं — ऑपरेटर को उपयोगकर्ता के मूल इरादे को बाद में विस्तारित या पुनर्व्याख्या करने का अधिकार देते हैं। AuthProof एक अलग ट्रस्ट मॉडल पर बनाया गया है: उपयोगकर्ता की अपनी निजी कुंजी निष्पादन को गेट करने वाले प्राधिकरण ऑब्जेक्ट पर हस्ताक्षर करती है, और लाइव मॉडल स्थिति को प्राधिकरण समय और निष्पादन से ठीक पहले दोनों समय सत्यापित किया जाता है। उपयोगकर्ता-हस्ताक्षरित प्राधिकरण और लाइव मॉडल-स्थिति गेटिंग का संयोजन विशिष्ट दावा है — कोई व्यापक प्रवर्तन कहानी नहीं।

क्या इसे अलग बनाता है:

उपयोगकर्ता हस्ताक्षर करने वाला प्राधिकरण है। प्रत्येक प्रतिस्पर्धी प्रोटोकॉल (AIP, AITH, OAP, SAGA, AgentSpec) ऑपरेटर द्वारा परिभाषित नीति के विरुद्ध प्रवर्तन करता है। AuthProof में, उपयोगकर्ता की निजी कुंजी सीधे प्राधिकरण ऑब्जेक्ट पर हस्ताक्षर करती है। उपयोगकर्ता के हस्ताक्षर करने के बाद ऑपरेटर दायरा नहीं बढ़ा सकता।
दो-चरणीय मॉडल-स्थिति प्रतिबद्धता। मॉडल को प्राधिकरण समय पर मापा जाता है और निष्पादन से ठीक पहले पुनः मापा जाता है। यदि मॉडल उन दो बिंदुओं के बीच बदल गया है, तो निष्पादन प्री-एक्ज़ीक्यूशन वेरिफिकेशन पर अवरुद्ध हो जाता है।
प्रदाता अद्यतन बनाम दुर्भावनापूर्ण प्रतिस्थापन, अलग किए गए। प्रोटोकॉल मॉडल-स्थिति परिवर्तनों को दो श्रेणियों में वर्गीकृत करता है: वैध प्रदाता अद्यतन (PROVIDER_UPDATE_REQUIRES_REAUTH) और अनधिकृत स्वैप (MALICIOUS_MODEL_SUBSTITUTION). प्रत्येक एक मशीन-पठनीय अस्वीकृति कारण कोड उत्पन्न करता है जो पहचानता है कि कौन से घटक बदले हैं।

Pre-Execution Verifier

नियतात्मक गेट जो किसी भी एजेंट कार्रवाई के निष्पादन से पहले चलता है।

PreExecutionVerifier एजेंट रनटाइम के बाहर स्थित है। रनटाइम को तब तक नियंत्रण नहीं मिलता जब तक कि सत्यापक पास नहीं हो जाता। एक समझौता किया गया या दुर्भावनापूर्ण एजेंट इसे छोड़ नहीं सकता â यह रनटाइम शुरू होने से पहले चलता है।

यह क्यों मायने रखता है

पारंपरिक प्राधिकरण जाँच एजेंट रनटाइम के अंदर होती हैं। यदि रनटाइम से समझौता किया जाता है, तो उन जाँचों को छोड़ा, पुनर्क्रमित या बायपास किया जा सकता है। PreExecutionVerifier प्राधिकरण को पूरी तरह से रनटाइम के बाहर ले जाकर इस हमले की सतह को समाप्त करता है। एजेंट केवल तभी निष्पादित होता है â और केवल तभी â जब सभी छह अनुक्रमिक जाँच पहले पास हो जाएँ।

त्वरित आरंभ```js

import { PreExecutionVerifier, DelegationLog } from 'authproof-sdk/pre-execution-verifier' import { RevocationRegistry } from 'authproof-sdk'

// 1. Set up the gate const delegationLog = new DelegationLog() const revocationRegistry = new RevocationRegistry() await revocationRegistry.init({ privateKey, publicJwk })

const verifier = new PreExecutionVerifier({ delegationLog, revocationRegistry }) await verifier.init({ privateKey: verifierKey, publicJwk: verifierPub })

// 2. Register your delegation receipt delegationLog.add(receiptHash, receipt)

// 3. Gate every action â before the agent runs const result = await verifier.check({ receiptHash, action: { operation: 'read', resource: 'calendar' }, operatorInstructions: 'Summarize meetings. Stay within scope.', programHash, // optional: prevents code substitution attacks })

if (!result.allowed) { throw new Error(Blocked: ${result.blockedReason}) } // Agent runtime only reaches here after all six checks pass

### Six sequential checks (stops at first failure)

| # | जांच | तब अवरुद्ध करता है |
|---|-------|-------------|
| 1 | रसीद हस्ताक्षर | ECDSA P-256 हस्ताक्षर अमान्य या रसीद से छेड़छाड़ की गई |
| 2 | निरसन | `RevocationRegistry` के माध्यम से रसीद निरस्त कर दी गई है |
| 3 | समय सीमा | रसीद समाप्त हो गई या अभी तक मान्य नहीं है (लॉग टाइमस्टैम्प ओरेकल, क्लाइंट घड़ी नहीं) |
| 4 | दायरा | कार्रवाई `ScopeSchema.allowedActions` में नहीं है या टेक्स्ट-आधारित दायरा मिलान विफल रहता है |
| 5 | ऑपरेटर निर्देश | वर्तमान निर्देश जारी करने के समय रसीद में बंद हैश से मेल नहीं खाते |
| 6 | प्रोग्राम हैश | प्रदान किया गया `programHash` प्रतिबद्ध `executes` हैश से मेल नहीं खाता (कोड प्रतिस्थापन रोकथाम) |

प्रत्येक जांच परिणाम — पास या फेल — स्वचालित रूप से एक अपरिवर्तनीय `ActionLog` में लॉग किया जाता है, जो सत्यापनकर्ता की अपनी कुंजी से हस्ताक्षरित होता है।

### Middleware integrations

सामान्य फ्रेमवर्क के लिए ड्रॉप-इन रैपर। प्रत्येक रैपर लपेटे गए कोड के निष्पादित होने से पहले प्रत्येक कॉल को `PreExecutionVerifier` के माध्यम से गेट करता है।

- **[LangChain](https://github.com/commonguy25/authproof-sdk/blob/main/src/middleware/langchain.js)** — किसी भी एजेंट को `invoke()` विधि के साथ लपेटता है
- **[Express/HTTP](https://github.com/commonguy25/authproof-sdk/blob/main/src/middleware/express.js)** — किसी भी Express-संगत फ्रेमवर्क के लिए अनुरोध मिडलवेयर
- **[Generic function wrapper](https://github.com/commonguy25/authproof-sdk/blob/main/src/middleware/generic.js)** — किसी भी async फ़ंक्शन को लपेटता है```js
// LangChain
import { authproofMiddleware } from 'authproof-sdk/middleware/langchain'
const guardedAgent = authproofMiddleware(agent, { receiptHash, verifier })

// Express
import { authproofMiddleware } from 'authproof-sdk/middleware/express'
app.use(authproofMiddleware({ verifier, getReceiptHash: (req) => req.headers['x-receipt-hash'] }))

// Any function
import { guardFunction } from 'authproof-sdk/middleware/generic'
const guardedExecute = guardFunction(executeAction, { receiptHash, verifier, action })

समस्या

एजेंट पहचान के लिए हर मौजूदा IETF ढांचा — AIP, draft-klrc-aiagent-auth, WIMSE — सेवा-से-एजेंट विश्वास को संबोधित करता है: कैसे एक डाउनस्ट्रीम सेवा यह सत्यापित करती है कि कोई एजेंट उसे कॉल करने के लिए अधिकृत है। उनमें से कोई भी उपयोगकर्ता-से-ऑपरेटर विश्वास को संबोधित नहीं करता।

वर्तमान एजेंटिक सिस्टम में प्रतिनिधिमंडल श्रृंखला है:``` User â Operator â Agent â Services

The user instructs the operator. The operator instructs the agent. But no cryptographic record of the user's original intent exists at the moment of delegation. The operator becomes a trusted third party with unchecked authority to expand, distort, or omit the user's instructions before they reach the agent.

The consequences:

- Users cannot prove what they authorized.
- Regulators have no audit trail.
- Courts have no evidence chain.
- Agents cannot distinguish legitimate operator instructions from compromised or rogue ones.

AuthProof fills this gap.

---

## The Core Primitive: Delegation Receipt

A **Delegation Receipt** is a signed Authorization Object anchored to a decentralized append-only log before any agent action begins. It contains four required fields:

### Scope

An explicit allowlist of permitted operations. Everything not listed is denied by default. Expressed in structured format — not natural language. Operation classes:

| Class | Description |
|---|---|
| `reads` | Read access to specified resources |
| `writes` | Write access to specified resources |
| `deletes` | Deletion of specified resources |
| `executes` | Execution of a specific program, referenced by its **static capability signature hash** |

`executes` is the most dangerous class. It must reference the cryptographic hash of a Safescript program's static capability DAG — not a name, URI, or description. No hash match means no execution.

### Boundaries

Explicit prohibitions that cannot be overridden by operator instructions under any circumstances. User-defined hard limits that survive any subsequent operator instruction.

### Time Window

Validity period of the authorization. The **log timestamp** is the time oracle — not the client clock. Client clocks are explicitly excluded from time validation.

### Operator Instruction Hash

A cryptographic hash of the operator's stated instructions at delegation time. If the operator subsequently instructs the agent differently, the discrepancy is detectable from the log without any additional trust assumptions.

The user signs this object with their private key via **WebAuthn/FIDO2 using the device secure enclave**. The signature is published to the log before any agent action. Every subsequent agent action references the receipt hash. Actions outside scope are cryptographically invalid.

---

## Trust Stack Architecture

Three protocol layers eliminate three trusted third parties:

### Layer 1 — Signed Capability Manifest *(removes trust in the registry)*

In the current MCP ecosystem, there is no cryptographic attestation that a tool server's descriptions match what it actually does. An operator can present an arbitrary schema.

The fix: tool servers publish a **cryptographically signed capability manifest** before any user authorization occurs. The `scope` field of the Delegation Receipt references the **hash of this manifest** — not the operator's self-reported schema. Divergence between server behavior and manifest is detectable at the log layer.

### Layer 2 — Delegation Receipt *(removes trust in the operator)*

The user's original intent is immutably recorded before operator instructions reach the agent. Operator deviation is provable.

### Layer 3 — Safescript Execution *(removes trust in the code)*

[Safescript](https://github.com/safescript) is an open-source sandboxed language for AI agent execution. Its static DAG structure means every program's full capability signature is computable before it runs — no dynamic dispatch, no runtime capability expansion.

The `executes` scope class references a specific Safescript capability signature hash. If the operator-supplied program does not match the committed hash, execution is blocked. The agent cannot be substituted with a different program after delegation.

---

## Quick Start```js
import { AuthProof, Scope, KeyCustody } from 'authproof-sdk';

// Initialize with hardware-backed key custody (recommended)
const authproof = new AuthProof({
  custody: KeyCustody.HARDWARE, // WebAuthn/FIDO2 via device secure enclave
  log: 'https://log.authproof.dev',
});

// Define permitted operations â explicit allowlist, deny-by-default
const scope = new Scope()
  .allow('reads',  ['resource://calendar/events', 'resource://email/inbox'])
  .allow('writes', ['resource://calendar/events'])
  .deny('deletes', '*')
  .execute('sha256:a3f1c9d8...', { program: 'scheduler-v1.sg' }); // Safescript hash

// Hard limits that survive any operator instruction
const boundaries = {
  never: ['external-network', 'credential-store', 'payment-methods'],
};

// Issue the Delegation Receipt â anchored to log before any agent action
const receipt = await authproof.delegate({
  scope,
  boundaries,
  window: { duration: '8h' },           // validated against log timestamp
  operatorInstructions: instructionText, // hashed and committed
});

// receipt.id    â unique receipt identifier
// receipt.hash  â reference in every agent action
// receipt.log   â append-only log anchor

// Agent-side: validate an action against the receipt
const check = await authproof.validate({
  receiptHash: receipt.hash,
  action: { class: 'writes', resource: 'resource://calendar/events' },
});

if (!check.authorized) {
  // Out-of-scope action: surface a micro-receipt request to the user
  const microReceipt = await authproof.requestMicroReceipt({
    action: check.requestedAction,
    parent: receipt.hash,
  });
}

गतिशील प्राधिकरण: माइक्रो-रसीदें

मूल प्रतिनिधि रसीद (Delegation Receipt) द्वारा कवर न की गई टूल कॉल के लिए, एजेंट चुपचाप आगे नहीं बढ़ सकता। प्रोटोकॉल अनिवार्य करता है:

एजेंट एक दायरे से बाहर की क्षमता आवश्यकता की पहचान करता है।
एजेंट उपयोगकर्ता को विशिष्ट कार्रवाई का वर्णन करते हुए एक क्षमता अनुरोध प्रस्तुत करता है।
उपयोगकर्ता केवल उस कार्रवाई को कवर करने वाली एक माइक्रो-रसीद पर हस्ताक्षर करता है।
एजेंट माइक्रो-रसीद हैश का संदर्भ देते हुए आगे बढ़ता है।

अज्ञात कार्रवाइयों के लिए स्पष्ट नई उपयोगकर्ता प्राधिकरण की आवश्यकता होती है। निर्भरता समाधान उसी नियम का पालन करता है â निर्भरताओं की जाँच प्रतिनिधि समय पर प्रतिबद्ध निर्भरता मैनिफेस्ट के हैश के विरुद्ध की जाती है। अप्रत्याशित निर्भरताएँ दायरे का उल्लंघन हैं।

समवर्ती एजेंट

प्रत्येक प्रतिनिधि घटना एक अद्वितीय रसीद आईडी ले जाती है। समवर्ती एजेंट प्रत्येक अपने स्वयं के रसीद हैश का संदर्भ देते हैं। वे रसीद द्वारा अलग-अलग पहचाने जाते हैं, एजेंट पहचान से नहीं।

कुंजी प्रबंधन

हार्डवेयर संरक्षा अनुशंसित डिफ़ॉल्ट है। निजी कुंजी कभी सुरक्षित एन्क्लेव नहीं छोड़ती; हस्ताक्षर डिवाइस बायोमेट्रिक्स या PIN द्वारा सुरक्षित है।

कार्रवाई लॉग

एक प्रतिनिधि रसीद (Delegation Receipt) परिभाषित करती है कि एक AI एजेंट को क्या करने का अधिकार है। एक्शन लॉग रिकॉर्ड करता है कि उसने वास्तव में क्या किया â और किसी भी विचलन को तुरंत सत्यापनीय बनाता है।

एजेंट द्वारा उठाया गया प्रत्येक कार्रवाई एक हस्ताक्षरित, समय-मुद्रांकित प्रविष्टि उत्पन्न करती है जो सक्रिय रसीद से जुड़ी होती है। प्रविष्टियाँ एक छेड़छाड़-स्पष्ट श्रृंखला बनाती हैं: प्रत्येक प्रविष्टि पिछली प्रविष्टि के SHA-256 हैश को एम्बेड करती है, इसलिए किसी भी पूर्वव्यापी संशोधन का पता बिना किसी विश्वसनीय तीसरे पक्ष के लगाया जा सकता है। diff() विधि ऑडिट प्रिमिटिव है â यह रसीद के अधिकृत दायरे को प्रत्येक रिकॉर्ड की गई कार्रवाई के विरुद्ध संरेखित करता है और किसी भी विचलन को लौटाता है।```js import AuthProof, { ActionLog } from 'authproof-sdk';

// 1. Issue a delegation receipt as normal const { privateKey, publicJwk } = await AuthProof.generateKey();

const { receipt, receiptId } = await AuthProof.create({ scope: 'Search the web for competitor pricing. Read calendar events.', boundaries: 'Do not send emails. Do not make purchases.', instructions: 'Cite sources. Keep under 500 words.', ttlHours: 4, privateKey, publicJwk, });

// 2. Initialize the action log with the agent's signing key const log = new ActionLog(); await log.init({ privateKey, publicJwk });

// Register the receipt so diff() knows what was authorized log.registerReceipt(receiptId, receipt);

// 3. Record each action the agent takes const e1 = await log.record(receiptId, { operation: 'Search competitor pricing', resource: 'web/search', parameters: { query: 'rival.com pricing 2024' }, });

const e2 = await log.record(receiptId, { operation: 'Read calendar events', resource: 'calendar/events', parameters: { range: 'this_week' }, });

// 4. Verify an individual entry (signature + chain integrity) const check = await log.verify(e1.entryId); // { valid: true, reason: 'Signature and chain integrity verified' }

// 5. Diff: authorized scope vs. everything that was done const report = log.diff(receiptId); // { // clean: true, // totalEntries: 2, // compliant: [{ entry: {...}, reason: '"Search competitor pricing" matches authorized scope' }, ...], // violations: [], // }

// A scope violation surfaces immediately await log.record(receiptId, { operation: 'Send email', resource: 'email/outbox' }); const auditReport = log.diff(receiptId); // auditReport.violations[0].reason â // '"Send email" outside authorized scope (0% scope match, 92% boundary overlap)'

### कार्य लॉग API

| विधि | विवरण |
|---|---|
| `new ActionLog()` | एक नया लॉग इंस्टेंस बनाएँ। स्टेट मेमोरी में है। |
| `log.init({ privateKey, publicJwk })` | एजेंट की ECDSA P-256 कुंजी से इनिशियलाइज़ करें। `record()` से पहले आवश्यक। |
| `log.registerReceipt(receiptHash, receipt)` | स्कोप तुलना के लिए एक रसीद पंजीकृत करें। `diff()` से पहले आवश्यक। |
| `log.record(receiptHash, action)` | एक हस्ताक्षरित, श्रृंखला-लिंक्ड एंट्री जोड़ें। सील की गई एंट्री लौटाता है। |
| `log.verify(entryId)` | एक एंट्री के हस्ताक्षर और श्रृंखला स्थिति की पुष्टि करें। `{ valid, reason }` लौटाता है। |
| `log.getEntries(receiptHash)` | एक रसीद के लिए कालानुक्रमिक क्रम में सभी एंट्रीज़। |
| `log.diff(receiptHash)` | सभी एंट्रीज़ की तुलना रसीद के स्कोप से करें। `{ compliant, violations, clean }` लौटाता है। |

### उत्पादन चेतावनी

v1 में टाइमस्टैम्प क्लॉक का उपयोग करते हैं। अनुपालन या कानूनी संदर्भों के लिए जहाँ टाइमस्टैम्प स्वतंत्र रूप से सत्यापनीय होने चाहिए, उत्पादन में तैनात करने से पहले RFC 3161 विश्वसनीय टाइमस्टैम्प प्राधिकरण से बदलें।

### महत्वपूर्ण

हमेशा स्पष्ट `allowedActions` ऐरे का उपयोग करके स्कोप परिभाषित करें। टेक्स्ट-आधारित स्कोप मिलान केवल विकास के लिए उपलब्ध है और उत्पादन या अनुपालन संदर्भों के लिए उपयुक्त नहीं है।

---

## गोपनीय तैनाती

AuthProof एजेंटों को हार्डवेयर-प्रमाणित विश्वसनीय निष्पादन वातावरण (TEE) के अंदर चलाएँ। `ConfidentialRuntime` वर्ग प्रतिनिधि रसीदों (delegation receipts) को एन्क्लेव मापों से बांधता है, ताकि मॉडल वज़न, सत्यापन कोड या प्लेटफ़ॉर्म के किसी भी प्रतिस्थापन का निष्पादन से पहले पता लगाया जा सके।

### हार्डवेयर आवश्यकताएँ

- **Intel TDX** — Intel Ice Lake Xeon या नया (चौथी पीढ़ी का Xeon Scalable)। Azure DCdsv3-श्रृंखला, GCP C3 गोपनीय VM।
- **AMD SEV-SNP** — AMD EPYC तीसरी पीढ़ी (Milan) या नया। Azure DCasv5-श्रृंखला, Nitro Enclaves के साथ AWS m6a।

### TEE माप बाइंडिंग के साथ एक रसीद बनाएँ```javascript
import { AuthProofClient } from 'authproof-sdk';

const client = new AuthProofClient();
const { receipt } = await client.delegate({
  scope: 'Summarize calendar events',
  operatorInstructions: 'Stay within scope.',
  expiresIn: '2h',
  privateKey,
  publicJwk,
  teeConfig: {
    platform:     'intel-tdx',
    verifierHash: verifierCodeHash,   // SHA-256 of your verifier binary
    modelHash:    modelWeightsHash,   // SHA-256 of model weights
  },
});
// receipt.teeMeasurement.expectedMrenclave is now bound to the receipt

Azure गोपनीय कंप्यूटिंग (Intel TDX) पर तैनात करें```javascript

import { ConfidentialRuntime } from 'authproof-sdk';

// Generate deployment configuration const config = ConfidentialRuntime.azureTDXConfig({ receiptHash, verifierHash, modelHash, region: 'eastus', }); // config.vmSize === 'Standard_DC4ds_v3' // config.attestationEndpoint === 'https://sharedeus.eus.attest.azure.net' // config.receiptBinding binds the receipt to the VM measurement

// At runtime inside the VM: const runtime = new ConfidentialRuntime({ platform: 'intel-tdx', verifier, actionLog, }); const result = await runtime.launch({ receiptHash, agentFn, operatorInstructions, verifierHash, modelHash, teeMeasurement: receipt.teeMeasurement, // mismatch blocks execution });

Azure SKU आवश्यकताएँ: `Standard_DC4ds_v3` या DCdsv3-श्रृंखला से बड़ा। कॉन्फ़िडेंशियल OS डिस्क एन्क्रिप्शन सक्षम करें। कोट सत्यापन के लिए Microsoft Azure Attestation (MAA) साझा एंडपॉइंट का उपयोग करें।

### AWS Nitro Enclaves पर तैनात करें```javascript
const config = ConfidentialRuntime.awsNitroConfig({
  receiptHash,
  verifierHash,
  modelHash,
  region: 'us-east-1',
});
// config.instanceType === 'c6a.xlarge'
// config.enclaveOptions.enabled === true
// config.pcr0 is the combined receipt+verifier+model measurement

AWS आवश्यकताएँ: c6a.xlarge या बड़ा --enclave-options Enabled के साथ। एन्क्लेव इमेज बनाने और चलाने के लिए nitro-cli का उपयोग करें। प्रमाणन दस्तावेज़ में PCR0 को रसीद बाइंडिंग के वैध होने के लिए config.pcr0 से मेल खाना चाहिए।

Kubernetes पर तैनात करें```javascript

const manifest = ConfidentialRuntime.kubernetesConfig({ receiptHash, platform: 'intel-tdx', namespace: 'production', }); // manifest is a full K8s List containing: // - Pod with TDX node selector and attestation sidecar // - ServiceAccount with minimal RBAC // - ConfigMap with receipt binding

`kubectl apply -f` के साथ YAML में सीरियलाइज़ करने के बाद लागू करें। नोड चयनकर्ता `intel.feature.node.kubernetes.io/tdx: "true"` को Intel Device Plugin for Kubernetes की आवश्यकता है।

### eBPF कर्नेल मॉड्यूल — सहायता अपेक्षित

TEE प्रवर्तन परत यूज़रस्पेस पक्ष (`ConfidentialRuntime`, `TokenPreparer`) के माध्यम से पूर्ण है। अंतिम प्रवर्तन चरण — eBPF LSM हुक के माध्यम से प्रत्येक syscall पर हस्ताक्षरित क्षमता टोकन को सत्यापित करना — एक कर्नेल मॉड्यूल की आवश्यकता है जो योगदान के लिए खुला है।

eBPF LSM अनुभव वाले इंजीनियर्स (Isovalent, Red Canary, या इसी तरह) विशेष रूप से स्वागत योग्य हैं। https://github.com/Commonguy25/authproof-sdk/issues पर एक issue या PR खोलें।

---

## उदाहरण

दो चलाने योग्य उदाहरण `examples/` निर्देशिका में हैं।

**[`examples/langchain-example.js`](https://github.com/commonguy25/authproof-sdk/blob/main/examples/langchain-example.js)** — पूर्ण LangChain एकीकरण पथ दिखाता है: एक कुंजी युग्म उत्पन्न करें, एक प्रतिनिधि रसीद जारी करें, `PreExecutionVerifier` को आरंभ करें, और किसी भी एजेंट को `authproofMiddleware` के साथ लपेटें ताकि एजेंट रनटाइम को नियंत्रण प्राप्त करने से पहले प्रत्येक `invoke()` कॉल को गेट किया जा सके। एक मॉक एजेंट शामिल है जिसे आप तुरंत चला सकते हैं और वास्तविक `AgentExecutor` के लिए सटीक कोड पैटर्न शामिल है। `npm run example:langchain` के साथ चलाएं।

**[`examples/webauthn-example.html`](https://github.com/commonguy25/authproof-sdk/blob/main/examples/webauthn-example.html)** — पूर्ण प्रतिनिधि प्रवाह का एक स्व-निहित तीन-कार्ड ब्राउज़र डेमो। कार्ड 1 आपको दायरा, सीमाएँ और संचालक निर्देश परिभाषित करने देता है, फिर एक स्थानीय कुंजी के साथ एक रसीद पर हस्ताक्षर करता है (वास्तविक WebAuthn के लिए `navigator.credentials` में स्वैप करें)। कार्ड 2 रसीद आईडी, समाप्ति, सिस्टम प्रॉम्प्ट और कच्चा JSON प्रदर्शित करता है। कार्ड 3 आपको किसी भी प्रस्तावित कार्रवाई को टाइप करने और रसीद के विरुद्ध वास्तविक समय में सत्यापित करने देता है, प्रत्येक जांच परिणाम दिखाता है। सीधे ब्राउज़र में खोलें — कोई बिल्ड चरण आवश्यक नहीं।

---

## स्थापना```bash
npm install authproof-sdk

npm: https://www.npmjs.com/package/authproof-sdk
GitHub: https://github.com/Commonguy25/authproof-sdk
प्रोटोकॉल विनिर्देश: WHITEPAPER.md

हार्डवेयर	डिवाइस सुरक्षित एन्क्लेव के माध्यम से WebAuthn/FIDO2। निजी कुंजी कभी हार्डवेयर नहीं छोड़ती।	हाँ â डिफ़ॉल्ट
प्रतिनिधिकृत	विश्वसनीय कुंजी प्रबंधक उपयोगकर्ता की ओर से कुंजी रखता है।	FIDO2 समर्थन के बिना वातावरण
स्व-संरक्षा	उपयोगकर्ता अपनी स्वयं की निजी कुंजी रखता है और प्रबंधित करता है।	उन्नत उपयोगकर्ता, एयर-गैप्ड वर्कफ़्लो

authproof-sdk

सबसे लोकप्रिय