simile 0.3.12__tar.gz → 0.4.1__tar.gz

{simile-0.3.12 → simile-0.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: simile
-Version: 0.3.12
+Version: 0.4.1
 Summary: Package for interfacing with Simile AI agents for simulation
 Author-email: Simile AI <cqz@simile.ai>
 License: MIT

{simile-0.3.12 → simile-0.4.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "simile"
-version = "0.3.12"
+version = "0.4.1"
 authors = [
   { name="Simile AI", email="cqz@simile.ai" },
 ]

{simile-0.3.12 → simile-0.4.1}/simile/__init__.py

@@ -14,6 +14,13 @@ from .models import (
     OpenGenerationResponse,
     ClosedGenerationRequest,
     ClosedGenerationResponse,
+    MemoryStream,
+    MemoryTurn,
+    MemoryTurnType,
+    ContextMemoryTurn,
+    ImageMemoryTurn,
+    OpenQuestionMemoryTurn,
+    ClosedQuestionMemoryTurn,
 )
 from .exceptions import (
     SimileAPIError,
@@ -38,6 +45,13 @@ __all__ = [
     "OpenGenerationResponse",
     "ClosedGenerationRequest",
     "ClosedGenerationResponse",
+    "MemoryStream",
+    "MemoryTurn",
+    "MemoryTurnType",
+    "ContextMemoryTurn",
+    "ImageMemoryTurn",
+    "OpenQuestionMemoryTurn",
+    "ClosedQuestionMemoryTurn",
     "SimileAPIError",
     "SimileAuthenticationError",
     "SimileNotFoundError",

{simile-0.3.12 → simile-0.4.1}/simile/client.py

@@ -21,6 +21,7 @@ from .models import (
     InitialDataItemPayload,
     SurveySessionCreateResponse,
     SurveySessionDetailResponse,
+    MemoryStream,
 )
 from .resources import Agent, SurveySession
 from .exceptions import (
@@ -254,6 +255,18 @@ class Simile:
             "DELETE", f"agents/{str(agent_id)}/populations/{str(population_id)}"
         )
         return raw_response.json()
+    
+    async def batch_add_agents_to_population(
+        self, agent_ids: List[Union[str, uuid.UUID]], population_id: Union[str, uuid.UUID]
+    ) -> Dict[str, Any]:
+        """Add multiple agents to a population in a single batch operation."""
+        agent_id_strs = [str(aid) for aid in agent_ids]
+        raw_response = await self._request(
+            "POST", 
+            f"populations/{str(population_id)}/agents/batch",
+            json=agent_id_strs
+        )
+        return raw_response.json()
 
     async def get_populations_for_agent(
         self, agent_id: Union[str, uuid.UUID]
@@ -333,6 +346,7 @@ class Simile:
         exclude_data_types: Optional[List[str]] = None,
         images: Optional[Dict[str, str]] = None,
         reasoning: bool = False,
+        memory_stream: Optional[MemoryStream] = None,
     ) -> AsyncGenerator[str, None]:
         """Streams an open response from an agent."""
         endpoint = f"/generation/open-stream/{str(agent_id)}"
@@ -398,22 +412,75 @@ class Simile:
         exclude_data_types: Optional[List[str]] = None,
         images: Optional[Dict[str, str]] = None,
         reasoning: bool = False,
+        memory_stream: Optional[MemoryStream] = None,
+        use_memory: Optional[Union[str, uuid.UUID]] = None,  # Session ID to load memory from
+        exclude_memory_ids: Optional[List[str]] = None,  # Study/question IDs to exclude
+        save_memory: Optional[Union[str, uuid.UUID]] = None,  # Session ID to save memory to
     ) -> OpenGenerationResponse:
-        """Generates an open response from an agent based on a question."""
+        """Generates an open response from an agent based on a question.
+        
+        Args:
+            agent_id: The agent to query
+            question: The question to ask
+            data_types: Optional data types to include
+            exclude_data_types: Optional data types to exclude
+            images: Optional images dict
+            reasoning: Whether to include reasoning
+            memory_stream: Explicit memory stream to use (overrides use_memory)
+            use_memory: Session ID to automatically load memory from
+            exclude_memory_ids: Study/question IDs to exclude from loaded memory
+            save_memory: Session ID to automatically save response to memory
+        """
+        # If use_memory is provided and no explicit memory_stream, load it
+        if use_memory and not memory_stream:
+            memory_stream = await self.get_memory(
+                session_id=use_memory,
+                agent_id=agent_id,
+                exclude_study_ids=exclude_memory_ids,
+                use_memory=True
+            )
+        
         endpoint = f"/generation/open/{str(agent_id)}"
-        request_payload = OpenGenerationRequest(
-            question=question,
-            data_types=data_types,
-            exclude_data_types=exclude_data_types,
-            images=images,
-            reasoning=reasoning,
-        )
+        # Build request payload directly as dict to avoid serialization issues
+        request_payload = {
+            "question": question,
+            "data_types": data_types,
+            "exclude_data_types": exclude_data_types,
+            "images": images,
+            "reasoning": reasoning,
+        }
+        
+        if memory_stream:
+            request_payload["memory_stream"] = memory_stream.to_dict()
+        
         response_data = await self._request(
             "POST",
             endpoint,
-            json=request_payload.model_dump(),
+            json=request_payload,
             response_model=OpenGenerationResponse,
         )
+        
+        # If save_memory is provided, save the response
+        if save_memory and response_data:
+            from .models import OpenQuestionMemoryTurn
+            
+            memory_turn = OpenQuestionMemoryTurn(
+                user_question=question,
+                user_images=images,
+                llm_response=response_data.answer,
+                llm_reasoning=response_data.reasoning if reasoning else None
+            )
+            
+            await self.save_memory(
+                agent_id=agent_id,
+                response=response_data.answer,
+                session_id=save_memory,
+                memory_turn=memory_turn.to_dict(),
+                memory_stream_used=memory_stream.to_dict() if memory_stream else None,
+                reasoning=response_data.reasoning if reasoning else None,
+                metadata={"question_type": "open"}
+            )
+        
         return response_data
 
     async def generate_closed_response(
@@ -425,25 +492,260 @@ class Simile:
         exclude_data_types: Optional[List[str]] = None,
         images: Optional[Dict[str, str]] = None,
         reasoning: bool = False,
+        memory_stream: Optional[MemoryStream] = None,
+        use_memory: Optional[Union[str, uuid.UUID]] = None,  # Session ID to load memory from
+        exclude_memory_ids: Optional[List[str]] = None,  # Study/question IDs to exclude
+        save_memory: Optional[Union[str, uuid.UUID]] = None,  # Session ID to save memory to
     ) -> ClosedGenerationResponse:
-        """Generates a closed response from an agent."""
+        """Generates a closed response from an agent.
+        
+        Args:
+            agent_id: The agent to query
+            question: The question to ask
+            options: The options to choose from
+            data_types: Optional data types to include
+            exclude_data_types: Optional data types to exclude
+            images: Optional images dict
+            reasoning: Whether to include reasoning
+            memory_stream: Explicit memory stream to use (overrides use_memory)
+            use_memory: Session ID to automatically load memory from
+            exclude_memory_ids: Study/question IDs to exclude from loaded memory
+            save_memory: Session ID to automatically save response to memory
+        """
+        # If use_memory is provided and no explicit memory_stream, load it
+        if use_memory and not memory_stream:
+            memory_stream = await self.get_memory(
+                session_id=use_memory,
+                agent_id=agent_id,
+                exclude_study_ids=exclude_memory_ids,
+                use_memory=True
+            )
+        
         endpoint = f"generation/closed/{str(agent_id)}"
-        request_payload = ClosedGenerationRequest(
-            question=question,
-            options=options,
-            data_types=data_types,
-            exclude_data_types=exclude_data_types,
-            images=images,
-            reasoning=reasoning,
-        )
+        # Build request payload directly as dict to avoid serialization issues
+        request_payload = {
+            "question": question,
+            "options": options,
+            "data_types": data_types,
+            "exclude_data_types": exclude_data_types,
+            "images": images,
+            "reasoning": reasoning,
+        }
+        
+        if memory_stream:
+            request_payload["memory_stream"] = memory_stream.to_dict()
+        
         response_data = await self._request(
             "POST",
             endpoint,
-            json=request_payload.model_dump(),
+            json=request_payload,
             response_model=ClosedGenerationResponse,
         )
+        
+        # If save_memory is provided, save the response
+        if save_memory and response_data:
+            from .models import ClosedQuestionMemoryTurn
+            
+            memory_turn = ClosedQuestionMemoryTurn(
+                user_question=question,
+                user_options=options,
+                user_images=images,
+                llm_response=response_data.response,
+                llm_reasoning=response_data.reasoning if reasoning else None
+            )
+            
+            await self.save_memory(
+                agent_id=agent_id,
+                response=response_data.response,
+                session_id=save_memory,
+                memory_turn=memory_turn.to_dict(),
+                memory_stream_used=memory_stream.to_dict() if memory_stream else None,
+                reasoning=response_data.reasoning if reasoning else None,
+                metadata={"question_type": "closed", "options": options}
+            )
+        
         return response_data
 
+    # Memory Management Methods
+    
+    async def save_memory(
+        self,
+        agent_id: Union[str, uuid.UUID],
+        response: str,
+        session_id: Optional[Union[str, uuid.UUID]] = None,
+        question_id: Optional[Union[str, uuid.UUID]] = None,
+        study_id: Optional[Union[str, uuid.UUID]] = None,
+        memory_turn: Optional[Dict[str, Any]] = None,
+        memory_stream_used: Optional[Dict[str, Any]] = None,
+        reasoning: Optional[str] = None,
+        metadata: Optional[Dict[str, Any]] = None,
+    ) -> str:
+        """
+        Save a response with associated memory information.
+        
+        Args:
+            agent_id: The agent ID
+            response: The agent's response text
+            session_id: Session ID for memory continuity
+            question_id: The question ID (optional)
+            study_id: The study ID (optional)
+            memory_turn: The memory turn to save
+            memory_stream_used: The memory stream that was used
+            reasoning: Optional reasoning
+            metadata: Additional metadata
+        
+        Returns:
+            Response ID if saved successfully
+        """
+        payload = {
+            "agent_id": str(agent_id),
+            "response": response,
+        }
+        
+        if session_id:
+            payload["session_id"] = str(session_id)
+        if question_id:
+            payload["question_id"] = str(question_id)
+        if study_id:
+            payload["study_id"] = str(study_id)
+        if memory_turn:
+            payload["memory_turn"] = memory_turn
+        if memory_stream_used:
+            payload["memory_stream_used"] = memory_stream_used
+        if reasoning:
+            payload["reasoning"] = reasoning
+        if metadata:
+            payload["metadata"] = metadata
+        
+        response = await self._request("POST", "memory/save", json=payload)
+        data = response.json()
+        if data.get("success"):
+            return data.get("response_id")
+        raise SimileAPIError("Failed to save memory")
+    
+    async def get_memory(
+        self,
+        session_id: Union[str, uuid.UUID],
+        agent_id: Union[str, uuid.UUID],
+        exclude_study_ids: Optional[List[Union[str, uuid.UUID]]] = None,
+        exclude_question_ids: Optional[List[Union[str, uuid.UUID]]] = None,
+        limit: Optional[int] = None,
+        use_memory: bool = True,
+    ) -> Optional[MemoryStream]:
+        """
+        Retrieve the memory stream for an agent in a session.
+        
+        Args:
+            session_id: Session ID to filter by
+            agent_id: The agent ID
+            exclude_study_ids: List of study IDs to exclude
+            exclude_question_ids: List of question IDs to exclude
+            limit: Maximum number of turns to include
+            use_memory: Whether to use memory at all
+        
+        Returns:
+            MemoryStream object or None
+        """
+        payload = {
+            "session_id": str(session_id),
+            "agent_id": str(agent_id),
+            "use_memory": use_memory,
+        }
+        
+        if exclude_study_ids:
+            payload["exclude_study_ids"] = [str(id) for id in exclude_study_ids]
+        if exclude_question_ids:
+            payload["exclude_question_ids"] = [str(id) for id in exclude_question_ids]
+        if limit:
+            payload["limit"] = limit
+        
+        response = await self._request("POST", "memory/get", json=payload)
+        data = response.json()
+        
+        if data.get("success") and data.get("memory_stream"):
+            return MemoryStream.from_dict(data["memory_stream"])
+        return None
+    
+    async def get_memory_summary(
+        self,
+        session_id: Union[str, uuid.UUID],
+    ) -> Dict[str, Any]:
+        """
+        Get a summary of memory usage for a session.
+        
+        Args:
+            session_id: Session ID to analyze
+        
+        Returns:
+            Dictionary with memory statistics
+        """
+        response = await self._request("GET", f"memory/summary/{session_id}")
+        data = response.json()
+        if data.get("success"):
+            return data.get("summary", {})
+        return {}
+    
+    async def clear_memory(
+        self,
+        session_id: Union[str, uuid.UUID],
+        agent_id: Optional[Union[str, uuid.UUID]] = None,
+        study_id: Optional[Union[str, uuid.UUID]] = None,
+    ) -> bool:
+        """
+        Clear memory for a session, optionally filtered by agent or study.
+        
+        Args:
+            session_id: Session ID to clear memory for
+            agent_id: Optional agent ID to filter by
+            study_id: Optional study ID to filter by
+        
+        Returns:
+            True if cleared successfully, False otherwise
+        """
+        payload = {
+            "session_id": str(session_id),
+        }
+        
+        if agent_id:
+            payload["agent_id"] = str(agent_id)
+        if study_id:
+            payload["study_id"] = str(study_id)
+        
+        response = await self._request("POST", "memory/clear", json=payload)
+        data = response.json()
+        return data.get("success", False)
+    
+    async def copy_memory(
+        self,
+        from_session_id: Union[str, uuid.UUID],
+        to_session_id: Union[str, uuid.UUID],
+        agent_id: Optional[Union[str, uuid.UUID]] = None,
+    ) -> int:
+        """
+        Copy memory from one session to another.
+        
+        Args:
+            from_session_id: Source session ID
+            to_session_id: Destination session ID
+            agent_id: Optional agent ID to filter by
+        
+        Returns:
+            Number of memory turns copied
+        """
+        payload = {
+            "from_session_id": str(from_session_id),
+            "to_session_id": str(to_session_id),
+        }
+        
+        if agent_id:
+            payload["agent_id"] = str(agent_id)
+        
+        response = await self._request("POST", "memory/copy", json=payload)
+        data = response.json()
+        if data.get("success"):
+            return data.get("copied_turns", 0)
+        return 0
+
     async def aclose(self):
         await self._client.aclose()
 

simile-0.4.1/simile/models.py

@@ -0,0 +1,400 @@
+from typing import List, Dict, Any, Optional, Union, Literal
+from pydantic import BaseModel, Field, validator
+from datetime import datetime
+from enum import Enum
+import uuid
+
+
+class Population(BaseModel):
+    population_id: uuid.UUID
+    name: str
+    description: Optional[str] = None
+    created_at: datetime
+    updated_at: datetime
+
+
+class PopulationInfo(BaseModel):
+    population_id: uuid.UUID
+    name: str
+    description: Optional[str] = None
+    agent_count: int
+
+
+class DataItem(BaseModel):
+    id: uuid.UUID
+    agent_id: uuid.UUID
+    data_type: str
+    content: Any
+    created_at: datetime
+    updated_at: datetime
+    metadata: Optional[Dict[str, Any]] = None
+
+
+class Agent(BaseModel):
+    agent_id: uuid.UUID
+    name: str
+    population_id: Optional[uuid.UUID] = None
+    created_at: datetime
+    updated_at: datetime
+    data_items: List[DataItem] = Field(default_factory=list)
+
+
+class CreatePopulationPayload(BaseModel):
+    name: str
+    description: Optional[str] = None
+
+
+class InitialDataItemPayload(BaseModel):
+    data_type: str
+    content: Any
+    metadata: Optional[Dict[str, Any]] = None
+
+
+class CreateAgentPayload(BaseModel):
+    name: str
+    population_id: Optional[uuid.UUID] = None
+    agent_data: Optional[List[InitialDataItemPayload]] = None
+
+
+class CreateDataItemPayload(BaseModel):
+    data_type: str
+    content: Any
+    metadata: Optional[Dict[str, Any]] = None
+
+
+class UpdateDataItemPayload(BaseModel):
+    content: Any
+    metadata: Optional[Dict[str, Any]] = None
+
+
+class DeletionResponse(BaseModel):
+    message: str
+
+
+# --- Generation Operation Models ---
+class OpenGenerationRequest(BaseModel):
+    question: str
+    data_types: Optional[List[str]] = None
+    exclude_data_types: Optional[List[str]] = None
+    images: Optional[Dict[str, str]] = (
+        None  # Dict of {description: url} for multiple images
+    )
+    reasoning: bool = False
+    memory_stream: Optional["MemoryStream"] = None
+
+
+class OpenGenerationResponse(BaseModel):
+    question: str
+    answer: str
+    reasoning: Optional[str] = ""
+
+
+class ClosedGenerationRequest(BaseModel):
+    question: str
+    options: List[str]
+    data_types: Optional[List[str]] = None
+    exclude_data_types: Optional[List[str]] = None
+    images: Optional[Dict[str, str]] = None
+    reasoning: bool = False
+    memory_stream: Optional["MemoryStream"] = None
+
+
+class ClosedGenerationResponse(BaseModel):
+    question: str
+    options: List[str]
+    response: str
+    reasoning: Optional[str] = ""
+
+
+class AddContextRequest(BaseModel):
+    context: str
+
+
+class AddContextResponse(BaseModel):
+    message: str
+    session_id: uuid.UUID
+
+
+# --- Survey Session Models ---
+class TurnType(str, Enum):
+    """Enum for different types of conversation turns."""
+
+    CONTEXT = "context"
+    IMAGE = "image"
+    OPEN_QUESTION = "open_question"
+    CLOSED_QUESTION = "closed_question"
+
+
+class BaseTurn(BaseModel):
+    """Base model for all conversation turns."""
+
+    timestamp: datetime = Field(default_factory=lambda: datetime.now())
+    type: TurnType
+
+    class Config:
+        use_enum_values = True
+
+
+class ContextTurn(BaseTurn):
+    """A context turn that provides background information."""
+
+    type: Literal[TurnType.CONTEXT] = TurnType.CONTEXT
+    user_context: str
+
+
+class ImageTurn(BaseTurn):
+    """A standalone image turn (e.g., for context or reference)."""
+
+    type: Literal[TurnType.IMAGE] = TurnType.IMAGE
+    images: Dict[str, str]
+    caption: Optional[str] = None
+
+
+class OpenQuestionTurn(BaseTurn):
+    """An open question-answer turn."""
+
+    type: Literal[TurnType.OPEN_QUESTION] = TurnType.OPEN_QUESTION
+    user_question: str
+    user_images: Optional[Dict[str, str]] = None
+    llm_response: Optional[str] = None
+
+
+class ClosedQuestionTurn(BaseTurn):
+    """A closed question-answer turn."""
+
+    type: Literal[TurnType.CLOSED_QUESTION] = TurnType.CLOSED_QUESTION
+    user_question: str
+    user_options: List[str]
+    user_images: Optional[Dict[str, str]] = None
+    llm_response: Optional[str] = None
+
+    @validator("user_options")
+    def validate_options(cls, v):
+        if not v:
+            raise ValueError("Closed questions must have at least one option")
+        if len(v) < 2:
+            raise ValueError("Closed questions should have at least two options")
+        return v
+
+    @validator("llm_response")
+    def validate_response(cls, v, values):
+        if (
+            v is not None
+            and "user_options" in values
+            and v not in values["user_options"]
+        ):
+            raise ValueError(f"Response '{v}' must be one of the provided options")
+        return v
+
+
+# Union type for all possible turn types
+SurveySessionTurn = Union[ContextTurn, ImageTurn, OpenQuestionTurn, ClosedQuestionTurn]
+
+
+class SurveySessionCreateResponse(BaseModel):
+    id: uuid.UUID  # Session ID
+    agent_id: uuid.UUID
+    created_at: datetime
+    status: str
+
+
+class SurveySessionDetailResponse(BaseModel):
+    """Detailed survey session response with typed conversation turns."""
+
+    id: uuid.UUID
+    agent_id: uuid.UUID
+    created_at: datetime
+    updated_at: datetime
+    status: str
+    conversation_history: List[SurveySessionTurn] = Field(default_factory=list)
+
+    class Config:
+        json_encoders = {datetime: lambda v: v.isoformat()}
+
+
+class SurveySessionListItemResponse(BaseModel):
+    """Summary response for listing survey sessions."""
+
+    id: uuid.UUID
+    agent_id: uuid.UUID
+    created_at: datetime
+    updated_at: datetime
+    status: str
+    turn_count: int = Field(description="Number of turns in conversation history")
+
+    class Config:
+        json_encoders = {datetime: lambda v: v.isoformat()}
+
+
+class SurveySessionCloseResponse(BaseModel):
+    id: uuid.UUID  # Session ID
+    status: str
+    updated_at: datetime
+    message: Optional[str] = None
+
+
+# --- Memory Stream Models (to replace Survey Sessions) ---
+class MemoryTurnType(str, Enum):
+    """Enum for different types of memory turns."""
+
+    CONTEXT = "context"
+    IMAGE = "image"
+    OPEN_QUESTION = "open_question"
+    CLOSED_QUESTION = "closed_question"
+
+
+class BaseMemoryTurn(BaseModel):
+    """Base model for all memory turns."""
+
+    timestamp: datetime = Field(default_factory=lambda: datetime.now())
+    type: MemoryTurnType
+
+    class Config:
+        use_enum_values = True
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary for serialization."""
+        data = self.model_dump()
+        # Remove timestamp - let API handle it
+        data.pop("timestamp", None)
+        # Ensure enum is serialized as string
+        if "type" in data:
+            if hasattr(data["type"], "value"):
+                data["type"] = data["type"].value
+        return data
+
+
+class ContextMemoryTurn(BaseMemoryTurn):
+    """A context turn that provides background information."""
+
+    type: MemoryTurnType = Field(default=MemoryTurnType.CONTEXT)
+    user_context: str
+
+
+class ImageMemoryTurn(BaseMemoryTurn):
+    """A standalone image turn (e.g., for context or reference)."""
+
+    type: MemoryTurnType = Field(default=MemoryTurnType.IMAGE)
+    images: Dict[str, str]
+    caption: Optional[str] = None
+
+
+class OpenQuestionMemoryTurn(BaseMemoryTurn):
+    """An open question-answer turn."""
+
+    type: MemoryTurnType = Field(default=MemoryTurnType.OPEN_QUESTION)
+    user_question: str
+    user_images: Optional[Dict[str, str]] = None
+    llm_response: Optional[str] = None
+    llm_reasoning: Optional[str] = None
+
+
+class ClosedQuestionMemoryTurn(BaseMemoryTurn):
+    """A closed question-answer turn."""
+
+    type: MemoryTurnType = Field(default=MemoryTurnType.CLOSED_QUESTION)
+    user_question: str
+    user_options: List[str]
+    user_images: Optional[Dict[str, str]] = None
+    llm_response: Optional[str] = None
+    llm_reasoning: Optional[str] = None
+
+
+# Discriminated union of all memory turn types
+MemoryTurn = Union[
+    ContextMemoryTurn, ImageMemoryTurn, OpenQuestionMemoryTurn, ClosedQuestionMemoryTurn
+]
+
+
+class MemoryStream(BaseModel):
+    """
+    A flexible memory stream that can be passed to generation functions.
+    This replaces the session-based approach with a more flexible paradigm.
+    """
+
+    turns: List[MemoryTurn] = Field(default_factory=list)
+
+    def add_turn(self, turn: MemoryTurn) -> None:
+        """Add a turn to the memory stream."""
+        self.turns.append(turn)
+
+    def remove_turn(self, index: int) -> Optional[MemoryTurn]:
+        """Remove a turn at the specified index."""
+        if 0 <= index < len(self.turns):
+            return self.turns.pop(index)
+        return None
+
+    def get_turns_by_type(self, turn_type: MemoryTurnType) -> List[MemoryTurn]:
+        """Get all turns of a specific type."""
+        return [turn for turn in self.turns if turn.type == turn_type]
+
+    def get_last_turn(self) -> Optional[MemoryTurn]:
+        """Get the most recent turn."""
+        return self.turns[-1] if self.turns else None
+
+    def clear(self) -> None:
+        """Clear all turns from the memory stream."""
+        self.turns = []
+
+    def __len__(self) -> int:
+        """Return the number of turns in the memory stream."""
+        return len(self.turns)
+
+    def __bool__(self) -> bool:
+        """Return True if the memory stream has any turns."""
+        return bool(self.turns)
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert memory stream to a dictionary for serialization."""
+        return {
+            "turns": [turn.to_dict() for turn in self.turns]
+        }
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "MemoryStream":
+        """Create a MemoryStream from a dictionary."""
+        memory = cls()
+        for turn_data in data.get("turns", []):
+            turn_type = turn_data.get("type")
+            if turn_type == MemoryTurnType.CONTEXT:
+                memory.add_turn(ContextMemoryTurn(**turn_data))
+            elif turn_type == MemoryTurnType.IMAGE:
+                memory.add_turn(ImageMemoryTurn(**turn_data))
+            elif turn_type == MemoryTurnType.OPEN_QUESTION:
+                memory.add_turn(OpenQuestionMemoryTurn(**turn_data))
+            elif turn_type == MemoryTurnType.CLOSED_QUESTION:
+                memory.add_turn(ClosedQuestionMemoryTurn(**turn_data))
+        return memory
+
+    def fork(self, up_to_index: Optional[int] = None) -> "MemoryStream":
+        """Create a copy of this memory stream, optionally up to a specific index."""
+        new_memory = MemoryStream()
+        turns_to_copy = self.turns[:up_to_index] if up_to_index is not None else self.turns
+        for turn in turns_to_copy:
+            new_memory.add_turn(turn.model_copy())
+        return new_memory
+
+    def filter_by_type(self, turn_type: MemoryTurnType) -> "MemoryStream":
+        """Create a new memory stream with only turns of a specific type."""
+        new_memory = MemoryStream()
+        for turn in self.get_turns_by_type(turn_type):
+            new_memory.add_turn(turn.model_copy())
+        return new_memory
+
+    def get_question_answer_pairs(self) -> List[tuple]:
+        """Extract question-answer pairs from the memory."""
+        pairs = []
+        for turn in self.turns:
+            if isinstance(turn, (OpenQuestionMemoryTurn, ClosedQuestionMemoryTurn)):
+                if turn.llm_response:
+                    pairs.append((turn.user_question, turn.llm_response))
+        return pairs
+
+    def truncate(self, max_turns: int) -> None:
+        """Keep only the most recent N turns."""
+        if len(self.turns) > max_turns:
+            self.turns = self.turns[-max_turns:]
+
+    def insert_turn(self, index: int, turn: MemoryTurn) -> None:
+        """Insert a turn at a specific position."""
+        self.turns.insert(index, turn)

{simile-0.3.12 → simile-0.4.1}/simile/resources.py

@@ -11,6 +11,7 @@ from .models import (
     AddContextResponse,
     SurveySessionDetailResponse,
     SurveySessionCreateResponse,
+    MemoryStream,
 )
 
 if TYPE_CHECKING:
@@ -34,6 +35,7 @@ class Agent:
         data_types: Optional[List[str]] = None,
         exclude_data_types: Optional[List[str]] = None,
         images: Optional[Dict[str, str]] = None,
+        memory_stream: Optional[MemoryStream] = None,
     ) -> OpenGenerationResponse:
         """Generates an open response from this agent based on a question."""
         return await self._client.generate_open_response(
@@ -42,6 +44,7 @@ class Agent:
             data_types=data_types,
             exclude_data_types=exclude_data_types,
             images=images,
+            memory_stream=memory_stream,
         )
 
     async def generate_closed_response(
@@ -51,6 +54,7 @@ class Agent:
         data_types: Optional[List[str]] = None,
         exclude_data_types: Optional[List[str]] = None,
         images: Optional[Dict[str, str]] = None,
+        memory_stream: Optional[MemoryStream] = None,
     ) -> ClosedGenerationResponse:
         """Generates a closed response from this agent."""
         return await self._client.generate_closed_response(
@@ -60,6 +64,7 @@ class Agent:
             data_types=data_types,
             exclude_data_types=exclude_data_types,
             images=images,
+            memory_stream=memory_stream,
         )
 
 

{simile-0.3.12 → simile-0.4.1}/simile.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: simile
-Version: 0.3.12
+Version: 0.4.1
 Summary: Package for interfacing with Simile AI agents for simulation
 Author-email: Simile AI <cqz@simile.ai>
 License: MIT

simile-0.3.12/simile/models.py

@@ -1,231 +0,0 @@
-from typing import List, Dict, Any, Optional, Union, Literal
-from pydantic import BaseModel, Field, validator
-from datetime import datetime
-from enum import Enum
-import uuid
-
-
-class Population(BaseModel):
-    population_id: uuid.UUID
-    name: str
-    description: Optional[str] = None
-    created_at: datetime
-    updated_at: datetime
-
-
-class PopulationInfo(BaseModel):
-    population_id: uuid.UUID
-    name: str
-    description: Optional[str] = None
-    agent_count: int
-
-
-class DataItem(BaseModel):
-    id: uuid.UUID
-    agent_id: uuid.UUID
-    data_type: str
-    content: Any
-    created_at: datetime
-    updated_at: datetime
-    metadata: Optional[Dict[str, Any]] = None
-
-
-class Agent(BaseModel):
-    agent_id: uuid.UUID
-    name: str
-    population_id: Optional[uuid.UUID] = None
-    created_at: datetime
-    updated_at: datetime
-    data_items: List[DataItem] = Field(default_factory=list)
-
-
-class CreatePopulationPayload(BaseModel):
-    name: str
-    description: Optional[str] = None
-
-
-class InitialDataItemPayload(BaseModel):
-    data_type: str
-    content: Any
-    metadata: Optional[Dict[str, Any]] = None
-
-
-class CreateAgentPayload(BaseModel):
-    name: str
-    population_id: Optional[uuid.UUID] = None
-    agent_data: Optional[List[InitialDataItemPayload]] = None
-
-
-class CreateDataItemPayload(BaseModel):
-    data_type: str
-    content: Any
-    metadata: Optional[Dict[str, Any]] = None
-
-
-class UpdateDataItemPayload(BaseModel):
-    content: Any
-    metadata: Optional[Dict[str, Any]] = None
-
-
-class DeletionResponse(BaseModel):
-    message: str
-
-
-# --- Generation Operation Models ---
-class OpenGenerationRequest(BaseModel):
-    question: str
-    data_types: Optional[List[str]] = None
-    exclude_data_types: Optional[List[str]] = None
-    images: Optional[Dict[str, str]] = (
-        None  # Dict of {description: url} for multiple images
-    )
-    reasoning: bool = False
-
-
-class OpenGenerationResponse(BaseModel):
-    question: str
-    answer: str
-    reasoning: Optional[str] = ""
-
-
-class ClosedGenerationRequest(BaseModel):
-    question: str
-    options: List[str]
-    data_types: Optional[List[str]] = None
-    exclude_data_types: Optional[List[str]] = None
-    images: Optional[Dict[str, str]] = None
-    reasoning: bool = False
-
-
-class ClosedGenerationResponse(BaseModel):
-    question: str
-    options: List[str]
-    response: str
-    reasoning: Optional[str] = ""
-
-
-class AddContextRequest(BaseModel):
-    context: str
-
-
-class AddContextResponse(BaseModel):
-    message: str
-    session_id: uuid.UUID
-
-
-# --- Survey Session Models ---
-class TurnType(str, Enum):
-    """Enum for different types of conversation turns."""
-
-    CONTEXT = "context"
-    IMAGE = "image"
-    OPEN_QUESTION = "open_question"
-    CLOSED_QUESTION = "closed_question"
-
-
-class BaseTurn(BaseModel):
-    """Base model for all conversation turns."""
-
-    timestamp: datetime = Field(default_factory=lambda: datetime.now())
-    type: TurnType
-
-    class Config:
-        use_enum_values = True
-
-
-class ContextTurn(BaseTurn):
-    """A context turn that provides background information."""
-
-    type: Literal[TurnType.CONTEXT] = TurnType.CONTEXT
-    user_context: str
-
-
-class ImageTurn(BaseTurn):
-    """A standalone image turn (e.g., for context or reference)."""
-
-    type: Literal[TurnType.IMAGE] = TurnType.IMAGE
-    images: Dict[str, str]
-    caption: Optional[str] = None
-
-
-class OpenQuestionTurn(BaseTurn):
-    """An open question-answer turn."""
-
-    type: Literal[TurnType.OPEN_QUESTION] = TurnType.OPEN_QUESTION
-    user_question: str
-    user_images: Optional[Dict[str, str]] = None
-    llm_response: Optional[str] = None
-
-
-class ClosedQuestionTurn(BaseTurn):
-    """A closed question-answer turn."""
-
-    type: Literal[TurnType.CLOSED_QUESTION] = TurnType.CLOSED_QUESTION
-    user_question: str
-    user_options: List[str]
-    user_images: Optional[Dict[str, str]] = None
-    llm_response: Optional[str] = None
-
-    @validator("user_options")
-    def validate_options(cls, v):
-        if not v:
-            raise ValueError("Closed questions must have at least one option")
-        if len(v) < 2:
-            raise ValueError("Closed questions should have at least two options")
-        return v
-
-    @validator("llm_response")
-    def validate_response(cls, v, values):
-        if (
-            v is not None
-            and "user_options" in values
-            and v not in values["user_options"]
-        ):
-            raise ValueError(f"Response '{v}' must be one of the provided options")
-        return v
-
-
-# Union type for all possible turn types
-SurveySessionTurn = Union[ContextTurn, ImageTurn, OpenQuestionTurn, ClosedQuestionTurn]
-
-
-class SurveySessionCreateResponse(BaseModel):
-    id: uuid.UUID  # Session ID
-    agent_id: uuid.UUID
-    created_at: datetime
-    status: str
-
-
-class SurveySessionDetailResponse(BaseModel):
-    """Detailed survey session response with typed conversation turns."""
-
-    id: uuid.UUID
-    agent_id: uuid.UUID
-    created_at: datetime
-    updated_at: datetime
-    status: str
-    conversation_history: List[SurveySessionTurn] = Field(default_factory=list)
-
-    class Config:
-        json_encoders = {datetime: lambda v: v.isoformat()}
-
-
-class SurveySessionListItemResponse(BaseModel):
-    """Summary response for listing survey sessions."""
-
-    id: uuid.UUID
-    agent_id: uuid.UUID
-    created_at: datetime
-    updated_at: datetime
-    status: str
-    turn_count: int = Field(description="Number of turns in conversation history")
-
-    class Config:
-        json_encoders = {datetime: lambda v: v.isoformat()}
-
-
-class SurveySessionCloseResponse(BaseModel):
-    id: uuid.UUID  # Session ID
-    status: str
-    updated_at: datetime
-    message: Optional[str] = None