@cognigy/rest-api-client 2026.1.0 → 2026.2.0-rc1

package/dist/esm/spec/aiAgentV2.spec.js

@@ -0,0 +1,563 @@
+import { __awaiter } from "tslib";
+import { describe, it, before } from "node:test";
+import * as assert from "node:assert";
+import { RestAPIClient } from "../RestAPIClient";
+import { ResourceNotFoundError } from "../shared/errors";
+describe("AI Agents V2 API", () => {
+    let client;
+    before(() => {
+        const apiBaseUrl = process.env.REST_API_CLIENT_E2E_TESTS_API_BASE_URL || "https://api-benni-test.cognigy.dev";
+        client = new RestAPIClient({
+            baseUrl: apiBaseUrl
+        });
+        client.setCredentials({
+            type: "ApiKey",
+            apiKey: process.env.REST_API_CLIENT_E2E_TESTS_API_KEY || ""
+        });
+    });
+    const validLocaleReferenceId = "ac919341-77c7-484f-86b9-f59b0759f1f8";
+    const validProjectId = "6960e2eaac2b03e5485f3d65";
+    const validAgentPersonaReferenceId = "b2199b60-631f-4e4d-88d6-7149ce3aee78";
+    describe("Agents", () => {
+        it("creates a new Agent", () => __awaiter(void 0, void 0, void 0, function* () {
+            const agent = yield client.createAgent({
+                name: "Customer Support Agent",
+                description: "Accepts support requests from customers and creates ticket in Zendesk.",
+                instructions: "You answer customer support requests in a friendly way. You can create tickets in our ticketing portal using the createTicket tool.",
+                localeReferenceId: validLocaleReferenceId,
+                projectId: validProjectId,
+                personaReferenceId: validAgentPersonaReferenceId,
+                toolReferenceIds: [],
+                knowledge: {
+                    context: "This is some always available context for the agent.",
+                    ragType: "cognigy",
+                    ragMode: "never",
+                    ragParameters: {}
+                }
+            });
+            assert.ok(agent, "Created agent is undefined");
+            assert.equal(Object.keys(agent).length, 15);
+            assert.ok(agent.id, "Agent ID is missing");
+            assert.ok(agent.referenceId, "Agent referenceId is missing");
+            assert.equal(agent.localeReferenceId, validLocaleReferenceId, "Agent localeReferenceId does not match");
+            assert.equal(agent.name, "Customer Support Agent", "Agent name does not match");
+            assert.equal(agent.description, "Accepts support requests from customers and creates ticket in Zendesk.", "Agent description does not match");
+            assert.equal(agent.instructions, "You answer customer support requests in a friendly way. You can create tickets in our ticketing portal using the createTicket tool.", "Agent instructions do not match");
+            assert.equal(agent.personaReferenceId, validAgentPersonaReferenceId, "Agent personaReferenceId does not match");
+            assert.deepStrictEqual(agent.toolReferenceIds, [], "Agent toolReferenceIds do not match");
+            assert.deepStrictEqual(agent.knowledge, {
+                context: "This is some always available context for the agent.",
+                ragType: "cognigy",
+                ragMode: "never",
+                ragParameters: {}
+            }, "Agent knowledge does not match");
+            assert.equal(agent.projectId, validProjectId, "Agent projectId does not match");
+            assert.ok(agent.organisationId, "Agent organisationId is missing");
+            assert.ok(agent.createdBy, "Agent createdBy is missing");
+            assert.ok(agent.createdAt, "Agent createdAt is missing");
+            assert.ok(agent.lastChangedBy, "Agent lastChangedBy is missing");
+            assert.ok(agent.lastChangedAt, "Agent lastChangedAt is missing");
+        }));
+        it("creates a new Agent and then reads its properties back", () => __awaiter(void 0, void 0, void 0, function* () {
+            const agent = yield client.createAgent({
+                name: "Customer Support Agent",
+                description: "Accepts support requests from customers and creates ticket in Zendesk.",
+                instructions: "You answer customer support requests in a friendly way. You can create tickets in our ticketing portal using the createTicket tool.",
+                localeReferenceId: validLocaleReferenceId,
+                projectId: validProjectId,
+                personaReferenceId: validAgentPersonaReferenceId,
+                toolReferenceIds: [],
+                knowledge: {
+                    context: "This is some always available context for the agent.",
+                    ragType: "cognigy",
+                    ragMode: "never",
+                    ragParameters: {}
+                }
+            });
+            const fetchedAgent = yield client.readAgent({
+                agentId: agent.id
+            });
+            assert.ok(fetchedAgent);
+            assert.equal(Object.keys(fetchedAgent).length, 15, "Fetched agent has incorrect number of properties");
+            assert.equal(fetchedAgent.id, agent.id, "Fetched agent ID does not match");
+            assert.equal(fetchedAgent.referenceId, agent.referenceId, "Fetched agent referenceId does not match");
+            assert.equal(fetchedAgent.localeReferenceId, agent.localeReferenceId, "Fetched agent localeReferenceId does not match");
+            assert.equal(fetchedAgent.name, agent.name, "Fetched agent name does not match");
+            assert.equal(fetchedAgent.description, agent.description, "Fetched agent description does not match");
+            assert.equal(fetchedAgent.instructions, agent.instructions, "Fetched agent instructions do not match");
+            assert.equal(fetchedAgent.personaReferenceId, agent.personaReferenceId, "Fetched agent personaReferenceId does not match");
+            assert.deepStrictEqual(fetchedAgent.toolReferenceIds, agent.toolReferenceIds, "Fetched agent toolReferenceIds do not match");
+            assert.deepStrictEqual(fetchedAgent.knowledge, agent.knowledge, "Fetched agent knowledge does not match");
+            assert.deepStrictEqual(fetchedAgent.knowledge, agent.knowledge, "Fetched agent knowledge does not match");
+            assert.equal(fetchedAgent.projectId, agent.projectId, "Fetched agent projectId does not match");
+            assert.equal(fetchedAgent.organisationId, agent.organisationId, "Fetched agent organisationId does not match");
+            assert.equal(fetchedAgent.createdBy, agent.createdBy, "Fetched agent createdBy does not match");
+            assert.equal(fetchedAgent.createdAt, agent.createdAt, "Fetched agent createdAt does not match");
+            assert.equal(fetchedAgent.lastChangedBy, agent.lastChangedBy, "Fetched agent lastChangedBy does not match");
+            assert.equal(fetchedAgent.lastChangedAt, agent.lastChangedAt, "Fetched agent lastChangedAt does not match");
+        }));
+        it("creates different Agents and then lists them", () => __awaiter(void 0, void 0, void 0, function* () {
+            yield client.createAgent({
+                name: "Support Agent",
+                description: "Accepts support requests from customers and creates ticket in Zendesk.",
+                instructions: "You answer customer support requests in a friendly way. You can create tickets in our ticketing portal using the createTicket tool.",
+                localeReferenceId: validLocaleReferenceId,
+                projectId: validProjectId,
+                personaReferenceId: validAgentPersonaReferenceId,
+                toolReferenceIds: [],
+                knowledge: {
+                    context: "We never talk about prices of our products via our helpdesk.",
+                    ragType: "cognigy",
+                    ragMode: "never",
+                    ragParameters: {}
+                }
+            });
+            yield client.createAgent({
+                name: "Flight Status Agent",
+                description: "Provides information about flight statuses to customers.",
+                instructions: "You provide up-to-date flight status information based on customer queries.",
+                localeReferenceId: validLocaleReferenceId,
+                projectId: validProjectId,
+                personaReferenceId: validAgentPersonaReferenceId,
+                toolReferenceIds: [],
+                knowledge: {
+                    context: "We never talk about prices of our products via our helpdesk.",
+                    ragType: "cognigy",
+                    ragMode: "never",
+                    ragParameters: {}
+                }
+            });
+            const agentList = yield client.indexAgents({}); // filter based on actual projectId
+            assert.ok(agentList.items);
+            assert.ok(agentList.nextCursor);
+            assert.ok(agentList.previousCursor);
+            assert.ok(agentList.total);
+            agentList.items.every(agent => {
+                assert.equal(Object.keys(agent).length, 15);
+                assert.ok(agent.id, "Agent ID is missing");
+                assert.ok(agent.referenceId, "Agent referenceId is missing");
+                assert.equal(agent.localeReferenceId, validLocaleReferenceId, "Agent localeReferenceId does not match");
+                assert.ok(agent.name, "Agent name is missing");
+                assert.ok(agent.description, "Agent description is missing");
+                assert.ok(agent.instructions, "Agent instructions are missing");
+                assert.equal(agent.personaReferenceId, validAgentPersonaReferenceId, "Agent personaReferenceId does not match");
+                assert.ok(agent.toolReferenceIds, "Agent toolReferenceIds are missing");
+                assert.ok(agent.knowledge, "Agent knowledge is missing");
+                assert.equal(agent.projectId, validProjectId, "Agent projectId does not match");
+                assert.ok(agent.organisationId, "Agent organisationId is missing");
+                assert.ok(agent.createdBy, "Agent createdBy is missing");
+                assert.ok(agent.createdAt, "Agent createdAt is missing");
+                assert.ok(agent.lastChangedBy, "Agent lastChangedBy is missing");
+                assert.ok(agent.lastChangedAt, "Agent lastChangedAt is missing");
+            });
+        }));
+        it("creates an Agent and then deletes it", () => __awaiter(void 0, void 0, void 0, function* () {
+            const agent = yield client.createAgent({
+                name: "Customer Support Agent",
+                description: "Accepts support requests from customers and creates ticket in Zendesk.",
+                instructions: "You answer customer support requests in a friendly way. You can create tickets in our ticketing portal using the createTicket tool.",
+                localeReferenceId: validLocaleReferenceId,
+                projectId: validProjectId,
+                personaReferenceId: validAgentPersonaReferenceId,
+                toolReferenceIds: [],
+                knowledge: {
+                    context: "This is some always available context for the agent.",
+                    ragType: "cognigy",
+                    ragMode: "never",
+                    ragParameters: {}
+                }
+            });
+            assert.ok(agent, "Created agent is undefined");
+            yield client.deleteAgent({
+                agentId: agent.id
+            });
+            // verify that the agent is gone
+            assert.rejects(() => client.readAgent({ agentId: agent.id }), ResourceNotFoundError);
+        }));
+    });
+    describe("Agent Personas", () => {
+        it("creates a new Agent Persona", () => __awaiter(void 0, void 0, void 0, function* () {
+            const agentPersona = yield client.createAgentPersona({
+                name: "Helpful Assistant",
+                description: "A friendly and helpful assistant persona.",
+                image: "https://example.com/images/helpful-assistant.png",
+                imageOptimizedFormat: true,
+                speakingStyle: {
+                    completeness: "concise",
+                    formality: "formal",
+                },
+                voiceConfig: {
+                    ttsModel: "neural",
+                    ttsVendor: "aws",
+                    ttsVoice: "Joanna",
+                    ttsLabel: "german",
+                    ttsLanguage: "de-DE",
+                    ttsDisableCache: false
+                },
+                projectId: validProjectId
+            });
+            assert.ok(agentPersona);
+            assert.equal(Object.keys(agentPersona).length, 14, "Agent Persona has incorrect number of properties");
+            assert.ok(agentPersona.id, "Agent Persona ID is missing");
+            assert.ok(agentPersona.referenceId, "Agent Persona referenceId is missing");
+            assert.equal(agentPersona.name, "Helpful Assistant", "Agent Persona name does not match");
+            assert.equal(agentPersona.image, "https://example.com/images/helpful-assistant.png", "Agent Persona image does not match");
+            assert.equal(agentPersona.imageOptimizedFormat, true, "Agent Persona imageOptimizedFormat does not match");
+            assert.equal(agentPersona.description, "A friendly and helpful assistant persona.", "Agent Persona description does not match");
+            assert.deepStrictEqual(agentPersona.speakingStyle, {
+                completeness: "concise",
+                formality: "formal",
+            }, "Agent Persona speakingStyle does not match");
+            assert.deepStrictEqual(agentPersona.voiceConfig, {
+                ttsModel: "neural",
+                ttsVendor: "aws",
+                ttsVoice: "Joanna",
+                ttsLabel: "german",
+                ttsLanguage: "de-DE",
+                ttsDisableCache: false
+            }, "Agent Persona voiceConfig does not match");
+            assert.equal(agentPersona.projectId, validProjectId, "Agent Persona projectId does not match");
+            assert.ok(agentPersona.organisationId);
+            assert.ok(agentPersona.createdBy, "Agent Persona createdBy is missing");
+            assert.ok(agentPersona.createdAt, "Agent Persona createdAt is missing");
+            assert.ok(agentPersona.lastChangedBy, "Agent Persona lastChangedBy is missing");
+            assert.ok(agentPersona.lastChangedAt, "Agent Persona lastChangedAt is missing");
+        }));
+        it("creates a new Agent Persona and then reads its properties back", () => __awaiter(void 0, void 0, void 0, function* () {
+            const agentPersona = yield client.createAgentPersona({
+                name: "Helpful Assistant",
+                description: "A friendly and helpful assistant persona.",
+                image: "https://example.com/images/helpful-assistant.png",
+                imageOptimizedFormat: true,
+                speakingStyle: {
+                    completeness: "concise",
+                    formality: "formal",
+                },
+                voiceConfig: {
+                    ttsModel: "neural",
+                    ttsVendor: "aws",
+                    ttsVoice: "Joanna",
+                    ttsLabel: "german",
+                    ttsLanguage: "de-DE",
+                    ttsDisableCache: false
+                },
+                projectId: validProjectId
+            });
+            const fetchedAgentPersona = yield client.readAgentPersona({
+                agentPersonaId: agentPersona.id
+            });
+            assert.deepStrictEqual(fetchedAgentPersona, agentPersona, "Fetched Agent Persona does not match the created one");
+        }));
+        it("creates different Agent Personas and then lists them", () => __awaiter(void 0, void 0, void 0, function* () {
+            yield client.createAgentPersona({
+                name: "Friendly Guide",
+                description: "A friendly guide persona.",
+                image: "https://example.com/images/friendly-guide.png",
+                imageOptimizedFormat: true,
+                speakingStyle: {
+                    completeness: "detailed",
+                    formality: "informal",
+                },
+                voiceConfig: {
+                    ttsModel: "neural",
+                    ttsVendor: "aws",
+                    ttsVoice: "Matthew",
+                    ttsLabel: "english",
+                    ttsLanguage: "en-US",
+                    ttsDisableCache: false
+                },
+                projectId: validProjectId
+            });
+            yield client.createAgentPersona({
+                name: "Professional Advisor",
+                description: "A professional advisor persona.",
+                image: "https://example.com/images/professional-advisor.png",
+                imageOptimizedFormat: false,
+                speakingStyle: {
+                    completeness: "concise",
+                    formality: "formal",
+                },
+                voiceConfig: {
+                    ttsModel: "standard",
+                    ttsVendor: "google",
+                    ttsVoice: "en-US-Wavenet-D",
+                    ttsLabel: "english",
+                    ttsLanguage: "en-US",
+                    ttsDisableCache: false
+                },
+                projectId: validProjectId
+            });
+            const agentPersonas = yield client.indexAgentPersonas({});
+            assert.ok(agentPersonas.items);
+            assert.ok(agentPersonas.nextCursor);
+            assert.ok(agentPersonas.previousCursor);
+            assert.ok(agentPersonas.total);
+            agentPersonas.items.every(agentPersona => {
+                assert.equal(Object.keys(agentPersona).length, 14);
+                assert.ok(agentPersona.id, "Agent Persona ID is missing");
+                assert.ok(agentPersona.referenceId, "Agent Persona referenceId is missing");
+                assert.ok(agentPersona.name, "Agent Persona name is missing");
+                assert.ok(agentPersona.description, "Agent Persona description is missing");
+                assert.ok(agentPersona.image, "Agent Persona image is missing");
+                assert.ok(typeof agentPersona.imageOptimizedFormat === "boolean", "Agent Persona imageOptimizedFormat is missing");
+                assert.ok(agentPersona.speakingStyle, "Agent Persona speakingStyle is missing");
+                assert.ok(agentPersona.voiceConfig, "Agent Persona voiceConfig is missing");
+                assert.ok(agentPersona.projectId, "Agent Persona projectId is missing");
+                assert.ok(agentPersona.organisationId, "Agent Persona organisationId is missing");
+                assert.ok(agentPersona.createdBy, "Agent Persona createdBy is missing");
+                assert.ok(agentPersona.createdAt, "Agent Persona createdAt is missing");
+                assert.ok(agentPersona.lastChangedBy, "Agent Persona lastChangedBy is missing");
+                assert.ok(agentPersona.lastChangedAt, "Agent Persona lastChangedAt is missing");
+            });
+        }));
+        it("creates an Agent Persona and updates it multiple times", () => __awaiter(void 0, void 0, void 0, function* () {
+            let agentPersona = yield client.createAgentPersona({
+                name: "Temporary Persona",
+                description: "This persona will be updated.",
+                image: "https://example.com/images/temporary-persona.png",
+                imageOptimizedFormat: false,
+                speakingStyle: {
+                    completeness: "concise",
+                    formality: "informal",
+                },
+                voiceConfig: {
+                    ttsModel: "standard",
+                    ttsVendor: "google",
+                    ttsVoice: "en-US-Wavenet-B",
+                    ttsLabel: "english",
+                    ttsLanguage: "en-US",
+                    ttsDisableCache: false
+                },
+                projectId: validProjectId
+            });
+            assert.ok(agentPersona);
+            agentPersona = yield client.updateAgentPersona({
+                agentPersonaId: agentPersona.id,
+                name: "Updated Persona Name",
+                description: "The description has been updated.",
+                image: "https://example.com/images/updated-persona.png",
+                imageOptimizedFormat: true,
+                speakingStyle: {
+                    completeness: "detailed",
+                    formality: "formal",
+                },
+                voiceConfig: {
+                    ttsModel: "neural",
+                    ttsVendor: "aws",
+                    ttsVoice: "Joanna",
+                    ttsLabel: "german",
+                    ttsLanguage: "de-DE",
+                    ttsDisableCache: false
+                }
+            });
+            assert.equal(agentPersona.name, "Updated Persona Name", "Agent Persona name was not updated correctly.");
+            assert.equal(agentPersona.description, "The description has been updated.", "Agent Persona description was not updated correctly.");
+            assert.equal(agentPersona.image, "https://example.com/images/updated-persona.png", "Agent Persona image was not updated correctly.");
+            assert.equal(agentPersona.imageOptimizedFormat, true);
+            assert.deepStrictEqual(agentPersona.speakingStyle, {
+                completeness: "detailed",
+                formality: "formal",
+            }, "Agent Persona speakingStyle was not updated correctly.");
+            assert.deepStrictEqual(agentPersona.voiceConfig, {
+                ttsModel: "neural",
+                ttsVendor: "aws",
+                ttsVoice: "Joanna",
+                ttsLabel: "german",
+                ttsLanguage: "de-DE",
+                ttsDisableCache: false
+            }, "Agent Persona voiceConfig was not updated correctly.");
+        }));
+        it("creates an Agent Persona and then deletes it", () => __awaiter(void 0, void 0, void 0, function* () {
+            const agentPersona = yield client.createAgentPersona({
+                name: "Temporary Persona",
+                description: "This persona will be deleted.",
+                image: "https://example.com/images/temporary-persona.png",
+                imageOptimizedFormat: false,
+                speakingStyle: {
+                    completeness: "concise",
+                    formality: "informal",
+                },
+                voiceConfig: {
+                    ttsModel: "standard",
+                    ttsVendor: "google",
+                    ttsVoice: "en-US-Wavenet-B",
+                    ttsLabel: "english",
+                    ttsLanguage: "en-US",
+                    ttsDisableCache: false
+                },
+                projectId: validProjectId
+            });
+            assert.ok(agentPersona);
+            yield client.deleteAgentPersona({
+                agentPersonaId: agentPersona.id
+            });
+            assert.rejects(() => client.readAgentPersona({ agentPersonaId: agentPersona.id }), ResourceNotFoundError);
+        }));
+    });
+    describe("Tool Descriptors", () => {
+        it("lists all available Tool Descriptors", () => __awaiter(void 0, void 0, void 0, function* () {
+            const toolDescriptors = yield client.indexToolDescriptors({});
+            assert.ok(toolDescriptors);
+            assert.ok(toolDescriptors.items);
+            const [firstToolDescriptor] = toolDescriptors.items;
+            assert.ok(Object.keys(firstToolDescriptor).length === 8);
+            assert.ok(firstToolDescriptor.id, "Tool Descriptor ID is missing");
+            assert.ok(firstToolDescriptor.type, "Tool Descriptor type is missing");
+            assert.ok(firstToolDescriptor.extension, "Tool Descriptor extension is missing");
+            assert.ok(firstToolDescriptor.imageUrl, "Tool Descriptor imageUrl is missing");
+            assert.ok(firstToolDescriptor.defaultLabel, "Tool Descriptor defaultLabel is missing");
+            assert.ok(firstToolDescriptor.defaultParameters, "Tool Descriptor defaultParameters is missing");
+            assert.ok(firstToolDescriptor.projectId, "Tool Descriptor projectId is missing");
+            assert.ok(firstToolDescriptor.organisationId, "Tool Descriptor organisationId is missing");
+        }));
+    });
+    describe("Tools", () => {
+        it("creates a new Tool", () => __awaiter(void 0, void 0, void 0, function* () {
+            const tool = yield client.createTool({
+                type: "httpRequest",
+                extension: "@cognigy/basic-tools",
+                name: "HTTP Request",
+                description: "A tool to make HTTP requests.",
+                parameters: [
+                    {
+                        name: "method",
+                        description: "The HTTP method to use.",
+                        mode: "dynamic",
+                        type: "string",
+                        value: {
+                            valueType: "static",
+                        }
+                    }
+                ],
+                projectId: validProjectId
+            });
+            assert.ok(tool);
+            assert.equal(Object.keys(tool).length, 13, "Tool has incorrect number of properties");
+            assert.ok(tool.id, "Tool ID is missing");
+            assert.equal(tool.type, "httpRequest", "Tool type does not match");
+            assert.equal(tool.extension, "@cognigy/basic-tools", "Tool extension does not match");
+            assert.equal(tool.name, "HTTP Request", "Tool name does not match");
+            assert.equal(tool.description, "A tool to make HTTP requests.", "Tool description does not match");
+            assert.deepStrictEqual(tool.parameters, [
+                {
+                    name: "method",
+                    description: "The HTTP method to use.",
+                    mode: "dynamic",
+                    type: "string",
+                    value: {
+                        valueType: "static"
+                    }
+                }
+            ], "Tool parameters do not match");
+            assert.equal(tool.projectId, validProjectId, "Tool projectId does not match");
+            assert.ok(tool.organisationId, "Tool organisationId is missing");
+            assert.ok(tool.createdAt, "Tool createdAt is missing");
+            assert.ok(tool.createdBy, "Tool createdBy is missing");
+            assert.ok(tool.lastChangedAt, "Tool lastChangedAt is missing");
+            assert.ok(tool.lastChangedBy, "Tool lastChangedBy is missing");
+        }));
+        it("creates a new Tool and then reads its properties back", () => __awaiter(void 0, void 0, void 0, function* () {
+            const tool = yield client.createTool({
+                type: "httpRequest",
+                extension: "@cognigy/basic-tools",
+                name: "HTTP Request",
+                description: "A tool to make HTTP requests.",
+                parameters: [
+                    {
+                        name: "method",
+                        description: "The HTTP method to use.",
+                        mode: "dynamic",
+                        type: "string",
+                        value: {
+                            valueType: "static",
+                        }
+                    }
+                ],
+                projectId: validProjectId
+            });
+            const fetchedTool = yield client.readTool({
+                toolId: tool.id
+            });
+            assert.ok(fetchedTool);
+            assert.ok(fetchedTool.id, "Tool ID is missing");
+            assert.equal(fetchedTool.type, "httpRequest", "Tool type does not match");
+            assert.equal(fetchedTool.extension, "@cognigy/basic-tools", "Tool extension does not match");
+            assert.equal(fetchedTool.name, "HTTP Request", "Tool name does not match");
+            assert.equal(fetchedTool.description, "A tool to make HTTP requests.", "Tool description does not match");
+            assert.equal(fetchedTool.projectId, validProjectId, "Tool projectId does not match");
+            assert.ok(fetchedTool.createdAt, "Tool createdAt is missing");
+            assert.ok(fetchedTool.createdBy, "Tool createdBy is missing");
+            assert.ok(fetchedTool.lastChangedAt);
+            assert.ok(fetchedTool.lastChangedBy, "Tool lastChangedBy is missing");
+            const [firstParam] = fetchedTool.parameters;
+            assert.ok(firstParam.name, "Tool parameter name is missing");
+            assert.ok(firstParam.description, "Tool parameter description is missing");
+            assert.ok(firstParam.mode, "Tool parameter mode is missing");
+            assert.ok(firstParam.type, "Tool parameter type is missing");
+            assert.ok(firstParam.value, "Tool parameter value is missing");
+        }));
+        it("lists all available Tools", () => __awaiter(void 0, void 0, void 0, function* () {
+            const tools = yield client.indexTools({});
+            assert.ok(tools);
+            assert.ok(tools.items);
+            assert.ok(tools.nextCursor);
+            assert.ok(tools.previousCursor);
+            assert.ok(tools.total);
+            const [firstTool] = tools.items;
+            assert.ok(Object.keys(firstTool).length === 13, "Tool has incorrect number of properties");
+            assert.ok(firstTool.id, "Tool ID is missing");
+            assert.ok(firstTool.referenceId, "Tool referenceId is missing");
+            assert.ok(firstTool.type, "Tool type is missing");
+            assert.ok(firstTool.extension, "Tool extension is missing");
+            assert.ok(firstTool.parameters, "Tool parameters are missing");
+            assert.ok(firstTool.name, "Tool name is missing");
+            assert.ok(firstTool.description, "Tool description is missing");
+            assert.ok(firstTool.projectId, "Tool projectId is missing");
+            assert.ok(firstTool.organisationId, "Tool organisationId is missing");
+            assert.ok(firstTool.createdAt, "Tool createdAt is missing");
+            assert.ok(firstTool.createdBy, "Tool createdBy is missing");
+            assert.ok(firstTool.lastChangedAt, "Tool lastChangedAt is missing");
+            assert.ok(firstTool.lastChangedBy, "Tool lastChangedBy is missing");
+        }));
+        it("creates a Tool and then deletes it", () => __awaiter(void 0, void 0, void 0, function* () {
+            const tool = yield client.createTool({
+                type: "httpRequest",
+                extension: "@cognigy/basic-tools",
+                name: "Temporary HTTP Request",
+                description: "A temporary tool to make HTTP requests.",
+                parameters: [],
+                projectId: validProjectId
+            });
+            assert.ok(tool);
+            yield client.deleteTool({
+                toolId: tool.id
+            });
+            assert.rejects(() => client.readTool({ toolId: tool.id }), ResourceNotFoundError);
+        }));
+        it("creates a Tool and then updates it", () => __awaiter(void 0, void 0, void 0, function* () {
+            const tool = yield client.createTool({
+                type: "httpRequest",
+                extension: "@cognigy/basic-tools",
+                name: "Updatable HTTP Request",
+                description: "A tool to make HTTP requests that will be updated.",
+                parameters: [],
+                projectId: validProjectId
+            });
+            assert.ok(tool);
+            const updatedTool = yield client.updateTool({
+                toolId: tool.id,
+                name: "Updated HTTP Request Tool",
+                description: "The description has been updated.",
+                parameters: []
+            });
+            assert.equal(updatedTool.id, tool.id, "Tool ID should not change after update");
+            assert.equal(updatedTool.name, "Updated HTTP Request Tool", "Tool name does not match after update");
+            assert.equal(updatedTool.description, "The description has been updated.", "Tool description does not match after update");
+            assert.ok(updatedTool.createdBy, "Tool createdBy is missing after update");
+            assert.ok(updatedTool.createdAt, "Tool createdAt is missing after update");
+            assert.ok(updatedTool.lastChangedBy, "Tool lastChangedBy is missing after update");
+            // assert.ok(updatedTool.lastChangedAt); (not properly set - always 0!)
+        }));
+    });
+});
+//# sourceMappingURL=aiAgentV2.spec.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@cognigy/rest-api-client",
-	"version": "2026.1.0",
+	"version": "2026.2.0-rc1",
 	"description": "Cognigy REST-Client",
 	"main": "build/index.js",
 	"module": "dist/esm/index.js",
