voicegate 0.1.0

package/README.md

@@ -0,0 +1,23 @@
+# voicegate (Node.js)
+
+Node.js SDK for [VoiceGate](https://aivoicegate.com) — voice infrastructure for AI agents, with KYA agent identity (by CallsFlow Ltd).
+
+```bash
+npm install voicegate
+```
+
+```js
+const { VoiceGate, AgentKey } = require('voicegate');
+
+const vg = new VoiceGate({ kyaUrl: 'https://aivoicegate.com' });
+const key = AgentKey.generate();
+const reg = await vg.kyaRegister(key, 'ops@your-company.com', 'your-agent.com');
+const credential = await vg.kyaGetCredential(key, reg.agent_id);
+await vg.kyaLogin(key, credential);
+console.log(await vg.me());
+```
+
+Full docs and the voice-call quick start: see the [repository README](../README.md).
+Runnable examples: [`examples/`](examples).
+
+Requires Node.js 18+ (global `fetch`). Zero runtime dependencies.

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "voicegate",
+  "version": "0.1.0",
+  "description": "Node.js SDK for VoiceGate — voice infrastructure for AI agents, with KYA agent identity (by CallsFlow Ltd)",
+  "main": "src/index.js",
+  "types": "src/index.d.ts",
+  "files": ["src"],
+  "scripts": {
+    "test": "node examples/kya_identity.js || true"
+  },
+  "keywords": [
+    "ai agents",
+    "voice api",
+    "telephony",
+    "verifiable credentials",
+    "erc-8004",
+    "kya",
+    "voicegate"
+  ],
+  "author": "CallsFlow Ltd",
+  "license": "MIT",
+  "homepage": "https://aivoicegate.com",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/IgorSokhinov/voicegate-sdk.git"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}

package/src/index.d.ts

@@ -0,0 +1,39 @@
+export interface VoiceGateOptions {
+  baseUrl?: string;
+  kyaUrl?: string;
+  apiKey?: string | null;
+  timeout?: number;
+}
+
+export interface CallParams {
+  to: string;
+  agentWebhook: string;
+  voice?: 'female' | 'male';
+  language?: string;
+  initialMessage?: string;
+}
+
+/** An agent's Ed25519 keypair — its cryptographic identity. */
+export class AgentKey {
+  static generate(): AgentKey;
+  static fromSeedB64(seedB64: string): AgentKey;
+  seedB64(): string;
+  rawPub(): Buffer;
+  readonly did: string;
+  signB64url(message: string): string;
+}
+
+export class VoiceGateError extends Error {
+  status: number;
+  body: string;
+}
+
+export class VoiceGate {
+  constructor(opts?: VoiceGateOptions);
+  call(params: CallParams): Promise<unknown>;
+  kyaRegister(key: AgentKey, operatorEmail: string, domain?: string): Promise<{ agent_id: string; kyc_status: string; [k: string]: unknown }>;
+  kyaGetCredential(key: AgentKey, agentId: string): Promise<Record<string, unknown>>;
+  kyaLogin(key: AgentKey, credential: Record<string, unknown>): Promise<{ access_token: string; [k: string]: unknown }>;
+  me(): Promise<Record<string, unknown>>;
+  issuer(): Promise<Record<string, unknown>>;
+}

package/src/index.js

@@ -0,0 +1,171 @@
+'use strict';
+/**
+ * VoiceGate — Node.js SDK for the voice gateway for AI agents (by CallsFlow Ltd).
+ *
+ * - `client.call(...)` asks the gateway to place a phone call for your agent.
+ * - `client.kyaRegister / kyaGetCredential / kyaLogin / me` run the Know Your
+ *   Agent flow: register, get a Verifiable Credential, log in with it, read the
+ *   cabinet (balance + reputation).
+ *
+ * KYA endpoints are live today. The voice-call endpoint is in private beta —
+ * point `baseUrl` at the host you were given, or run your own gateway.
+ *
+ * No dependencies: Node 18+ (global fetch) and the built-in `crypto` module.
+ */
+const crypto = require('crypto');
+
+const B58 = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz';
+
+function b58encode(buf) {
+  let n = BigInt('0x' + (buf.toString('hex') || '0'));
+  let out = '';
+  while (n > 0n) {
+    const r = n % 58n;
+    n = n / 58n;
+    out = B58[Number(r)] + out;
+  }
+  for (const b of buf) {
+    if (b === 0) out = '1' + out;
+    else break;
+  }
+  return out;
+}
+
+function b64url(buf) {
+  return buf.toString('base64').replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '');
+}
+
+// PKCS8 DER prefix for a raw 32-byte Ed25519 seed.
+const PKCS8_ED25519_PREFIX = Buffer.from('302e020100300506032b657004220420', 'hex');
+
+function keyObjectsFromSeed(seed32) {
+  const der = Buffer.concat([PKCS8_ED25519_PREFIX, seed32]);
+  const privateKey = crypto.createPrivateKey({ key: der, format: 'der', type: 'pkcs8' });
+  const publicKey = crypto.createPublicKey(privateKey);
+  return { privateKey, publicKey };
+}
+
+/** An agent's Ed25519 keypair — its cryptographic identity. */
+class AgentKey {
+  constructor(seed32) {
+    this._seed = seed32;
+    const { privateKey, publicKey } = keyObjectsFromSeed(seed32);
+    this._priv = privateKey;
+    this._pub = publicKey;
+  }
+
+  static generate() {
+    const { privateKey } = crypto.generateKeyPairSync('ed25519');
+    const seed = Buffer.from(privateKey.export({ format: 'jwk' }).d, 'base64url');
+    return new AgentKey(seed);
+  }
+
+  static fromSeedB64(seedB64) {
+    return new AgentKey(Buffer.from(seedB64, 'base64'));
+  }
+
+  seedB64() {
+    return this._seed.toString('base64');
+  }
+
+  rawPub() {
+    return Buffer.from(this._pub.export({ format: 'jwk' }).x, 'base64url');
+  }
+
+  get did() {
+    // did:key for Ed25519 = base58btc('z' + multicodec 0xed01 + raw public key)
+    return 'did:key:z' + b58encode(Buffer.concat([Buffer.from([0xed, 0x01]), this.rawPub()]));
+  }
+
+  signB64url(message) {
+    return b64url(crypto.sign(null, Buffer.from(message, 'utf8'), this._priv));
+  }
+}
+
+class VoiceGateError extends Error {
+  constructor(status, body) {
+    super(`VoiceGate API error ${status}: ${body}`);
+    this.status = status;
+    this.body = body;
+  }
+}
+
+class VoiceGate {
+  constructor(opts = {}) {
+    this.base = (opts.baseUrl || 'https://api.aivoicegate.com').replace(/\/+$/, '');
+    this.kya = (opts.kyaUrl || opts.baseUrl || this.base).replace(/\/+$/, '');
+    this.apiKey = opts.apiKey || null;
+    this.timeout = opts.timeout || 30000;
+    this._session = null;
+  }
+
+  async _request(method, url, body, auth) {
+    const headers = { 'Content-Type': 'application/json' };
+    if (auth) headers['Authorization'] = 'Bearer ' + auth;
+    const ctrl = new AbortController();
+    const t = setTimeout(() => ctrl.abort(), this.timeout);
+    let resp;
+    try {
+      resp = await fetch(url, {
+        method,
+        headers,
+        body: body != null ? JSON.stringify(body) : undefined,
+        signal: ctrl.signal,
+      });
+    } finally {
+      clearTimeout(t);
+    }
+    const text = await resp.text();
+    if (!resp.ok) throw new VoiceGateError(resp.status, text);
+    return text ? JSON.parse(text) : null;
+  }
+
+  // ── voice call (private beta) ──────────────────────────────────────────────
+  async call({ to, agentWebhook, voice = 'female', language = 'en', initialMessage } = {}) {
+    const body = { to, voice, language, agent_webhook: agentWebhook, pay: 'usdc:base' };
+    if (initialMessage) body.initial_message = initialMessage;
+    return this._request('POST', this.base + '/v1/agent-call', body, this.apiKey);
+  }
+
+  // ── KYA — Know Your Agent (live) ───────────────────────────────────────────
+  async kyaRegister(key, operatorEmail, domain) {
+    return this._request('POST', this.kya + '/v1/agents/register', {
+      operator_email: operatorEmail,
+      operator_kind: 'business',
+      domain: domain || null,
+      public_key: key.did,
+    });
+  }
+
+  async kyaGetCredential(key, agentId) {
+    const proof = key.signB64url('kya-credential:' + agentId);
+    const res = await this._request('POST', `${this.kya}/v1/agents/${agentId}/credential`, {
+      public_key: key.did,
+      proof,
+    });
+    return res.credential;
+  }
+
+  async kyaLogin(key, credential) {
+    const challenge = await this._request('POST', this.kya + '/v1/auth/challenge', { did: key.did });
+    const signature = key.signB64url(challenge.nonce);
+    const res = await this._request('POST', this.kya + '/v1/auth/verify', {
+      credential,
+      nonce: challenge.nonce,
+      signature,
+    });
+    this._session = res.access_token;
+    return res;
+  }
+
+  async me() {
+    if (!this._session) throw new VoiceGateError(0, 'not logged in — call kyaLogin() first');
+    return this._request('GET', this.kya + '/v1/me', null, this._session);
+  }
+
+  async issuer() {
+    return this._request('GET', this.kya + '/v1/issuer');
+  }
+}
+
+module.exports = { VoiceGate, AgentKey, VoiceGateError };