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

pygeai/cli/commands/lab/ai_lab.py

@@ -1,6 +1,6 @@
 import json
-import sys
 
+from pygeai import logger
 from pygeai.cli.commands import Command, Option, ArgumentsEnum
 from pygeai.cli.commands.builders import build_help_text
 from pygeai.cli.commands.common import get_boolean_value
@@ -8,10 +8,13 @@ from pygeai.cli.commands.lab.common import get_agent_data_prompt_inputs, get_age
     get_agent_data_prompt_examples, get_tool_parameters
 from pygeai.cli.texts.help import AI_LAB_HELP_TEXT
 from pygeai.core.common.exceptions import MissingRequirementException, WrongArgumentError
+from pygeai.core.utils.console import Console
+from pygeai.cli.commands.lab.options import PROJECT_ID_OPTION
 from pygeai.lab.agents.clients import AgentClient
 from pygeai.lab.processes.clients import AgenticProcessClient
 from pygeai.lab.strategies.clients import ReasoningStrategyClient
-from pygeai.lab.tools.clients import ToolClient, VALID_SCOPES
+from pygeai.lab.tools.clients import ToolClient
+from pygeai.lab.constants import VALID_SCOPES
 
 
 def show_help():
@@ -19,7 +22,7 @@ def show_help():
     Displays help text in stdout
     """
     help_text = build_help_text(ai_lab_commands, AI_LAB_HELP_TEXT)
-    sys.stdout.write(help_text)
+    Console.write_stdout(help_text)
 
 
 def list_agents(option_list: list):
@@ -47,12 +50,8 @@ def list_agents(option_list: list):
         if option_flag.name == "allow_external":
             allow_external = get_boolean_value(option_arg)
 
-    if not project_id:
-        raise MissingRequirementException("Project ID must be specified.")
-
-    client = AgentClient()
+    client = AgentClient(project_id=project_id)
     result = client.list_agents(
-        project_id=project_id,
         status=status,
         start=start,
         count=count,
@@ -60,16 +59,11 @@ def list_agents(option_list: list):
         allow_drafts=allow_drafts,
         allow_external=allow_external,
     )
-    sys.stdout.write(f"Agent list: \n{result}\n")
+    Console.write_stdout(f"Agent list: \n{result}")
 
 
 list_agents_options = [
-    Option(
-        "project_id",
-        ["--project-id", "--pid"],
-        "ID of the project",
-        True
-    ),
+    PROJECT_ID_OPTION,
     Option(
         "status",
         ["--status"],
@@ -126,6 +120,7 @@ def create_agent(option_list: list):
     agent_data_llm_temperature = None
     agent_data_llm_top_k = None
     agent_data_llm_top_p = None
+    agent_data_strategy_name = None
     agent_data_model_name = None
     agent_data_resource_pools = None
     automatic_publish = False
@@ -200,6 +195,8 @@ def create_agent(option_list: list):
             agent_data_llm_top_k = option_arg
         if option_flag.name == "agent_data_llm_top_p":
             agent_data_llm_top_p = option_arg
+        if option_flag.name == "agent_data_strategy_name":
+            agent_data_strategy_name = option_arg
         if option_flag.name == "agent_data_model_name":
             agent_data_model_name = option_arg
         if option_flag.name == "agent_data_resource_pools":
@@ -216,10 +213,11 @@ def create_agent(option_list: list):
         if option_flag.name == "automatic_publish":
             automatic_publish = get_boolean_value(option_arg)
 
-    if not project_id:
-        raise MissingRequirementException("Project ID must be specified.")
-    if not (name and access_scope and public_name):
-        raise MissingRequirementException("Cannot create assistant without specifying name, access scope and public name")
+    if not name:
+        raise MissingRequirementException("Cannot create assistant without specifying name.")
+
+    if access_scope == 'public' and not public_name:
+        raise MissingRequirementException("If access scope is public, public name must be defined.")
 
     prompt_inputs = get_agent_data_prompt_inputs(agent_data_prompt_inputs)
     prompt_outputs = get_agent_data_prompt_outputs(agent_data_prompt_outputs)
@@ -244,9 +242,8 @@ def create_agent(option_list: list):
         {"name": agent_data_model_name}
     ]
 
-    client = AgentClient()
+    client = AgentClient(project_id=project_id)
     result = client.create_agent(
-        project_id=project_id,
         name=name,
         access_scope=access_scope,
         public_name=public_name,
@@ -255,20 +252,16 @@ def create_agent(option_list: list):
         description=description,
         agent_data_prompt=agent_data_prompt,
         agent_data_llm_config=agent_data_llm_config,
+        agent_data_strategy_name=agent_data_strategy_name,
         agent_data_models=agent_data_models,
         agent_data_resource_pools=agent_data_resource_pools,
         automatic_publish=automatic_publish
     )
-    sys.stdout.write(f"New agent detail: \n{result}\n")
+    Console.write_stdout(f"New agent detail: \n{result}")
 
 
 create_agent_options = [
-    Option(
-        "project_id",
-        ["--project-id", "--pid"],
-        "Unique identifier of the project where the agent will be created",
-        True
-    ),
+    PROJECT_ID_OPTION,
     Option(
         "name",
         ["--name", "-n"],
@@ -360,6 +353,12 @@ create_agent_options = [
         "TopP sampling parameter for LLM (currently unused)",
         True
     ),
+    Option(
+        "agent_data_strategy_name",
+        ["--agent-data-strategy-name", "--strategy-name"],
+        "Name of the reasoning strategy to use",
+        True
+    ),
     Option(
         "agent_data_model_name",
         ["--agent-data-model-name", "--adm-name"],
@@ -401,27 +400,21 @@ def get_agent(option_list: list):
         if option_flag.name == "allow_drafts":
             allow_drafts = get_boolean_value(option_arg)
 
-    if not (project_id and agent_id):
-        raise MissingRequirementException("Project ID and Agent id must be specified.")
+    if not agent_id:
+        raise MissingRequirementException("Agent ID must be specified.")
 
-    client = AgentClient()
+    client = AgentClient(project_id=project_id)
     result = client.get_agent(
-        project_id=project_id,
         agent_id=agent_id,
         revision=revision,
         version=version,
         allow_drafts=allow_drafts,
     )
-    sys.stdout.write(f"Agent detail: \n{result}\n")
+    Console.write_stdout(f"Agent detail: \n{result}")
 
 
 get_agent_options = [
-    Option(
-        "project_id",
-        ["--project-id", "--pid"],
-        "ID of the project",
-        True
-    ),
+    PROJECT_ID_OPTION,
     Option(
         "agent_id",
         ["--agent-id", "--aid"],
@@ -449,34 +442,119 @@ get_agent_options = [
 ]
 
 
-def create_sharing_link(option_list: list):
+def export_agent(option_list: list):
     project_id = None
     agent_id = None
+    file = None
 
     for option_flag, option_arg in option_list:
         if option_flag.name == "project_id":
             project_id = option_arg
         if option_flag.name == "agent_id":
             agent_id = option_arg
+        if option_flag.name == "file":
+            file = option_arg
 
-    if not (project_id and agent_id):
-        raise MissingRequirementException("Project ID and Agent id must be specified.")
+    if not agent_id:
+        raise MissingRequirementException("Agent ID must be specified.")
 
-    client = AgentClient()
-    result = client.create_sharing_link(
-        project_id=project_id,
+    client = AgentClient(project_id=project_id)
+    result = client.export_agent(
         agent_id=agent_id,
     )
-    sys.stdout.write(f"Sharing token: \n{result}\n")
+    if file:
+        try:
+            data = json.loads(result) if isinstance(result, str) else result
+            with open(file, "w") as f:
+                json.dump(data, f, indent=4)
+            Console.write_stdout(f"Result from API saved to {file}.")
+        except json.JSONDecodeError as e:
+            logger.error(f"Result from API endpoint is not in JSON format: {e}")
+            Console.write_stderr(f"Result from API endpoint is not in JSON format.")
+    else:
+        Console.write_stdout(f"Agent spec: \n{result}")
+
+
+export_agent_options = [
+    PROJECT_ID_OPTION,
+    Option(
+        "agent_id",
+        ["--agent-id", "--aid"],
+        "ID of the agent to retrieve",
+        True
+    ),
+    Option(
+        "file",
+        ["--file", "-f"],
+        "File path to save export specification for agent",
+        True
+    ),
+]
 
 
-create_sharing_link_options = [
+def import_agent(option_list: list):
+    project_id = None
+    file = None
+
+    for option_flag, option_arg in option_list:
+        if option_flag.name == "project_id":
+            project_id = option_arg
+        if option_flag.name == "file":
+            file = option_arg
+
+
+    if not file:
+        raise MissingRequirementException("File path to spec must be specified.")
+
+    try:
+        with open(file, "r") as f:
+            agent_data = json.load(f)
+    except json.JSONDecodeError as e:
+        logger.error(f"File is not in JSON format: {e}")
+        Console.write_stderr(f"File is not in JSON format.")
+
+    client = AgentClient(project_id=project_id)
+    result = client.import_agent(
+        data=agent_data
+    )
+
+    Console.write_stdout(f"Agent import details: {result}")
+
+
+
+import_agent_options = [
+    PROJECT_ID_OPTION,
     Option(
-        "project_id",
-        ["--project-id", "--pid"],
-        "ID of the project",
+        "file",
+        ["--file", "-f"],
+        "File path to save export specification for agent",
         True
     ),
+]
+
+
+def create_sharing_link(option_list: list):
+    project_id = None
+    agent_id = None
+
+    for option_flag, option_arg in option_list:
+        if option_flag.name == "project_id":
+            project_id = option_arg
+        if option_flag.name == "agent_id":
+            agent_id = option_arg
+
+    if not agent_id:
+        raise MissingRequirementException("Agent ID must be specified.")
+
+    client = AgentClient(project_id=project_id)
+    result = client.create_sharing_link(
+        agent_id=agent_id,
+    )
+    Console.write_stdout(f"Sharing token: \n{result}")
+
+
+create_sharing_link_options = [
+    PROJECT_ID_OPTION,
     Option(
         "agent_id",
         ["--agent-id", "--aid"],
@@ -499,25 +577,19 @@ def publish_agent_revision(option_list: list):
         if option_flag.name == "revision":
             revision = option_arg
 
-    if not (project_id and agent_id and revision):
-        raise MissingRequirementException("Project ID, Agent ID and revision must be specified.")
+    if not (agent_id and revision):
+        raise MissingRequirementException("Agent ID and revision must be specified.")
 
-    client = AgentClient()
+    client = AgentClient(project_id=project_id)
     result = client.publish_agent_revision(
-        project_id=project_id,
         agent_id=agent_id,
         revision=revision
     )
-    sys.stdout.write(f"Published revision detail: \n{result}\n")
+    Console.write_stdout(f"Published revision detail: \n{result}")
 
 
 publish_agent_revision_options = [
-    Option(
-        "project_id",
-        ["--project-id", "--pid"],
-        "ID of the project",
-        True
-    ),
+    PROJECT_ID_OPTION,
     Option(
         "agent_id",
         ["--agent-id", "--aid"],
@@ -543,24 +615,18 @@ def delete_agent(option_list: list):
         if option_flag.name == "agent_id":
             agent_id = option_arg
 
-    if not (project_id and agent_id):
-        raise MissingRequirementException("Project ID and Agent ID must be specified.")
+    if not agent_id:
+        raise MissingRequirementException("Agent ID must be specified.")
 
-    client = AgentClient()
+    client = AgentClient(project_id=project_id)
     result = client.delete_agent(
-        project_id=project_id,
         agent_id=agent_id,
     )
-    sys.stdout.write(f"Deleted agent detail: \n{result}\n")
+    Console.write_stdout(f"Deleted agent detail: \n{result}")
 
 
 delete_agent_options = [
-    Option(
-        "project_id",
-        ["--project-id", "--pid"],
-        "ID of the project",
-        True
-    ),
+    PROJECT_ID_OPTION,
     Option(
         "agent_id",
         ["--agent-id", "--aid"],
@@ -588,6 +654,7 @@ def update_agent(option_list: list):
     agent_data_llm_temperature = None
     agent_data_llm_top_k = None
     agent_data_llm_top_p = None
+    agent_data_strategy_name = None
     agent_data_model_name = None
     agent_data_resource_pools = None
     automatic_publish = False
@@ -664,7 +731,9 @@ def update_agent(option_list: list):
         if option_flag.name == "agent_data_llm_top_k":
             agent_data_llm_top_k = option_arg
         if option_flag.name == "agent_data_llm_top_p":
-            agent_data_llm_top_p = option_arg
+            agent_data_llm_top_k = option_arg
+        if option_flag.name == "agent_data_strategy_name":
+            agent_data_strategy_name = option_arg
         if option_flag.name == "agent_data_model_name":
             agent_data_model_name = option_arg
         if option_flag.name == "agent_data_resource_pools":
@@ -683,9 +752,6 @@ def update_agent(option_list: list):
         if option_flag.name == "upsert":
             upsert = get_boolean_value(option_arg)
 
-    if not project_id:
-        raise MissingRequirementException("Project ID must be specified.")
-
     if not (name and access_scope and public_name):
         raise MissingRequirementException("Cannot update assistant without specifying name, access scope and public name")
 
@@ -712,9 +778,8 @@ def update_agent(option_list: list):
         {"name": agent_data_model_name}
     ]
 
-    client = AgentClient()
+    client = AgentClient(project_id=project_id)
     result = client.update_agent(
-        project_id=project_id,
         agent_id=agent_id,
         name=name,
         access_scope=access_scope,
@@ -724,21 +789,17 @@ def update_agent(option_list: list):
         description=description,
         agent_data_prompt=agent_data_prompt,
         agent_data_llm_config=agent_data_llm_config,
+        agent_data_strategy_name=agent_data_strategy_name,
         agent_data_models=agent_data_models,
         agent_data_resource_pools=agent_data_resource_pools,
         automatic_publish=automatic_publish,
         upsert=upsert
     )
-    sys.stdout.write(f"Updated agent detail: \n{result}\n")
+    Console.write_stdout(f"Updated agent detail: \n{result}")
 
 
 update_agent_options = [
-    Option(
-        "project_id",
-        ["--project-id", "--pid"],
-        "Unique identifier of the project where the agent will be created",
-        True
-    ),
+    PROJECT_ID_OPTION,
     Option(
         "agent_id",
         ["--agent-id", "--aid"],
@@ -836,6 +897,12 @@ update_agent_options = [
         "TopP sampling parameter for LLM (currently unused)",
         True
     ),
+    Option(
+        "agent_data_strategy_name",
+        ["--agent-data-strategy-name", "--strategy-name"],
+        "Name of the reasoning strategy to use",
+        True
+    ),
     Option(
         "agent_data_model_name",
         ["--agent-data-model-name", "--adm-name"],
@@ -923,8 +990,6 @@ def create_tool(option_list: list):
         if option_flag.name == "automatic_publish":
             automatic_publish = get_boolean_value(option_arg)
 
-    if not project_id:
-        raise MissingRequirementException("Project ID must be specified.")
     if not name:
         raise MissingRequirementException("Tool name must be specified.")
     if access_scope == "public" and not public_name:
@@ -936,9 +1001,8 @@ def create_tool(option_list: list):
 
     tool_parameters = get_tool_parameters(parameters)
 
-    client = ToolClient()
+    client = ToolClient(project_id=project_id)
     result = client.create_tool(
-        project_id=project_id,
         name=name,
         description=description,
         scope=scope,
@@ -951,16 +1015,11 @@ def create_tool(option_list: list):
         parameters=tool_parameters,
         automatic_publish=automatic_publish
     )
-    sys.stdout.write(f"New tool detail: \n{result}\n")
+    Console.write_stdout(f"New tool detail: \n{result}")
 
 
 create_tool_options = [
-    Option(
-        "project_id",
-        ["--project-id", "--pid"],
-        "Unique identifier of the project where the tool will be created",
-        True
-    ),
+    PROJECT_ID_OPTION,
     Option(
         "name",
         ["--name", "-n"],
@@ -1055,15 +1114,11 @@ def list_tools(option_list: list):
         if option_flag.name == "allow_external":
             allow_external = get_boolean_value(option_arg)
 
-    if not project_id:
-        raise MissingRequirementException("Project ID must be specified.")
-
     if scope and scope not in VALID_SCOPES:
         raise ValueError(f"Scope must be one of {', '.join(VALID_SCOPES)}.")
 
-    client = ToolClient()
+    client = ToolClient(project_id=project_id)
     result = client.list_tools(
-        project_id=project_id,
         id=id,
         count=count,
         access_scope=access_scope,
@@ -1071,16 +1126,11 @@ def list_tools(option_list: list):
         scope=scope,
         allow_external=allow_external,
     )
-    sys.stdout.write(f"Tool list: \n{result}\n")
+    Console.write_stdout(f"Tool list: \n{result}")
 
 
 list_tools_options = [
-    Option(
-        "project_id",
-        ["--project-id", "--pid"],
-        "ID of the project",
-        True
-    ),
+    PROJECT_ID_OPTION,
     Option(
         "id",
         ["--id"],
@@ -1139,27 +1189,21 @@ def get_tool(option_list: list):
         if option_flag.name == "allow_drafts":
             allow_drafts = get_boolean_value(option_arg)
 
-    if not (project_id and tool_id):
-        raise MissingRequirementException("Project ID and Tool id must be specified.")
+    if not tool_id:
+        raise MissingRequirementException("Tool ID must be specified.")
 
-    client = ToolClient()
+    client = ToolClient(project_id=project_id)
     result = client.get_tool(
-        project_id=project_id,
         tool_id=tool_id,
         revision=revision,
         version=version,
         allow_drafts=allow_drafts,
     )
-    sys.stdout.write(f"Tool detail: \n{result}\n")
+    Console.write_stdout(f"Tool detail: \n{result}")
 
 
 get_tool_options = [
-    Option(
-        "project_id",
-        ["--project-id", "--pid"],
-        "ID of the project",
-        True
-    ),
+    PROJECT_ID_OPTION,
     Option(
         "tool_id",
         ["--tool-id", "--tid"],
@@ -1187,6 +1231,57 @@ get_tool_options = [
 ]
 
 
+def export_tool(option_list: list):
+    project_id = None
+    tool_id = None
+    file = None
+
+    for option_flag, option_arg in option_list:
+        if option_flag.name == "project_id":
+            project_id = option_arg
+        if option_flag.name == "tool_id":
+            tool_id = option_arg
+        if option_flag.name == "file":
+            file = option_arg
+
+    if not tool_id:
+        raise MissingRequirementException("Tool ID must be specified.")
+
+    client = ToolClient(project_id=project_id)
+    result = client.export_tool(
+        tool_id=tool_id,
+    )
+    Console.write_stdout(f"Tool spec: \n{result}")
+    if file:
+        try:
+            data = json.loads(result) if isinstance(result, str) else result
+            with open(file, "w") as f:
+                json.dump(data, f, indent=4)
+            Console.write_stdout(f"Result from API saved to {file}.")
+        except json.JSONDecodeError as e:
+            logger.error(f"Result from API endpoint is not in JSON format: {e}")
+            Console.write_stderr(f"Result from API endpoint is not in JSON format.")
+
+
+
+export_tool_options = [
+    PROJECT_ID_OPTION,
+    Option(
+        "tool_id",
+        ["--tool-id", "--tid"],
+        "ID of the tool to retrieve",
+        True
+    ),
+    Option(
+        "file",
+        ["--file", "-f"],
+        "File path to save export specification for tool",
+        True
+    ),
+]
+
+
+
 def delete_tool(option_list: list):
     project_id = None
     tool_id = None
@@ -1195,30 +1290,24 @@ def delete_tool(option_list: list):
     for option_flag, option_arg in option_list:
         if option_flag.name == "project_id":
             project_id = option_arg
-        elif option_flag.name == "tool_id":
+        if option_flag.name == "tool_id":
             tool_id = option_arg
         elif option_flag.name == "tool_name":
             tool_name = option_arg
 
-    if not project_id or not (tool_id or tool_name):
-        raise MissingRequirementException("Project ID and either Tool ID or Tool Name must be specified.")
+    if not (tool_id or tool_name):
+        raise MissingRequirementException("Either Tool ID or Tool Name must be specified.")
 
-    client = ToolClient()
+    client = ToolClient(project_id=project_id)
     result = client.delete_tool(
-        project_id=project_id,
         tool_id=tool_id,
         tool_name=tool_name
     )
-    sys.stdout.write(f"Deleted tool detail: \n{result}\n")
+    Console.write_stdout(f"Deleted tool detail: \n{result}")
 
 
 delete_tool_options = [
-    Option(
-        "project_id",
-        ["--project-id", "--pid"],
-        "ID of the project",
-        True
-    ),
+    PROJECT_ID_OPTION,
     Option(
         "tool_id",
         ["--tool-id", "--tid"],
@@ -1298,8 +1387,6 @@ def update_tool(option_list: list):
         if option_flag.name == "upsert":
             upsert = get_boolean_value(option_arg)
 
-    if not project_id:
-        raise MissingRequirementException("Project ID must be specified.")
     if not tool_id:
         raise MissingRequirementException("Tool ID must be specified.")
     if access_scope == "public" and not public_name:
@@ -1311,9 +1398,8 @@ def update_tool(option_list: list):
 
     tool_parameters = get_tool_parameters(parameters)
 
-    client = ToolClient()
+    client = ToolClient(project_id=project_id)
     result = client.update_tool(
-        project_id=project_id,
         tool_id=tool_id,
         name=name,
         description=description,
@@ -1328,16 +1414,11 @@ def update_tool(option_list: list):
         automatic_publish=automatic_publish,
         upsert=upsert
     )
-    sys.stdout.write(f"Updated tool detail: \n{result}\n")
+    Console.write_stdout(f"Updated tool detail: \n{result}")
 
 
 update_tool_options = [
-    Option(
-        "project_id",
-        ["--project-id", "--pid"],
-        "Unique identifier of the project containing the tool",
-        True
-    ),
+    PROJECT_ID_OPTION,
     Option(
         "tool_id",
         ["--tool-id", "--tid"],
@@ -1432,25 +1513,19 @@ def publish_tool_revision(option_list: list):
         if option_flag.name == "revision":
             revision = option_arg
 
-    if not (project_id and tool_id and revision):
-        raise MissingRequirementException("Project ID, Tool ID and revision must be specified.")
+    if not (tool_id and revision):
+        raise MissingRequirementException("Tool ID and revision must be specified.")
 
-    client = ToolClient()
+    client = ToolClient(project_id=project_id)
     result = client.publish_tool_revision(
-        project_id=project_id,
         tool_id=tool_id,
         revision=revision
     )
-    sys.stdout.write(f"Published revision detail: \n{result}\n")
+    Console.write_stdout(f"Published revision detail: \n{result}")
 
 
 publish_tool_revision_options = [
-    Option(
-        "project_id",
-        ["--project-id", "--pid"],
-        "ID of the project",
-        True
-    ),
+    PROJECT_ID_OPTION,
     Option(
         "tool_id",
         ["--tool-id", "--tid"],
@@ -1488,28 +1563,22 @@ def get_parameter(option_list: list):
         if option_flag.name == "version":
             version = option_arg
 
-    if not (project_id and (tool_public_name or tool_id)):
-        raise MissingRequirementException("Project ID and Tool public name or ID must be specified.")
+    if not (tool_public_name or tool_id):
+        raise MissingRequirementException("Tool public name or ID must be specified.")
 
-    client = ToolClient()
+    client = ToolClient(project_id=project_id)
     result = client.get_parameter(
-        project_id=project_id,
         tool_id=tool_id,
         tool_public_name=tool_public_name,
         revision=revision,
         version=version,
         allow_drafts=allow_drafts,
     )
-    sys.stdout.write(f"Parameter detail: \n{result}\n")
+    Console.write_stdout(f"Parameter detail: \n{result}")
 
 
 get_parameter_options = [
-    Option(
-        "project_id",
-        ["--project-id", "--pid"],
-        "ID of the project",
-        True
-    ),
+    PROJECT_ID_OPTION,
     Option(
         "tool_id",
         ["--tool-id", "--tid"],
@@ -1571,8 +1640,6 @@ def set_parameter(option_list: list):
                     "\"isRequired\": true, \"type\": \"config\", \"fromSecret\": false, \"value\": \"config_value\"}'"
                 )
 
-    if not project_id:
-        raise MissingRequirementException("Project ID must be specified.")
     if not (tool_public_name or tool_id):
         raise MissingRequirementException("Tool public name or ID must be specified.")
     if not parameters:
@@ -1580,23 +1647,17 @@ def set_parameter(option_list: list):
 
     tool_parameters = get_tool_parameters(parameters)
 
-    client = ToolClient()
+    client = ToolClient(project_id=project_id)
     result = client.set_parameter(
-        project_id=project_id,
         tool_id=tool_id,
         tool_public_name=tool_public_name,
         parameters=tool_parameters
     )
-    sys.stdout.write(f"Set parameter detail: \n{result}\n")
+    Console.write_stdout(f"Set parameter detail: \n{result}")
 
 
 set_parameter_options = [
-    Option(
-        "project_id",
-        ["--project-id", "--pid"],
-        "ID of the project",
-        True
-    ),
+    PROJECT_ID_OPTION,
     Option(
         "tool_id",
         ["--tool-id", "--tid"],
@@ -1657,7 +1718,7 @@ def list_reasoning_strategies(option_list: list):
         allow_external=allow_external,
         access_scope=access_scope,
     )
-    sys.stdout.write(f"Reasoning strategies list: \n{result}\n")
+    Console.write_stdout(f"Reasoning strategies list: \n{result}")
 
 
 list_reasoning_strategies_options = [
@@ -1695,7 +1756,6 @@ list_reasoning_strategies_options = [
 
 
 def create_reasoning_strategy(option_list: list):
-    project_id = None
     name = None
     system_prompt = None
     access_scope = "public"
@@ -1704,8 +1764,6 @@ def create_reasoning_strategy(option_list: list):
     automatic_publish = False
 
     for option_flag, option_arg in option_list:
-        if option_flag.name == "project_id":
-            project_id = option_arg
         if option_flag.name == "name":
             name = option_arg
         if option_flag.name == "system_prompt":
@@ -1728,8 +1786,6 @@ def create_reasoning_strategy(option_list: list):
         if option_flag.name == "automatic_publish":
             automatic_publish = get_boolean_value(option_arg)
 
-    if not project_id:
-        raise MissingRequirementException("Project ID must be specified.")
     if not name:
         raise MissingRequirementException("Name must be specified.")
     if not system_prompt:
@@ -1749,7 +1805,6 @@ def create_reasoning_strategy(option_list: list):
 
     client = ReasoningStrategyClient()
     result = client.create_reasoning_strategy(
-        project_id=project_id,
         name=name,
         system_prompt=system_prompt,
         access_scope=access_scope,
@@ -1757,16 +1812,10 @@ def create_reasoning_strategy(option_list: list):
         localized_descriptions=localized_descriptions,
         automatic_publish=automatic_publish
     )
-    sys.stdout.write(f"Created reasoning strategy detail: \n{result}\n")
+    Console.write_stdout(f"Created reasoning strategy detail: \n{result}")
 
 
 create_reasoning_strategy_options = [
-    Option(
-        "project_id",
-        ["--project-id", "--pid"],
-        "ID of the project",
-        True
-    ),
     Option(
         "name",
         ["--name", "-n"],
@@ -1809,7 +1858,6 @@ create_reasoning_strategy_options = [
 
 
 def update_reasoning_strategy(option_list: list):
-    project_id = None
     reasoning_strategy_id = None
     name = None
     system_prompt = None
@@ -1820,8 +1868,6 @@ def update_reasoning_strategy(option_list: list):
     upsert = False
 
     for option_flag, option_arg in option_list:
-        if option_flag.name == "project_id":
-            project_id = option_arg
         if option_flag.name == "reasoning_strategy_id":
             reasoning_strategy_id = option_arg
         if option_flag.name == "name":
@@ -1847,10 +1893,8 @@ def update_reasoning_strategy(option_list: list):
             automatic_publish = get_boolean_value(option_arg)
         if option_flag.name == "upsert":
             # upsert = get_boolean_value(option_arg)
-            sys.stdout.write("Upsert is not yet supported for reasoning strategies. Coming soon.")
+            Console.write_stdout("Upsert is not yet supported for reasoning strategies. Coming soon.")
 
-    if not project_id:
-        raise MissingRequirementException("Project ID must be specified.")
     if not reasoning_strategy_id:
         raise MissingRequirementException("Reasoning strategy ID must be specified.")
 
@@ -1870,7 +1914,6 @@ def update_reasoning_strategy(option_list: list):
 
     client = ReasoningStrategyClient()
     result = client.update_reasoning_strategy(
-        project_id=project_id,
         reasoning_strategy_id=reasoning_strategy_id,
         name=name,
         system_prompt=system_prompt,
@@ -1880,16 +1923,10 @@ def update_reasoning_strategy(option_list: list):
         automatic_publish=automatic_publish,
         upsert=upsert
     )
-    sys.stdout.write(f"Updated reasoning strategy detail: \n{result}\n")
+    Console.write_stdout(f"Updated reasoning strategy detail: \n{result}")
 
 
 update_reasoning_strategy_options = [
-    Option(
-        "project_id",
-        ["--project-id", "--pid"],
-        "ID of the project",
-        True
-    ),
     Option(
         "reasoning_strategy_id",
         ["--reasoning-strategy-id", "--rsid"],
@@ -1944,39 +1981,27 @@ update_reasoning_strategy_options = [
 
 
 def get_reasoning_strategy(option_list: list):
-    project_id = None
     reasoning_strategy_id = None
     reasoning_strategy_name = None
 
     for option_flag, option_arg in option_list:
-        if option_flag.name == "project_id":
-            project_id = option_arg
         if option_flag.name == "reasoning_strategy_id":
             reasoning_strategy_id = option_arg
         if option_flag.name == "reasoning_strategy_name":
             reasoning_strategy_name = option_arg
 
-    if not project_id:
-        raise MissingRequirementException("Project ID must be specified.")
     if not (reasoning_strategy_id or reasoning_strategy_name):
         raise MissingRequirementException("Either reasoning strategy ID or name must be specified.")
 
     client = ReasoningStrategyClient()
     result = client.get_reasoning_strategy(
-        project_id=project_id,
         reasoning_strategy_id=reasoning_strategy_id,
         reasoning_strategy_name=reasoning_strategy_name
     )
-    sys.stdout.write(f"Reasoning strategy detail: \n{result}\n")
+    Console.write_stdout(f"Reasoning strategy detail: \n{result}")
 
 
 get_reasoning_strategy_options = [
-    Option(
-        "project_id",
-        ["--project-id", "--pid"],
-        "ID of the project",
-        True
-    ),
     Option(
         "reasoning_strategy_id",
         ["--reasoning-strategy-id", "--rsid"],
@@ -2099,16 +2124,13 @@ def create_process(option_list: list):
         if option_flag.name == "automatic_publish":
             automatic_publish = get_boolean_value(option_arg)
 
-    if not project_id:
-        raise MissingRequirementException("Project ID must be specified.")
     if not key:
         raise MissingRequirementException("Key must be specified.")
     if not name:
         raise MissingRequirementException("Name must be specified.")
 
-    client = AgenticProcessClient()
+    client = AgenticProcessClient(project_id=project_id)
     result = client.create_process(
-        project_id=project_id,
         key=key,
         name=name,
         description=description,
@@ -2121,16 +2143,11 @@ def create_process(option_list: list):
         sequence_flows=sequence_flows if sequence_flows else None,
         automatic_publish=automatic_publish
     )
-    sys.stdout.write(f"Created process detail: \n{result}\n")
+    Console.write_stdout(f"Created process detail: \n{result}")
 
 
 create_process_options = [
-    Option(
-        "project_id",
-        ["--project-id", "--pid"],
-        "ID of the project",
-        True
-    ),
+    PROJECT_ID_OPTION,
     Option(
         "key",
         ["--key", "-k"],
@@ -2324,14 +2341,11 @@ def update_process(option_list: list):
         if option_flag.name == "upsert":
             upsert = get_boolean_value(option_arg)
 
-    if not project_id:
-        raise MissingRequirementException("Project ID must be specified.")
     if not (process_id or name):
         raise MissingRequirementException("Either process ID or name must be specified.")
 
-    client = AgenticProcessClient()
+    client = AgenticProcessClient(project_id=project_id)
     result = client.update_process(
-        project_id=project_id,
         process_id=process_id,
         name=name,
         key=key,
@@ -2346,16 +2360,11 @@ def update_process(option_list: list):
         automatic_publish=automatic_publish,
         upsert=upsert
     )
-    sys.stdout.write(f"Updated process detail: \n{result}\n")
+    Console.write_stdout(f"Updated process detail: \n{result}")
 
 
 update_process_options = [
-    Option(
-        "project_id",
-        ["--project-id", "--pid"],
-        "ID of the project",
-        True
-    ),
+    PROJECT_ID_OPTION,
     Option(
         "process_id",
         ["--process-id", "--pid"],
@@ -2473,30 +2482,22 @@ def get_process(option_list: list):
         if option_flag.name == "allow_drafts":
             allow_drafts = get_boolean_value(option_arg)
 
-    if not project_id:
-        raise MissingRequirementException("Project ID must be specified.")
     if not (process_id or process_name):
         raise MissingRequirementException("Either process ID or process name must be specified.")
 
-    client = AgenticProcessClient()
+    client = AgenticProcessClient(project_id=project_id)
     result = client.get_process(
-        project_id=project_id,
         process_id=process_id,
         process_name=process_name,
         revision=revision,
         version=version,
         allow_drafts=allow_drafts
     )
-    sys.stdout.write(f"Process detail: \n{result}\n")
+    Console.write_stdout(f"Process detail: \n{result}")
 
 
 get_process_options = [
-    Option(
-        "project_id",
-        ["--project-id", "--pid"],
-        "ID of the project",
-        True
-    ),
+    PROJECT_ID_OPTION,
     Option(
         "process_id",
         ["--process-id", "--pid"],
@@ -2555,12 +2556,8 @@ def list_processes(option_list: list):
         if option_flag.name == "allow_draft":
             allow_draft = get_boolean_value(option_arg)
 
-    if not project_id:
-        raise MissingRequirementException("Project ID must be specified.")
-
-    client = AgenticProcessClient()
+    client = AgenticProcessClient(project_id=project_id)
     result = client.list_processes(
-        project_id=project_id,
         id=id,
         name=name,
         status=status,
@@ -2568,16 +2565,11 @@ def list_processes(option_list: list):
         count=count,
         allow_draft=allow_draft
     )
-    sys.stdout.write(f"Process list: \n{result}\n")
+    Console.write_stdout(f"Process list: \n{result}")
 
 
 list_processes_options = [
-    Option(
-        "project_id",
-        ["--project-id", "--pid"],
-        "ID of the project",
-        True
-    ),
+    PROJECT_ID_OPTION,
     Option(
         "id",
         ["--id"],
@@ -2636,29 +2628,21 @@ def list_processes_instances(option_list: list):
         if option_flag.name == "count":
             count = option_arg
 
-    if not project_id:
-        raise MissingRequirementException("Project ID must be specified.")
     if not process_id:
         raise MissingRequirementException("Process ID must be specified.")
 
-    client = AgenticProcessClient()
+    client = AgenticProcessClient(project_id=project_id)
     result = client.list_process_instances(
-        project_id=project_id,
         process_id=process_id,
         is_active=is_active,
         start=start,
         count=count
     )
-    sys.stdout.write(f"Process instances list: \n{result}\n")
+    Console.write_stdout(f"Process instances list: \n{result}")
 
 
 list_processes_instances_options = [
-    Option(
-        "project_id",
-        ["--project-id", "--pid"],
-        "ID of the project",
-        True
-    ),
+    PROJECT_ID_OPTION,
     Option(
         "process_id",
         ["--process-id", "--pid"],
@@ -2699,27 +2683,19 @@ def delete_process(option_list: list):
         if option_flag.name == "process_name":
             process_name = option_arg
 
-    if not project_id:
-        raise MissingRequirementException("Project ID must be specified.")
     if not (process_id or process_name):
         raise MissingRequirementException("Either process ID or process name must be specified.")
 
-    client = AgenticProcessClient()
+    client = AgenticProcessClient(project_id=project_id)
     result = client.delete_process(
-        project_id=project_id,
         process_id=process_id,
         process_name=process_name
     )
-    sys.stdout.write(f"Delete process result: \n{result}\n")
+    Console.write_stdout(f"Delete process result: \n{result}")
 
 
 delete_process_options = [
-    Option(
-        "project_id",
-        ["--project-id", "--pid"],
-        "ID of the project",
-        True
-    ),
+    PROJECT_ID_OPTION,
     Option(
         "process_id",
         ["--process-id", "--pid"],
@@ -2751,30 +2727,22 @@ def publish_process_revision(option_list: list):
         if option_flag.name == "revision":
             revision = option_arg
 
-    if not project_id:
-        raise MissingRequirementException("Project ID must be specified.")
     if not (process_id or process_name):
         raise MissingRequirementException("Either process ID or process name must be specified.")
     if not revision:
         raise MissingRequirementException("Revision must be specified.")
 
-    client = AgenticProcessClient()
+    client = AgenticProcessClient(project_id=project_id)
     result = client.publish_process_revision(
-        project_id=project_id,
         process_id=process_id,
         process_name=process_name,
         revision=revision
     )
-    sys.stdout.write(f"Published process revision detail: \n{result}\n")
+    Console.write_stdout(f"Published process revision detail: \n{result}")
 
 
 publish_process_revision_options = [
-    Option(
-        "project_id",
-        ["--project-id", "--pid"],
-        "ID of the project",
-        True
-    ),
+    PROJECT_ID_OPTION,
     Option(
         "process_id",
         ["--process-id", "--pid"],
@@ -2837,14 +2805,11 @@ def create_task(option_list: list):
         if option_flag.name == "automatic_publish":
             automatic_publish = get_boolean_value(option_arg)
 
-    if not project_id:
-        raise MissingRequirementException("Project ID must be specified.")
     if not name:
         raise MissingRequirementException("Task name must be specified.")
 
-    client = AgenticProcessClient()
+    client = AgenticProcessClient(project_id=project_id)
     result = client.create_task(
-        project_id=project_id,
         name=name,
         description=description,
         title_template=title_template,
@@ -2853,16 +2818,11 @@ def create_task(option_list: list):
         artifact_types=artifact_types,
         automatic_publish=automatic_publish
     )
-    sys.stdout.write(f"Created task detail: \n{result}\n")
+    Console.write_stdout(f"Created task detail: \n{result}")
 
 
 create_task_options = [
-    Option(
-        "project_id",
-        ["--project-id", "--pid"],
-        "ID of the project",
-        True
-    ),
+    PROJECT_ID_OPTION,
     Option(
         "name",
         ["--name", "-n"],
@@ -2921,27 +2881,19 @@ def get_task(option_list: list):
         if option_flag.name == "task_name":
             task_name = option_arg
 
-    if not project_id:
-        raise MissingRequirementException("Project ID must be specified.")
     if not (task_id or task_name):
         raise MissingRequirementException("Either task ID or task name must be specified.")
 
-    client = AgenticProcessClient()
+    client = AgenticProcessClient(project_id=project_id)
     result = client.get_task(
-        project_id=project_id,
         task_id=task_id,
         task_name=task_name
     )
-    sys.stdout.write(f"Task detail: \n{result}\n")
+    Console.write_stdout(f"Task detail: \n{result}")
 
 
 get_task_options = [
-    Option(
-        "project_id",
-        ["--project-id", "--pid"],
-        "ID of the project",
-        True
-    ),
+    PROJECT_ID_OPTION,
     Option(
         "task_id",
         ["--task-id", "--tid"],
@@ -2976,27 +2928,18 @@ def list_tasks(option_list: list):
         if option_flag.name == "allow_drafts":
             allow_drafts = get_boolean_value(option_arg)
 
-    if not project_id:
-        raise MissingRequirementException("Project ID must be specified.")
-
-    client = AgenticProcessClient()
+    client = AgenticProcessClient(project_id=project_id)
     result = client.list_tasks(
-        project_id=project_id,
         id=id,
         start=start,
         count=count,
         allow_drafts=allow_drafts
     )
-    sys.stdout.write(f"Task list: \n{result}\n")
+    Console.write_stdout(f"Task list: \n{result}")
 
 
 list_tasks_options = [
-    Option(
-        "project_id",
-        ["--project-id", "--pid"],
-        "ID of the project",
-        True
-    ),
+    PROJECT_ID_OPTION,
     Option(
         "id",
         ["--id"],
@@ -3068,14 +3011,11 @@ def update_task(option_list: list):
         if option_flag.name == "upsert":
             upsert = get_boolean_value(option_arg)
 
-    if not project_id:
-        raise MissingRequirementException("Project ID must be specified.")
     if not (task_id or name):
         raise MissingRequirementException("Either task ID or name must be specified.")
 
-    client = AgenticProcessClient()
+    client = AgenticProcessClient(project_id=project_id)
     result = client.update_task(
-        project_id=project_id,
         task_id=task_id,
         name=name,
         description=description,
@@ -3086,16 +3026,11 @@ def update_task(option_list: list):
         automatic_publish=automatic_publish,
         upsert=upsert
     )
-    sys.stdout.write(f"Updated task detail: \n{result}\n")
+    Console.write_stdout(f"Updated task detail: \n{result}")
 
 
 update_task_options = [
-    Option(
-        "project_id",
-        ["--project-id", "--pid"],
-        "ID of the project",
-        True
-    ),
+    PROJECT_ID_OPTION,
     Option(
         "task_id",
         ["--task-id", "--tid"],
@@ -3166,27 +3101,19 @@ def delete_task(option_list: list):
         if option_flag.name == "task_name":
             task_name = option_arg
 
-    if not project_id:
-        raise MissingRequirementException("Project ID must be specified.")
     if not (task_id or task_name):
         raise MissingRequirementException("Either task ID or task name must be specified.")
 
-    client = AgenticProcessClient()
+    client = AgenticProcessClient(project_id=project_id)
     result = client.delete_task(
-        project_id=project_id,
         task_id=task_id,
         task_name = task_name
     )
-    sys.stdout.write(f"Delete task result: \n{result}\n")
+    Console.write_stdout(f"Delete task result: \n{result}")
 
 
 delete_task_options = [
-    Option(
-        "project_id",
-        ["--project-id", "--pid"],
-        "ID of the project",
-        True
-    ),
+    PROJECT_ID_OPTION,
     Option(
         "task_id",
         ["--task-id", "--tid"],
@@ -3218,30 +3145,22 @@ def publish_task_revision(option_list: list):
         if option_flag.name == "revision":
             revision = option_arg
 
-    if not project_id:
-        raise MissingRequirementException("Project ID must be specified.")
     if not (task_id or task_name):
         raise MissingRequirementException("Either task ID or task name must be specified.")
     if not revision:
         raise MissingRequirementException("Revision must be specified.")
 
-    client = AgenticProcessClient()
+    client = AgenticProcessClient(project_id=project_id)
     result = client.publish_task_revision(
-        project_id=project_id,
         task_id=task_id,
         task_name=task_name,
         revision=revision
     )
-    sys.stdout.write(f"Published task revision detail: \n{result}\n")
+    Console.write_stdout(f"Published task revision detail: \n{result}")
 
 
 publish_task_revision_options = [
-    Option(
-        "project_id",
-        ["--project-id", "--pid"],
-        "ID of the project",
-        True
-    ),
+    PROJECT_ID_OPTION,
     Option(
         "task_id",
         ["--task-id", "--tid"],
@@ -3287,28 +3206,20 @@ def start_instance(option_list: list):
                     "Variables must be a JSON list: '[{\"key\": \"location\", \"value\": \"Paris\"}]'"
                 )
 
-    if not project_id:
-        raise MissingRequirementException("Project ID must be specified.")
     if not process_name:
         raise MissingRequirementException("Process name must be specified.")
 
-    client = AgenticProcessClient()
+    client = AgenticProcessClient(project_id=project_id)
     result = client.start_instance(
-        project_id=project_id,
         process_name=process_name,
         subject=subject,
         variables=variables
     )
-    sys.stdout.write(f"Started instance detail: \n{result}\n")
+    Console.write_stdout(f"Started instance detail: \n{result}")
 
 
 start_instance_options = [
-    Option(
-        "project_id",
-        ["--project-id", "--pid"],
-        "ID of the project",
-        True
-    ),
+    PROJECT_ID_OPTION,
     Option(
         "process_name",
         ["--process-name", "--pn"],
@@ -3340,26 +3251,18 @@ def abort_instance(option_list: list):
         if option_flag.name == "instance_id":
             instance_id = option_arg
 
-    if not project_id:
-        raise MissingRequirementException("Project ID must be specified.")
     if not instance_id:
         raise MissingRequirementException("Instance ID must be specified.")
 
-    client = AgenticProcessClient()
+    client = AgenticProcessClient(project_id=project_id)
     result = client.abort_instance(
-        project_id=project_id,
         instance_id=instance_id
     )
-    sys.stdout.write(f"Abort instance result: \n{result}\n")
+    Console.write_stdout(f"Abort instance result: \n{result}")
 
 
 abort_instance_options = [
-    Option(
-        "project_id",
-        ["--project-id", "--pid"],
-        "ID of the project",
-        True
-    ),
+    PROJECT_ID_OPTION,
     Option(
         "instance_id",
         ["--instance-id", "--iid"],
@@ -3379,26 +3282,18 @@ def get_instance(option_list: list):
         if option_flag.name == "instance_id":
             instance_id = option_arg
 
-    if not project_id:
-        raise MissingRequirementException("Project ID must be specified.")
     if not instance_id:
         raise MissingRequirementException("Instance ID must be specified.")
 
-    client = AgenticProcessClient()
+    client = AgenticProcessClient(project_id=project_id)
     result = client.get_instance(
-        project_id=project_id,
         instance_id=instance_id
     )
-    sys.stdout.write(f"Instance detail: \n{result}\n")
+    Console.write_stdout(f"Instance detail: \n{result}")
 
 
 get_instance_options = [
-    Option(
-        "project_id",
-        ["--project-id", "--pid"],
-        "ID of the project",
-        True
-    ),
+    PROJECT_ID_OPTION,
     Option(
         "instance_id",
         ["--instance-id", "--iid"],
@@ -3418,26 +3313,18 @@ def get_instance_history(option_list: list):
         if option_flag.name == "instance_id":
             instance_id = option_arg
 
-    if not project_id:
-        raise MissingRequirementException("Project ID must be specified.")
     if not instance_id:
         raise MissingRequirementException("Instance ID must be specified.")
 
-    client = AgenticProcessClient()
+    client = AgenticProcessClient(project_id=project_id)
     result = client.get_instance_history(
-        project_id=project_id,
         instance_id=instance_id
     )
-    sys.stdout.write(f"Instance history: \n{result}\n")
+    Console.write_stdout(f"Instance history: \n{result}")
 
 
 get_instance_history_options = [
-    Option(
-        "project_id",
-        ["--project-id", "--pid"],
-        "ID of the project",
-        True
-    ),
+    PROJECT_ID_OPTION,
     Option(
         "instance_id",
         ["--instance-id", "--iid"],
@@ -3456,26 +3343,18 @@ def get_thread_information(option_list: list):
         if option_flag.name == "thread_id":
             thread_id = option_arg
 
-    if not project_id:
-        raise MissingRequirementException("Project ID must be specified.")
     if not thread_id:
         raise MissingRequirementException("Thread ID must be specified.")
 
-    client = AgenticProcessClient()
+    client = AgenticProcessClient(project_id=project_id)
     result = client.get_thread_information(
-        project_id=project_id,
         thread_id=thread_id
     )
-    sys.stdout.write(f"Thread information: \n{result}\n")
+    Console.write_stdout(f"Thread information: \n{result}")
 
 
 get_thread_information_options = [
-    Option(
-        "project_id",
-        ["--project-id", "--pid"],
-        "ID of the project",
-        True
-    ),
+    PROJECT_ID_OPTION,
     Option(
         "thread_id",
         ["--thread-id", "--tid"],
@@ -3498,29 +3377,21 @@ def send_user_signal(option_list: list):
         if option_flag.name == "signal_name":
             signal_name = option_arg
 
-    if not project_id:
-        raise MissingRequirementException("Project ID must be specified.")
     if not instance_id:
         raise MissingRequirementException("Instance ID must be specified.")
     if not signal_name:
         raise MissingRequirementException("Signal name must be specified.")
 
-    client = AgenticProcessClient()
+    client = AgenticProcessClient(project_id=project_id)
     result = client.send_user_signal(
-        project_id=project_id,
         instance_id=instance_id,
         signal_name=signal_name
     )
-    sys.stdout.write(f"Send user signal result: \n{result}\n")
+    Console.write_stdout(f"Send user signal result: \n{result}")
 
 
 send_user_signal_options = [
-    Option(
-        "project_id",
-        ["--project-id", "--pid"],
-        "ID of the project",
-        True
-    ),
+    PROJECT_ID_OPTION,
     Option(
         "instance_id",
         ["--instance-id", "--iid"],
@@ -3568,28 +3439,20 @@ def create_kb(option_list: list):
                     "Metadata must be a JSON list of strings: '[\"meta1\", \"meta2\"]'"
                 )
 
-    if not project_id:
-        raise MissingRequirementException("Project ID must be specified.")
     if not name:
         raise MissingRequirementException("Name must be specified.")
 
-    client = AgenticProcessClient()
+    client = AgenticProcessClient(project_id=project_id)
     result = client.create_kb(
-        project_id=project_id,
         name=name,
         artifacts=artifacts,
         metadata=metadata
     )
-    sys.stdout.write(f"Created knowledge base detail: \n{result}\n")
+    Console.write_stdout(f"Created knowledge base detail: \n{result}")
 
 
 create_kb_options = [
-    Option(
-        "project_id",
-        ["--project-id", "--pid"],
-        "ID of the project",
-        True
-    ),
+    PROJECT_ID_OPTION,
     Option(
         "name",
         ["--name", "-n"],
@@ -3624,27 +3487,19 @@ def get_kb(option_list: list):
         if option_flag.name == "kb_name":
             kb_name = option_arg
 
-    if not project_id:
-        raise MissingRequirementException("Project ID must be specified.")
     if not (kb_id or kb_name):
         raise MissingRequirementException("Either KB ID or KB name must be specified.")
 
-    client = AgenticProcessClient()
+    client = AgenticProcessClient(project_id=project_id)
     result = client.get_kb(
-        project_id=project_id,
         kb_id=kb_id,
         kb_name=kb_name
     )
-    sys.stdout.write(f"Knowledge base detail: \n{result}\n")
+    Console.write_stdout(f"Knowledge base detail: \n{result}")
 
 
 get_kb_options = [
-    Option(
-        "project_id",
-        ["--project-id", "--pid"],
-        "ID of the project",
-        True
-    ),
+    PROJECT_ID_OPTION,
     Option(
         "kb_id",
         ["--kb-id", "--kid"],
@@ -3676,26 +3531,17 @@ def list_kbs(option_list: list):
         if option_flag.name == "count":
             count = option_arg
 
-    if not project_id:
-        raise MissingRequirementException("Project ID must be specified.")
-
-    client = AgenticProcessClient()
+    client = AgenticProcessClient(project_id=project_id)
     result = client.list_kbs(
-        project_id=project_id,
         name=name,
         start=start,
         count=count
     )
-    sys.stdout.write(f"Knowledge base list: \n{result}\n")
+    Console.write_stdout(f"Knowledge base list: \n{result}")
 
 
 list_kbs_options = [
-    Option(
-        "project_id",
-        ["--project-id", "--pid"],
-        "ID of the project",
-        True
-    ),
+    PROJECT_ID_OPTION,
     Option(
         "name",
         ["--name", "-n"],
@@ -3730,27 +3576,19 @@ def delete_kb(option_list: list):
         if option_flag.name == "kb_name":
             kb_name = option_arg
 
-    if not project_id:
-        raise MissingRequirementException("Project ID must be specified.")
     if not (kb_id or kb_name):
         raise MissingRequirementException("Either KB ID or KB name must be specified.")
 
-    client = AgenticProcessClient()
+    client = AgenticProcessClient(project_id=project_id)
     result = client.delete_kb(
-        project_id=project_id,
         kb_id=kb_id,
         kb_name=kb_name
     )
-    sys.stdout.write(f"Delete knowledge base result: \n{result}\n")
+    Console.write_stdout(f"Delete knowledge base result: \n{result}")
 
 
 delete_kb_options = [
-    Option(
-        "project_id",
-        ["--project-id", "--pid"],
-        "ID of the project",
-        True
-    ),
+    PROJECT_ID_OPTION,
     Option(
         "kb_id",
         ["--kb-id", "--kid"],
@@ -3790,28 +3628,19 @@ def list_jobs(option_list: list):
         if option_flag.name == "name":
             name = option_arg
 
-    if not project_id:
-        raise MissingRequirementException("Project ID must be specified.")
-
-    client = AgenticProcessClient()
+    client = AgenticProcessClient(project_id=project_id)
     result = client.list_jobs(
-        project_id=project_id,
         start=start,
         count=count,
         topic=topic,
         token=token,
         name=name
     )
-    sys.stdout.write(f"Job list: \n{result}\n")
+    Console.write_stdout(f"Job list: \n{result}")
 
 
 list_jobs_options = [
-    Option(
-        "project_id",
-        ["--project-id", "--pid"],
-        "ID of the project",
-        True
-    ),
+    PROJECT_ID_OPTION,
     Option(
         "start",
         ["--start", "-s"],
@@ -3884,6 +3713,24 @@ ai_lab_commands = [
         [],
         get_agent_options
     ),
+    Command(
+        "export_agent",
+        ["export-agent", "ea"],
+        "Export agent",
+        export_agent,
+        ArgumentsEnum.REQUIRED,
+        [],
+        export_agent_options
+    ),
+    Command(
+        "import_agent",
+        ["import-agent", "ia"],
+        "Import agent",
+        import_agent,
+        ArgumentsEnum.REQUIRED,
+        [],
+        import_agent_options
+    ),
     Command(
         "create_sharing_link",
         ["create-sharing-link", "csl"],
@@ -3948,6 +3795,15 @@ ai_lab_commands = [
         [],
         get_tool_options
     ),
+    #Command(
+    #    "export_tool",
+    #    ["export-tool", "et"],
+    #    "Export tool",
+    #    export_tool,
+    #    ArgumentsEnum.REQUIRED,
+    #    [],
+    #    export_tool_options
+    #),
     Command(
         "delete_tool",
         ["delete-tool", "dt"],