ibm-watsonx-orchestrate 1.1.0__tar.gz → 1.2.0__tar.gz

{ibm_watsonx_orchestrate-1.1.0 → ibm_watsonx_orchestrate-1.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ibm-watsonx-orchestrate
-Version: 1.1.0
+Version: 1.2.0
 Summary: IBM watsonx.orchestrate SDK
 Author-email: IBM <support@ibm.com>
 License: MIT License

{ibm_watsonx_orchestrate-1.1.0 → ibm_watsonx_orchestrate-1.2.0}/src/ibm_watsonx_orchestrate/__init__.py

@@ -5,7 +5,7 @@
 
 pkg_name = "ibm-watsonx-orchestrate"
 
-__version__ = "1.1.0"
+__version__ = "1.2.0"
 
 
 

{ibm_watsonx_orchestrate-1.1.0 → ibm_watsonx_orchestrate-1.2.0}/src/ibm_watsonx_orchestrate/agent_builder/tools/types.py

@@ -1,5 +1,5 @@
 from enum import Enum
-from typing import List, Any, Dict, Literal, Optional
+from typing import List, Any, Dict, Literal, Optional, Union
 
 from pydantic import BaseModel, model_validator, ConfigDict, Field, AliasChoices
 
@@ -14,7 +14,7 @@ class ToolPermission(str, Enum):
 class JsonSchemaObject(BaseModel):
     model_config = ConfigDict(extra='allow')
 
-    type: Optional[Literal['object', 'string', 'number', 'integer', 'boolean', 'array', 'null']] = None
+    type: Optional[Union[Literal['object', 'string', 'number', 'integer', 'boolean', 'array', 'null'], List[Literal['object', 'string', 'number', 'integer', 'boolean', 'array', 'null']]]] = None
     title: str | None = None
     description: str | None = None
     properties: Optional[Dict[str, 'JsonSchemaObject']] = None
@@ -34,13 +34,19 @@ class JsonSchemaObject(BaseModel):
     aliasName: str | None = None
     "Runtime feature where the sdk can provide the original name of a field before prefixing"
 
+    @model_validator(mode='after')
+    def normalize_type_field(self) -> 'JsonSchemaObject':
+        if isinstance(self.type, list):
+            self.type = self.type[0]
+        return self
+
 
 class ToolRequestBody(BaseModel):
     model_config = ConfigDict(extra='allow')
 
     type: Literal['object']
     properties: Dict[str, JsonSchemaObject]
-    required: List[str]
+    required: Optional[List[str]] = None
 
 
 class ToolResponseBody(BaseModel):
@@ -52,7 +58,7 @@ class ToolResponseBody(BaseModel):
     items: JsonSchemaObject = None
     uniqueItems: bool = None
     anyOf: List['JsonSchemaObject'] = None
-    required: List[str] = None
+    required: Optional[List[str]] = None
 
 class OpenApiSecurityScheme(BaseModel):
     type: Literal['apiKey', 'http', 'oauth2', 'openIdConnect']
@@ -128,6 +134,10 @@ class SkillToolBinding(BaseModel):
 class ClientSideToolBinding(BaseModel):
     pass
 
+class McpToolBinding(BaseModel):
+    server_url: Optional[str] = None
+    source: str
+    connections: Dict[str, str]
 
 class ToolBinding(BaseModel):
     openapi: OpenApiToolBinding = None
@@ -135,6 +145,7 @@ class ToolBinding(BaseModel):
     wxflows: WxFlowsToolBinding = None
     skill: SkillToolBinding = None
     client_side: ClientSideToolBinding = None
+    mcp: McpToolBinding = None
 
     @model_validator(mode='after')
     def validate_binding_type(self) -> 'ToolBinding':
@@ -143,7 +154,8 @@ class ToolBinding(BaseModel):
             self.python is not None,
             self.wxflows is not None,
             self.skill is not None,
-            self.client_side is not None
+            self.client_side is not None,
+            self.mcp is not None
         ]
         if sum(bindings) == 0:
             raise ValueError("One binding must be set")
@@ -159,4 +171,5 @@ class ToolSpec(BaseModel):
     input_schema: ToolRequestBody = None
     output_schema: ToolResponseBody = None
     binding: ToolBinding = None
+    toolkit_id: str | None = None
 

ibm_watsonx_orchestrate-1.2.0/src/ibm_watsonx_orchestrate/cli/commands/toolkit/toolkit_command.py

