airbyte-agent-zendesk-support 0.18.18__py3-none-any.whl → 0.18.21__py3-none-any.whl

airbyte_agent_zendesk_support/_vendored/connector_sdk/cloud_utils/__init__.py

@@ -0,0 +1,5 @@
+"""Cloud API utilities for Airbyte Platform integration."""
+
+from .client import AirbyteCloudClient
+
+__all__ = ["AirbyteCloudClient"]

airbyte_agent_zendesk_support/_vendored/connector_sdk/cloud_utils/client.py

@@ -0,0 +1,213 @@
+"""AirbyteCloudClient for Airbyte Platform API integration."""
+
+from __future__ import annotations
+
+from datetime import datetime, timedelta
+from typing import Any
+
+import httpx
+
+
+class AirbyteCloudClient:
+    """Client for interacting with Airbyte Platform APIs.
+
+    Handles authentication, token caching, and API calls to:
+    - Get bearer tokens for authentication
+    - Look up connector instances for users
+    - Execute connectors via the cloud API
+
+    Example:
+        client = AirbyteCloudClient(
+            client_id="your-client-id",
+            client_secret="your-client-secret"
+        )
+
+        # Get a connector instance
+        instance_id = await client.get_connector_instance_id(
+            external_user_id="user-123",
+            connector_definition_id="stripe-def-456"
+        )
+
+        # Execute the connector
+        result = await client.execute_connector(
+            instance_id=instance_id,
+            entity="customers",
+            action="list",
+            params={"limit": 10}
+        )
+    """
+
+    AUTH_BASE_URL = "https://cloud.airbyte.com"  # For token endpoint
+    API_BASE_URL = "https://api.airbyte.ai"  # For instance lookup & execution
+
+    def __init__(self, client_id: str, client_secret: str):
+        """Initialize AirbyteCloudClient.
+
+        Args:
+            client_id: Airbyte client ID for authentication
+            client_secret: Airbyte client secret for authentication
+        """
+        self._client_id = client_id
+        self._client_secret = client_secret
+
+        # Token cache (instance-level)
+        self._cached_token: str | None = None
+        self._token_expires_at: datetime | None = None
+        self._http_client = httpx.AsyncClient(
+            timeout=httpx.Timeout(300.0),  # 5 minute timeout
+            follow_redirects=True,
+        )
+
+    async def get_bearer_token(self) -> str:
+        """Get bearer token for API authentication.
+
+        Caches the token and only requests a new one when the cached token
+        is expired or missing. Adds a 60-second buffer before expiration
+        to avoid edge cases.
+
+        Returns:
+            Bearer token string
+
+        Raises:
+            httpx.HTTPStatusError: If the token request fails with 4xx/5xx
+            httpx.RequestError: If the network request fails
+
+        Example:
+            token = await client.get_bearer_token()
+            # Use token in Authorization header: f"Bearer {token}"
+        """
+        # Check if we have a cached token that hasn't expired
+        if self._cached_token and self._token_expires_at:
+            # Add 60 second buffer before expiration to avoid edge cases
+            now = datetime.now()
+            if now < self._token_expires_at:
+                # Token is still valid, return cached version
+                return self._cached_token
+
+        # Token is missing or expired, fetch a new one
+        url = f"{self.AUTH_BASE_URL}/api/v1/applications/token"
+        request_body = {
+            "client_id": self._client_id,
+            "client_secret": self._client_secret,
+        }
+
+        response = await self._http_client.post(url, json=request_body)
+        response.raise_for_status()
+
+        data = response.json()
+        access_token = data["access_token"]
+        expires_in = 15 * 60  # default 15 min expiry time * 60 seconds
+
+        # Calculate expiration time with 60 second buffer
+        expires_at = datetime.now() + timedelta(seconds=expires_in - 60)
+        self._cached_token = access_token
+        self._token_expires_at = expires_at
+
+        return access_token
+
+    async def get_connector_instance_id(
+        self,
+        external_user_id: str,
+        connector_definition_id: str,
+    ) -> str:
+        """Get connector instance ID for a user.
+
+        Looks up the connector instance that belongs to the specified user
+        and connector definition. Validates that exactly one instance exists.
+
+        Args:
+            external_user_id: User identifier in the Airbyte system
+            connector_definition_id: UUID of the connector definition
+
+        Returns:
+            Connector instance ID (UUID string)
+
+        Raises:
+            ValueError: If 0 or more than 1 instance is found
+            httpx.HTTPStatusError: If API returns 4xx/5xx status code
+            httpx.RequestError: If network request fails
+
+        Example:
+            instance_id = await client.get_connector_instance_id(
+                external_user_id="user-123",
+                connector_definition_id="550e8400-e29b-41d4-a716-446655440000"
+            )
+        """
+
+        token = await self.get_bearer_token()
+        url = f"{self.API_BASE_URL}/api/v1/connectors/instances_for_user"
+        params = {
+            "external_user_id": external_user_id,
+            "definition_id": connector_definition_id,
+        }
+
+        headers = {"Authorization": f"Bearer {token}"}
+        response = await self._http_client.get(url, params=params, headers=headers)
+        response.raise_for_status()
+
+        data = response.json()
+        instances = data["instances"]
+
+        if len(instances) == 0:
+            raise ValueError(f"No connector instance found for user '{external_user_id}' " f"and connector '{connector_definition_id}'")
+
+        if len(instances) > 1:
+            raise ValueError(
+                f"Multiple connector instances found for user '{external_user_id}' "
+                f"and connector '{connector_definition_id}'. Expected exactly 1, "
+                f"found {len(instances)}"
+            )
+
+        instance_id = instances[0]["id"]
+        return instance_id
+
+    async def execute_connector(
+        self,
+        instance_id: str,
+        entity: str,
+        action: str,
+        params: dict[str, Any] | None,
+    ) -> dict[str, Any]:
+        """Execute a connector operation.
+
+        Args:
+            instance_id: Connector instance UUID
+            entity: Entity name (e.g., "customers", "invoices")
+            action: Operation action (e.g., "list", "get", "create")
+            params: Optional parameters for the operation
+
+        Returns:
+            Raw JSON response dict from the API
+
+        Raises:
+            httpx.HTTPStatusError: If API returns 4xx/5xx status code
+            httpx.RequestError: If network request fails
+
+        Example:
+            result = await client.execute_connector(
+                instance_id="inst-123",
+                entity="customers",
+                action="list",
+                params={"limit": 10}
+            )
+        """
+        token = await self.get_bearer_token()
+        url = f"{self.API_BASE_URL}/api/v1/connectors/instances/{instance_id}/execute"
+        headers = {"Authorization": f"Bearer {token}"}
+        request_body = {
+            "entity": entity,
+            "action": action,
+            "params": params,
+        }
+
+        response = await self._http_client.post(url, json=request_body, headers=headers)
+        response.raise_for_status()
+
+        return response.json()
+
+    async def close(self):
+        """Close the HTTP client.
+
+        Call this when you're done using the client to clean up resources.
+        """
+        await self._http_client.aclose()

