@lawreneliang/atel-sdk 0.1.0

package/dist/trust/index.d.ts

@@ -0,0 +1,84 @@
+/**
+ * Module: Trust Manager
+ *
+ * Unified trust management combining TrustScoreClient and TrustGraph.
+ * Provides a single entry point for submitting execution results and
+ * querying comprehensive trust information.
+ */
+import { TrustScoreClient, type ExecutionSummary, type ScoreReport } from '../score/index.js';
+import { TrustGraph, type TrustResult } from '../graph/index.js';
+/** Extended execution summary that includes issuer for graph updates */
+export interface TrustSubmission extends ExecutionSummary {
+    /** DID of the agent that delegated the task (issuer) */
+    issuer: string;
+    /** Scene/category for graph classification (defaults to task_type) */
+    scene?: string;
+    /** Max cost of the task (used for weight calculation) */
+    max_cost?: number;
+    /** Number of similar tasks previously executed (for novelty) */
+    similar_task_count?: number;
+}
+/** Comprehensive trust query result */
+export interface ComprehensiveTrust {
+    /** Trust score from the graph (0–1 range, composite) */
+    graphTrust: TrustResult;
+    /** Score report from the score client (0–100 range) */
+    scoreReport: ScoreReport;
+    /** Combined trust score (normalized 0–1) */
+    combinedScore: number;
+}
+/**
+ * Unified trust manager that coordinates TrustScoreClient and TrustGraph.
+ *
+ * Provides:
+ * - `submitResult()` — updates both score and graph in one call
+ * - `queryTrust()` — returns comprehensive trust combining both systems
+ */
+export declare class TrustManager {
+    /** The underlying score client */
+    readonly scoreClient: TrustScoreClient;
+    /** The underlying trust graph */
+    readonly graph: TrustGraph;
+    constructor(options?: {
+        scoreClient?: TrustScoreClient;
+        graph?: TrustGraph;
+    });
+    /**
+     * Submit an execution result, updating both the score client and trust graph.
+     *
+     * @param submission - The execution result with issuer information.
+     */
+    submitResult(submission: TrustSubmission): void;
+    /**
+     * Query comprehensive trust between two agents for a given scene.
+     *
+     * Combines graph-based trust (composite) with score-based reputation
+     * into a single normalized score.
+     *
+     * @param from - The querying agent's DID.
+     * @param to - The target agent's DID.
+     * @param scene - The scene/category to query trust for.
+     * @returns Comprehensive trust information.
+     */
+    queryTrust(from: string, to: string, scene: string): ComprehensiveTrust;
+    /**
+     * Get the score report for a specific agent.
+     *
+     * @param agentId - The agent's DID.
+     * @returns The score report.
+     */
+    getAgentScore(agentId: string): ScoreReport;
+    /**
+     * Get the graph trust between two agents.
+     *
+     * @param from - Source agent DID.
+     * @param to - Target agent DID.
+     * @param scene - Scene/category.
+     * @returns Trust result from the graph.
+     */
+    getGraphTrust(from: string, to: string, scene: string): TrustResult;
+    /**
+     * Estimate max_cost from risk level for weight calculation.
+     */
+    private _estimateCost;
+}

package/dist/trust/index.js

