codemie-sdk-python 0.1.275__py3-none-any.whl → 0.1.289__py3-none-any.whl

codemie_sdk/__init__.py

@@ -73,10 +73,33 @@ from .models.vendor_guardrail import (
     VendorGuardrailInstallResponse,
     VendorGuardrailUninstallResponse,
 )
+from .models.guardrails import (
+    GuardrailAssignmentSetting,
+    GuardrailAssignmentEntity,
+    GuardrailAssignmentRequest,
+    GuardrailAssignmentResponse,
+)
+from .models.analytics import (
+    ResponseMetadata,
+    PaginationMetadata,
+    ColumnDefinition,
+    Metric,
+    SummariesData,
+    TabularData,
+    UserListItem,
+    UsersListData,
+    SummariesResponse,
+    TabularResponse,
+    UsersListResponse,
+    AnalyticsQueryParams,
+    PaginatedAnalyticsQueryParams,
+)
 from .services.vendor_assistant import VendorAssistantService
 from .services.vendor_workflow import VendorWorkflowService
 from .services.vendor_knowledgebase import VendorKnowledgeBaseService
 from .services.vendor_guardrail import VendorGuardrailService
+from .services.codemie_guardrails import CodemieGuardrailService
+from .services.analytics import AnalyticsService
 
 __version__ = "0.2.12"
 __all__ = [
@@ -132,4 +155,23 @@ __all__ = [
     "VendorGuardrailInstallResponse",
     "VendorGuardrailUninstallResponse",
     "VendorGuardrailService",
+    "GuardrailAssignmentSetting",
+    "GuardrailAssignmentEntity",
+    "GuardrailAssignmentRequest",
+    "GuardrailAssignmentResponse",
+    "CodemieGuardrailService",
+    "ResponseMetadata",
+    "PaginationMetadata",
+    "ColumnDefinition",
+    "Metric",
+    "SummariesData",
+    "TabularData",
+    "UserListItem",
+    "UsersListData",
+    "SummariesResponse",
+    "TabularResponse",
+    "UsersListResponse",
+    "AnalyticsQueryParams",
+    "PaginatedAnalyticsQueryParams",
+    "AnalyticsService",
 ]

codemie_sdk/client/client.py

@@ -3,6 +3,8 @@
 from typing import Optional
 
 from ..auth.credentials import KeycloakCredentials
+from ..services.admin import AdminService
+from ..services.analytics import AnalyticsService
 from ..services.assistant import AssistantService
 from ..services.conversation import ConversationService
 from ..services.datasource import DatasourceService
@@ -17,6 +19,7 @@ from ..services.vendor_assistant import VendorAssistantService
 from ..services.vendor_workflow import VendorWorkflowService
 from ..services.vendor_knowledgebase import VendorKnowledgeBaseService
 from ..services.vendor_guardrail import VendorGuardrailService
+from ..services.codemie_guardrails import CodemieGuardrailService
 
 
 class CodeMieClient:
@@ -69,6 +72,10 @@ class CodeMieClient:
         self._token = "" if self._is_localhost else self.auth.get_token()
 
         # Initialize services with verify_ssl parameter and token
+        self.admin = AdminService(self._api_domain, self._token, verify_ssl=verify_ssl)
+        self.analytics = AnalyticsService(
+            self._api_domain, self._token, verify_ssl=verify_ssl
+        )
         self.assistants = AssistantService(
             self._api_domain, self._token, verify_ssl=verify_ssl
         )
@@ -105,6 +112,9 @@ class CodeMieClient:
         self.vendor_guardrails = VendorGuardrailService(
             self._api_domain, self._token, verify_ssl=self._verify_ssl
         )
+        self.codemie_guardrails = CodemieGuardrailService(
+            self._api_domain, self._token, verify_ssl=self._verify_ssl
+        )
 
     @property
     def token(self) -> str:
@@ -128,6 +138,12 @@ class CodeMieClient:
         """Force token refresh."""
         self._token = "" if self._is_localhost else self.auth.get_token()
         # Update token in services
+        self.admin = AdminService(
+            self._api_domain, self._token, verify_ssl=self._verify_ssl
+        )
+        self.analytics = AnalyticsService(
+            self._api_domain, self._token, verify_ssl=self._verify_ssl
+        )
         self.assistants = AssistantService(
             self._api_domain, self._token, verify_ssl=self._verify_ssl
         )
@@ -170,4 +186,7 @@ class CodeMieClient:
         self.vendor_guardrails = VendorGuardrailService(
             self._api_domain, self._token, verify_ssl=self._verify_ssl
         )
+        self.codemie_guardrails = CodemieGuardrailService(
+            self._api_domain, self._token, verify_ssl=self._verify_ssl
+        )
         return self._token

codemie_sdk/models/admin.py

@@ -0,0 +1,28 @@
+"""Admin models for managing applications/projects."""
+
+from typing import List
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class ApplicationsListResponse(BaseModel):
+    """Response model for list applications endpoint."""
+
+    model_config = ConfigDict(extra="ignore")
+
+    applications: List[str] = Field(..., description="List of application names")
+
+
+class ApplicationCreateRequest(BaseModel):
+    """Request model for creating an application/project."""
+
+    model_config = ConfigDict(extra="ignore")
+
+    name: str = Field(..., description="Application/project name")
+
+
+class ApplicationCreateResponse(BaseModel):
+    """Response model for create application endpoint."""
+
+    model_config = ConfigDict(extra="ignore")
+
+    message: str = Field(..., description="Created application name")

codemie_sdk/models/analytics.py

@@ -0,0 +1,148 @@
+"""Models for analytics-related data structures."""
+
+from typing import Any, Dict, List, Optional
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class ResponseMetadata(BaseModel):
+    """Metadata for analytics responses."""
+
+    model_config = ConfigDict(extra="ignore")
+
+    timestamp: str = Field(description="ISO 8601 timestamp when response generated")
+    data_as_of: str = Field(description="ISO 8601 timestamp of data freshness")
+    filters_applied: Dict[str, Any] = Field(description="Applied filters")
+    execution_time_ms: float = Field(description="Query execution time in milliseconds")
+
+
+class PaginationMetadata(BaseModel):
+    """Pagination metadata for tabular responses."""
+
+    model_config = ConfigDict(extra="ignore")
+
+    page: int = Field(description="Zero-indexed page number")
+    per_page: int = Field(description="Items per page")
+    total_count: int = Field(description="Total items available")
+    has_more: bool = Field(description="Whether more pages exist")
+
+
+class ColumnDefinition(BaseModel):
+    """Column metadata for tabular data."""
+
+    model_config = ConfigDict(extra="ignore")
+
+    id: str = Field(description="Column identifier")
+    label: str = Field(description="Human-readable label")
+    type: str = Field(description='Data type: "string", "number", "date"')
+    format: Optional[str] = Field(
+        None, description='Format hint: "currency", "percentage", "timestamp"'
+    )
+    description: Optional[str] = Field(None, description="Column description")
+
+
+class Metric(BaseModel):
+    """Individual metric in summary responses."""
+
+    model_config = ConfigDict(extra="ignore")
+
+    id: str = Field(description="Metric identifier")
+    label: str = Field(description="Human-readable label")
+    type: str = Field(description="Data type")
+    value: Any = Field(description="Metric value (int, float, str, etc.)")
+    format: Optional[str] = Field(
+        None, description='Format hint: "currency", "percentage", "number"'
+    )
+    description: Optional[str] = Field(None, description="Metric description")
+
+
+class SummariesData(BaseModel):
+    """Container for summary metrics."""
+
+    model_config = ConfigDict(extra="ignore")
+
+    metrics: List[Metric] = Field(description="Array of metrics")
+
+
+class TabularData(BaseModel):
+    """Container for tabular data with dynamic columns."""
+
+    model_config = ConfigDict(extra="ignore")
+
+    columns: List[ColumnDefinition] = Field(description="Column definitions")
+    rows: List[Dict[str, Any]] = Field(description="Data rows (dict per row)")
+    totals: Optional[Dict[str, Any]] = Field(None, description="Optional totals row")
+
+
+class UserListItem(BaseModel):
+    """Individual user item."""
+
+    model_config = ConfigDict(extra="ignore")
+
+    id: str = Field(description="User ID")
+    name: str = Field(description="User name")
+
+
+class UsersListData(BaseModel):
+    """Container for users list."""
+
+    model_config = ConfigDict(extra="ignore")
+
+    users: List[UserListItem] = Field(description="List of users")
+    total_count: int = Field(description="Total number of users")
+
+
+class SummariesResponse(BaseModel):
+    """Response for summary endpoints (summaries, cli-summary)."""
+
+    model_config = ConfigDict(extra="ignore")
+
+    data: SummariesData = Field(description="Summary data")
+    metadata: ResponseMetadata = Field(description="Response metadata")
+
+
+class TabularResponse(BaseModel):
+    """Response for tabular endpoints (19 endpoints)."""
+
+    model_config = ConfigDict(extra="ignore")
+
+    data: TabularData = Field(description="Tabular data")
+    metadata: ResponseMetadata = Field(description="Response metadata")
+    pagination: Optional[PaginationMetadata] = Field(
+        None, description="Optional pagination metadata"
+    )
+
+
+class UsersListResponse(BaseModel):
+    """Response for users list endpoint."""
+
+    model_config = ConfigDict(extra="ignore")
+
+    data: UsersListData = Field(description="Users list data")
+    metadata: ResponseMetadata = Field(description="Response metadata")
+
+
+class AnalyticsQueryParams(BaseModel):
+    """Query parameters for analytics endpoints."""
+
+    model_config = ConfigDict(extra="ignore")
+
+    time_period: Optional[str] = Field(
+        None,
+        description='Time period: "last_hour", "last_6_hours", "last_24_hours", "last_7_days", "last_30_days", "last_90_days", "last_year"',
+    )
+    start_date: Optional[str] = Field(
+        None, description="ISO 8601 format start date (use with end_date)"
+    )
+    end_date: Optional[str] = Field(
+        None, description="ISO 8601 format end date (use with start_date)"
+    )
+    users: Optional[str] = Field(None, description="Comma-separated user IDs")
+    projects: Optional[str] = Field(None, description="Comma-separated project names")
+
+
+class PaginatedAnalyticsQueryParams(AnalyticsQueryParams):
+    """Query parameters with pagination."""
+
+    page: int = Field(0, description="Zero-indexed page number")
+    per_page: int = Field(20, description="Items per page")

codemie_sdk/models/assistant.py

@@ -216,6 +216,7 @@ class AssistantRequestBase(AssistantBase):
     mcp_servers: List[MCPServerDetails] = Field(default_factory=list)
     assistant_ids: List[str] = Field(default_factory=list)
     prompt_variables: List[PromptVariable] = Field(default_factory=list)
+    skip_integration_validation: Optional[bool] = Field(default=False)
 
 
 class AssistantCreateRequest(AssistantRequestBase):
@@ -230,6 +231,92 @@ class AssistantUpdateRequest(AssistantRequestBase):
     pass
 
 
+class MissingIntegration(BaseModel):
+    """Model representing a single missing tool credential."""
+
+    model_config = ConfigDict(extra="ignore")
+
+    toolkit: str = Field(..., description="Toolkit name (e.g., 'Data Management')")
+    tool: str = Field(..., description="Tool name (e.g., 'sql')")
+    label: str = Field(..., description="Display label for the tool (e.g., 'SQL')")
+    credential_type: Optional[str] = Field(
+        None, description="Credential type required (e.g., 'AWS', 'Jira')"
+    )
+
+
+class MissingIntegrationsByCredentialType(BaseModel):
+    """Model representing missing tools grouped by credential type."""
+
+    model_config = ConfigDict(extra="ignore")
+
+    credential_type: str = Field(
+        ..., description="Credential type (e.g., 'AWS', 'Jira', 'Confluence')"
+    )
+    missing_tools: List[MissingIntegration] = Field(
+        ..., description="List of missing tools requiring this credential type"
+    )
+    # Optional sub-assistant context
+    assistant_id: Optional[str] = Field(
+        None, description="Sub-assistant ID (if from sub-assistant)"
+    )
+    assistant_name: Optional[str] = Field(
+        None, description="Sub-assistant name (if from sub-assistant)"
+    )
+    icon_url: Optional[str] = Field(
+        None, description="Sub-assistant icon URL (if from sub-assistant)"
+    )
+
+
+class IntegrationValidationResult(BaseModel):
+    """Complete validation result for assistant integrations."""
+
+    model_config = ConfigDict(extra="ignore")
+
+    has_missing_integrations: bool = Field(
+        ..., description="Whether any integrations are missing"
+    )
+    missing_by_credential_type: List[MissingIntegrationsByCredentialType] = Field(
+        default_factory=list,
+        description="Missing tools in main assistant grouped by credential type",
+    )
+    sub_assistants_missing: List[MissingIntegrationsByCredentialType] = Field(
+        default_factory=list,
+        description="Missing tools in sub-assistants grouped by credential type",
+    )
+    message: Optional[str] = Field(
+        None, description="User-friendly message about missing integrations"
+    )
+
+
+class AssistantCreateResponse(BaseModel):
+    """Response model for assistant creation with validation."""
+
+    model_config = ConfigDict(extra="ignore", populate_by_name=True)
+
+    message: str = Field(..., description="Response message")
+    assistant_id: Optional[str] = Field(
+        None,
+        alias="assistantId",
+        description="Created assistant ID (None if validation failed)",
+    )
+    validation: Optional[IntegrationValidationResult] = Field(
+        None,
+        description="Validation result (populated if validation found missing integrations)",
+    )
+
+
+class AssistantUpdateResponse(BaseModel):
+    """Response model for assistant update with validation."""
+
+    model_config = ConfigDict(extra="ignore")
+
+    message: str = Field(..., description="Response message")
+    validation: Optional[IntegrationValidationResult] = Field(
+        None,
+        description="Validation result (populated if validation found missing integrations)",
+    )
+
+
 class AssistantVersion(BaseModel):
     """Immutable snapshot of assistant configuration for a specific version."""
 

codemie_sdk/models/guardrails.py

@@ -0,0 +1,62 @@
+"""Models for guardrail assignments."""
+
+from typing import List
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class GuardrailAssignmentSetting(BaseModel):
+    """Model for guardrail assignment settings."""
+
+    model_config = ConfigDict(extra="ignore")
+
+    mode: str = Field(..., description="Assignment mode (e.g., 'all', 'specific')")
+    source: str = Field(..., description="Source type (e.g., 'input', 'output')")
+
+
+class GuardrailAssignmentEntity(BaseModel):
+    """Model for guardrail assignment to specific entities."""
+
+    model_config = ConfigDict(extra="ignore")
+
+    settings: List[GuardrailAssignmentSetting] = Field(
+        default_factory=list, description="List of assignment settings"
+    )
+    items: List[str] = Field(
+        default_factory=list, description="List of specific entity IDs"
+    )
+
+
+class GuardrailAssignmentRequest(BaseModel):
+    """Request model for assigning guardrails to entities."""
+
+    model_config = ConfigDict(extra="ignore")
+
+    project: GuardrailAssignmentEntity = Field(
+        default_factory=lambda: GuardrailAssignmentEntity(settings=[], items=[]),
+        description="Project-level assignments",
+    )
+    assistants: GuardrailAssignmentEntity = Field(
+        default_factory=lambda: GuardrailAssignmentEntity(settings=[], items=[]),
+        description="Assistant-level assignments",
+    )
+    workflows: GuardrailAssignmentEntity = Field(
+        default_factory=lambda: GuardrailAssignmentEntity(settings=[], items=[]),
+        description="Workflow-level assignments",
+    )
+    datasources: GuardrailAssignmentEntity = Field(
+        default_factory=lambda: GuardrailAssignmentEntity(settings=[], items=[]),
+        description="Datasource-level assignments",
+    )
+
+
+class GuardrailAssignmentResponse(BaseModel):
+    """Response model for guardrail assignment."""
+
+    model_config = ConfigDict(extra="ignore")
+
+    success: int = Field(..., description="Count of successful assignments")
+    failed: int = Field(..., description="Count of failed assignments")
+    errors: List[str] = Field(
+        default_factory=list, description="List of error messages"
+    )

codemie_sdk/services/admin.py

@@ -0,0 +1,60 @@
+"""Admin service implementation."""
+
+from typing import List, Optional
+
+from ..models.admin import (
+    ApplicationsListResponse,
+    ApplicationCreateRequest,
+    ApplicationCreateResponse,
+)
+from ..utils import ApiRequestHandler
+
+
+class AdminService:
+    """Service for managing CodeMie applications/projects."""
+
+    def __init__(self, api_domain: str, token: str, verify_ssl: bool = True):
+        """Initialize the admin service.
+
+        Args:
+            api_domain: Base URL for the CodeMie API
+            token: Authentication token
+            verify_ssl: Whether to verify SSL certificates
+        """
+        self._api = ApiRequestHandler(api_domain, token, verify_ssl)
+
+    def list_applications(self, project_name: Optional[str] = None) -> List[str]:
+        """Get list of all applications/projects.
+
+        Args:
+            project_name: Optional project name to filter by
+
+        Returns:
+            List of application names
+        """
+        params = {}
+        if project_name:
+            params["search"] = project_name
+
+        response = self._api.get(
+            "/v1/admin/applications",
+            ApplicationsListResponse,
+            params=params if params else None,
+        )
+        return response.applications
+
+    def create_application(self, request: ApplicationCreateRequest) -> str:
+        """Create a new application/project.
+
+        Args:
+            request: Application creation request
+
+        Returns:
+            Created application name
+        """
+        response = self._api.post(
+            "/v1/admin/application",
+            ApplicationCreateResponse,
+            json_data=request.model_dump(exclude_none=True),
+        )
+        return response.message

codemie_sdk/services/analytics.py

@@ -0,0 +1,463 @@
+"""Analytics service implementation."""
+
+from typing import Optional
+
+from ..models.analytics import (
+    AnalyticsQueryParams,
+    PaginatedAnalyticsQueryParams,
+    SummariesResponse,
+    TabularResponse,
+    UsersListResponse,
+)
+from ..utils import ApiRequestHandler
+
+
+class AnalyticsService:
+    """Service for managing CodeMie analytics."""
+
+    def __init__(self, api_domain: str, token: str, verify_ssl: bool = True):
+        """Initialize the analytics service.
+
+        Args:
+            api_domain: Base URL for the CodeMie API
+            token: Authentication token
+            verify_ssl: Whether to verify SSL certificates
+        """
+        self._api = ApiRequestHandler(api_domain, token, verify_ssl)
+
+    def get_summaries(
+        self, params: Optional[AnalyticsQueryParams] = None
+    ) -> SummariesResponse:
+        """Get overall platform summary metrics.
+
+        Args:
+            params: Query parameters (time filters, user/project filters)
+
+        Returns:
+            SummariesResponse with metrics array including total input tokens,
+            cached input tokens, output tokens, and money spent
+        """
+        query_params = params.model_dump(exclude_none=True) if params else {}
+        return self._api.get(
+            "/v1/analytics/summaries",
+            SummariesResponse,
+            params=query_params,
+            wrap_response=False,
+        )
+
+    def get_cli_summary(
+        self, params: Optional[AnalyticsQueryParams] = None
+    ) -> SummariesResponse:
+        """Get CLI-specific summary metrics.
+
+        Args:
+            params: Query parameters (time filters, user/project filters)
+
+        Returns:
+            SummariesResponse with CLI metrics including unique users, repos,
+            sessions, file operations, and code statistics
+        """
+        query_params = params.model_dump(exclude_none=True) if params else {}
+        return self._api.get(
+            "/v1/analytics/cli-summary",
+            SummariesResponse,
+            params=query_params,
+            wrap_response=False,
+        )
+
+    def get_assistants_chats(
+        self, params: Optional[PaginatedAnalyticsQueryParams] = None
+    ) -> TabularResponse:
+        """Get assistants chats analytics.
+
+        Args:
+            params: Query parameters (filters + pagination)
+
+        Returns:
+            TabularResponse with assistant performance metrics including chat statistics,
+            error rates, token consumption, and costs
+        """
+        query_params = params.model_dump(exclude_none=True) if params else {}
+        return self._api.get(
+            "/v1/analytics/assistants-chats",
+            TabularResponse,
+            params=query_params,
+            wrap_response=False,
+        )
+
+    def get_workflows(
+        self, params: Optional[PaginatedAnalyticsQueryParams] = None
+    ) -> TabularResponse:
+        """Get workflows analytics.
+
+        Args:
+            params: Query parameters (filters + pagination)
+
+        Returns:
+            TabularResponse with workflow execution metrics including total runs,
+            success/failure rates, costs, and performance statistics
+        """
+        query_params = params.model_dump(exclude_none=True) if params else {}
+        return self._api.get(
+            "/v1/analytics/workflows",
+            TabularResponse,
+            params=query_params,
+            wrap_response=False,
+        )
+
+    def get_tools_usage(
+        self, params: Optional[PaginatedAnalyticsQueryParams] = None
+    ) -> TabularResponse:
+        """Get tool usage analytics.
+
+        Args:
+            params: Query parameters (filters + pagination)
+
+        Returns:
+            TabularResponse with tool usage metrics including invocation counts,
+            user adoption, agent usage, and error tracking
+        """
+        query_params = params.model_dump(exclude_none=True) if params else {}
+        return self._api.get(
+            "/v1/analytics/tools-usage",
+            TabularResponse,
+            params=query_params,
+            wrap_response=False,
+        )
+
+    def get_webhooks_invocation(
+        self, params: Optional[PaginatedAnalyticsQueryParams] = None
+    ) -> TabularResponse:
+        """Get webhooks invocation statistics.
+
+        Args:
+            params: Query parameters (filters + pagination)
+
+        Returns:
+            TabularResponse with webhook usage patterns showing invocation counts
+            per user and webhook alias
+        """
+        query_params = params.model_dump(exclude_none=True) if params else {}
+        return self._api.get(
+            "/v1/analytics/webhooks-invocation",
+            TabularResponse,
+            params=query_params,
+            wrap_response=False,
+        )
+
+    def get_mcp_servers(
+        self, params: Optional[PaginatedAnalyticsQueryParams] = None
+    ) -> TabularResponse:
+        """Get top MCP servers analytics.
+
+        Args:
+            params: Query parameters (filters + pagination)
+
+        Returns:
+            TabularResponse with MCP server usage distribution showing
+            percentage share of each server
+        """
+        query_params = params.model_dump(exclude_none=True) if params else {}
+        return self._api.get(
+            "/v1/analytics/mcp-servers",
+            TabularResponse,
+            params=query_params,
+            wrap_response=False,
+        )
+
+    def get_mcp_servers_by_users(
+        self, params: Optional[PaginatedAnalyticsQueryParams] = None
+    ) -> TabularResponse:
+        """Get MCP servers usage by users.
+
+        Args:
+            params: Query parameters (filters + pagination)
+
+        Returns:
+            TabularResponse with individual user adoption and usage of MCP servers
+            showing which users are utilizing which servers
+        """
+        query_params = params.model_dump(exclude_none=True) if params else {}
+        return self._api.get(
+            "/v1/analytics/mcp-servers-by-users",
+            TabularResponse,
+            params=query_params,
+            wrap_response=False,
+        )
+
+    def get_projects_spending(
+        self, params: Optional[PaginatedAnalyticsQueryParams] = None
+    ) -> TabularResponse:
+        """Get money spent by projects.
+
+        Args:
+            params: Query parameters (filters + pagination)
+
+        Returns:
+            TabularResponse with project-level spending ranked by amount
+        """
+        query_params = params.model_dump(exclude_none=True) if params else {}
+        return self._api.get(
+            "/v1/analytics/projects-spending",
+            TabularResponse,
+            params=query_params,
+            wrap_response=False,
+        )
+
+    def get_llms_usage(
+        self, params: Optional[PaginatedAnalyticsQueryParams] = None
+    ) -> TabularResponse:
+        """Get top LLMs usage analytics.
+
+        Args:
+            params: Query parameters (filters + pagination)
+
+        Returns:
+            TabularResponse with LLM model usage distribution showing
+            preference patterns across different models
+        """
+        query_params = params.model_dump(exclude_none=True) if params else {}
+        return self._api.get(
+            "/v1/analytics/llms-usage",
+            TabularResponse,
+            params=query_params,
+            wrap_response=False,
+        )
+
+    def get_users_spending(
+        self, params: Optional[PaginatedAnalyticsQueryParams] = None
+    ) -> TabularResponse:
+        """Get money spent by users.
+
+        Args:
+            params: Query parameters (filters + pagination)
+
+        Returns:
+            TabularResponse with individual user spending ranked by amount
+        """
+        query_params = params.model_dump(exclude_none=True) if params else {}
+        return self._api.get(
+            "/v1/analytics/users-spending",
+            TabularResponse,
+            params=query_params,
+            wrap_response=False,
+        )
+
+    def get_budget_soft_limit(
+        self, params: Optional[PaginatedAnalyticsQueryParams] = None
+    ) -> TabularResponse:
+        """Get soft budget limit violations.
+
+        Args:
+            params: Query parameters (filters + pagination)
+
+        Returns:
+            TabularResponse with users who have exceeded soft budget limits
+            (warning threshold)
+        """
+        query_params = params.model_dump(exclude_none=True) if params else {}
+        return self._api.get(
+            "/v1/analytics/budget-soft-limit",
+            TabularResponse,
+            params=query_params,
+            wrap_response=False,
+        )
+
+    def get_budget_hard_limit(
+        self, params: Optional[PaginatedAnalyticsQueryParams] = None
+    ) -> TabularResponse:
+        """Get hard budget limit violations.
+
+        Args:
+            params: Query parameters (filters + pagination)
+
+        Returns:
+            TabularResponse with users who have reached or exceeded hard budget
+            limits (enforcement threshold)
+        """
+        query_params = params.model_dump(exclude_none=True) if params else {}
+        return self._api.get(
+            "/v1/analytics/budget-hard-limit",
+            TabularResponse,
+            params=query_params,
+            wrap_response=False,
+        )
+
+    def get_users_activity(
+        self, params: Optional[PaginatedAnalyticsQueryParams] = None
+    ) -> TabularResponse:
+        """Get most active users analytics.
+
+        Args:
+            params: Query parameters (filters + pagination)
+
+        Returns:
+            TabularResponse with comprehensive user activity metrics including
+            spending, recent projects, and token consumption
+        """
+        query_params = params.model_dump(exclude_none=True) if params else {}
+        return self._api.get(
+            "/v1/analytics/users-activity",
+            TabularResponse,
+            params=query_params,
+            wrap_response=False,
+        )
+
+    def get_projects_activity(
+        self, params: Optional[PaginatedAnalyticsQueryParams] = None
+    ) -> TabularResponse:
+        """Get most active projects analytics.
+
+        Args:
+            params: Query parameters (filters + pagination)
+
+        Returns:
+            TabularResponse with project activity metrics including spending,
+            active user counts, and token consumption
+        """
+        query_params = params.model_dump(exclude_none=True) if params else {}
+        return self._api.get(
+            "/v1/analytics/projects-activity",
+            TabularResponse,
+            params=query_params,
+            wrap_response=False,
+        )
+
+    def get_agents_usage(
+        self, params: Optional[PaginatedAnalyticsQueryParams] = None
+    ) -> TabularResponse:
+        """Get top agents usage analytics.
+
+        Args:
+            params: Query parameters (filters + pagination)
+
+        Returns:
+            TabularResponse with agent usage analytics including invocations,
+            spending, user adoption, tool usage, and error tracking
+        """
+        query_params = params.model_dump(exclude_none=True) if params else {}
+        return self._api.get(
+            "/v1/analytics/agents-usage",
+            TabularResponse,
+            params=query_params,
+            wrap_response=False,
+        )
+
+    def get_cli_agents(
+        self, params: Optional[PaginatedAnalyticsQueryParams] = None
+    ) -> TabularResponse:
+        """Get top CLI agents analytics.
+
+        Args:
+            params: Query parameters (filters + pagination)
+
+        Returns:
+            TabularResponse with CLI agent usage distribution showing
+            percentage share of each agent
+        """
+        query_params = params.model_dump(exclude_none=True) if params else {}
+        return self._api.get(
+            "/v1/analytics/cli-agents",
+            TabularResponse,
+            params=query_params,
+            wrap_response=False,
+        )
+
+    def get_cli_llms(
+        self, params: Optional[PaginatedAnalyticsQueryParams] = None
+    ) -> TabularResponse:
+        """Get top CLI LLMs analytics.
+
+        Args:
+            params: Query parameters (filters + pagination)
+
+        Returns:
+            TabularResponse with LLM model usage distribution in CLI context
+            showing percentage share
+        """
+        query_params = params.model_dump(exclude_none=True) if params else {}
+        return self._api.get(
+            "/v1/analytics/cli-llms",
+            TabularResponse,
+            params=query_params,
+            wrap_response=False,
+        )
+
+    def get_cli_users(
+        self, params: Optional[PaginatedAnalyticsQueryParams] = None
+    ) -> TabularResponse:
+        """Get most active CLI users analytics.
+
+        Args:
+            params: Query parameters (filters + pagination)
+
+        Returns:
+            TabularResponse with CLI user activity showing total invocation
+            counts per user
+        """
+        query_params = params.model_dump(exclude_none=True) if params else {}
+        return self._api.get(
+            "/v1/analytics/cli-users",
+            TabularResponse,
+            params=query_params,
+            wrap_response=False,
+        )
+
+    def get_cli_errors(
+        self, params: Optional[PaginatedAnalyticsQueryParams] = None
+    ) -> TabularResponse:
+        """Get top error codes for CLI.
+
+        Args:
+            params: Query parameters (filters + pagination)
+
+        Returns:
+            TabularResponse with most common CLI error codes with occurrence
+            counts for troubleshooting
+        """
+        query_params = params.model_dump(exclude_none=True) if params else {}
+        return self._api.get(
+            "/v1/analytics/cli-errors",
+            TabularResponse,
+            params=query_params,
+            wrap_response=False,
+        )
+
+    def get_cli_repositories(
+        self, params: Optional[PaginatedAnalyticsQueryParams] = None
+    ) -> TabularResponse:
+        """Get repository statistics.
+
+        Args:
+            params: Query parameters (filters + pagination)
+
+        Returns:
+            TabularResponse with repository-level metrics including code changes,
+            token consumption, and branch activity
+        """
+        query_params = params.model_dump(exclude_none=True) if params else {}
+        return self._api.get(
+            "/v1/analytics/cli-repositories",
+            TabularResponse,
+            params=query_params,
+            wrap_response=False,
+        )
+
+    def get_users(
+        self, params: Optional[AnalyticsQueryParams] = None
+    ) -> UsersListResponse:
+        """Get users list.
+
+        Args:
+            params: Query parameters (time filters, user/project filters)
+
+        Returns:
+            UsersListResponse with list of unique users
+        """
+        query_params = params.model_dump(exclude_none=True) if params else {}
+        return self._api.get(
+            "/v1/analytics/users",
+            UsersListResponse,
+            params=query_params,
+            wrap_response=False,
+        )

codemie_sdk/services/assistant.py

@@ -14,6 +14,8 @@ from ..models.assistant import (
     Assistant,
     AssistantCreateRequest,
     AssistantUpdateRequest,
+    AssistantCreateResponse,
+    AssistantUpdateResponse,
     ToolKitDetails,
     AssistantChatRequest,
     BaseModelResponse,
@@ -90,20 +92,24 @@ class AssistantService:
         """
         return self._api.get(f"/v1/assistants/slug/{slug}", Assistant)
 
-    def create(self, request: AssistantCreateRequest) -> dict:
+    def create(self, request: AssistantCreateRequest) -> AssistantCreateResponse:
         """Create a new assistant.
 
         Args:
             request: Assistant creation request
 
         Returns:
-            Created assistant details
+            AssistantCreateResponse with assistant_id and optional validation results
         """
         return self._api.post(
-            "/v1/assistants", dict, json_data=request.model_dump(exclude_none=True)
+            "/v1/assistants",
+            AssistantCreateResponse,
+            json_data=request.model_dump(exclude_none=True),
         )
 
-    def update(self, assistant_id: str, request: AssistantUpdateRequest) -> dict:
+    def update(
+        self, assistant_id: str, request: AssistantUpdateRequest
+    ) -> AssistantUpdateResponse:
         """Update an existing assistant.
 
         Args:
@@ -111,11 +117,11 @@ class AssistantService:
             request: Assistant update request
 
         Returns:
-            Updated assistant details
+            AssistantUpdateResponse with optional validation results
         """
         return self._api.put(
             f"/v1/assistants/{assistant_id}",
-            dict,
+            AssistantUpdateResponse,
             json_data=request.model_dump(exclude_none=True),
         )
 
@@ -296,7 +302,8 @@ class AssistantService:
                     if hasattr(version, "assistant_ids")
                     else assistant.assistant_ids,
                 )
-                resp = self.update(assistant_id, update_req)
+                update_resp = self.update(assistant_id, update_req)
+                resp = update_resp.model_dump()
                 resp["_rollback_fallback"] = True
                 resp["_target_version"] = version_number
                 if change_notes:

codemie_sdk/services/codemie_guardrails.py

@@ -0,0 +1,76 @@
+"""CodeMie guardrail service implementation for managing guardrail assignments."""
+
+from ..models.guardrails import (
+    GuardrailAssignmentRequest,
+    GuardrailAssignmentResponse,
+)
+from ..utils import ApiRequestHandler
+
+
+class CodemieGuardrailService:
+    """Service for managing CodeMie guardrail assignments."""
+
+    def __init__(self, api_domain: str, token: str, verify_ssl: bool = True):
+        """Initialize the CodeMie guardrail service.
+
+        Args:
+            api_domain: Base URL for the CodeMie API
+            token: Authentication token
+            verify_ssl: Whether to verify SSL certificates
+        """
+        self._api = ApiRequestHandler(api_domain, token, verify_ssl)
+
+    def assign_guardrails(
+        self,
+        guardrail_id: str,
+        assignment: GuardrailAssignmentRequest,
+    ) -> GuardrailAssignmentResponse:
+        """Assign guardrails to project entities (assistants, workflows, datasources).
+
+        Args:
+            guardrail_id: ID of the guardrail to assign (AI run ID from installation)
+            assignment: Assignment configuration for different entity types
+
+        Returns:
+            GuardrailAssignmentResponse with success status
+
+        Example:
+            >>> from codemie_sdk.models.guardrails import (
+            ...     GuardrailAssignmentRequest,
+            ...     GuardrailAssignmentEntity,
+            ...     GuardrailAssignmentSetting
+            ... )
+            >>> # Assign guardrail to all project assistants
+            >>> assignment = GuardrailAssignmentRequest(
+            ...     assistants=GuardrailAssignmentEntity(
+            ...         settings=[GuardrailAssignmentSetting(mode="all", source="input")],
+            ...         items=[]
+            ...     )
+            ... )
+            >>> response = client.codemie_guardrails.assign_guardrails(
+            ...     guardrail_id="ai_run_123",
+            ...     assignment=assignment
+            ... )
+            >>> if response.success:
+            ...     print("Guardrail assigned successfully!")
+            >>>
+            >>> # Assign to specific assistants
+            >>> assignment = GuardrailAssignmentRequest(
+            ...     assistants=GuardrailAssignmentEntity(
+            ...         settings=[],
+            ...         items=["asst_123", "asst_456"]
+            ...     )
+            ... )
+            >>> response = client.codemie_guardrails.assign_guardrails(
+            ...     guardrail_id="ai_run_123",
+            ...     assignment=assignment
+            ... )
+        """
+        payload = assignment.model_dump(by_alias=True)
+
+        return self._api.put(
+            f"/v1/guardrails/{guardrail_id}/assignments",
+            GuardrailAssignmentResponse,
+            json_data=payload,
+            wrap_response=False,
+        )

{codemie_sdk_python-0.1.275.dist-info → codemie_sdk_python-0.1.289.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: codemie-sdk-python
-Version: 0.1.275
+Version: 0.1.289
 Summary: CodeMie SDK for Python
 Author: Vadym Vlasenko
 Author-email: vadym_vlasenko@epam.com

{codemie_sdk_python-0.1.275.dist-info → codemie_sdk_python-0.1.289.dist-info}/RECORD

@@ -1,15 +1,18 @@
-codemie_sdk/__init__.py,sha256=rdb72JEOkNMYrVYgnahqFpp7I6FgbmeWuNflMKWetgE,4168
+codemie_sdk/__init__.py,sha256=4ha4xbTsassZHl3AsbIM6rEF3wfl0h2e0YcZiAOZb7Q,5258
 codemie_sdk/auth/__init__.py,sha256=IksEj223xEZtJ-cQ0AT9L0Bs9psIJ8QNzDXrPTUQ3xQ,126
 codemie_sdk/auth/credentials.py,sha256=OzR_CXPBNTEC6VmNdzcCHF7rWWGrVf3agAlGKgPtTiU,4361
 codemie_sdk/client/__init__.py,sha256=yf6C39MmrJ6gK9ZHMhBeynKwUUYVSUTQbKxU8-4qpKg,101
-codemie_sdk/client/client.py,sha256=sz6h62XE1g2tTbgNdbeMws-wQPROXwLTUmtaVI6TC1U,7155
+codemie_sdk/client/client.py,sha256=SV-wo892o3YlvaGcLL9Cx0mDFggBZFBsxCVfZwjnokI,8039
 codemie_sdk/exceptions.py,sha256=XoVPyognx-JmyVxLHkZPAcX1CMi1OoT1diBFJLU54so,1183
 codemie_sdk/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-codemie_sdk/models/assistant.py,sha256=PO2TMB9koJzrMEZ0jWtR3MVwyU88hebNYLjD3RB1uro,12736
+codemie_sdk/models/admin.py,sha256=eAsz4rFFrXCXjUubn4U23AmhZA5bAT0ip5RyfyEc5e0,805
+codemie_sdk/models/analytics.py,sha256=mquZwaIwouQMAXEDy0E5ClvmIFz7rtTcgu-OzVhTMn4,5008
+codemie_sdk/models/assistant.py,sha256=KJ1bgDKRnur_O1XNlE__Um-mI_zG_LLO2WLDUlL9VQw,15907
 codemie_sdk/models/common.py,sha256=gmZ-ps8TbaieNKr0kUKoQEjhVrHD2CAYomOpZQRatH8,1195
 codemie_sdk/models/conversation.py,sha256=tGlqtVnoRCbTm8J8Y1BUmBvMpLW3IRFE0CIHJYoNU_Y,4238
 codemie_sdk/models/datasource.py,sha256=rL1pUkdPq7_KmnuPkSCO9Bp7DlAXCN51YrtbP3os3qM,13843
 codemie_sdk/models/file_operation.py,sha256=D2hnsxOO9lzVMw0BNCgKPfHf28bWQmbw5rccgaTXI90,747
+codemie_sdk/models/guardrails.py,sha256=6AyN0kx8lII85jFwLQztdCZJ2nPpjAoI6PU2f3TP7RM,2139
 codemie_sdk/models/integration.py,sha256=FFFcggLf9kh5QVle1T8Jexyh5bc3hgh39YHIp8xfMZ0,2328
 codemie_sdk/models/llm.py,sha256=ppb9-1dx1UFhRuJpSR3ij7H6Pfhe9nO4C4BEOIbToy4,1192
 codemie_sdk/models/task.py,sha256=J4ZFRY3s8qBGrqB5NLQF0rMbInLh4s7OEZ0ZfmnW0Ho,1476
@@ -22,7 +25,10 @@ codemie_sdk/models/workflow.py,sha256=qfk0rBJnFUMpcEDq_E5GB3hzYKbe_bb2NYJlLZJwUE
 codemie_sdk/models/workflow_execution_payload.py,sha256=Pa28ElqsJLudscJnmZhXUEJWJXLw55xc-KYBPi97EZ4,724
 codemie_sdk/models/workflow_state.py,sha256=okEMKzkiBU3GHs9VNBoiEMOnOeZRMXGYtpL0NYSg-FY,1374
 codemie_sdk/models/workflow_thoughts.py,sha256=CjHaIPgca9kQAjpoq8IpX4MuDeql1SvaoKS5RmyU2SE,616
-codemie_sdk/services/assistant.py,sha256=hbKW2gweGMcOQCXbhrkgI__gwuPgZk0jz1GzJ7kH8Dw,15940
+codemie_sdk/services/admin.py,sha256=j_d_LuHHC70ckIz1ImqwccQIk1Ew05_Hl0-lw6meWVA,1723
+codemie_sdk/services/analytics.py,sha256=A7J-cC-82vD1m8bLYX3Nyz5MdpveuMT61-M_827f52A,14956
+codemie_sdk/services/assistant.py,sha256=GIiD_t-g1dJnuNmZOQZlr4020hse0NIBE1mULQS_65k,16247
+codemie_sdk/services/codemie_guardrails.py,sha256=VI4dqoswYAQMHCgTsJds7Uugq0zk9TPSdKzt6keSyQQ,2812
 codemie_sdk/services/conversation.py,sha256=Ss0mkGaBi4u8-YKzhRYUJOfoFqJueDp9JurI5DRCGT8,2566
 codemie_sdk/services/datasource.py,sha256=vusKiIyRZwliBUPzp78saXuiIEAg1f4FLz-g5ildRFY,9773
 codemie_sdk/services/files.py,sha256=SgqPmI1jnWIQ7pdxZSaRDnCFU7OnJllb5XLH-1q3zNg,2512
@@ -40,6 +46,6 @@ codemie_sdk/services/workflow_execution.py,sha256=BfbnoyMutQ4_SkpKdCi-F2A5r9JqEf
 codemie_sdk/services/workflow_execution_state.py,sha256=tXoaa8yT09xgYEUNiHhVULe76TwGwVgZupMIUyyLxdo,2070
 codemie_sdk/utils/__init__.py,sha256=BXAJJfAzO89-kMYvWWo9wSNhSbGgF3vB1In9sePFhMM,109
 codemie_sdk/utils/http.py,sha256=pVNYH1PTqfu8ZzP3tBCugVUOroh_QcKu2ej8EzeDm4Q,10337
-codemie_sdk_python-0.1.275.dist-info/METADATA,sha256=kImnuq6XF1diAU0A4cNwf6IiMxgc4-EZ0ZVyTqmkQLQ,36787
-codemie_sdk_python-0.1.275.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-codemie_sdk_python-0.1.275.dist-info/RECORD,,
+codemie_sdk_python-0.1.289.dist-info/METADATA,sha256=GnMMB5-Ho8ArDwv2VrRfH38nk4CN7x6Kb1MaulAi4vo,36787
+codemie_sdk_python-0.1.289.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+codemie_sdk_python-0.1.289.dist-info/RECORD,,