@ziggs-ai/agent-sdk 0.1.12 → 0.2.1

package/src/server/tools/tier2/paymentTools.ts

@@ -1,170 +0,0 @@
-import { defineTool, type ToolDefinition } from '../../../tools/defineTool.js';
-import { ZiggsPayClient } from '../../ziggspay/ZiggsPayClient.js';
-
-type Ctx = Record<string, unknown>;
-type AnyObj = Record<string, unknown>;
-
-function clientFor(ctx: Ctx): ZiggsPayClient {
-  const operatorKey = ctx?.['operatorKey'] as string | undefined;
-  if (!operatorKey) throw new Error('operatorKey missing from tool context');
-  return new ZiggsPayClient({ operatorKey, actAsAgentId: (ctx?.['agentId'] as string) || undefined });
-}
-
-interface PayError extends Error { status?: number; body?: string; }
-
-function rethrowWithContext(error: unknown, prefix: string): never {
-  const e = error as PayError;
-  const wrapped = new Error(`${prefix}: ${e.message}`) as PayError;
-  if (e.status !== undefined) wrapped.status = e.status;
-  if (e.body !== undefined) wrapped.body = e.body;
-  (wrapped as unknown as AnyObj)['cause'] = error;
-  throw wrapped;
-}
-
-function buildCaveats(args: AnyObj): AnyObj[] {
-  const caveats: AnyObj[] = [];
-  if (args['maxAmount'] != null) caveats.push({ type: 'max_amount', value: args['maxAmount'] });
-  if (args['dailyBudget'] != null) caveats.push({ type: 'daily_budget', value: args['dailyBudget'] });
-  if (args['allowedRecipients'] != null) caveats.push({ type: 'allowed_recipients', value: args['allowedRecipients'] });
-  if (args['expiresInSeconds'] != null) caveats.push({ type: 'expires_at', value: Date.now() + (args['expiresInSeconds'] as number) * 1000 });
-  return caveats;
-}
-
-export const paymentBalanceTool: ToolDefinition = defineTool('payment_balance', {},
-  async (_args, ctx) => {
-    try { return await clientFor(ctx as Ctx).balance(); }
-    catch (e) { rethrowWithContext(e, 'Failed to get balance'); }
-  },
-  { description: "Check the caller's current wallet balance and available balance (total minus active holds). Use before a transfer to confirm sufficient funds." },
-);
-
-export const paymentTransferTool: ToolDefinition = defineTool('payment_transfer',
-  { toWalletId: { type: 'string', required: true }, amount: { type: 'number', required: true }, description: 'string', idempotencyKey: 'string', paymentGrantId: 'string' },
-  async (args, ctx) => {
-    if (!args['toWalletId']) throw new Error('toWalletId is required');
-    if (!args['amount'] || (args['amount'] as number) <= 0) throw new Error('amount must be positive');
-    const client = clientFor(ctx as Ctx);
-    let result: AnyObj;
-    try {
-      result = await client.transfer({ to: args['toWalletId'] as string, amount: Math.round(args['amount'] as number), description: (args['description'] as string) || 'Agent-initiated transfer', idempotencyKey: args['idempotencyKey'] as string | undefined, paymentGrantId: args['paymentGrantId'] as string | undefined }) as AnyObj;
-    } catch (e) { rethrowWithContext(e, 'Transfer failed'); }
-    if (result!['status'] === 'approval_required') {
-      return { status: 'approval_required', approvalId: result!['approvalId'] || null, expiresAt: result!['expiresAt'] || null, reason: result!['reason'] || null, amount: args['amount'], toWalletId: result!['toWalletId'],
-        message: 'Transfer paused: the wallet owner must approve this amount.',
-        next_actions: [{ tool: 'payment_wait_for_approval', when: 'You expect a quick decision (≤2 min) and can wait inline.', args: { approvalId: result!['approvalId'], timeoutMs: 120000 } }, { tool: 'task_update_plan_step', when: 'You want to abandon the transfer and route around it.' }] };
-    }
-    return { status: 'transferred', transactionId: result!['transactionId'] || null, amount: args['amount'], toWalletId: result!['toWalletId'] };
-  },
-);
-
-export const paymentWaitForApprovalTool: ToolDefinition = defineTool('payment_wait_for_approval',
-  { approvalId: { type: 'string', required: true }, timeoutMs: 'number', pollMs: 'number' },
-  async (args, ctx) => {
-    if (!args['approvalId']) throw new Error('approvalId is required');
-    try {
-      const result = await clientFor(ctx as Ctx).waitForApproval(args['approvalId'] as string, { timeoutMs: args['timeoutMs'] as number | undefined, pollMs: args['pollMs'] as number | undefined }) as AnyObj;
-      return { status: result['status'], approvalId: args['approvalId'], transactionId: result['transactionId'] || null, approval: result['approval'] || null };
-    } catch (e) { rethrowWithContext(e, 'wait_for_approval failed'); }
-  },
-);
-
-export const paymentResolveWalletTool: ToolDefinition = defineTool('payment_resolve_wallet',
-  { userId: 'string', agentId: 'string' },
-  async (args, ctx) => {
-    if (!args['userId'] && !args['agentId']) throw new Error('Provide userId or agentId to resolve a wallet');
-    try {
-      const wallet = await clientFor(ctx as Ctx).resolve({ userId: args['userId'] as string | undefined, agentId: args['agentId'] as string | undefined }) as AnyObj | null;
-      return { walletId: wallet?.['walletId'] || null, ownerId: wallet?.['ownerId'] || null, currency: wallet?.['currency'] || 'pez', status: wallet?.['status'] || null };
-    } catch (e) { rethrowWithContext(e, 'Failed to resolve wallet'); }
-  },
-  { description: 'Look up a walletId by userId or agentId. Use before a transfer when you only know the recipient by their platform ID.' },
-);
-
-export const paymentHoldTool: ToolDefinition = defineTool('payment_hold',
-  { amount: { type: 'number', required: true }, description: 'string', idempotencyKey: 'string' },
-  async (args, ctx) => {
-    if (!args['amount'] || (args['amount'] as number) <= 0) throw new Error('amount must be positive');
-    try {
-      const result = await clientFor(ctx as Ctx).hold({ amount: Math.round(args['amount'] as number), description: (args['description'] as string) || 'Agent escrow hold', idempotencyKey: args['idempotencyKey'] as string | undefined }) as AnyObj;
-      return { status: 'held', transactionId: (result['transaction'] as AnyObj | undefined)?.['transactionId'] || null, amount: args['amount'] };
-    } catch (e) { rethrowWithContext(e, 'Hold failed'); }
-  },
-  { description: 'Pre-authorize (escrow) funds without moving them. Use to reserve payment at agreement formation; release with payment_release once work is complete or to refund if work is cancelled.' },
-);
-
-export const paymentReleaseTool: ToolDefinition = defineTool('payment_release',
-  { holdId: { type: 'string', required: true }, action: { type: 'string', required: true }, toWalletId: 'string', idempotencyKey: 'string' },
-  async (args, ctx) => {
-    if (!args['holdId']) throw new Error('holdId is required');
-    if (args['action'] !== 'complete' && args['action'] !== 'refund') throw new Error("action must be 'complete' or 'refund'");
-    if (args['action'] === 'complete' && !args['toWalletId']) throw new Error('toWalletId is required when action=complete');
-    try {
-      const result = await clientFor(ctx as Ctx).release({ holdId: args['holdId'] as string, action: args['action'] as string, toWalletId: args['toWalletId'] as string | undefined, idempotencyKey: args['idempotencyKey'] as string | undefined }) as AnyObj;
-      return { status: args['action'] === 'complete' ? 'settled' : 'refunded', transactionId: (result['transaction'] as AnyObj | undefined)?.['transactionId'] || null, holdId: args['holdId'], action: args['action'] };
-    } catch (e) { rethrowWithContext(e, 'Release failed'); }
-  },
-  { description: "Settle or refund an escrow hold. Use action='complete' to transfer held funds to toWalletId (work done), or action='refund' to return funds to the sender (work cancelled)." },
-);
-
-const issueGrantHandler = async (args: AnyObj, ctx: Ctx) => {
-  if (!args['holderId']) throw new Error('holderId is required');
-  try {
-    const caveats = buildCaveats(args);
-    const result = await clientFor(ctx).issueGrant({ holderId: args['holderId'] as string, caveats }) as AnyObj;
-    const grant = result['grant'] as AnyObj | undefined;
-    return { grantId: grant?.['grantId'] || null, holderId: grant?.['holderId'] || args['holderId'], caveats: grant?.['caveats'] || caveats, expiresAt: grant?.['expiresAt'] || null };
-  } catch (e) { rethrowWithContext(e, 'Failed to issue payment grant'); }
-};
-
-export const paymentIssueGrantTool: ToolDefinition = defineTool('payment_issue_grant',
-  { holderId: { type: 'string', required: true }, maxAmount: 'number', dailyBudget: 'number', allowedRecipients: ['string'], expiresInSeconds: 'number' },
-  issueGrantHandler,
-);
-
-const attenuateGrantHandler = async (args: AnyObj, ctx: Ctx) => {
-  const grantId = args['grantId'] as string;
-  if (!grantId) throw new Error('grantId is required');
-  if (!args['holderId']) throw new Error('holderId is required');
-  try {
-    const caveats = buildCaveats(args);
-    const result = await clientFor(ctx).attenuateGrant({ grantId, holderId: args['holderId'] as string, caveats }) as AnyObj;
-    const grant = result['grant'] as AnyObj | undefined;
-    return { grantId: grant?.['grantId'] || null, parentGrantId: grant?.['parentGrantId'] || grantId, holderId: grant?.['holderId'] || args['holderId'], caveats: grant?.['caveats'] || caveats, expiresAt: grant?.['expiresAt'] || null };
-  } catch (e) { rethrowWithContext(e, 'Failed to attenuate payment grant'); }
-};
-
-export const paymentAttenuateGrantTool: ToolDefinition = defineTool('payment_attenuate_grant',
-  { grantId: { type: 'string', required: true }, holderId: { type: 'string', required: true }, maxAmount: 'number', dailyBudget: 'number', allowedRecipients: ['string'], expiresInSeconds: 'number' },
-  attenuateGrantHandler,
-);
-
-const revokeGrantHandler = async (args: AnyObj, ctx: Ctx) => {
-  const grantId = args['grantId'] as string;
-  if (!grantId) throw new Error('grantId is required');
-  try {
-    const result = await clientFor(ctx).revokeGrant(grantId) as AnyObj;
-    return { status: 'revoked', grantId, revoked: result['revoked'] ?? null };
-  } catch (e) { rethrowWithContext(e, 'Failed to revoke payment grant'); }
-};
-
-export const paymentRevokeGrantTool: ToolDefinition = defineTool('payment_revoke_grant',
-  { grantId: { type: 'string', required: true } },
-  revokeGrantHandler,
-);
-
-const listGrantsHandler = async (_args: AnyObj, ctx: Ctx) => {
-  try {
-    const result = await clientFor(ctx).listGrants();
-    return { grants: result || [] };
-  } catch (e) { rethrowWithContext(e, 'Failed to list payment grants'); }
-};
-
-export const paymentListGrantsTool: ToolDefinition = defineTool('payment_list_grants', {},
-  listGrantsHandler,
-);
-
-export const PAYMENT_TOOLS: ToolDefinition[] = [
-  paymentBalanceTool, paymentTransferTool, paymentWaitForApprovalTool,
-  paymentHoldTool, paymentReleaseTool, paymentResolveWalletTool,
-  paymentIssueGrantTool, paymentAttenuateGrantTool, paymentRevokeGrantTool, paymentListGrantsTool,
-];

