graphai 0.1.2 → 0.2.1

package/lib/experimental_agents/data_agents/packages.d.ts

@@ -0,0 +1,5 @@
+import totalAgent from "../../experimental_agents/data_agents/total_agent";
+import dataObjectMergeTemplateAgent from "../../experimental_agents/data_agents/data_object_merge_template_agent";
+import dataSumTemplateAgent from "../../experimental_agents/data_agents/data_sum_template_agent";
+import propertyFilterAgent from "../../experimental_agents/data_agents/property_filter_agent";
+export { totalAgent, dataObjectMergeTemplateAgent, dataSumTemplateAgent, propertyFilterAgent };

package/lib/experimental_agents/data_agents/packages.js

@@ -0,0 +1,14 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.propertyFilterAgent = exports.dataSumTemplateAgent = exports.dataObjectMergeTemplateAgent = exports.totalAgent = void 0;
+const total_agent_1 = __importDefault(require("../../experimental_agents/data_agents/total_agent"));
+exports.totalAgent = total_agent_1.default;
+const data_object_merge_template_agent_1 = __importDefault(require("../../experimental_agents/data_agents/data_object_merge_template_agent"));
+exports.dataObjectMergeTemplateAgent = data_object_merge_template_agent_1.default;
+const data_sum_template_agent_1 = __importDefault(require("../../experimental_agents/data_agents/data_sum_template_agent"));
+exports.dataSumTemplateAgent = data_sum_template_agent_1.default;
+const property_filter_agent_1 = __importDefault(require("../../experimental_agents/data_agents/property_filter_agent"));
+exports.propertyFilterAgent = property_filter_agent_1.default;

package/lib/experimental_agents/data_agents/property_filter_agent.d.ts

@@ -0,0 +1,61 @@
+import { AgentFunction } from "../../graphai";
+export declare const propertyFilterAgent: AgentFunction<{
+    include?: Array<string>;
+    exclude?: Array<string>;
+}>;
+declare const propertyFilterAgentInfo: {
+    name: string;
+    agent: AgentFunction<{
+        include?: string[] | undefined;
+        exclude?: string[] | undefined;
+    }>;
+    mock: AgentFunction<{
+        include?: string[] | undefined;
+        exclude?: string[] | undefined;
+    }>;
+    samples: ({
+        inputs: {
+            color: string;
+            model: string;
+            type: string;
+            maker: string;
+            range: number;
+        }[];
+        params: {
+            include: string[];
+            exclude?: undefined;
+        };
+        result: {
+            color: string;
+            model: string;
+            type?: undefined;
+            maker?: undefined;
+            range?: undefined;
+        };
+    } | {
+        inputs: {
+            color: string;
+            model: string;
+            type: string;
+            maker: string;
+            range: number;
+        }[];
+        params: {
+            exclude: string[];
+            include?: undefined;
+        };
+        result: {
+            type: string;
+            maker: string;
+            range: number;
+            color?: undefined;
+            model?: undefined;
+        };
+    })[];
+    description: string;
+    category: string[];
+    author: string;
+    repository: string;
+    license: string;
+};
+export default propertyFilterAgentInfo;

package/lib/experimental_agents/data_agents/property_filter_agent.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.propertyFilterAgent = void 0;
+const propertyFilterAgent = async ({ inputs, params }) => {
+    const [input] = inputs;
+    const { include, exclude } = params;
+    const propIds = include ? include : Object.keys(input);
+    const excludeSet = new Set(exclude ?? []);
+    return propIds.reduce((tmp, propId) => {
+        if (!excludeSet.has(propId)) {
+            tmp[propId] = input[propId];
+        }
+        return tmp;
+    }, {});
+};
+exports.propertyFilterAgent = propertyFilterAgent;
+const inputs = [{ color: "red", model: "Model 3", type: "EV", maker: "Tesla", range: 300 }];
+const propertyFilterAgentInfo = {
+    name: "propertyFilterAgent",
+    agent: exports.propertyFilterAgent,
+    mock: exports.propertyFilterAgent,
+    samples: [
+        {
+            inputs,
+            params: { include: ["color", "model"] },
+            result: { color: "red", model: "Model 3" },
+        },
+        {
+            inputs,
+            params: { exclude: ["color", "model"] },
+            result: { type: "EV", maker: "Tesla", range: 300 },
+        },
+    ],
+    description: "Filter properties based on property name either with 'include' or 'exclude'",
+    category: ["data"],
+    author: "Receptron team",
+    repository: "https://github.com/receptron/graphai",
+    license: "MIT",
+};
+exports.default = propertyFilterAgentInfo;

