scalekit-sdk-python 2.23.0__tar.gz → 2.24.0__tar.gz

{scalekit_sdk_python-2.23.0 → scalekit_sdk_python-2.24.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: scalekit-sdk-python
-Version: 2.23.0
+Version: 2.24.0
 Summary: Scalekit official Python SDK
 Home-page: https://github.com/scalekit-inc/scalekit-sdk-python
 Author: Team Scalekit

{scalekit_sdk_python-2.23.0 → scalekit_sdk_python-2.24.0}/scalekit/_version.py

@@ -1,3 +1,3 @@
 # Single source of truth for the SDK version.
 # Import this in setup.py and scalekit/core.py — never hardcode the version elsewhere.
-__version__ = "2.23.0"
+__version__ = "2.24.0"

{scalekit_sdk_python-2.23.0 → scalekit_sdk_python-2.24.0}/scalekit/actions/models/triggers.py

@@ -146,6 +146,9 @@ class TriggerSubscribeOutcome(str, Enum):
     NOT_FOUND = "NOT_FOUND"
     FAILED = "FAILED"
     """Could not be created this time; safe to retry."""
+    NOT_ATTEMPTED = "NOT_ATTEMPTED"
+    """Not tried: an earlier account stopped the batch or its time ran out. Nothing was
+    created for the account; ``reason`` says which, and retrying is safe."""
 
 
 class TriggerSubscriptionDeleteOutcome(str, Enum):
@@ -295,6 +298,11 @@ class AvailableTrigger(_TriggerModel):
             whole connection.
         requires_signing_secret: The provider signs its events with a secret you set
             with ``set_signing_secret``.
+        ingress_per_account: ``True`` when events arrive through one webhook URL per
+            connected account instead of one per connection. Create each URL and set
+            its secret by passing ``connected_account_id`` to
+            ``create_ingress_endpoint`` and the signing-secret methods. Always
+            ``False`` for poll triggers.
 
     Example:
         >>> page = client.actions.triggers.list_available("conn_123")
@@ -320,6 +328,7 @@ class AvailableTrigger(_TriggerModel):
     register_hint: str = ""
     secret_hint: str = ""
     provides_bearer_secret: bool = False
+    ingress_per_account: bool = False
 
     @classmethod
     def from_proto(cls, proto: pb.AvailableTrigger) -> AvailableTrigger:
@@ -352,6 +361,7 @@ class AvailableTrigger(_TriggerModel):
             register_hint=proto.register_hint,
             secret_hint=proto.secret_hint,
             provides_bearer_secret=proto.provides_bearer_secret,
+            ingress_per_account=proto.ingress_per_account,
         )
 
 
@@ -843,6 +853,12 @@ class TriggerIngressEndpoint(_TriggerModel):
             accepted; ``None`` when no rotation is in progress.
         signing_secret_rotation_id: The latest rotation; pass it to
             ``confirm_signing_secret_rotation``. ``0`` when none ever started.
+        connected_account_id: The connected account this URL delivers to, when
+            ``scope`` is ``DeliveryScope.ACCOUNT``; ``""`` for the connection's URL.
+        scope: ``DeliveryScope.CONNECTION`` for the connection's URL,
+            ``DeliveryScope.ACCOUNT`` for one connected account's own URL; ``None``
+            when the server did not say. A scope this SDK version does not know is a
+            plain ``str``.
 
     Example:
         >>> endpoint = client.actions.triggers.create_ingress_endpoint("conn_123")
@@ -857,6 +873,8 @@ class TriggerIngressEndpoint(_TriggerModel):
     rotation_in_progress: bool = False
     previous_signing_secret_expires_at: datetime | None = None
     signing_secret_rotation_id: int = 0
+    connected_account_id: str = ""
+    scope: DeliveryScope | str | None = None
 
     @classmethod
     def from_proto(cls, proto: pb.TriggerIngressEndpoint) -> TriggerIngressEndpoint:
@@ -872,6 +890,8 @@ class TriggerIngressEndpoint(_TriggerModel):
                 proto, "previous_signing_secret_expires_at"
             ),
             signing_secret_rotation_id=proto.signing_secret_rotation_id,
+            connected_account_id=proto.connected_account_id,
+            scope=enum_from_proto(DeliveryScope, pb.TriggerDeliveryScope, proto.scope),
         )
 
 