@@ -0,0 +1,71 @@
+import typer
+from typing import List
+from typing_extensions import Annotated, Optional
+from ibm_watsonx_orchestrate.cli.commands.toolkit.toolkit_controller import ToolkitController, ToolkitKind
+
+toolkits_app = typer.Typer(no_args_is_help=True)
+
+@toolkits_app.command(name="import")
+def import_toolkit(
+    kind: Annotated[
+        ToolkitKind,
+        typer.Option("--kind", "-k", help="Kind of toolkit, currently only MCP is supported"),
+    ],
+    name: Annotated[
+        str,
+        typer.Option("--name", "-n", help="Name of the toolkit"),
+    ],
+    description: Annotated[
+        str,
+        typer.Option("--description", help="Description of the toolkit"),
+    ],
+    package_root: Annotated[
+        str,
+        typer.Option("--package-root", "-p", help="Root directory of the MCP server package"),
+    ],
+    command: Annotated[
+        str,
+        typer.Option(
+            "--command", 
+            help="Command to start the MCP server. Can be a string (e.g. 'node dist/index.js --transport stdio') "
+                "or a JSON-style list of arguments (e.g. '[\"node\", \"dist/index.js\", \"--transport\", \"stdio\"]'). "
+                "The first argument will be used as the executable, the rest as its arguments."
+        ),
+    ],
+    tools: Annotated[
+        Optional[str],
+        typer.Option("--tools", "-t", help="Comma-separated list of tools to import. Or you can use `*` to use all tools"),
+    ] = None,
+    app_id: Annotated[
+        List[str],
+        typer.Option(
+            "--app-id", "-a", 
+            help='The app id of the connection to associate with this tool. A application connection represents the server authentication credentials needed to connect to this tool. Only type key_value is currently supported for MCP.'
+        )
+    ] = None
+):
+    if tools == "*":
+        tool_list = ["*"] # Wildcard to use all tools
+    elif tools:
+        tool_list = [tool.strip() for tool in tools.split(",")]
+    else:
+        tool_list = None
+
+    toolkit_controller = ToolkitController(
+    kind=kind,
+    name=name,
+    description=description,
+    package_root=package_root,
+    command=command,
+)
+    toolkit_controller.import_toolkit(tools=tool_list, app_id=app_id)
+
+@toolkits_app.command(name="remove")
+def remove_toolkit(
+    name: Annotated[
+        str,
+        typer.Option("--name", "-n", help="Name of the toolkit you wish to remove"),
+    ],
+):  
+    toolkit_controller = ToolkitController()
+    toolkit_controller.remove_toolkit(name=name)

ibm_watsonx_orchestrate-1.2.0/src/ibm_watsonx_orchestrate/cli/commands/toolkit/toolkit_controller.py