package/lib/experimental_agents/data_agents/total_agent.d.ts

@@ -39,6 +39,7 @@ declare const totalAgentInfo: {
         };
     })[];
     description: string;
+    category: string[];
     author: string;
     repository: string;
     license: string;

package/lib/experimental_agents/data_agents/total_agent.js

@@ -44,6 +44,7 @@ const totalAgentInfo = {
         },
     ],
     description: "Returns the sum of input values",
+    category: ["data"],
     author: "Satoshi Nakajima",
     repository: "https://github.com/snakajima/graphai",
     license: "MIT",

package/lib/experimental_agents/embedding_agent.d.ts

@@ -1,6 +1,20 @@
 import { AgentFunction } from "../graphai";
 export declare const stringEmbeddingsAgent: AgentFunction<{
     model?: string;
-}, {
-    contents: any;
-}, Array<string> | string>;
+}, any, Array<string> | string>;
+declare const stringEmbeddingsAgentInfo: {
+    name: string;
+    agent: AgentFunction<{
+        model?: string | undefined;
+    }, any, string | string[]>;
+    mock: AgentFunction<{
+        model?: string | undefined;
+    }, any, string | string[]>;
+    samples: never[];
+    description: string;
+    category: never[];
+    author: string;
+    repository: string;
+    license: string;
+};
+export default stringEmbeddingsAgentInfo;

package/lib/experimental_agents/embedding_agent.js

@@ -38,6 +38,18 @@ const stringEmbeddingsAgent = async ({ params, inputs }) => {
     const embeddings = jsonResponse.data.map((object) => {
         return object.embedding;
     });
-    return { contents: embeddings };
+    return embeddings;
 };
 exports.stringEmbeddingsAgent = stringEmbeddingsAgent;
+const stringEmbeddingsAgentInfo = {
+    name: "stringEmbeddingsAgent",
+    agent: exports.stringEmbeddingsAgent,
+    mock: exports.stringEmbeddingsAgent,
+    samples: [],
+    description: "Embeddings Agent",
+    category: [],
+    author: "Receptron team",
+    repository: "https://github.com/receptron/graphai",
+    license: "MIT",
+};
+exports.default = stringEmbeddingsAgentInfo;

package/lib/experimental_agents/function_agent.d.ts

@@ -0,0 +1,42 @@
+import { AgentFunction } from "../graphai";
+export declare const functionAgent: AgentFunction<{
+    function: (...args: any[]) => any;
+}>;
+declare const functionAgentInfo: {
+    name: string;
+    agent: AgentFunction<{
+        function: (...args: any[]) => any;
+    }>;
+    mock: AgentFunction<{
+        function: (...args: any[]) => any;
+    }>;
+    samples: ({
+        inputs: {
+            model: string;
+            maker: string;
+            range: number;
+            price: number;
+        }[];
+        params: {
+            function: (info: Record<string, any>) => string;
+        };
+        result: string;
+    } | {
+        inputs: string[];
+        params: {
+            function: (str: string) => any;
+        };
+        result: {
+            model: string;
+            maker: string;
+            range: number;
+            price: number;
+        };
+    })[];
+    description: string;
+    category: string[];
+    author: string;
+    repository: string;
+    license: string;
+};
+export default functionAgentInfo;

