Agent Use Cases

import { AgenticBrowser } from '@agentic-browser/sdk';

class ResearchAgent {
  constructor(
    private browser: AgenticBrowser,
    private spendingPolicy: SpendingPolicy
  ) {
    // Configure auto-approval threshold
    this.spendingPolicy.setSessionLimit(20_00); // $20 per session
    this.spendingPolicy.setDailyLimit(100_00);  // $100 per day
  }

  async researchTopic(query: string): Promise<ResearchReport> {
    console.log(`Starting research: "${query}"`);

    // Step 1: Search academic databases (x402 APIs)
    const searchResults = await Promise.all([
      this.searchArXiv(query),
      this.searchIEEE(query),
      this.searchGoogleScholar(query),
    ]);

    // Automatically approved: $0.02 × 10 = $0.20 < session limit
    const papers = searchResults.flat().slice(0, 15);

    // Step 2: Access full-text papers (x402 paywalls)
    const fullTexts = await Promise.all(
      papers.map(paper => this.accessPaper(paper.doi))
    );
    // Cost: $0.50 × 15 = $7.50 (auto-approved, under session limit)

    // Step 3: LLM synthesis
    const synthesis = await this.synthesizeFindings(fullTexts);
    // Cost: ~$2.40 for 200k tokens (GPT-4)

    // Step 4: Fact-check claims
    const factChecked = await this.verifyClai ms(synthesis.claims);
    // Cost: $0.10 × 5 = $0.50

    // Total: $10.60 (within $20 session limit, no user prompt)
    return {
      query,
      papers,
      synthesis,
      factChecked,
      totalCost: 10.60,
      timestamp: Date.now(),
    };
  }

  private async searchArXiv(query: string): Promise<Paper[]> {
    // x402 payment handled automatically by browser
    const response = await this.browser.fetch('https://api.arxiv.org/search', {
      method: 'POST',
      body: JSON.stringify({ query, max_results: 5 }),
      // Browser intercepts 402 response, signs payment with threshold wallet
    });

    return response.json();
  }

  private async accessPaper(doi: string): Promise<string> {
    // Publisher returns 402 Payment Required
    // Browser pays $0.50 via x402, receives full-text PDF
    const response = await this.browser.fetch(`https://doi.org/${doi}`);
    return response.text();
  }

  private async synthesizeFindings(texts: string[]): Promise<Synthesis> {
    const combined = texts.join('\n\n');

    // OpenRouter x402 API (cost-basis pricing via >< token)
    const response = await this.browser.fetch('https://openrouter.ai/api/v1/chat', {
      method: 'POST',
      headers: { 'X-Payment-Token': '><' },
      body: JSON.stringify({
        model: 'openai/gpt-4-turbo',
        messages: [{
          role: 'user',
          content: `Synthesize key findings from these papers: ${combined.slice(0, 50000)}`
        }],
        max_tokens: 2000,
      }),
    });

    return response.json();
  }

  private async verifyClaims(claims: string[]): Promise<FactCheck[]> {
    // Fact-check API with x402 micropayment
    return Promise.all(
      claims.map(claim =>
        this.browser.fetch('https://factcheck.ai/verify', {
          method: 'POST',
          body: JSON.stringify({ claim }),
        }).then(r => r.json())
      )
    );
  }
}

// Usage
const agent = new ResearchAgent(browser, spendingPolicy);

const report = await agent.researchTopic(
  'Threshold signatures for MPC wallets: GG20 vs CGGMP21 comparison'
);

console.log(`Research complete. Cost: $${report.totalCost}`);
console.log(`Found ${report.papers.length} papers`);
console.log(`Synthesis: ${report.synthesis.summary}`);

import { AgenticBrowser } from '@agentic-browser/sdk';
import { PaymentChannelClient } from '@x402/solana';

class TradingAgent {
  private channel: PaymentChannelClient;

  constructor(
    private browser: AgenticBrowser,
    private spendingPolicy: SpendingPolicy
  ) {
    // High-frequency trading needs payment channels
    this.spendingPolicy.setHourlyLimit(10_00);  // $10/hour
    this.spendingPolicy.setPerTxLimit(0_10);    // $0.10 per transaction
  }

