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

codemie_sdk/models/vendor_workflow.py

@@ -0,0 +1,145 @@
+"""Models for vendor workflow settings."""
+
+from datetime import datetime
+from enum import Enum
+from typing import Optional, List
+
+from pydantic import BaseModel, ConfigDict, Field
+
+from .vendor_assistant import PaginationInfo, TokenPagination
+
+
+class VendorWorkflowSetting(BaseModel):
+    """Model representing a vendor workflow setting."""
+
+    model_config = ConfigDict(extra="ignore")
+
+    setting_id: str = Field(..., description="Unique identifier for the setting")
+    setting_name: str = Field(..., description="Name of the setting")
+    project: str = Field(..., description="Project associated with the setting")
+    entities: List[str] = Field(
+        default_factory=list, description="List of entities associated with the setting"
+    )
+    invalid: Optional[bool] = Field(None, description="Whether the setting is invalid")
+    error: Optional[str] = Field(
+        None, description="Error message if the setting is invalid"
+    )
+
+
+class VendorWorkflowSettingsResponse(BaseModel):
+    """Response model for vendor workflow settings list."""
+
+    model_config = ConfigDict(extra="ignore")
+
+    data: List[VendorWorkflowSetting] = Field(
+        ..., description="List of vendor workflow settings"
+    )
+    pagination: PaginationInfo = Field(..., description="Pagination information")
+
+
+class VendorWorkflowStatus(str, Enum):
+    """Status of vendor workflow."""
+
+    PREPARED = "PREPARED"
+    NOT_PREPARED = "NOT_PREPARED"
+
+
+class VendorWorkflow(BaseModel):
+    """Model representing a vendor workflow."""
+
+    model_config = ConfigDict(extra="ignore")
+
+    id: str = Field(..., description="Unique identifier for the workflow")
+    name: str = Field(..., description="Name of the workflow")
+    status: VendorWorkflowStatus = Field(..., description="Status of the workflow")
+    description: Optional[str] = Field(None, description="Description of the workflow")
+    version: str = Field(..., description="Version of the workflow")
+    createdAt: datetime = Field(
+        ..., description="Creation timestamp", alias="createdAt"
+    )
+    updatedAt: datetime = Field(
+        ..., description="Last update timestamp", alias="updatedAt"
+    )
+
+
+class VendorWorkflowsResponse(BaseModel):
+    """Response model for vendor workflows list."""
+
+    model_config = ConfigDict(extra="ignore")
+
+    data: List[VendorWorkflow] = Field(..., description="List of vendor workflows")
+    pagination: TokenPagination = Field(
+        ..., description="Token-based pagination information"
+    )
+
+
+class VendorWorkflowAlias(BaseModel):
+    """Model representing a vendor workflow alias."""
+
+    model_config = ConfigDict(extra="ignore")
+
+    id: str = Field(..., description="Unique identifier for the alias")
+    name: str = Field(..., description="Name of the alias")
+    status: VendorWorkflowStatus = Field(..., description="Status of the alias")
+    description: Optional[str] = Field(None, description="Description of the alias")
+    version: str = Field(..., description="Version of the alias")
+    createdAt: datetime = Field(
+        ..., description="Creation timestamp", alias="createdAt"
+    )
+    updatedAt: datetime = Field(
+        ..., description="Last update timestamp", alias="updatedAt"
+    )
+    aiRunId: Optional[str] = Field(
+        None, description="AI run ID if the alias is installed", alias="aiRunId"
+    )
+
+
+class VendorWorkflowAliasesResponse(BaseModel):
+    """Response model for vendor workflow aliases list."""
+
+    model_config = ConfigDict(extra="ignore")
+
+    data: List[VendorWorkflowAlias] = Field(
+        ..., description="List of vendor workflow aliases"
+    )
+    pagination: TokenPagination = Field(
+        ..., description="Token-based pagination information"
+    )
+
+
+class VendorWorkflowInstallRequest(BaseModel):
+    """Model for a single workflow installation request."""
+
+    model_config = ConfigDict(extra="ignore")
+
+    id: str = Field(..., description="Workflow ID to install")
+    flowAliasId: str = Field(..., description="Flow alias ID to use for the workflow")
+    setting_id: str = Field(..., description="Vendor setting ID")
+
+
+class VendorWorkflowInstallSummary(BaseModel):
+    """Model for workflow installation summary."""
+
+    model_config = ConfigDict(extra="ignore")
+
+    flowId: str = Field(..., description="Installed workflow ID")
+    flowAliasId: str = Field(..., description="Flow alias ID used for installation")
+    aiRunId: str = Field(..., description="AI run ID for the installation")
+
+
+class VendorWorkflowInstallResponse(BaseModel):
+    """Response model for workflow installation."""
+
+    model_config = ConfigDict(extra="ignore")
+
+    summary: List[VendorWorkflowInstallSummary] = Field(
+        ..., description="List of installation summaries"
+    )
+
+
+class VendorWorkflowUninstallResponse(BaseModel):
+    """Response model for workflow uninstallation."""
+
+    model_config = ConfigDict(extra="ignore")
+
+    success: bool = Field(..., description="Whether the uninstallation was successful")