package/lib/experimental_agents/function_agent.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.functionAgent = void 0;
+const functionAgent = async ({ inputs, params }) => {
+    return params.function(...inputs);
+};
+exports.functionAgent = functionAgent;
+const carInfo = { model: "Model 3", maker: "Tesla", range: 300, price: 35000 };
+const functionAgentInfo = {
+    name: "functionAgent",
+    agent: exports.functionAgent,
+    mock: exports.functionAgent,
+    samples: [
+        {
+            inputs: [carInfo],
+            params: {
+                function: (info) => {
+                    const { model, maker, range, price } = info;
+                    return `A ${maker} ${model} has the range of ${range} miles. It costs $${price}.`;
+                },
+            },
+            result: "A Tesla Model 3 has the range of 300 miles. It costs $35000.",
+        },
+        {
+            inputs: [JSON.stringify(carInfo)],
+            params: {
+                function: (str) => {
+                    return JSON.parse(str);
+                },
+            },
+            result: carInfo,
+        },
+    ],
+    description: "It allows developers to implement the agent function within the graph itself.",
+    category: ["data"],
+    author: "Receptron team",
+    repository: "https://github.com/receptron/graphai",
+    license: "MIT",
+};
+exports.default = functionAgentInfo;

package/lib/experimental_agents/graph_agents/index.d.ts

@@ -0,0 +1,2 @@
+export { nestedAgent } from "../../experimental_agents/graph_agents/nested_agent";
+export { mapAgent } from "../../experimental_agents/graph_agents/map_agent";

package/lib/experimental_agents/graph_agents/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mapAgent = exports.nestedAgent = void 0;
+var nested_agent_1 = require("../../experimental_agents/graph_agents/nested_agent");
+Object.defineProperty(exports, "nestedAgent", { enumerable: true, get: function () { return nested_agent_1.nestedAgent; } });
+var map_agent_1 = require("../../experimental_agents/graph_agents/map_agent");
+Object.defineProperty(exports, "mapAgent", { enumerable: true, get: function () { return map_agent_1.mapAgent; } });

package/lib/experimental_agents/graph_agents/map_agent.d.ts

@@ -0,0 +1,20 @@
+import { AgentFunction } from "../../graphai";
+export declare const mapAgent: AgentFunction<{
+    injectionTo?: Array<string>;
+}, Record<string, Array<any>>, any>;
+declare const mapAgentInfo: {
+    name: string;
+    agent: AgentFunction<{
+        injectionTo?: string[] | undefined;
+    }, Record<string, any[]>, any>;
+    mock: AgentFunction<{
+        injectionTo?: string[] | undefined;
+    }, Record<string, any[]>, any>;
+    samples: never[];
+    description: string;
+    category: never[];
+    author: string;
+    repository: string;
+    license: string;
+};
+export default mapAgentInfo;

package/lib/experimental_agents/{map_agent.js → graph_agents/map_agent.js}

