@coinbase/agentkit 0.3.0 → 0.5.0

package/dist/action-providers/defillama/utils.test.js

@@ -0,0 +1,124 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("./utils");
+describe("DefiLlama Utilities", () => {
+    describe("pruneGetProtocolResponse", () => {
+        it("should handle null input", () => {
+            expect((0, utils_1.pruneGetProtocolResponse)(null)).toBeNull();
+        });
+        it("should not modify objects without time-series data", () => {
+            const input = {
+                id: "test-protocol",
+                name: "Protocol",
+                symbol: "ABC",
+            };
+            const result = (0, utils_1.pruneGetProtocolResponse)(input);
+            expect(result).not.toBeNull();
+            expect(result).toEqual(input);
+        });
+        it("should prune time-series arrays", () => {
+            const timeSeriesData = Array.from({ length: 20 }, (_, i) => ({
+                date: Date.now() - i * 86400000,
+                totalLiquidityUSD: 1000 + i,
+            }));
+            const input = {
+                id: "test-protocol",
+                name: "Protocol",
+                tvl: [...timeSeriesData],
+            };
+            const result = (0, utils_1.pruneGetProtocolResponse)(input, 5);
+            expect(result).not.toBeNull();
+            if (result) {
+                expect(result.name).toBe("Protocol");
+                expect(result.tvl).toHaveLength(5);
+                const resultDates = result.tvl.map(entry => entry.date);
+                const sortedDates = [...resultDates].sort((a, b) => b - a);
+                expect(resultDates).toEqual(sortedDates);
+            }
+        });
+        it("should prune nested time-series arrays in chainTvls", () => {
+            const timeSeriesData = Array.from({ length: 20 }, (_, i) => ({
+                date: Date.now() - i * 86400000,
+                totalLiquidityUSD: 1000 + i,
+            }));
+            const tokenTimeSeriesData = Array.from({ length: 20 }, (_, i) => ({
+                date: Date.now() - i * 86400000,
+                tokens: { ETH: 1000 + i },
+            }));
+            const input = {
+                id: "test-protocol",
+                name: "Protocol",
+                chainTvls: {
+                    Ethereum: {
+                        tvl: [...timeSeriesData],
+                        tokens: [...tokenTimeSeriesData],
+                    },
+                    Polygon: {
+                        tvl: [...timeSeriesData],
+                        tokensInUsd: [...tokenTimeSeriesData],
+                    },
+                },
+            };
+            const result = (0, utils_1.pruneGetProtocolResponse)(input, 3);
+            expect(result).not.toBeNull();
+            if (result) {
+                expect(result.name).toBe("Protocol");
+                expect(result.chainTvls).toBeDefined();
+                if (result.chainTvls) {
+                    expect(result.chainTvls.Ethereum.tvl).toHaveLength(3);
+                    expect(result.chainTvls.Ethereum.tokens).toHaveLength(3);
+                    expect(result.chainTvls.Polygon.tvl).toHaveLength(3);
+                    expect(result.chainTvls.Polygon.tokensInUsd).toHaveLength(3);
+                    const ethereumTvlDates = result.chainTvls.Ethereum.tvl.map(entry => entry.date);
+                    const sortedDates = [...ethereumTvlDates].sort((a, b) => b - a);
+                    expect(ethereumTvlDates).toEqual(sortedDates);
+                }
+            }
+        });
+        it("should respect the maxEntries parameter", () => {
+            const timeSeriesData = Array.from({ length: 50 }, (_, i) => ({
+                date: Date.now() - i * 86400000,
+                totalLiquidityUSD: 1000 + i,
+            }));
+            const tokenTimeSeriesData = Array.from({ length: 50 }, (_, i) => ({
+                date: Date.now() - i * 86400000,
+                tokens: { ETH: 1000 + i },
+            }));
+            const input = {
+                id: "test-protocol",
+                name: "Protocol",
+                tvl: [...timeSeriesData],
+                tokens: [...tokenTimeSeriesData],
+            };
+            const result1 = (0, utils_1.pruneGetProtocolResponse)(input, 1);
+            expect(result1).not.toBeNull();
+            if (result1) {
+                expect(result1.tvl).toHaveLength(1);
+                expect(result1.tokens).toHaveLength(1);
+            }
+            const result10 = (0, utils_1.pruneGetProtocolResponse)(input, 10);
+            expect(result10).not.toBeNull();
+            if (result10) {
+                expect(result10.tvl).toHaveLength(10);
+                expect(result10.tokens).toHaveLength(10);
+            }
+        });
+        it("should handle arrays without date property", () => {
+            const nonDateArray = Array.from({ length: 20 }, (_, i) => ({
+                value: 1000 + i,
+                name: `Item ${i}`,
+            }));
+            // Using a type assertion for this test case as it's testing a specific behavior
+            const input = {
+                id: "test-protocol",
+                name: "Protocol",
+                tvl: [...nonDateArray],
+            };
+            const result = (0, utils_1.pruneGetProtocolResponse)(input, 5);
+            expect(result).not.toBeNull();
+            if (result) {
+                expect(result.tvl).toHaveLength(5);
+            }
+        });
+    });
+});