@@ -0,0 +1,107 @@
+/**
+ * Module: Trust Manager
+ *
+ * Unified trust management combining TrustScoreClient and TrustGraph.
+ * Provides a single entry point for submitting execution results and
+ * querying comprehensive trust information.
+ */
+import { TrustScoreClient, } from '../score/index.js';
+import { TrustGraph, calculateTaskWeight, } from '../graph/index.js';
+// ─── TrustManager ────────────────────────────────────────────────
+/**
+ * Unified trust manager that coordinates TrustScoreClient and TrustGraph.
+ *
+ * Provides:
+ * - `submitResult()` — updates both score and graph in one call
+ * - `queryTrust()` — returns comprehensive trust combining both systems
+ */
+export class TrustManager {
+    /** The underlying score client */
+    scoreClient;
+    /** The underlying trust graph */
+    graph;
+    constructor(options) {
+        this.scoreClient = options?.scoreClient ?? new TrustScoreClient();
+        this.graph = options?.graph ?? new TrustGraph();
+    }
+    /**
+     * Submit an execution result, updating both the score client and trust graph.
+     *
+     * @param submission - The execution result with issuer information.
+     */
+    submitResult(submission) {
+        // 1. Submit to TrustScoreClient
+        this.scoreClient.submitExecutionSummary(submission);
+        // 2. Calculate task weight for graph
+        const taskWeight = calculateTaskWeight({
+            tool_calls: submission.tool_calls,
+            duration_ms: submission.duration_ms,
+            max_cost: submission.max_cost ?? this._estimateCost(submission.risk_level),
+            risk_level: submission.risk_level,
+            similar_task_count: submission.similar_task_count ?? 0,
+        });
+        // 3. Update TrustGraph
+        this.graph.recordInteraction({
+            from: submission.issuer,
+            to: submission.executor,
+            scene: submission.scene ?? submission.task_type,
+            success: submission.success,
+            task_weight: taskWeight,
+            duration_ms: submission.duration_ms,
+        });
+    }
+    /**
+     * Query comprehensive trust between two agents for a given scene.
+     *
+     * Combines graph-based trust (composite) with score-based reputation
+     * into a single normalized score.
+     *
+     * @param from - The querying agent's DID.
+     * @param to - The target agent's DID.
+     * @param scene - The scene/category to query trust for.
+     * @returns Comprehensive trust information.
+     */
+    queryTrust(from, to, scene) {
+        const graphTrust = this.graph.compositeTrust(from, to, scene);
+        const scoreReport = this.scoreClient.getAgentScore(to);
+        // Combine: 60% graph trust + 40% normalized score
+        const normalizedScore = scoreReport.trust_score / 100;
+        const combinedScore = 0.6 * graphTrust.trust_score + 0.4 * normalizedScore;
+        return {
+            graphTrust,
+            scoreReport,
+            combinedScore,
+        };
+    }
+    /**
+     * Get the score report for a specific agent.
+     *
+     * @param agentId - The agent's DID.
+     * @returns The score report.
+     */
+    getAgentScore(agentId) {
+        return this.scoreClient.getAgentScore(agentId);
+    }
+    /**
+     * Get the graph trust between two agents.
+     *
+     * @param from - Source agent DID.
+     * @param to - Target agent DID.
+     * @param scene - Scene/category.
+     * @returns Trust result from the graph.
+     */
+    getGraphTrust(from, to, scene) {
+        return this.graph.compositeTrust(from, to, scene);
+    }
+    /**
+     * Estimate max_cost from risk level for weight calculation.
+     */
+    _estimateCost(riskLevel) {
+        switch (riskLevel) {
+            case 'critical': return 10;
+            case 'high': return 5;
+            case 'medium': return 2;
+            default: return 1;
+        }
+    }
+}

package/dist/trust-sync/index.d.ts

@@ -0,0 +1,30 @@
+import type { TrustSubmission } from '../trust/index.js';
+export interface TrustSyncResult {
+    synced: boolean;
+    reference?: string;
+    detail?: string;
+}
+export interface TrustSyncAdapter {
+    submit(submission: TrustSubmission): Promise<TrustSyncResult>;
+}
+export interface HttpTrustSyncAdapterOptions {
+    /** Base URL of TrustScoreService, e.g. http://localhost:3100 */
+    baseUrl: string;
+    /** Request timeout in milliseconds */
+    timeoutMs?: number;
+    /** Optional bearer token */
+    bearerToken?: string;
+}
+/**
+ * Default network trust sync adapter for self-hosted TrustScoreService.
+ *
+ * Sends execution summary to:
+ *   POST {baseUrl}/api/v1/summary
+ */
+export declare class HttpTrustSyncAdapter implements TrustSyncAdapter {
+    private readonly baseUrl;
+    private readonly timeoutMs;
+    private readonly bearerToken?;
+    constructor(options: HttpTrustSyncAdapterOptions);
+    submit(submission: TrustSubmission): Promise<TrustSyncResult>;
+}