{scalekit_sdk_python-2.23.0 → scalekit_sdk_python-2.24.0}/scalekit/actions/triggers.py

@@ -10,7 +10,13 @@ from typing import Protocol
 
 from pydantic import ValidationError
 
-from scalekit._convert import date_to_str, enum_to_proto, str_list, timedelta_to_seconds
+from scalekit._convert import (
+    date_to_str,
+    enum_to_proto,
+    require,
+    str_list,
+    timedelta_to_seconds,
+)
 from scalekit.actions.models.trigger_event import TriggerEvent
 from scalekit.actions.models.triggers import (
     BatchCreateTriggerSubscriptionsResponse,
@@ -68,6 +74,17 @@ class HeadersLike(Protocol):
         ...
 
 
+def _account_id(value: str | None) -> str | None:
+    """Pass ``connected_account_id`` through, refusing ``""``.
+
+    The server reads an empty ID as "not given", so ``""`` would quietly act on the
+    connection's own URL instead of failing; ``None`` is the way to leave it out.
+    """
+    if value is not None:
+        require("connected_account_id", value)
+    return value
+
+
 # Separator a server or proxy puts between repeated header values it joins into one
 # line: "," plus the spaces or tabs after it. Values are not otherwise trimmed, so
 # " 1" stays " 1" (and fails the timestamp check).
@@ -496,8 +513,9 @@ class ActionTriggers:
         """Subscribe up to 100 connected accounts to a trigger in one call.
 
         Not atomic: each account gets its own outcome in ``results`` (``CREATED``,
-        ``ALREADY_SUBSCRIBED``, ``REFUSED``, ``NOT_FOUND``, ``FAILED``), and those never
-        raise. Safe to call again for the ``FAILED`` ones. For a connection-scoped
+        ``ALREADY_SUBSCRIBED``, ``REFUSED``, ``NOT_FOUND``, ``FAILED``,
+        ``NOT_ATTEMPTED``), and those never raise. Safe to call again for the ``FAILED``
+        and ``NOT_ATTEMPTED`` ones (nothing was created for them). For a connection-scoped
         trigger, leave ``connected_account_ids`` out.
 
         Args:
@@ -655,54 +673,84 @@ class ActionTriggers:
 
     # Ingress endpoint and signing secret
 
-    def get_ingress_endpoint(self, connection_id: str) -> TriggerIngressEndpoint:
-        """Read the webhook URL a provider sends a connection's events to.
+    def get_ingress_endpoint(
+        self, connection_id: str, *, connected_account_id: str | None = None
+    ) -> TriggerIngressEndpoint:
+        """Read the webhook URL a provider sends events to, and its signing-secret state.
 
         Args:
             connection_id: The connection (``conn_...``).
+            connected_account_id: Act on this connected account's own webhook URL
+                (``ca_...``), for a trigger whose ``AvailableTrigger.ingress_per_account``
+                is ``True``. Leave it out to act on the connection's URL. The server
+                answers an account that is not on this connection as not found.
 
         Returns:
             The URL and the state of its signing secret (never the secret itself).
 
         Raises:
-            ValueError: ``connection_id`` is empty.
+            ValueError: ``connection_id`` or ``connected_account_id`` is empty.
+            ScalekitBadRequestException: ``connected_account_id`` is malformed.
             ScalekitNotFoundException: No webhook URL yet
                 (``TRIGGER_INGRESS_ENDPOINT_NOT_CREATED``; call
-                ``create_ingress_endpoint``), or unknown connection
-                (``RESOURCE_NOT_FOUND``).
+                ``create_ingress_endpoint``), or unknown connection or connected
+                account (``RESOURCE_NOT_FOUND``).
 
         Example:
             >>> endpoint = client.actions.triggers.get_ingress_endpoint("conn_123")
             >>> endpoint.signing_secret_configured
+            >>> account_endpoint = client.actions.triggers.get_ingress_endpoint(
+            ...     "conn_123", connected_account_id="ca_456")
+            >>> account_endpoint.scope
         """
-        response = self._client().get_trigger_ingress_endpoint(connection_id)
+        response = self._client().get_trigger_ingress_endpoint(
+            connection_id, connected_account_id=_account_id(connected_account_id)
+        )
         return TriggerIngressEndpoint.from_proto(response[0])
 
-    def create_ingress_endpoint(self, connection_id: str) -> TriggerIngressEndpoint:
-        """Create a connection's webhook URL, or return the existing one.
+    def create_ingress_endpoint(
+        self, connection_id: str, *, connected_account_id: str | None = None
+    ) -> TriggerIngressEndpoint:
+        """Create a webhook URL, or return the existing one.
 
         Args:
             connection_id: The connection (``conn_...``).
+            connected_account_id: Act on this connected account's own webhook URL
+                (``ca_...``), for a trigger whose ``AvailableTrigger.ingress_per_account``
+                is ``True``. Leave it out to act on the connection's URL. The server
+                answers an account that is not on this connection as not found.
 
         Returns:
             The URL to paste into the provider's app configuration.
 
         Raises:
-            ValueError: ``connection_id`` is empty.
+            ValueError: ``connection_id`` or ``connected_account_id`` is empty.
             ScalekitBadRequestException: The connection has no webhook trigger
-                (``TRIGGER_INGRESS_NOT_APPLICABLE``), or its trigger definitions are
-                unavailable (``TRIGGER_INGRESS_DEFINITIONS_UNAVAILABLE``).
-            ScalekitNotFoundException: Unknown connection.
+                (``TRIGGER_INGRESS_NOT_APPLICABLE``), its trigger definitions are
+                unavailable (``TRIGGER_INGRESS_DEFINITIONS_UNAVAILABLE``), or the
+                request does not fit how the connection's webhook triggers are
+                delivered (``TRIGGER_INGRESS_SCOPE_MISMATCH``), ``connected_account_id``
+                is malformed, or that account is inactive or only has a pending
+                consent.
+            ScalekitNotFoundException: Unknown connection or connected account.
 
         Example:
             >>> endpoint = client.actions.triggers.create_ingress_endpoint("conn_123")
             >>> print("paste into the provider:", endpoint.url)
+            >>> account_endpoint = client.actions.triggers.create_ingress_endpoint(
+            ...     "conn_123", connected_account_id="ca_456")
         """
-        response = self._client().create_trigger_ingress_endpoint(connection_id)
+        response = self._client().create_trigger_ingress_endpoint(
+            connection_id, connected_account_id=_account_id(connected_account_id)
+        )
         return TriggerIngressEndpoint.from_proto(response[0])
 
     def set_signing_secret(
-        self, connection_id: str, *, signing_secret: str
+        self,
+        connection_id: str,
+        *,
+        signing_secret: str,
+        connected_account_id: str | None = None,
     ) -> TriggerIngressEndpoint:
         """Store the signing secret the provider signs its events with.
 
@@ -715,31 +763,47 @@ class ActionTriggers:
             connection_id: The connection (``conn_...``).
             signing_secret: The secret from the provider's app configuration (8-4096
                 characters; surrounding whitespace is trimmed by the server).
