codemie-sdk-python 0.1.52__py3-none-any.whl → 0.1.258__py3-none-any.whl

codemie_sdk/services/assistant.py

@@ -1,10 +1,14 @@
 """Assistant service implementation."""
 
+import inspect
 import json
 from pathlib import Path
 from typing import List, Union, Optional, Dict, Any, Literal
+from pydantic import BaseModel
+from copy import deepcopy
 
 import requests
+import mimetypes
 
 from ..models.assistant import (
     Assistant,
@@ -16,6 +20,7 @@ from ..models.assistant import (
     AssistantBase,
     Context,
     ExportAssistantPayload,
+    AssistantEvaluationRequest,
 )
 from ..models.common import PaginationParams
 from ..utils import ApiRequestHandler
@@ -37,7 +42,7 @@ class AssistantService:
     def list(
         self,
         minimal_response: bool = True,
-        scope: Literal["visible_to_user", "created_by_user"] = "visible_to_user",
+        scope: Literal["visible_to_user", "marketplace"] = "visible_to_user",
         page: int = 0,
         per_page: int = 12,
         filters: Optional[Dict[str, Any]] = None,
@@ -165,33 +170,270 @@ class AssistantService:
         """
         return self._api.get(f"/v1/assistants/prebuilt/{slug}", Assistant)
 
+    def list_versions(
+        self, assistant_id: str, page: int = 0, per_page: Optional[int] = None
+    ):
+        """List assistant versions.
+
+        Args:
+            assistant_id: Assistant identifier
+            page: Page number for pagination
+            per_page: Items per page (optional). If not provided, backend defaults are used.
+
+        Returns:
+            List of AssistantVersion objects
+        """
+
+        params: Dict[str, Any] = {"page": page}
+        if per_page is not None:
+            params["per_page"] = per_page
+        from ..models.assistant import AssistantVersion
+
+        raw = self._api.get(
+            f"/v1/assistants/{assistant_id}/versions",
+            dict,
+            params=params,
+            wrap_response=False,
+        )
+        items = []
+        if isinstance(raw, list):
+            items = raw
+        elif isinstance(raw, dict):
+            items = raw.get("data") or raw.get("versions") or []
+        else:
+            items = []
+        return [AssistantVersion.model_validate(it) for it in items]
+
+    def get_version(self, assistant_id: str, version_number: int):
+        """Get a specific assistant version by number.
+
+        Args:
+            assistant_id: Assistant identifier
+            version_number: Version number to retrieve
+
+        Returns:
+            AssistantVersion object
+        """
+        from ..models.assistant import AssistantVersion
+
+        raw = self._api.get(
+            f"/v1/assistants/{assistant_id}/versions/{version_number}", AssistantVersion
+        )
+        if isinstance(raw, dict):
+            return AssistantVersion.model_validate(raw)
+        return raw
+
+    def compare_versions(self, assistant_id: str, v1: int, v2: int) -> Dict[str, Any]:
+        """Compare two assistant versions and return diff summary.
+
+        Args:
+            assistant_id: Assistant identifier
+            v1: First version number
+            v2: Second version number
+
+        Returns:
+            Generic dictionary with comparison result (diff, summary, etc.)
+        """
+        return self._api.get(
+            f"/v1/assistants/{assistant_id}/versions/{v1}/compare/{v2}",
+            dict,
+        )
+
+    def rollback_to_version(
+        self, assistant_id: str, version_number: int, change_notes: Optional[str] = None
+    ) -> dict:
+        """Rollback assistant to a specific version. Creates a new version mirroring target.
+
+        Args:
+            assistant_id: Assistant identifier
+            version_number: Target version to rollback to
+            change_notes: Optional description of why rollback is performed
+
+        Returns:
+            Backend response (dict)
+        """
+        payload: Dict[str, Any] = {}
+        if change_notes:
+            payload["change_notes"] = change_notes
+        try:
+            return self._api.post(
+                f"/v1/assistants/{assistant_id}/versions/{version_number}/rollback",
+                dict,
+                json_data=payload,
+            )
+        except requests.HTTPError as err:
+            try:
+                assistant = self.get(assistant_id)
+                version = self.get_version(assistant_id, version_number)
+
+                update_req = AssistantUpdateRequest(
+                    name=assistant.name,
+                    description=assistant.description or "",
+                    system_prompt=version.system_prompt,
+                    project=assistant.project,
+                    llm_model_type=version.llm_model_type or assistant.llm_model_type,
+                    temperature=version.temperature
+                    if hasattr(version, "temperature")
+                    else assistant.temperature,
+                    top_p=version.top_p
+                    if hasattr(version, "top_p")
+                    else assistant.top_p,
+                    context=version.context
+                    if hasattr(version, "context")
+                    else assistant.context,
+                    toolkits=version.toolkits
+                    if hasattr(version, "toolkits")
+                    else assistant.toolkits,
+                    user_prompts=assistant.user_prompts,
+                    shared=assistant.shared,
+                    is_react=assistant.is_react,
+                    is_global=assistant.is_global,
+                    slug=assistant.slug,
+                    mcp_servers=version.mcp_servers
+                    if hasattr(version, "mcp_servers")
+                    else assistant.mcp_servers,
+                    assistant_ids=version.assistant_ids
+                    if hasattr(version, "assistant_ids")
+                    else assistant.assistant_ids,
+                )
+                resp = self.update(assistant_id, update_req)
+                resp["_rollback_fallback"] = True
+                resp["_target_version"] = version_number
+                if change_notes:
+                    resp["change_notes"] = change_notes
+                return resp
+            except Exception:
+                raise err
+
     def chat(
         self,
         assistant_id: str,
         request: AssistantChatRequest,
+        headers: Optional[Dict[str, str]] = None,
     ) -> Union[requests.Response, BaseModelResponse]:
         """Send a chat request to an assistant.
 
         Args:
             assistant_id: ID of the assistant to chat with
             request: Chat request details
+            headers: Optional additional HTTP headers (e.g., X-* for MCP propagation)
 
         Returns:
             Chat response or streaming response
         """
-        return self._api.post(
+        pydantic_schema = None
+        if (
+            request.output_schema is not None
+            and inspect.isclass(request.output_schema)
+            and issubclass(request.output_schema, BaseModel)
+        ):
+            pydantic_schema = deepcopy(request.output_schema)
+            request.output_schema = request.output_schema.model_json_schema()
+
+        response = self._api.post(
             f"/v1/assistants/{assistant_id}/model",
             BaseModelResponse,
             json_data=request.model_dump(exclude_none=True, by_alias=True),
             stream=request.stream,
+            extra_headers=headers,
         )
+        if not request.stream and pydantic_schema:
+            # we do conversion to the BaseModel here because self._parse_response don't see actual request model,
+            # where reflected desired output format for structured output
+            response.generated = pydantic_schema.model_validate(response.generated)
+
+        return response
+
+    def chat_with_version(
+        self,
+        assistant_id: str,
+        version_number: int,
+        request: AssistantChatRequest,
+    ) -> Union[requests.Response, BaseModelResponse]:
+        """Send a chat request to a specific assistant version.
+
+        Uses the stable chat endpoint with an explicit `version` parameter to
+        ensure compatibility with environments that don't expose
+        /versions/{version}/model.
+
+        Args:
+            assistant_id: ID of the assistant to chat with
+            version_number: version to pin chat to
+            request: Chat request details
+
+        Returns:
+            Chat response or streaming response
+        """
+        pydantic_schema = None
+        if issubclass(request.output_schema, BaseModel):
+            pydantic_schema = deepcopy(request.output_schema)
+            request.output_schema = request.output_schema.model_json_schema()
+
+        payload = request.model_dump(exclude_none=True, by_alias=True)
+        payload["version"] = version_number
+
+        response = self._api.post(
+            f"/v1/assistants/{assistant_id}/model",
+            BaseModelResponse,
+            json_data=payload,
+            stream=request.stream,
+        )
+        if not request.stream and pydantic_schema:
+            response.generated = pydantic_schema.model_validate(response.generated)
+
+        return response
+
+    def chat_by_slug(
+        self,
+        assistant_slug: str,
+        request: AssistantChatRequest,
+        headers: Optional[Dict[str, str]] = None,
+    ) -> Union[requests.Response, BaseModelResponse]:
+        """Send a chat request to an assistant by slug.
+
+        Args:
+            assistant_slug: Slug of the assistant to chat with
+            request: Chat request details
+            headers: Optional additional HTTP headers (e.g., X-* for MCP propagation)
+
+        Returns:
+            Chat response or streaming response
+        """
+        pydantic_schema = None
+        if (
+            request.output_schema is not None
+            and inspect.isclass(request.output_schema)
+            and issubclass(request.output_schema, BaseModel)
+        ):
+            pydantic_schema = deepcopy(request.output_schema)
+            request.output_schema = request.output_schema.model_json_schema()
+
+        response = self._api.post(
+            f"/v1/assistants/slug/{assistant_slug}/model",
+            BaseModelResponse,
+            json_data=request.model_dump(exclude_none=True, by_alias=True),
+            stream=request.stream,
+            extra_headers=headers,
+        )
+        if not request.stream and pydantic_schema:
+            response.generated = pydantic_schema.model_validate(response.generated)
+
+        return response
 
     def upload_file_to_chat(self, file_path: Path):
         """Upload a file to assistant chat and return the response containing file_url."""
 
         with open(file_path, "rb") as file:
             files = [
-                ("file", (file_path.name, file, self._api.detect_mime_type(file_path)))
+                (
+                    "file",
+                    (
+                        file_path.name,
+                        file,
+                        mimetypes.guess_type(file_path.name)[0]
+                        or "application/octet-stream",
+                    ),
+                ),
             ]
             response = self._api.post_multipart("/v1/files/", dict, files=files)
 
@@ -213,3 +455,19 @@ class AssistantService:
             stream=True,
             json_data=request.model_dump(exclude_none=True),
         )
+
+    def evaluate(self, assistant_id: str, request: AssistantEvaluationRequest) -> dict:
+        """Evaluate an assistant with a dataset.
+
+        Args:
+            assistant_id: ID of the assistant to evaluate
+            request: Evaluation request details
+
+        Returns:
+            Evaluation results
+        """
+        return self._api.post(
+            f"/v1/assistants/{assistant_id}/evaluate",
+            dict,
+            json_data=request.model_dump(exclude_none=True),
+        )

codemie_sdk/services/conversation.py

@@ -0,0 +1,90 @@
+"""Conversation service implementation."""
+
+from typing import List
+
+from ..models.conversation import (
+    Conversation,
+    ConversationDetails,
+    ConversationCreateRequest,
+)
+from ..utils import ApiRequestHandler
+
+
+class ConversationService:
+    """Service for managing user conversations."""
+
+    def __init__(self, api_domain: str, token: str, verify_ssl: bool = True):
+        """Initialize the conversation service.
+
+        Args:
+            api_domain: Base URL for the API
+            token: Authentication token
+            verify_ssl: Whether to verify SSL certificates
+        """
+        self._api = ApiRequestHandler(api_domain, token, verify_ssl)
+
+    def list(self) -> List[Conversation]:
+        """Get list of all conversations for the current user.
+
+        Returns:
+            List of all conversations for the current user.
+        """
+        return self._api.get("/v1/conversations", List[Conversation])
+
+    def list_by_assistant_id(self, assistant_id: str) -> List[Conversation]:
+        """Get list of all conversations for the current user that include the specified assistant.
+
+        Args:
+            assistant_id: Assistant ID
+
+        Returns:
+            List of conversations for the specified assistant.
+        """
+        return [
+            conv
+            for conv in self._api.get("/v1/conversations", List[Conversation])
+            if assistant_id in conv.assistant_ids
+        ]
+
+    def get_conversation(self, conversation_id: str) -> ConversationDetails:
+        """Get details for a specific conversation by its ID.
+
+        Args:
+            conversation_id: Conversation ID
+
+        Returns:
+            Conversation details
+        """
+        return self._api.get(
+            f"/v1/conversations/{conversation_id}",
+            ConversationDetails,
+        )
+
+    def create(self, request: ConversationCreateRequest) -> dict:
+        """Create a new conversation.
+
+        Args:
+            request: Conversation creation request
+
+        Returns:
+            Created conversation details
+        """
+        return self._api.post(
+            "/v1/conversations",
+            dict,
+            json_data=request.model_dump(exclude_none=True),
+        )
+
+    def delete(self, conversation_id: str) -> dict:
+        """Delete a specific conversation by its ID.
+
+        Args:
+            conversation_id: Conversation ID to delete
+
+        Returns:
+            Deletion confirmation
+        """
+        return self._api.delete(
+            f"/v1/conversations/{conversation_id}",
+            dict,
+        )

codemie_sdk/services/datasource.py

@@ -1,6 +1,7 @@
 """DataSource service implementation."""
 
 import json
+import mimetypes
 from typing import Literal, List, Union, Tuple, Optional, Dict, Any
 from pathlib import Path
 
@@ -14,7 +15,11 @@ from ..models.datasource import (
     UpdateCodeDataSourceRequest,
     BaseUpdateDataSourceRequest,
     FileDataSourceRequest,
+    CodeAnalysisDataSourceRequest,
+    CodeExplorationDataSourceRequest,
+    ElasticsearchStatsResponse,
 )
+from ..models.assistant import AssistantListResponse
 from ..utils import ApiRequestHandler
 
 
@@ -82,7 +87,10 @@ class DatasourceService:
                     content = f.read()
 
                 # Basic MIME type detection
-                mime_type = self._api.detect_mime_type(file_path)
+                mime_type = (
+                    mimetypes.guess_type(file_path.name)[0]
+                    or "application/octet-stream"
+                )
                 file_uploads.append(("files", (file_path.name, content, mime_type)))
 
             elif isinstance(file_item, tuple) and len(file_item) == 3:
@@ -161,16 +169,20 @@ class DatasourceService:
         params["sort_key"] = sort_key
         params["sort_order"] = sort_order
 
+        unified_filters = {}
         if datasource_types:
-            params["index_type"] = datasource_types
+            unified_filters["index_type"] = datasource_types
         if projects:
-            params["project"] = projects
+            unified_filters["project"] = projects
         if status:
-            params["status"] = status.value
+            unified_filters["status"] = status.value
         if owner:
-            params["created_by"] = owner
+            unified_filters["created_by"] = owner
         if filters:
-            params["filters"] = json.dumps(filters)
+            unified_filters.update(filters)
+        if unified_filters:
+            params["filters"] = json.dumps(unified_filters)
+
         return self._api.get("/v1/index", List[DataSource], params=params)
 
     def get(self, datasource_id: str) -> DataSource:
@@ -198,3 +210,66 @@ class DatasourceService:
             Deletion confirmation
         """
         return self._api.delete(f"/v1/index/{datasource_id}", dict)
+
+    def get_assistants_using_datasource(
+        self, datasource_id: str
+    ) -> List[AssistantListResponse]:
+        """Get list of assistants that are using this datasource.
+
+        Args:
+            datasource_id: ID of the datasource
+
+        Returns:
+            List of AssistantListResponse objects containing assistants using this datasource
+
+        Raises:
+            ApiError: If the datasource is not found or other API errors occur.
+        """
+        return self._api.get(
+            f"/v1/index/{datasource_id}/assistants", List[AssistantListResponse]
+        )
+
+    def create_provider_datasource(
+        self,
+        toolkit_id: str,
+        provider_name: str,
+        request: Union[CodeAnalysisDataSourceRequest, CodeExplorationDataSourceRequest],
+    ) -> dict:
+        """Create a provider-based datasource.
+
+        Args:
+            toolkit_id: ID of the toolkit to use
+            provider_name: Name of the provider
+            request: Provider datasource creation request (CodeAnalysisDataSourceRequest or CodeExplorationDataSourceRequest)
+
+        Returns:
+            dict: Response from the server containing operation status
+        """
+        endpoint = (
+            f"/v1/index/provider?toolkit_id={toolkit_id}&provider_name={provider_name}"
+        )
+
+        return self._api.post(
+            endpoint,
+            dict,
+            json_data=request.model_dump(by_alias=True, exclude_none=True),
+        )
+
+    def get_elasticsearch_stats(self, datasource_id: str) -> ElasticsearchStatsResponse:
+        """Get Elasticsearch statistics for a specific datasource index.
+
+        Args:
+            datasource_id: ID of the datasource
+
+        Returns:
+            ElasticsearchStatsResponse with Elasticsearch statistics including:
+            - index_name: Name of the index in Elasticsearch
+            - size_in_bytes: Size of the index in bytes
+
+        Raises:
+            ApiError: If the datasource is not found, platform datasources are not supported,
+                     or Elasticsearch statistics are not available.
+        """
+        return self._api.get(
+            f"/v1/index/{datasource_id}/elasticsearch", ElasticsearchStatsResponse
+        )

codemie_sdk/services/files.py

@@ -0,0 +1,82 @@
+"""File operation service implementation."""
+
+import mimetypes
+from pathlib import Path
+from typing import List
+
+from ..models.file_operation import FileBulkCreateResponse
+from ..utils import ApiRequestHandler
+
+
+class FileOperationService:
+    """Service for managing file operations."""
+
+    def __init__(self, api_domain: str, token: str, verify_ssl: bool = True):
+        """Initialize the file operation 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 bulk_upload(self, files: List[Path]) -> FileBulkCreateResponse:
+        """Upload multiple files in a single operation.
+
+        Args:
+            files: List of File paths (required)
+
+        Returns:
+            FileBulkCreateResponse: Results of the bulk operation including
+
+        Raises:
+            ValueError: If items in files is not a Path
+            ApiError: If bulk creation fails or validation errors occur
+        """
+
+        files_to_upload = []
+
+        for file_path in files:
+            if isinstance(file_path, Path):
+                # File path provided - read file and detect MIME type
+                with open(file_path, "rb") as file:
+                    content = file.read()
+
+                # Basic MIME type detection
+                mime_type = (
+                    mimetypes.guess_type(file_path.name)[0]
+                    or "application/octet-stream"
+                )
+                files_to_upload.append(("files", (file_path.name, content, mime_type)))
+            else:
+                raise ValueError("Each item in list must be a Path")
+
+        response = self._api.post_multipart(
+            "/v1/files/bulk",
+            files=files_to_upload,
+            response_model=FileBulkCreateResponse,
+        )
+
+        return response
+
+    def get_file(self, file_id: str) -> bytes:
+        """Get a file by its ID.
+
+        Args:
+            file_id: The file identifier (base64 encoded ID from file_url)
+
+        Returns:
+            bytes: The file content as binary data
+
+        Raises:
+            ApiError: If the file doesn't exist or there's an API error
+        """
+        import requests
+
+        response = self._api.get(
+            f"/v1/files/{file_id}",
+            response_model=requests.Response,
+            wrap_response=False,
+        )
+        return response.content

codemie_sdk/services/integration.py

@@ -5,7 +5,11 @@ from typing import List, Optional, Dict, Any
 
 from ..exceptions import NotFoundError
 from ..models.common import PaginationParams
-from ..models.integration import Integration, IntegrationType
+from ..models.integration import (
+    Integration,
+    IntegrationType,
+    IntegrationTestRequest,
+)
 from ..utils import ApiRequestHandler
 
 
@@ -150,3 +154,19 @@ class IntegrationService:
         return self._api.delete(
             f"{self._get_base_path(setting_type)}/{setting_id}", dict
         )
+
+    def test(self, integration: IntegrationTestRequest, response_type: Any) -> Any:
+        """Test an integration.
+
+        Args:
+            integration: IntegrationTestRequest - integration to test
+            response_type: Type of response expected
+
+        Returns:
+            Test integration response
+        """
+        return self._api.post(
+            "/v1/settings/test/",
+            response_model=response_type,
+            json_data=integration.model_dump(exclude_none=True),
+        )