package/dist/trust-sync/index.js

@@ -0,0 +1,57 @@
+/**
+ * Default network trust sync adapter for self-hosted TrustScoreService.
+ *
+ * Sends execution summary to:
+ *   POST {baseUrl}/api/v1/summary
+ */
+export class HttpTrustSyncAdapter {
+    baseUrl;
+    timeoutMs;
+    bearerToken;
+    constructor(options) {
+        this.baseUrl = options.baseUrl.replace(/\/+$/, '');
+        this.timeoutMs = options.timeoutMs ?? 10_000;
+        this.bearerToken = options.bearerToken;
+    }
+    async submit(submission) {
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), this.timeoutMs);
+        const headers = {
+            'Content-Type': 'application/json',
+        };
+        if (this.bearerToken) {
+            headers.Authorization = `Bearer ${this.bearerToken}`;
+        }
+        try {
+            const response = await fetch(`${this.baseUrl}/api/v1/summary`, {
+                method: 'POST',
+                headers,
+                body: JSON.stringify(submission),
+                signal: controller.signal,
+            });
+            if (!response.ok) {
+                const text = await response.text();
+                return {
+                    synced: false,
+                    detail: `HTTP ${response.status}: ${text || response.statusText}`,
+                };
+            }
+            const body = await response.json();
+            return {
+                synced: true,
+                reference: body.agent_id ?? submission.executor,
+                detail: body.last_updated ? `updated_at=${body.last_updated}` : 'ok',
+            };
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            return {
+                synced: false,
+                detail: message,
+            };
+        }
+        finally {
+            clearTimeout(timeout);
+        }
+    }
+}

package/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "@lawreneliang/atel-sdk",
+  "version": "0.1.0",
+  "description": "ATEL Protocol SDK - Agent Trust & Economics Layer",
+  "type": "module",
+  "main": "./dist/index.js",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc",
+    "clean": "rm -rf dist",
+    "test": "vitest --run",
+    "test:perf": "vitest --run tests/performance.test.ts",
+    "wallets:generate": "tsx scripts/generate-test-wallets.ts",
+    "run:cluster": "tsx scripts/agent-cluster-runner.ts",
+    "acceptance:deploy": "tsx scripts/deploy-acceptance.ts",
+    "doctor": "tsx scripts/doctor.ts",
+    "quickstart:local": "tsx demo/quickstart-local.ts",
+    "quickstart:network": "tsx demo/quickstart-network.ts",
+    "demo:real": "tsx demo/real-api-demo.ts",
+    "smoke:anchor": "tsx scripts/testnet-anchor-smoke.ts",
+    "serve": "tsx src/service/server.ts",
+    "prepublishOnly": "npm run clean && npm run build && npm test"
+  },
+  "dependencies": {
+    "@solana/web3.js": "^1.98.4",
+    "ajv": "^8.17.1",
+    "ajv-formats": "^3.0.1",
+    "bs58": "^6.0.0",
+    "ethers": "^6.16.0",
+    "express": "^5.2.1",
+    "tweetnacl": "^1.0.3",
+    "uuid": "^11.1.0"
+  },
+  "devDependencies": {
+    "@types/express": "^5.0.6",
+    "@types/node": "^25.2.3",
+    "@types/supertest": "^6.0.3",
+    "@types/uuid": "^10.0.0",
+    "supertest": "^7.2.2",
+    "tsx": "^4.21.0",
+    "typescript": "^5.7.0",
+    "vitest": "^3.2.4"
+  },
+  "license": "MIT"
+}