+            connected_account_id: Act on this connected account's own webhook URL
+                (``ca_...``), for a trigger whose ``AvailableTrigger.ingress_per_account``
+                is ``True``. Leave it out to act on the connection's URL. The server
+                answers an account that is not on this connection as not found.
 
         Returns:
             The endpoint, with ``masked_signing_secret`` and rotation state.
 
         Raises:
-            ValueError: ``connection_id`` is empty.
-            ScalekitBadRequestException: The secret is too short, or this provider uses
+            ValueError: ``connection_id`` or ``connected_account_id`` is empty.
+            ScalekitBadRequestException: ``connected_account_id`` is malformed, the
+                secret is too short, or this provider uses
                 a secret Scalekit generates (``TRIGGER_SIGNING_SECRET_GENERATED_ONLY``;
                 call ``generate_signing_secret``).
             ScalekitConflictException: A rotation is already in progress.
             ScalekitNotFoundException: No webhook URL yet
-                (``TRIGGER_INGRESS_ENDPOINT_NOT_CREATED``).
+                (``TRIGGER_INGRESS_ENDPOINT_NOT_CREATED``), or unknown connection or
+                connected account.
 
         Example:
             >>> endpoint = client.actions.triggers.set_signing_secret(
             ...     "conn_123", signing_secret=os.environ["PROVIDER_SIGNING_SECRET"])
             >>> endpoint.rotation_in_progress
