pygeai 0.1.51b3__py3-none-any.whl → 0.6.0b15__py3-none-any.whl

pygeai/tests/cli/commands/lab/test_common.py

@@ -0,0 +1,208 @@
+import unittest
+from unittest import TestCase
+from pygeai.cli.commands.lab.common import (
+    get_agent_data_prompt_inputs,
+    get_agent_data_prompt_outputs,
+    get_agent_data_prompt_examples,
+    get_tool_parameters
+)
+from pygeai.core.common.exceptions import WrongArgumentError
+
+
+class TestLabCommon(TestCase):
+    """
+    python -m unittest pygeai.tests.cli.commands.lab.test_common.TestLabCommon
+    """
+
+    def test_get_agent_data_prompt_inputs_valid(self):
+        input_list = ["input1", "input2"]
+        result = get_agent_data_prompt_inputs(input_list)
+        self.assertEqual(result, input_list)
+
+    def test_get_agent_data_prompt_inputs_invalid_non_string(self):
+        input_list = ["input1", 123]  # Non-string element
+        with self.assertRaises(WrongArgumentError) as context:
+            get_agent_data_prompt_inputs(input_list)
+        self.assertIn("Inputs must be a list of strings", str(context.exception))
+
+    def test_get_agent_data_prompt_inputs_empty(self):
+        input_list = []
+        result = get_agent_data_prompt_inputs(input_list)
+        self.assertEqual(result, [])
+
+    def test_get_agent_data_prompt_outputs_valid(self):
+        output_list = [
+            {"key": "output1", "description": "Description for output1"},
+            {"key": "output2", "description": "Description for output2"}
+        ]
+        result = get_agent_data_prompt_outputs(output_list)
+        self.assertEqual(result, output_list)
+
+    def test_get_agent_data_prompt_outputs_invalid_missing_key(self):
+        output_list = [
+            {"description": "Description without key"}  # Missing 'key'
+        ]
+        with self.assertRaises(WrongArgumentError) as context:
+            get_agent_data_prompt_outputs(output_list)
+        self.assertIn("Each output must be in JSON format", str(context.exception))
+
+    def test_get_agent_data_prompt_outputs_invalid_type(self):
+        output_list = [
+            "not a dict"  # Not a dictionary
+        ]
+        with self.assertRaises(WrongArgumentError) as context:
+            get_agent_data_prompt_outputs(output_list)
+        self.assertIn("Each output must be in JSON format", str(context.exception))
+
+    def test_get_agent_data_prompt_outputs_empty(self):
+        output_list = []
+        result = get_agent_data_prompt_outputs(output_list)
+        self.assertEqual(result, [])
+
+    def test_get_agent_data_prompt_examples_valid(self):
+        example_list = [
+            {"inputData": "Input example 1", "output": '{"result": "Output 1"}'},
+            {"inputData": "Input example 2", "output": '{"result": "Output 2"}'}
+        ]
+        result = get_agent_data_prompt_examples(example_list)
+        self.assertEqual(result, example_list)
+
+    def test_get_agent_data_prompt_examples_invalid_missing_field(self):
+        example_list = [
+            {"inputData": "Input without output"}  # Missing 'output'
+        ]
+        with self.assertRaises(WrongArgumentError) as context:
+            get_agent_data_prompt_examples(example_list)
+        self.assertIn("Each example must be in JSON format", str(context.exception))
+
+    def test_get_agent_data_prompt_examples_invalid_type(self):
+        example_list = [
+            "not a dict"  # Not a dictionary
+        ]
+        with self.assertRaises(WrongArgumentError) as context:
+            get_agent_data_prompt_examples(example_list)
+        self.assertIn("Each example must be in JSON format", str(context.exception))
+
+    def test_get_agent_data_prompt_examples_empty(self):
+        example_list = []
+        result = get_agent_data_prompt_examples(example_list)
+        self.assertEqual(result, [])
+
+    def test_get_tool_parameters_valid_regular(self):
+        param_list = [
+            {"key": "param1", "dataType": "String", "description": "Param 1 description", "isRequired": True}
+        ]
+        result = get_tool_parameters(param_list)
+        self.assertEqual(result, param_list)
+
+    def test_get_tool_parameters_valid_config(self):
+        param_list = [
+            {
+                "key": "config1",
+                "dataType": "String",
+                "description": "Config 1 description",
+                "isRequired": True,
+                "type": "config",
+                "fromSecret": False,
+                "value": "config_value"
+            }
+        ]
+        result = get_tool_parameters(param_list)
+        self.assertEqual(result, param_list)
+
+    def test_get_tool_parameters_invalid_missing_field(self):
+        param_list = [
+            {"key": "param1", "dataType": "String", "isRequired": True}  # Missing 'description'
+        ]
+        with self.assertRaises(WrongArgumentError) as context:
+            get_tool_parameters(param_list)
+        self.assertIn("Each parameter must contain 'key', 'dataType', 'description', and 'isRequired'", str(context.exception))
+
+    def test_get_tool_parameters_invalid_key_type(self):
+        param_list = [
+            {"key": 123, "dataType": "String", "description": "Param description", "isRequired": True}  # 'key' not string
+        ]
+        with self.assertRaises(WrongArgumentError) as context:
+            get_tool_parameters(param_list)
+        self.assertIn("Parameter 'key' must be a string", str(context.exception))
+
+    def test_get_tool_parameters_invalid_data_type(self):
+        param_list = [
+            {"key": "param1", "dataType": 123, "description": "Param description", "isRequired": True}  # 'dataType' not string
+        ]
+        with self.assertRaises(WrongArgumentError) as context:
+            get_tool_parameters(param_list)
+        self.assertIn("Parameter 'dataType' must be a string", str(context.exception))
+
+    def test_get_tool_parameters_invalid_description_type(self):
+        param_list = [
+            {"key": "param1", "dataType": "String", "description": 123, "isRequired": True}  # 'description' not string
+        ]
+        with self.assertRaises(WrongArgumentError) as context:
+            get_tool_parameters(param_list)
+        self.assertIn("Parameter 'description' must be a string", str(context.exception))
+
+    def test_get_tool_parameters_invalid_is_required_type(self):
+        param_list = [
+            {"key": "param1", "dataType": "String", "description": "Param description", "isRequired": "True"}  # 'isRequired' not bool
+        ]
+        with self.assertRaises(WrongArgumentError) as context:
+            get_tool_parameters(param_list)
+        self.assertIn("Parameter 'isRequired' must be a boolean", str(context.exception))
+
+    def test_get_tool_parameters_invalid_type_value(self):
+        param_list = [
+            {
+                "key": "param1",
+                "dataType": "String",
+                "description": "Param description",
+                "isRequired": True,
+                "type": "invalid"  # 'type' not 'config'
+            }
+        ]
+        with self.assertRaises(WrongArgumentError) as context:
+            get_tool_parameters(param_list)
+        self.assertIn("Parameter 'type' must be 'config' if present", str(context.exception))
+
+    def test_get_tool_parameters_invalid_from_secret_type(self):
+        param_list = [
+            {
+                "key": "param1",
+                "dataType": "String",
+                "description": "Param description",
+                "isRequired": True,
+                "type": "config",
+                "fromSecret": "True"  # 'fromSecret' not bool
+            }
+        ]
+        with self.assertRaises(WrongArgumentError) as context:
+            get_tool_parameters(param_list)
+        self.assertIn("Parameter 'fromSecret' must be a boolean if present", str(context.exception))
+
+    def test_get_tool_parameters_invalid_value_type(self):
+        param_list = [
+            {
+                "key": "param1",
+                "dataType": "String",
+                "description": "Param description",
+                "isRequired": True,
+                "type": "config",
+                "value": 123  # 'value' not string
+            }
+        ]
+        with self.assertRaises(WrongArgumentError) as context:
+            get_tool_parameters(param_list)
+        self.assertIn("Parameter 'value' must be a string if present", str(context.exception))
+
+    def test_get_tool_parameters_invalid_format(self):
+        param_list = [
+            "not a dict"  # Not a dictionary
+        ]
+        with self.assertRaises(WrongArgumentError) as context:
+            get_tool_parameters(param_list)
+        self.assertIn("Each parameter must contain", str(context.exception))
+
+    def test_get_tool_parameters_empty(self):
+        param_list = []
+        result = get_tool_parameters(param_list)
+        self.assertEqual(result, [])

