atlast-ecp-ts 0.1.0

package/README.md

@@ -0,0 +1,159 @@
+# @atlast/sdk
+
+**ATLAST Evidence Chain Protocol (ECP) SDK for TypeScript/Node.js**
+
+> At last, trust for the Agent economy.
+
+Track your AI agent's work with cryptographic evidence chains. Every LLM call, tool use, and decision is recorded, hashed, and chained — creating an immutable audit trail.
+
+Privacy-first: only SHA-256 hashes are stored. Content never leaves your device.
+
+## Install
+
+```bash
+npm install @atlast/sdk
+```
+
+## Quick Start
+
+### Layer 1 — Wrap your OpenAI client (5 lines)
+
+```typescript
+import { wrap } from '@atlast/sdk';
+import OpenAI from 'openai';
+
+const client = wrap(new OpenAI(), { agentId: 'my-agent' });
+
+// All chat.completions.create() calls are now automatically tracked
+const response = await client.chat.completions.create({
+  model: 'gpt-4',
+  messages: [{ role: 'user', content: 'Hello' }],
+});
+// → ECP record saved to ~/.ecp/records/
+```
+
+### Track custom functions
+
+```typescript
+import { track } from '@atlast/sdk';
+
+const myAgentStep = track('my-agent', async (query: string) => {
+  // Your agent logic here
+  return await processQuery(query);
+});
+
+await myAgentStep('What is the weather?');
+```
+
+### Manual record creation
+
+```typescript
+import { createRecord, storeRecord } from '@atlast/sdk';
+
+const record = createRecord({
+  agentId: 'my-agent',
+  input: 'user query',
+  output: 'agent response',
+  model: 'claude-sonnet-4-20250514',
+  latencyMs: 1234,
+});
+
+storeRecord('my-agent', record);
+```
+
+### Upload to ATLAST Backend
+
+```typescript
+import { uploadBatch } from '@atlast/sdk';
+
+// Upload batched records (merkle root + record hashes)
+await uploadBatch({
+  agentId: 'my-agent',
+  apiUrl: 'https://api.llachat.com',  // or set ATLAST_API_URL env
+  apiKey: 'your-agent-api-key',       // or set ATLAST_API_KEY env
+});
+```
+
+## How It Works
+
+1. **Record**: Each LLM call creates an ECP record with input/output SHA-256 hashes (content stays local)
+2. **Chain**: Records are linked via hash chains, forming an immutable evidence trail
+3. **Sign**: Records are signed with your agent's Ed25519 key (auto-generated DID)
+4. **Upload**: Batch upload merkle roots to ATLAST backend via `POST /v1/batches` with `X-Agent-Key` header
+
+## API Reference
+
+### Core
+
+| Export | Description |
+|--------|-------------|
+| `wrap(client, opts)` | Wrap OpenAI-compatible client for automatic ECP tracking |
+| `track(agentId, fn)` | Track a function's execution as an ECP record |
+| `createRecord(opts)` | Create an ECP record manually |
+
+### Storage
+
+| Export | Description |
+|--------|-------------|
+| `storeRecord(id, rec)` | Store a record locally (JSONL in `~/.ecp/records/`) |
+| `loadRecords(agentId)` | Load stored records for an agent |
+| `collectBatch(agentId)` | Collect records into a batch for upload |
+
+### Identity & Crypto
+
+| Export | Description |
+|--------|-------------|
+| `loadOrCreateIdentity(id)` | Load or create agent DID + Ed25519 keys |
+| `getIdentity(id)` | Get existing identity (returns null if none) |
+| `sha256(data)` | SHA-256 hash with `sha256:` prefix |
+| `hashRecord(record)` | Compute canonical hash of an ECP record |
+| `buildMerkleRoot(hashes)` | Build merkle root from record hashes |
+| `generateDID(publicKey)` | Generate `did:ecp:` identifier from public key |
+| `verifySignature(data, sig, pubkey)` | Verify Ed25519 signature |
+
+### Network
+
+| Export | Description |
+|--------|-------------|
+| `uploadBatch(config)` | Upload batch to ATLAST backend (`POST /v1/batches`) |
+
+### Types
+
+| Export | Description |
+|--------|-------------|
+| `ECPRecord` | ECP record type definition |
+| `ECPIdentity` | Agent identity (DID + keys) |
+| `ATLASTConfig` | SDK configuration options |
+| `CreateRecordOptions` | Options for `createRecord()` |
+| `WrapOptions` | Options for `wrap()` |
+| `TrackOptions` | Options for `track()` |
+| `BatchUploadRequest` | Batch upload request shape |
+| `BatchUploadResponse` | Batch upload response shape |
+
+## Environment Variables
+
+| Variable | Default | Description |
+|----------|---------|-------------|
+| `ATLAST_ECP_DIR` | `~/.ecp` | Directory for ECP data (identity, records) |
+| `ATLAST_API_URL` | `https://api.llachat.com` | Backend API endpoint for batch upload |
+| `ATLAST_API_KEY` | — | Agent API key (sent as `X-Agent-Key` header) |
+
+## ECP Compatibility
+
+This SDK produces ECP v0.1 records (nested `step` format). It is compatible with the Python SDK (`atlast-ecp`) which also supports ECP v1.0 (flat format). Both formats are valid and can coexist.
+
+For zero-code recording via transparent proxy, see the Python SDK:
+```bash
+pip install atlast-ecp[proxy]
+atlast run python my_agent.py
+```
+
+## Links
+
+- [ECP Specification](https://github.com/willau95/atlast-ecp/blob/main/ECP-SPEC.md)
+- [Python SDK](https://pypi.org/project/atlast-ecp/)
+- [ATLAST Protocol](https://llachat.com)
+
+## License
+
+MIT

package/dist/batch.d.ts

@@ -0,0 +1,5 @@
+/**
+ * ATLAST ECP Batch — collect records and upload to backend
+ */
+import type { BatchUploadResponse, ATLASTConfig } from './types';
+export declare function uploadBatch(config: ATLASTConfig): Promise<BatchUploadResponse>;

package/dist/batch.js

@@ -0,0 +1,64 @@
+"use strict";
+/**
+ * ATLAST ECP Batch — collect records and upload to backend
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uploadBatch = uploadBatch;
+const crypto_1 = require("./crypto");
+const storage_1 = require("./storage");
+const identity_1 = require("./identity");
+const DEFAULT_API_URL = 'https://api.llachat.com';
+async function uploadBatch(config) {
+    const identity = (0, identity_1.loadOrCreateIdentity)(config.agentId);
+    const { records, hashes } = (0, storage_1.collectBatch)(config.agentId, config.batchSize || 100);
+    if (records.length === 0) {
+        return { batch_id: '', status: 'empty', message: 'No records to upload', attestation_uid: undefined };
+    }
+    const merkleRoot = (0, crypto_1.buildMerkleRoot)(hashes);
+    const sig = (0, crypto_1.signData)(identity.private_key, merkleRoot);
+    // Compute flag counts
+    const flagCounts = {};
+    let totalLatency = 0;
+    let latencyCount = 0;
+    for (const r of records) {
+        for (const f of r.flags) {
+            flagCounts[f] = (flagCounts[f] || 0) + 1;
+        }
+        if (r.latency_ms) {
+            totalLatency += r.latency_ms;
+            latencyCount++;
+        }
+    }
+    const avgLatency = latencyCount > 0 ? Math.round(totalLatency / latencyCount) : 0;
+    const payload = {
+        agent_did: identity.did,
+        merkle_root: merkleRoot,
+        record_count: records.length,
+        avg_latency_ms: avgLatency,
+        batch_ts: Date.now(),
+        sig,
+        ecp_version: '0.5',
+        flag_counts: flagCounts,
+        record_hashes: records.map((r) => ({
+            id: r.id,
+            hash: r.chain.hash,
+            flags: r.flags,
+        })),
+    };
+    const apiUrl = config.apiUrl || process.env.ATLAST_API_URL || DEFAULT_API_URL;
+    const apiKey = config.apiKey || process.env.ATLAST_API_KEY;
+    const headers = { 'Content-Type': 'application/json' };
+    if (apiKey) {
+        headers['X-Agent-Key'] = apiKey;
+    }
+    const resp = await fetch(`${apiUrl}/v1/batches`, {
+        method: 'POST',
+        headers,
+        body: JSON.stringify(payload),
+    });
+    if (!resp.ok) {
+        const errText = await resp.text();
+        throw new Error(`Batch upload failed (${resp.status}): ${errText}`);
+    }
+    return (await resp.json());
+}

package/dist/crypto.d.ts

@@ -0,0 +1,15 @@
+/**
+ * ATLAST ECP Crypto — hashing, signing, merkle tree
+ */
+export declare function sha256(data: string): string;
+export declare function hashRecord(record: Record<string, unknown>): string;
+export declare function generateId(prefix?: string): string;
+export declare function generateDID(): string;
+export declare function buildMerkleRoot(hashes: string[]): string;
+export interface KeyPair {
+    publicKey: string;
+    privateKey: string;
+}
+export declare function generateKeyPair(): KeyPair;
+export declare function signData(privateKeyHex: string, data: string): string;
+export declare function verifySignature(publicKeyHex: string, data: string, signatureHex: string): boolean;

package/dist/crypto.js

@@ -0,0 +1,78 @@
+"use strict";
+/**
+ * ATLAST ECP Crypto — hashing, signing, merkle tree
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sha256 = sha256;
+exports.hashRecord = hashRecord;
+exports.generateId = generateId;
+exports.generateDID = generateDID;
+exports.buildMerkleRoot = buildMerkleRoot;
+exports.generateKeyPair = generateKeyPair;
+exports.signData = signData;
+exports.verifySignature = verifySignature;
+const crypto_1 = require("crypto");
+function sha256(data) {
+    return (0, crypto_1.createHash)('sha256').update(data).digest('hex');
+}
+function hashRecord(record) {
+    // Zero out chain.hash and sig before hashing
+    const clone = JSON.parse(JSON.stringify(record));
+    if (clone.chain)
+        clone.chain.hash = '';
+    delete clone.sig;
+    const canonical = JSON.stringify(clone, Object.keys(clone).sort());
+    return sha256(canonical);
+}
+function generateId(prefix = 'rec') {
+    return `${prefix}_${(0, crypto_1.randomBytes)(6).toString('hex')}`;
+}
+function generateDID() {
+    const id = (0, crypto_1.randomBytes)(16).toString('hex');
+    return `did:ecp:${id}`;
+}
+function buildMerkleRoot(hashes) {
+    if (hashes.length === 0)
+        return sha256('');
+    if (hashes.length === 1)
+        return hashes[0];
+    const next = [];
+    for (let i = 0; i < hashes.length; i += 2) {
+        const left = hashes[i];
+        const right = i + 1 < hashes.length ? hashes[i + 1] : left;
+        next.push(sha256(left + right));
+    }
+    return buildMerkleRoot(next);
+}
+function generateKeyPair() {
+    const { publicKey, privateKey } = (0, crypto_1.generateKeyPairSync)('ed25519', {
+        publicKeyEncoding: { type: 'spki', format: 'der' },
+        privateKeyEncoding: { type: 'pkcs8', format: 'der' },
+    });
+    return {
+        publicKey: publicKey.toString('hex'),
+        privateKey: privateKey.toString('hex'),
+    };
+}
+function signData(privateKeyHex, data) {
+    const keyObj = (0, crypto_1.createPrivateKey)({
+        key: Buffer.from(privateKeyHex, 'hex'),
+        format: 'der',
+        type: 'pkcs8',
+    });
+    const signature = (0, crypto_1.sign)(null, Buffer.from(data), keyObj);
+    return signature.toString('hex');
+}
+function verifySignature(publicKeyHex, data, signatureHex) {
+    try {
+        const keyObj = (0, crypto_1.createPublicKey)({
+            key: Buffer.from(publicKeyHex, 'hex'),
+            format: 'der',
+            type: 'spki',
+        });
+        return (0, crypto_1.verify)(null, Buffer.from(data), keyObj, Buffer.from(signatureHex, 'hex'));
+    }
+    catch {
+        return false;
+    }
+}

package/dist/identity.d.ts

@@ -0,0 +1,7 @@
+/**
+ * ATLAST ECP Identity — DID management and key storage
+ */
+import type { ECPIdentity } from './types';
+export declare function getECPDir(): string;
+export declare function loadOrCreateIdentity(agentId: string): ECPIdentity;
+export declare function getIdentity(agentId: string): ECPIdentity | null;

package/dist/identity.js

@@ -0,0 +1,44 @@
+"use strict";
+/**
+ * ATLAST ECP Identity — DID management and key storage
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getECPDir = getECPDir;
+exports.loadOrCreateIdentity = loadOrCreateIdentity;
+exports.getIdentity = getIdentity;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const crypto_1 = require("./crypto");
+const DEFAULT_ECP_DIR = (0, path_1.join)(process.env.HOME || '~', '.ecp');
+function getECPDir() {
+    return process.env.ATLAST_ECP_DIR || DEFAULT_ECP_DIR;
+}
+function identityPath(agentId) {
+    const dir = (0, path_1.join)(getECPDir(), 'agents', agentId);
+    if (!(0, fs_1.existsSync)(dir))
+        (0, fs_1.mkdirSync)(dir, { recursive: true });
+    return (0, path_1.join)(dir, 'identity.json');
+}
+function loadOrCreateIdentity(agentId) {
+    const path = identityPath(agentId);
+    if ((0, fs_1.existsSync)(path)) {
+        const data = JSON.parse((0, fs_1.readFileSync)(path, 'utf-8'));
+        return data;
+    }
+    const keyPair = (0, crypto_1.generateKeyPair)();
+    const identity = {
+        did: (0, crypto_1.generateDID)(),
+        agent_id: agentId,
+        public_key: keyPair.publicKey,
+        private_key: keyPair.privateKey,
+        created_at: new Date().toISOString(),
+    };
+    (0, fs_1.writeFileSync)(path, JSON.stringify(identity, null, 2));
+    return identity;
+}
+function getIdentity(agentId) {
+    const path = identityPath(agentId);
+    if (!(0, fs_1.existsSync)(path))
+        return null;
+    return JSON.parse((0, fs_1.readFileSync)(path, 'utf-8'));
+}

package/dist/index.d.ts

@@ -0,0 +1,24 @@
+/**
+ * @atlast/sdk — ATLAST Evidence Chain Protocol SDK for TypeScript/Node.js
+ *
+ * Layer 1 integration: 5 lines of code to track your AI agent's work.
+ *
+ * Quick Start:
+ *   import { wrap } from '@atlast/sdk';
+ *   import OpenAI from 'openai';
+ *
+ *   const client = wrap(new OpenAI(), { agentId: 'my-agent' });
+ *   // All LLM calls are now tracked with evidence chains
+ */
+export type { ECPRecord, ECPIdentity, BatchUploadRequest, BatchUploadResponse, ATLASTConfig } from './types';
+export { loadOrCreateIdentity, getIdentity } from './identity';
+export { createRecord, setChainHead, getChainHead } from './record';
+export type { CreateRecordOptions } from './record';
+export { storeRecord, loadRecords, collectBatch } from './storage';
+export { uploadBatch } from './batch';
+export { wrap } from './wrap';
+export type { WrapOptions } from './wrap';
+export { track } from './track';
+export type { TrackOptions } from './track';
+export { sha256, hashRecord, buildMerkleRoot, generateDID, verifySignature } from './crypto';
+export type { LocalConfig } from './types';

package/dist/index.js

@@ -0,0 +1,45 @@
+"use strict";
+/**
+ * @atlast/sdk — ATLAST Evidence Chain Protocol SDK for TypeScript/Node.js
+ *
+ * Layer 1 integration: 5 lines of code to track your AI agent's work.
+ *
+ * Quick Start:
+ *   import { wrap } from '@atlast/sdk';
+ *   import OpenAI from 'openai';
+ *
+ *   const client = wrap(new OpenAI(), { agentId: 'my-agent' });
+ *   // All LLM calls are now tracked with evidence chains
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.verifySignature = exports.generateDID = exports.buildMerkleRoot = exports.hashRecord = exports.sha256 = exports.track = exports.wrap = exports.uploadBatch = exports.collectBatch = exports.loadRecords = exports.storeRecord = exports.getChainHead = exports.setChainHead = exports.createRecord = exports.getIdentity = exports.loadOrCreateIdentity = void 0;
+// Identity (DID management)
+var identity_1 = require("./identity");
+Object.defineProperty(exports, "loadOrCreateIdentity", { enumerable: true, get: function () { return identity_1.loadOrCreateIdentity; } });
+Object.defineProperty(exports, "getIdentity", { enumerable: true, get: function () { return identity_1.getIdentity; } });
+// Record creation
+var record_1 = require("./record");
+Object.defineProperty(exports, "createRecord", { enumerable: true, get: function () { return record_1.createRecord; } });
+Object.defineProperty(exports, "setChainHead", { enumerable: true, get: function () { return record_1.setChainHead; } });
+Object.defineProperty(exports, "getChainHead", { enumerable: true, get: function () { return record_1.getChainHead; } });
+// Storage
+var storage_1 = require("./storage");
+Object.defineProperty(exports, "storeRecord", { enumerable: true, get: function () { return storage_1.storeRecord; } });
+Object.defineProperty(exports, "loadRecords", { enumerable: true, get: function () { return storage_1.loadRecords; } });
+Object.defineProperty(exports, "collectBatch", { enumerable: true, get: function () { return storage_1.collectBatch; } });
+// Batch upload
+var batch_1 = require("./batch");
+Object.defineProperty(exports, "uploadBatch", { enumerable: true, get: function () { return batch_1.uploadBatch; } });
+// Wrap (Layer 1 — transparent client wrapper)
+var wrap_1 = require("./wrap");
+Object.defineProperty(exports, "wrap", { enumerable: true, get: function () { return wrap_1.wrap; } });
+// Track (decorator-style function tracking)
+var track_1 = require("./track");
+Object.defineProperty(exports, "track", { enumerable: true, get: function () { return track_1.track; } });
+// Crypto utilities
+var crypto_1 = require("./crypto");
+Object.defineProperty(exports, "sha256", { enumerable: true, get: function () { return crypto_1.sha256; } });
+Object.defineProperty(exports, "hashRecord", { enumerable: true, get: function () { return crypto_1.hashRecord; } });
+Object.defineProperty(exports, "buildMerkleRoot", { enumerable: true, get: function () { return crypto_1.buildMerkleRoot; } });
+Object.defineProperty(exports, "generateDID", { enumerable: true, get: function () { return crypto_1.generateDID; } });
+Object.defineProperty(exports, "verifySignature", { enumerable: true, get: function () { return crypto_1.verifySignature; } });

package/dist/record.d.ts

@@ -0,0 +1,20 @@
+/**
+ * ATLAST ECP Record — create and chain evidence records
+ */
+import type { ECPRecord, ECPIdentity } from './types';
+export declare function setChainHead(hash: string): void;
+export declare function getChainHead(): string;
+export interface CreateRecordOptions {
+    agentId: string;
+    stepType?: ECPRecord['step_type'];
+    model?: string;
+    input: string;
+    output: string;
+    tokensIn?: number;
+    tokensOut?: number;
+    latencyMs?: number;
+    flags?: string[];
+    metadata?: Record<string, unknown>;
+    identity?: ECPIdentity;
+}
+export declare function createRecord(opts: CreateRecordOptions): ECPRecord;

package/dist/record.js

@@ -0,0 +1,48 @@
+"use strict";
+/**
+ * ATLAST ECP Record — create and chain evidence records
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setChainHead = setChainHead;
+exports.getChainHead = getChainHead;
+exports.createRecord = createRecord;
+const crypto_1 = require("./crypto");
+let lastHash = 'genesis';
+function setChainHead(hash) {
+    lastHash = hash;
+}
+function getChainHead() {
+    return lastHash;
+}
+function createRecord(opts) {
+    const record = {
+        id: (0, crypto_1.generateId)('rec'),
+        ts: Date.now(),
+        agent_id: opts.agentId,
+        step_type: opts.stepType || 'llm_call',
+        model: opts.model,
+        input_hash: (0, crypto_1.sha256)(opts.input),
+        output_hash: (0, crypto_1.sha256)(opts.output),
+        tokens_in: opts.tokensIn,
+        tokens_out: opts.tokensOut,
+        latency_ms: opts.latencyMs,
+        flags: opts.flags || [],
+        metadata: opts.metadata,
+        chain: {
+            prev: lastHash,
+            hash: '',
+        },
+    };
+    // Detect signals
+    if (opts.latencyMs && opts.latencyMs > 5000) {
+        record.flags.push('high_latency');
+    }
+    // Compute chain hash
+    record.chain.hash = (0, crypto_1.hashRecord)(record);
+    // Sign if identity provided
+    if (opts.identity) {
+        record.sig = (0, crypto_1.signData)(opts.identity.private_key, record.chain.hash);
+    }
+    lastHash = record.chain.hash;
+    return record;
+}

package/dist/storage.d.ts

@@ -0,0 +1,10 @@
+/**
+ * ATLAST ECP Storage — local record storage (JSONL)
+ */
+import type { ECPRecord } from './types';
+export declare function storeRecord(agentId: string, record: ECPRecord): void;
+export declare function loadRecords(agentId: string): ECPRecord[];
+export declare function collectBatch(agentId: string, maxRecords?: number): {
+    records: ECPRecord[];
+    hashes: string[];
+};

package/dist/storage.js

@@ -0,0 +1,36 @@
+"use strict";
+/**
+ * ATLAST ECP Storage — local record storage (JSONL)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.storeRecord = storeRecord;
+exports.loadRecords = loadRecords;
+exports.collectBatch = collectBatch;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const identity_1 = require("./identity");
+function recordsPath(agentId) {
+    const dir = (0, path_1.join)((0, identity_1.getECPDir)(), 'agents', agentId);
+    if (!(0, fs_1.existsSync)(dir))
+        (0, fs_1.mkdirSync)(dir, { recursive: true });
+    return (0, path_1.join)(dir, 'records.jsonl');
+}
+function storeRecord(agentId, record) {
+    const path = recordsPath(agentId);
+    (0, fs_1.appendFileSync)(path, JSON.stringify(record) + '\n');
+}
+function loadRecords(agentId) {
+    const path = recordsPath(agentId);
+    if (!(0, fs_1.existsSync)(path))
+        return [];
+    return (0, fs_1.readFileSync)(path, 'utf-8')
+        .trim()
+        .split('\n')
+        .filter(Boolean)
+        .map((line) => JSON.parse(line));
+}
+function collectBatch(agentId, maxRecords = 100) {
+    const records = loadRecords(agentId).slice(-maxRecords);
+    const hashes = records.map((r) => r.chain.hash);
+    return { records, hashes };
+}

package/dist/track.d.ts

@@ -0,0 +1,20 @@
+/**
+ * ATLAST ECP Track — decorator-style tracking for agent functions
+ *
+ * Usage:
+ *   import { track } from '@atlast/sdk';
+ *
+ *   const myFunction = track('my-agent', async (input: string) => {
+ *     // ... agent logic
+ *     return result;
+ *   });
+ */
+export interface TrackOptions {
+    agentId: string;
+    stepType?: 'llm_call' | 'tool_call' | 'decision' | 'custom';
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Track a function's execution as an ECP record.
+ */
+export declare function track<TArgs extends unknown[], TResult>(agentIdOrOpts: string | TrackOptions, fn: (...args: TArgs) => Promise<TResult>): (...args: TArgs) => Promise<TResult>;

package/dist/track.js

@@ -0,0 +1,60 @@
+"use strict";
+/**
+ * ATLAST ECP Track — decorator-style tracking for agent functions
+ *
+ * Usage:
+ *   import { track } from '@atlast/sdk';
+ *
+ *   const myFunction = track('my-agent', async (input: string) => {
+ *     // ... agent logic
+ *     return result;
+ *   });
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.track = track;
+const record_1 = require("./record");
+const storage_1 = require("./storage");
+const identity_1 = require("./identity");
+/**
+ * Track a function's execution as an ECP record.
+ */
+function track(agentIdOrOpts, fn) {
+    const opts = typeof agentIdOrOpts === 'string' ? { agentId: agentIdOrOpts } : agentIdOrOpts;
+    const identity = (0, identity_1.loadOrCreateIdentity)(opts.agentId);
+    return async function tracked(...args) {
+        const startTime = Date.now();
+        const inputStr = JSON.stringify(args);
+        const flags = [];
+        let result;
+        try {
+            result = await fn(...args);
+        }
+        catch (e) {
+            flags.push('error');
+            const record = (0, record_1.createRecord)({
+                agentId: opts.agentId,
+                stepType: opts.stepType || 'custom',
+                input: inputStr,
+                output: `error: ${e.message}`,
+                latencyMs: Date.now() - startTime,
+                flags,
+                metadata: opts.metadata,
+                identity,
+            });
+            (0, storage_1.storeRecord)(opts.agentId, record);
+            throw e;
+        }
+        const record = (0, record_1.createRecord)({
+            agentId: opts.agentId,
+            stepType: opts.stepType || 'custom',
+            input: inputStr,
+            output: JSON.stringify(result),
+            latencyMs: Date.now() - startTime,
+            flags,
+            metadata: opts.metadata,
+            identity,
+        });
+        (0, storage_1.storeRecord)(opts.agentId, record);
+        return result;
+    };
+}

package/dist/types.d.ts

@@ -0,0 +1,65 @@
+/**
+ * ATLAST ECP Types — Evidence Chain Protocol data structures
+ */
+export interface ECPRecord {
+    id: string;
+    ts: number;
+    agent_id: string;
+    step_type: 'llm_call' | 'tool_call' | 'decision' | 'custom';
+    model?: string;
+    input_hash: string;
+    output_hash: string;
+    tokens_in?: number;
+    tokens_out?: number;
+    latency_ms?: number;
+    flags: string[];
+    metadata?: Record<string, unknown>;
+    chain: {
+        prev: string;
+        hash: string;
+    };
+    sig?: string;
+}
+export interface ECPIdentity {
+    did: string;
+    agent_id: string;
+    public_key: string;
+    private_key: string;
+    created_at: string;
+}
+export interface BatchUploadRequest {
+    agent_did: string;
+    merkle_root: string;
+    record_count: number;
+    avg_latency_ms: number;
+    batch_ts: number;
+    sig: string;
+    ecp_version: string;
+    flag_counts?: Record<string, number>;
+    record_hashes?: Array<{
+        id: string;
+        hash: string;
+        flags?: string[];
+    }>;
+}
+export interface BatchUploadResponse {
+    batch_id: string;
+    attestation_uid?: string;
+    eas_url?: string;
+    status: string;
+    message: string;
+}
+export interface ATLASTConfig {
+    apiUrl?: string;
+    apiKey?: string;
+    ecpDir?: string;
+    agentId: string;
+    autoUpload?: boolean;
+    batchSize?: number;
+    flushIntervalMs?: number;
+}
+export interface LocalConfig {
+    agent_did?: string;
+    agent_api_key?: string;
+    endpoint?: string;
+}

package/dist/types.js

@@ -0,0 +1,5 @@
+"use strict";
+/**
+ * ATLAST ECP Types — Evidence Chain Protocol data structures
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/wrap.d.ts

@@ -0,0 +1,18 @@
+/**
+ * ATLAST ECP Wrap — transparent LLM client wrapper (Layer 1)
+ *
+ * Usage:
+ *   import { wrap } from '@atlast/sdk';
+ *   const client = wrap(new OpenAI(), { agentId: 'my-agent' });
+ *   // All chat.completions.create() calls are now tracked
+ */
+export interface WrapOptions {
+    agentId: string;
+    apiUrl?: string;
+    autoUpload?: boolean;
+}
+/**
+ * Wrap an OpenAI-compatible client to automatically record ECP evidence.
+ * Intercepts chat.completions.create() calls.
+ */
+export declare function wrap<T extends object>(client: T, options: WrapOptions): T;

package/dist/wrap.js

@@ -0,0 +1,83 @@
+"use strict";
+/**
+ * ATLAST ECP Wrap — transparent LLM client wrapper (Layer 1)
+ *
+ * Usage:
+ *   import { wrap } from '@atlast/sdk';
+ *   const client = wrap(new OpenAI(), { agentId: 'my-agent' });
+ *   // All chat.completions.create() calls are now tracked
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wrap = wrap;
+const record_1 = require("./record");
+const storage_1 = require("./storage");
+const identity_1 = require("./identity");
+/**
+ * Wrap an OpenAI-compatible client to automatically record ECP evidence.
+ * Intercepts chat.completions.create() calls.
+ */
+function wrap(client, options) {
+    const identity = (0, identity_1.loadOrCreateIdentity)(options.agentId);
+    // Deep proxy to intercept chat.completions.create
+    return new Proxy(client, {
+        get(target, prop, receiver) {
+            const value = Reflect.get(target, prop, receiver);
+            if (prop === 'chat' && typeof value === 'object' && value !== null) {
+                return new Proxy(value, {
+                    get(chatTarget, chatProp, chatReceiver) {
+                        const chatValue = Reflect.get(chatTarget, chatProp, chatReceiver);
+                        if (chatProp === 'completions' && typeof chatValue === 'object' && chatValue !== null) {
+                            return new Proxy(chatValue, {
+                                get(compTarget, compProp, compReceiver) {
+                                    const compValue = Reflect.get(compTarget, compProp, compReceiver);
+                                    if (compProp === 'create' && typeof compValue === 'function') {
+                                        return async function wrappedCreate(...args) {
+                                            const startTime = Date.now();
+                                            const params = args[0];
+                                            const inputStr = JSON.stringify(params?.messages || '');
+                                            let result;
+                                            let error;
+                                            const flags = [];
+                                            try {
+                                                result = await compValue.apply(compTarget, args);
+                                            }
+                                            catch (e) {
+                                                error = e;
+                                                flags.push('error');
+                                                throw e;
+                                            }
+                                            finally {
+                                                const latencyMs = Date.now() - startTime;
+                                                const outputStr = error
+                                                    ? `error: ${error.message}`
+                                                    : JSON.stringify(result?.choices || '');
+                                                const usage = result?.usage;
+                                                const record = (0, record_1.createRecord)({
+                                                    agentId: options.agentId,
+                                                    stepType: 'llm_call',
+                                                    model: params?.model,
+                                                    input: inputStr,
+                                                    output: outputStr,
+                                                    tokensIn: usage?.prompt_tokens,
+                                                    tokensOut: usage?.completion_tokens,
+                                                    latencyMs,
+                                                    flags,
+                                                    identity,
+                                                });
+                                                (0, storage_1.storeRecord)(options.agentId, record);
+                                            }
+                                            return result;
+                                        };
+                                    }
+                                    return compValue;
+                                },
+                            });
+                        }
+                        return chatValue;
+                    },
+                });
+            }
+            return value;
+        },
+    });
+}

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "atlast-ecp-ts",
+  "version": "0.1.0",
+  "description": "ATLAST ECP SDK for TypeScript/Node.js — Evidence Chain Protocol for AI agents",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "test": "vitest run",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "atlast",
+    "ecp",
+    "ai-agent",
+    "trust",
+    "evidence-chain"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/willau95/atlast-sdk-ts"
+  },
+  "devDependencies": {
+    "@types/node": "^25.5.0",
+    "typescript": "^5.4.0",
+    "vitest": "^3.0.0"
+  }
+}