+            >>> client.actions.triggers.set_signing_secret(
+            ...     "conn_123",
+            ...     signing_secret=os.environ["PROVIDER_SIGNING_SECRET"],
+            ...     connected_account_id="ca_456")
         """
         response = self._client().set_trigger_signing_secret(
-            connection_id, signing_secret=signing_secret
+            connection_id,
+            signing_secret=signing_secret,
+            connected_account_id=_account_id(connected_account_id),
         )
         return TriggerIngressEndpoint.from_proto(response[0])
 
     def confirm_signing_secret_rotation(
-        self, connection_id: str, *, signing_secret_rotation_id: int | None = None
+        self,
+        connection_id: str,
+        *,
+        signing_secret_rotation_id: int | None = None,
+        connected_account_id: str | None = None,
     ) -> TriggerIngressEndpoint:
         """Finish a signing-secret rotation so only the new secret is accepted.
 
@@ -748,15 +812,20 @@ class ActionTriggers:
             signing_secret_rotation_id: ``TriggerIngressEndpoint.signing_secret_rotation_id``
                 of the rotation to confirm. Required while a rotation is in progress;
                 ignored when none is.
+            connected_account_id: Act on this connected account's own webhook URL
+                (``ca_...``), for a trigger whose ``AvailableTrigger.ingress_per_account``
+                is ``True``. Leave it out to act on the connection's URL. The server
+                answers an account that is not on this connection as not found.
 
         Returns:
             The endpoint after the confirmation.
 
         Raises:
-            ValueError: ``connection_id`` is empty.
-            ScalekitBadRequestException: The rotation ID is missing or names an older
-                rotation.
-            ScalekitNotFoundException: No webhook URL yet.
+            ValueError: ``connection_id`` or ``connected_account_id`` is empty.
+            ScalekitBadRequestException: ``connected_account_id`` is malformed, or the
+                rotation ID is missing or names an older rotation.
+            ScalekitNotFoundException: No webhook URL yet, or unknown connection or
+                connected account.
 
         Example:
             >>> endpoint = client.actions.triggers.get_ingress_endpoint("conn_123")
@@ -764,11 +833,15 @@ class ActionTriggers:
             ...     "conn_123", signing_secret_rotation_id=endpoint.signing_secret_rotation_id)
         """
         response = self._client().confirm_trigger_signing_secret_rotation(
-            connection_id, signing_secret_rotation_id=signing_secret_rotation_id
+            connection_id,
+            signing_secret_rotation_id=signing_secret_rotation_id,
+            connected_account_id=_account_id(connected_account_id),
         )
         return TriggerIngressEndpoint.from_proto(response[0])
 
-    def generate_signing_secret(self, connection_id: str) -> GenerateTriggerSigningSecretResponse:
+    def generate_signing_secret(
+        self, connection_id: str, *, connected_account_id: str | None = None
+    ) -> GenerateTriggerSigningSecretResponse:
         """Generate a signing secret, for providers that use one Scalekit creates.
 
         The secret is returned in plaintext only in this response; it is left out of
@@ -776,22 +849,32 @@ class ActionTriggers:
 
         Args:
             connection_id: The connection (``conn_...``).
+            connected_account_id: Act on this connected account's own webhook URL
+                (``ca_...``), for a trigger whose ``AvailableTrigger.ingress_per_account``
+                is ``True``. Leave it out to act on the connection's URL. The server
+                answers an account that is not on this connection as not found.
 
         Returns:
             The endpoint, the secret and the URL that includes it.
 
         Raises:
-            ValueError: ``connection_id`` is empty.
-            ScalekitBadRequestException: The provider signs its own events
+            ValueError: ``connection_id`` or ``connected_account_id`` is empty.
+            ScalekitBadRequestException: ``connected_account_id`` is malformed, or the
+                provider signs its own events
                 (``TRIGGER_SIGNING_SECRET_NOT_GENERATABLE``; use ``set_signing_secret``).
             ScalekitConflictException: A rotation is in progress.
-            ScalekitNotFoundException: No webhook URL yet.
+            ScalekitNotFoundException: No webhook URL yet, or unknown connection or
+                connected account.
 
         Example:
             >>> generated = client.actions.triggers.generate_signing_secret("conn_123")
             >>> save_to_provider(generated.url_with_secret)