@@ -0,0 +1,212 @@
+import os
+import zipfile
+import tempfile
+from typing import List, Optional
+from enum import Enum
+import logging
+import sys
+import re
+import requests
+from ibm_watsonx_orchestrate.client.toolkit.toolkit_client import ToolKitClient
+from ibm_watsonx_orchestrate.client.utils import instantiate_client
+from ibm_watsonx_orchestrate.utils.utils import sanatize_app_id
+from ibm_watsonx_orchestrate.client.connections import get_connections_client
+import typer
+import json
+from rich.console import Console
+from rich.progress import Progress, SpinnerColumn, TextColumn
+from ibm_watsonx_orchestrate.client.utils import is_local_dev
+
+logger = logging.getLogger(__name__)
+
+class ToolkitKind(str, Enum):
+    MCP = "mcp"
+
+def get_connection_id(app_id: str) -> str:
+    connections_client = get_connections_client()
+    existing_draft_configuration = connections_client.get_config(app_id=app_id, env='draft')
+    existing_live_configuration = connections_client.get_config(app_id=app_id, env='live')
+
+    for config in [existing_draft_configuration, existing_live_configuration]:
+        if config and config.security_scheme != 'key_value_creds':
+            logger.error("Only key_value credentials are currently supported")
+            exit(1)
+    connection_id = None
+    if app_id is not None:
+        connection = connections_client.get(app_id=app_id)
+        if  not connection:
+            logger.error(f"No connection exists with the app-id '{app_id}'")
+            exit(1)
+        connection_id = connection.connection_id
+    return connection_id
+
+def validate_params(kind: str):
+    if kind != ToolkitKind.MCP:
+        raise ValueError(f"Unsupported toolkit kind: {kind}")
+
+
+class ToolkitController:
+    def __init__(
+        self, 
+        kind: ToolkitKind = None,
+        name: str = None,
+        description: str = None,
+        package_root: str  = None,
+        command: str  = None,
+    ):
+        self.kind = kind
+        self.name = name
+        self.description = description
+        self.package_root = package_root
+        self.command = command
+        self.client = None
+
+    def get_client(self) -> ToolKitClient:
+        if not self.client:
+            self.client = instantiate_client(ToolKitClient)
+        return self.client
+
+    def import_toolkit(self, tools: Optional[List[str]] = None, app_id: Optional[List[str]] = None):
+        if not is_local_dev():
+            logger.error("This functionality is only available for Local Environments")
+            sys.exit(1)
+
+        if app_id and isinstance(app_id, str):
+            app_id = [app_id]
+        elif not app_id:
+            app_id = []
+
+        validate_params(kind=self.kind)
+
+        remapped_connections = self._remap_connections(app_id)
+
+        client = self.get_client()
+        draft_toolkits = client.get_draft_by_name(toolkit_name=self.name)
+        if len(draft_toolkits) > 0:
+            logger.error(f"Existing toolkit found with name '{self.name}'. Failed to create toolkit.")
+            sys.exit(1)
+
+        with tempfile.TemporaryDirectory() as tmpdir:
+            # Handle zip file or directory
+            if self.package_root.endswith(".zip") and os.path.isfile(self.package_root):
+                zip_file_path = self.package_root
+            else:
+                zip_file_path = os.path.join(tmpdir, os.path.basename(f"{self.package_root.rstrip(os.sep)}.zip"))
+                with zipfile.ZipFile(zip_file_path, "w", zipfile.ZIP_DEFLATED) as mcp_zip_tool_artifacts:
+                    self._populate_zip(self.package_root, mcp_zip_tool_artifacts)
+
+            try:
+                command_parts = json.loads(self.command)
+                if not isinstance(command_parts, list):
+                    raise ValueError("JSON command must be a list of strings")
+            except (json.JSONDecodeError, ValueError):
+                command_parts = self.command.split()
+
+            command = command_parts[0]
+            args = command_parts[1:]
+
+            console = Console()
+            # List tools if not provided
+            if tools is None:
+                with Progress(
+                    SpinnerColumn(spinner_name="dots"),
+                    TextColumn("[progress.description]{task.description}"),
+                    transient=True,
+                    console=console,
+                ) as progress:
+                    progress.add_task(description="No tools specified, retrieving all tools from provided MCP server", total=None)
+                    tools = self.get_client().list_tools(
+                    zip_file_path=zip_file_path,
+                    command=command,
+                    args=args,
+                )
+                # Normalize tools to a list of tool names
+                tools = [
+                    tool["name"] if isinstance(tool, dict) and "name" in tool else tool
+                    for tool in tools
+                ]
+
+
+                logger.info("✅ The following tools will be imported:")
+                for tool in tools:
+                    console.print(f"  • {tool}")
+
+
+            # Create toolkit metadata
+            payload = {
+                "name": self.name,
+                "description": self.description,
+                "mcp": {
+                    "source": "files",
+                    "command": command,
+                    "args": args,
+                    "tools": tools,
+                    "connections": remapped_connections,
+                }
+            }
+            toolkit = self.get_client().create_toolkit(payload)
+            toolkit_id = toolkit["id"]
+
+            console = Console()
+            # Upload zip file
+            with Progress(
+                SpinnerColumn(spinner_name="dots"),
+                TextColumn("[progress.description]{task.description}"),
+                transient=True,
+                console=console,
+            ) as progress:
+                progress.add_task(description="Uploading toolkit zip file...", total=None)
+                self.get_client().upload(toolkit_id=toolkit_id, zip_file_path=zip_file_path)
+            logger.info(f"Successfully imported tool kit {self.name}")
+
+    def _populate_zip(self, package_root: str, zipfile: zipfile.ZipFile) -> str:
+        for root, _, files in os.walk(package_root):
+            for file in files:
+                full_path = os.path.join(root, file)
+                relative_path = os.path.relpath(full_path, start=package_root)
+                zipfile.write(full_path, arcname=relative_path)
+        return zipfile
+
+    def _remap_connections(self, app_ids: List[str]):
+        app_id_dict = {}
+        for app_id in app_ids:        
+            split_pattern = re.compile(r"(?<!\\)=")
+            split_id = re.split(split_pattern, app_id)
+            split_id = [x.replace("\\=", "=") for x in split_id]
+            if len(split_id) == 2:
+                runtime_id, local_id = split_id
+            elif len(split_id) == 1:
+                runtime_id = split_id[0]
+                local_id = split_id[0]
+            else:
+                raise typer.BadParameter(f"The provided --app-id '{app_id}' is not valid. This is likely caused by having mutliple equal signs, please use '\\=' to represent a literal '=' character")
+
+            if not len(runtime_id.strip()) or not len(local_id.strip()):
+                raise typer.BadParameter(f"The provided --app-id '{app_id}' is not valid. --app-id cannot be empty or whitespace")
+
+            runtime_id = sanatize_app_id(runtime_id)
+            app_id_dict[runtime_id] = get_connection_id(local_id)
+
+        return app_id_dict
+
+    
+    def remove_toolkit(self, name: str):
+        if not is_local_dev():
+            logger.error("This functionality is only available for Local Environments")
+            sys.exit(1)
+        try:
+            client = self.get_client()
+            draft_toolkits = client.get_draft_by_name(toolkit_name=name)
+            if len(draft_toolkits) > 1:
+                logger.error(f"Multiple existing toolkits found with name '{name}'. Failed to remove toolkit")
+                sys.exit(1)
+            if len(draft_toolkits) > 0:
+                draft_toolkit = draft_toolkits[0]
+                toolkit_id = draft_toolkit.get("id")
+                self.get_client().delete(toolkit_id=toolkit_id)
+                logger.info(f"Successfully removed tool {name}")
+            else:
+                logger.warning(f"No toolkit named '{name}' found")
+        except requests.HTTPError as e:
+            logger.error(e.response.text)
+            exit(1)

