@coinbase/agentkit 0.2.3-nightly.20250307.28 → 0.3.0

package/dist/action-providers/allora/alloraActionProvider.d.ts

@@ -0,0 +1,44 @@
+import { ActionProvider } from "../actionProvider";
+import { AlloraAPIClientConfig } from "@alloralabs/allora-sdk";
+import { z } from "zod";
+import { GetAllTopicsSchema, GetInferenceByTopicIdSchema, GetPriceInferenceSchema } from "./schemas";
+/**
+ * Action provider for interacting with Allora Network
+ */
+export declare class AlloraActionProvider extends ActionProvider {
+    private client;
+    /**
+     * Creates an instance of AlloraActionProvider
+     *
+     * @param config - Configuration for the Allora API client including API key and optional chain slug
+     */
+    constructor(config?: AlloraAPIClientConfig);
+    /**
+     * Gets all available topics from Allora Network
+     *
+     * @param _ - Empty object as no parameters are required
+     * @returns A string containing the list of topics in JSON format
+     */
+    getAllTopics(_: z.infer<typeof GetAllTopicsSchema>): Promise<string>;
+    /**
+     * Gets inference data for a specific topic from Allora Network
+     *
+     * @param args - Object containing the topic ID to get inference for
+     * @returns A string containing the inference data in JSON format
+     */
+    getInferenceByTopicId(args: z.infer<typeof GetInferenceByTopicIdSchema>): Promise<string>;
+    /**
+     * Gets price inference for a token/timeframe pair from Allora Network
+     *
+     * @param args - Object containing the asset symbol and timeframe
+     * @returns A string containing the price inference data in JSON format
+     */
+    getPriceInference(args: z.infer<typeof GetPriceInferenceSchema>): Promise<string>;
+    /**
+     * Checks if the provider supports a given network
+     *
+     * @returns Always returns true as Allora service is network-agnostic
+     */
+    supportsNetwork(): boolean;
+}
+export declare const alloraActionProvider: (config?: AlloraAPIClientConfig) => AlloraActionProvider;

package/dist/action-providers/allora/alloraActionProvider.js

