@ziggs-ai/agent-sdk 0.2.1 → 0.3.0

package/dist/server/ziggspay/ZiggsPayClient.d.ts

@@ -1,82 +0,0 @@
-import 'dotenv/config';
-export interface ZiggsPayClientOptions {
-    operatorKey: string;
-    actAsAgentId?: string;
-    baseUrl?: string;
-}
-export declare class ZiggsPayClient {
-    private operatorKey;
-    private actAsAgentId;
-    private baseUrl;
-    constructor({ operatorKey, actAsAgentId, baseUrl }: ZiggsPayClientOptions);
-    balance(): Promise<{
-        walletId: string | null;
-        currency: string;
-        balance: number;
-        availableBalance: number;
-    }>;
-    resolve({ userId, agentId }?: {
-        userId?: string;
-        agentId?: string;
-    }): Promise<unknown>;
-    transfer({ to, amount, idempotencyKey, description, paymentGrantId }: {
-        to: string;
-        amount: number;
-        idempotencyKey?: string;
-        description?: string;
-        paymentGrantId?: string;
-    }): Promise<unknown>;
-    hold({ amount, idempotencyKey, description }: {
-        amount: number;
-        idempotencyKey?: string;
-        description?: string;
-    }): Promise<unknown>;
-    release({ holdId, action, toWalletId, idempotencyKey }: {
-        holdId: string;
-        action?: string;
-        toWalletId?: string;
-        idempotencyKey?: string;
-    }): Promise<unknown>;
-    history(params?: {
-        limit?: number;
-        offset?: number;
-        type?: string;
-    }): Promise<unknown>;
-    issueGrant({ holderId, caveats }: {
-        holderId: string;
-        caveats?: unknown;
-    }): Promise<unknown>;
-    attenuateGrant({ grantId, holderId, caveats }: {
-        grantId: string;
-        holderId: string;
-        caveats?: unknown;
-    }): Promise<unknown>;
-    revokeGrant(grantId: string): Promise<unknown>;
-    listGrants(): Promise<unknown[]>;
-    createTopUpIntent({ amount, description, currency }?: {
-        amount?: number;
-        description?: string;
-        currency?: string;
-    }): Promise<unknown>;
-    confirmMockIntent(intentId: string): Promise<unknown>;
-    faucet({ amount, description, idempotencyKey }?: {
-        amount?: number;
-        description?: string;
-        idempotencyKey?: string;
-    }): Promise<unknown>;
-    approvals({ status }?: {
-        status?: string;
-    }): Promise<unknown[]>;
-    getApproval(approvalId: string): Promise<unknown | null>;
-    decide(approvalId: string, decision: string, note?: string): Promise<unknown>;
-    waitForApproval(approvalId: string, opts?: {
-        pollMs?: number;
-        timeoutMs?: number;
-        signal?: AbortSignal;
-    }): Promise<unknown>;
-    private _buildHeaders;
-    private _request;
-    private _get;
-    private _post;
-}
-export declare function createZiggsPayClient(opts: ZiggsPayClientOptions): ZiggsPayClient;

package/dist/server/ziggspay/ZiggsPayClient.js