{ibm_watsonx_orchestrate-1.1.0 → ibm_watsonx_orchestrate-1.2.0}/src/ibm_watsonx_orchestrate/cli/commands/tools/tools_controller.py

@@ -27,8 +27,9 @@ from ibm_watsonx_orchestrate.cli.config import Config, CONTEXT_SECTION_HEADER, C
     DEFAULT_CONFIG_FILE_CONTENT
 from ibm_watsonx_orchestrate.agent_builder.connections import ConnectionSecurityScheme, ExpectedCredentials
 from ibm_watsonx_orchestrate.client.tools.tool_client import ToolClient
+from ibm_watsonx_orchestrate.client.toolkit.toolkit_client import ToolKitClient
 from ibm_watsonx_orchestrate.client.connections import get_connections_client, get_connection_type
-from ibm_watsonx_orchestrate.client.utils import instantiate_client
+from ibm_watsonx_orchestrate.client.utils import instantiate_client, is_local_dev
 from ibm_watsonx_orchestrate.utils.utils import sanatize_app_id
 
 from  ibm_watsonx_orchestrate import __version__
@@ -41,6 +42,7 @@ __supported_characters_pattern = re.compile("^(\\w|_)+$")
 class ToolKind(str, Enum):
     openapi = "openapi"
     python = "python"
+    mcp = "mcp"
     # skill = "skill"
 
 def validate_app_ids(kind: ToolKind, **args) -> None:
@@ -368,21 +370,24 @@ class ToolsController:
         response = self.get_client().get()
         tool_specs = [ToolSpec.model_validate(tool) for tool in response]
         tools = [BaseTool(spec=spec) for spec in tool_specs]
-        
 
         if verbose:
             tools_list = []
             for tool in tools:
-
                 tools_list.append(json.loads(tool.dumps_spec()))
 
             rich.print(JSON(json.dumps(tools_list, indent=4)))
         else:
             table = rich.table.Table(show_header=True, header_style="bold white", show_lines=True)
-            columns = ["Name", "Description", "Permission", "Type", "App ID"]
+            columns = ["Name", "Description", "Permission", "Type", "Toolkit", "App ID"]
             for column in columns:
                 table.add_column(column)
-            
+
+            connections_client = get_connections_client()
+            connections = connections_client.list()
+
+            connections_dict = {conn.connection_id: conn for conn in connections}
+
             for tool in tools:
                 tool_binding = tool.__tool_spec__.binding
                 
@@ -394,25 +399,49 @@ class ToolsController:
                     elif tool_binding.python is not None and hasattr(tool_binding.python, "connections") and tool_binding.python.connections is not None:
                         for conn in tool_binding.python.connections:
                             connection_ids.append(tool_binding.python.connections[conn])
