Building an App

my-app/
├─ Cargo.toml
├─ aomi.toml          (contributor apps only — see "The aomi.toml manifest")
└─ src/
   ├─ lib.rs          App registration + preamble (via dyn_aomi_app!)
   ├─ client.rs       HTTP client + typed models + tool arg structs
   └─ tool.rs         Tool implementations (DynAomiTool)

use aomi_sdk::*;

mod client;
mod tool;

const PREAMBLE: &str = r#"## Role
You are a lightweight example app for market lookup and simple HTTP API integration.

## Purpose
- Demonstrate the recommended Aomi app file structure
- Show how to wrap a public JSON API with typed tools
- Keep the example free of private infrastructure assumptions

## Workflow
1. Use `search_coins` to find a CoinGecko asset ID.
2. Use `get_coin_price` to fetch the current USD price for that asset.
"#;

dyn_aomi_app!(
    app = client::HttpJsonExampleApp,
    name = "http-json-example",
    version = "0.1.0",
    preamble = PREAMBLE,
    tools = [client::SearchCoins, client::GetCoinPrice,],
    namespaces = []
);

const PREAMBLE: &str = r#"## Role
You are **DeFi Data Assistant**, a read-only analyst backed by DeFiLlama's free public API.
Your job is to answer questions about token prices, protocol size, chain activity, and yield
opportunities — never to execute trades.

## Capabilities
- **Token prices** -- `defillama_get_token_price` for current price.
- **Protocols** -- `defillama_list_protocols` ranks protocols by current TVL.
- **Chains** -- `defillama_get_chain_tvl` returns the chain leaderboard by TVL.

## Conventions
- **No auth.** DefiLlama is a free public API; no key is needed.
- **Coin identifiers** use `coingecko:<id>` (e.g. `coingecko:bitcoin`) or `<chain>:<address>`.
- **Protocol slugs** match DefiLlama URLs (e.g. `aave-v3`, `uniswap`, `lido`).

## Formatting
- Format USD amounts: TVL > $1B as `$X.XXB`, > $1M as `$XXX.XM`, otherwise `$X,XXX`.
"#;

You are the MyCoinDex trading assistant.

## Capabilities
- Check real-time token prices
- View user portfolio and P&L
- Execute trades (with user confirmation)
- List available trading pairs

## Rules
- Always confirm with the user before executing a trade
- Show prices in USD unless the user requests otherwise
- If you don't have data for a token, say so clearly
- Never fabricate prices or portfolio data

## Tone
- Professional but approachable
- Concise responses unless the user asks for detail
- Use bullet points for lists of data

use crate::client::*;
use aomi_sdk::*;
use serde_json::{Value, json};

pub(crate) struct SearchCoins;

impl DynAomiTool for SearchCoins {
    type App = HttpJsonExampleApp;
    type Args = SearchCoinsArgs;
    const NAME: &'static str = "search_coins";
    const DESCRIPTION: &'static str =
        "Search CoinGecko for matching assets and return coin ids developers can use in follow-up price calls.";

    fn run(
        _app: &HttpJsonExampleApp,
        args: Self::Args,
        _ctx: DynToolCallCtx,
    ) -> Result<Value, String> {
        let client = CoinGeckoClient::new()?;
        let value = client.get_json("/search", &[("query", args.query.as_str())])?;
        // ...normalize into stable JSON...
        Ok(json!({ "query": args.query, "matches": value }))
    }
}

use aomi_sdk::schemars::JsonSchema;
use serde::Deserialize;

#[derive(Debug, Deserialize, JsonSchema)]
pub(crate) struct SearchCoinsArgs {
    /// Free-form search query such as `bitcoin`, `eth`, or `dogecoin`
    pub(crate) query: String,
}

#[derive(Debug, Deserialize, JsonSchema)]
pub(crate) struct GetCoinPriceArgs {
    /// CoinGecko coin id such as `bitcoin` or `ethereum`
    pub(crate) coin_id: String,
}

pub(crate) struct CoinGeckoClient {
    pub(crate) http: reqwest::blocking::Client,
}

impl CoinGeckoClient {
    pub(crate) fn get_json(&self, path: &str, query: &[(&str, &str)]) -> Result<Value, String> {
        let url = format!("{API_BASE}{path}");
        let response = self.http.get(&url).query(query).send()
            .map_err(|e| format!("CoinGecko request failed: {e}"))?;
        let status = response.status();
        let body = response.text().unwrap_or_default();
        if !status.is_success() {
            return Err(format!("CoinGecko error {status}: {body}"));
        }
        serde_json::from_str(&body).map_err(|e| format!("CoinGecko decode failed: {e}"))
    }
}

dyn_aomi_app!(
    app = tool::DefiLlamaApp,
    name = "defillama",
    version = "0.1.0",
    preamble = PREAMBLE,
    tools = [tool::GetTokenPrice, tool::ListProtocols, tool::GetChainTvl],
    namespaces = ["evm-core"]
);

[app]
name         = "my-cool-app"            # slug — kebab-case, becomes the release tag
display_name = "My Cool App"            # human-readable name
platform     = "community"              # the platform you publish to
git          = "https://github.com/aomi-labs/community-apps"
public       = true                     # visible to all backend users

# Optional. Which backend tier may load this release.
# Omit to default to ["staging"]. Set to ["prod"] once tested,
# or ["staging", "prod"] for both.
# server_tags = ["staging"]

[package]
name = "my-cool-app"
version = "0.1.0"
edition = "2024"

[lib]
crate-type = ["cdylib"]

[dependencies]
aomi-sdk   = "=0.1.20"          # match platform.json's required_sdk_version
serde      = { version = "1", features = ["derive"] }
serde_json = "1"