feat(sdk): generate SDK for version v4.2.0 (#69)

* feat(sdk): generate SDK for version v4.2.0

* chore: bumped the containers to match the corresponding server version

* fix(api): Ensure error responses are deserialized

The ApiClient failed to handle the body of non-2xx (error) API responses. The code generator did not create the necessary logic to deserialize the default error type defined in the OpenAPI specification. This caused the `response_body` in a caught `ApiError` to always be `None`, making it impossible to debug API failures through the SDK.

This patch modifies the `response_deserialize` method to intelligently process error bodies. It now checks the `Content-Type` header of the response. If the content is JSON, it is decoded into a dictionary. If the content is not JSON or if parsing fails, it gracefully falls back to using the raw text of the body.

This ensures that the `ApiError` exception always contains a useful payload (either a structured dictionary or raw text), significantly improving the debugging experience by making API errors transparent.

Author: mridang

etc/docker-compose.yaml

@@ -20,7 +20,7 @@ services:
     restart: 'no'
     networks:
       - storage
-    image: 'ghcr.io/zitadel/zitadel:v4.0.0'
+    image: 'ghcr.io/zitadel/zitadel:v4.2.0'
     command: 'init --config /example-zitadel-config.yaml --config /example-zitadel-secrets.yaml'
     depends_on:
       db:
@@ -34,7 +34,7 @@ services:
     restart: 'no'
     networks:
       - storage
-    image: 'ghcr.io/zitadel/zitadel:v4.0.0-debug'
+    image: 'ghcr.io/zitadel/zitadel:v4.2.0-debug'
     user: root
     entrypoint: '/bin/bash'
     command: [ "-c", "/app/zitadel setup --config /example-zitadel-config.yaml --config /example-zitadel-secrets.yaml --steps /example-zitadel-init-steps.yaml --masterkey \"my_test_masterkey_0123456789ABEF\" && echo \"--- ZITADEL SETUP COMPLETE ---\" && echo \"Personal Access Token (PAT) will be in ./zitadel_output/pat.txt on your host.\" && echo \"Service Account Key will be in ./zitadel_output/sa-key.json on your host.\" && echo \"OAuth Client ID and Secret will be in 'zitadel' service logs (grep for 'Application created').\"" ]
@@ -55,7 +55,7 @@ services:
     networks:
       - backend
       - storage
-    image: 'ghcr.io/zitadel/zitadel:v4.0.0'
+    image: 'ghcr.io/zitadel/zitadel:v4.2.0'
     command: >
       start --config /example-zitadel-config.yaml
       --config /example-zitadel-secrets.yaml

zitadel_client/api/action_service_api.py

@@ -54,10 +54,12 @@ def __init__(self, api_client=None) -> None:
 
 
     @validate_call
-    def create_target(        self,                action_service_create_target_request: ActionServiceCreateTargetRequest,                _request_timeout: Union[            None,            Annotated[StrictFloat, Field(gt=0)],            Tuple[                Annotated[StrictFloat, Field(gt=0)],                Annotated[StrictFloat, Field(gt=0)]            ]        ] = None,        _request_auth: Optional[Dict[StrictStr, Any]] = None,        _content_type: Optional[StrictStr] = None,        _headers: Optional[Dict[StrictStr, Any]] = None,        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,    ) -> ActionServiceCreateTargetResponse:
-        """CreateTarget
+    def create_target(        self,                action_service_create_target_request: Optional[ActionServiceCreateTargetRequest] = None,                _request_timeout: Union[            None,            Annotated[StrictFloat, Field(gt=0)],            Tuple[                Annotated[StrictFloat, Field(gt=0)],                Annotated[StrictFloat, Field(gt=0)]            ]        ] = None,        _request_auth: Optional[Dict[StrictStr, Any]] = None,        _content_type: Optional[StrictStr] = None,        _headers: Optional[Dict[StrictStr, Any]] = None,        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,    ) -> ActionServiceCreateTargetResponse:
+        if action_service_create_target_request is None:
+            action_service_create_target_request = {}
+        """Create Target
 
-        Create Target   Create a new target to your endpoint, which can be used in executions.   Required permission:    - `action.target.write`   Required feature flag:    - `actions`
+        Create a new target to your endpoint, which can be used in executions.   Required permission:    - `action.target.write`   Required feature flag:    - `actions`
 
         :param action_service_create_target_request: (required)
         :type action_service_create_target_request: ActionServiceCreateTargetRequest
@@ -183,9 +185,9 @@ def _create_target_serialize(
 
     @validate_call
     def delete_target(        self,                action_service_delete_target_request: ActionServiceDeleteTargetRequest,                _request_timeout: Union[            None,            Annotated[StrictFloat, Field(gt=0)],            Tuple[                Annotated[StrictFloat, Field(gt=0)],                Annotated[StrictFloat, Field(gt=0)]            ]        ] = None,        _request_auth: Optional[Dict[StrictStr, Any]] = None,        _content_type: Optional[StrictStr] = None,        _headers: Optional[Dict[StrictStr, Any]] = None,        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,    ) -> ActionServiceDeleteTargetResponse:
-        """DeleteTarget
+        """Delete Target
 
-        Delete Target   Delete an existing target. This will remove it from any configured execution as well.  In case the target is not found, the request will return a successful response as  the desired state is already achieved.   Required permission:    - `action.target.delete`   Required feature flag:    - `actions`
+        Delete an existing target. This will remove it from any configured execution as well.  In case the target is not found, the request will return a successful response as  the desired state is already achieved.   Required permission:    - `action.target.delete`   Required feature flag:    - `actions`
 
         :param action_service_delete_target_request: (required)
         :type action_service_delete_target_request: ActionServiceDeleteTargetRequest
@@ -311,9 +313,9 @@ def _delete_target_serialize(
 
     @validate_call
     def get_target(        self,                action_service_get_target_request: ActionServiceGetTargetRequest,                _request_timeout: Union[            None,            Annotated[StrictFloat, Field(gt=0)],            Tuple[                Annotated[StrictFloat, Field(gt=0)],                Annotated[StrictFloat, Field(gt=0)]            ]        ] = None,        _request_auth: Optional[Dict[StrictStr, Any]] = None,        _content_type: Optional[StrictStr] = None,        _headers: Optional[Dict[StrictStr, Any]] = None,        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,    ) -> ActionServiceGetTargetResponse:
-        """GetTarget
+        """Get Target
 
-        Get Target   Returns the target identified by the requested ID.   Required permission:    - `action.target.read`   Required feature flag:    - `actions`
+        Returns the target identified by the requested ID.   Required permission:    - `action.target.read`   Required feature flag:    - `actions`
 
         :param action_service_get_target_request: (required)
         :type action_service_get_target_request: ActionServiceGetTargetRequest
@@ -441,9 +443,9 @@ def _get_target_serialize(
     def list_execution_functions(        self,                body: Optional[Dict[str, Any]] = None,                _request_timeout: Union[            None,            Annotated[StrictFloat, Field(gt=0)],            Tuple[                Annotated[StrictFloat, Field(gt=0)],                Annotated[StrictFloat, Field(gt=0)]            ]        ] = None,        _request_auth: Optional[Dict[StrictStr, Any]] = None,        _content_type: Optional[StrictStr] = None,        _headers: Optional[Dict[StrictStr, Any]] = None,        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,    ) -> ActionServiceListExecutionFunctionsResponse:
         if body is None:
             body = {}
-        """ListExecutionFunctions
+        """List Execution Functions
 
-        List Execution Functions   List all available functions which can be used as condition for executions.
+        List all available functions which can be used as condition for executions.
 
         :param body: (required)
         :type body: object
@@ -571,9 +573,9 @@ def _list_execution_functions_serialize(
     def list_execution_methods(        self,                body: Optional[Dict[str, Any]] = None,                _request_timeout: Union[            None,            Annotated[StrictFloat, Field(gt=0)],            Tuple[                Annotated[StrictFloat, Field(gt=0)],                Annotated[StrictFloat, Field(gt=0)]            ]        ] = None,        _request_auth: Optional[Dict[StrictStr, Any]] = None,        _content_type: Optional[StrictStr] = None,        _headers: Optional[Dict[StrictStr, Any]] = None,        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,    ) -> ActionServiceListExecutionMethodsResponse:
         if body is None:
             body = {}
-        """ListExecutionMethods
+        """List Execution Methods
 
-        List Execution Methods   List all available methods which can be used as condition for executions.
+        List all available methods which can be used as condition for executions.
 
         :param body: (required)
         :type body: object
@@ -701,9 +703,9 @@ def _list_execution_methods_serialize(
     def list_execution_services(        self,                body: Optional[Dict[str, Any]] = None,                _request_timeout: Union[            None,            Annotated[StrictFloat, Field(gt=0)],            Tuple[                Annotated[StrictFloat, Field(gt=0)],                Annotated[StrictFloat, Field(gt=0)]            ]        ] = None,        _request_auth: Optional[Dict[StrictStr, Any]] = None,        _content_type: Optional[StrictStr] = None,        _headers: Optional[Dict[StrictStr, Any]] = None,        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,    ) -> ActionServiceListExecutionServicesResponse:
         if body is None:
             body = {}
-        """ListExecutionServices
+        """List Execution Services
 
-        List Execution Services   List all available services which can be used as condition for executions.
+        List all available services which can be used as condition for executions.
 
         :param body: (required)
         :type body: object
@@ -829,9 +831,9 @@ def _list_execution_services_serialize(
 
     @validate_call
     def list_executions(        self,                action_service_list_executions_request: ActionServiceListExecutionsRequest,                _request_timeout: Union[            None,            Annotated[StrictFloat, Field(gt=0)],            Tuple[                Annotated[StrictFloat, Field(gt=0)],                Annotated[StrictFloat, Field(gt=0)]            ]        ] = None,        _request_auth: Optional[Dict[StrictStr, Any]] = None,        _content_type: Optional[StrictStr] = None,        _headers: Optional[Dict[StrictStr, Any]] = None,        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,    ) -> ActionServiceListExecutionsResponse:
-        """ListExecutions
+        """List Executions
 
-        List Executions   List all matching executions. By default all executions of the instance are returned that have at least one execution target.  Make sure to include a limit and sorting for pagination.   Required permission:    - `action.execution.read`   Required feature flag:    - `actions`
+        List all matching executions. By default all executions of the instance are returned that have at least one execution target.  Make sure to include a limit and sorting for pagination.   Required permission:    - `action.execution.read`   Required feature flag:    - `actions`
 
         :param action_service_list_executions_request: (required)
         :type action_service_list_executions_request: ActionServiceListExecutionsRequest
@@ -957,9 +959,9 @@ def _list_executions_serialize(
 
     @validate_call
     def list_targets(        self,                action_service_list_targets_request: ActionServiceListTargetsRequest,                _request_timeout: Union[            None,            Annotated[StrictFloat, Field(gt=0)],            Tuple[                Annotated[StrictFloat, Field(gt=0)],                Annotated[StrictFloat, Field(gt=0)]            ]        ] = None,        _request_auth: Optional[Dict[StrictStr, Any]] = None,        _content_type: Optional[StrictStr] = None,        _headers: Optional[Dict[StrictStr, Any]] = None,        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,    ) -> ActionServiceListTargetsResponse:
-        """ListTargets
+        """List targets
 
-        List targets   List all matching targets. By default all targets of the instance are returned.  Make sure to include a limit and sorting for pagination.   Required permission:    - `action.target.read`   Required feature flag:    - `actions`
+        List all matching targets. By default all targets of the instance are returned.  Make sure to include a limit and sorting for pagination.   Required permission:    - `action.target.read`   Required feature flag:    - `actions`
 
         :param action_service_list_targets_request: (required)
         :type action_service_list_targets_request: ActionServiceListTargetsRequest
@@ -1085,9 +1087,9 @@ def _list_targets_serialize(
 
     @validate_call
     def set_execution(        self,                action_service_set_execution_request: ActionServiceSetExecutionRequest,                _request_timeout: Union[            None,            Annotated[StrictFloat, Field(gt=0)],            Tuple[                Annotated[StrictFloat, Field(gt=0)],                Annotated[StrictFloat, Field(gt=0)]            ]        ] = None,        _request_auth: Optional[Dict[StrictStr, Any]] = None,        _content_type: Optional[StrictStr] = None,        _headers: Optional[Dict[StrictStr, Any]] = None,        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,    ) -> ActionServiceSetExecutionResponse:
-        """SetExecution
+        """Set Execution
 
-        Set Execution   Sets an execution to call a target or include the targets of another execution.  Setting an empty list of targets will remove all targets from the execution, making it a noop.   Required permission:    - `action.execution.write`   Required feature flag:    - `actions`
+        Sets an execution to call a target or include the targets of another execution.  Setting an empty list of targets will remove all targets from the execution, making it a noop.   Required permission:    - `action.execution.write`   Required feature flag:    - `actions`
 
         :param action_service_set_execution_request: (required)
         :type action_service_set_execution_request: ActionServiceSetExecutionRequest
@@ -1212,10 +1214,12 @@ def _set_execution_serialize(
 
 
     @validate_call
-    def update_target(        self,                action_service_update_target_request: ActionServiceUpdateTargetRequest,                _request_timeout: Union[            None,            Annotated[StrictFloat, Field(gt=0)],            Tuple[                Annotated[StrictFloat, Field(gt=0)],                Annotated[StrictFloat, Field(gt=0)]            ]        ] = None,        _request_auth: Optional[Dict[StrictStr, Any]] = None,        _content_type: Optional[StrictStr] = None,        _headers: Optional[Dict[StrictStr, Any]] = None,        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,    ) -> ActionServiceUpdateTargetResponse:
-        """UpdateTarget
+    def update_target(        self,                action_service_update_target_request: Optional[ActionServiceUpdateTargetRequest] = None,                _request_timeout: Union[            None,            Annotated[StrictFloat, Field(gt=0)],            Tuple[                Annotated[StrictFloat, Field(gt=0)],                Annotated[StrictFloat, Field(gt=0)]            ]        ] = None,        _request_auth: Optional[Dict[StrictStr, Any]] = None,        _content_type: Optional[StrictStr] = None,        _headers: Optional[Dict[StrictStr, Any]] = None,        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,    ) -> ActionServiceUpdateTargetResponse:
+        if action_service_update_target_request is None:
+            action_service_update_target_request = {}
+        """Update Target
 
-        Update Target   Update an existing target.  To generate a new signing key set the optional expirationSigningKey.   Required permission:    - `action.target.write`   Required feature flag:    - `actions`
+        Update an existing target.  To generate a new signing key set the optional expirationSigningKey.   Required permission:    - `action.target.write`   Required feature flag:    - `actions`
 
         :param action_service_update_target_request: (required)
         :type action_service_update_target_request: ActionServiceUpdateTargetRequest