@@ -0,0 +1,195 @@
+"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.alloraActionProvider = exports.AlloraActionProvider = void 0;
+const actionProvider_1 = require("../actionProvider");
+const actionDecorator_1 = require("../actionDecorator");
+const allora_sdk_1 = require("@alloralabs/allora-sdk");
+const zod_1 = require("zod");
+const schemas_1 = require("./schemas");
+/**
+ * Action provider for interacting with Allora Network
+ */
+class AlloraActionProvider extends actionProvider_1.ActionProvider {
+    /**
+     * Creates an instance of AlloraActionProvider
+     *
+     * @param config - Configuration for the Allora API client including API key and optional chain slug
+     */
+    constructor(config = {}) {
+        super("allora", []);
+        // This is a public, development only key and should be used for testing purposes only.
+        // It might be changed or revoked in the future. It is also subject to limits and usage policies.
+        const DEFAULT_API_KEY = "UP-4151d0cc489a44a7aa5cd7ef";
+        config.apiKey = config.apiKey || DEFAULT_API_KEY;
+        config.chainSlug = config.chainSlug || allora_sdk_1.ChainSlug.TESTNET;
+        this.client = new allora_sdk_1.AlloraAPIClient(config);
+    }
+    /**
+     * Gets all available topics from Allora Network
+     *
+     * @param _ - Empty object as no parameters are required
+     * @returns A string containing the list of topics in JSON format
+     */
+    async getAllTopics(_) {
+        try {
+            const topics = await this.client.getAllTopics();
+            const topicsJson = JSON.stringify(topics);
+            return `The available topics at Allora Network are:\n ${topicsJson}`;
+        }
+        catch (error) {
+            return `Error getting all topics: ${error}`;
+        }
+    }
+    /**
+     * Gets inference data for a specific topic from Allora Network
+     *
+     * @param args - Object containing the topic ID to get inference for
+     * @returns A string containing the inference data in JSON format
+     */
+    async getInferenceByTopicId(args) {
+        try {
+            const inference = await this.client.getInferenceByTopicID(args.topicId);
+            const inferenceJson = JSON.stringify(inference.inference_data);
+            return `The inference for topic ${args.topicId} is:\n ${inferenceJson}`;
+        }
+        catch (error) {
+            return `Error getting inference for topic ${args.topicId}: ${error}`;
+        }
+    }
+    /**
+     * Gets price inference for a token/timeframe pair from Allora Network
+     *
+     * @param args - Object containing the asset symbol and timeframe
+     * @returns A string containing the price inference data in JSON format
+     */
+    async getPriceInference(args) {
+        try {
+            const inference = await this.client.getPriceInference(args.asset, args.timeframe);
+            const response = {
+                price: inference.inference_data.network_inference_normalized,
+                timestamp: inference.inference_data.timestamp,
+                asset: args.asset,
+                timeframe: args.timeframe,
+            };
+            const inferenceJson = JSON.stringify(response);
+            return `The price inference for ${args.asset} (${args.timeframe}) is:\n${inferenceJson}`;
+        }
+        catch (error) {
+            return `Error getting price inference for ${args.asset} (${args.timeframe}): ${error}`;
+        }
+    }
+    /**
+     * Checks if the provider supports a given network
+     *
+     * @returns Always returns true as Allora service is network-agnostic
+     */
+    supportsNetwork() {
+        return true; // Allora service is network-agnostic
+    }
+}
+exports.AlloraActionProvider = AlloraActionProvider;
+__decorate([
+    (0, actionDecorator_1.CreateAction)({
+        name: "get_all_topics",
+        description: `
+This tool will get all available inference topics from Allora Network.
+
+A successful response will return a list of available topics in JSON format. Example:
+[
+    {
+        "topic_id": 1,
+        "topic_name": "Bitcoin 8h",
+        "description": "Bitcoin price prediction for the next 8 hours",
+        "epoch_length": 100,
+        "ground_truth_lag": 10,
+        "loss_method": "method1",
+        "worker_submission_window": 50,
+        "worker_count": 5,
+        "reputer_count": 3,
+        "total_staked_allo": 1000,
+        "total_emissions_allo": 500,
+        "is_active": true,
+        "updated_at": "2023-01-01T00:00:00Z"
+    }
+]
+
+Key fields:
+- topic_id: Unique identifier, use with get_inference_by_topic_id action
+- topic_name: Name of the topic
+- description: Short description of the topic's purpose
+- is_active: If true, topic is active and accepting submissions
+- updated_at: Timestamp of last update
+
+A failure response will return an error message with details.
+`,
+        schema: schemas_1.GetAllTopicsSchema,
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [void 0]),
+    __metadata("design:returntype", Promise)
+], AlloraActionProvider.prototype, "getAllTopics", null);
+__decorate([
+    (0, actionDecorator_1.CreateAction)({
+        name: "get_inference_by_topic_id",
+        description: `
+This tool will get inference for a specific topic from Allora Network.
+It requires a topic ID as input, which can be obtained from the get_all_topics action.
+
+A successful response will return a message with the inference data in JSON format. Example:
+    {
+        "network_inference": "0.5",
+        "network_inference_normalized": "0.5",
+        "confidence_interval_percentiles": ["0.1", "0.5", "0.9"],
+        "confidence_interval_percentiles_normalized": ["0.1", "0.5", "0.9"],
+        "confidence_interval_values": ["0.1", "0.5", "0.9"],
+        "confidence_interval_values_normalized": ["0.1", "0.5", "0.9"],
+        "topic_id": "1",
+        "timestamp": 1718198400,
+        "extra_data": "extra_data"
+    }
+The network_inference field is the inference for the topic.
+The network_inference_normalized field is the normalized inference for the topic.
+
+A failure response will return an error message with details.
+`,
+        schema: schemas_1.GetInferenceByTopicIdSchema,
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [void 0]),
+    __metadata("design:returntype", Promise)
+], AlloraActionProvider.prototype, "getInferenceByTopicId", null);
+__decorate([
+    (0, actionDecorator_1.CreateAction)({
+        name: "get_price_inference",
+        description: `
+This tool will get price inference for a specific token and timeframe from Allora Network.
+It requires an asset symbol (e.g., 'BTC', 'ETH') and a timeframe (e.g., '8h', '24h') as input.
+
+A successful response will return a message with the price inference. Example:
+    The price inference for BTC (8h) is:
+    {
+        "price": "100000",
+        "timestamp": 1718198400,
+        "asset": "BTC",
+        "timeframe": "8h"
+    }
+
+A failure response will return an error message with details.
+`,
+        schema: schemas_1.GetPriceInferenceSchema,
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [void 0]),
+    __metadata("design:returntype", Promise)
+], AlloraActionProvider.prototype, "getPriceInference", null);
+const alloraActionProvider = (config = {}) => new AlloraActionProvider(config);
+exports.alloraActionProvider = alloraActionProvider;

package/dist/action-providers/allora/alloraActionProvider.test.d.ts

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

package/dist/action-providers/allora/alloraActionProvider.test.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const alloraActionProvider_1 = require("./alloraActionProvider");
+const allora_sdk_1 = require("@alloralabs/allora-sdk");
+jest.mock("@alloralabs/allora-sdk");
+describe("AlloraActionProvider", () => {
+    let provider;
+    const mockConfig = { apiKey: "test-api-key", chainSlug: allora_sdk_1.ChainSlug.TESTNET };
+    beforeEach(() => {
+        jest.clearAllMocks();
+        provider = new alloraActionProvider_1.AlloraActionProvider(mockConfig);
+    });
+    describe("getAllTopics", () => {
+        it("should return topics when successful", async () => {
+            const mockTopics = [
+                {
+                    topic_id: 1,
+                    topic_name: "Bitcoin 8h",
+                    description: "Bitcoin price prediction",
+                    epoch_length: 100,
+                    ground_truth_lag: 10,
+                    loss_method: "method1",
+                    worker_submission_window: 50,
+                    worker_count: 5,
+                    reputer_count: 3,
+                    total_staked_allo: 1000,
+                    total_emissions_allo: 500,
+                    is_active: true,
+                    updated_at: "2023-01-01T00:00:00Z",
+                },
+            ];
+            allora_sdk_1.AlloraAPIClient.prototype.getAllTopics.mockResolvedValue(mockTopics);
+            const result = await provider.getAllTopics({});
+            expect(result).toContain("The available topics at Allora Network are:");
+            expect(result).toContain(JSON.stringify(mockTopics));
+        });
+        it("should handle errors", async () => {
+            const error = new Error("API Error");
+            allora_sdk_1.AlloraAPIClient.prototype.getAllTopics.mockRejectedValue(error);
+            const result = await provider.getAllTopics({});
+            expect(result).toContain("Error getting all topics:");
+            expect(result).toContain(error.toString());
+        });
+    });
+    describe("getInferenceByTopicId", () => {
+        const mockTopicId = 1;
+        it("should return inference when successful", async () => {
+            const mockInferenceResponse = {
+                inference_data: {
+                    network_inference: "0.5",
+                    network_inference_normalized: "0.5",
+                    confidence_interval_percentiles: ["0.1", "0.5", "0.9"],
+                    confidence_interval_percentiles_normalized: ["0.1", "0.5", "0.9"],
+                    confidence_interval_values: ["0.1", "0.5", "0.9"],
+                    confidence_interval_values_normalized: ["0.1", "0.5", "0.9"],
+                    topic_id: "1",
+                    timestamp: 1718198400,
+                    extra_data: "extra_data",
+                },
+            };
+            allora_sdk_1.AlloraAPIClient.prototype.getInferenceByTopicID.mockResolvedValue(mockInferenceResponse);
+            const result = await provider.getInferenceByTopicId({ topicId: mockTopicId });
+            expect(result).toContain(`The inference for topic ${mockTopicId} is:`);
+            expect(result).toContain(JSON.stringify(mockInferenceResponse.inference_data));
+        });
+        it("should handle errors", async () => {
+            const error = new Error("API Error");
+            allora_sdk_1.AlloraAPIClient.prototype.getInferenceByTopicID.mockRejectedValue(error);
+            const result = await provider.getInferenceByTopicId({ topicId: mockTopicId });
+            expect(result).toContain(`Error getting inference for topic ${mockTopicId}:`);
+            expect(result).toContain(error.toString());
+        });
+    });
+    describe("getPriceInference", () => {
+        const mockAsset = allora_sdk_1.PriceInferenceToken.BTC;
+        const mockTimeframe = "8h";
+        it("should return price inference when successful", async () => {
+            const mockPriceInference = {
+                inference_data: {
+                    network_inference_normalized: "50000.00",
+                    timestamp: 1718198400,
+                },
+            };
+            allora_sdk_1.AlloraAPIClient.prototype.getPriceInference.mockResolvedValue(mockPriceInference);
+            const expectedResponse = {
+                price: "50000.00",
+                timestamp: 1718198400,
+                asset: mockAsset,
+                timeframe: mockTimeframe,
+            };
+            const result = await provider.getPriceInference({
+                asset: mockAsset,
+                timeframe: mockTimeframe,
+            });
+            expect(result).toContain(`The price inference for ${mockAsset} (${mockTimeframe}) is:`);
+            expect(result).toContain(JSON.stringify(expectedResponse));
+        });
+        it("should handle errors", async () => {
+            const error = new Error("API Error");
+            allora_sdk_1.AlloraAPIClient.prototype.getPriceInference.mockRejectedValue(error);
+            const result = await provider.getPriceInference({
+                asset: mockAsset,
+                timeframe: mockTimeframe,
+            });
+            expect(result).toContain(`Error getting price inference for ${mockAsset} (${mockTimeframe}):`);
+            expect(result).toContain(error.toString());
+        });
+    });
+});

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

@@ -0,0 +1,2 @@
+export * from "./alloraActionProvider";
+export * from "./schemas";

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

@@ -0,0 +1,18 @@
+"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("./alloraActionProvider"), exports);
+__exportStar(require("./schemas"), exports);

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

@@ -0,0 +1,28 @@
+import { z } from "zod";
+/**
+ * Input schema for getting all topics from Allora Network
+ */
+export declare const GetAllTopicsSchema: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+/**
+ * Input schema for getting inference data by topic ID from Allora Network
+ */
+export declare const GetInferenceByTopicIdSchema: z.ZodObject<{
+    topicId: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    topicId: number;
+}, {
+    topicId: number;
+}>;
+/**
+ * Input schema for getting price inference for a token/timeframe pair
+ */
+export declare const GetPriceInferenceSchema: z.ZodObject<{
+    asset: z.ZodString;
+    timeframe: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    asset: string;
+    timeframe: string;
+}, {
+    asset: string;
+    timeframe: string;
+}>;

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

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetPriceInferenceSchema = exports.GetInferenceByTopicIdSchema = exports.GetAllTopicsSchema = void 0;
+const zod_1 = require("zod");
+/**
+ * Input schema for getting all topics from Allora Network
+ */
+exports.GetAllTopicsSchema = zod_1.z
+    .object({})
+    .strip()
+    .describe("Instructions for getting all topics from Allora Network");
+/**
+ * Input schema for getting inference data by topic ID from Allora Network
+ */
+exports.GetInferenceByTopicIdSchema = zod_1.z
+    .object({
+    topicId: zod_1.z.number().describe("The ID of the topic to get inference data for"),
+})
+    .strip()
+    .describe("Instructions for getting inference data from Allora Network by topic ID");
+/**
+ * Input schema for getting price inference for a token/timeframe pair
+ */
+exports.GetPriceInferenceSchema = zod_1.z
+    .object({
+    asset: zod_1.z.string().describe("The token to get price inference for (e.g., 'BTC', 'ETH')"),
+    timeframe: zod_1.z.string().describe("The timeframe for the prediction (e.g., '8h', '24h')"),
+})
+    .strip()
+    .describe("Instructions for getting price inference for a token/timeframe pair");

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

@@ -18,3 +18,4 @@ export * from "./twitter";
 export * from "./wallet";
 export * from "./weth";
 export * from "./wow";
+export * from "./allora";

package/dist/action-providers/index.js

@@ -34,3 +34,4 @@ __exportStar(require("./twitter"), exports);
 __exportStar(require("./wallet"), exports);
 __exportStar(require("./weth"), exports);
 __exportStar(require("./wow"), exports);
+__exportStar(require("./allora"), exports);

package/package.json

@@ -2,7 +2,7 @@
   "name": "@coinbase/agentkit",
   "description": "Coinbase AgentKit core primitives",
   "repository": "https://github.com/coinbase/agentkit",
-  "version": "0.2.3-nightly.20250307.28",
+  "version": "0.3.0",
   "author": "Coinbase Inc.",
   "license": "Apache-2.0",
   "main": "dist/index.js",
@@ -40,6 +40,7 @@
     "typescript"
   ],
   "dependencies": {
+    "@alloralabs/allora-sdk": "^0.1.0",
     "@coinbase/coinbase-sdk": "^0.20.0",
     "@jup-ag/api": "^6.0.39",
     "@privy-io/server-auth": "^1.18.4",