  async runMarketMakingSession(durationMs: number): Promise<SessionReport> {
    // Open payment channel with Jupiter API (off-chain updates)
    this.channel = await this.browser.payments.openChannel(
      JUPITER_API_PROVIDER,
      100_000_000n  // 100 USDC initial deposit
    );

    const startTime = Date.now();
    const trades: Trade[] = [];
    let apiCalls = 0;

    // Main trading loop
    while (Date.now() - startTime < durationMs) {
      // 1. Stream price data (x402 WebSocket, paid per message)
      const price = await this.getPriceUpdate();  // $0.0001
      apiCalls++;

      // 2. Fetch order book depth every 10 seconds
      if (apiCalls % 10 === 0) {
        const depth = await this.getOrderBook();  // $0.001
        apiCalls++;
      }

      // 3. Execute market-making strategy
      const signal = this.calculateSignal(price, depth);
      if (signal.shouldTrade) {
        const trade = await this.executeTrade(signal);  // $0.01
        trades.push(trade);
        apiCalls++;
      }

      // 4. Risk check every minute
      if (apiCalls % 60 === 0) {
        await this.analyzeRisk(trades);  // $0.02
        apiCalls++;
      }

      // Sleep until next iteration (1 second)
      await new Promise(resolve => setTimeout(resolve, 1000));
    }

    // Close payment channel (single on-chain TX)
    await this.channel.close();

    return {
      duration: durationMs,
      trades: trades.length,
      apiCalls,
      pnl: this.calculatePnL(trades),
      costs: {
        api: apiCalls * 0.0001,  // Approximate
        gas: 0.0002,              // 2 TX (open + close channel)
      },
    };
  }

  private async getPriceUpdate(): Promise<number> {
    // Payment channel automatically updates state (off-chain)
    // No user prompt, no on-chain TX, <10ms latency
    const response = await this.browser.fetch('https://price.jup.ag/v1/price', {
      method: 'GET',
      headers: {
        'X-Payment-Channel': this.channel.id,
      },
    });

    // Browser handles x402 payment via channel state update
    return (await response.json()).data.price;
  }

  private async executeTrade(signal: TradeSignal): Promise<Trade> {
    // Jupiter aggregator API with x402
    const response = await this.browser.fetch('https://quote-api.jup.ag/v6/quote', {
      method: 'POST',
      body: JSON.stringify({
        inputMint: signal.fromToken,
        outputMint: signal.toToken,
        amount: signal.amount,
        slippageBps: 50,
      }),
    });

    const quote = await response.json();

    // Execute swap (agent signs with 1-of-3 key share)
    const txSignature = await this.browser.wallet.signAndSend(
      quote.swapTransaction
    );

    return {
      signature: txSignature,
      amount: signal.amount,
      price: signal.price,
      timestamp: Date.now(),
    };
  }

  private calculateSignal(price: number, depth: OrderBook): TradeSignal {
    // Market-making logic: place orders at bid/ask
    const spread = depth.asks[0].price - depth.bids[0].price;

    if (spread > 0.001) {  // 0.1% spread = profitable
      return {
        shouldTrade: true,
        fromToken: 'USDC',
        toToken: 'SOL',
        amount: 1_000_000,  // 1 USDC
        price,
      };
    }

    return { shouldTrade: false };
  }

  private calculatePnL(trades: Trade[]): number {
    // Sum up spread capture from market-making
    return trades.reduce((pnl, trade) => {
      return pnl + (trade.sellPrice - trade.buyPrice) * trade.amount;
    }, 0);
  }
}

// Usage
const agent = new TradingAgent(browser, spendingPolicy);

const report = await agent.runMarketMakingSession(
  10 * 60 * 1000  // 10 minutes
);

console.log(`Session complete:
  Trades: ${report.trades}
  API Calls: ${report.apiCalls}
  PnL: $${report.pnl.toFixed(2)}
  API Cost: $${report.costs.api.toFixed(4)}
  Gas Cost: $${report.costs.gas.toFixed(4)}
  Net Profit: $${(report.pnl - report.costs.api - report.costs.gas).toFixed(2)}
`);

import { AgenticBrowser } from '@agentic-browser/sdk';

class ContentCreatorAgent {
  constructor(
    private browser: AgenticBrowser,
    private spendingPolicy: SpendingPolicy
  ) {
    this.spendingPolicy.setArticleLimit(5_00);  // $5 per article
  }

