wiil-python 0.0.3__py3-none-any.whl → 0.0.5__py3-none-any.whl

wiil/client/http_client.py

@@ -181,9 +181,9 @@ class HttpClient:
             try:
                 if isinstance(data, dict):
                     validated_data = schema(**data)
-                    data = validated_data.model_dump(exclude_none=True)
+                    data = validated_data.model_dump(by_alias=True, exclude_none=True)
                 elif isinstance(data, BaseModel):
-                    data = data.model_dump(exclude_none=True)
+                    data = data.model_dump(by_alias=True, exclude_none=True)
             except ValidationError as e:
                 raise WiilValidationError(
                     'Request validation failed',
@@ -275,9 +275,9 @@ class HttpClient:
             try:
                 if isinstance(data, dict):
                     validated_data = schema(**data)
-                    data = validated_data.model_dump(exclude_none=True)
+                    data = validated_data.model_dump(by_alias=True, exclude_none=True)
                 elif isinstance(data, BaseModel):
-                    data = data.model_dump(exclude_none=True)
+                    data = data.model_dump(by_alias=True, exclude_none=True)
             except ValidationError as e:
                 raise WiilValidationError(
                     'Request validation failed',
@@ -369,9 +369,9 @@ class HttpClient:
             try:
                 if isinstance(data, dict):
                     validated_data = schema(**data)
-                    data = validated_data.model_dump(exclude_none=True)
+                    data = validated_data.model_dump(by_alias=True, exclude_none=True)
                 elif isinstance(data, BaseModel):
-                    data = data.model_dump(exclude_none=True)
+                    data = data.model_dump(by_alias=True, exclude_none=True)
             except ValidationError as e:
                 raise WiilValidationError(
                     'Request validation failed',

wiil/models/business_mgt/service_appointment.py

@@ -6,7 +6,7 @@ calendar integration and service provider assignment.
 
 from typing import Optional
 
-from pydantic import BaseModel as PydanticBaseModel
+from pydantic import BaseModel as PydanticBaseModel
 from pydantic import ConfigDict, EmailStr, Field
 
 from wiil.models.base import BaseModel
@@ -154,12 +154,9 @@ class CreateServiceAppointment(PydanticBaseModel):
         create_data = CreateServiceAppointment(
             business_service_id="service_123",
             customer_id="cust_456",
-            customer_name="Jane Smith",
-            customer_email="jane@example.com",
             start_time=1234567890,
             duration=45,
-            total_price=75.00,
-            status=AppointmentStatus.PENDING
+            total_price=75.00
         )
         ```
     """
@@ -172,19 +169,15 @@ class CreateServiceAppointment(PydanticBaseModel):
 
     business_service_id: str = Field(..., alias="businessServiceId")
     customer_id: str = Field(..., alias="customerId")
-    customer_name: Optional[str] = Field(None, alias="customerName")
-    customer_email: Optional[EmailStr] = Field(None, alias="customerEmail")
     start_time: int = Field(..., alias="startTime")
     end_time: Optional[int] = Field(None, alias="endTime")
-    duration: Optional[int] = Field(30, gt=0)
-    total_price: Optional[float] = Field(0.0, ge=0, alias="totalPrice")
+    duration: Optional[int] = Field(None, gt=0)
+    total_price: Optional[float] = Field(None, ge=0, alias="totalPrice")
     deposit_paid: float = Field(0.0, ge=0, alias="depositPaid")
-    status: AppointmentStatus = AppointmentStatus.PENDING
     assigned_user_account_id: Optional[str] = Field(None, alias="assignedUserAccountId")
     calendar_id: Optional[str] = Field(None, alias="calendarId")
     calendar_event_id: Optional[str] = Field(None, alias="calendarEventId")
     calendar_provider: Optional[CalendarProvider] = Field(None, alias="calendarProvider")
-    service_conversation_config_id: Optional[str] = Field(None, alias="serviceConversationConfigId")
 
 
 class UpdateServiceAppointment(PydanticBaseModel):
@@ -196,7 +189,6 @@ class UpdateServiceAppointment(PydanticBaseModel):
         ```python
         update_data = UpdateServiceAppointment(
             id="appt_123",
-            status=AppointmentStatus.COMPLETED,
             end_time=1234567950
         )
         ```
@@ -211,17 +203,13 @@ class UpdateServiceAppointment(PydanticBaseModel):
     id: str
     business_service_id: Optional[str] = Field(None, alias="businessServiceId")
     customer_id: Optional[str] = Field(None, alias="customerId")
-    customer_name: Optional[str] = Field(None, alias="customerName")
-    customer_email: Optional[EmailStr] = Field(None, alias="customerEmail")
     start_time: Optional[int] = Field(None, alias="startTime")
     end_time: Optional[int] = Field(None, alias="endTime")
     duration: Optional[int] = Field(None, gt=0)
     total_price: Optional[float] = Field(None, ge=0, alias="totalPrice")
     deposit_paid: Optional[float] = Field(None, ge=0, alias="depositPaid")
-    status: Optional[AppointmentStatus] = None
     assigned_user_account_id: Optional[str] = Field(None, alias="assignedUserAccountId")
     calendar_id: Optional[str] = Field(None, alias="calendarId")
     calendar_event_id: Optional[str] = Field(None, alias="calendarEventId")
     calendar_provider: Optional[CalendarProvider] = Field(None, alias="calendarProvider")
     cancel_reason: Optional[str] = Field(None, alias="cancelReason")
-    service_conversation_config_id: Optional[str] = Field(None, alias="serviceConversationConfigId")

wiil/resources/service_mgt/__init__.py

@@ -19,9 +19,18 @@ from wiil.resources.service_mgt.translation_sessions import TranslationSessionsR
 from wiil.resources.service_mgt.knowledge_sources import KnowledgeSourcesResource
 from wiil.resources.service_mgt.support_models import SupportModelsResource
 from wiil.resources.service_mgt.telephony_provider import TelephonyProviderResource
-from wiil.resources.service_mgt.dynamic_agent_status import DynamicAgentStatusResource
-from wiil.resources.service_mgt.dynamic_web_agent import DynamicWebAgentResource
-from wiil.resources.service_mgt.dynamic_phone_agent import DynamicPhoneAgentResource
+from wiil.resources.service_mgt.dynamic_agent_status import (
+    DynamicAgentStatusResource,
+    PollTimeoutError,
+)
+from wiil.resources.service_mgt.dynamic_web_agent import (
+    DynamicWebAgentResource,
+    WebAgentCreateOptions,
+)
+from wiil.resources.service_mgt.dynamic_phone_agent import (
+    DynamicPhoneAgentResource,
+    PhoneAgentCreateOptions,
+)
 
 __all__ = [
     'AgentConfigurationsResource',
@@ -36,6 +45,9 @@ __all__ = [
     'SupportModelsResource',
     'TelephonyProviderResource',
     'DynamicAgentStatusResource',
+    'PollTimeoutError',
     'DynamicWebAgentResource',
+    'WebAgentCreateOptions',
     'DynamicPhoneAgentResource',
+    'PhoneAgentCreateOptions',
 ]

wiil/resources/service_mgt/dynamic_agent_status.py

@@ -2,10 +2,19 @@
 
 from wiil.client.http_client import HttpClient
 from wiil.models.service_mgt.dynamic_setup import (
+    DynamicAgentProcessingState,
     DynamicAgentSetupResult,
 )
 
 
+class PollTimeoutError(Exception):
+    """Raised when polling times out before completion."""
+
+    def __init__(self, message: str, last_state: DynamicAgentProcessingState):
+        super().__init__(message)
+        self.last_state = last_state
+
+
 class DynamicAgentStatusResource:
     """Resource class for checking dynamic agent setup status.
 
@@ -32,4 +41,4 @@ class DynamicAgentStatusResource:
         )
 
 
-__all__ = ['DynamicAgentStatusResource']
+__all__ = ['DynamicAgentStatusResource', 'PollTimeoutError']

wiil/resources/service_mgt/dynamic_phone_agent.py

@@ -1,74 +1,190 @@
-"""Dynamic Phone Agent resource for managing phone agent configurations."""
+"""Dynamic Phone Agent resource for phone-based AI agents."""
 
-from typing import Any, Dict, Optional
-from urllib.parse import urlencode
+import time
+from dataclasses import dataclass
+from typing import Callable, Optional
 
 from wiil.client.http_client import HttpClient
+from wiil.errors import WiilValidationError
 from wiil.models.service_mgt.dynamic_setup import (
+    DynamicAgentProcessingState,
     DynamicPhoneAgentSetup,
     DynamicPhoneAgentSetupResult,
+    DynamicSTTModelConfiguration,
+    DynamicTTSModelConfiguration,
     UpdateDynamicPhoneAgent,
 )
-from wiil.types import PaginatedResult, PaginationRequest
+from wiil.resources.service_mgt.dynamic_agent_status import PollTimeoutError
+
+
+@dataclass
+class PhoneAgentCreateOptions:
+    """Options for configuring agent creation behavior."""
+
+    poll_until_complete: bool = True
+    """Whether to poll until setup completes."""
+
+    poll_interval: float = 5.0
+    """Polling interval in seconds."""
+
+    poll_timeout: float = 120.0
+    """Maximum wait time in seconds before timing out."""
+
+    on_progress: Optional[Callable[[DynamicAgentProcessingState], None]] = None
+    """Callback invoked on each poll with the current processing state."""
+
+    silent: bool = False
+    """Whether to suppress console logging."""
 
 
 class DynamicPhoneAgentResource:
-    """Resource class for managing dynamic phone agents in the WIIL Platform.
+    """Resource class for managing dynamic phone agent provisioning.
+
+    Provides methods for creating and updating dynamic phone agent
+    configurations. Dynamic phone agents enable AI-powered phone
+    interactions with configurable STT and TTS capabilities.
 
-    Provides methods for creating, retrieving, updating, deleting, and listing
-    dynamic phone agent configurations. Phone agents are deployed on telephony
-    channels for voice-based customer interactions.
+    Example:
+        >>> from wiil.models.type_definitions import (
+        ...     AgentCapabilities,
+        ...     AgentRoleTemplateIdentifier,
+        ... )
+        >>>
+        >>> client = WiilClient(api_key='your-api-key')
+        >>>
+        >>> # Create with polling (waits for completion)
+        >>> result = client.dynamic_phone_agent.create(
+        ...     DynamicPhoneAgentSetup(
+        ...         assistant_name='Alex',
+        ...         capabilities=[AgentCapabilities.APPOINTMENT_MANAGEMENT],
+        ...         role_template_identifier=(
+        ...             AgentRoleTemplateIdentifier.CUSTOMER_SUPPORT_GENERAL
+        ...         ),
+        ...     )
+        ... )
+        >>>
+        >>> # Create without waiting
+        >>> result = client.dynamic_phone_agent.create(
+        ...     data,
+        ...     options=PhoneAgentCreateOptions(poll_until_complete=False)
+        ... )
     """
 
     def __init__(self, http: HttpClient):
         self._http = http
-        self._base_path = '/dynamic-phone-agent'
+        self._base_path = '/dynamic-setup/phone-agent'
+        self._status_path = '/dynamic-setup'
 
     def create(
         self,
-        data: DynamicPhoneAgentSetup
+        data: DynamicPhoneAgentSetup,
+        options: Optional[PhoneAgentCreateOptions] = None
     ) -> DynamicPhoneAgentSetupResult:
-        """Create a new dynamic phone agent.
+        """Create and provision a new dynamic phone agent.
 
         Args:
-            data: Phone agent setup data
+            data: Phone agent configuration data
+            options: Creation options for polling and logging behavior
 
         Returns:
-            The setup result with processing status
+            The setup result including provisioned phone number
+
+        Raises:
+            WiilValidationError: When validation fails or model not supported
+            WiilAPIError: When the API returns an error
+            PollTimeoutError: When polling times out before completion
         """
-        return self._http.post(
+        opts = options or PhoneAgentCreateOptions()
+        start_time = time.time()
+        agent_name = data.assistant_name
+
+        # Validate model configurations before proceeding
+        self._validate_model_configurations(
+            data.stt_configuration,
+            data.tts_configuration
+        )
+
+        # Log initial creation
+        if not opts.silent:
+            self._log(f'Creating agent "{agent_name}"...')
+
+        # Create the agent
+        initial_result = self._http.post(
             self._base_path,
             data.model_dump(by_alias=True, exclude_none=True),
             schema=DynamicPhoneAgentSetup,
             response_model=DynamicPhoneAgentSetupResult
         )
 
-    def get(self, agent_id: str) -> DynamicPhoneAgentSetupResult:
-        """Retrieve a dynamic phone agent by ID.
+        # If not polling, return immediately
+        if not opts.poll_until_complete:
+            if not opts.silent:
+                self._log(f'Setup initiated (ID: {initial_result.id})')
+            return initial_result
 
-        Args:
-            agent_id: Phone agent ID
+        # Check if already complete
+        if initial_result.processing_state.status in ('completed', 'failed'):
+            self._log_final_result(initial_result, start_time, opts.silent)
+            return initial_result
 
-        Returns:
-            The phone agent setup result
-        """
-        return self._http.get(
-            f'{self._base_path}/{agent_id}',
-            response_model=DynamicPhoneAgentSetupResult
-        )
+        # Poll until complete
+        while True:
+            result = self._http.get(
+                f'{self._status_path}/{initial_result.id}',
+                response_model=DynamicPhoneAgentSetupResult
+            )
+            last_state = result.processing_state
+
+            # Log progress
+            if not opts.silent:
+                self._log_progress(last_state)
+
+            # Invoke callback
+            if opts.on_progress:
+                opts.on_progress(last_state)
+
+            # Check for terminal states
+            if last_state.status in ('completed', 'failed'):
+                self._log_final_result(result, start_time, opts.silent)
+                return result
+
+            # Check for timeout
+            elapsed = time.time() - start_time
+            if elapsed >= opts.poll_timeout:
+                if not opts.silent:
+                    self._log(f'Timeout after {self._format_duration(elapsed)}')
+                msg = (
+                    f'Polling timed out after {opts.poll_timeout}s. '
+                    f'Last status: {last_state.status} '
+                    f'at {last_state.progress_percentage}%'
+                )
+                raise PollTimeoutError(msg, last_state)
+
+            # Wait before next poll
+            time.sleep(opts.poll_interval)
 
     def update(
         self,
         data: UpdateDynamicPhoneAgent
     ) -> DynamicPhoneAgentSetupResult:
-        """Update an existing dynamic phone agent.
+        """Update an existing dynamic phone agent configuration.
 
         Args:
             data: Phone agent update data (must include id)
 
         Returns:
             The updated phone agent setup result
+
+        Raises:
+            WiilValidationError: When input validation fails
+            WiilAPIError: When phone agent is not found or API error
         """
+        # Validate model configurations before proceeding
+        self._validate_model_configurations(
+            data.stt_configuration,
+            data.tts_configuration
+        )
+
         return self._http.patch(
             self._base_path,
             data.model_dump(by_alias=True, exclude_none=True),
@@ -76,39 +192,121 @@ class DynamicPhoneAgentResource:
             response_model=DynamicPhoneAgentSetupResult
         )
 
-    def delete(self, agent_id: str) -> bool:
-        """Delete a dynamic phone agent.
+    def _validate_model_configurations(
+        self,
+        stt_config: Optional[DynamicSTTModelConfiguration],
+        tts_config: Optional[DynamicTTSModelConfiguration]
+    ) -> None:
+        """Validate STT and TTS model configs against support registry."""
+        has_stt = (
+            stt_config
+            and stt_config.provider_type
+            and stt_config.provider_model_id
+        )
+        if has_stt:
+            self._validate_model(
+                stt_config.provider_type,
+                stt_config.provider_model_id,
+                'STT'
+            )
 
-        Args:
-            agent_id: Phone agent ID
+        has_tts = (
+            tts_config
+            and tts_config.provider_type
+            and tts_config.provider_model_id
+        )
+        if has_tts:
+            self._validate_model(
+                tts_config.provider_type,
+                tts_config.provider_model_id,
+                'TTS'
+            )
 
-        Returns:
-            True if deletion was successful
-        """
-        return self._http.delete(f'{self._base_path}/{agent_id}')
+    def _validate_model(
+        self,
+        provider_type: str,
+        provider_model_id: str,
+        model_type: str
+    ) -> None:
+        """Validate a single model against the support registry."""
+        is_supported = self._http.get(
+            f'/support-models/supports/{provider_type}/{provider_model_id}',
+            response_model=bool
+        )
+
+        if not is_supported:
+            msg = (
+                f'Unsupported {model_type} model: '
+                f'{provider_type}/{provider_model_id}. '
+                f'Verify the model is available in the support registry.'
+            )
+            raise WiilValidationError(msg)
+
+    def _log(self, message: str) -> None:
+        """Log a message with agent context."""
+        print(f'[Phone Agent] {message}')
 
-    def list(
+    def _log_progress(self, state: DynamicAgentProcessingState) -> None:
+        """Log progress with a visual progress bar."""
+        bar = self._create_progress_bar(state.progress_percentage)
+        status_msg = state.message or self._get_status_message(state.status)
+        pct = state.progress_percentage
+        print(f'[Phone Agent] {bar} {pct}% | {status_msg}')
+
+    def _log_final_result(
         self,
-        params: Optional[PaginationRequest] = None
-    ) -> PaginatedResult[DynamicPhoneAgentSetupResult]:
-        """List dynamic phone agents with pagination.
+        result: DynamicPhoneAgentSetupResult,
+        start_time: float,
+        silent: bool
+    ) -> None:
+        """Log the final result with summary."""
+        if silent:
+            return
 
-        Args:
-            params: Pagination parameters
+        elapsed = time.time() - start_time
+        duration = self._format_duration(elapsed)
 
-        Returns:
-            Paginated list of phone agent setup results
-        """
-        query_params: Dict[str, Any] = {}
-        if params:
-            query_params['page'] = params.page
-            query_params['pageSize'] = params.page_size
-
-        query_string = f'?{urlencode(query_params)}' if query_params else ''
-        return self._http.get(
-            f'{self._base_path}{query_string}',
-            response_model=PaginatedResult[DynamicPhoneAgentSetupResult]
+        is_success = (
+            result.processing_state.status == 'completed' and result.success
         )
+        if is_success:
+            bar = self._create_progress_bar(100)
+            print(f'[Phone Agent] {bar} 100% | Setup complete')
+            print(f'[Phone Agent] Ready in {duration}')
+            if result.phone_number:
+                print(f'  -> Phone: {result.phone_number}')
+            if result.agent_configuration_id:
+                print(f'  -> Agent ID: {result.agent_configuration_id}')
+            if result.instruction_configuration_id:
+                inst_id = result.instruction_configuration_id
+                print(f'  -> Instruction ID: {inst_id}')
+        else:
+            print(f'[Phone Agent] Setup failed after {duration}')
+            if result.error_message:
+                print(f'  -> Error: {result.error_message}')
+
+    def _create_progress_bar(self, percentage: int) -> str:
+        """Create a visual progress bar."""
+        total = 20
+        filled = round((percentage / 100) * total)
+        empty = total - filled
+        return '█' * filled + '░' * empty
+
+    def _get_status_message(self, status: str) -> str:
+        """Get a human-readable status message."""
+        messages = {
+            'pending': 'Initializing...',
+            'in_progress': 'Processing...',
+            'completed': 'Setup complete',
+            'failed': 'Setup failed',
+        }
+        return messages.get(status, status)
+
+    def _format_duration(self, seconds: float) -> str:
+        """Format duration in human-readable form."""
+        if seconds < 1:
+            return f'{int(seconds * 1000)}ms'
+        return f'{seconds:.1f}s'
 
 
-__all__ = ['DynamicPhoneAgentResource']
+__all__ = ['DynamicPhoneAgentResource', 'PhoneAgentCreateOptions']