valta-sdk 2.1.7 → 2.2.2

package/dist/index.d.ts

@@ -1,197 +1,351 @@
-interface RequestOptions {
-    method?: 'GET' | 'POST' | 'PATCH' | 'DELETE';
-    body?: unknown;
+interface ValtaConfig {
+    apiKey: string;
+    baseUrl?: string;
+    timeout?: number;
 }
-declare class Requester {
-    private apiKey;
-    private baseUrl;
-    constructor(apiKey: string, baseUrl?: string);
-    request<T>(path: string, options?: RequestOptions): Promise<T>;
+interface LoginResponse {
+    token: string;
+    user: {
+        id: string;
+        email: string;
+        name?: string | null;
+        plan: string;
+    };
 }
-
-interface Agent {
+interface WhoamiResponse {
     id: string;
-    name: string;
-    type: string;
-    status: 'active' | 'frozen' | 'paused';
-    walletAddress?: string;
+    email: string;
+    name: string | null;
+    plan: string;
+    creditsRemaining: number;
     createdAt: string;
-    updatedAt: string;
 }
 interface CreateAgentParams {
     name: string;
-    type: string;
     description?: string;
+    wallet?: {
+        initialBalance?: number;
+        dailyLimit?: number;
+        monthlyLimit?: number;
+        currency?: string;
+    };
+    policy?: {
+        requireApprovalAbove?: number;
+        requireApproval?: {
+            above: number;
+        };
+        maxPerTransaction?: number;
+        blockedCategories?: string[];
+        allowedDomains?: string[];
+        blockedDomains?: string[];
+    };
+    autonomyLevel?: 'supervised' | 'semi_autonomous' | 'fully_autonomous';
+    agentType?: string;
+    type?: string;
 }
-interface ListAgentsParams {
-    limit?: number;
-    offset?: number;
-    status?: 'active' | 'frozen' | 'paused';
-}
-interface ListAgentsResponse {
-    agents: Agent[];
-    total: number;
-    limit: number;
-    offset: number;
+interface Agent {
+    id: string;
+    userId: string;
+    name: string;
+    description: string | null;
+    status: 'active' | 'frozen' | 'inactive';
+    autonomyLevel: 'supervised' | 'semi_autonomous' | 'fully_autonomous';
+    agentType: string | null;
+    walletAddress: string;
+    wallet: AgentWallet;
+    policy: AgentPolicy | null;
+    createdAt: string;
+    updatedAt: string;
 }
-declare class AgentsResource {
-    private requester;
-    constructor(requester: Requester);
-    list(params?: ListAgentsParams): Promise<ListAgentsResponse>;
-    get(agentId: string): Promise<Agent>;
-    create(params: CreateAgentParams): Promise<Agent>;
-    update(agentId: string, params: Partial<CreateAgentParams>): Promise<Agent>;
-    freeze(agentId: string): Promise<Agent>;
-    unfreeze(agentId: string): Promise<Agent>;
-    delete(agentId: string): Promise<{
-        deleted: boolean;
-        id: string;
-    }>;
+interface AgentWallet {
+    id: string;
+    agentId: string;
+    balance: number;
+    currency: string;
+    dailyLimit: number | null;
+    monthlyLimit: number | null;
+    dailySpent: number;
+    monthlySpent: number;
 }
-
-interface WalletBalance {
-    usdc: string;
-    usdcPending: string;
-    lastUpdated: string;
-}
-interface WalletTransferParams {
-    toAgentId?: string;
-    toAddress?: string;
-    amount: string;
-    currency: 'USDC';
-    note?: string;
+interface AgentPolicy {
+    id: string;
+    agentId: string;
+    requireApprovalAbove: number | null;
+    maxPerTransaction: number | null;
+    dailyLimit: number | null;
+    monthlyLimit: number | null;
+    blockedCategories: string[];
+    allowedDomains: string[];
+    blockedDomains: string[];
 }
-interface WalletTransfer {
+interface AgentRun {
     id: string;
-    fromAgentId: string;
-    toAgentId?: string;
-    toAddress?: string;
-    amount: string;
-    currency: string;
-    status: 'pending' | 'completed' | 'failed';
+    agentId: string;
+    status: 'running' | 'completed' | 'failed' | 'waiting_approval' | 'frozen' | 'cancelled';
+    task: string;
+    output: string | null;
+    summary?: string | null;
+    error: string | null;
+    tokensUsed: number;
+    toolCallsCount: number;
+    durationMs: number | null;
+    startedAt: string;
+    completedAt: string | null;
     createdAt: string;
 }
-declare class WalletsResource {
-    private requester;
-    constructor(requester: Requester);
-    get(agentId: string): Promise<WalletBalance>;
-    transfer(agentId: string, params: WalletTransferParams): Promise<WalletTransfer>;
+interface RunAgentParams {
+    task: string;
+    context?: string;
+    timeout?: number;
 }
-
-interface Policy {
+interface WalletBalance {
+    agentId: string;
+    balance: number;
+    currency: string;
+    dailySpent: number;
+    monthlySpent: number;
+    dailyLimit: number | null;
+    monthlyLimit: number | null;
+    walletAddress: string;
+}
+interface WalletDepositAddress {
+    address: string;
+    qrCodeDataUrl: string;
+    network: 'Base';
+    currency: 'USDC';
+}
+interface WalletTransaction {
     id: string;
     agentId: string;
-    name: string;
-    maxSpendPerDay?: number;
-    maxSpendPerTransaction?: number;
-    allowedRecipients?: string[];
+    type: 'debit' | 'credit' | 'transfer_out' | 'transfer_in';
+    amount: number;
     currency: string;
-    active: boolean;
+    description: string;
+    referenceId: string | null;
+    status: 'completed' | 'pending' | 'failed' | 'blocked';
     createdAt: string;
 }
+interface TransferParams {
+    fromAgentId: string;
+    toAgentId: string;
+    amount: number;
+    description?: string;
+}
 interface CreatePolicyParams {
     agentId: string;
-    name: string;
-    maxSpendPerDay?: number;
-    maxSpendPerTransaction?: number;
-    allowedRecipients?: string[];
-    currency?: string;
+    requireApprovalAbove?: number;
+    maxPerTransaction?: number;
+    dailyLimit?: number;
+    monthlyLimit?: number;
+    blockedCategories?: string[];
+    allowedDomains?: string[];
+    blockedDomains?: string[];
 }
-declare class PoliciesResource {
-    private requester;
-    constructor(requester: Requester);
-    list(agentId?: string): Promise<Policy[]>;
-    create(params: CreatePolicyParams): Promise<Policy>;
-    update(policyId: string, params: Partial<CreatePolicyParams>): Promise<Policy>;
-    delete(policyId: string): Promise<{
-        deleted: boolean;
-    }>;
+interface UpdatePolicyParams extends Partial<Omit<CreatePolicyParams, 'agentId'>> {
 }
-
-interface AuditLog {
+interface AuditEntry {
     id: string;
     agentId: string;
+    userId: string;
     action: string;
-    amount?: string;
-    currency?: string;
-    metadata?: Record<string, unknown>;
+    details: Record<string, unknown> | null;
+    amount: number | null;
+    status: 'success' | 'blocked' | 'pending' | 'failed';
+    previousHash: string | null;
     hash: string;
-    previousHash: string;
+    ipAddress: string | null;
     createdAt: string;
 }
 interface ListAuditParams {
     agentId?: string;
-    limit?: number;
-    offset?: number;
+    action?: string;
+    status?: 'success' | 'blocked' | 'pending' | 'failed';
     from?: string;
     to?: string;
+    page?: number;
+    limit?: number;
 }
-interface ListAuditResponse {
-    logs: AuditLog[];
-    total: number;
-}
-declare class AuditResource {
-    private requester;
-    constructor(requester: Requester);
-    list(params?: ListAuditParams): Promise<ListAuditResponse>;
-}
-
 interface ApiKey {
     id: string;
     name: string;
-    prefix: string;
-    tier: 'free' | 'builder' | 'startup' | 'enterprise';
-    lastUsed?: string;
+    keyPrefix: string;
+    fullKey?: string;
+    lastUsedAt: string | null;
     createdAt: string;
 }
-interface CreateKeyResponse {
-    id: string;
+interface CreateApiKeyParams {
     name: string;
-    key: string;
-    tier: string;
-    createdAt: string;
 }
+interface PaginatedResponse<T> {
+    data: T[];
+    pagination: {
+        total: number;
+        page: number;
+        limit: number;
+        hasMore: boolean;
+    };
+}
+
+declare class HttpClient {
+    private readonly apiKey;
+    private readonly baseUrl;
+    private readonly timeout;
+    constructor(config: ValtaConfig);
+    request<T>(params: {
+        method: 'GET' | 'POST' | 'PATCH' | 'DELETE';
+        path: string;
+        body?: unknown;
+        query?: Record<string, string | number | boolean | undefined>;
+        authenticated?: boolean;
+    }): Promise<T>;
+    get<T>(path: string, query?: Record<string, string | number | boolean | undefined>): Promise<T>;
+    post<T>(path: string, body?: unknown, authenticated?: boolean): Promise<T>;
+    patch<T>(path: string, body?: unknown): Promise<T>;
+    delete<T>(path: string): Promise<T>;
+}
+
+declare class AuthResource {
+    private http;
+    constructor(http: HttpClient);
+    login(email: string, password: string): Promise<LoginResponse>;
+    logout(): Promise<void>;
+    whoami(): Promise<WhoamiResponse>;
+    refreshToken(): Promise<{
+        token: string;
+    }>;
+}
+
+declare class AgentsResource {
+    private http;
+    constructor(http: HttpClient);
+    create(params: CreateAgentParams): Promise<Agent>;
+    list(params?: {
+        page?: number;
+        limit?: number;
+        status?: 'active' | 'frozen' | 'inactive';
+    }): Promise<PaginatedResponse<Agent>>;
+    get(agentId: string): Promise<Agent>;
+    update(agentId: string, params: {
+        name?: string;
+        description?: string;
+        autonomyLevel?: Agent['autonomyLevel'];
+    }): Promise<Agent>;
+    delete(agentId: string): Promise<{
+        success: boolean;
+    }>;
+    freeze(agentId: string): Promise<{
+        success: boolean;
+        agentId: string;
+        status: 'frozen';
+    }>;
+    unfreeze(agentId: string): Promise<{
+        success: boolean;
+        agentId: string;
+        status: 'active';
+    }>;
+    run(agentId: string, params: RunAgentParams): Promise<AgentRun>;
+    getRun(agentId: string, runId: string): Promise<AgentRun>;
+    listRuns(agentId: string, params?: {
+        page?: number;
+        limit?: number;
+        status?: AgentRun['status'];
+    }): Promise<PaginatedResponse<AgentRun>>;
+}
+
+declare class AuditResource {
+    private http;
+    constructor(http: HttpClient);
+    list(params?: ListAuditParams): Promise<PaginatedResponse<AuditEntry>>;
+    get(entryId: string): Promise<AuditEntry>;
+    export(params?: ListAuditParams): Promise<AuditEntry[]>;
+    verify(agentId: string): Promise<{
+        intact: boolean;
+        entriesChecked: number;
+    }>;
+}
+
 declare class KeysResource {
-    private requester;
-    constructor(requester: Requester);
+    private http;
+    constructor(http: HttpClient);
+    create(params: CreateApiKeyParams): Promise<ApiKey & {
+        fullKey: string;
+    }>;
     list(): Promise<ApiKey[]>;
-    create(name: string): Promise<CreateKeyResponse>;
     revoke(keyId: string): Promise<{
-        deleted: boolean;
+        success: boolean;
     }>;
 }
 
-interface ValtaConfig {
-    apiKey: string;
-    baseUrl?: string;
+declare class PoliciesResource {
+    private http;
+    constructor(http: HttpClient);
+    create(params: CreatePolicyParams): Promise<AgentPolicy>;
+    get(agentId: string): Promise<AgentPolicy | null>;
+    update(agentId: string, params: UpdatePolicyParams): Promise<AgentPolicy>;
+    delete(agentId: string): Promise<{
+        success: boolean;
+    }>;
+    list(): Promise<AgentPolicy[]>;
 }
-declare class ValtaClient {
-    agents: AgentsResource;
-    wallets: WalletsResource;
-    policies: PoliciesResource;
-    audit: AuditResource;
-    keys: KeysResource;
+
+declare class WalletsResource {
+    private http;
+    constructor(http: HttpClient);
+    get(agentId: string): Promise<WalletBalance>;
+    getBalance(agentId: string): Promise<number>;
+    getDepositAddress(agentId: string): Promise<WalletDepositAddress>;
+    listTransactions(agentId: string, params?: {
+        page?: number;
+        limit?: number;
+        type?: WalletTransaction['type'];
+    }): Promise<PaginatedResponse<WalletTransaction>>;
+    transfer(params: TransferParams): Promise<{
+        success: boolean;
+        transactionId: string;
+        fromBalance: number;
+        toBalance: number;
+    }>;
+}
+
+declare class Valta {
+    readonly auth: AuthResource;
+    readonly agents: AgentsResource;
+    readonly wallets: WalletsResource;
+    readonly policies: PoliciesResource;
+    readonly audit: AuditResource;
+    readonly keys: KeysResource;
+    private readonly http;
     constructor(config: ValtaConfig | string);
 }
 
+type ValtaErrorCode = 'UNAUTHORISED' | 'FORBIDDEN' | 'NOT_FOUND' | 'RATE_LIMIT_EXCEEDED' | 'TIER_LIMIT_EXCEEDED' | 'AGENT_FROZEN' | 'POLICY_VIOLATION' | 'INSUFFICIENT_BALANCE' | 'APPROVAL_REQUIRED' | 'INVALID_REQUEST' | 'SERVER_ERROR' | 'NETWORK_ERROR' | 'TIMEOUT';
 declare class ValtaError extends Error {
-    code: string;
-    status: number;
-    constructor(message: string, code: string, status: number);
+    readonly code: ValtaErrorCode;
+    readonly status: number | null;
+    readonly details: Record<string, unknown> | null;
+    constructor(params: {
+        message: string;
+        code: ValtaErrorCode;
+        status?: number;
+        details?: Record<string, unknown>;
+    });
+    isRateLimit(): boolean;
+    isAuth(): boolean;
+    requiresApproval(): boolean;
 }
 declare class AuthError extends ValtaError {
     constructor(message?: string);
 }
 declare class TierError extends ValtaError {
-    requiredTier: string;
-    upgradeUrl: string;
-    constructor(message: string, requiredTier: string);
+    readonly requiredTier: string | null;
+    readonly upgradeUrl: string;
+    constructor(message: string, requiredTier?: string);
 }
 declare class RateLimitError extends ValtaError {
     constructor(message?: string);
 }
 declare class NotFoundError extends ValtaError {
-    constructor(resource: string);
+    constructor(message?: string);
 }
 
-export { type Agent, type ApiKey, type AuditLog, AuthError, type CreateAgentParams, type CreateKeyResponse, type CreatePolicyParams, type ListAgentsParams, type ListAuditParams, NotFoundError, type Policy, RateLimitError, TierError, ValtaClient, ValtaError, type WalletBalance, type WalletTransfer, type WalletTransferParams, ValtaClient as default };
+export { type Agent, type AgentPolicy, type AgentRun, type AgentWallet, type ApiKey, type AuditEntry, AuthError, type CreateAgentParams, type CreateApiKeyParams, type CreatePolicyParams, type ListAuditParams, type LoginResponse, NotFoundError, type PaginatedResponse, RateLimitError, type RunAgentParams, TierError, type TransferParams, type UpdatePolicyParams, Valta, Valta as ValtaClient, type ValtaConfig, ValtaError, type ValtaErrorCode, type WalletBalance, type WalletDepositAddress, type WalletTransaction, type WhoamiResponse, Valta as default };

package/dist/index.js

@@ -1,17 +1,2 @@
-import {
-  AuthError,
-  NotFoundError,
-  RateLimitError,
-  TierError,
-  ValtaClient,
-  ValtaError
-} from "./chunk-LBY67QV7.js";
-export {
-  AuthError,
-  NotFoundError,
-  RateLimitError,
-  TierError,
-  ValtaClient,
-  ValtaError,
-  ValtaClient as default
-};
+var d=class{constructor(t){this.http=t;}async login(t,e){return this.http.post("/auth/login",{email:t,password:e},false)}async logout(){await this.http.post("/auth/logout");}async whoami(){return this.http.get("/auth/whoami")}async refreshToken(){return this.http.post("/auth/refresh-token")}};var m=class{constructor(t){this.http=t;}async create(t){return this.http.post("/agents",t)}async list(t){return this.http.get("/agents",t)}async get(t){return this.http.get(`/agents/${encodeURIComponent(t)}`)}async update(t,e){return this.http.patch(`/agents/${encodeURIComponent(t)}`,e)}async delete(t){return this.http.delete(`/agents/${encodeURIComponent(t)}`)}async freeze(t){return this.http.post(`/agents/${encodeURIComponent(t)}/freeze`)}async unfreeze(t){return this.http.post(`/agents/${encodeURIComponent(t)}/unfreeze`)}async run(t,e){return this.http.post(`/agents/${encodeURIComponent(t)}/run`,e)}async getRun(t,e){return this.http.get(`/agents/${encodeURIComponent(t)}/runs/${encodeURIComponent(e)}`)}async listRuns(t,e){return this.http.get(`/agents/${encodeURIComponent(t)}/runs`,e)}};var g=class{constructor(t){this.http=t;}async list(t){return this.http.get("/audit",t)}async get(t){return this.http.get(`/audit/${encodeURIComponent(t)}`)}async export(t){let e=[],o=1,i=true;for(;i;){let p=await this.list({...t,page:o,limit:100});e.push(...p.data),i=p.pagination.hasMore,o+=1;}return e}async verify(t){return this.http.get(`/audit/verify/${encodeURIComponent(t)}`)}};var h=class{constructor(t){this.http=t;}async create(t){return this.http.post("/keys",t)}async list(){return this.http.get("/keys")}async revoke(t){return this.http.delete(`/keys/${encodeURIComponent(t)}`)}};var n=class extends Error{constructor(t){super(t.message),this.name="ValtaError",this.code=t.code,this.status=t.status??null,this.details=t.details??null;}isRateLimit(){return this.code==="RATE_LIMIT_EXCEEDED"}isAuth(){return this.code==="UNAUTHORISED"||this.code==="FORBIDDEN"}requiresApproval(){return this.code==="APPROVAL_REQUIRED"}},A=class extends n{constructor(t="Invalid or missing API key"){super({message:t,code:"UNAUTHORISED",status:401}),this.name="AuthError";}},P=class extends n{constructor(t,e){super({message:t,code:"TIER_LIMIT_EXCEEDED",status:403,details:{requiredTier:e}}),this.name="TierError",this.requiredTier=e??null,this.upgradeUrl="https://valta.co/upgrade";}},I=class extends n{constructor(t="Rate limit exceeded"){super({message:t,code:"RATE_LIMIT_EXCEEDED",status:429}),this.name="RateLimitError";}},T=class extends n{constructor(t="Resource not found"){super({message:t,code:"NOT_FOUND",status:404}),this.name="NotFoundError";}};var E=class{constructor(t){this.http=t;}async create(t){return this.http.post("/policies",t)}async get(t){try{return await this.http.get(`/policies/${encodeURIComponent(t)}`)}catch(e){if(e instanceof n&&e.code==="NOT_FOUND")return null;throw e}}async update(t,e){return this.http.patch(`/policies/${encodeURIComponent(t)}`,e)}async delete(t){return this.http.delete(`/policies/${encodeURIComponent(t)}`)}async list(){return this.http.get("/policies")}};var y=class{constructor(t){this.http=t;}async get(t){return this.http.get(`/wallets/${encodeURIComponent(t)}`)}async getBalance(t){return (await this.get(t)).balance}async getDepositAddress(t){return this.http.get(`/wallets/${encodeURIComponent(t)}/deposit-address`)}async listTransactions(t,e){return this.http.get(`/wallets/${encodeURIComponent(t)}/transactions`,e)}async transfer(t){return this.http.post("/wallets/transfer",t)}};var f="2.2.0",R=class{constructor(t){this.apiKey=t.apiKey,this.baseUrl=(t.baseUrl??"https://valta.co/api/v1").replace(/\/$/,""),this.timeout=t.timeout??3e4;}async request(t){let e=`${this.baseUrl}${t.path}`;if(t.query){let r=new URLSearchParams;for(let[u,a]of Object.entries(t.query))a!==void 0&&r.set(u,String(a));let l=r.toString();l&&(e+=`?${l}`);}let o=new AbortController,i=setTimeout(()=>o.abort(),this.timeout),p={"Content-Type":"application/json","User-Agent":`valta-sdk/${f}`,"X-Valta-SDK":f};t.authenticated!==false&&(p["x-api-key"]=this.apiKey);try{let r=await fetch(e,{method:t.method,headers:p,body:t.body===void 0?void 0:JSON.stringify(t.body),signal:o.signal});clearTimeout(i);let l=await r.text(),u=l?C(l,r.status):null;if(!r.ok){let a=u??{};throw new n({message:a.message??a.error??`HTTP ${r.status}`,code:U(a.code,r.status),status:r.status,details:a})}return u}catch(r){throw clearTimeout(i),r instanceof n?r:r instanceof Error&&r.name==="AbortError"?new n({message:`Request timed out after ${this.timeout}ms`,code:"TIMEOUT"}):new n({message:r instanceof Error?r.message:"An unknown network error occurred",code:"NETWORK_ERROR"})}}get(t,e){return this.request({method:"GET",path:t,query:e})}post(t,e,o=true){return this.request({method:"POST",path:t,body:e,authenticated:o})}patch(t,e){return this.request({method:"PATCH",path:t,body:e})}delete(t){return this.request({method:"DELETE",path:t})}};function C(s,t){try{return JSON.parse(s)}catch{throw new n({message:"Invalid JSON response from server",code:"SERVER_ERROR",status:t})}}function U(s,t){let e=String(s||"").toUpperCase();if(e==="UNAUTHORIZED"||e==="API_KEY_REQUIRED"||e==="INVALID_API_KEY")return "UNAUTHORISED";if(e==="RATE_LIMIT"||e==="API_KEY_RATE_LIMITED")return "RATE_LIMIT_EXCEEDED";if(e==="TIER_LIMIT")return "TIER_LIMIT_EXCEEDED";if(D(e))return e;switch(t){case 400:return "INVALID_REQUEST";case 401:return "UNAUTHORISED";case 403:return "FORBIDDEN";case 404:return "NOT_FOUND";case 429:return "RATE_LIMIT_EXCEEDED";default:return "SERVER_ERROR"}}function D(s){return ["UNAUTHORISED","FORBIDDEN","NOT_FOUND","RATE_LIMIT_EXCEEDED","TIER_LIMIT_EXCEEDED","AGENT_FROZEN","POLICY_VIOLATION","INSUFFICIENT_BALANCE","APPROVAL_REQUIRED","INVALID_REQUEST","SERVER_ERROR","NETWORK_ERROR","TIMEOUT"].includes(s)}var c=class{constructor(t){let e=typeof t=="string"?{apiKey:t}:t;if(!e.apiKey)throw new Error("Valta API key is required. Get one at https://valta.co/dashboard/api-keys");this.http=new R(e),this.auth=new d(this.http),this.agents=new m(this.http),this.wallets=new y(this.http),this.policies=new E(this.http),this.audit=new g(this.http),this.keys=new h(this.http);}};
+export{A as AuthError,T as NotFoundError,I as RateLimitError,P as TierError,c as Valta,c as ValtaClient,n as ValtaError,c as default};

package/package.json

@@ -1,35 +1,56 @@
-{
-  "name": "valta-sdk",
-  "version": "2.1.7",
-  "description": "Official SDK for Valta — AI agent financial infrastructure",
-  "main": "dist/index.js",
-  "module": "dist/index.mjs",
-  "types": "dist/index.d.ts",
-  "exports": {
-    
-    ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.mjs",
-      "require": "./dist/index.js"
-    }
-  },
-  "bin": {
-  "valta": "bin/valta.js"
-},
-  "files": [
-    "dist",
-    "bin"
-  ],
-  "scripts": {
-    "build": "tsup src/index.ts src/cli/index.ts --format cjs,esm --dts",
-    "dev": "tsup src/index.ts --format cjs,esm --dts --watch"
-  },
-  "keywords": ["valta", "ai", "agents", "payments", "usdc"],
-  "author": "Valta",
-  "license": "MIT",
-  "type": "module",
-  "devDependencies": {
-    "tsup": "^8.5.1",
-    "typescript": "^5.9.3"
-  }
-}
+{
+  "name": "valta-sdk",
+  "version": "2.2.2",
+  "description": "Financial governance infrastructure for autonomous AI agents",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "bin": {
+    "valta": "bin/valta.js"
+  },
+  "files": [
+    "dist/index.js",
+    "dist/index.cjs",
+    "dist/index.d.ts",
+    "dist/cli/index.js",
+    "bin",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "test": "vitest run --pool forks",
+    "test:watch": "vitest --pool forks",
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "npm run build && npm run test && npm run typecheck"
+  },
+  "keywords": [
+    "ai",
+    "agents",
+    "financial",
+    "governance",
+    "wallet",
+    "valta"
+  ],
+  "author": "Valta",
+  "license": "MIT",
+  "homepage": "https://valta.co/docs",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Billionaire664/Valta.co"
+  },
+  "type": "module",
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "tsup": "^8.5.1",
+    "typescript": "^5.9.3",
+    "vitest": "^1.6.1"
+  }
+}