pygeai/tests/cli/commands/lab/test_spec.py

@@ -0,0 +1,246 @@
+import unittest
+from unittest.mock import patch, MagicMock
+from pygeai.cli.commands.lab.spec import (
+    show_help,
+    load_agent,
+    create_agent,
+    load_tool,
+    create_tool,
+    load_task,
+    create_task,
+    load_agentic_process,
+    create_agentic_process
+)
+from pygeai.core.common.exceptions import MissingRequirementException
+from pygeai.cli.commands import Option
+
+
+class TestSpec(unittest.TestCase):
+    """
+    python -m unittest pygeai.tests.cli.commands.lab.test_spec.TestSpec
+    """
+
+    def test_show_help(self):
+        with patch('pygeai.cli.commands.lab.spec.Console.write_stdout') as mock_stdout:
+            show_help()
+            mock_stdout.assert_called_once()
+
+    def test_load_agent_missing_file(self):
+        option_list = []
+        with self.assertRaises(MissingRequirementException) as cm:
+            load_agent(option_list)
+        self.assertEqual(str(cm.exception), "Cannot load agent definition without specifying path to JSON file.")
+
+    def test_load_agent_single_dict(self):
+        option_list = [
+            (Option("file", ["--file"], "", True), "file.json"),
+            (Option("automatic_publish", ["--automatic-publish"], "", True), False)
+        ]
+        agent_data = {"key": "value"}
+        agent_mock = MagicMock()
+
+        with patch('pygeai.cli.commands.lab.spec.JSONLoader.load_data', return_value=agent_data), \
+             patch('pygeai.cli.commands.lab.spec.AgentParser.get_agent', return_value=agent_mock), \
+             patch('pygeai.cli.commands.lab.spec.create_agent') as mock_create:
+            load_agent(option_list)
+            mock_create.assert_called_once_with(agent_mock, False)
+
+    def test_load_agent_list(self):
+        option_list = [
+            (Option("file", ["--file"], "", True), "file.json"),
+            (Option("automatic_publish", ["--automatic-publish"], "", True), False)
+        ]
+        agent_data = [{"key1": "value1"}, {"key2": "value2"}]
+        agent_mock1, agent_mock2 = MagicMock(), MagicMock()
+
+        with patch('pygeai.cli.commands.lab.spec.JSONLoader.load_data', return_value=agent_data), \
+             patch('pygeai.cli.commands.lab.spec.AgentParser.get_agent', side_effect=[agent_mock1, agent_mock2]), \
+             patch('pygeai.cli.commands.lab.spec.create_agent') as mock_create:
+            load_agent(option_list)
+            self.assertEqual(mock_create.call_count, 2)
+            mock_create.assert_any_call(agent_mock1, False)
+            mock_create.assert_any_call(agent_mock2, False)
+
+    def test_create_agent_success(self):
+        agent_mock = MagicMock()
+        created_agent_mock = MagicMock()
+        with patch('pygeai.cli.commands.lab.spec.AILabManager') as mock_manager, \
+             patch('pygeai.cli.commands.lab.spec.Console.write_stdout') as mock_stdout:
+            mock_manager.return_value = MagicMock()
+            mock_manager.return_value.create_agent.return_value = created_agent_mock
+            create_agent(agent_mock, False)
+            mock_stdout.assert_called_once_with(f"Created agent detail: \n{created_agent_mock}")
+
+    def test_create_agent_failure(self):
+        agent_mock = MagicMock()
+        with patch('pygeai.cli.commands.lab.spec.AILabManager', side_effect=Exception("Error")), \
+             patch('pygeai.cli.commands.lab.spec.Console.write_stderr') as mock_stderr, \
+             patch('pygeai.cli.commands.lab.spec.logger.error') as mock_logger:
+            create_agent(agent_mock, False)
+            mock_stderr.assert_called_once_with(f"Error creating agent: \n{agent_mock}")
+            mock_logger.assert_called_once()
+
+    def test_load_tool_missing_file(self):
+        option_list = []
+        with self.assertRaises(MissingRequirementException) as cm:
+            load_tool(option_list)
+        self.assertEqual(str(cm.exception), "Cannot load tool definition without specifying path to JSON file.")
+
+    def test_load_tool_single_dict(self):
+        option_list = [
+            (Option("file", ["--file"], "", True), "file.json"),
+            (Option("automatic_publish", ["--automatic-publish"], "", True), False)
+        ]
+        tool_data = {"key": "value"}
+        tool_mock = MagicMock()
+
+        with patch('pygeai.cli.commands.lab.spec.JSONLoader.load_data', return_value=tool_data), \
+             patch('pygeai.cli.commands.lab.spec.ToolParser.get_tool', return_value=tool_mock), \
+             patch('pygeai.cli.commands.lab.spec.create_tool') as mock_create:
+            load_tool(option_list)
+            mock_create.assert_called_once_with(tool_mock, False)
+
+    def test_load_tool_list(self):
+        option_list = [
+            (Option("file", ["--file"], "", True), "file.json"),
+            (Option("automatic_publish", ["--automatic-publish"], "", True), False)
+        ]
+        tool_data = [{"key1": "value1"}, {"key2": "value2"}]
+        tool_mock1, tool_mock2 = MagicMock(), MagicMock()
+
+        with patch('pygeai.cli.commands.lab.spec.JSONLoader.load_data', return_value=tool_data), \
+             patch('pygeai.cli.commands.lab.spec.ToolParser.get_tool', side_effect=[tool_mock1, tool_mock2]), \
+             patch('pygeai.cli.commands.lab.spec.create_tool') as mock_create:
+            load_tool(option_list)
+            self.assertEqual(mock_create.call_count, 2)
+            mock_create.assert_any_call(tool_mock1, False)
+            mock_create.assert_any_call(tool_mock2, False)
+
+    def test_create_tool_success(self):
+        tool_mock = MagicMock()
+        created_tool_mock = MagicMock()
+        with patch('pygeai.cli.commands.lab.spec.AILabManager') as mock_manager, \
+             patch('pygeai.cli.commands.lab.spec.Console.write_stdout') as mock_stdout:
+            mock_manager.return_value = MagicMock()
+            mock_manager.return_value.create_tool.return_value = created_tool_mock
+            create_tool(tool_mock, False)
+            mock_stdout.assert_called_once_with(f"Created tool detail: \n{created_tool_mock}")
+
+    def test_create_tool_failure(self):
+        tool_mock = MagicMock()
+        with patch('pygeai.cli.commands.lab.spec.AILabManager', side_effect=Exception("Error")), \
+             patch('pygeai.cli.commands.lab.spec.Console.write_stderr') as mock_stderr, \
+             patch('pygeai.cli.commands.lab.spec.logger.error') as mock_logger:
+            create_tool(tool_mock, False)
+            mock_stderr.assert_called_once_with(f"Error creating tool: \n{tool_mock}")
+            mock_logger.assert_called_once()
+
+    def test_load_task_missing_file(self):
+        option_list = []
+        with self.assertRaises(MissingRequirementException) as cm:
+            load_task(option_list)
+        self.assertEqual(str(cm.exception), "Cannot load task definition without specifying path to JSON file.")
+
+    def test_load_task_single_dict(self):
+        option_list = [
+            (Option("file", ["--file"], "", True), "file.json"),
+            (Option("automatic_publish", ["--automatic-publish"], "", True), False)
+        ]
+        task_data = {"key": "value"}
+        task_mock = MagicMock()
+
+        with patch('pygeai.cli.commands.lab.spec.JSONLoader.load_data', return_value=task_data), \
+             patch('pygeai.cli.commands.lab.spec.TaskParser.get_task', return_value=task_mock), \
+             patch('pygeai.cli.commands.lab.spec.create_task') as mock_create:
+            load_task(option_list)
+            mock_create.assert_called_once_with(task_mock, False)
+
+    def test_load_task_list(self):
+        option_list = [
+            (Option("file", ["--file"], "", True), "file.json"),
+            (Option("automatic_publish", ["--automatic-publish"], "", True), False)
+        ]
+        task_data = [{"key1": "value1"}, {"key2": "value2"}]
+        task_mock1, task_mock2 = MagicMock(), MagicMock()
+
+        with patch('pygeai.cli.commands.lab.spec.JSONLoader.load_data', return_value=task_data), \
+             patch('pygeai.cli.commands.lab.spec.TaskParser.get_task', side_effect=[task_mock1, task_mock2]), \
+             patch('pygeai.cli.commands.lab.spec.create_task') as mock_create:
+            load_task(option_list)
+            self.assertEqual(mock_create.call_count, 2)
+            mock_create.assert_any_call(task_mock1, False)
+            mock_create.assert_any_call(task_mock2, False)
+
+    def test_create_task_success(self):
+        task_mock = MagicMock()
+        created_task_mock = MagicMock()
+        with patch('pygeai.cli.commands.lab.spec.AILabManager') as mock_manager, \
+             patch('pygeai.cli.commands.lab.spec.Console.write_stdout') as mock_stdout:
+            mock_manager.return_value = MagicMock()
+            mock_manager.return_value.create_task.return_value = created_task_mock
+            create_task(task_mock, False)
+            mock_stdout.assert_called_once_with(f"Created task detail: \n{created_task_mock}")
+
+    def test_create_task_failure(self):
+        task_mock = MagicMock()
+        with patch('pygeai.cli.commands.lab.spec.AILabManager', side_effect=Exception("Error")), \
+             patch('pygeai.cli.commands.lab.spec.Console.write_stderr') as mock_stderr, \
+             patch('pygeai.cli.commands.lab.spec.logger.error') as mock_logger:
+            create_task(task_mock, False)
+            mock_stderr.assert_called_once_with(f"Error creating task: \n{task_mock}")
+            mock_logger.assert_called_once()
+
+    def test_load_agentic_process_missing_file(self):
+        option_list = []
+        with self.assertRaises(MissingRequirementException) as cm:
+            load_agentic_process(option_list)
+        self.assertEqual(str(cm.exception), "Cannot load agentic process definition without specifying path to JSON file.")
+
+    def test_load_agentic_process_single_dict(self):
+        option_list = [
+            (Option("file", ["--file"], "", True), "file.json"),
+            (Option("automatic_publish", ["--automatic-publish"], "", True), False)
+        ]
+        process_data = {"key": "value"}
+        process_mock = MagicMock()
+
+        with patch('pygeai.cli.commands.lab.spec.JSONLoader.load_data', return_value=process_data), \
+             patch('pygeai.cli.commands.lab.spec.AgenticProcessParser.get_agentic_process', return_value=process_mock), \
+             patch('pygeai.cli.commands.lab.spec.create_agentic_process') as mock_create:
+            load_agentic_process(option_list)
+            mock_create.assert_called_once_with(process_mock, False)
+
+    def test_load_agentic_process_list(self):
+        option_list = [
+            (Option("file", ["--file"], "", True), "file.json"),
+            (Option("automatic_publish", ["--automatic-publish"], "", True), False)
+        ]
+        process_data = [{"key1": "value1"}, {"key2": "value2"}]
+        process_mock1, process_mock2 = MagicMock(), MagicMock()
+
+        with patch('pygeai.cli.commands.lab.spec.JSONLoader.load_data', return_value=process_data), \
+             patch('pygeai.cli.commands.lab.spec.AgenticProcessParser.get_agentic_process', side_effect=[process_mock1, process_mock2]), \
+             patch('pygeai.cli.commands.lab.spec.create_agentic_process') as mock_create:
+            load_agentic_process(option_list)
+            self.assertEqual(mock_create.call_count, 2)
+            mock_create.assert_any_call(process_mock1, False)
+            mock_create.assert_any_call(process_mock2, False)
+
+    def test_create_agentic_process_success(self):
+        process_mock = MagicMock()
+        created_process_mock = MagicMock()
+        with patch('pygeai.cli.commands.lab.spec.AILabManager') as mock_manager, \
+             patch('pygeai.cli.commands.lab.spec.Console.write_stdout') as mock_stdout:
+            mock_manager.return_value = MagicMock()
+            mock_manager.return_value.create_process.return_value = created_process_mock
+            create_agentic_process(process_mock, False)
+            mock_stdout.assert_called_once_with(f"Created agentic process detail: \n{created_process_mock}")
+
+    def test_create_agentic_process_failure(self):
+        process_mock = MagicMock()
+        with patch('pygeai.cli.commands.lab.spec.AILabManager', side_effect=Exception("Error")), \
+             patch('pygeai.cli.commands.lab.spec.Console.write_stderr') as mock_stderr, \
+             patch('pygeai.cli.commands.lab.spec.logger.error') as mock_logger:
+            create_agentic_process(process_mock, False)
+            mock_stderr.assert_called_once_with(f"Error creating agentic process: \n{process_mock}")
+            mock_logger.assert_called_once()