package/dist/action-providers/erc20/constants.d.ts

@@ -133,3 +133,5 @@ export declare const abi: readonly [{
         readonly type: "bool";
     }];
 }];
+export declare const BaseTokenToAssetId: Map<string, string>;
+export declare const BaseSepoliaTokenToAssetId: Map<string, string>;

package/dist/action-providers/erc20/constants.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.abi = void 0;
+exports.BaseSepoliaTokenToAssetId = exports.BaseTokenToAssetId = exports.abi = void 0;
+const coinbase_sdk_1 = require("@coinbase/coinbase-sdk");
 exports.abi = [
     {
         type: "event",
@@ -189,3 +190,13 @@ exports.abi = [
         ],
     },
 ];
+exports.BaseTokenToAssetId = new Map([
+    ["0xcbB7C0000aB88B473b1f5aFd9ef808440eed33Bf", coinbase_sdk_1.Coinbase.assets.Cbbtc],
+    ["0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913", coinbase_sdk_1.Coinbase.assets.Usdc],
+    ["0x60a3E35Cc302bFA44Cb288Bc5a4F316Fdb1adb42", coinbase_sdk_1.Coinbase.assets.Eurc],
+]);
+exports.BaseSepoliaTokenToAssetId = new Map([
+    ["0xcbB7C0006F23900c38EB856149F799620fcb8A4a", coinbase_sdk_1.Coinbase.assets.Cbbtc],
+    ["0x036CbD53842c5426634e7929541eC2318f3dCF7e", coinbase_sdk_1.Coinbase.assets.Usdc],
+    ["0x808456652fdb597867f38412077A9182bf77359F", coinbase_sdk_1.Coinbase.assets.Eurc],
+]);

package/dist/action-providers/erc20/erc20ActionProvider.js