@@ -1,203 +0,0 @@
-import 'dotenv/config';
-function getDefaultBaseUrl() {
-    return process.env.BACKEND_URL || process.env.ZIGGS_BACKEND_URL || 'http://localhost:3000';
-}
-function randomIdempotencyKey(prefix = 'op') {
-    return `${prefix}_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 10)}`;
-}
-function parseError(text, fallback) {
-    if (!text)
-        return fallback;
-    try {
-        const parsed = JSON.parse(text);
-        return parsed['error'] || parsed['message'] || text;
-    }
-    catch {
-        return text;
-    }
-}
-export class ZiggsPayClient {
-    operatorKey;
-    actAsAgentId;
-    baseUrl;
-    constructor({ operatorKey, actAsAgentId, baseUrl }) {
-        if (!operatorKey || typeof operatorKey !== 'string')
-            throw new Error('ZiggsPayClient requires an operatorKey');
-        this.operatorKey = operatorKey;
-        this.actAsAgentId = actAsAgentId || null;
-        this.baseUrl = baseUrl || getDefaultBaseUrl();
-    }
-    async balance() {
-        const w = await this._get('/payments/wallet');
-        const wallet = w['wallet'];
-        return { walletId: wallet?.['walletId'] || null, currency: wallet?.['currency'] || 'pez', balance: w['balance'] ?? 0, availableBalance: w['availableBalance'] ?? 0 };
-    }
-    async resolve({ userId, agentId } = {}) {
-        if (!userId && !agentId)
-            throw new Error('resolve: provide userId or agentId');
-        const params = new URLSearchParams();
-        if (userId)
-            params.set('userId', userId);
-        if (agentId)
-            params.set('agentId', agentId);
-        const res = await this._get(`/payments/wallets/resolve?${params}`);
-        return res['wallet'] || null;
-    }
-    async transfer({ to, amount, idempotencyKey, description, paymentGrantId }) {
-        if (!to)
-            throw new Error('transfer: `to` is required');
-        if (!(Number.isInteger(amount) && amount > 0))
-            throw new Error('transfer: `amount` must be a positive integer (cents)');
-        if (this.actAsAgentId && !paymentGrantId)
-            throw new Error('transfer: paymentGrantId is required for agent-impersonated transfers. The wallet owner must have issued a payment grant to this agentId.');
-        let toWalletId = to;
-        if (!to.startsWith('wal_')) {
-            const w = await this.resolve(to.startsWith('agent_') ? { agentId: to } : { userId: to });
-            if (!w?.['walletId'])
-                throw new Error(`transfer: could not resolve wallet for "${to}"`);
-            toWalletId = w['walletId'];
-        }
-        const result = await this._post('/payments/transfer', { toWalletId, amount, idempotencyKey: idempotencyKey || randomIdempotencyKey('xfer'), description, paymentGrantId });
-        if (result?.['status'] === 'approval_required') {
-            const approval = result['approval'] || {};
-            return { status: 'approval_required', approvalId: approval['approvalId'] || null, expiresAt: approval['expiresAt'] || null, reason: approval['reason'] || 'Amount exceeds auto-approve threshold', toWalletId, amount };
-        }
-        const tx = result?.['transaction'];
-        return { status: 'transferred', transactionId: tx?.['transactionId'] || null, toWalletId, amount };
-    }
-    async hold({ amount, idempotencyKey, description }) {
-        if (!(Number.isInteger(amount) && amount > 0))
-            throw new Error('hold: `amount` must be a positive integer (cents)');
-        return this._post('/payments/hold', { amount, idempotencyKey: idempotencyKey || randomIdempotencyKey('hold'), description });
-    }
-    async release({ holdId, action = 'complete', toWalletId, idempotencyKey }) {
-        return this._post(`/payments/release/${holdId}`, { idempotencyKey: idempotencyKey || randomIdempotencyKey('rel'), action, toWalletId });
-    }
-    async history(params = {}) {
-        const q = new URLSearchParams();
-        if (params.limit != null)
-            q.set('limit', String(params.limit));
-        if (params.offset != null)
-            q.set('offset', String(params.offset));
-        if (params.type)
-            q.set('type', params.type);
-        return this._get('/payments/history' + (q.toString() ? `?${q}` : ''));
-    }
-    async issueGrant({ holderId, caveats }) {
-        return this._post('/payments/grants', { holderId, caveats });
-    }
-    async attenuateGrant({ grantId, holderId, caveats }) {
-        return this._post(`/payments/grants/${grantId}/attenuate`, { holderId, caveats });
-    }
-    async revokeGrant(grantId) {
-        return this._request('DELETE', `/payments/grants/${grantId}`, undefined);
-    }
-    async listGrants() {
-        // GET /payments/grants was retired (ZIG-648); wallet grants the acting agent
-        // holds are listed via the unified GET /grants. Follow the cursor so a holder
-        // with more than one page isn't truncated; live grants only.
-        const all = [];
-        let cursor;
-        for (let page = 0; page < 50; page++) {
-            const q = new URLSearchParams({ scopeKind: 'wallet', health: 'active' });
-            if (cursor)
-                q.set('cursor', cursor);
-            const res = (await this._get(`/grants?${q.toString()}`));
-            all.push(...(res['items'] || []));
-            const next = res['nextCursor'];
-            if (!next)
-                break;
-            cursor = next;
-        }
-        return all;
-    }
-    async createTopUpIntent({ amount, description, currency } = {}) {
-        return this._post('/payments/onramp/intent', { amount, description, currency });
-    }
-    async confirmMockIntent(intentId) {
-        return this._post(`/payments/onramp/mock-confirm/${intentId}`, {});
-    }
-    async faucet({ amount, description = 'Faucet', idempotencyKey } = {}) {
-        return this._post('/payments/wallet/fund', { amount, idempotencyKey: idempotencyKey || randomIdempotencyKey('faucet'), description });
-    }
-    async approvals({ status = 'pending' } = {}) {
-        const res = await this._get(`/payments/approvals?status=${encodeURIComponent(status)}`);
-        return res['approvals'] || [];
-    }
-    async getApproval(approvalId) {
-        if (!approvalId)
-            throw new Error('getApproval: approvalId is required');
-        try {
-            const res = await this._get(`/payments/approvals/${approvalId}`);
-            return res?.['approval'] || null;
-        }
-        catch (err) {
-            if (err.status === 404)
-                return null;
-            throw err;
-        }
-    }
-    async decide(approvalId, decision, note = '') {
-        return this._post(`/payments/approvals/${approvalId}/decide`, { decision, note });
-    }
-    async waitForApproval(approvalId, opts = {}) {
-        const pollMs = Math.max(500, opts.pollMs ?? 3_000);
-        const timeoutMs = Math.max(pollMs, opts.timeoutMs ?? 120_000);
-        const signal = opts.signal;
-        const deadline = Date.now() + timeoutMs;
-        const sleep = (ms) => new Promise((resolve, reject) => {
-            const timer = setTimeout(resolve, ms);
-            if (signal) {
-                if (signal.aborted) {
-                    clearTimeout(timer);
-                    reject(new Error('aborted'));
-                    return;
-                }
-                signal.addEventListener('abort', () => { clearTimeout(timer); reject(new Error('aborted')); }, { once: true });
-            }
-        });
-        while (true) {
-            if (signal?.aborted)
-                throw new Error('aborted');
-            const approval = await this.getApproval(approvalId);
-            if (!approval)
-                return { status: 'gone' };
-            const s = approval['status'];
-            if (s === 'executed')
-                return { status: 'executed', approval, transactionId: approval['executedTransactionId'] || null };
-            if (s === 'rejected')
-                return { status: 'rejected', approval };
-            if (s === 'expired')
-                return { status: 'expired', approval };
-            const remaining = deadline - Date.now();
-            if (remaining <= 0)
-                return { status: 'timeout', approval };
-            await sleep(Math.min(pollMs, remaining));
-        }
-    }
-    _buildHeaders(extra = {}) {
-        const h = { Authorization: `Bearer ${this.operatorKey}`, ...extra };
-        if (this.actAsAgentId)
-            h['X-Agent-Id'] = this.actAsAgentId;
-        return h;
-    }
-    async _request(method, path, body) {
-        const init = { method, headers: this._buildHeaders(body !== undefined ? { 'content-type': 'application/json' } : {}) };
-        if (body !== undefined)
-            init.body = JSON.stringify(body);
-        const response = await fetch(`${this.baseUrl}${path}`, init);
-        const text = await response.text();
-        if (!response.ok) {
-            const err = new Error(parseError(text, `HTTP ${response.status}`));
-            err.status = response.status;
-            err.body = text;
-            throw err;
-        }
-        return text ? JSON.parse(text) : null;
-    }
-    _get(path) { return this._request('GET', path, undefined); }
-    _post(path, body) { return this._request('POST', path, body ?? {}); }
-}
-export function createZiggsPayClient(opts) {
-    return new ZiggsPayClient(opts);
-}