package/src/server/ziggsconnect/ZiggsConnectClient.ts

@@ -1,126 +0,0 @@
-import 'dotenv/config';
-
-function getDefaultBaseUrl(): string {
-  return process.env.BACKEND_URL || process.env.ZIGGS_BACKEND_URL || 'http://localhost:3000';
-}
-
-function parseError(text: string, fallback: string): string {
-  if (!text) return fallback;
-  try {
-    const parsed = JSON.parse(text) as Record<string, unknown>;
-    return (parsed['message'] as string) || (parsed['error'] as string) || text;
-  } catch {
-    return text;
-  }
-}
-
-interface ConnectError extends Error {
-  status?: number;
-  body?: string;
-}
-
-export interface ZiggsConnectClientOptions {
-  operatorKey: string;
-  actAsAgentId?: string;
-  baseUrl?: string;
-}
-
-export interface ProxyParams {
-  connectionId: string;
-  grantId: string;
-  action: string;
-  payload?: unknown;
-}
-
-export class ZiggsConnectClient {
-  private operatorKey: string;
-  private actAsAgentId: string | null;
-  private baseUrl: string;
-
-  constructor({ operatorKey, actAsAgentId, baseUrl }: ZiggsConnectClientOptions) {
-    if (!operatorKey || typeof operatorKey !== 'string') {
-      throw new Error('ZiggsConnectClient requires an operatorKey');
-    }
-    this.operatorKey = operatorKey;
-    this.actAsAgentId = actAsAgentId || null;
-    this.baseUrl = baseUrl || getDefaultBaseUrl();
-  }
-
-  /**
-   * Present a ConnectionGrant to the broker and perform a provider action.
-   * Returns the provider result — never the raw OAuth token.
-   */
-  async proxy({ connectionId, grantId, action, payload }: ProxyParams): Promise<unknown> {
-    if (!connectionId) throw new Error('proxy: connectionId is required');
-    if (!grantId) throw new Error('proxy: grantId is required');
-    if (!action) throw new Error('proxy: action is required');
-    if (!this.actAsAgentId) {
-      throw new Error(
-        'proxy: actAsAgentId is required — connection broker calls must impersonate the grant holder agent',
-      );
-    }
-    const res = (await this._post(`/connections/${encodeURIComponent(connectionId)}/proxy`, {
-      grantId,
-      action,
-      payload: payload ?? {},
-    })) as Record<string, unknown>;
-    return res['result'] ?? res;
-  }
-
-  /**
-   * List ConnectionGrants held by this agent for a connection.
-   * Requires actAsAgentId; filters server rows to holderId === agent.
-   */
-  async listGrants({ connectionId }: { connectionId: string }): Promise<unknown[]> {
-    if (!connectionId) throw new Error('listGrants: connectionId is required');
-    if (!this.actAsAgentId) {
-      throw new Error(
-        'listGrants: actAsAgentId is required — grants are scoped to the impersonated agent',
-      );
-    }
-    const res = (await this._get(
-      `/connections/${encodeURIComponent(connectionId)}/grants`,
-    )) as Record<string, unknown>;
-    const grants = (res['grants'] as Array<Record<string, unknown>>) || [];
-    return grants.filter((g) => g['holderId'] === this.actAsAgentId);
-  }
-
-  private _buildHeaders(extra: Record<string, string> = {}): Record<string, string> {
-    const h: Record<string, string> = { Authorization: `Bearer ${this.operatorKey}`, ...extra };
-    if (this.actAsAgentId) h['X-Agent-Id'] = this.actAsAgentId;
-    return h;
-  }
-
-  private async _request(method: string, path: string, body: unknown): Promise<unknown> {
-    const init: RequestInit = {
-      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}`)) as ConnectError;
-      err.status = response.status;
-      err.body = text;
-      throw err;
-    }
-    return text ? JSON.parse(text) : null;
-  }
-
-  private _get(path: string): Promise<unknown> {
-    return this._request('GET', path, undefined);
-  }
-
-  private _post(path: string, body: unknown): Promise<unknown> {
-    return this._request('POST', path, body ?? {});
-  }
-}
-
-export function createZiggsConnectClient(
-  opts: ZiggsConnectClientOptions,
-): ZiggsConnectClient {
-  return new ZiggsConnectClient(opts);
-}

package/src/server/ziggscontext/ZiggsContextClient.ts

@@ -1,129 +0,0 @@
-import 'dotenv/config';
-
-function getDefaultBaseUrl(): string {
-  return process.env.BACKEND_URL || process.env.ZIGGS_BACKEND_URL || 'http://localhost:3000';
-}
-
-function parseError(text: string, fallback: string): string {
-  if (!text) return fallback;
-  try {
-    const parsed = JSON.parse(text) as Record<string, unknown>;
-    return (parsed['message'] as string) || (parsed['error'] as string) || text;
-  } catch {
-    return text;
-  }
-}
-
-interface ContextError extends Error {
-  status?: number;
-  body?: string;
-}
-
-export interface ZiggsContextClientOptions {
-  operatorKey: string;
-  actAsAgentId?: string;
-  baseUrl?: string;
-}
-
-export interface ContextReachDescriptor {
-  grantId: string;
-  scope: { kind: 'chat' | 'agreement' | 'org'; id: string };
-  temporal: 'from-now' | 'from-start';
-  watermarkAt: string;
-  expiresAt: string | null;
-  parentGrantId: string | null;
-  createdAt: string;
-}
-
-export interface DelegateContextGrantParams {
-  parentGrantId: string;
-  holderId: string;
-  scope: { kind: 'chat' | 'agreement' | 'org'; id: string };
-  temporal: 'from-now' | 'from-start';
-  expiresAt?: string | null;
-  watermarkAt?: string;
-}
-
-/**
- * HTTP client for context grants (ZIG-413).
- * Presentation model (signed bytes vs grant id) is intentionally not baked in here.
- */
-export class ZiggsContextClient {
-  private operatorKey: string;
-  private actAsAgentId: string | null;
-  private baseUrl: string;
-
-  constructor({ operatorKey, actAsAgentId, baseUrl }: ZiggsContextClientOptions) {
-    if (!operatorKey || typeof operatorKey !== 'string') {
-      throw new Error('ZiggsContextClient requires an operatorKey');
-    }
-    this.operatorKey = operatorKey;
-    this.actAsAgentId = actAsAgentId || null;
-    this.baseUrl = baseUrl || getDefaultBaseUrl();
-  }
-
-  /** ZIG-412: scope descriptors for what this agent can reach (no content). */
-  async discover(): Promise<ContextReachDescriptor[]> {
-    this.requireActAsAgent('discover');
-    const res = (await this._get('/context/discovery')) as Record<string, unknown>;
-    return (res['reach'] as ContextReachDescriptor[]) || [];
-  }
-
-  /** Holder delegates a narrower child grant. */
-  async delegate(params: DelegateContextGrantParams): Promise<unknown> {
-    this.requireActAsAgent('delegate');
-    if (!params.parentGrantId) throw new Error('delegate: parentGrantId is required');
-    if (!params.holderId) throw new Error('delegate: holderId is required');
-    if (!params.scope?.kind || !params.scope?.id) {
-      throw new Error('delegate: scope { kind, id } is required');
-    }
-    return this._post(`/context/grants/${encodeURIComponent(params.parentGrantId)}/delegate`, {
-      holderId: params.holderId,
-      scope: params.scope,
-      temporal: params.temporal,
-      expiresAt: params.expiresAt,
-      watermarkAt: params.watermarkAt,
-    });
-  }
-
-  private requireActAsAgent(method: string): void {
-    if (!this.actAsAgentId) {
-      throw new Error(
-        `${method}: actAsAgentId is required — context grant calls must impersonate the grant holder agent`,
-      );
-    }
-  }
-
-  private _buildHeaders(extra: Record<string, string> = {}): Record<string, string> {
-    const h: Record<string, string> = { Authorization: `Bearer ${this.operatorKey}`, ...extra };
-    if (this.actAsAgentId) h['X-Agent-Id'] = this.actAsAgentId;
-    return h;
-  }
-
-  private async _request(method: string, path: string, body: unknown): Promise<unknown> {
-    const init: RequestInit = {
-      method,
-      headers: this._buildHeaders(
-        body !== undefined ? { 'content-type': 'application/json' } : {},
-      ),
-    };
-    if (body !== undefined) init.body = JSON.stringify(body);
-    const res = await fetch(`${this.baseUrl}${path}`, init);
-    const text = await res.text();
-    if (!res.ok) {
-      const err = new Error(parseError(text, `${method} ${path} failed (${res.status})`)) as ContextError;
-      err.status = res.status;
-      err.body = text;
-      throw err;
-    }
-    return text ? JSON.parse(text) : {};
-  }
-
-  private _get(path: string): Promise<unknown> {
-    return this._request('GET', path, undefined);
-  }
-
-  private _post(path: string, body: unknown): Promise<unknown> {
-    return this._request('POST', path, body);
-  }
-}

package/src/server/ziggspay/ZiggsPayClient.ts

@@ -1,193 +0,0 @@
-import 'dotenv/config';
-
-function getDefaultBaseUrl(): string {
-  return process.env.BACKEND_URL || process.env.ZIGGS_BACKEND_URL || 'http://localhost:3000';
-}
-
-function randomIdempotencyKey(prefix = 'op'): string {
-  return `${prefix}_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 10)}`;
-}
-
-function parseError(text: string, fallback: string): string {
-  if (!text) return fallback;
-  try {
-    const parsed = JSON.parse(text) as Record<string, unknown>;
-    return (parsed['error'] as string) || (parsed['message'] as string) || text;
-  } catch { return text; }
-}
-
-interface PayError extends Error { status?: number; body?: string; }
-
-export interface ZiggsPayClientOptions {
-  operatorKey: string;
-  actAsAgentId?: string;
-  baseUrl?: string;
-}
-
-export class ZiggsPayClient {
-  private operatorKey: string;
-  private actAsAgentId: string | null;
-  private baseUrl: string;
-
-  constructor({ operatorKey, actAsAgentId, baseUrl }: ZiggsPayClientOptions) {
-    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(): Promise<{ walletId: string | null; currency: string; balance: number; availableBalance: number }> {
-    const w = await this._get('/payments/wallet') as Record<string, unknown>;
-    const wallet = w['wallet'] as Record<string, unknown> | undefined;
-    return { walletId: (wallet?.['walletId'] as string) || null, currency: (wallet?.['currency'] as string) || 'pez', balance: (w['balance'] as number) ?? 0, availableBalance: (w['availableBalance'] as number) ?? 0 };
-  }
-
-  async resolve({ userId, agentId }: { userId?: string; agentId?: string } = {}): Promise<unknown> {
-    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}`) as Record<string, unknown>;
-    return res['wallet'] || null;
-  }
-
-  async transfer({ to, amount, idempotencyKey, description, paymentGrantId }: { to: string; amount: number; idempotencyKey?: string; description?: string; paymentGrantId?: string }): Promise<unknown> {
-    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 }) as Record<string, unknown> | null;
-      if (!w?.['walletId']) throw new Error(`transfer: could not resolve wallet for "${to}"`);
-      toWalletId = w['walletId'] as string;
-    }
-    const result = await this._post('/payments/transfer', { toWalletId, amount, idempotencyKey: idempotencyKey || randomIdempotencyKey('xfer'), description, paymentGrantId }) as Record<string, unknown>;
-    if (result?.['status'] === 'approval_required') {
-      const approval = (result['approval'] as Record<string, unknown>) || {};
-      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'] as Record<string, unknown> | undefined;
-    return { status: 'transferred', transactionId: tx?.['transactionId'] || null, toWalletId, amount };
-  }
-
-  async hold({ amount, idempotencyKey, description }: { amount: number; idempotencyKey?: string; description?: string }): Promise<unknown> {
-    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 }: { holdId: string; action?: string; toWalletId?: string; idempotencyKey?: string }): Promise<unknown> {
-    return this._post(`/payments/release/${holdId}`, { idempotencyKey: idempotencyKey || randomIdempotencyKey('rel'), action, toWalletId });
-  }
-
-  async history(params: { limit?: number; offset?: number; type?: string } = {}): Promise<unknown> {
-    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 }: { holderId: string; caveats?: unknown }): Promise<unknown> {
-    return this._post('/payments/grants', { holderId, caveats });
-  }
-
-  async attenuateGrant({ grantId, holderId, caveats }: { grantId: string; holderId: string; caveats?: unknown }): Promise<unknown> {
-    return this._post(`/payments/grants/${grantId}/attenuate`, { holderId, caveats });
-  }
-
-  async revokeGrant(grantId: string): Promise<unknown> {
-    return this._request('DELETE', `/payments/grants/${grantId}`, undefined);
-  }
-
-  async listGrants(): Promise<unknown[]> {
-    const res = await this._get('/payments/grants') as Record<string, unknown>;
-    return (res['grants'] as unknown[]) || [];
-  }
-
-  async createTopUpIntent({ amount, description, currency }: { amount?: number; description?: string; currency?: string } = {}): Promise<unknown> {
-    return this._post('/payments/onramp/intent', { amount, description, currency });
-  }
-
-  async confirmMockIntent(intentId: string): Promise<unknown> {
-    return this._post(`/payments/onramp/mock-confirm/${intentId}`, {});
-  }
-
-  async faucet({ amount, description = 'Faucet', idempotencyKey }: { amount?: number; description?: string; idempotencyKey?: string } = {}): Promise<unknown> {
-    return this._post('/payments/wallet/fund', { amount, idempotencyKey: idempotencyKey || randomIdempotencyKey('faucet'), description });
-  }
-
-  async approvals({ status = 'pending' }: { status?: string } = {}): Promise<unknown[]> {
-    const res = await this._get(`/payments/approvals?status=${encodeURIComponent(status)}`) as Record<string, unknown>;
-    return (res['approvals'] as unknown[]) || [];
-  }
-
-  async getApproval(approvalId: string): Promise<unknown | null> {
-    if (!approvalId) throw new Error('getApproval: approvalId is required');
-    try {
-      const res = await this._get(`/payments/approvals/${approvalId}`) as Record<string, unknown>;
-      return res?.['approval'] || null;
-    } catch (err) {
-      if ((err as PayError).status === 404) return null;
-      throw err;
-    }
-  }
-
-  async decide(approvalId: string, decision: string, note = ''): Promise<unknown> {
-    return this._post(`/payments/approvals/${approvalId}/decide`, { decision, note });
-  }
-
-  async waitForApproval(approvalId: string, opts: { pollMs?: number; timeoutMs?: number; signal?: AbortSignal } = {}): Promise<unknown> {
-    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: number) => new Promise<void>((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) as Record<string, unknown> | null;
-      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));
-    }
-  }
-
-  private _buildHeaders(extra: Record<string, string> = {}): Record<string, string> {
-    const h: Record<string, string> = { Authorization: `Bearer ${this.operatorKey}`, ...extra };
-    if (this.actAsAgentId) h['X-Agent-Id'] = this.actAsAgentId;
-    return h;
-  }
-
-  private async _request(method: string, path: string, body: unknown): Promise<unknown> {
-    const init: RequestInit = { 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}`)) as PayError;
-      err.status = response.status;
-      err.body = text;
-      throw err;
-    }
-    return text ? JSON.parse(text) : null;
-  }
-
-  private _get(path: string): Promise<unknown> { return this._request('GET', path, undefined); }
-  private _post(path: string, body: unknown): Promise<unknown> { return this._request('POST', path, body ?? {}); }
-}
-
-export function createZiggsPayClient(opts: ZiggsPayClientOptions): ZiggsPayClient {
-  return new ZiggsPayClient(opts);
-}

package/src/shared/ids.ts

@@ -1,3 +0,0 @@
-export function generateId(): string {
-  return `${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
-}