@rubric-protocol/sdk 1.0.1

package/dist/index.d.ts

@@ -0,0 +1,126 @@
+/**
+ * RUBRIC PROTOCOL SDK
+ * AI Attestation Infrastructure — EU AI Act Article 12 Compliance
+ * Rubric Protocol
+ */
+export interface RubricConfig {
+    baseUrl: string;
+    apiKey: string;
+}
+export interface Agent {
+    agentId: string;
+    name: string;
+    capabilities: {
+        name: string;
+        description: string;
+    }[];
+    endpoint: string;
+    status: string;
+    reputation: {
+        tasksCompleted: number;
+        successRate: number;
+        score?: number;
+    };
+}
+export interface Task {
+    taskId: string;
+    type: string;
+    description: string;
+    status: string;
+    bids: Bid[];
+    assignment: any;
+    result: TaskResult | null;
+}
+export interface Bid {
+    bidId: string;
+    agentId: string;
+    cost: number;
+    estimatedTime: number;
+    confidence: number;
+}
+export interface TaskResult {
+    agentId: string;
+    output: any;
+    executionTime: number;
+    completedAt: string;
+    attestationId: string;
+}
+export interface Pipeline {
+    pipelineId: string;
+    name: string;
+    status: string;
+    steps: PipelineStep[];
+    attestations: string[];
+    completedAt?: string;
+}
+export interface PipelineStep {
+    stepIndex: number;
+    type: string;
+    description: string;
+    status: string;
+    attestationId?: string;
+    output?: any;
+}
+export interface Proof {
+    sequenceNumber: string;
+    topic: string;
+    explorer: string;
+    task: any;
+    pipeline: any;
+    verified: boolean;
+    network: string;
+}
+export declare class RubricClient {
+    private baseUrl;
+    private apiKey;
+    constructor(config: RubricConfig);
+    private request;
+    health(): Promise<any>;
+    stats(): Promise<any>;
+    registerAgent(name: string, capabilities: {
+        name: string;
+        description: string;
+    }[], endpoint: string): Promise<Agent>;
+    listAgents(capability?: string): Promise<{
+        data: Agent[];
+        total: number;
+    }>;
+    getAgent(agentId: string): Promise<Agent>;
+    deregisterAgent(agentId: string): Promise<any>;
+    getReputation(agentId: string): Promise<any>;
+    leaderboard(): Promise<any>;
+    submitTask(type: string, description: string, input?: any): Promise<Task>;
+    listTasks(): Promise<{
+        data: Task[];
+        total: number;
+    }>;
+    getTask(taskId: string): Promise<Task>;
+    placeBid(taskId: string, agentId: string, cost: number, estimatedTime: number, confidence: number): Promise<Bid>;
+    assignTask(taskId: string): Promise<any>;
+    submitResult(taskId: string, agentId: string, output: any, executionTime: number): Promise<TaskResult>;
+    createPipeline(name: string, steps: {
+        type: string;
+        capability: string;
+        description: string;
+    }[]): Promise<Pipeline>;
+    listPipelines(): Promise<{
+        data: Pipeline[];
+        total: number;
+    }>;
+    getPipeline(pipelineId: string): Promise<Pipeline>;
+    startPipeline(pipelineId: string, input?: any): Promise<any>;
+    completeStep(pipelineId: string, agentId: string, output: any, executionTime: number): Promise<any>;
+    verify(sequenceNumber: string): Promise<Proof>;
+    events(limit?: number, type?: string): Promise<any>;
+    runTask(agentId: string, type: string, description: string, output: any, executionTime?: number): Promise<TaskResult>;
+    runPipeline(name: string, steps: {
+        type: string;
+        capability: string;
+        description: string;
+        output: any;
+    }[], input?: any): Promise<{
+        pipeline: Pipeline;
+        attestations: string[];
+    }>;
+}
+export default RubricClient;

package/dist/index.js