codemie_sdk/models/workflow.py

@@ -84,6 +84,6 @@ class WorkflowExecution(BaseModel):
     status: ExecutionStatus = Field(alias="overall_status")
     created_date: datetime = Field(alias="date")
     prompt: str
-    updated_date: Optional[datetime] = None
+    updated_date: Optional[datetime] = Field(alias="update_date")
     created_by: User
     tokens_usage: Optional[TokensUsage] = None

codemie_sdk/models/workflow_execution_payload.py

@@ -0,0 +1,21 @@
+"""Workflow execution payload models."""
+
+from typing import Optional, Union
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class WorkflowExecutionCreateRequest(BaseModel):
+    """Request model for workflow execution creation."""
+
+    model_config = ConfigDict(populate_by_name=True)
+
+    user_input: Optional[Union[str, dict, list, int, float, bool]] = Field(
+        None, description="User input for the workflow execution"
+    )
+    file_name: Optional[str] = Field(
+        None, description="File name associated with the workflow execution"
+    )
+    propagate_headers: bool = Field(
+        default=False,
+        description="Enable propagation of X-* HTTP headers to MCP servers during tool execution",
+    )

codemie_sdk/models/workflow_state.py

@@ -2,7 +2,7 @@
 
 from datetime import datetime
 from enum import Enum
-from typing import Optional
+from typing import List, Optional
 
 from pydantic import BaseModel, ConfigDict
 
@@ -24,9 +24,11 @@ class WorkflowExecutionStateThought(BaseModel):
     model_config = ConfigDict(populate_by_name=True)
 
     id: str
-    text: str
-    created_at: datetime
+    execution_state_id: str
     parent_id: Optional[str] = None
+    author_name: str
+    author_type: str
+    date: datetime
 
 
 class WorkflowExecutionState(BaseModel):
@@ -41,6 +43,7 @@ class WorkflowExecutionState(BaseModel):
     status: WorkflowExecutionStatusEnum = WorkflowExecutionStatusEnum.NOT_STARTED
     started_at: Optional[datetime] = None
     completed_at: Optional[datetime] = None
+    thoughts: Optional[List[WorkflowExecutionStateThought]] = None
 
 
 class WorkflowExecutionStateOutput(BaseModel):

codemie_sdk/models/workflow_thoughts.py

@@ -0,0 +1,26 @@
+"""Workflow execution thoughts models."""
+
+from datetime import datetime
+from typing import List, Optional
+
+from pydantic import BaseModel, ConfigDict
+
+
+class WorkflowExecutionThought(BaseModel):
+    """Model for workflow execution thought."""
+
+    model_config = ConfigDict(populate_by_name=True)
+
+    id: str
+    execution_state_id: str
+    parent_id: Optional[str] = None
+    author_name: str
+    author_type: str
+    input_text: str
+    content: str
+    date: datetime
+    children: List["WorkflowExecutionThought"] = []
+
+
+# Update forward references for recursive model
+WorkflowExecutionThought.model_rebuild()

codemie_sdk/services/assistant.py

@@ -1,5 +1,6 @@
 """Assistant service implementation."""
 
+import inspect
 import json
 from pathlib import Path
 from typing import List, Union, Optional, Dict, Any, Literal
@@ -169,22 +170,163 @@ 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
         """
         pydantic_schema = None
-        if issubclass(request.output_schema, BaseModel):
+        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()
 
@@ -193,6 +335,7 @@ class AssistantService:
             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,
@@ -201,6 +344,82 @@ class AssistantService:
 
         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."""
 

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

@@ -15,7 +15,11 @@ from ..models.datasource import (
     UpdateCodeDataSourceRequest,
     BaseUpdateDataSourceRequest,
     FileDataSourceRequest,
+    CodeAnalysisDataSourceRequest,
+    CodeExplorationDataSourceRequest,
+    ElasticsearchStatsResponse,
 )
+from ..models.assistant import AssistantListResponse
 from ..utils import ApiRequestHandler
 
 
@@ -206,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
+        )