valta-sdk 2.0.0

package/README.md

@@ -0,0 +1,158 @@
+# Valta SDK
+
+Official TypeScript SDK for [Valta](https://valta.co) - Programmable AI Agent Spending Controls.
+
+## Installation
+
+```bash
+npm install valta-sdk
+```
+
+## Quick Start
+
+```typescript
+import { Valta } from "valta-sdk";
+
+const valta = new Valta({
+  apiKey: "sk_valta_...", // Your API key from valta.co/dashboard/api-keys
+});
+
+// Request agent spending permission
+const result = await valta.requestSpend({
+  agentId: "research-agent",
+  amount: 20,
+  category: "api_calls",
+  description: "Purchase dataset access",
+});
+
+if (result.approved) {
+  console.log("Approved! TX:", result.tx_id);
+} else if (result.requires_approval) {
+  console.log("Pending human approval:", result.request_id);
+} else {
+  console.log("Denied:", result.reason);
+}
+```
+
+## Features
+
+- **Spending Controls** - Request permission before agents spend money
+- **Spending Policies** - Set per-transaction, daily, and monthly limits
+- **Human Approval Mode** - Require manual approval above thresholds
+- **Kill Switch** - Instantly freeze agent spending
+- **Agent Tools** - Configure and execute agent tools
+- **Agent Chains** - Create agent-to-agent workflows
+- **Balance Queries** - Check wallet balance programmatically
+
+## API Reference
+
+### Initialize
+
+```typescript
+const valta = new Valta({
+  apiKey: "sk_valta_...",
+  baseUrl: "https://valta.co", // optional, defaults to production
+});
+```
+
+### Spending
+
+```typescript
+// Request a spend action
+const result = await valta.requestSpend({
+  agentId: "my-agent",
+  amount: 10,
+  category: "api_calls",
+  description: "Call external API",
+});
+
+// Check balance
+const { balance, currency } = await valta.getBalance();
+```
+
+### Policies
+
+```typescript
+// Create a spending policy
+const policy = await valta.createPolicy({
+  agentId: "research-agent",
+  name: "Research Budget",
+  dailyLimit: 100,
+  monthlyLimit: 1000,
+  maxPerTransaction: 50,
+  requireApprovalAbove: 25,
+  allowedCategories: ["api_calls", "datasets"],
+});
+
+// List all policies
+const policies = await valta.listPolicies();
+```
+
+### Approvals
+
+```typescript
+// Get pending approvals
+const pending = await valta.getPendingApprovals();
+
+// Approve or reject
+await valta.approveRequest(requestId);
+await valta.rejectRequest(requestId, "Too expensive");
+```
+
+### Kill Switch
+
+```typescript
+// Freeze an agent immediately
+await valta.freezeAgent("rogue-agent", "Suspicious activity detected");
+
+// Unfreeze when resolved
+await valta.unfreezeAgent("rogue-agent");
+```
+
+### Agent Tools
+
+```typescript
+// Get tools configured for an agent
+const tools = await valta.getAgentTools("my-agent");
+
+// Toggle a tool on/off
+await valta.toggleTool(toolId, false);
+
+// Execute a tool
+const result = await valta.executeTool("my-agent", toolId, { query: "data" });
+```
+
+### Agent Chains
+
+```typescript
+// Create an agent chain (agent-to-agent workflow)
+const chain = await valta.createChain({
+  name: "Research Pipeline",
+  steps: [
+    { order: 1, agent_id: "research", agent_name: "Research Agent", action: "gather_data", input_from: "user" },
+    { order: 2, agent_id: "analysis", agent_name: "Analysis Agent", action: "analyze", input_from: "previous" },
+    { order: 3, agent_id: "report", agent_name: "Report Agent", action: "generate_report", input_from: "previous" },
+  ],
+});
+
+// Execute a chain
+await valta.executeChain(chain.chain_id);
+```
+
+## Error Handling
+
+```typescript
+import { ValtaError } from "valta-sdk";
+
+try {
+  await valta.requestSpend({ agentId: "agent", amount: 1000 });
+} catch (error) {
+  if (error instanceof ValtaError) {
+    console.error(`Valta error (${error.status}):`, error.message);
+  }
+}
+```
+
+## License
+
+MIT

package/bin/valta.js

@@ -0,0 +1,159 @@
+#!/usr/bin/env node
+
+import { readFileSync, writeFileSync, existsSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+
+const CONFIG_FILE = join(homedir(), ".valta", "config.json");
+const VERSION = "2.0.0";
+
+function loadConfig() {
+  if (!existsSync(CONFIG_FILE)) return {};
+  try { return JSON.parse(readFileSync(CONFIG_FILE, "utf8")); } catch { return {}; }
+}
+
+function saveConfig(data) {
+  const dir = join(homedir(), ".valta");
+  if (!existsSync(dir)) {
+    const { mkdirSync } = await import("fs");
+    mkdirSync(dir, { recursive: true });
+  }
+  writeFileSync(CONFIG_FILE, JSON.stringify(data, null, 2));
+}
+
+const args = process.argv.slice(2);
+const command = args[0];
+
+const help = `
+  Valta CLI v${VERSION}
+
+  COMMANDS
+    valta init              Initialize a new Valta project
+    valta login             Save your API key
+    valta create-agent      Generate an agent starter file
+    valta run               Run a quick agent query
+    valta --version         Show CLI version
+    valta help              Show this help
+
+  EXAMPLES
+    valta login
+    valta create-agent trading
+    valta run "What is BTC doing today?" --agent trading_signal
+`;
+
+async function main() {
+  switch (command) {
+    case "init": {
+      const template = `// Valta project starter
+// https://valta.co/docs
+
+import { ValtaClient } from "valta-sdk";
+
+const valta = new ValtaClient({
+  apiKey: process.env.VALTA_API_KEY,
+});
+
+// List available agents
+const agents = await valta.listAgents();
+console.log("Available agents:", agents.map(a => a.name));
+
+// Chat with the Trading Signal agent
+const agent = valta.createAgent("trading_signal");
+const response = await agent.chat("What is BTC doing today?");
+console.log(response.message);
+`;
+      writeFileSync("valta-starter.js", template);
+      console.log("✓ Created valta-starter.js");
+      console.log("  Run: node valta-starter.js");
+      break;
+    }
+
+    case "login": {
+      const { createInterface } = await import("readline");
+      const rl = createInterface({ input: process.stdin, output: process.stdout });
+      rl.question("Enter your Valta API key (from /dashboard/api-keys): ", (key) => {
+        rl.close();
+        const trimmed = key.trim();
+        if (!trimmed) { console.error("✗ No API key provided"); process.exit(1); }
+        const cfg = loadConfig();
+        cfg.apiKey = trimmed;
+        try { saveConfig(cfg); } catch {
+          const { mkdirSync } = require("fs");
+          mkdirSync(join(homedir(), ".valta"), { recursive: true });
+          saveConfig(cfg);
+        }
+        console.log(`✓ API key saved to ${CONFIG_FILE}`);
+        console.log("  You can now import it as: VALTA_API_KEY from your environment.");
+      });
+      break;
+    }
+
+    case "create-agent": {
+      const type = args[1] || "general";
+      const fileName = `${type}Agent.js`;
+      const agentTemplate = `// ${type.charAt(0).toUpperCase() + type.slice(1)} Agent — Valta SDK
+import { ValtaClient } from "valta-sdk";
+
+const valta = new ValtaClient({ apiKey: process.env.VALTA_API_KEY });
+const agent = valta.createAgent("${type}_agent");
+
+const response = await agent.chat("Your question here");
+console.log(response.message);
+`;
+      writeFileSync(fileName, agentTemplate);
+      console.log(`✓ Created ${fileName}`);
+      break;
+    }
+
+    case "run": {
+      const message = args[1];
+      const agentFlag = args.indexOf("--agent");
+      const agentId = agentFlag !== -1 ? args[agentFlag + 1] : "financial_advisor";
+
+      if (!message) {
+        console.error("Usage: valta run \"your question\" --agent <agent_id>");
+        process.exit(1);
+      }
+
+      const cfg = loadConfig();
+      const apiKey = cfg.apiKey || process.env.VALTA_API_KEY;
+      if (!apiKey) {
+        console.error("✗ No API key. Run: valta login");
+        process.exit(1);
+      }
+
+      console.log(`Running ${agentId}...`);
+      const res = await fetch(`https://valta.co/api/bot/${encodeURIComponent(agentId)}/chat`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json", "Authorization": `Bearer ${apiKey}` },
+        body: JSON.stringify({ message }),
+      });
+      const data = await res.json();
+      if (!res.ok) { console.error("✗", data.error || "Request failed"); process.exit(1); }
+      console.log("\n" + (data.message || data.response || JSON.stringify(data)));
+      break;
+    }
+
+    case "--version":
+    case "-v":
+      console.log(`valta-sdk v${VERSION}`);
+      break;
+
+    case "help":
+    case "--help":
+    case "-h":
+    case undefined:
+      console.log(help);
+      break;
+
+    default:
+      console.error(`Unknown command: ${command}`);
+      console.log(help);
+      process.exit(1);
+  }
+}
+
+main().catch((err) => {
+  console.error("✗", err.message);
+  process.exit(1);
+});

package/dist/index.d.mts

@@ -0,0 +1,167 @@
+interface ValtaConfig {
+    /** Your Valta API key — get it from /dashboard/api-keys */
+    apiKey: string;
+    /** Base URL. Defaults to https://valta.co */
+    baseUrl?: string;
+    /** Optional timeout in milliseconds. Default: 30000 */
+    timeout?: number;
+}
+
+type AgentCategory = "finance" | "trading" | "analytics" | "development" | "marketing" | "compliance" | "research" | "general";
+type PlanType = "FREE" | "PRO" | "ENTERPRISE";
+interface AgentConfig {
+    agentId: string;
+    name: string;
+    category: AgentCategory;
+    description?: string;
+    planRequired?: PlanType;
+    isLive?: boolean;
+}
+interface ChatMessage {
+    role: "user" | "assistant" | "system";
+    content: string;
+}
+interface ChatResponse {
+    message: string;
+    agentId: string;
+    tokens?: number;
+    provider?: string;
+}
+interface AutomationConfig {
+    name: string;
+    agentId: string;
+    task: string;
+    schedule: "daily" | "every:30m" | "every:1h" | "every:6h" | "every:12h" | "every:168h";
+    enabled?: boolean;
+}
+interface Automation {
+    automationId: string;
+    name: string;
+    agentId: string;
+    schedule: string;
+    enabled: boolean;
+    runCount: number;
+    lastRunAt: string | null;
+    nextRunAt: string | null;
+}
+interface PipelineStep {
+    agentId: string;
+    task: string;
+}
+interface PipelineConfig {
+    name: string;
+    description?: string;
+    steps: PipelineStep[];
+}
+interface PipelineResult {
+    agentId: string;
+    agentName: string;
+    response: string;
+    durationMs: number;
+}
+interface WalletBalance {
+    balance: number;
+    currency: string;
+}
+interface Transaction {
+    txnId: string;
+    type: string;
+    amount: number;
+    status: string;
+    createdAt: string;
+}
+
+declare class WalletTool {
+    private apiKey;
+    private baseUrl;
+    constructor(apiKey: string, baseUrl: string);
+    getBalance(): Promise<WalletBalance>;
+    getTransactions(limit?: number): Promise<Transaction[]>;
+    getAddress(): Promise<string>;
+}
+
+interface AnalyticsSummary {
+    totalSpend: number;
+    topAgents: Array<{
+        agentId: string;
+        name: string;
+        spend: number;
+    }>;
+    spendByDay: Array<{
+        date: string;
+        amount: number;
+    }>;
+}
+declare class AnalyticsTool {
+    private apiKey;
+    private baseUrl;
+    constructor(apiKey: string, baseUrl: string);
+    getSummary(): Promise<AnalyticsSummary>;
+    getAuditTrail(limit?: number): Promise<unknown[]>;
+}
+
+declare class TradingAgent {
+    private apiKey;
+    private baseUrl;
+    constructor(apiKey: string, baseUrl: string);
+    analyze(question: string): Promise<ChatResponse>;
+    getMarketBrief(): Promise<string>;
+    getSignals(assets: string[]): Promise<string>;
+}
+
+declare class PortfolioAgent {
+    private apiKey;
+    private baseUrl;
+    constructor(apiKey: string, baseUrl: string);
+    analyze(question: string): Promise<ChatResponse>;
+    getReport(): Promise<string>;
+    getRebalancingSuggestions(targetAllocation: Record<string, number>): Promise<string>;
+}
+
+type Plugin = (client: ValtaClient) => void;
+declare class ValtaClient {
+    readonly apiKey: string;
+    readonly baseUrl: string;
+    readonly wallet: WalletTool;
+    readonly analytics: AnalyticsTool;
+    readonly trading: TradingAgent;
+    readonly portfolio: PortfolioAgent;
+    private plugins;
+    constructor(config: ValtaConfig);
+    use(plugin: Plugin): this;
+    listAgents(): Promise<AgentConfig[]>;
+    createAgent(agentId: string): AgentHandle;
+    createAutomation(config: AutomationConfig): Promise<Automation>;
+    listAutomations(): Promise<Automation[]>;
+    runAutomation(automationId: string): Promise<{
+        response: string | null;
+    }>;
+    createPipeline(config: PipelineConfig): Promise<string>;
+    runPipeline(pipelineId: string): Promise<PipelineResult[]>;
+}
+declare class AgentHandle {
+    private apiKey;
+    private baseUrl;
+    readonly agentId: string;
+    constructor(apiKey: string, baseUrl: string, agentId: string);
+    chat(message: string, conversationId?: string): Promise<ChatResponse>;
+    run(): this;
+}
+
+declare class ValtaError extends Error {
+    status: number;
+    code?: string;
+    constructor(message: string, status?: number, code?: string);
+}
+declare class ValtaAuthError extends ValtaError {
+    constructor(message?: string);
+}
+declare class ValtaRateLimitError extends ValtaError {
+    retryAfter?: number;
+    constructor(message?: string, retryAfter?: number);
+}
+declare class ValtaUpgradeError extends ValtaError {
+    constructor(message?: string);
+}
+
+export { type AgentCategory, type AgentConfig, AgentHandle, AnalyticsTool, type Automation, type AutomationConfig, type ChatMessage, type ChatResponse, type PipelineConfig, type PipelineResult, type PipelineStep, type PlanType, PortfolioAgent, TradingAgent, type Transaction, ValtaAuthError, ValtaClient, type ValtaConfig, ValtaError, ValtaRateLimitError, ValtaUpgradeError, type WalletBalance, WalletTool, ValtaClient as default };

package/dist/index.d.ts

@@ -0,0 +1,167 @@
+interface ValtaConfig {
+    /** Your Valta API key — get it from /dashboard/api-keys */
+    apiKey: string;
+    /** Base URL. Defaults to https://valta.co */
+    baseUrl?: string;
+    /** Optional timeout in milliseconds. Default: 30000 */
+    timeout?: number;
+}
+
+type AgentCategory = "finance" | "trading" | "analytics" | "development" | "marketing" | "compliance" | "research" | "general";
+type PlanType = "FREE" | "PRO" | "ENTERPRISE";
+interface AgentConfig {
+    agentId: string;
+    name: string;
+    category: AgentCategory;
+    description?: string;
+    planRequired?: PlanType;
+    isLive?: boolean;
+}
+interface ChatMessage {
+    role: "user" | "assistant" | "system";
+    content: string;
+}
+interface ChatResponse {
+    message: string;
+    agentId: string;
+    tokens?: number;
+    provider?: string;
+}
+interface AutomationConfig {
+    name: string;
+    agentId: string;
+    task: string;
+    schedule: "daily" | "every:30m" | "every:1h" | "every:6h" | "every:12h" | "every:168h";
+    enabled?: boolean;
+}
+interface Automation {
+    automationId: string;
+    name: string;
+    agentId: string;
+    schedule: string;
+    enabled: boolean;
+    runCount: number;
+    lastRunAt: string | null;
+    nextRunAt: string | null;
+}
+interface PipelineStep {
+    agentId: string;
+    task: string;
+}
+interface PipelineConfig {
+    name: string;
+    description?: string;
+    steps: PipelineStep[];
+}
+interface PipelineResult {
+    agentId: string;
+    agentName: string;
+    response: string;
+    durationMs: number;
+}
+interface WalletBalance {
+    balance: number;
+    currency: string;
+}
+interface Transaction {
+    txnId: string;
+    type: string;
+    amount: number;
+    status: string;
+    createdAt: string;
+}
+
+declare class WalletTool {
+    private apiKey;
+    private baseUrl;
+    constructor(apiKey: string, baseUrl: string);
+    getBalance(): Promise<WalletBalance>;
+    getTransactions(limit?: number): Promise<Transaction[]>;
+    getAddress(): Promise<string>;
+}
+
+interface AnalyticsSummary {
+    totalSpend: number;
+    topAgents: Array<{
+        agentId: string;
+        name: string;
+        spend: number;
+    }>;
+    spendByDay: Array<{
+        date: string;
+        amount: number;
+    }>;
+}
+declare class AnalyticsTool {
+    private apiKey;
+    private baseUrl;
+    constructor(apiKey: string, baseUrl: string);
+    getSummary(): Promise<AnalyticsSummary>;
+    getAuditTrail(limit?: number): Promise<unknown[]>;
+}
+
+declare class TradingAgent {
+    private apiKey;
+    private baseUrl;
+    constructor(apiKey: string, baseUrl: string);
+    analyze(question: string): Promise<ChatResponse>;
+    getMarketBrief(): Promise<string>;
+    getSignals(assets: string[]): Promise<string>;
+}
+
+declare class PortfolioAgent {
+    private apiKey;
+    private baseUrl;
+    constructor(apiKey: string, baseUrl: string);
+    analyze(question: string): Promise<ChatResponse>;
+    getReport(): Promise<string>;
+    getRebalancingSuggestions(targetAllocation: Record<string, number>): Promise<string>;
+}
+
+type Plugin = (client: ValtaClient) => void;
+declare class ValtaClient {
+    readonly apiKey: string;
+    readonly baseUrl: string;
+    readonly wallet: WalletTool;
+    readonly analytics: AnalyticsTool;
+    readonly trading: TradingAgent;
+    readonly portfolio: PortfolioAgent;
+    private plugins;
+    constructor(config: ValtaConfig);
+    use(plugin: Plugin): this;
+    listAgents(): Promise<AgentConfig[]>;
+    createAgent(agentId: string): AgentHandle;
+    createAutomation(config: AutomationConfig): Promise<Automation>;
+    listAutomations(): Promise<Automation[]>;
+    runAutomation(automationId: string): Promise<{
+        response: string | null;
+    }>;
+    createPipeline(config: PipelineConfig): Promise<string>;
+    runPipeline(pipelineId: string): Promise<PipelineResult[]>;
+}
+declare class AgentHandle {
+    private apiKey;
+    private baseUrl;
+    readonly agentId: string;
+    constructor(apiKey: string, baseUrl: string, agentId: string);
+    chat(message: string, conversationId?: string): Promise<ChatResponse>;
+    run(): this;
+}
+
+declare class ValtaError extends Error {
+    status: number;
+    code?: string;
+    constructor(message: string, status?: number, code?: string);
+}
+declare class ValtaAuthError extends ValtaError {
+    constructor(message?: string);
+}
+declare class ValtaRateLimitError extends ValtaError {
+    retryAfter?: number;
+    constructor(message?: string, retryAfter?: number);
+}
+declare class ValtaUpgradeError extends ValtaError {
+    constructor(message?: string);
+}
+
+export { type AgentCategory, type AgentConfig, AgentHandle, AnalyticsTool, type Automation, type AutomationConfig, type ChatMessage, type ChatResponse, type PipelineConfig, type PipelineResult, type PipelineStep, type PlanType, PortfolioAgent, TradingAgent, type Transaction, ValtaAuthError, ValtaClient, type ValtaConfig, ValtaError, ValtaRateLimitError, ValtaUpgradeError, type WalletBalance, WalletTool, ValtaClient as default };

package/dist/index.js

@@ -0,0 +1,355 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AgentHandle: () => AgentHandle,
+  AnalyticsTool: () => AnalyticsTool,
+  PortfolioAgent: () => PortfolioAgent,
+  TradingAgent: () => TradingAgent,
+  ValtaAuthError: () => ValtaAuthError,
+  ValtaClient: () => ValtaClient,
+  ValtaError: () => ValtaError,
+  ValtaRateLimitError: () => ValtaRateLimitError,
+  ValtaUpgradeError: () => ValtaUpgradeError,
+  WalletTool: () => WalletTool,
+  default: () => ValtaClient
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/core/config.ts
+var DEFAULT_BASE_URL = "https://valta.co";
+function validateConfig(config) {
+  if (!config.apiKey || typeof config.apiKey !== "string") {
+    throw new Error("ValtaClient: apiKey is required. Get yours at https://valta.co/dashboard/api-keys");
+  }
+  return {
+    apiKey: config.apiKey.trim(),
+    baseUrl: (config.baseUrl || DEFAULT_BASE_URL).replace(/\/$/, ""),
+    timeout: config.timeout || 3e4
+  };
+}
+
+// src/utils/errors.ts
+var ValtaError = class extends Error {
+  constructor(message, status = 500, code) {
+    super(message);
+    this.name = "ValtaError";
+    this.status = status;
+    this.code = code;
+  }
+};
+var ValtaAuthError = class extends ValtaError {
+  constructor(message = "Invalid or missing API key") {
+    super(message, 401, "AUTH_ERROR");
+    this.name = "ValtaAuthError";
+  }
+};
+var ValtaRateLimitError = class extends ValtaError {
+  constructor(message = "Rate limit exceeded", retryAfter) {
+    super(message, 429, "RATE_LIMIT");
+    this.name = "ValtaRateLimitError";
+    this.retryAfter = retryAfter;
+  }
+};
+var ValtaUpgradeError = class extends ValtaError {
+  constructor(message = "Upgrade your plan to access this feature") {
+    super(message, 403, "UPGRADE_REQUIRED");
+    this.name = "ValtaUpgradeError";
+  }
+};
+
+// src/utils/http.ts
+async function request(apiKey, baseUrl, method, path, body) {
+  const url = `${baseUrl.replace(/\/$/, "")}${path}`;
+  const res = await fetch(url, {
+    method,
+    headers: {
+      "Content-Type": "application/json",
+      "Authorization": `Bearer ${apiKey}`,
+      "X-Valta-SDK": "1.0.0"
+    },
+    body: body ? JSON.stringify(body) : void 0
+  });
+  if (!res.ok) {
+    let parsed;
+    try {
+      parsed = await res.json();
+    } catch {
+      parsed = {};
+    }
+    const message = parsed?.error || parsed?.message || `HTTP ${res.status}`;
+    const code = parsed?.code;
+    if (res.status === 401) throw new ValtaAuthError(message);
+    if (res.status === 403) throw new ValtaUpgradeError(message);
+    if (res.status === 429) {
+      const retryAfter = Number(res.headers.get("retry-after")) || void 0;
+      throw new ValtaRateLimitError(message, retryAfter);
+    }
+    throw new ValtaError(message, res.status, code);
+  }
+  return res.json();
+}
+async function get(apiKey, baseUrl, path) {
+  return request(apiKey, baseUrl, "GET", path);
+}
+async function post(apiKey, baseUrl, path, body) {
+  return request(apiKey, baseUrl, "POST", path, body);
+}
+
+// src/tools/wallet.ts
+var WalletTool = class {
+  constructor(apiKey, baseUrl) {
+    this.apiKey = apiKey;
+    this.baseUrl = baseUrl;
+  }
+  async getBalance() {
+    const res = await get(
+      this.apiKey,
+      this.baseUrl,
+      "/api/user/wallet/balance"
+    );
+    return { balance: res.balance || 0, currency: res.currency || "USDC" };
+  }
+  async getTransactions(limit = 20) {
+    const res = await get(
+      this.apiKey,
+      this.baseUrl,
+      `/api/user/transactions?limit=${limit}`
+    );
+    return res.transactions || res.data || [];
+  }
+  async getAddress() {
+    const res = await get(
+      this.apiKey,
+      this.baseUrl,
+      "/api/user/wallet"
+    );
+    return res.address || res.walletAddress || "";
+  }
+};
+
+// src/tools/analytics.ts
+var AnalyticsTool = class {
+  constructor(apiKey, baseUrl) {
+    this.apiKey = apiKey;
+    this.baseUrl = baseUrl;
+  }
+  async getSummary() {
+    const res = await get(
+      this.apiKey,
+      this.baseUrl,
+      "/api/user/analytics"
+    );
+    return res.summary || { totalSpend: 0, topAgents: [], spendByDay: [] };
+  }
+  async getAuditTrail(limit = 50) {
+    const res = await get(
+      this.apiKey,
+      this.baseUrl,
+      `/api/user/audit-trail?limit=${limit}`
+    );
+    return res.events || [];
+  }
+};
+
+// src/agents/tradingAgent.ts
+var TRADING_AGENT_ID = "trading_signal";
+var TradingAgent = class {
+  constructor(apiKey, baseUrl) {
+    this.apiKey = apiKey;
+    this.baseUrl = baseUrl;
+  }
+  async analyze(question) {
+    const res = await post(
+      this.apiKey,
+      this.baseUrl,
+      `/api/bot/${TRADING_AGENT_ID}/chat`,
+      { message: question }
+    );
+    return { message: res.message || "", agentId: TRADING_AGENT_ID, tokens: res.tokens, provider: res.provider };
+  }
+  async getMarketBrief() {
+    const res = await this.analyze(
+      "Give me a brief market analysis for BTC, ETH, and SOL. Include price action, key levels, and sentiment."
+    );
+    return res.message;
+  }
+  async getSignals(assets) {
+    const assetList = assets.join(", ").toUpperCase();
+    const res = await this.analyze(
+      `Provide buy/sell/hold signals for: ${assetList}. Include entry price, target, and stop-loss.`
+    );
+    return res.message;
+  }
+};
+
+// src/agents/portfolioAgent.ts
+var PORTFOLIO_AGENT_ID = "portfolio_analyzer";
+var PortfolioAgent = class {
+  constructor(apiKey, baseUrl) {
+    this.apiKey = apiKey;
+    this.baseUrl = baseUrl;
+  }
+  async analyze(question) {
+    const res = await post(
+      this.apiKey,
+      this.baseUrl,
+      `/api/bot/${PORTFOLIO_AGENT_ID}/chat`,
+      { message: question }
+    );
+    return { message: res.message || "", agentId: PORTFOLIO_AGENT_ID, tokens: res.tokens, provider: res.provider };
+  }
+  async getReport() {
+    const res = await this.analyze(
+      "Generate a full portfolio health report. Include current allocation, risk score, and rebalancing suggestions."
+    );
+    return res.message;
+  }
+  async getRebalancingSuggestions(targetAllocation) {
+    const allocStr = Object.entries(targetAllocation).map(([asset, pct]) => `${asset}: ${pct}%`).join(", ");
+    const res = await this.analyze(
+      `Suggest how to rebalance my portfolio to reach this target allocation: ${allocStr}`
+    );
+    return res.message;
+  }
+};
+
+// src/core/client.ts
+var ValtaClient = class {
+  constructor(config) {
+    this.plugins = [];
+    const validated = validateConfig(config);
+    this.apiKey = validated.apiKey;
+    this.baseUrl = validated.baseUrl;
+    this.wallet = new WalletTool(this.apiKey, this.baseUrl);
+    this.analytics = new AnalyticsTool(this.apiKey, this.baseUrl);
+    this.trading = new TradingAgent(this.apiKey, this.baseUrl);
+    this.portfolio = new PortfolioAgent(this.apiKey, this.baseUrl);
+  }
+  // ── Plugin system (express-style middleware) ────────────────
+  use(plugin) {
+    plugin(this);
+    this.plugins.push(plugin);
+    return this;
+  }
+  // ── Agents ──────────────────────────────────────────────────
+  async listAgents() {
+    const res = await get(
+      this.apiKey,
+      this.baseUrl,
+      "/api/agents"
+    );
+    return res.agents || res.capabilities || [];
+  }
+  createAgent(agentId) {
+    return new AgentHandle(this.apiKey, this.baseUrl, agentId);
+  }
+  // ── Automations ─────────────────────────────────────────────
+  async createAutomation(config) {
+    const res = await post(
+      this.apiKey,
+      this.baseUrl,
+      "/api/user/automations",
+      {
+        name: config.name,
+        triggerType: "schedule",
+        schedule: config.schedule,
+        agentId: config.agentId,
+        enabled: config.enabled ?? true,
+        payload: JSON.stringify({ task: config.task })
+      }
+    );
+    const list = await this.listAutomations();
+    return list.find((a) => a.automationId === res.automationId) || { automationId: res.automationId };
+  }
+  async listAutomations() {
+    const res = await get(
+      this.apiKey,
+      this.baseUrl,
+      "/api/user/automations"
+    );
+    return res.automations || [];
+  }
+  async runAutomation(automationId) {
+    const res = await post(
+      this.apiKey,
+      this.baseUrl,
+      `/api/user/automations/${encodeURIComponent(automationId)}/run`
+    );
+    return { response: res.result?.agentResponse || null };
+  }
+  // ── Multi-Agent Pipelines (Enterprise) ──────────────────────
+  async createPipeline(config) {
+    const res = await post(
+      this.apiKey,
+      this.baseUrl,
+      "/api/user/pipelines",
+      config
+    );
+    return res.pipelineId;
+  }
+  async runPipeline(pipelineId) {
+    const res = await post(
+      this.apiKey,
+      this.baseUrl,
+      `/api/user/pipelines/${encodeURIComponent(pipelineId)}/run`
+    );
+    return res.results || [];
+  }
+};
+var AgentHandle = class {
+  constructor(apiKey, baseUrl, agentId) {
+    this.apiKey = apiKey;
+    this.baseUrl = baseUrl;
+    this.agentId = agentId;
+  }
+  async chat(message, conversationId) {
+    const res = await post(
+      this.apiKey,
+      this.baseUrl,
+      `/api/bot/${encodeURIComponent(this.agentId)}/chat`,
+      { message, conversationId }
+    );
+    return {
+      message: res.message || "",
+      agentId: this.agentId,
+      tokens: res.tokens,
+      provider: res.provider
+    };
+  }
+  run() {
+    console.log(`Agent ${this.agentId} is ready. Use .chat(message) to interact.`);
+    return this;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AgentHandle,
+  AnalyticsTool,
+  PortfolioAgent,
+  TradingAgent,
+  ValtaAuthError,
+  ValtaClient,
+  ValtaError,
+  ValtaRateLimitError,
+  ValtaUpgradeError,
+  WalletTool
+});

package/dist/index.mjs

@@ -0,0 +1,319 @@
+// src/core/config.ts
+var DEFAULT_BASE_URL = "https://valta.co";
+function validateConfig(config) {
+  if (!config.apiKey || typeof config.apiKey !== "string") {
+    throw new Error("ValtaClient: apiKey is required. Get yours at https://valta.co/dashboard/api-keys");
+  }
+  return {
+    apiKey: config.apiKey.trim(),
+    baseUrl: (config.baseUrl || DEFAULT_BASE_URL).replace(/\/$/, ""),
+    timeout: config.timeout || 3e4
+  };
+}
+
+// src/utils/errors.ts
+var ValtaError = class extends Error {
+  constructor(message, status = 500, code) {
+    super(message);
+    this.name = "ValtaError";
+    this.status = status;
+    this.code = code;
+  }
+};
+var ValtaAuthError = class extends ValtaError {
+  constructor(message = "Invalid or missing API key") {
+    super(message, 401, "AUTH_ERROR");
+    this.name = "ValtaAuthError";
+  }
+};
+var ValtaRateLimitError = class extends ValtaError {
+  constructor(message = "Rate limit exceeded", retryAfter) {
+    super(message, 429, "RATE_LIMIT");
+    this.name = "ValtaRateLimitError";
+    this.retryAfter = retryAfter;
+  }
+};
+var ValtaUpgradeError = class extends ValtaError {
+  constructor(message = "Upgrade your plan to access this feature") {
+    super(message, 403, "UPGRADE_REQUIRED");
+    this.name = "ValtaUpgradeError";
+  }
+};
+
+// src/utils/http.ts
+async function request(apiKey, baseUrl, method, path, body) {
+  const url = `${baseUrl.replace(/\/$/, "")}${path}`;
+  const res = await fetch(url, {
+    method,
+    headers: {
+      "Content-Type": "application/json",
+      "Authorization": `Bearer ${apiKey}`,
+      "X-Valta-SDK": "1.0.0"
+    },
+    body: body ? JSON.stringify(body) : void 0
+  });
+  if (!res.ok) {
+    let parsed;
+    try {
+      parsed = await res.json();
+    } catch {
+      parsed = {};
+    }
+    const message = parsed?.error || parsed?.message || `HTTP ${res.status}`;
+    const code = parsed?.code;
+    if (res.status === 401) throw new ValtaAuthError(message);
+    if (res.status === 403) throw new ValtaUpgradeError(message);
+    if (res.status === 429) {
+      const retryAfter = Number(res.headers.get("retry-after")) || void 0;
+      throw new ValtaRateLimitError(message, retryAfter);
+    }
+    throw new ValtaError(message, res.status, code);
+  }
+  return res.json();
+}
+async function get(apiKey, baseUrl, path) {
+  return request(apiKey, baseUrl, "GET", path);
+}
+async function post(apiKey, baseUrl, path, body) {
+  return request(apiKey, baseUrl, "POST", path, body);
+}
+
+// src/tools/wallet.ts
+var WalletTool = class {
+  constructor(apiKey, baseUrl) {
+    this.apiKey = apiKey;
+    this.baseUrl = baseUrl;
+  }
+  async getBalance() {
+    const res = await get(
+      this.apiKey,
+      this.baseUrl,
+      "/api/user/wallet/balance"
+    );
+    return { balance: res.balance || 0, currency: res.currency || "USDC" };
+  }
+  async getTransactions(limit = 20) {
+    const res = await get(
+      this.apiKey,
+      this.baseUrl,
+      `/api/user/transactions?limit=${limit}`
+    );
+    return res.transactions || res.data || [];
+  }
+  async getAddress() {
+    const res = await get(
+      this.apiKey,
+      this.baseUrl,
+      "/api/user/wallet"
+    );
+    return res.address || res.walletAddress || "";
+  }
+};
+
+// src/tools/analytics.ts
+var AnalyticsTool = class {
+  constructor(apiKey, baseUrl) {
+    this.apiKey = apiKey;
+    this.baseUrl = baseUrl;
+  }
+  async getSummary() {
+    const res = await get(
+      this.apiKey,
+      this.baseUrl,
+      "/api/user/analytics"
+    );
+    return res.summary || { totalSpend: 0, topAgents: [], spendByDay: [] };
+  }
+  async getAuditTrail(limit = 50) {
+    const res = await get(
+      this.apiKey,
+      this.baseUrl,
+      `/api/user/audit-trail?limit=${limit}`
+    );
+    return res.events || [];
+  }
+};
+
+// src/agents/tradingAgent.ts
+var TRADING_AGENT_ID = "trading_signal";
+var TradingAgent = class {
+  constructor(apiKey, baseUrl) {
+    this.apiKey = apiKey;
+    this.baseUrl = baseUrl;
+  }
+  async analyze(question) {
+    const res = await post(
+      this.apiKey,
+      this.baseUrl,
+      `/api/bot/${TRADING_AGENT_ID}/chat`,
+      { message: question }
+    );
+    return { message: res.message || "", agentId: TRADING_AGENT_ID, tokens: res.tokens, provider: res.provider };
+  }
+  async getMarketBrief() {
+    const res = await this.analyze(
+      "Give me a brief market analysis for BTC, ETH, and SOL. Include price action, key levels, and sentiment."
+    );
+    return res.message;
+  }
+  async getSignals(assets) {
+    const assetList = assets.join(", ").toUpperCase();
+    const res = await this.analyze(
+      `Provide buy/sell/hold signals for: ${assetList}. Include entry price, target, and stop-loss.`
+    );
+    return res.message;
+  }
+};
+
+// src/agents/portfolioAgent.ts
+var PORTFOLIO_AGENT_ID = "portfolio_analyzer";
+var PortfolioAgent = class {
+  constructor(apiKey, baseUrl) {
+    this.apiKey = apiKey;
+    this.baseUrl = baseUrl;
+  }
+  async analyze(question) {
+    const res = await post(
+      this.apiKey,
+      this.baseUrl,
+      `/api/bot/${PORTFOLIO_AGENT_ID}/chat`,
+      { message: question }
+    );
+    return { message: res.message || "", agentId: PORTFOLIO_AGENT_ID, tokens: res.tokens, provider: res.provider };
+  }
+  async getReport() {
+    const res = await this.analyze(
+      "Generate a full portfolio health report. Include current allocation, risk score, and rebalancing suggestions."
+    );
+    return res.message;
+  }
+  async getRebalancingSuggestions(targetAllocation) {
+    const allocStr = Object.entries(targetAllocation).map(([asset, pct]) => `${asset}: ${pct}%`).join(", ");
+    const res = await this.analyze(
+      `Suggest how to rebalance my portfolio to reach this target allocation: ${allocStr}`
+    );
+    return res.message;
+  }
+};
+
+// src/core/client.ts
+var ValtaClient = class {
+  constructor(config) {
+    this.plugins = [];
+    const validated = validateConfig(config);
+    this.apiKey = validated.apiKey;
+    this.baseUrl = validated.baseUrl;
+    this.wallet = new WalletTool(this.apiKey, this.baseUrl);
+    this.analytics = new AnalyticsTool(this.apiKey, this.baseUrl);
+    this.trading = new TradingAgent(this.apiKey, this.baseUrl);
+    this.portfolio = new PortfolioAgent(this.apiKey, this.baseUrl);
+  }
+  // ── Plugin system (express-style middleware) ────────────────
+  use(plugin) {
+    plugin(this);
+    this.plugins.push(plugin);
+    return this;
+  }
+  // ── Agents ──────────────────────────────────────────────────
+  async listAgents() {
+    const res = await get(
+      this.apiKey,
+      this.baseUrl,
+      "/api/agents"
+    );
+    return res.agents || res.capabilities || [];
+  }
+  createAgent(agentId) {
+    return new AgentHandle(this.apiKey, this.baseUrl, agentId);
+  }
+  // ── Automations ─────────────────────────────────────────────
+  async createAutomation(config) {
+    const res = await post(
+      this.apiKey,
+      this.baseUrl,
+      "/api/user/automations",
+      {
+        name: config.name,
+        triggerType: "schedule",
+        schedule: config.schedule,
+        agentId: config.agentId,
+        enabled: config.enabled ?? true,
+        payload: JSON.stringify({ task: config.task })
+      }
+    );
+    const list = await this.listAutomations();
+    return list.find((a) => a.automationId === res.automationId) || { automationId: res.automationId };
+  }
+  async listAutomations() {
+    const res = await get(
+      this.apiKey,
+      this.baseUrl,
+      "/api/user/automations"
+    );
+    return res.automations || [];
+  }
+  async runAutomation(automationId) {
+    const res = await post(
+      this.apiKey,
+      this.baseUrl,
+      `/api/user/automations/${encodeURIComponent(automationId)}/run`
+    );
+    return { response: res.result?.agentResponse || null };
+  }
+  // ── Multi-Agent Pipelines (Enterprise) ──────────────────────
+  async createPipeline(config) {
+    const res = await post(
+      this.apiKey,
+      this.baseUrl,
+      "/api/user/pipelines",
+      config
+    );
+    return res.pipelineId;
+  }
+  async runPipeline(pipelineId) {
+    const res = await post(
+      this.apiKey,
+      this.baseUrl,
+      `/api/user/pipelines/${encodeURIComponent(pipelineId)}/run`
+    );
+    return res.results || [];
+  }
+};
+var AgentHandle = class {
+  constructor(apiKey, baseUrl, agentId) {
+    this.apiKey = apiKey;
+    this.baseUrl = baseUrl;
+    this.agentId = agentId;
+  }
+  async chat(message, conversationId) {
+    const res = await post(
+      this.apiKey,
+      this.baseUrl,
+      `/api/bot/${encodeURIComponent(this.agentId)}/chat`,
+      { message, conversationId }
+    );
+    return {
+      message: res.message || "",
+      agentId: this.agentId,
+      tokens: res.tokens,
+      provider: res.provider
+    };
+  }
+  run() {
+    console.log(`Agent ${this.agentId} is ready. Use .chat(message) to interact.`);
+    return this;
+  }
+};
+export {
+  AgentHandle,
+  AnalyticsTool,
+  PortfolioAgent,
+  TradingAgent,
+  ValtaAuthError,
+  ValtaClient,
+  ValtaError,
+  ValtaRateLimitError,
+  ValtaUpgradeError,
+  WalletTool,
+  ValtaClient as default
+};

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "valta-sdk",
+  "version": "2.0.0",
+  "description": "Official Valta SDK — AI agents, automations, pipelines, and wallet tools",
+  "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": "./bin/valta.js",
+  "files": [
+    "dist",
+    "bin"
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts --format cjs,esm --dts",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "valta",
+    "ai",
+    "agent",
+    "wallet",
+    "automation",
+    "pipeline",
+    "fintech",
+    "sdk",
+    "trading",
+    "portfolio"
+  ],
+  "author": "Valta",
+  "license": "MIT",
+  "homepage": "https://valta.co",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Billionaire664/Valta.co.git"
+  },
+  "devDependencies": {
+    "tsup": "^8.0.0",
+    "typescript": "^5.0.0"
+  }
+}