@coinbase/agentkit 0.10.0 → 0.10.2

package/dist/action-providers/pyth/pythActionProvider.test.js

@@ -9,35 +9,180 @@ describe("PythActionProvider", () => {
         jest.resetAllMocks().restoreAllMocks();
     });
     describe("fetchPriceFeed", () => {
-        it("should return the first price feed ID that matches the input token symbol", async () => {
+        it("should return the first price feed ID that matches the input token symbol for crypto", async () => {
             fetchMock.mockResolvedValueOnce({
                 ok: true,
-                json: async () => [{ id: "some-price-feed-id", attributes: { base: "BTC" } }],
+                json: async () => [
+                    { id: "some-price-feed-id", attributes: { base: "BTC", quote_currency: "USD" } },
+                ],
             });
-            const priceFeedId = await provider.fetchPriceFeed({ tokenSymbol: "BTC" });
-            expect(priceFeedId).toEqual("some-price-feed-id");
+            const result = await provider.fetchPriceFeed({
+                tokenSymbol: "BTC",
+                assetType: "crypto",
+                quoteCurrency: "USD",
+            });
+            const parsed = JSON.parse(result);
+            expect(parsed.success).toBe(true);
+            expect(parsed.priceFeedID).toEqual("some-price-feed-id");
         });
-        it("should throw an error if no price feed is found", async () => {
+        it("should return the first price feed ID that matches the input token symbol for metals", async () => {
             fetchMock.mockResolvedValueOnce({
                 ok: true,
-                json: async () => [{ id: "some-price-feed-id", attributes: { base: "BTC" } }],
+                json: async () => [
+                    { id: "gold-price-feed-id", attributes: { base: "XAU", quote_currency: "USD" } },
+                ],
+            });
+            const result = await provider.fetchPriceFeed({
+                tokenSymbol: "XAU",
+                assetType: "metal",
+                quoteCurrency: "USD",
             });
-            await expect(provider.fetchPriceFeed({ tokenSymbol: "ETH" })).rejects.toThrow("No price feed found for ETH");
+            const parsed = JSON.parse(result);
+            expect(parsed.success).toBe(true);
+            expect(parsed.priceFeedID).toEqual("gold-price-feed-id");
         });
-        it("should throw an error if the response is not ok", async () => {
+        it("should return the first price feed ID that matches the input token symbol for commodities", async () => {
+            fetchMock.mockResolvedValueOnce({
+                ok: true,
+                json: async () => [
+                    { id: "oil-price-feed-id", attributes: { base: "WTI", quote_currency: "USD" } },
+                ],
+            });
+            const result = await provider.fetchPriceFeed({
+                tokenSymbol: "WTI",
+                assetType: "metal",
+                quoteCurrency: "USD",
+            });
+            const parsed = JSON.parse(result);
+            expect(parsed.success).toBe(true);
+            expect(parsed.priceFeedID).toEqual("oil-price-feed-id");
+        });
+        it("should return the first price feed ID that matches the input token symbol for equities", async () => {
+            fetchMock.mockResolvedValueOnce({
+                ok: true,
+                json: async () => [
+                    {
+                        id: "apple-price-feed-id",
+                        attributes: {
+                            base: "AAPL",
+                            quote_currency: "USD",
+                            symbol: "Equity.US.AAPL/USD",
+                            display_symbol: "AAPL/USD",
+                        },
+                    },
+                ],
+            });
+            const result = await provider.fetchPriceFeed({
+                tokenSymbol: "AAPL",
+                assetType: "equity",
+                quoteCurrency: "USD",
+            });
+            const parsed = JSON.parse(result);
+            expect(parsed.success).toBe(true);
+            expect(parsed.priceFeedID).toEqual("apple-price-feed-id");
+        });
+        it("should return the first price feed ID that matches the input token symbol for FX", async () => {
+            fetchMock.mockResolvedValueOnce({
+                ok: true,
+                json: async () => [
+                    { id: "eur-price-feed-id", attributes: { base: "EUR", quote_currency: "USD" } },
+                ],
+            });
+            const result = await provider.fetchPriceFeed({
+                tokenSymbol: "EUR",
+                assetType: "fx",
+                quoteCurrency: "USD",
+            });
+            const parsed = JSON.parse(result);
+            expect(parsed.success).toBe(true);
+            expect(parsed.priceFeedID).toEqual("eur-price-feed-id");
+        });
+        it("should return error if no price feed is found", async () => {
+            fetchMock.mockResolvedValueOnce({
+                ok: true,
+                json: async () => [
+                    { id: "some-price-feed-id", attributes: { base: "BTC", quote_currency: "USD" } },
+                ],
+            });
+            const result = await provider.fetchPriceFeed({
+                tokenSymbol: "SOL",
+                assetType: "crypto",
+                quoteCurrency: "USD",
+            });
+            const parsed = JSON.parse(result);
+            expect(parsed.success).toBe(false);
+            expect(parsed.error).toContain("No price feed found for SOL/USD");
+        });
+        it("should return error if the response is not ok", async () => {
             fetchMock.mockResolvedValueOnce({
                 ok: false,
                 status: 404,
             });
-            await expect(provider.fetchPriceFeed({ tokenSymbol: "BTC" })).rejects.toThrow("HTTP error! status: 404");
+            const result = await provider.fetchPriceFeed({
+                tokenSymbol: "BTC",
+                assetType: "crypto",
+                quoteCurrency: "USD",
+            });
+            const parsed = JSON.parse(result);
+            expect(parsed.success).toBe(false);
+            expect(parsed.error).toContain("HTTP error! status: 404");
         });
-        it("should throw an error if response is ok but no data is returned", async () => {
+        it("should return error if response is ok but no data is returned", async () => {
             fetchMock.mockResolvedValueOnce({
                 ok: true,
                 json: async () => [],
             });
-            const provider = (0, pythActionProvider_1.pythActionProvider)();
-            await expect(provider.fetchPriceFeed({ tokenSymbol: "BTC" })).rejects.toThrow("No price feed found for BTC");
+            const result = await provider.fetchPriceFeed({
+                tokenSymbol: "BTC",
+                assetType: "crypto",
+                quoteCurrency: "USD",
+            });
+            const parsed = JSON.parse(result);
+            expect(parsed.success).toBe(false);
+            expect(parsed.error).toContain("No price feed found for BTC");
+        });
+        it("should prefer regular market hours feed for equities over pre/post market", async () => {
+            fetchMock.mockResolvedValueOnce({
+                ok: true,
+                json: async () => [
+                    {
+                        id: "post-market-feed-id",
+                        attributes: {
+                            base: "COIN",
+                            quote_currency: "USD",
+                            symbol: "Equity.US.COIN/USD.POST",
+                            display_symbol: "COIN/USD POST MARKET",
+                        },
+                    },
+                    {
+                        id: "regular-market-feed-id",
+                        attributes: {
+                            base: "COIN",
+                            quote_currency: "USD",
+                            symbol: "Equity.US.COIN/USD",
+                            display_symbol: "COIN/USD",
+                        },
+                    },
+                    {
+                        id: "pre-market-feed-id",
+                        attributes: {
+                            base: "COIN",
+                            quote_currency: "USD",
+                            symbol: "Equity.US.COIN/USD.PRE",
+                            display_symbol: "COIN/USD PRE MARKET",
+                        },
+                    },
+                ],
+            });
+            const result = await provider.fetchPriceFeed({
+                tokenSymbol: "COIN",
+                assetType: "equity",
+                quoteCurrency: "USD",
+            });
+            const parsed = JSON.parse(result);
+            expect(parsed.success).toBe(true);
+            expect(parsed.priceFeedID).toEqual("regular-market-feed-id");
+            expect(parsed.feedType).toEqual("COIN/USD");
         });
     });
     describe("fetchPrice", () => {
@@ -55,8 +200,10 @@ describe("PythActionProvider", () => {
                     ],
                 }),
             });
-            const price = await provider.fetchPrice({ priceFeedID: "some-price-feed-id" });
-            expect(price).toEqual("1");
+            const result = await provider.fetchPrice({ priceFeedID: "some-price-feed-id" });
+            const parsed = JSON.parse(result);
+            expect(parsed.success).toBe(true);
+            expect(parsed.price).toEqual("1");
         });
         it("should return the price for a given price feed ID with a negative exponent", async () => {
             fetchMock.mockResolvedValueOnce({
@@ -72,9 +219,10 @@ describe("PythActionProvider", () => {
                     ],
                 }),
             });
-            const provider = (0, pythActionProvider_1.pythActionProvider)();
-            const price = await provider.fetchPrice({ priceFeedID: "some-price-feed-id" });
-            expect(price).toEqual("1.00");
+            const result = await provider.fetchPrice({ priceFeedID: "some-price-feed-id" });
+            const parsed = JSON.parse(result);
+            expect(parsed.success).toBe(true);
+            expect(parsed.price).toEqual("1.00");
         });
         it("should handle scaled price starting with a decimal", async () => {
             fetchMock.mockResolvedValueOnce({
@@ -90,24 +238,32 @@ describe("PythActionProvider", () => {
                     ],
                 }),
             });
-            const price = await provider.fetchPrice({ priceFeedID: "some-price-feed-id" });
-            expect(price).toEqual("0.25");
+            const result = await provider.fetchPrice({ priceFeedID: "some-price-feed-id" });
+            const parsed = JSON.parse(result);
+            expect(parsed.success).toBe(true);
+            expect(parsed.price).toEqual("0.25");
         });
-        it("should throw an error if there is no price data", async () => {
+        it("should return error if there is no price data", async () => {
             fetchMock.mockResolvedValueOnce({
                 ok: true,
                 json: async () => ({
                     parsed: [],
                 }),
             });
-            await expect(provider.fetchPrice({ priceFeedID: "some-price-feed-id" })).rejects.toThrow("No price data found for some-price-feed-id");
+            const result = await provider.fetchPrice({ priceFeedID: "some-price-feed-id" });
+            const parsed = JSON.parse(result);
+            expect(parsed.success).toBe(false);
+            expect(parsed.error).toContain("No price data found for some-price-feed-id");
         });
-        it("should throw an error if response is not ok", async () => {
+        it("should return error if response is not ok", async () => {
             fetchMock.mockResolvedValueOnce({
                 ok: false,
                 status: 404,
             });
-            await expect(provider.fetchPrice({ priceFeedID: "some-price-feed-id" })).rejects.toThrow("HTTP error! status: 404");
+            const result = await provider.fetchPrice({ priceFeedID: "some-price-feed-id" });
+            const parsed = JSON.parse(result);
+            expect(parsed.success).toBe(false);
+            expect(parsed.error).toContain("HTTP error! status: 404");
         });
     });
 });

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

@@ -4,10 +4,16 @@ import { z } from "zod";
  */
 export declare const PythFetchPriceFeedIDSchema: z.ZodObject<{
     tokenSymbol: z.ZodString;
+    quoteCurrency: z.ZodDefault<z.ZodString>;
+    assetType: z.ZodDefault<z.ZodEnum<["crypto", "equity", "fx", "metal"]>>;
 }, "strict", z.ZodTypeAny, {
     tokenSymbol: string;
+    quoteCurrency: string;
+    assetType: "crypto" | "equity" | "fx" | "metal";
 }, {
     tokenSymbol: string;
+    quoteCurrency?: string | undefined;
+    assetType?: "crypto" | "equity" | "fx" | "metal" | undefined;
 }>;
 /**
  * Input schema for Pyth fetch price action.

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

@@ -7,7 +7,15 @@ const zod_1 = require("zod");
  */
 exports.PythFetchPriceFeedIDSchema = zod_1.z
     .object({
-    tokenSymbol: zod_1.z.string().describe("The token symbol to fetch the price feed ID for"),
+    tokenSymbol: zod_1.z.string().describe("The asset ticker/symbol to fetch the price feed ID for"),
+    quoteCurrency: zod_1.z
+        .string()
+        .default("USD")
+        .describe("The quote currency to filter by (defaults to USD)"),
+    assetType: zod_1.z
+        .enum(["crypto", "equity", "fx", "metal"])
+        .default("crypto")
+        .describe("The asset type to search for (crypto, equity, fx, metal)"),
 })
     .strict();
 /**