pygeai/tests/cli/commands/test_assistant.py

@@ -0,0 +1,202 @@
+import unittest
+from unittest.mock import patch, Mock
+
+from pygeai.cli.commands.assistant import (
+    show_help,
+    get_assistant_detail,
+    create_assistant,
+    update_assistant,
+    delete_assistant,
+    send_chat_request,
+    get_request_status,
+    cancel_request
+)
+from pygeai.core.common.exceptions import MissingRequirementException, WrongArgumentError
+
+
+class TestAssistant(unittest.TestCase):
+    """
+    python -m unittest pygeai.tests.cli.commands.test_assistant.TestAssistant
+    """
+    def test_show_help(self):
+        with patch('pygeai.core.utils.console.Console.write_stdout') as mock_stdout:
+            show_help()
+            mock_stdout.assert_called_once()
+
+    def test_get_assistant_detail_success(self):
+        option_list = [
+            (Mock(spec=['name'], name="detail"), "full"),
+            (Mock(spec=['name'], name="assistant_id"), "123")
+        ]
+        option_list[0][0].name = "detail"
+        option_list[1][0].name = "assistant_id"
+        with patch('pygeai.assistant.clients.AssistantClient.get_assistant_data', return_value="Assistant data"):
+            with patch('pygeai.core.utils.console.Console.write_stdout') as mock_stdout:
+                get_assistant_detail(option_list)
+                mock_stdout.assert_called_once_with("Assistant detail: \nAssistant data")
+
+    def test_get_assistant_detail_missing_id(self):
+        option_list = [(Mock(spec=['name'], name="detail"), "full")]
+        option_list[0][0].name = "detail"
+        with self.assertRaises(MissingRequirementException) as context:
+            get_assistant_detail(option_list)
+        self.assertEqual(str(context.exception), "Cannot retrieve assistant detail without assistant_id")
+
+    def test_create_assistant_success(self):
+        option_list = [
+            (Mock(spec=['name'], name="type"), "text"),
+            (Mock(spec=['name'], name="name"), "Test Assistant"),
+            (Mock(spec=['name'], name="prompt"), "Test prompt"),
+            (Mock(spec=['name'], name="description"), "Description"),
+            (Mock(spec=['name'], name="provider_name"), "provider"),
+            (Mock(spec=['name'], name="model_name"), "model"),
+            (Mock(spec=['name'], name="temperature"), "0.5"),
+            (Mock(spec=['name'], name="max_tokens"), "100"),
+            (Mock(spec=['name'], name="welcome_data_title"), "Welcome"),
+            (Mock(spec=['name'], name="welcome_data_description"), "Welcome description")
+        ]
+        for opt, _ in option_list:
+            opt.name = opt._mock_name
+        with patch('pygeai.assistant.clients.AssistantClient.create_assistant', return_value="Created assistant"):
+            with patch('pygeai.core.utils.console.Console.write_stdout') as mock_stdout:
+                with patch('pygeai.cli.commands.common.get_llm_settings', return_value={"provider": "provider"}):
+                    with patch('pygeai.cli.commands.common.get_welcome_data', return_value={"title": "Welcome"}):
+                        create_assistant(option_list)
+                        mock_stdout.assert_called_once_with("New assistant detail: \nCreated assistant")
+
+    def test_create_assistant_missing_required(self):
+        option_list = [(Mock(spec=['name'], name="type"), "text")]
+        option_list[0][0].name = "type"
+        with self.assertRaises(MissingRequirementException) as context:
+            create_assistant(option_list)
+        self.assertEqual(str(context.exception), "Cannot create new assistant without 'type', 'name' and 'prompt'")
+
+    def test_create_assistant_invalid_temperature(self):
+        option_list = [
+            (Mock(spec=['name'], name="type"), "text"),
+            (Mock(spec=['name'], name="name"), "Test Assistant"),
+            (Mock(spec=['name'], name="prompt"), "Test prompt"),
+            (Mock(spec=['name'], name="temperature"), "invalid")
+        ]
+        for opt, _ in option_list:
+            opt.name = opt._mock_name
+        with self.assertRaises(WrongArgumentError) as context:
+            create_assistant(option_list)
+        self.assertEqual(str(context.exception), "When defined, temperature must be a decimal numer. Example: 0.5")
+
+    def test_update_assistant_success(self):
+        option_list = [
+            (Mock(spec=['name'], name="assistant_id"), "123"),
+            (Mock(spec=['name'], name="name"), "Updated Assistant"),
+            (Mock(spec=['name'], name="prompt"), "Updated prompt"),
+            (Mock(spec=['name'], name="action"), "saveNewRevision")
+        ]
+        for opt, _ in option_list:
+            opt.name = opt._mock_name
+        with patch('pygeai.assistant.clients.AssistantClient.update_assistant', return_value="Updated assistant"):
+            with patch('pygeai.core.utils.console.Console.write_stdout') as mock_stdout:
+                update_assistant(option_list)
+                mock_stdout.assert_called_once_with("Updated assistant detail: \nUpdated assistant")
+
+    def test_update_assistant_missing_id(self):
+        option_list = [(Mock(spec=['name'], name="name"), "Updated Assistant")]
+        option_list[0][0].name = "name"
+        with self.assertRaises(MissingRequirementException) as context:
+            update_assistant(option_list)
+        self.assertEqual(str(context.exception), "Cannot update existing assistant without 'assistant_id'")
+
+    def test_update_assistant_missing_revision_id_for_save(self):
+        option_list = [
+            (Mock(spec=['name'], name="assistant_id"), "123"),
+            (Mock(spec=['name'], name="action"), "save")
+        ]
+        for opt, _ in option_list:
+            opt.name = opt._mock_name
+        with self.assertRaises(MissingRequirementException) as context:
+            update_assistant(option_list)
+        self.assertEqual(str(context.exception), "A revision_id is necessary when updating an existing version.")
+
+    def test_update_assistant_missing_prompt_for_new_revision(self):
+        option_list = [
+            (Mock(spec=['name'], name="assistant_id"), "123"),
+            (Mock(spec=['name'], name="action"), "saveNewRevision")
+        ]
+        for opt, _ in option_list:
+            opt.name = opt._mock_name
+        with self.assertRaises(MissingRequirementException) as context:
+            update_assistant(option_list)
+        self.assertEqual(str(context.exception), "Prompt must be defined if revisionId is specified or in case of actions saveNewRevision and savePublishNewRevision.")
+
+    def test_delete_assistant_success(self):
+        option_list = [(Mock(spec=['name'], name="assistant_id"), "123")]
+        option_list[0][0].name = "assistant_id"
+        with patch('pygeai.assistant.clients.AssistantClient.delete_assistant', return_value="Deleted assistant"):
+            with patch('pygeai.core.utils.console.Console.write_stdout') as mock_stdout:
+                delete_assistant(option_list)
+                mock_stdout.assert_called_once_with("Deleted assistant: \nDeleted assistant")
+
+    def test_delete_assistant_missing_id(self):
+        option_list = []
+        with self.assertRaises(MissingRequirementException) as context:
+            delete_assistant(option_list)
+        self.assertEqual(str(context.exception), "Cannot delete assistant without 'assistant_id'")
+
+    def test_send_chat_request_success(self):
+        option_list = [
+            (Mock(spec=['name'], name="assistant_name"), "Test Assistant"),
+            (Mock(spec=['name'], name="messages"), '{"role": "user", "content": "Hello"}')
+        ]
+        for opt, _ in option_list:
+            opt.name = opt._mock_name
+        with patch('pygeai.assistant.clients.AssistantClient.send_chat_request', return_value="Chat response"):
+            with patch('pygeai.core.utils.console.Console.write_stdout') as mock_stdout:
+                with patch('pygeai.cli.commands.common.get_messages', return_value=[{"role": "user", "content": "Hello"}]):
+                    send_chat_request(option_list)
+                    mock_stdout.assert_called_once_with("Chat request response: \nChat response")
+
+    def test_send_chat_request_missing_name(self):
+        option_list = [(Mock(spec=['name'], name="messages"), '{"role": "user", "content": "Hello"}')]
+        option_list[0][0].name = "messages"
+        with self.assertRaises(MissingRequirementException) as context:
+            send_chat_request(option_list)
+        self.assertEqual(str(context.exception), "Cannot send chat request without specifying assistant name")
+
+    def test_send_chat_request_invalid_messages(self):
+        option_list = [
+            (Mock(spec=['name'], name="assistant_name"), "Test Assistant"),
+            (Mock(spec=['name'], name="messages"), "invalid_json")
+        ]
+        for opt, _ in option_list:
+            opt.name = opt._mock_name
+        with self.assertRaises(WrongArgumentError) as context:
+            send_chat_request(option_list)
+        self.assertIn("Each message must be in json format", str(context.exception))
+
+    def test_get_request_status_success(self):
+        option_list = [(Mock(spec=['name'], name="request_id"), "456")]
+        option_list[0][0].name = "request_id"
+        with patch('pygeai.assistant.clients.AssistantClient.get_request_status', return_value="Request status data"):
+            with patch('pygeai.core.utils.console.Console.write_stdout') as mock_stdout:
+                get_request_status(option_list)
+                mock_stdout.assert_called_once_with("Request status: \nRequest status data")
+
+    def test_get_request_status_missing_id(self):
+        option_list = []
+        with self.assertRaises(MissingRequirementException) as context:
+            get_request_status(option_list)
+        self.assertEqual(str(context.exception), "Cannot retrieve status of request without request_id.")
+
+    def test_cancel_request_success(self):
+        option_list = [(Mock(spec=['name'], name="request_id"), "456")]
+        option_list[0][0].name = "request_id"
+        with patch('pygeai.assistant.clients.AssistantClient.cancel_request', return_value="Request cancelled"):
+            with patch('pygeai.core.utils.console.Console.write_stdout') as mock_stdout:
+                cancel_request(option_list)
+                mock_stdout.assert_called_once_with("Cancel request detail: \nRequest cancelled")
+
+    def test_cancel_request_missing_id(self):
+        option_list = []
+        with self.assertRaises(MissingRequirementException) as context:
+            cancel_request(option_list)
+        self.assertEqual(str(context.exception), "Cannot cancel request without request_id.")
+