-                
-                connections_client = get_connections_client()
+                    elif tool_binding.mcp is not None and hasattr(tool_binding.mcp, "connections"):
+                        for conn in tool_binding.mcp.connections:
+                            connection_ids.append(tool_binding.mcp.connections[conn])
+
+
                 app_ids = []
                 for connection_id in connection_ids:
-                    app_id = str(connections_client.get_draft_by_id(connection_id))
+                    connection = connections_dict.get(connection_id)
+                    if connection:
+                        app_id = str(connection.app_id or connection.connection_id)
+                    elif connection_id:
+                        app_id = str(connection_id)
+                    else:
+                        app_id = ""
                     app_ids.append(app_id)
 
                 if tool_binding.python is not None:
                         tool_type=ToolKind.python
                 elif tool_binding.openapi is not None:
                         tool_type=ToolKind.openapi
+                elif tool_binding.mcp is not None:
+                        tool_type=ToolKind.mcp
                 else:
                         tool_type="Unknown"
                 
+                toolkit_name = ""
+
+                if is_local_dev():
+                    toolkit_client = instantiate_client(ToolKitClient)
+                    if tool.__tool_spec__.toolkit_id:
+                        toolkit = toolkit_client.get_draft_by_id(tool.__tool_spec__.toolkit_id)
+                        if isinstance(toolkit, dict) and "name" in toolkit:
+                            toolkit_name = toolkit["name"]
+                        elif toolkit:
+                            toolkit_name = str(toolkit)
+
+                
                 table.add_row(
                     tool.__tool_spec__.name,
                     tool.__tool_spec__.description,
                     tool.__tool_spec__.permission,
                     tool_type,
+                    toolkit_name,
                     ", ".join(app_ids),
                 )
 

{ibm_watsonx_orchestrate-1.1.0 → ibm_watsonx_orchestrate-1.2.0}/src/ibm_watsonx_orchestrate/cli/main.py

@@ -11,6 +11,7 @@ from ibm_watsonx_orchestrate.cli.commands.models.models_command import models_ap
 from ibm_watsonx_orchestrate.cli.commands.environment.environment_command import environment_app
 from ibm_watsonx_orchestrate.cli.commands.channels.channels_command import channel_app
 from ibm_watsonx_orchestrate.cli.commands.knowledge_bases.knowledge_bases_command import knowledge_bases_app
