evermemos 0.3.9__py3-none-any.whl → 0.3.10__py3-none-any.whl

evermemos/resources/v1/status/request.py

@@ -0,0 +1,175 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Optional
+
+import httpx
+
+from ...._types import Body, Query, Headers, NotGiven, not_given
+from ...._utils import maybe_transform, async_maybe_transform
+from ...._compat import cached_property
+from ...._resource import SyncAPIResource, AsyncAPIResource
+from ...._response import (
+    to_raw_response_wrapper,
+    to_streamed_response_wrapper,
+    async_to_raw_response_wrapper,
+    async_to_streamed_response_wrapper,
+)
+from ...._base_client import make_request_options
+from ....types.v1.status import request_get_params
+from ....types.v1.status.request_get_response import RequestGetResponse
+
+__all__ = ["RequestResource", "AsyncRequestResource"]
+
+
+class RequestResource(SyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> RequestResourceWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/evermemos/evermemos-python#accessing-raw-response-data-eg-headers
+        """
+        return RequestResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> RequestResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/evermemos/evermemos-python#with_streaming_response
+        """
+        return RequestResourceWithStreamingResponse(self)
+
+    def get(
+        self,
+        *,
+        request_id: Optional[str],
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> RequestGetResponse:
+        """
+        Query the processing status of a specific request
+
+        Args:
+          request_id: which is returned by add_memories api
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        return self._get(
+            "/api/v1/status/request",
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=maybe_transform({"request_id": request_id}, request_get_params.RequestGetParams),
+            ),
+            cast_to=RequestGetResponse,
+        )
+
+
+class AsyncRequestResource(AsyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> AsyncRequestResourceWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/evermemos/evermemos-python#accessing-raw-response-data-eg-headers
+        """
+        return AsyncRequestResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncRequestResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/evermemos/evermemos-python#with_streaming_response
+        """
+        return AsyncRequestResourceWithStreamingResponse(self)
+
+    async def get(
+        self,
+        *,
+        request_id: Optional[str],
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> RequestGetResponse:
+        """
+        Query the processing status of a specific request
+
+        Args:
+          request_id: which is returned by add_memories api
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        return await self._get(
+            "/api/v1/status/request",
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=await async_maybe_transform({"request_id": request_id}, request_get_params.RequestGetParams),
+            ),
+            cast_to=RequestGetResponse,
+        )
+
+
+class RequestResourceWithRawResponse:
+    def __init__(self, request: RequestResource) -> None:
+        self._request = request
+
+        self.get = to_raw_response_wrapper(
+            request.get,
+        )
+
+
+class AsyncRequestResourceWithRawResponse:
+    def __init__(self, request: AsyncRequestResource) -> None:
+        self._request = request
+
+        self.get = async_to_raw_response_wrapper(
+            request.get,
+        )
+
+
+class RequestResourceWithStreamingResponse:
+    def __init__(self, request: RequestResource) -> None:
+        self._request = request
+
+        self.get = to_streamed_response_wrapper(
+            request.get,
+        )
+
+
+class AsyncRequestResourceWithStreamingResponse:
+    def __init__(self, request: AsyncRequestResource) -> None:
+        self._request = request
+
+        self.get = async_to_streamed_response_wrapper(
+            request.get,
+        )

evermemos/resources/v1/status/status.py

@@ -0,0 +1,102 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from .request import (
+    RequestResource,
+    AsyncRequestResource,
+    RequestResourceWithRawResponse,
+    AsyncRequestResourceWithRawResponse,
+    RequestResourceWithStreamingResponse,
+    AsyncRequestResourceWithStreamingResponse,
+)
+from ...._compat import cached_property
+from ...._resource import SyncAPIResource, AsyncAPIResource
+
+__all__ = ["StatusResource", "AsyncStatusResource"]
+
+
+class StatusResource(SyncAPIResource):
+    @cached_property
+    def request(self) -> RequestResource:
+        return RequestResource(self._client)
+
+    @cached_property
+    def with_raw_response(self) -> StatusResourceWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/evermemos/evermemos-python#accessing-raw-response-data-eg-headers
+        """
+        return StatusResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> StatusResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/evermemos/evermemos-python#with_streaming_response
+        """
+        return StatusResourceWithStreamingResponse(self)
+
+
+class AsyncStatusResource(AsyncAPIResource):
+    @cached_property
+    def request(self) -> AsyncRequestResource:
+        return AsyncRequestResource(self._client)
+
+    @cached_property
+    def with_raw_response(self) -> AsyncStatusResourceWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/evermemos/evermemos-python#accessing-raw-response-data-eg-headers
+        """
+        return AsyncStatusResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncStatusResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/evermemos/evermemos-python#with_streaming_response
+        """
+        return AsyncStatusResourceWithStreamingResponse(self)
+
+
+class StatusResourceWithRawResponse:
+    def __init__(self, status: StatusResource) -> None:
+        self._status = status
+
+    @cached_property
+    def request(self) -> RequestResourceWithRawResponse:
+        return RequestResourceWithRawResponse(self._status.request)
+
+
+class AsyncStatusResourceWithRawResponse:
+    def __init__(self, status: AsyncStatusResource) -> None:
+        self._status = status
+
+    @cached_property
+    def request(self) -> AsyncRequestResourceWithRawResponse:
+        return AsyncRequestResourceWithRawResponse(self._status.request)
+
+
+class StatusResourceWithStreamingResponse:
+    def __init__(self, status: StatusResource) -> None:
+        self._status = status
+
+    @cached_property
+    def request(self) -> RequestResourceWithStreamingResponse:
+        return RequestResourceWithStreamingResponse(self._status.request)
+
+
+class AsyncStatusResourceWithStreamingResponse:
+    def __init__(self, status: AsyncStatusResource) -> None:
+        self._status = status
+
+    @cached_property
+    def request(self) -> AsyncRequestResourceWithStreamingResponse:
+        return AsyncRequestResourceWithStreamingResponse(self._status.request)

evermemos/resources/v1/v1.py

@@ -4,6 +4,14 @@ from __future__ import annotations
 
 from ..._compat import cached_property
 from ..._resource import SyncAPIResource, AsyncAPIResource
+from .status.status import (
+    StatusResource,
+    AsyncStatusResource,
+    StatusResourceWithRawResponse,
+    AsyncStatusResourceWithRawResponse,
+    StatusResourceWithStreamingResponse,
+    AsyncStatusResourceWithStreamingResponse,
+)
 from .memories.memories import (
     MemoriesResource,
     AsyncMemoriesResource,
@@ -21,6 +29,10 @@ class V1Resource(SyncAPIResource):
     def memories(self) -> MemoriesResource:
         return MemoriesResource(self._client)
 
+    @cached_property
+    def status(self) -> StatusResource:
+        return StatusResource(self._client)
+
     @cached_property
     def with_raw_response(self) -> V1ResourceWithRawResponse:
         """
@@ -46,6 +58,10 @@ class AsyncV1Resource(AsyncAPIResource):
     def memories(self) -> AsyncMemoriesResource:
         return AsyncMemoriesResource(self._client)
 
+    @cached_property
+    def status(self) -> AsyncStatusResource:
+        return AsyncStatusResource(self._client)
+
     @cached_property
     def with_raw_response(self) -> AsyncV1ResourceWithRawResponse:
         """
@@ -74,6 +90,10 @@ class V1ResourceWithRawResponse:
     def memories(self) -> MemoriesResourceWithRawResponse:
         return MemoriesResourceWithRawResponse(self._v1.memories)
 
+    @cached_property
+    def status(self) -> StatusResourceWithRawResponse:
+        return StatusResourceWithRawResponse(self._v1.status)
+
 
 class AsyncV1ResourceWithRawResponse:
     def __init__(self, v1: AsyncV1Resource) -> None:
@@ -83,6 +103,10 @@ class AsyncV1ResourceWithRawResponse:
     def memories(self) -> AsyncMemoriesResourceWithRawResponse:
         return AsyncMemoriesResourceWithRawResponse(self._v1.memories)
 
+    @cached_property
+    def status(self) -> AsyncStatusResourceWithRawResponse:
+        return AsyncStatusResourceWithRawResponse(self._v1.status)
+
 
 class V1ResourceWithStreamingResponse:
     def __init__(self, v1: V1Resource) -> None:
@@ -92,6 +116,10 @@ class V1ResourceWithStreamingResponse:
     def memories(self) -> MemoriesResourceWithStreamingResponse:
         return MemoriesResourceWithStreamingResponse(self._v1.memories)
 
+    @cached_property
+    def status(self) -> StatusResourceWithStreamingResponse:
+        return StatusResourceWithStreamingResponse(self._v1.status)
+
 
 class AsyncV1ResourceWithStreamingResponse:
     def __init__(self, v1: AsyncV1Resource) -> None:
@@ -100,3 +128,7 @@ class AsyncV1ResourceWithStreamingResponse:
     @cached_property
     def memories(self) -> AsyncMemoriesResourceWithStreamingResponse:
         return AsyncMemoriesResourceWithStreamingResponse(self._v1.memories)
+
+    @cached_property
+    def status(self) -> AsyncStatusResourceWithStreamingResponse:
+        return AsyncStatusResourceWithStreamingResponse(self._v1.status)

evermemos/types/v1/__init__.py

@@ -4,11 +4,9 @@ from __future__ import annotations
 
 from .metadata import Metadata as Metadata
 from .memory_type import MemoryType as MemoryType
-from .memory_load_params import MemoryLoadParams as MemoryLoadParams
+from .memory_add_params import MemoryAddParams as MemoryAddParams
+from .memory_add_response import MemoryAddResponse as MemoryAddResponse
 from .memory_get_response import MemoryGetResponse as MemoryGetResponse
-from .memory_create_params import MemoryCreateParams as MemoryCreateParams
 from .memory_delete_params import MemoryDeleteParams as MemoryDeleteParams
-from .memory_load_response import MemoryLoadResponse as MemoryLoadResponse
-from .memory_create_response import MemoryCreateResponse as MemoryCreateResponse
 from .memory_delete_response import MemoryDeleteResponse as MemoryDeleteResponse
 from .memory_search_response import MemorySearchResponse as MemorySearchResponse

evermemos/types/v1/memories/conversation_meta_create_params.py

@@ -7,32 +7,138 @@ from typing_extensions import Required, TypedDict
 
 from ...._types import SequenceNotStr
 
-__all__ = ["ConversationMetaCreateParams", "UserDetails"]
+__all__ = [
+    "ConversationMetaCreateParams",
+    "LlmCustomSetting",
+    "LlmCustomSettingBoundary",
+    "LlmCustomSettingExtraction",
+    "UserDetails",
+]
 
 
 class ConversationMetaCreateParams(TypedDict, total=False):
     created_at: Required[str]
+    """Conversation creation time (ISO 8601 format)"""
 
-    name: Required[str]
+    default_timezone: Optional[str]
+    """Default timezone"""
 
-    scene: Required[str]
+    description: Optional[str]
+    """Conversation description"""
 
-    scene_desc: Required[Dict[str, object]]
+    group_id: Optional[str]
+    """Group unique identifier.
 
-    default_timezone: Optional[str]
+    When null/not provided, represents default settings for this scene.
+    """
 
-    group_id: Optional[str]
+    llm_custom_setting: Optional[LlmCustomSetting]
+    """LLM custom settings for algorithm control.
+
+    **Only for global config (group_id=null), not allowed for group config (group_id
+    provided).**
+
+    Allows configuring different LLM providers/models for different tasks like
+    boundary detection and memory extraction.
+    """
+
+    name: Optional[str]
+    """Group/conversation name.
+
+    **Required for group config (group_id provided), not allowed for global config
+    (group_id=null).**
+    """
+
+    scene: Optional[str]
+    """Scene identifier.
+
+    **Required for global config (group_id=null), not allowed for group config
+    (group_id provided).**
+
+    Enum values from ScenarioType:
+
+    - group_chat: work/group chat scenario, suitable for group conversations such as
+      multi-person collaboration and project discussions
+    - assistant: assistant scenario, suitable for one-on-one AI assistant
+      conversations
+    """
+
+    scene_desc: Optional[Dict[str, object]]
+    """Scene description object.
+
+    **Required for global config (group_id=null), not allowed for group config
+    (group_id provided).**
+
+    Can include fields like description, type, etc.
+    """
 
     tags: Optional[SequenceNotStr[str]]
+    """Tag list"""
 
     user_details: Optional[Dict[str, UserDetails]]
+    """Participant details, key is user ID, value is user detail object"""
+
+
+class LlmCustomSettingBoundary(TypedDict, total=False):
+    """LLM config for boundary detection (fast, cheap model recommended)"""
+
+    model: Required[str]
+    """Model name"""
+
+    provider: Required[str]
+    """LLM provider name"""
+
+    extra: Optional[Dict[str, object]]
+    """Additional provider-specific configuration"""
+
+
+class LlmCustomSettingExtraction(TypedDict, total=False):
+    """LLM config for memory extraction (high quality model recommended)"""
+
+    model: Required[str]
+    """Model name"""
+
+    provider: Required[str]
+    """LLM provider name"""
+
+    extra: Optional[Dict[str, object]]
+    """Additional provider-specific configuration"""
+
+
+class LlmCustomSetting(TypedDict, total=False):
+    """LLM custom settings for algorithm control.
+
+    **Only for global config (group_id=null),
+    not allowed for group config (group_id provided).**
+
+    Allows configuring different LLM providers/models for different tasks like boundary detection and memory extraction.
+    """
+
+    boundary: Optional[LlmCustomSettingBoundary]
+    """LLM config for boundary detection (fast, cheap model recommended)"""
+
+    extra: Optional[Dict[str, object]]
+    """Additional task-specific LLM configurations"""
+
+    extraction: Optional[LlmCustomSettingExtraction]
+    """LLM config for memory extraction (high quality model recommended)"""
 
 
 class UserDetails(TypedDict, total=False):
     custom_role: Optional[str]
+    """User's job/position role (e.g. developer, designer, manager)"""
 
     extra: Optional[Dict[str, object]]
+    """Additional information"""
 
     full_name: Optional[str]
+    """User full name"""
 
     role: Optional[str]
+    """
+    User type role, used to identify if this user is a human or AI. Enum values from
+    MessageSenderRole:
+
+    - user: Human user
+    - assistant: AI assistant/bot
+    """

evermemos/types/v1/memories/conversation_meta_create_response.py

@@ -4,38 +4,106 @@ from typing import Dict, List, Optional
 
 from ...._models import BaseModel
 
-__all__ = ["ConversationMetaCreateResponse", "Result"]
+__all__ = [
+    "ConversationMetaCreateResponse",
+    "Result",
+    "ResultLlmCustomSetting",
+    "ResultLlmCustomSettingBoundary",
+    "ResultLlmCustomSettingExtraction",
+]
 
 
-class Result(BaseModel):
-    id: str
+class ResultLlmCustomSettingBoundary(BaseModel):
+    """LLM config for boundary detection (fast, cheap model recommended)"""
+
+    model: str
+    """Model name"""
+
+    provider: str
+    """LLM provider name"""
+
+    extra: Optional[Dict[str, object]] = None
+    """Additional provider-specific configuration"""
+
+
+class ResultLlmCustomSettingExtraction(BaseModel):
+    """LLM config for memory extraction (high quality model recommended)"""
+
+    model: str
+    """Model name"""
+
+    provider: str
+    """LLM provider name"""
+
+    extra: Optional[Dict[str, object]] = None
+    """Additional provider-specific configuration"""
+
 
-    conversation_created_at: str
+class ResultLlmCustomSetting(BaseModel):
+    """LLM custom settings (only for global config)"""
 
-    name: str
+    boundary: Optional[ResultLlmCustomSettingBoundary] = None
+    """LLM config for boundary detection (fast, cheap model recommended)"""
 
-    scene: str
+    extra: Optional[Dict[str, object]] = None
+    """Additional task-specific LLM configurations"""
+
+    extraction: Optional[ResultLlmCustomSettingExtraction] = None
+    """LLM config for memory extraction (high quality model recommended)"""
+
+
+class Result(BaseModel):
+    """Saved conversation metadata"""
+
+    id: str
+    """Document ID"""
+
+    conversation_created_at: Optional[str] = None
+    """Conversation creation time"""
 
     created_at: Optional[str] = None
+    """Record creation time"""
 
     default_timezone: Optional[str] = None
+    """Default timezone"""
+
+    description: Optional[str] = None
+    """Description"""
 
     group_id: Optional[str] = None
+    """Group ID (null for global config)"""
 
     is_default: Optional[bool] = None
+    """Whether this is the global (default) config"""
+
+    llm_custom_setting: Optional[ResultLlmCustomSetting] = None
+    """LLM custom settings (only for global config)"""
+
+    name: Optional[str] = None
+    """Group/conversation name (only for group config)"""
+
+    scene: Optional[str] = None
+    """Scene identifier (only for global config)"""
 
     scene_desc: Optional[Dict[str, object]] = None
+    """Scene description (only for global config)"""
 
     tags: Optional[List[str]] = None
+    """Tags"""
 
     updated_at: Optional[str] = None
+    """Record update time"""
 
     user_details: Optional[Dict[str, Dict[str, object]]] = None
+    """User details"""
 
 
 class ConversationMetaCreateResponse(BaseModel):
     result: Result
+    """Saved conversation metadata"""
 
     message: Optional[str] = None
+    """Response message"""
 
     status: Optional[str] = None
+    """Response status"""