@@ -18,6 +18,7 @@
 		"type-check:watch": "npm run type-check -- --watch",
 		"test:only": "npm run test:unit",
 		"test:unit": "nyc mocha --opts .mocharc && rimraf ./.nyc_output",
+		"test:aiAgentsV2": "node --import=tsx --test --test-timeout=120000 --test-force-exit --test-reporter spec ./src/spec/aiAgentV2.spec.ts",
 		"prepublishOnly": "npm run build"
 	},
 	"repository": {},
@@ -30,6 +31,7 @@
 	"author": "Cognigy GmbH",
 	"license": "Cognigy Proprietary License",
 	"dependencies": {
+		"@cognigy/extension-tools": "0.17.0-rc4",
 		"ajv": "6.12.6",
 		"axios": "1.8.3",
 		"form-data": "4.0.4",
@@ -51,7 +53,7 @@
 		"@rollup/plugin-json": "4.1.0",
 		"@rollup/plugin-node-resolve": "13.3.0",
 		"@rollup/plugin-typescript": "8.3.4",
-		"@types/node": "18.7.6",
+		"@types/node": "22.19.7",
 		"@types/sinon": "10.0.13",
 		"@types/tus-js-client": "^2.1.0",
 		"@typescript-eslint/eslint-plugin": "5.33.1",
@@ -70,6 +72,7 @@
 		"regenerator-runtime": "0.13.9",
 		"rimraf": "3.0.2",
 		"rollup": "2.78.0",
+		"tsx": "4.21",
 		"typescript": "4.7.4"
 	},
 	"engines": {
@@ -77,4 +80,4 @@
 		"npm": ">=10.1.0",
 		"vscode": "^1.22.0"
 	}
-}
+}