+            >>> client.actions.triggers.generate_signing_secret(
+            ...     "conn_123", connected_account_id="ca_456")
         """
-        response = self._client().generate_trigger_signing_secret(connection_id)
+        response = self._client().generate_trigger_signing_secret(
+            connection_id, connected_account_id=_account_id(connected_account_id)
+        )
         return GenerateTriggerSigningSecretResponse.from_proto(response[0])
 
     # Deliveries

{scalekit_sdk_python-2.23.0 → scalekit_sdk_python-2.24.0}/scalekit/core.py

@@ -187,7 +187,7 @@ class CoreClient:
 
     sdk_version = f"Scalekit-Python/{_sdk_version}"
     # YYYYMMDD
-    api_version = "20261027"
+    api_version = "20261106"
     user_agent = f"{sdk_version} Python/{platform.python_version()} ({platform.system()}; {platform.architecture()}"
 
     def __init__(

{scalekit_sdk_python-2.23.0 → scalekit_sdk_python-2.24.0}/scalekit/resource.py

@@ -369,6 +369,7 @@ class ResourceClient:
         page_size: Optional[int] = None,
         page_token: Optional[str] = None,
         user_ids: Optional[List[str]] = None,
+        consent_ids: Optional[List[str]] = None,
     ) -> ListResourceUserConsentsResponse:
         """
         Method to list the end-user consents granted against a resource
@@ -377,9 +378,12 @@ class ResourceClient:
         scopes and granted_at. The response also carries total_size plus
         next_page_token / prev_page_token cursors.
 
-        Pass user_ids to match specific external user IDs exactly and
-        case-sensitively. Pass search for a case-insensitive substring match.
-        When both are given, user_ids wins and search is ignored.
+        Pass consent_ids to fetch specific consents by ID. Pass user_ids to match
+        specific external user IDs exactly and case-sensitively. Pass search for a
+        case-insensitive substring match. When several are given, the priority is
+        consent_ids, then user_ids, then search; the lower ones are ignored. Blank-only
+        consent_ids are ignored. An older server ignores consent_ids, so confirm each
+        returned id is one you passed before revoking.
 
         :param resource_id      : Resource id to list consents for (format: res_xxxxx)
         :type                   : ``` str ```
@@ -389,7 +393,11 @@ class ResourceClient:
         :type                   : ``` int ```
         :param page_token       : Page token for pagination
         :type                   : ``` str ```
-        :param user_ids         : Exact match on external user IDs (max 25)
+        :param user_ids         : Exact match on external user IDs (max 25). Ignored when consent_ids is set
+        :type                   : ``` list ```
+        :param consent_ids      : Exact match on consent IDs (format: usrcnst_xxxxx), max 25 distinct.
+                                  Blank-only values are ignored. IDs that do not exist or belong to another
+                                  resource are omitted from the result
         :type                   : ``` list ```
         :returns:
             List Resource User Consents Response
@@ -397,6 +405,12 @@ class ResourceClient:
         if not resource_id:
             raise ValueError("resource_id is required")
 
+        # The filter overrides search server-side, so attach it only when IDs were supplied.
+        consent_filter = (
+            ResourceUserConsentFilter(external_user_id=user_ids, consent_id=consent_ids)
+            if user_ids or consent_ids else None
+        )
+
         return self.core_client.grpc_exec(
             self.client_service.ListResourceUserConsents.with_call,
             ListResourceUserConsentsRequest(
@@ -404,7 +418,7 @@ class ResourceClient:
                 search=search,
                 page_size=page_size,
                 page_token=page_token,
-                filter=ResourceUserConsentFilter(external_user_id=user_ids) if user_ids else None,
+                filter=consent_filter,
             )
         )
 

{scalekit_sdk_python-2.23.0 → scalekit_sdk_python-2.24.0}/scalekit/triggers.py

@@ -227,59 +227,99 @@ class TriggersClient:
     # Ingress endpoint and signing secret
 
     def get_trigger_ingress_endpoint(
-        self, connection_id: str
+        self, connection_id: str, *, connected_account_id: str | None = None
     ) -> tuple[pb.TriggerIngressEndpoint, grpc.Call]:
-        """Read a connection's webhook URL and signing-secret state."""
+        """Read a webhook URL and signing-secret state.
+
+        Reads the connection's URL, or one connected account's own URL when
+        ``connected_account_id`` is given. The ID is sent as given: the server treats
+        ``""`` as omitted, and validates the rest.
+        """
         require("connection_id", connection_id)