@@ -1,23 +1,32 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.mapAgent = void 0;
-const graphai_1 = require("../graphai");
-const utils_1 = require("../utils/utils");
+const graphai_1 = require("../../graphai");
+const utils_1 = require("../../utils/utils");
+const nested_agent_1 = require("./nested_agent");
 const mapAgent = async ({ params, inputs, agents, log, taskManager, graphData }) => {
     if (taskManager) {
         const status = taskManager.getStatus();
         (0, utils_1.assert)(status.concurrency > status.running, `mapAgent: Concurrency is too low: ${status.concurrency}`);
     }
-    (0, utils_1.assert)(graphData !== undefined, "mapAgent: graphData is required");
+    const nestedGraphData = (0, nested_agent_1.getNestedGraphData)(graphData, inputs);
     const input = Array.isArray(inputs[0]) ? inputs[0] : inputs;
-    const injectionTo = params.injectionTo ?? "$0";
-    if (graphData.nodes[injectionTo] === undefined) {
-        // If the input node does not exist, automatically create a static node
-        graphData.nodes[injectionTo] = { value: {} };
-    }
+    const injectionTo = params.injectionTo ??
+        inputs.map((__input, index) => {
+            return `$${index}`;
+        });
+    injectionTo.forEach((nodeId) => {
+        if (nestedGraphData.nodes[nodeId] === undefined) {
+            // If the input node does not exist, automatically create a static node
+            nestedGraphData.nodes[nodeId] = { value: {} };
+        }
+    });
     const graphs = input.map((data) => {
-        const graphAI = new graphai_1.GraphAI(graphData, agents || {}, taskManager);
-        graphAI.injectValue(injectionTo, data, "__mapAgent_inputs__");
+        const graphAI = new graphai_1.GraphAI(nestedGraphData, agents || {}, taskManager);
+        // Only the first input will be mapped
+        injectionTo.forEach((injectToNodeId, index) => {
+            graphAI.injectValue(injectToNodeId, index === 0 ? data : inputs[index], "__mapAgent_inputs__");
+        });
         return graphAI;
     });
     const runs = graphs.map((graph) => {
@@ -44,3 +53,15 @@ const mapAgent = async ({ params, inputs, agents, log, taskManager, graphData })
     return compositeResult;
 };
 exports.mapAgent = mapAgent;
+const mapAgentInfo = {
+    name: "mapAgent",
+    agent: exports.mapAgent,
+    mock: exports.mapAgent,
+    samples: [],
+    description: "Map Agent",
+    category: [],
+    author: "Receptron team",
+    repository: "https://github.com/receptron/graphai",
+    license: "MIT",
+};
+exports.default = mapAgentInfo;

package/lib/experimental_agents/graph_agents/nested_agent.d.ts

@@ -0,0 +1,22 @@
+import { AgentFunction } from "../../graphai";
+import { GraphData } from "../../type";
+export declare const getNestedGraphData: (graphData: GraphData | string | undefined, inputs: Array<any>) => GraphData;
+export declare const nestedAgent: AgentFunction<{
+    injectionTo?: Array<string>;
+}>;
+declare const nestedAgentInfo: {
+    name: string;
+    agent: AgentFunction<{
+        injectionTo?: string[] | undefined;
+    }>;
+    mock: AgentFunction<{
+        injectionTo?: string[] | undefined;
+    }>;
+    samples: never[];
+    description: string;
+    category: never[];
+    author: string;
+    repository: string;
+    license: string;
+};
+export default nestedAgentInfo;

package/lib/experimental_agents/graph_agents/nested_agent.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nestedAgent = exports.getNestedGraphData = void 0;
+const graphai_1 = require("../../graphai");
+const utils_1 = require("../../utils/utils");
+// This function allows us to use one of inputs as the graph data for this nested agent,
+// which is equivalent to "eval" of JavaScript.
+const getNestedGraphData = (graphData, inputs) => {
+    (0, utils_1.assert)(graphData !== undefined, "nestedAgent: graphData is required");
+    if (typeof graphData === "string") {
+        const regex = /^\$(\d+)$/;
+        const match = graphData.match(regex);
+        if (match) {
+            const index = parseInt(match[1], 10);
+            if (index < inputs.length) {
+                return inputs[index];
+            }
+        }
+        (0, utils_1.assert)(false, `getNestedGraphData: Invalid graphData string: ${graphData}`);
+    }
+    return graphData;
+};
+exports.getNestedGraphData = getNestedGraphData;
+const nestedAgent = async ({ params, inputs, agents, log, taskManager, graphData }) => {
+    if (taskManager) {
+        const status = taskManager.getStatus(false);
+        (0, utils_1.assert)(status.concurrency > status.running, `nestedAgent: Concurrency is too low: ${status.concurrency}`);
+    }
+    const nestedGraphData = (0, exports.getNestedGraphData)(graphData, inputs);
+    const injectionTo = params.injectionTo ??
+        inputs.map((__input, index) => {
+            return `$${index}`;
+        });
+    injectionTo.forEach((nodeId) => {
+        if (nestedGraphData.nodes[nodeId] === undefined) {
+            // If the input node does not exist, automatically create a static node
+            nestedGraphData.nodes[nodeId] = { value: {} };
+        }
+    });
+    const graphAI = new graphai_1.GraphAI(nestedGraphData, agents || {}, taskManager);
+    try {
+        // Inject inputs to specified source nodes
+        injectionTo.forEach((injectToNodeId, index) => {
+            graphAI.injectValue(injectToNodeId, inputs[index]);
+        });
+        const results = await graphAI.run(false);
+        log?.push(...graphAI.transactionLogs());
+        return results;
+    }
+    catch (error) {
+        log?.push(...graphAI.transactionLogs());
+        if (error instanceof Error) {
+            console.log("Error:", error.message);
+        }
+        throw error;
+    }
+};
+exports.nestedAgent = nestedAgent;
+const nestedAgentInfo = {
+    name: "nestedAgent",
+    agent: exports.nestedAgent,
+    mock: exports.nestedAgent,
+    samples: [],
+    description: "nested Agent",
+    category: [],
+    author: "Receptron team",
+    repository: "https://github.com/receptron/graphai",
+    license: "MIT",
+};
+exports.default = nestedAgentInfo;

package/lib/experimental_agents/graph_agents/packages.d.ts

@@ -0,0 +1,3 @@
+import nestedAgent from "../../experimental_agents/graph_agents/nested_agent";
+import mapAgent from "../../experimental_agents/graph_agents/map_agent";
+export { nestedAgent, mapAgent };

package/lib/experimental_agents/graph_agents/packages.js

@@ -0,0 +1,10 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mapAgent = exports.nestedAgent = void 0;
+const nested_agent_1 = __importDefault(require("../../experimental_agents/graph_agents/nested_agent"));
+exports.nestedAgent = nested_agent_1.default;
+const map_agent_1 = __importDefault(require("../../experimental_agents/graph_agents/map_agent"));
+exports.mapAgent = map_agent_1.default;

package/lib/experimental_agents/index.d.ts

@@ -1,11 +1,11 @@
 export * from "./string_agents";
-export * from "./slashgpt_agent";
 export * from "./sleeper_agents";
 export * from "./data_agents";
-export * from "./nested_agent";
 export * from "./array_agents";
-export * from "./embedding_agent";
 export * from "./matrix_agents";
-export * from "./token_agent";
 export * from "./test_agents";
-export * from "./map_agent";
+export * from "./graph_agents";
+export * from "./llm_agents";
+export * from "./embedding_agent";
+export * from "./token_agent";
+export * from "./function_agent";

package/lib/experimental_agents/index.js

@@ -15,13 +15,13 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./string_agents"), exports);
-__exportStar(require("./slashgpt_agent"), exports);
 __exportStar(require("./sleeper_agents"), exports);
 __exportStar(require("./data_agents"), exports);
-__exportStar(require("./nested_agent"), exports);
 __exportStar(require("./array_agents"), exports);
-__exportStar(require("./embedding_agent"), exports);
 __exportStar(require("./matrix_agents"), exports);
-__exportStar(require("./token_agent"), exports);
 __exportStar(require("./test_agents"), exports);
-__exportStar(require("./map_agent"), exports);
+__exportStar(require("./graph_agents"), exports);
+__exportStar(require("./llm_agents"), exports);
+__exportStar(require("./embedding_agent"), exports);
+__exportStar(require("./token_agent"), exports);
+__exportStar(require("./function_agent"), exports);

package/lib/experimental_agents/llm_agents/groq_agent.d.ts

@@ -0,0 +1,26 @@
+import { AgentFunction } from "../../graphai";
+export declare const gloqAgent: AgentFunction<{
+    model: string;
+    query?: string;
+    system?: string;
+}, Record<string, any> | string, string>;
+declare const gloqAgentInfo: {
+    name: string;
+    agent: AgentFunction<{
+        model: string;
+        query?: string | undefined;
+        system?: string | undefined;
+    }, string | Record<string, any>, string>;
+    mock: AgentFunction<{
+        model: string;
+        query?: string | undefined;
+        system?: string | undefined;
+    }, string | Record<string, any>, string>;
+    samples: never[];
+    description: string;
+    category: string[];
+    author: string;
+    repository: string;
+    license: string;
+};
+export default gloqAgentInfo;

package/lib/experimental_agents/llm_agents/groq_agent.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.gloqAgent = void 0;
+const groq_sdk_1 = require("groq-sdk");
+const utils_1 = require("../../utils/utils");
+const groq = process.env.GROQ_API_KEY
+    ? new groq_sdk_1.Groq({
+        apiKey: process.env.GROQ_API_KEY,
+    })
+    : undefined;
+const gloqAgent = async ({ params, inputs }) => {
+    (0, utils_1.assert)(groq !== undefined, "The GROQ_API_KEY environment variable is missing.");
+    const query = params?.query ? [params.query] : [];
+    const content = query.concat(inputs).join("\n");
+    const messages = params?.system ? [{ role: "system", content: params.system }] : [];
+    messages.push({
+        role: "user",
+        content,
+    });
+    console.log(messages);
+    const result = await groq.chat.completions.create({
+        messages,
+        model: params.model,
+    });
+    return result;
+};
+exports.gloqAgent = gloqAgent;
+const gloqAgentInfo = {
+    name: "gloqAgent",
+    agent: exports.gloqAgent,
+    mock: exports.gloqAgent,
+    samples: [],
+    description: "Groq Agent",
+    category: ["llm"],
+    author: "Receptron team",
+    repository: "https://github.com/receptron/graphai",
+    license: "MIT",
+};
+exports.default = gloqAgentInfo;

package/lib/experimental_agents/llm_agents/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./slashgpt_agent";
+export * from "./groq_agent";

package/lib/experimental_agents/llm_agents/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("./slashgpt_agent"), exports);
+__exportStar(require("./groq_agent"), exports);

package/lib/experimental_agents/llm_agents/packages.d.ts

@@ -0,0 +1,3 @@
+import gloqAgent from "../../experimental_agents/llm_agents/groq_agent";
+import slashGPTAgent from "../../experimental_agents/llm_agents/slashgpt_agent";
+export { gloqAgent, slashGPTAgent };

package/lib/experimental_agents/llm_agents/packages.js

@@ -0,0 +1,10 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.slashGPTAgent = exports.gloqAgent = void 0;
+const groq_agent_1 = __importDefault(require("../../experimental_agents/llm_agents/groq_agent"));
+exports.gloqAgent = groq_agent_1.default;
+const slashgpt_agent_1 = __importDefault(require("../../experimental_agents/llm_agents/slashgpt_agent"));
+exports.slashGPTAgent = slashgpt_agent_1.default;

package/lib/experimental_agents/llm_agents/slashgpt_agent.d.ts

@@ -0,0 +1,27 @@
+import { AgentFunction } from "../../graphai";
+import { ManifestData, ChatData } from "slashgpt";
+export declare const slashGPTAgent: AgentFunction<{
+    manifest: ManifestData;
+    query?: string;
+    function_result?: boolean;
+}, ChatData[], string>;
+declare const slashGPTAgentInfo: {
+    name: string;
+    agent: AgentFunction<{
+        manifest: ManifestData;
+        query?: string | undefined;
+        function_result?: boolean | undefined;
+    }, ChatData[], string>;
+    mock: AgentFunction<{
+        manifest: ManifestData;
+        query?: string | undefined;
+        function_result?: boolean | undefined;
+    }, ChatData[], string>;
+    samples: never[];
+    description: string;
+    category: string[];
+    author: string;
+    repository: string;
+    license: string;
+};
+export default slashGPTAgentInfo;