@@ -70,6 +70,24 @@ class ERC20ActionProvider extends actionProvider_1.ActionProvider {
      */
     async transfer(walletProvider, args) {
         try {
+            // Check if we can do gasless transfer
+            const isCdpWallet = walletProvider.getName() === "cdp_wallet_provider";
+            const network = walletProvider.getNetwork();
+            const tokenAddress = (0, viem_1.getAddress)(args.contractAddress);
+            const canDoGasless = isCdpWallet &&
+                ((network.networkId === "base-mainnet" && constants_1.BaseTokenToAssetId.has(tokenAddress)) ||
+                    (network.networkId === "base-sepolia" && constants_1.BaseSepoliaTokenToAssetId.has(tokenAddress)));
+            if (canDoGasless) {
+                // Cast to CdpWalletProvider to access erc20Transfer
+                const cdpWallet = walletProvider;
+                const assetId = network.networkId === "base-mainnet"
+                    ? constants_1.BaseTokenToAssetId.get(tokenAddress)
+                    : constants_1.BaseSepoliaTokenToAssetId.get(tokenAddress);
+                const hash = await cdpWallet.gaslessERC20Transfer(assetId, args.destination, args.amount);
+                await walletProvider.waitForTransactionReceipt(hash);
+                return `Transferred ${args.amount} of ${args.contractAddress} to ${args.destination} using gasless transfer.\nTransaction hash: ${hash}`;
+            }
+            // Fallback to regular transfer
             const hash = await walletProvider.sendTransaction({
                 to: args.contractAddress,
                 data: (0, viem_1.encodeFunctionData)({

package/dist/action-providers/erc20/erc20ActionProvider.test.js

@@ -74,6 +74,10 @@ describe("Transfer Action", () => {
         mockWallet = {
             sendTransaction: jest.fn(),
             waitForTransactionReceipt: jest.fn(),
+            getName: jest.fn().mockReturnValue("evm_wallet_provider"),
+            getNetwork: jest.fn().mockReturnValue({
+                networkId: "base-mainnet",
+            }),
         };
         mockWallet.sendTransaction.mockResolvedValue(TRANSACTION_HASH);
         mockWallet.waitForTransactionReceipt.mockResolvedValue({});

package/dist/action-providers/index.d.ts

@@ -1,14 +1,17 @@
 export * from "./actionDecorator";
 export * from "./actionProvider";
 export * from "./customActionProvider";
+export * from "./across";
 export * from "./alchemy";
 export * from "./basename";
 export * from "./cdp";
 export * from "./compound";
+export * from "./defillama";
 export * from "./erc20";
 export * from "./erc721";
 export * from "./farcaster";
 export * from "./jupiter";
+export * from "./messari";
 export * from "./pyth";
 export * from "./moonwell";
 export * from "./morpho";

package/dist/action-providers/index.js

@@ -17,14 +17,17 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./actionDecorator"), exports);
 __exportStar(require("./actionProvider"), exports);
 __exportStar(require("./customActionProvider"), exports);
+__exportStar(require("./across"), exports);
 __exportStar(require("./alchemy"), exports);
 __exportStar(require("./basename"), exports);
 __exportStar(require("./cdp"), exports);
 __exportStar(require("./compound"), exports);
+__exportStar(require("./defillama"), exports);
 __exportStar(require("./erc20"), exports);
 __exportStar(require("./erc721"), exports);
 __exportStar(require("./farcaster"), exports);
 __exportStar(require("./jupiter"), exports);
+__exportStar(require("./messari"), exports);
 __exportStar(require("./pyth"), exports);
 __exportStar(require("./moonwell"), exports);
 __exportStar(require("./morpho"), exports);

package/dist/action-providers/messari/constants.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Base URL for the Messari API
+ */
+export declare const MESSARI_BASE_URL = "https://api.messari.io/ai/v1";
+/**
+ * Default error message when API key is missing
+ */
+export declare const API_KEY_MISSING_ERROR = "MESSARI_API_KEY is not configured.";
+/**
+ * Rate limits by subscription tier
+ */
+export declare const RATE_LIMITS: {
+    FREE: string;
+    LITE: string;
+    PRO: string;
+    ENTERPRISE: string;
+};

package/dist/action-providers/messari/constants.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RATE_LIMITS = exports.API_KEY_MISSING_ERROR = exports.MESSARI_BASE_URL = void 0;
+/**
+ * Base URL for the Messari API
+ */
+exports.MESSARI_BASE_URL = "https://api.messari.io/ai/v1";
+/**
+ * Default error message when API key is missing
+ */
+exports.API_KEY_MISSING_ERROR = "MESSARI_API_KEY is not configured.";
+/**
+ * Rate limits by subscription tier
+ */
+exports.RATE_LIMITS = {
+    FREE: "2 requests per day",
+    LITE: "10 requests per day",
+    PRO: "20 requests per day",
+    ENTERPRISE: "50 requests per day",
+};

package/dist/action-providers/messari/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./messariActionProvider";
+export * from "./schemas";
+export * from "./types";
+export * from "./constants";
+export * from "./utils";

package/dist/action-providers/messari/index.js

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./messariActionProvider"), exports);
+__exportStar(require("./schemas"), exports);
+__exportStar(require("./types"), exports);
+__exportStar(require("./constants"), exports);
+__exportStar(require("./utils"), exports);

package/dist/action-providers/messari/messariActionProvider.d.ts

@@ -0,0 +1,42 @@
+import { z } from "zod";
+import { ActionProvider } from "../actionProvider";
+import { Network } from "../../network";
+import { MessariResearchQuestionSchema } from "./schemas";
+import { MessariActionProviderConfig } from "./types";
+/**
+ * MessariActionProvider is an action provider for Messari AI toolkit interactions.
+ * It enables AI agents to ask research questions about crypto markets, protocols, and tokens.
+ *
+ * @augments ActionProvider
+ */
+export declare class MessariActionProvider extends ActionProvider {
+    private readonly apiKey;
+    /**
+     * Constructor for the MessariActionProvider class.
+     *
+     * @param config - The configuration options for the MessariActionProvider
+     */
+    constructor(config?: MessariActionProviderConfig);
+    /**
+     * Makes a request to the Messari AI API with a research question
+     *
+     * @param args - The arguments containing the research question
+     * @returns A string containing the research results or an error message
+     */
+    researchQuestion(args: z.infer<typeof MessariResearchQuestionSchema>): Promise<string>;
+    /**
+     * Checks if the action provider supports the given network.
+     * Messari research is network-agnostic, so it supports all networks.
+     *
+     * @param _ - The network to check
+     * @returns Always returns true as Messari research is network-agnostic
+     */
+    supportsNetwork(_: Network): boolean;
+}
+/**
+ * Factory function to create a new MessariActionProvider instance.
+ *
+ * @param config - The configuration options for the MessariActionProvider
+ * @returns A new instance of MessariActionProvider
+ */
+export declare const messariActionProvider: (config?: MessariActionProviderConfig) => MessariActionProvider;

package/dist/action-providers/messari/messariActionProvider.js

@@ -0,0 +1,128 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.messariActionProvider = exports.MessariActionProvider = void 0;
+const zod_1 = require("zod");
+const actionProvider_1 = require("../actionProvider");
+const actionDecorator_1 = require("../actionDecorator");
+const schemas_1 = require("./schemas");
+const constants_1 = require("./constants");
+const utils_1 = require("./utils");
+/**
+ * MessariActionProvider is an action provider for Messari AI toolkit interactions.
+ * It enables AI agents to ask research questions about crypto markets, protocols, and tokens.
+ *
+ * @augments ActionProvider
+ */
+class MessariActionProvider extends actionProvider_1.ActionProvider {
+    /**
+     * Constructor for the MessariActionProvider class.
+     *
+     * @param config - The configuration options for the MessariActionProvider
+     */
+    constructor(config = {}) {
+        super("messari", []);
+        config.apiKey || (config.apiKey = process.env.MESSARI_API_KEY);
+        if (!config.apiKey) {
+            throw new Error(constants_1.API_KEY_MISSING_ERROR);
+        }
+        this.apiKey = config.apiKey;
+    }
+    /**
+     * Makes a request to the Messari AI API with a research question
+     *
+     * @param args - The arguments containing the research question
+     * @returns A string containing the research results or an error message
+     */
+    async researchQuestion(args) {
+        try {
+            // Make API request
+            const response = await fetch(`${constants_1.MESSARI_BASE_URL}/chat/completions`, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    "x-messari-api-key": this.apiKey,
+                },
+                body: JSON.stringify({
+                    messages: [
+                        {
+                            role: "user",
+                            content: args.question,
+                        },
+                    ],
+                }),
+            });
+            if (!response.ok) {
+                throw await (0, utils_1.createMessariError)(response);
+            }
+            // Parse and validate response
+            let data;
+            try {
+                data = (await response.json());
+            }
+            catch (jsonError) {
+                throw new Error(`Failed to parse API response: ${jsonError instanceof Error ? jsonError.message : String(jsonError)}`);
+            }
+            if (!data.data?.messages?.[0]?.content) {
+                throw new Error("Received invalid response format from Messari API");
+            }
+            const result = data.data.messages[0].content;
+            return `Messari Research Results:\n\n${result}`;
+        }
+        catch (error) {
+            if (error instanceof Error && "responseText" in error) {
+                return (0, utils_1.formatMessariApiError)(error);
+            }
+            return (0, utils_1.formatGenericError)(error);
+        }
+    }
+    /**
+     * Checks if the action provider supports the given network.
+     * Messari research is network-agnostic, so it supports all networks.
+     *
+     * @param _ - The network to check
+     * @returns Always returns true as Messari research is network-agnostic
+     */
+    supportsNetwork(_) {
+        return true; // Messari research is network-agnostic
+    }
+}
+exports.MessariActionProvider = MessariActionProvider;
+__decorate([
+    (0, actionDecorator_1.CreateAction)({
+        name: "research_question",
+        description: `
+This tool queries Messari AI for comprehensive crypto research across these datasets:
+1. News/Content - Latest crypto news, blogs, podcasts
+2. Exchanges - CEX/DEX volumes, market share, assets listed
+3. Onchain Data - Active addresses, transaction fees, total transactions.
+4. Token Unlocks - Upcoming supply unlocks, vesting schedules, and token emission details
+5. Market Data - Asset prices, trading volume, market cap, TVL, and historical performance
+6. Fundraising - Investment data, funding rounds, venture capital activity.
+7. Protocol Research - Technical analysis of how protocols work, tokenomics, and yield mechanisms
+8. Social Data - Twitter followers and Reddit subscribers metrics, growth trends
+
+Examples: "Which DEXs have the highest trading volume this month?", "When is Arbitrum's next major token unlock?", "How does Morpho generate yield for users?", "Which cryptocurrency has gained the most Twitter followers in 2023?", "What did Vitalik Buterin say about rollups in his recent blog posts?"
+    `,
+        schema: schemas_1.MessariResearchQuestionSchema,
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [void 0]),
+    __metadata("design:returntype", Promise)
+], MessariActionProvider.prototype, "researchQuestion", null);
+/**
+ * Factory function to create a new MessariActionProvider instance.
+ *
+ * @param config - The configuration options for the MessariActionProvider
+ * @returns A new instance of MessariActionProvider
+ */
+const messariActionProvider = (config = {}) => new MessariActionProvider(config);
+exports.messariActionProvider = messariActionProvider;

package/dist/action-providers/messari/messariActionProvider.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/action-providers/messari/messariActionProvider.test.js

@@ -0,0 +1,152 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const messariActionProvider_1 = require("./messariActionProvider");
+const constants_1 = require("./constants");
+const MOCK_API_KEY = "messari-test-key";
+const MOCK_RESEARCH_RESPONSE = {
+    data: {
+        messages: [
+            {
+                role: "assistant",
+                content: "Ethereum (ETH) has shown strong performance over the past month with a 15% price increase. The current price is approximately $3,500, up from $3,000 at the beginning of the month. Trading volume has also increased by 20% in the same period.",
+            },
+        ],
+    },
+};
+const MOCK_ERROR_RESPONSE = {
+    error: "Internal server error, please try again. If the problem persists, please contact support",
+    data: null,
+};
+describe("MessariActionProvider", () => {
+    let provider;
+    beforeEach(() => {
+        process.env.MESSARI_API_KEY = MOCK_API_KEY;
+        provider = (0, messariActionProvider_1.messariActionProvider)({ apiKey: MOCK_API_KEY });
+        jest.restoreAllMocks();
+    });
+    afterEach(() => {
+        jest.clearAllMocks();
+        delete process.env.MESSARI_API_KEY;
+    });
+    describe("constructor", () => {
+        it("should initialize with API key from constructor", () => {
+            const customProvider = (0, messariActionProvider_1.messariActionProvider)({ apiKey: "custom-key" });
+            expect(customProvider["apiKey"]).toBe("custom-key");
+        });
+        it("should initialize with API key from environment variable", () => {
+            process.env.MESSARI_API_KEY = "env-key";
+            const envProvider = (0, messariActionProvider_1.messariActionProvider)();
+            expect(envProvider["apiKey"]).toBe("env-key");
+        });
+        it("should throw error if API key is not provided", () => {
+            delete process.env.MESSARI_API_KEY;
+            expect(() => (0, messariActionProvider_1.messariActionProvider)()).toThrow(constants_1.API_KEY_MISSING_ERROR);
+        });
+    });
+    describe("researchQuestion", () => {
+        it("should successfully fetch research results", async () => {
+            const fetchMock = jest.spyOn(global, "fetch").mockResolvedValue({
+                ok: true,
+                json: async () => MOCK_RESEARCH_RESPONSE,
+            });
+            const question = "What is the current price of Ethereum?";
+            const response = await provider.researchQuestion({ question });
+            expect(fetchMock).toHaveBeenCalled();
+            const [url, options] = fetchMock.mock.calls[0];
+            expect(url).toBe("https://api.messari.io/ai/v1/chat/completions");
+            expect(options).toEqual(expect.objectContaining({
+                method: "POST",
+                headers: expect.objectContaining({
+                    "Content-Type": "application/json",
+                    "x-messari-api-key": MOCK_API_KEY,
+                }),
+                body: JSON.stringify({
+                    messages: [
+                        {
+                            role: "user",
+                            content: question,
+                        },
+                    ],
+                }),
+            }));
+            expect(response).toContain("Messari Research Results:");
+            expect(response).toContain(MOCK_RESEARCH_RESPONSE.data.messages[0].content);
+        });
+        it("should handle non-ok response with structured error format", async () => {
+            const errorResponseText = JSON.stringify(MOCK_ERROR_RESPONSE);
+            jest.spyOn(global, "fetch").mockResolvedValue({
+                ok: false,
+                status: 500,
+                statusText: "Internal Server Error",
+                text: async () => errorResponseText,
+            });
+            const response = await provider.researchQuestion({
+                question: "What is the current price of Bitcoin?",
+            });
+            expect(response).toContain("Messari API Error: Internal server error");
+            expect(response).not.toContain("500");
+        });
+        it("should handle non-ok response with non-JSON error format", async () => {
+            const plainTextError = "Rate limit exceeded";
+            jest.spyOn(global, "fetch").mockResolvedValue({
+                ok: false,
+                status: 429,
+                statusText: "Too Many Requests",
+                text: async () => plainTextError,
+            });
+            const response = await provider.researchQuestion({
+                question: "What is the current price of Bitcoin?",
+            });
+            expect(response).toContain("Messari API Error:");
+            expect(response).toContain("429");
+            expect(response).toContain("Too Many Requests");
+            expect(response).toContain(plainTextError);
+        });
+        it("should handle JSON parsing error in successful response", async () => {
+            jest.spyOn(global, "fetch").mockResolvedValue({
+                ok: true,
+                json: async () => {
+                    throw new Error("Invalid JSON");
+                },
+            });
+            const response = await provider.researchQuestion({
+                question: "What is the market cap of Solana?",
+            });
+            expect(response).toContain("Unexpected error: Failed to parse API response");
+            expect(response).toContain("Invalid JSON");
+        });
+        it("should handle invalid response format", async () => {
+            jest.spyOn(global, "fetch").mockResolvedValue({
+                ok: true,
+                json: async () => ({ data: { messages: [] } }),
+            });
+            const response = await provider.researchQuestion({
+                question: "What is the market cap of Solana?",
+            });
+            expect(response).toContain("Unexpected error: Received invalid response format from Messari API");
+        });
+        it("should handle fetch error", async () => {
+            const error = new Error("Network error");
+            jest.spyOn(global, "fetch").mockRejectedValue(error);
+            const response = await provider.researchQuestion({
+                question: "What is the market cap of Solana?",
+            });
+            expect(response).toContain("Unexpected error: Network error");
+        });
+        it("should handle string error with JSON content", async () => {
+            const stringifiedError = JSON.stringify(MOCK_ERROR_RESPONSE);
+            jest.spyOn(global, "fetch").mockRejectedValue(stringifiedError);
+            const response = await provider.researchQuestion({
+                question: "What is the market cap of Solana?",
+            });
+            expect(response).toContain("Messari API Error: Internal server error");
+        });
+    });
+    describe("supportsNetwork", () => {
+        it("should always return true as research is network-agnostic", () => {
+            expect(provider.supportsNetwork({ protocolFamily: "evm" })).toBe(true);
+            expect(provider.supportsNetwork({ protocolFamily: "solana" })).toBe(true);
+            expect(provider.supportsNetwork({ protocolFamily: "unknown" })).toBe(true);
+        });
+    });
+});

package/dist/action-providers/messari/schemas.d.ts

@@ -0,0 +1,11 @@
+import { z } from "zod";
+/**
+ * Input schema for submitting a research question to Messari AI.
+ */
+export declare const MessariResearchQuestionSchema: z.ZodObject<{
+    question: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    question: string;
+}, {
+    question: string;
+}>;

package/dist/action-providers/messari/schemas.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MessariResearchQuestionSchema = void 0;
+const zod_1 = require("zod");
+/**
+ * Input schema for submitting a research question to Messari AI.
+ */
+exports.MessariResearchQuestionSchema = zod_1.z
+    .object({
+    question: zod_1.z
+        .string()
+        .min(1, "Research question is required.")
+        .describe("The research question about crypto markets, protocols, or tokens"),
+})
+    .strip()
+    .describe("Input schema for submitting a research question to Messari AI");