airbyte_agent_zendesk_support/_vendored/connector_sdk/connector_model_loader.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 import re
 from pathlib import Path
 from typing import Any
+from uuid import UUID
 
 import jsonref
 import yaml
@@ -105,7 +106,7 @@ def resolve_schema_refs(schema: Any, spec_dict: dict) -> dict[str, Any]:
 
     try:
         # Resolve all references
-        resolved_spec = jsonref.replace_refs(
+        resolved_spec = jsonref.replace_refs(  # type: ignore[union-attr]
             temp_spec,
             base_uri="",
             jsonschema=True,  # Use JSONSchema draft 7 semantics
@@ -117,9 +118,11 @@ def resolve_schema_refs(schema: Any, spec_dict: dict) -> dict[str, Any]:
 
         # Remove any remaining jsonref proxy objects by converting to plain dict
         return _deproxy_schema(resolved_schema)
-    except (jsonref.JsonRefError, KeyError, RecursionError):
+    except (AttributeError, KeyError, RecursionError, Exception):
         # If resolution fails, return the original schema
         # This allows the system to continue even with malformed $refs
+        # AttributeError covers the case where jsonref might be None
+        # Exception catches jsonref.JsonRefError and other jsonref exceptions
         return schema_dict
 
 
@@ -404,9 +407,13 @@ def convert_openapi_to_connector_model(spec: OpenAPIConnector) -> ConnectorModel
 
     # Extract retry config from x-airbyte-retry-config extension
     retry_config = spec.info.x_airbyte_retry_config
+    connector_id = spec.info.x_airbyte_connector_id
+    if not connector_id:
+        raise InvalidOpenAPIError("Missing required x-airbyte-connector-id field")
 
     # Create ConnectorModel
     model = ConnectorModel(
+        id=connector_id,
         name=name,
         version=version,
         base_url=base_url,
@@ -926,8 +933,20 @@ def load_connector_model(definition_path: str | Path) -> ConnectorModel:
         )
         entities.append(entity)
 
+    # Get connector ID
+    connector_id_value = connector_meta.get("id")
+    if connector_id_value:
+        # Try to parse as UUID (handles string UUIDs)
+        if isinstance(connector_id_value, str):
+            connector_id = UUID(connector_id_value)
+        else:
+            connector_id = connector_id_value
+    else:
+        raise ValueError
+
     # Build ConnectorModel
     model = ConnectorModel(
+        id=connector_id,
         name=connector_meta["name"],
         version=connector_meta.get("version", OPENAPI_DEFAULT_VERSION),
         base_url=raw_definition.get("base_url", connector_meta.get("base_url", "")),

airbyte_agent_zendesk_support/_vendored/connector_sdk/executor/hosted_executor.py

@@ -1,12 +1,11 @@
-"""Hosted executor for proxying operations through the backend API."""
+"""Hosted executor for proxying operations through the cloud API."""
 
 from __future__ import annotations
 
-import os
-
-import httpx
 from opentelemetry import trace
 
+from ..cloud_utils import AirbyteCloudClient
+
 from .models import (
     ExecutionConfig,
     ExecutionResult,
@@ -14,30 +13,36 @@ from .models import (
 
 
 class HostedExecutor:
-    """Executor that proxies execution through the Sonar backend API.
+    """Executor that proxies execution through the Airbyte Cloud API.
 
-    This is the "hosted mode" executor that makes HTTP calls to the backend API
-    instead of directly calling external services. The backend handles all
+    This is the "hosted mode" executor that makes HTTP calls to the cloud API
+    instead of directly calling external services. The cloud API handles all
     connector logic, secrets management, and execution.
 
-    The API URL is configured at initialization via the api_url parameter,
-    which defaults to the AIRBYTE_CONNECTOR_API_URL environment variable.
+    The executor takes an external_user_id and uses the AirbyteCloudClient to:
+    1. Authenticate with the Airbyte Platform (bearer token with caching)
+    2. Look up the user's connector instance
+    3. Execute the connector operation via the cloud API
 
     Implements ExecutorProtocol.
 
     Example:
+        # Create executor with user ID, credentials, and connector definition ID
         executor = HostedExecutor(
-            connector_id="stripe-prod-123",
+            external_user_id="user-123",
             airbyte_client_id="client_abc123",
-            airbyte_client_secret="secret_xyz789"
+            airbyte_client_secret="secret_xyz789",
+            connector_definition_id="abc123-def456-ghi789",
         )
 
-        config = ExecutionConfig(
+        # Execute an operation
+        execution_config = ExecutionConfig(
             entity="customers",
-            action="list"
+            action="list",
+            params={"limit": 10}
         )
 
-        result = await executor.execute(config)
+        result = await executor.execute(execution_config)
         if result.success:
             print(f"Data: {result.data}")
         else:
@@ -46,53 +51,45 @@ class HostedExecutor:
 
     def __init__(
         self,
-        connector_id: str,
+        external_user_id: str,
         airbyte_client_id: str,
         airbyte_client_secret: str,
-        api_url: str | None = None,
+        connector_definition_id: str,
     ):
         """Initialize hosted executor.
 
         Args:
-            connector_id: ID of the connector to execute (e.g., "stripe-prod-123")
+            external_user_id: User identifier in the Airbyte system
             airbyte_client_id: Airbyte client ID for authentication
             airbyte_client_secret: Airbyte client secret for authentication
-            api_url: API URL for the hosted executor backend. Defaults to
-                AIRBYTE_CONNECTOR_API_URL environment variable or "http://localhost:8001"
+            connector_definition_id: Connector definition ID used to look up
+                the user's connector instance.
 
         Example:
             executor = HostedExecutor(
-                connector_id="my-connector-id",
-                airbyte_client_id="client_abc123",
-                airbyte_client_secret="secret_xyz789"
-            )
-
-            # Or with custom API URL:
-            executor = HostedExecutor(
-                connector_id="my-connector-id",
+                external_user_id="user-123",
                 airbyte_client_id="client_abc123",
                 airbyte_client_secret="secret_xyz789",
-                api_url="https://api.production.com"
+                connector_definition_id="abc123-def456-ghi789",
             )
         """
-        self.connector_id = connector_id
-        self.airbyte_client_id = airbyte_client_id
-        self.airbyte_client_secret = airbyte_client_secret
-        self.api_url = api_url or os.getenv("AIRBYTE_CONNECTOR_API_URL", "http://localhost:8001")
-
-        # Create synchronous HTTP client
-        # We use sync client even though execute() is async for simplicity
-        # The async wrapper allows it to work with the protocol
-        self.client = httpx.Client(
-            timeout=httpx.Timeout(300.0),  # 5 minute timeout
-            follow_redirects=True,
+        self._external_user_id = external_user_id
+        self._connector_definition_id = connector_definition_id
+
+        # Create AirbyteCloudClient for API interactions
+        self._cloud_client = AirbyteCloudClient(
+            client_id=airbyte_client_id,
+            client_secret=airbyte_client_secret,
         )
 
     async def execute(self, config: ExecutionConfig) -> ExecutionResult:
-        """Execute connector via backend API (ExecutorProtocol implementation).
+        """Execute connector via cloud API (ExecutorProtocol implementation).
 
-        Makes an HTTP POST request to /connectors/{connector_id}/execute with
-        OAuth authentication and the configuration in the request body.
+        Flow:
+        1. Get connector id from connector model
+        2. Look up the user's connector instance ID
+        3. Execute the connector operation via the cloud API
+        4. Parse the response into ExecutionResult
 
         Args:
             config: Execution configuration (entity, action, params)
@@ -101,88 +98,100 @@ class HostedExecutor:
             ExecutionResult with success/failure status
 
         Raises:
+            ValueError: If no instance or multiple instances found for user
             httpx.HTTPStatusError: If API returns 4xx/5xx status code
             httpx.RequestError: If network request fails
 
         Example:
             config = ExecutionConfig(
                 entity="customers",
-                action="list"
+                action="list",
+                params={"limit": 10}
             )
             result = await executor.execute(config)
         """
         tracer = trace.get_tracer("airbyte.connector-sdk.executor.hosted")
 
         with tracer.start_as_current_span("airbyte.hosted_executor.execute") as span:
-            # Add span attributes
-            span.set_attribute("connector.id", self.connector_id)
+            # Add span attributes for observability
+            span.set_attribute("connector.definition_id", self._connector_definition_id)
             span.set_attribute("connector.entity", config.entity)
             span.set_attribute("connector.action", config.action)
-            span.set_attribute("connector.api_url", self.api_url)
+            span.set_attribute("user.external_id", self._external_user_id)
             if config.params:
                 # Only add non-sensitive param keys
                 span.set_attribute("connector.param_keys", list(config.params.keys()))
 
-            # Build API URL from instance api_url
-            url = f"{self.api_url}/connectors/{self.connector_id}/execute"
-            span.set_attribute("http.url", url)
-
-            # Build request body matching ExecutionRequest model
-            # Extract entity, action, and params from config attributes
-            request_body = {
-                "entity": config.entity,
-                "action": config.action,
-                "params": config.params,
-            }
-
             try:
-                # Make synchronous HTTP request
-                # (wrapped in async method for protocol compatibility)
-                response = self.client.post(url, json=request_body)
+                # Step 1: Get connector definition id
+                connector_definition_id = self._connector_definition_id
+
+                # Step 2: Get the connector instance ID for this user
+                instance_id = await self._cloud_client.get_connector_instance_id(
+                    external_user_id=self._external_user_id,
+                    connector_definition_id=connector_definition_id,
+                )
 
-                # Add response status code to span
-                span.set_attribute("http.status_code", response.status_code)
+                span.set_attribute("connector.instance_id", instance_id)
 
-                # Raise exception for 4xx/5xx status codes
-                response.raise_for_status()
+                # Step 3: Execute the connector via the cloud API
+                response = await self._cloud_client.execute_connector(
+                    instance_id=instance_id,
+                    entity=config.entity,
+                    action=config.action,
+                    params=config.params,
+                )
 
-                # Parse JSON response
-                result_data = response.json()
+                # Step 4: Parse the response into ExecutionResult
+                # The response_data is a dict from the API
+                result = self._parse_execution_result(response)
 
                 # Mark span as successful
-                span.set_attribute("connector.success", True)
+                span.set_attribute("connector.success", result.success)
 
-                # Return success result
-                return ExecutionResult(success=True, data=result_data, error=None)
+                return result
 
-            except httpx.HTTPStatusError as e:
-                # HTTP error (4xx, 5xx) - record and re-raise
+            except ValueError as e:
+                # Instance lookup validation error (0 or >1 instances)
                 span.set_attribute("connector.success", False)
-                span.set_attribute("connector.error_type", "HTTPStatusError")
-                span.set_attribute("http.status_code", e.response.status_code)
+                span.set_attribute("connector.error_type", "ValueError")
                 span.record_exception(e)
                 raise
 
             except Exception as e:
-                # Catch-all for any other unexpected exceptions
+                # HTTP errors and other exceptions
                 span.set_attribute("connector.success", False)
                 span.set_attribute("connector.error_type", type(e).__name__)
                 span.record_exception(e)
                 raise
 
-    def close(self):
-        """Close the HTTP client.
+    def _parse_execution_result(self, response: dict) -> ExecutionResult:
+        """Parse API response into ExecutionResult.
 
-        Call this when you're done using the executor to clean up resources.
+        Args:
+            response_data: Raw JSON response from the cloud API
+
+        Returns:
+            ExecutionResult with parsed data
+        """
+
+        return ExecutionResult(
+            success=True,
+            data=response["result"],
+            meta=response.get("connector_metadata"),
+            error=None,
+        )
+
+    async def close(self):
+        """Close the cloud client and cleanup resources.
+
+        Call this when you're done using the executor to clean up HTTP connections.
 
         Example:
-            executor = HostedExecutor(
-                workspace_id="workspace-123",
-                connector_id="my-connector"
-            )
+            executor = HostedExecutor(...)
             try:
                 result = await executor.execute(config)
             finally:
-                executor.close()
+                await executor.close()
         """
-        self.client.close()
+        await self._cloud_client.close()

airbyte_agent_zendesk_support/_vendored/connector_sdk/http_client.py

@@ -147,6 +147,9 @@ class HTTPClient:
             self.base_url = self.base_url.replace(f"{{{var_name}}}", var_value)
 
         self.auth_config = auth_config
+        assert (
+            self.auth_config.type is not None
+        ), "auth_config.type cannot be None"  # Should never be None when instantiated via the local executor flow
         self.secrets = secrets
         self.logger = logger or NullLogger()
         self.metrics = HTTPMetrics()
@@ -296,12 +299,12 @@ class HTTPClient:
 
                         # Support both sync and async callbacks
                         callback_result = self.on_token_refresh(callback_data)
-                        if hasattr(callback_result, "__await__"):
+                        if callback_result is not None and hasattr(callback_result, "__await__"):
                             await callback_result
                     except Exception as callback_error:
                         self.logger.log_error(
                             request_id=None,
-                            error=("Token refresh callback failed during initialization: " f"{callback_error!s}"),
+                            error=(f"Token refresh callback failed during initialization: {callback_error!s}"),
                             status_code=None,
                         )
 
@@ -485,7 +488,7 @@ class HTTPClient:
                 elif "application/json" in content_type or not content_type:
                     response_data = await response.json()
                 else:
-                    error_msg = f"Expected JSON response for {method.upper()} {url}, " f"got content-type: {content_type}"
+                    error_msg = f"Expected JSON response for {method.upper()} {url}, got content-type: {content_type}"
                     raise HTTPClientError(error_msg)
 
             except ValueError as e:
@@ -556,6 +559,7 @@ class HTTPClient:
             current_token = self.secrets.get("access_token")
             strategy = AuthStrategyFactory.get_strategy(self.auth_config.type)
 
+            # Try to refresh credentials
             try:
                 result = await strategy.handle_auth_error(
                     status_code=status_code,
@@ -564,53 +568,56 @@ class HTTPClient:
                     config_values=self.config_values,
                     http_client=None,  # Let strategy create its own client
                 )
-
-                if result:
-                    # Notify callback if provided (for persistence)
-                    # Include both tokens AND extracted values for full persistence
-                    if self.on_token_refresh is not None:
-                        try:
-                            # Build callback data with both tokens and extracted values
-                            callback_data = dict(result.tokens)
-                            if result.extracted_values:
-                                callback_data.update(result.extracted_values)
-
-                            # Support both sync and async callbacks
-                            callback_result = self.on_token_refresh(callback_data)
-                            if hasattr(callback_result, "__await__"):
-                                await callback_result
-                        except Exception as callback_error:
-                            self.logger.log_error(
-                                request_id=request_id,
-                                error=f"Token refresh callback failed: {str(callback_error)}",
-                                status_code=status_code,
-                            )
-
-                    # Update secrets with new tokens (in-memory)
-                    self.secrets.update(result.tokens)
-
-                    # Update config_values and re-render base_url with extracted values
-                    if result.extracted_values:
-                        self._apply_token_extract(result.extracted_values)
-
-                    if self.secrets.get("access_token") != current_token:
-                        # Retry with new token - this will go through full retry logic
-                        return await self.request(
-                            method=method,
-                            path=path,
-                            params=params,
-                            json=json,
-                            data=data,
-                            headers=headers,
-                        )
-
             except Exception as refresh_error:
                 self.logger.log_error(
                     request_id=request_id,
                     error=f"Credential refresh failed: {str(refresh_error)}",
                     status_code=status_code,
                 )
+                result = None
+
+            # If refresh succeeded, update tokens and retry
+            if result:
+                # Notify callback if provided (for persistence)
+                # Include both tokens AND extracted values for full persistence
+                if self.on_token_refresh is not None:
+                    try:
+                        # Build callback data with both tokens and extracted values
+                        callback_data = dict(result.tokens)
+                        if result.extracted_values:
+                            callback_data.update(result.extracted_values)
+
+                        # Support both sync and async callbacks
+                        callback_result = self.on_token_refresh(callback_data)
+                        if callback_result is not None and hasattr(callback_result, "__await__"):
+                            await callback_result
+                    except Exception as callback_error:
+                        self.logger.log_error(
+                            request_id=request_id,
+                            error=f"Token refresh callback failed: {str(callback_error)}",
+                            status_code=status_code,
+                        )
+
+                # Update secrets with new tokens (in-memory)
+                self.secrets.update(result.tokens)
+
+                # Update config_values and re-render base_url with extracted values
+                if result.extracted_values:
+                    self._apply_token_extract(result.extracted_values)
 
+                if self.secrets.get("access_token") != current_token:
+                    # Retry with new token - this will go through full retry logic
+                    # Any errors from this retry will propagate to the caller
+                    return await self.request(
+                        method=method,
+                        path=path,
+                        params=params,
+                        json=json,
+                        data=data,
+                        headers=headers,
+                    )
+
+        # Refresh failed or token didn't change, log and let original error propagate
         self.logger.log_error(request_id=request_id, error=str(error), status_code=status_code)
 
     async def request(

airbyte_agent_zendesk_support/_vendored/connector_sdk/schema/base.py

@@ -8,6 +8,7 @@ References:
 
 from enum import StrEnum
 from typing import Dict, Optional
+from uuid import UUID
 
 from pydantic import BaseModel, ConfigDict, Field, field_validator
 from pydantic_core import Url
@@ -117,7 +118,7 @@ class Info(BaseModel):
 
     # Airbyte extension
     x_airbyte_connector_name: Optional[str] = Field(None, alias="x-airbyte-connector-name")
-    x_airbyte_connector_id: Optional[str] = Field(None, alias="x-airbyte-connector-id")
+    x_airbyte_connector_id: Optional[UUID] = Field(None, alias="x-airbyte-connector-id")
     x_airbyte_external_documentation_urls: list[DocUrl] = Field(..., alias="x-airbyte-external-documentation-urls")
     x_airbyte_retry_config: Optional[RetryConfig] = Field(None, alias="x-airbyte-retry-config")
     x_airbyte_example_questions: Optional[ExampleQuestions] = Field(None, alias="x-airbyte-example-questions")

airbyte_agent_zendesk_support/_vendored/connector_sdk/types.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 
 from enum import Enum
 from typing import Any
+from uuid import UUID
 
 from pydantic import BaseModel, ConfigDict, Field
 
@@ -230,6 +231,7 @@ class ConnectorModel(BaseModel):
 
     model_config = ConfigDict(use_enum_values=True)
 
+    id: UUID
     name: str
     version: str = OPENAPI_DEFAULT_VERSION
     base_url: str

airbyte_agent_zendesk_support/connector.py

@@ -205,10 +205,9 @@ class ZendeskSupportConnector:
     def __init__(
         self,
         auth_config: ZendeskSupportAuthConfig | None = None,
-        connector_id: str | None = None,
+        external_user_id: str | None = None,
         airbyte_client_id: str | None = None,
         airbyte_client_secret: str | None = None,
-        airbyte_connector_api_url: str | None = None,
         on_token_refresh: Any | None = None,
         subdomain: str | None = None    ):
         """
@@ -216,14 +215,13 @@ class ZendeskSupportConnector:
 
         Supports both local and hosted execution modes:
         - Local mode: Provide `auth_config` for direct API calls
-        - Hosted mode: Provide `connector_id`, `airbyte_client_id`, and `airbyte_client_secret` for hosted execution
+        - Hosted mode: Provide `external_user_id`, `airbyte_client_id`, and `airbyte_client_secret` for hosted execution
 
         Args:
             auth_config: Typed authentication configuration (required for local mode)
-            connector_id: Connector ID (required for hosted mode)
+            external_user_id: External user ID (required for hosted mode)
             airbyte_client_id: Airbyte OAuth client ID (required for hosted mode)
             airbyte_client_secret: Airbyte OAuth client secret (required for hosted mode)
-            airbyte_connector_api_url: Airbyte connector API URL (defaults to Airbyte Cloud API URL)
             on_token_refresh: Optional callback for OAuth2 token refresh persistence.
                 Called with new_tokens dict when tokens are refreshed. Can be sync or async.
                 Example: lambda tokens: save_to_database(tokens)            subdomain: Your Zendesk subdomain
@@ -232,7 +230,7 @@ class ZendeskSupportConnector:
             connector = ZendeskSupportConnector(auth_config=ZendeskSupportAuthConfig(access_token="...", refresh_token="..."))
             # Hosted mode (executed on Airbyte cloud)
             connector = ZendeskSupportConnector(
-                connector_id="connector-456",
+                external_user_id="user-123",
                 airbyte_client_id="client_abc123",
                 airbyte_client_secret="secret_xyz789"
             )
@@ -248,20 +246,20 @@ class ZendeskSupportConnector:
                 on_token_refresh=save_tokens
             )
         """
-        # Hosted mode: connector_id, airbyte_client_id, and airbyte_client_secret provided
-        if connector_id and airbyte_client_id and airbyte_client_secret:
+        # Hosted mode: external_user_id, airbyte_client_id, and airbyte_client_secret provided
+        if external_user_id and airbyte_client_id and airbyte_client_secret:
             from ._vendored.connector_sdk.executor import HostedExecutor
             self._executor = HostedExecutor(
-                connector_id=connector_id,
+                external_user_id=external_user_id,
                 airbyte_client_id=airbyte_client_id,
                 airbyte_client_secret=airbyte_client_secret,
-                api_url=airbyte_connector_api_url,
+                connector_definition_id=str(ZendeskSupportConnectorModel.id),
             )
         else:
             # Local mode: auth_config required
             if not auth_config:
                 raise ValueError(
-                    "Either provide (connector_id, airbyte_client_id, airbyte_client_secret) for hosted mode "
+                    "Either provide (external_user_id, airbyte_client_id, airbyte_client_secret) for hosted mode "
                     "or auth_config for local mode"
                 )
 

airbyte_agent_zendesk_support/connector_model.py

@@ -23,8 +23,12 @@ from ._vendored.connector_sdk.schema.security import (
 from ._vendored.connector_sdk.schema.components import (
     PathOverrideConfig,
 )
+from uuid import (
+    UUID,
+)
 
 ZendeskSupportConnectorModel: ConnectorModel = ConnectorModel(
+    id=UUID('79c1aa37-dae3-42ae-b333-d1c105477715'),
     name='zendesk-support',
     version='0.1.3',
     base_url='https://{subdomain}.zendesk.com/api/v2',

{airbyte_agent_zendesk_support-0.18.18.dist-info → airbyte_agent_zendesk_support-0.18.21.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: airbyte-agent-zendesk-support
-Version: 0.18.18
+Version: 0.18.21
 Summary: Airbyte Zendesk-Support Connector for AI platforms
 Project-URL: Homepage, https://github.com/airbytehq/airbyte-embedded
 Project-URL: Documentation, https://github.com/airbytehq/airbyte-embedded/tree/main/integrations
@@ -32,7 +32,7 @@ Requires-Dist: pyyaml>=6.0
 Requires-Dist: segment-analytics-python>=2.2.0
 Description-Content-Type: text/markdown
 
-# Airbyte Zendesk-Support AI Connector
+# Zendesk-Support agent connector
 
 Zendesk Support is a customer service platform that helps businesses manage support
 tickets, customer interactions, and help center content. This connector provides
@@ -41,7 +41,7 @@ triggers, macros, views, satisfaction ratings, SLA policies, and help center art
 for customer support analytics and service performance insights.
 
 
-## Example Questions
+## Example questions
 
 - Show me the tickets assigned to me last week
 - What are the top 5 support issues our organization has faced this month?
@@ -52,7 +52,7 @@ for customer support analytics and service performance insights.
 - Identify the most common ticket fields used in our support workflow
 - Summarize the performance of our SLA policies this quarter
 
-## Unsupported Questions
+## Unsupported questions
 
 - Create a new support ticket for [customerX]
 - Update the priority of this ticket
@@ -77,10 +77,12 @@ connector = ZendeskSupportConnector(
     refresh_token="..."
   )
 )
-result = connector.tickets.list()
+result = await connector.tickets.list()
 ```
 
-## Documentation
+## Full documentation
+
+This connector supports the following entities and actions.
 
 | Entity | Actions |
 |--------|---------|
@@ -108,14 +110,12 @@ result = connector.tickets.list()
 | Article Attachments | [List](./REFERENCE.md#article-attachments-list), [Get](./REFERENCE.md#article-attachments-get), [Download](./REFERENCE.md#article-attachments-download) |
 
 
-For detailed documentation on available actions and parameters, see [REFERENCE.md](./REFERENCE.md).
-
-For the service's official API docs, see [Zendesk-Support API Reference](https://developer.zendesk.com/api-reference/ticketing/introduction/).
-
-## Version Information
+For detailed documentation on available actions and parameters, see this connector's [full reference documentation](./REFERENCE.md).
 
-**Package Version:** 0.18.18
+For the service's official API docs, see the [Zendesk-Support API reference](https://developer.zendesk.com/api-reference/ticketing/introduction/).
 
-**Connector Version:** 0.1.3
+## Version information
 
-**Generated with connector-sdk:** c4c39c2797ecd929407c9417c728d425f77b37ed
+- **Package version:** 0.18.21
+- **Connector version:** 0.1.3
+- **Generated with Connector SDK commit SHA:** f7c55d3e3cdc7568cab2da9d736285eec58f044b

{airbyte_agent_zendesk_support-0.18.18.dist-info → airbyte_agent_zendesk_support-0.18.21.dist-info}/RECORD

@@ -1,23 +1,25 @@
 airbyte_agent_zendesk_support/__init__.py,sha256=MPz4HU055DRA3-1qgbGXh2E0YHmhcexQCFl-Tz21gm4,6227
-airbyte_agent_zendesk_support/connector.py,sha256=-LPmn1PIRQXv88xHRvBMs4mKXhxQqfOQwN5sT_ay3hU,63971
-airbyte_agent_zendesk_support/connector_model.py,sha256=Ccfavcm8fqVUB6orIrkBxbOIQDtsLUvDSncyrwNkvAU,241047
+airbyte_agent_zendesk_support/connector.py,sha256=7AYDMDbkygncAVYtxo0q880C6SrVZQhaCvK8p0bKiOQ,63878
+airbyte_agent_zendesk_support/connector_model.py,sha256=q-rn6aRvFt4H-neQ1HQRX7oq2MDEJY7MMuSaEAhGYCk,241131
 airbyte_agent_zendesk_support/models.py,sha256=31bsOmf4nBdf8EXN3JpYzXW8mx6gv1xaZjeuEBgSzws,36399
 airbyte_agent_zendesk_support/types.py,sha256=3CxJ8HosRMyzNEbVmRbybNCTVj9Ycxr7io25TP3YcCQ,6337
 airbyte_agent_zendesk_support/_vendored/__init__.py,sha256=ILl7AHXMui__swyrjxrh9yRa4dLiwBvV6axPWFWty80,38
 airbyte_agent_zendesk_support/_vendored/connector_sdk/__init__.py,sha256=T5o7roU6NSpH-lCAGZ338sE5dlh4ZU6i6IkeG1zpems,1949
 airbyte_agent_zendesk_support/_vendored/connector_sdk/auth_strategies.py,sha256=0BfIISVzuvZTAYZjQFOOhKTpw0QuKDlLQBQ1PQo-V2M,39967
 airbyte_agent_zendesk_support/_vendored/connector_sdk/auth_template.py,sha256=vKnyA21Jp33EuDjkIUAf1PGicwk4t9kZAPJuAgAZKzU,4458
-airbyte_agent_zendesk_support/_vendored/connector_sdk/connector_model_loader.py,sha256=OEaXMI8lhjH-vAPfgaefrSijZJfttNqC6Ee3u2apYnA,33901
+airbyte_agent_zendesk_support/_vendored/connector_sdk/connector_model_loader.py,sha256=BeX4QykMUQZk5qY--WuwxXClI7FBDxxbGguqcztAd8A,34663
 airbyte_agent_zendesk_support/_vendored/connector_sdk/constants.py,sha256=uH4rjBX6WsBP8M0jt7AUJI9w5Adn4wvJwib7Gdfkr1M,2736
 airbyte_agent_zendesk_support/_vendored/connector_sdk/exceptions.py,sha256=ss5MGv9eVPmsbLcLWetuu3sDmvturwfo6Pw3M37Oq5k,481
 airbyte_agent_zendesk_support/_vendored/connector_sdk/extensions.py,sha256=iWA2i0kiiGZY84H8P25A6QmfbuZwu7euMcj4-Vx2DOQ,20185
-airbyte_agent_zendesk_support/_vendored/connector_sdk/http_client.py,sha256=Uv86Hye3uIs2F4TbXXFWnB4E6BHfvJQLBwak7J1_0kw,27073
+airbyte_agent_zendesk_support/_vendored/connector_sdk/http_client.py,sha256=NdccrrBHI5rW56XnXcP54arCwywIVKnMeSQPas6KlOM,27466
 airbyte_agent_zendesk_support/_vendored/connector_sdk/secrets.py,sha256=UWcO9fP-vZwcfkAuvlZahlOCTOwdNN860BIwe8X4jxw,6868
-airbyte_agent_zendesk_support/_vendored/connector_sdk/types.py,sha256=1yz4O8wjL5Aytzz0duluxJZ7ntEFIBlA4_6XSAlizpE,8079
+airbyte_agent_zendesk_support/_vendored/connector_sdk/types.py,sha256=sS9olOyT-kVemHmcFll2ePFRhTdGMbWcz7bSgV-MuSw,8114
 airbyte_agent_zendesk_support/_vendored/connector_sdk/utils.py,sha256=G4LUXOC2HzPoND2v4tQW68R9uuPX9NQyCjaGxb7Kpl0,1958
 airbyte_agent_zendesk_support/_vendored/connector_sdk/validation.py,sha256=CDjCux1eg35a0Y4BegSivzIwZjiTqOxYWotWNLqTSVU,31792
+airbyte_agent_zendesk_support/_vendored/connector_sdk/cloud_utils/__init__.py,sha256=4799Hv9f2zxDVj1aLyQ8JpTEuFTp_oOZMRz-NZCdBJg,134
+airbyte_agent_zendesk_support/_vendored/connector_sdk/cloud_utils/client.py,sha256=HoDgZuEgGHj78P-BGwUf6HGPVWynbdKjGOmjb-JDk58,7188
 airbyte_agent_zendesk_support/_vendored/connector_sdk/executor/__init__.py,sha256=EmG9YQNAjSuYCVB4D5VoLm4qpD1KfeiiOf7bpALj8p8,702
-airbyte_agent_zendesk_support/_vendored/connector_sdk/executor/hosted_executor.py,sha256=FXlV4JgYbYMHVHMbeMH8LOdhsXuw-flEJjHXf7JmMtc,6756
+airbyte_agent_zendesk_support/_vendored/connector_sdk/executor/hosted_executor.py,sha256=YQ-qfT7PZh9izNFHHe7SAcETiZOKrWjTU-okVb0_VL8,7079
 airbyte_agent_zendesk_support/_vendored/connector_sdk/executor/local_executor.py,sha256=hHlBTtvykrUcfypzyW0e61fU4e3vlxc90mypCFzgSl0,61879
 airbyte_agent_zendesk_support/_vendored/connector_sdk/executor/models.py,sha256=lYVT_bNcw-PoIks4WHNyl2VY-lJVf2FntzINSOBIheE,5845
 airbyte_agent_zendesk_support/_vendored/connector_sdk/http/__init__.py,sha256=y8fbzZn-3yV9OxtYz8Dy6FFGI5v6TOqADd1G3xHH3Hw,911
@@ -38,7 +40,7 @@ airbyte_agent_zendesk_support/_vendored/connector_sdk/performance/__init__.py,sh
 airbyte_agent_zendesk_support/_vendored/connector_sdk/performance/instrumentation.py,sha256=_dXvNiqdndIBwDjeDKNViWzn_M5FkSUsMmJtFldrmsM,1504
 airbyte_agent_zendesk_support/_vendored/connector_sdk/performance/metrics.py,sha256=3-wPwlJyfVLUIG3y7ESxk0avhkILk3z8K7zSrnlZf5U,2833
 airbyte_agent_zendesk_support/_vendored/connector_sdk/schema/__init__.py,sha256=Uymu-QuzGJuMxexBagIvUxpVAigIuIhz3KeBl_Vu4Ko,1638
-airbyte_agent_zendesk_support/_vendored/connector_sdk/schema/base.py,sha256=le4UqbUrPFtWxIwmoTAyS0chYFO5ksEMYDyrkK5ORlI,4776
+airbyte_agent_zendesk_support/_vendored/connector_sdk/schema/base.py,sha256=eN6YfHwsYNz_0CE-S715Me8x3gQWTtaRk1vhFjEZF8I,4799
 airbyte_agent_zendesk_support/_vendored/connector_sdk/schema/components.py,sha256=2ivMNhUAcovw88qvDkW221ILf1L63eXteztTDZL46us,7989
 airbyte_agent_zendesk_support/_vendored/connector_sdk/schema/connector.py,sha256=VFBOzIkLgYBR1XUTmyrPGqBkX8PP-zsG8avQcdJUqXs,3864
 airbyte_agent_zendesk_support/_vendored/connector_sdk/schema/extensions.py,sha256=LdoCuMLNdCj68O47qAL4v8xmqGz5tJgRiNZL5JnL9uw,3311
@@ -48,6 +50,6 @@ airbyte_agent_zendesk_support/_vendored/connector_sdk/telemetry/__init__.py,sha2
 airbyte_agent_zendesk_support/_vendored/connector_sdk/telemetry/config.py,sha256=tLmQwAFD0kP1WyBGWBS3ysaudN9H3e-3EopKZi6cGKg,885
 airbyte_agent_zendesk_support/_vendored/connector_sdk/telemetry/events.py,sha256=NvqjlUbkm6cbGh4ffKxYxtjdwwgzfPF4MKJ2GfgWeFg,1285
 airbyte_agent_zendesk_support/_vendored/connector_sdk/telemetry/tracker.py,sha256=KacNdbHatvPPhnNrycp5YUuD5xpkp56AFcHd-zguBgk,5247
-airbyte_agent_zendesk_support-0.18.18.dist-info/METADATA,sha256=uAItn1WzsX2GEGSNlKnufbWc-jJoFJ4Et1JF6sVvDlE,5510
-airbyte_agent_zendesk_support-0.18.18.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-airbyte_agent_zendesk_support-0.18.18.dist-info/RECORD,,
+airbyte_agent_zendesk_support-0.18.21.dist-info/METADATA,sha256=h_eKn-nbGYB3MCSchx0bZNgcJcpCCSKAImsE8EQwnSA,5629
+airbyte_agent_zendesk_support-0.18.21.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+airbyte_agent_zendesk_support-0.18.21.dist-info/RECORD,,