+        request = pb.GetTriggerIngressEndpointRequest(connection_id=connection_id)
+        if connected_account_id is not None:
+            request.connected_account_id = connected_account_id
         return self.core_client.grpc_exec(
             self.trigger_service.GetTriggerIngressEndpoint.with_call,
-            pb.GetTriggerIngressEndpointRequest(connection_id=connection_id),
+            request,
         )
 
     def create_trigger_ingress_endpoint(
-        self, connection_id: str
+        self, connection_id: str, *, connected_account_id: str | None = None
     ) -> tuple[pb.TriggerIngressEndpoint, grpc.Call]:
-        """Create a connection's webhook URL, or return the existing one."""
+        """Create a webhook URL, or return the existing one.
+
+        Creates the connection's URL, or one connected account's own URL when
+        ``connected_account_id`` is given.
+        """
         require("connection_id", connection_id)
+        request = pb.CreateTriggerIngressEndpointRequest(connection_id=connection_id)
+        if connected_account_id is not None:
+            request.connected_account_id = connected_account_id
         return self.core_client.grpc_exec(
             self.trigger_service.CreateTriggerIngressEndpoint.with_call,
-            pb.CreateTriggerIngressEndpointRequest(connection_id=connection_id),
+            request,
         )
 
     def set_trigger_signing_secret(
-        self, connection_id: str, *, signing_secret: str
+        self,
+        connection_id: str,
+        *,
+        signing_secret: str,
+        connected_account_id: str | None = None,
     ) -> tuple[pb.TriggerIngressEndpoint, grpc.Call]:
-        """Store the provider's signing secret, or start a rotation. Not retried."""
+        """Store the provider's signing secret, or start a rotation. Not retried.
+
+        Acts on one connected account's URL when ``connected_account_id`` is given.
+        """
         require("connection_id", connection_id)
+        request = pb.SetTriggerSigningSecretRequest(
+            connection_id=connection_id, signing_secret=signing_secret
+        )
+        if connected_account_id is not None:
+            request.connected_account_id = connected_account_id
         return self.core_client.grpc_exec(
             self.trigger_service.SetTriggerSigningSecret.with_call,
-            pb.SetTriggerSigningSecretRequest(
-                connection_id=connection_id, signing_secret=signing_secret
-            ),
+            request,
             retry_on_unavailable=False,
         )
 
     def confirm_trigger_signing_secret_rotation(
-        self, connection_id: str, *, signing_secret_rotation_id: int | None = None
+        self,
+        connection_id: str,
+        *,
+        signing_secret_rotation_id: int | None = None,
+        connected_account_id: str | None = None,
     ) -> tuple[pb.TriggerIngressEndpoint, grpc.Call]:
-        """Confirm a signing-secret rotation so the previous secret stops being accepted."""
+        """Confirm a signing-secret rotation so the previous secret stops being accepted.
+
+        Acts on one connected account's URL when ``connected_account_id`` is given.
+        """
         require("connection_id", connection_id)
         request = pb.ConfirmTriggerSigningSecretRotationRequest(connection_id=connection_id)
         if signing_secret_rotation_id is not None:
             request.signing_secret_rotation_id = signing_secret_rotation_id
+        if connected_account_id is not None:
+            request.connected_account_id = connected_account_id
         return self.core_client.grpc_exec(
             self.trigger_service.ConfirmTriggerSigningSecretRotation.with_call,
             request,
         )
 
     def generate_trigger_signing_secret(
-        self, connection_id: str
+        self, connection_id: str, *, connected_account_id: str | None = None
     ) -> tuple[pb.GenerateTriggerSigningSecretResponse, grpc.Call]:
-        """Generate a signing secret for providers that use one Scalekit creates. Not retried."""
+        """Generate a signing secret for providers that use one Scalekit creates. Not retried.
+
+        Acts on one connected account's URL when ``connected_account_id`` is given.
+        """
         require("connection_id", connection_id)
+        request = pb.GenerateTriggerSigningSecretRequest(connection_id=connection_id)
+        if connected_account_id is not None:
+            request.connected_account_id = connected_account_id
         return self.core_client.grpc_exec(
             self.trigger_service.GenerateTriggerSigningSecret.with_call,
-            pb.GenerateTriggerSigningSecretRequest(connection_id=connection_id),
+            request,
             retry_on_unavailable=False,
         )