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

evermemos/types/v1/memories/conversation_meta_get_response.py

@@ -4,38 +4,106 @@ from typing import Dict, List, Optional
 
 from ...._models import BaseModel
 
-__all__ = ["ConversationMetaGetResponse", "Result"]
+__all__ = [
+    "ConversationMetaGetResponse",
+    "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):
+    """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 ConversationMetaGetResponse(BaseModel):
     result: Result
+    """Conversation metadata"""
 
     message: Optional[str] = None
+    """Response message"""
 
     status: Optional[str] = None
+    """Response status"""

evermemos/types/v1/memories/conversation_meta_update_params.py

@@ -3,32 +3,115 @@
 from __future__ import annotations
 
 from typing import Dict, Optional
-from typing_extensions import TypedDict
+from typing_extensions import Required, TypedDict
 
 from ...._types import SequenceNotStr
 
-__all__ = ["ConversationMetaUpdateParams", "UserDetails"]
+__all__ = [
+    "ConversationMetaUpdateParams",
+    "LlmCustomSetting",
+    "LlmCustomSettingBoundary",
+    "LlmCustomSettingExtraction",
+    "UserDetails",
+]
 
 
 class ConversationMetaUpdateParams(TypedDict, total=False):
     default_timezone: Optional[str]
+    """New default timezone"""
+
+    description: Optional[str]
+    """New description"""
 
     group_id: Optional[str]
+    """Group ID to update. When null, updates the global (default) config."""
+
+    llm_custom_setting: Optional[LlmCustomSetting]
+    """New LLM custom settings.
+
+    **Only allowed for global config (group_id=null). Not allowed for group config
+    (inherited from global config).**
+    """
 
     name: Optional[str]
+    """New group/conversation name.
+
+    **Only allowed for group config (group_id provided). Not allowed for global
+    config.**
+    """
 
     scene_desc: Optional[Dict[str, object]]
+    """New scene description.
+
+    **Only allowed for global config (group_id=null). Not allowed for group config
+    (inherited from global config).**
+    """
 
     tags: Optional[SequenceNotStr[str]]
+    """New tag list"""
 
     user_details: Optional[Dict[str, UserDetails]]
+    """New user details (will completely replace existing user_details)"""
+
+
+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):
+    """New LLM custom settings.
+
+    **Only allowed for global config (group_id=null).
+    Not allowed for group config (inherited from global config).**
+    """
+
+    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_update_response.py

@@ -8,22 +8,33 @@ __all__ = ["ConversationMetaUpdateResponse", "Result"]
 
 
 class Result(BaseModel):
+    """Patch result with updated fields"""
+
     id: str
+    """Document ID"""
 
     group_id: Optional[str] = None
+    """Group ID (null for default config)"""
 
     name: Optional[str] = None
+    """Conversation name"""
 
     scene: Optional[str] = None
+    """Scene identifier"""
 
     updated_at: Optional[str] = None
+    """Record update time"""
 
     updated_fields: Optional[List[str]] = None
+    """List of updated field names"""
 
 
 class ConversationMetaUpdateResponse(BaseModel):
     result: Result
+    """Patch result with updated fields"""
 
     message: Optional[str] = None
+    """Response message"""
 
     status: Optional[str] = None
+    """Response status"""

evermemos/types/v1/memory_add_params.py

@@ -0,0 +1,60 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Optional
+from typing_extensions import Required, TypedDict
+
+from ..._types import SequenceNotStr
+
+__all__ = ["MemoryAddParams"]
+
+
+class MemoryAddParams(TypedDict, total=False):
+    content: Required[str]
+    """Message content"""
+
+    create_time: Required[str]
+    """Message creation time (ISO 8601 format)"""
+
+    message_id: Required[str]
+    """Message unique identifier"""
+
+    sender: Required[str]
+    """Sender user ID (required).
+
+    Also used as user_id internally for memory ownership.
+    """
+
+    flush: bool
+    """Force boundary trigger.
+
+    When True, immediately triggers memory extraction instead of waiting for natural
+    boundary detection.
+    """
+
+    group_id: Optional[str]
+    """Group ID.
+
+    If not provided, will automatically generate based on hash(sender) + '\\__group'
+    suffix, representing single-user mode where each user's messages are extracted
+    into separate memory spaces.
+    """
+
+    group_name: Optional[str]
+    """Group name"""
+
+    refer_list: Optional[SequenceNotStr[str]]
+    """List of referenced message IDs"""
+
+    role: Optional[str]
+    """
+    Message sender role, used to identify the source of the message. Enum values
+    from MessageSenderRole:
+
+    - user: Message from a human user
+    - assistant: Message from an AI assistant
+    """
+
+    sender_name: Optional[str]
+    """Sender name (uses sender if not provided)"""

evermemos/types/v1/{memory_create_response.py → memory_add_response.py}

@@ -2,10 +2,10 @@
 
 from ..._models import BaseModel
 
-__all__ = ["MemoryCreateResponse"]
+__all__ = ["MemoryAddResponse"]
 
 
-class MemoryCreateResponse(BaseModel):
+class MemoryAddResponse(BaseModel):
     message: str
 
     request_id: str

evermemos/types/v1/memory_delete_params.py

@@ -9,8 +9,17 @@ __all__ = ["MemoryDeleteParams"]
 
 
 class MemoryDeleteParams(TypedDict, total=False):
+    id: Optional[str]
+    """Alias for memory_id (backward compatibility)"""
+
+    event_id: Optional[str]
+    """Alias for memory_id (backward compatibility)"""
+
     group_id: Optional[str]
+    """Group ID (filter condition)"""
 
     memory_id: Optional[str]
+    """Memory id (filter condition)"""
 
     user_id: Optional[str]
+    """User ID (filter condition)"""

evermemos/types/v1/memory_delete_response.py

@@ -8,14 +8,21 @@ __all__ = ["MemoryDeleteResponse", "Result"]
 
 
 class Result(BaseModel):
+    """Delete operation result"""
+
     count: Optional[int] = None
+    """Number of memories deleted"""
 
     filters: Optional[List[str]] = None
+    """List of filter types used for deletion"""
 
 
 class MemoryDeleteResponse(BaseModel):
     result: Result
+    """Delete operation result"""
 
     message: Optional[str] = None
+    """Response message"""
 
     status: Optional[str] = None
+    """Response status"""

evermemos/types/v1/memory_get_response.py

@@ -125,23 +125,21 @@ class ResultMemoryEpisodicMemoryModel(BaseModel):
 
     episode_id: str
 
-    summary: str
-
-    title: str
-
     user_id: str
 
     created_at: Optional[datetime] = None
 
     end_time: Optional[datetime] = None
 
+    episode: Optional[str] = None
+
     extend: Optional[Dict[str, object]] = None
 
     group_id: Optional[str] = None
 
     group_name: Optional[str] = None
 
-    key_events: Optional[List[str]] = None
+    keywords: Optional[List[str]] = None
 
     location: Optional[str] = None
 
@@ -157,6 +155,8 @@ class ResultMemoryEpisodicMemoryModel(BaseModel):
 
     subject: Optional[str] = None
 
+    summary: Optional[str] = None
+
     timestamp: Optional[datetime] = None
 
     updated_at: Optional[datetime] = None
@@ -203,6 +203,8 @@ class ResultMemoryForesightModel(BaseModel):
 
     content: str
 
+    foresight: str
+
     parent_id: str
 
     parent_type: str
@@ -249,6 +251,8 @@ ResultMemory: TypeAlias = Union[
 
 
 class Result(BaseModel):
+    """Memory fetch result"""
+
     has_more: Optional[bool] = None
 
     memories: Optional[List[ResultMemory]] = None
@@ -260,7 +264,10 @@ class Result(BaseModel):
 
 class MemoryGetResponse(BaseModel):
     result: Result
+    """Memory fetch result"""
 
     message: Optional[str] = None
+    """Response message"""
 
     status: Optional[str] = None
+    """Response status"""

evermemos/types/v1/memory_search_response.py

@@ -74,6 +74,8 @@ class ResultPendingMessage(BaseModel):
 
 
 class Result(BaseModel):
+    """Memory search result"""
+
     has_more: Optional[bool] = None
 
     memories: Optional[List[ResultMemory]] = None
@@ -93,7 +95,10 @@ class Result(BaseModel):
 
 class MemorySearchResponse(BaseModel):
     result: Result
+    """Memory search result"""
 
     message: Optional[str] = None
+    """Response message"""
 
     status: Optional[str] = None
+    """Response status"""

evermemos/types/v1/status/__init__.py

@@ -0,0 +1,6 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from .request_get_params import RequestGetParams as RequestGetParams
+from .request_get_response import RequestGetResponse as RequestGetResponse

evermemos/types/v1/status/request_get_params.py

@@ -0,0 +1,13 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Optional
+from typing_extensions import Required, TypedDict
+
+__all__ = ["RequestGetParams"]
+
+
+class RequestGetParams(TypedDict, total=False):
+    request_id: Required[Optional[str]]
+    """which is returned by add_memories api"""

evermemos/types/v1/status/request_get_response.py

@@ -0,0 +1,21 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Dict, Optional
+
+from ...._models import BaseModel
+
+__all__ = ["RequestGetResponse"]
+
+
+class RequestGetResponse(BaseModel):
+    success: bool
+    """Whether the query was successful"""
+
+    data: Optional[Dict[str, object]] = None
+    """Request status data"""
+
+    found: Optional[bool] = None
+    """Whether the request status was found"""
+
+    message: Optional[str] = None
+    """Message"""

{evermemos-0.3.9.dist-info → evermemos-0.3.10.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: evermemos
-Version: 0.3.9
+Version: 0.3.10
 Summary: The official Python library for the EverMemOS API
 Project-URL: Homepage, https://github.com/evermemos/evermemos-python
 Project-URL: Repository, https://github.com/evermemos/evermemos-python
@@ -67,13 +67,13 @@ client = EverMemOS(
     api_key=os.environ.get("EVERMEMOS_API_KEY"),  # This is the default and can be omitted
 )
 
-memory = client.v1.memories.create(
+response = client.v1.memories.add(
     content="Let's discuss the technical solution for the new feature today",
     create_time="2025-01-15T10:00:00+00:00",
     message_id="msg_001",
     sender="user_001",
 )
-print(memory.request_id)
+print(response.request_id)
 ```
 
 While you can provide an `api_key` keyword argument,
@@ -96,13 +96,13 @@ client = AsyncEverMemOS(
 
 
 async def main() -> None:
-    memory = await client.v1.memories.create(
+    response = await client.v1.memories.add(
         content="Let's discuss the technical solution for the new feature today",
         create_time="2025-01-15T10:00:00+00:00",
         message_id="msg_001",
         sender="user_001",
     )
-    print(memory.request_id)
+    print(response.request_id)
 
 
 asyncio.run(main())
@@ -135,13 +135,13 @@ async def main() -> None:
         api_key=os.environ.get("EVERMEMOS_API_KEY"),  # This is the default and can be omitted
         http_client=DefaultAioHttpClient(),
     ) as client:
-        memory = await client.v1.memories.create(
+        response = await client.v1.memories.add(
             content="Let's discuss the technical solution for the new feature today",
             create_time="2025-01-15T10:00:00+00:00",
             message_id="msg_001",
             sender="user_001",
         )
-        print(memory.request_id)
+        print(response.request_id)
 
 
 asyncio.run(main())
@@ -165,22 +165,20 @@ from evermemos import EverMemOS
 
 client = EverMemOS()
 
-response = client.v1.memories.load(
-    conversation_meta={
-        "group_id": "chat_user_001_assistant",
-        "created_at": "2025-06-26T00:00:00Z",
-        "default_timezone": "UTC",
-        "name": "User Support Chat",
-        "scene": "assistant",
-        "scene_desc": {},
-        "tags": ["support"],
-        "user_details": {
-            "user_001": "bar",
-            "robot_001": "bar",
+conversation_meta = client.v1.memories.conversation_meta.create(
+    created_at="2025-01-15T10:00:00+00:00",
+    llm_custom_setting={
+        "boundary": {
+            "model": "gpt-4o-mini",
+            "provider": "openai",
+        },
+        "extraction": {
+            "model": "gpt-4o",
+            "provider": "openai",
         },
     },
 )
-print(response.conversation_meta)
+print(conversation_meta.llm_custom_setting)
 ```
 
 ## Handling errors
@@ -199,7 +197,7 @@ from evermemos import EverMemOS
 client = EverMemOS()
 
 try:
-    client.v1.memories.create(
+    client.v1.memories.add(
         content="Let's discuss the technical solution for the new feature today",
         create_time="2025-01-15T10:00:00+00:00",
         message_id="msg_001",
@@ -247,7 +245,7 @@ client = EverMemOS(
 )
 
 # Or, configure per-request:
-client.with_options(max_retries=5).v1.memories.create(
+client.with_options(max_retries=5).v1.memories.add(
     content="Let's discuss the technical solution for the new feature today",
     create_time="2025-01-15T10:00:00+00:00",
     message_id="msg_001",
@@ -275,7 +273,7 @@ client = EverMemOS(
 )
 
 # Override per-request:
-client.with_options(timeout=5.0).v1.memories.create(
+client.with_options(timeout=5.0).v1.memories.add(
     content="Let's discuss the technical solution for the new feature today",
     create_time="2025-01-15T10:00:00+00:00",
     message_id="msg_001",
@@ -321,7 +319,7 @@ The "raw" Response object can be accessed by prefixing `.with_raw_response.` to
 from evermemos import EverMemOS
 
 client = EverMemOS()
-response = client.v1.memories.with_raw_response.create(
+response = client.v1.memories.with_raw_response.add(
     content="Let's discuss the technical solution for the new feature today",
     create_time="2025-01-15T10:00:00+00:00",
     message_id="msg_001",
@@ -329,7 +327,7 @@ response = client.v1.memories.with_raw_response.create(
 )
 print(response.headers.get('X-My-Header'))
 
-memory = response.parse()  # get the object that `v1.memories.create()` would have returned
+memory = response.parse()  # get the object that `v1.memories.add()` would have returned
 print(memory.request_id)
 ```
 
@@ -344,7 +342,7 @@ The above interface eagerly reads the full response body when you make the reque
 To stream the response body, use `.with_streaming_response` instead, which requires a context manager and only reads the response body once you call `.read()`, `.text()`, `.json()`, `.iter_bytes()`, `.iter_text()`, `.iter_lines()` or `.parse()`. In the async client, these are async methods.
 
 ```python
-with client.v1.memories.with_streaming_response.create(
+with client.v1.memories.with_streaming_response.add(
     content="Let's discuss the technical solution for the new feature today",
     create_time="2025-01-15T10:00:00+00:00",
     message_id="msg_001",