+from ibm_watsonx_orchestrate.cli.commands.toolkit.toolkit_command import toolkits_app
 
 app = typer.Typer(
     no_args_is_help=True,
@@ -20,10 +21,11 @@ app.add_typer(login_app)
 app.add_typer(environment_app, name="env", help='Add, remove, or select the activate env other commands will interact with (either your local server or a production instance)')
 app.add_typer(agents_app, name="agents", help='Interact with the agents in your active env')
 app.add_typer(tools_app, name="tools", help='Interact with the tools in your active env')
+app.add_typer(toolkits_app, name="toolkits", help="Interact with the toolkits in your active env")
 app.add_typer(knowledge_bases_app, name="knowledge-bases", help="Upload knowledge your agents can search through to your active env")
 app.add_typer(connections_app, name="connections", help='Interact with the agents in your active env')
-app.add_typer(server_app, name="server", help='Manipulate your local Orchestrate Developer Edition server [requires an Entitlement]')
-app.add_typer(chat_app, name="chat", help='Launch the chat ui for your local Developer Edition server [requires docker pull credentials]')
+app.add_typer(server_app, name="server", help='Manipulate your local Orchestrate Developer Edition server [requires entitlement]')
+app.add_typer(chat_app, name="chat", help='Launch the chat ui for your local Developer Edition server [requires entitlement]')
 app.add_typer(models_app, name="models", help='List the available large language models (llms) that can be used in your agent definitions')
 app.add_typer(channel_app, name="channels", help="Configure channels where your agent can exist on (such as embedded webchat)")
 app.add_typer(settings_app, name="settings", help='Configure the settings for your active env')

ibm_watsonx_orchestrate-1.2.0/src/ibm_watsonx_orchestrate/client/toolkit/toolkit_client.py

@@ -0,0 +1,81 @@
+from ibm_watsonx_orchestrate.client.base_api_client import BaseAPIClient, ClientAPIException
+from typing_extensions import List
+import os
+import json
+
+class ToolKitClient(BaseAPIClient):
+    # POST /toolkits/prepare/list-tools
+    def list_tools(self, zip_file_path: str, command: str, args: List[str]) -> List[str]:
+        """
+        List the available tools inside the MCP server
+        """
+
+        filename = os.path.basename(zip_file_path)
+
+        list_toolkit_obj = {
+            "source": "files",
+            "command": command,
+            "args": args,
+        }
+
+        with open(zip_file_path, "rb") as f:
+            files = {
+                "list_toolkit_obj": (None, json.dumps(list_toolkit_obj), "application/json"),
+                "file": (filename, f, "application/zip"),
+            }
+
+            response = self._post("/orchestrate/toolkits/prepare/list-tools", files=files)
+
+        return response.get("tools", [])
+
+
+    # POST /api/v1/orchestrate/toolkits
+    def create_toolkit(self, payload) -> dict:
+        """
+        Creates new toolkit metadata
+        """
+        try:
+            return self._post("/orchestrate/toolkits", data=payload)
+        except ClientAPIException as e:
+            if e.response.status_code == 400 and "already exists" in e.response.text:
+                raise ClientAPIException(
+                    status_code=400,
+                    message=f"There is already a Toolkit with the same name that exists for this tenant."
+                )
+            raise(e)
+    
+    # POST /toolkits/{toolkit-id}/upload
+    def upload(self, toolkit_id: str, zip_file_path: str) -> dict:
+        """
+        Upload zip file to the toolkit.
+        """
+        filename = os.path.basename(zip_file_path)
+        with open(zip_file_path, "rb") as f:
+            files = {
+                "file": (filename, f, "application/zip", {"Expires": "0"})
+            }
+            return self._post(f"/orchestrate/toolkits/{toolkit_id}/upload", files=files)
+        
+    # DELETE /toolkits/{toolkit-id} 
+    def delete(self, toolkit_id: str) -> dict:
+        return self._delete(f"/orchestrate/toolkits/{toolkit_id}")
+
+    def get_draft_by_name(self, toolkit_name: str) -> List[dict]:
+        return self.get_drafts_by_names([toolkit_name])
+
+    def get_drafts_by_names(self, toolkit_names: List[str]) -> List[dict]:
+        formatted_toolkit_names = [f"names={x}" for x in toolkit_names]
+        return self._get(f"/orchestrate/toolkits?{'&'.join(formatted_toolkit_names)}")
+    
+    def get_draft_by_id(self, toolkit_id: str) -> dict:
+        if toolkit_id is None:
+            return ""
+        else:
+            try:
+                toolkit = self._get(f"/orchestrate/toolkits/{toolkit_id}")
+                return toolkit
+            except ClientAPIException as e:
+                if e.response.status_code == 404 and "not found with the given name" in e.response.text:
+                    return ""
+                raise(e)
+

{ibm_watsonx_orchestrate-1.1.0 → ibm_watsonx_orchestrate-1.2.0}/src/ibm_watsonx_orchestrate/docker/compose-lite.yml

@@ -595,3 +595,4 @@ volumes:
 networks:
   default:
     name: wxo-server
+    

{ibm_watsonx_orchestrate-1.1.0 → ibm_watsonx_orchestrate-1.2.0}/src/ibm_watsonx_orchestrate/docker/default.env

@@ -49,18 +49,18 @@ EVENT_BROKER_TTL="-1"
 # THE VALUES FOR REGISTRY_URL AND *_REGISTRY ARE NOT SET HERE; THEY ARE EITHER PROVIDED BY THE USER OR DETERMINED AT RUNTIME BASED ON WO_DEVELOPER_EDITION_SOURCE.
 REGISTRY_URL=
 
-SERVER_TAG=02-05-2025
+SERVER_TAG=03-05-2025
 SERVER_REGISTRY=
 
-WORKER_TAG=01-05-2025
+WORKER_TAG=03-05-2025
 WORKER_REGISTRY=
 
 DB_REGISTRY=
 # If you build multiarch set all three of these to the same, we have a pr against main
 # to not have this separation, but we can merge it later
-DBTAG=01-05-2025
-AMDDBTAG=01-05-2025
-ARM64DBTAG=01-05-2025
+DBTAG=02-05-2025
+AMDDBTAG=02-05-2025
+ARM64DBTAG=02-05-2025
 
 UI_REGISTRY=
 UITAG=01-05-2025
@@ -68,10 +68,10 @@ UITAG=01-05-2025
 CM_REGISTRY=
 CM_TAG=30-04-2025
 
-TRM_TAG=01-05-2025
+TRM_TAG=02-05-2025
 TRM_REGISTRY=
 
-TR_TAG=01-05-2025
+TR_TAG=02-05-2025
 TR_REGISTRY=
 
 BUILDER_REGISTRY=