@@ -0,0 +1,117 @@
+"use strict";
+/**
+ * RUBRIC PROTOCOL SDK
+ * AI Attestation Infrastructure — EU AI Act Article 12 Compliance
+ * Rubric Protocol
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RubricClient = void 0;
+class RubricClient {
+    constructor(config) {
+        this.baseUrl = config.baseUrl.replace(/\/$/, '');
+        this.apiKey = config.apiKey;
+    }
+    async request(method, path, body) {
+        const headers = { 'Content-Type': 'application/json' };
+        if (this.apiKey)
+            headers['x-api-key'] = this.apiKey;
+        const opts = { method, headers };
+        if (body)
+            opts.body = JSON.stringify(body);
+        const res = await fetch(`${this.baseUrl}${path}`, opts);
+        if (!res.ok) {
+            const err = await res.json().catch(() => ({ error: res.statusText }));
+            throw new Error(err.error || `HTTP ${res.status}`);
+        }
+        return res.json();
+    }
+    // ── Health ──
+    async health() { return this.request('GET', '/'); }
+    async stats() { return this.request('GET', '/v1/stats'); }
+    // ── Agents ──
+    async registerAgent(name, capabilities, endpoint) {
+        return this.request('POST', '/v1/agents', { name, capabilities, endpoint });
+    }
+    async listAgents(capability) {
+        const q = capability ? `?capability=${capability}` : '';
+        return this.request('GET', `/v1/agents${q}`);
+    }
+    async getAgent(agentId) {
+        return this.request('GET', `/v1/agents/${agentId}`);
+    }
+    async deregisterAgent(agentId) {
+        return this.request('DELETE', `/v1/agents/${agentId}`);
+    }
+    async getReputation(agentId) {
+        return this.request('GET', `/v1/agents/${agentId}/reputation`);
+    }
+    async leaderboard() {
+        return this.request('GET', '/v1/leaderboard');
+    }
+    // ── Tasks ──
+    async submitTask(type, description, input) {
+        return this.request('POST', '/v1/tasks', { type, description, input });
+    }
+    async listTasks() {
+        return this.request('GET', '/v1/tasks');
+    }
+    async getTask(taskId) {
+        return this.request('GET', `/v1/tasks/${taskId}`);
+    }
+    async placeBid(taskId, agentId, cost, estimatedTime, confidence) {
+        return this.request('POST', `/v1/tasks/${taskId}/bid`, { agentId, cost, estimatedTime, confidence });
+    }
+    async assignTask(taskId) {
+        return this.request('POST', `/v1/tasks/${taskId}/assign`, {});
+    }
+    async submitResult(taskId, agentId, output, executionTime) {
+        return this.request('POST', `/v1/tasks/${taskId}/result`, { agentId, output, executionTime });
+    }
+    // ── Pipelines ──
+    async createPipeline(name, steps) {
+        return this.request('POST', '/v1/pipelines', { name, steps });
+    }
+    async listPipelines() {
+        return this.request('GET', '/v1/pipelines');
+    }
+    async getPipeline(pipelineId) {
+        return this.request('GET', `/v1/pipelines/${pipelineId}`);
+    }
+    async startPipeline(pipelineId, input) {
+        return this.request('POST', `/v1/pipelines/${pipelineId}/start`, { input });
+    }
+    async completeStep(pipelineId, agentId, output, executionTime) {
+        return this.request('POST', `/v1/pipelines/${pipelineId}/step-result`, { agentId, output, executionTime });
+    }
+    // ── Proof ──
+    async verify(sequenceNumber) {
+        return this.request('GET', `/v1/proof/${sequenceNumber}`);
+    }
+    // ── Events ──
+    async events(limit = 50, type) {
+        const params = [`limit=${limit}`];
+        if (type)
+            params.push(`type=${type}`);
+        return this.request('GET', `/v1/events?${params.join('&')}`);
+    }
+    // ── Convenience: Run full task lifecycle ──
+    async runTask(agentId, type, description, output, executionTime = 2000) {
+        const task = await this.submitTask(type, description);
+        await this.placeBid(task.taskId, agentId, 500, 3000, 0.95);
+        await this.assignTask(task.taskId);
+        return this.submitResult(task.taskId, agentId, output, executionTime);
+    }
+    // ── Convenience: Run full pipeline ──
+    async runPipeline(name, steps, input) {
+        const pipeline = await this.createPipeline(name, steps.map(s => ({ type: s.type, capability: s.capability, description: s.description })));
+        await this.startPipeline(pipeline.pipelineId, input);
+        let result;
+        for (const step of steps) {
+            result = await this.completeStep(pipeline.pipelineId, 'sdk-auto', step.output, 2000);
+        }
+        return { pipeline: await this.getPipeline(pipeline.pipelineId), attestations: result.attestations || [] };
+    }
+}
+exports.RubricClient = RubricClient;
+// Default export
+exports.default = RubricClient;

package/example.ts

@@ -0,0 +1,39 @@
+import { RubricClient } from './index';
+
+const tempus = new RubricClient({
+  baseUrl: 'http://155.138.228.65/forge',
+  apiKey: 'rubric-dev-key-2026'
+});
+
+async function main() {
+  // Register an agent
+  const agent = await tempus.registerAgent('MyBot', [
+    { name: 'analysis', description: 'Data analysis' }
+  ], 'http://localhost:8080');
+  console.log('Agent:', agent.name, agent.agentId);
+
+  // Run a single task (full lifecycle)
+  const result = await tempus.runTask(
+    agent.agentId, 'analysis', 'HBAR trend check',
+    { trend: 'bullish', confidence: 0.9 }
+  );
+  console.log('Result attested on HCS #' + result.attestationId);
+
+  // Verify the proof
+  const proof = await tempus.verify(result.attestationId);
+  console.log('Verified:', proof.verified, '| Topic:', proof.topic);
+
+  // Run a pipeline
+  const { attestations } = await tempus.runPipeline('SDK Demo', [
+    { type: 'collect', capability: 'research', description: 'Gather data', output: { data: [1,2,3] } },
+    { type: 'analyze', capability: 'analysis', description: 'Analyze', output: { trend: 'up' } },
+    { type: 'report', capability: 'writing', description: 'Write report', output: { report: 'HBAR bullish' } }
+  ]);
+  console.log('Pipeline complete! HCS attestations:', attestations);
+
+  // Check leaderboard
+  const board = await tempus.leaderboard();
+  console.log('Leaderboard:', board.data);
+}
+
+main().catch(console.error);

package/index.ts

@@ -0,0 +1,192 @@
+/**
+ * RUBRIC PROTOCOL SDK
+ * AI Attestation Infrastructure — EU AI Act Article 12 Compliance
+ * Rubric Protocol
+ */
+
+export interface RubricConfig {
+  baseUrl: string;
+  apiKey: string;
+}
+
+export interface Agent {
+  agentId: string;
+  name: string;
+  capabilities: { name: string; description: string }[];
+  endpoint: string;
+  status: string;
+  reputation: { tasksCompleted: number; successRate: number; score?: number };
+}
+
+export interface Task {
+  taskId: string;
+  type: string;
+  description: string;
+  status: string;
+  bids: Bid[];
+  assignment: any;
+  result: TaskResult | null;
+}
+
+export interface Bid {
+  bidId: string;
+  agentId: string;
+  cost: number;
+  estimatedTime: number;
+  confidence: number;
+}
+
+export interface TaskResult {
+  agentId: string;
+  output: any;
+  executionTime: number;
+  completedAt: string;
+  attestationId: string;
+}
+
+export interface Pipeline {
+  pipelineId: string;
+  name: string;
+  status: string;
+  steps: PipelineStep[];
+  attestations: string[];
+  completedAt?: string;
+}
+
+export interface PipelineStep {
+  stepIndex: number;
+  type: string;
+  description: string;
+  status: string;
+  attestationId?: string;
+  output?: any;
+}
+
+export interface Proof {
+  sequenceNumber: string;
+  topic: string;
+  explorer: string;
+  task: any;
+  pipeline: any;
+  verified: boolean;
+  network: string;
+}
+
+export class RubricClient {
+  private baseUrl: string;
+  private apiKey: string;
+
+  constructor(config: RubricConfig) {
+    this.baseUrl = config.baseUrl.replace(/\/$/, '');
+    this.apiKey = config.apiKey;
+  }
+
+  private async request(method: string, path: string, body?: any): Promise<any> {
+    const headers: Record<string, string> = { 'Content-Type': 'application/json' };
+    if (this.apiKey) headers['x-api-key'] = this.apiKey;
+    const opts: RequestInit = { method, headers };
+    if (body) opts.body = JSON.stringify(body);
+    const res = await fetch(`${this.baseUrl}${path}`, opts);
+    if (!res.ok) {
+      const err = await res.json().catch(() => ({ error: res.statusText }));
+      throw new Error(err.error || `HTTP ${res.status}`);
+    }
+    return res.json();
+  }
+
+  // ── Health ──
+  async health() { return this.request('GET', '/'); }
+  async stats() { return this.request('GET', '/v1/stats'); }
+
+  // ── Agents ──
+  async registerAgent(name: string, capabilities: { name: string; description: string }[], endpoint: string): Promise<Agent> {
+    return this.request('POST', '/v1/agents', { name, capabilities, endpoint });
+  }
+  async listAgents(capability?: string): Promise<{ data: Agent[]; total: number }> {
+    const q = capability ? `?capability=${capability}` : '';
+    return this.request('GET', `/v1/agents${q}`);
+  }
+  async getAgent(agentId: string): Promise<Agent> {
+    return this.request('GET', `/v1/agents/${agentId}`);
+  }
+  async deregisterAgent(agentId: string) {
+    return this.request('DELETE', `/v1/agents/${agentId}`);
+  }
+  async getReputation(agentId: string) {
+    return this.request('GET', `/v1/agents/${agentId}/reputation`);
+  }
+  async leaderboard() {
+    return this.request('GET', '/v1/leaderboard');
+  }
+
+  // ── Tasks ──
+  async submitTask(type: string, description: string, input?: any): Promise<Task> {
+    return this.request('POST', '/v1/tasks', { type, description, input });
+  }
+  async listTasks(): Promise<{ data: Task[]; total: number }> {
+    return this.request('GET', '/v1/tasks');
+  }
+  async getTask(taskId: string): Promise<Task> {
+    return this.request('GET', `/v1/tasks/${taskId}`);
+  }
+  async placeBid(taskId: string, agentId: string, cost: number, estimatedTime: number, confidence: number): Promise<Bid> {
+    return this.request('POST', `/v1/tasks/${taskId}/bid`, { agentId, cost, estimatedTime, confidence });
+  }
+  async assignTask(taskId: string) {
+    return this.request('POST', `/v1/tasks/${taskId}/assign`, {});
+  }
+  async submitResult(taskId: string, agentId: string, output: any, executionTime: number): Promise<TaskResult> {
+    return this.request('POST', `/v1/tasks/${taskId}/result`, { agentId, output, executionTime });
+  }
+
+  // ── Pipelines ──
+  async createPipeline(name: string, steps: { type: string; capability: string; description: string }[]): Promise<Pipeline> {
+    return this.request('POST', '/v1/pipelines', { name, steps });
+  }
+  async listPipelines(): Promise<{ data: Pipeline[]; total: number }> {
+    return this.request('GET', '/v1/pipelines');
+  }
+  async getPipeline(pipelineId: string): Promise<Pipeline> {
+    return this.request('GET', `/v1/pipelines/${pipelineId}`);
+  }
+  async startPipeline(pipelineId: string, input?: any) {
+    return this.request('POST', `/v1/pipelines/${pipelineId}/start`, { input });
+  }
+  async completeStep(pipelineId: string, agentId: string, output: any, executionTime: number) {
+    return this.request('POST', `/v1/pipelines/${pipelineId}/step-result`, { agentId, output, executionTime });
+  }
+
+  // ── Proof ──
+  async verify(sequenceNumber: string): Promise<Proof> {
+    return this.request('GET', `/v1/proof/${sequenceNumber}`);
+  }
+
+  // ── Events ──
+  async events(limit = 50, type?: string) {
+    const params = [`limit=${limit}`];
+    if (type) params.push(`type=${type}`);
+    return this.request('GET', `/v1/events?${params.join('&')}`);
+  }
+
+  // ── Convenience: Run full task lifecycle ──
+  async runTask(agentId: string, type: string, description: string, output: any, executionTime = 2000): Promise<TaskResult> {
+    const task = await this.submitTask(type, description);
+    await this.placeBid(task.taskId, agentId, 500, 3000, 0.95);
+    await this.assignTask(task.taskId);
+    return this.submitResult(task.taskId, agentId, output, executionTime);
+  }
+
+  // ── Convenience: Run full pipeline ──
+  async runPipeline(name: string, steps: { type: string; capability: string; description: string; output: any }[], input?: any): Promise<{ pipeline: Pipeline; attestations: string[] }> {
+    const pipeline = await this.createPipeline(name, steps.map(s => ({ type: s.type, capability: s.capability, description: s.description })));
+    await this.startPipeline(pipeline.pipelineId, input);
+    let result: any;
+    for (const step of steps) {
+      result = await this.completeStep(pipeline.pipelineId, 'sdk-auto', step.output, 2000);
+    }
+    return { pipeline: await this.getPipeline(pipeline.pipelineId), attestations: result.attestations || [] };
+  }
+}
+
+// Default export
+export default RubricClient;

package/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "@rubric-protocol/sdk",
+  "version": "1.0.1",
+  "description": "Rubric Protocol SDK — AI agent coordination on Hedera",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "license": "MIT",
+  "author": "Rubric Protocol",
+  "repository": "https://github.com/rubric-protocol/sdk",
+  "keywords": [
+    "hedera",
+    "hcs",
+    "ai-attestation",
+    "eu-ai-act",
+    "blockchain"
+  ],
+  "dependencies": {},
+  "devDependencies": {
+    "typescript": "^5.0.0"
+  }
+}

package/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "commonjs",
+    "declaration": true,
+    "outDir": "./dist",
+    "rootDir": "./",
+    "strict": false,
+    "skipLibCheck": true,
+    "esModuleInterop": true
+  },
+  "include": ["index.ts"],
+  "exclude": ["node_modules", "dist", "example.ts"]
+}