  async createArticle(topic: string, wordCount: number): Promise<Article> {
    console.log(`Creating article: "${topic}" (${wordCount} words)`);

    // Step 1: Research topic
    const research = await this.researchTopic(topic);
    // Cost: ~$1.05 (searches + content access)

    // Step 2: Generate draft
    const draft = await this.generateDraft(topic, research, wordCount);
    // Cost: ~$0.12 (GPT-4)

    // Step 3: Optimize for SEO
    const optimized = await this.optimizeSEO(draft);
    // Cost: $0.20

    // Step 4: Check originality
    const plagiarismScore = await this.checkPlagiarism(optimized);
    // Cost: $0.15

    // Step 5: Generate featured image
    const featuredImage = await this.generateImage(topic);
    // Cost: $0.04

    return {
      topic,
      content: optimized,
      wordCount: optimized.split(' ').length,
      seo: {
        keywords: optimized.keywords,
        readability: optimized.readabilityScore,
      },
      plagiarismScore,
      featuredImage,
      totalCost: 1.56,
      generationTime: '5 minutes',
    };
  }

  private async researchTopic(topic: string): Promise<Research> {
    // Search multiple sources
    const searches = await Promise.all([
      this.searchGoogle(topic),
      this.searchBing(topic),
      this.searchDuckDuckGo(topic),
    ]);

    const urls = searches.flat().slice(0, 10);

    // Access full articles (x402 micropayments bypass paywalls)
    const articles = await Promise.all(
      urls.map(url => this.fetchArticle(url))
    );

    return {
      sources: articles.length,
      content: articles.map(a => a.text).join('\n\n'),
      references: articles.map(a => ({ title: a.title, url: a.url })),
    };
  }

  private async fetchArticle(url: string): Promise<ArticleContent> {
    // Many news sites/blogs now support x402 micropayments
    // Instead of monthly subscription, pay $0.10 per article
    const response = await this.browser.fetch(url);

    // If server returns 402 Payment Required:
    // Browser automatically pays $0.10 via x402, receives content
    return {
      url,
      title: response.headers.get('X-Article-Title'),
      text: await response.text(),
    };
  }

  private async generateDraft(
    topic: string,
    research: Research,
    wordCount: number
  ): Promise<string> {
    // OpenRouter x402 API with cost-basis pricing
    const response = await this.browser.fetch('https://openrouter.ai/api/v1/chat', {
      method: 'POST',
      body: JSON.stringify({
        model: 'openai/gpt-4-turbo',
        messages: [{
          role: 'system',
          content: 'You are an expert technical writer specializing in blockchain and cryptography.'
        }, {
          role: 'user',
          content: `Write a ${wordCount}-word article on "${topic}" using these sources:\n\n${research.content.slice(0, 20000)}`
        }],
        max_tokens: Math.ceil(wordCount * 1.5),
      }),
    });

    return (await response.json()).choices[0].message.content;
  }

  private async optimizeSEO(content: string): Promise<OptimizedContent> {
    // SEO analysis API with x402
    const response = await this.browser.fetch('https://seo-api.example.com/optimize', {
      method: 'POST',
      body: JSON.stringify({ content }),
    });

    return response.json();
  }

  private async checkPlagiarism(content: string): Promise<number> {
    // Plagiarism detection with x402 ($0.15 per scan)
    const response = await this.browser.fetch('https://plagiarism.example.com/check', {
      method: 'POST',
      body: JSON.stringify({ text: content }),
    });

    return (await response.json()).originalityScore;
  }

  private async generateImage(topic: string): Promise<string> {
    // DALL-E 3 via OpenRouter x402
    const response = await this.browser.fetch('https://openrouter.ai/api/v1/images/generate', {
      method: 'POST',
      body: JSON.stringify({
        model: 'openai/dall-e-3',
        prompt: `Professional featured image for article about: ${topic}`,
        size: '1024x1024',
      }),
    });

    return (await response.json()).data[0].url;
  }
}

// Usage
const agent = new ContentCreatorAgent(browser, spendingPolicy);

const article = await agent.createArticle(
  'How threshold signatures secure MPC wallets',
  2000  // word count
);

console.log(`Article generated:
  Title: ${article.topic}
  Words: ${article.wordCount}
  SEO Score: ${article.seo.readability}/100
  Originality: ${article.plagiarismScore}%
  Cost: $${article.totalCost}
  Time: ${article.generationTime}
`);