letta-nightly 0.6.27.dev20250220104103__py3-none-any.whl → 0.6.28.dev20250220163833__py3-none-any.whl

letta/server/rest_api/interface.py

@@ -317,6 +317,9 @@ class StreamingServerInterface(AgentChunkStreamingInterface):
         self.debug = False
         self.timeout = 10 * 60  # 10 minute timeout
 
+        # for expect_reasoning_content, we should accumulate `content`
+        self.expect_reasoning_content_buffer = None
+
     def _reset_inner_thoughts_json_reader(self):
         # A buffer for accumulating function arguments (we want to buffer keys and run checks on each one)
         self.function_args_reader = JSONInnerThoughtsExtractor(inner_thoughts_key=self.inner_thoughts_kwarg, wait_for_first_key=True)
@@ -387,6 +390,39 @@ class StreamingServerInterface(AgentChunkStreamingInterface):
         # Wipe the inner thoughts buffers
         self._reset_inner_thoughts_json_reader()
 
+        # If we were in reasoning mode and accumulated a json block, attempt to release it as chunks
+        # if self.expect_reasoning_content_buffer is not None:
+        #     try:
+        #         # NOTE: this is hardcoded for our DeepSeek API integration
+        #         json_reasoning_content = json.loads(self.expect_reasoning_content_buffer)
+
+        #         if "name" in json_reasoning_content:
+        #             self._push_to_buffer(
+        #                 ToolCallMessage(
+        #                     id=message_id,
+        #                     date=message_date,
+        #                     tool_call=ToolCallDelta(
+        #                         name=json_reasoning_content["name"],
+        #                         arguments=None,
+        #                         tool_call_id=None,
+        #                     ),
+        #                 )
+        #             )
+        #         if "arguments" in json_reasoning_content:
+        #             self._push_to_buffer(
+        #                 ToolCallMessage(
+        #                     id=message_id,
+        #                     date=message_date,
+        #                     tool_call=ToolCallDelta(
+        #                         name=None,
+        #                         arguments=json_reasoning_content["arguments"],
+        #                         tool_call_id=None,
+        #                     ),
+        #                 )
+        #             )
+        #     except Exception as e:
+        #         print(f"Failed to interpret reasoning content ({self.expect_reasoning_content_buffer}) as JSON: {e}")
+
     def step_complete(self):
         """Signal from the agent that one 'step' finished (step = LLM response + tool execution)"""
         if not self.multi_step:
@@ -410,7 +446,13 @@ class StreamingServerInterface(AgentChunkStreamingInterface):
         return
 
     def _process_chunk_to_letta_style(
-        self, chunk: ChatCompletionChunkResponse, message_id: str, message_date: datetime
+        self,
+        chunk: ChatCompletionChunkResponse,
+        message_id: str,
+        message_date: datetime,
+        # if we expect `reasoning_content``, then that's what gets mapped to ReasoningMessage
+        # and `content` needs to be handled outside the interface
+        expect_reasoning_content: bool = False,
     ) -> Optional[Union[ReasoningMessage, ToolCallMessage, AssistantMessage]]:
         """
         Example data from non-streaming response looks like:
@@ -426,6 +468,7 @@ class StreamingServerInterface(AgentChunkStreamingInterface):
 
         if (
             message_delta.content is None
+            and (expect_reasoning_content and message_delta.reasoning_content is None)
             and message_delta.tool_calls is None
             and message_delta.function_call is None
             and choice.finish_reason is None
@@ -435,17 +478,68 @@ class StreamingServerInterface(AgentChunkStreamingInterface):
             return None
 
         # inner thoughts
-        if message_delta.content is not None:
-            if message_delta.content == "":
-                print("skipping empty content")
-                processed_chunk = None
+        if expect_reasoning_content and message_delta.reasoning_content is not None:
+            processed_chunk = ReasoningMessage(
+                id=message_id,
+                date=message_date,
+                reasoning=message_delta.reasoning_content,
+            )
+        elif expect_reasoning_content and message_delta.content is not None:
+            # "ignore" content if we expect reasoning content
+            if self.expect_reasoning_content_buffer is None:
+                self.expect_reasoning_content_buffer = message_delta.content
             else:
-                processed_chunk = ReasoningMessage(
+                self.expect_reasoning_content_buffer += message_delta.content
+
+            # we expect this to be pure JSON
+            # OptimisticJSONParser
+
+            # If we can pull a name out, pull it
+
+            try:
+                # NOTE: this is hardcoded for our DeepSeek API integration
+                json_reasoning_content = json.loads(self.expect_reasoning_content_buffer)
+                print(f"json_reasoning_content: {json_reasoning_content}")
+
+                processed_chunk = ToolCallMessage(
                     id=message_id,
                     date=message_date,
-                    reasoning=message_delta.content,
+                    tool_call=ToolCallDelta(
+                        name=json_reasoning_content.get("name"),
+                        arguments=json.dumps(json_reasoning_content.get("arguments")),
+                        tool_call_id=None,
+                    ),
                 )
 
+            except json.JSONDecodeError as e:
+                print(f"Failed to interpret reasoning content ({self.expect_reasoning_content_buffer}) as JSON: {e}")
+
+                return None
+            # Else,
+            # return None
+            # processed_chunk = ToolCallMessage(
+            #     id=message_id,
+            #     date=message_date,
+            #     tool_call=ToolCallDelta(
+            #         # name=tool_call_delta.get("name"),
+            #         name=None,
+            #         arguments=message_delta.content,
+            #         # tool_call_id=tool_call_delta.get("id"),
+            #         tool_call_id=None,
+            #     ),
+            # )
+            # return processed_chunk
+
+            # TODO eventually output as tool call outputs?
+            # print(f"Hiding content delta stream: '{message_delta.content}'")
+            # return None
+        elif message_delta.content is not None:
+            processed_chunk = ReasoningMessage(
+                id=message_id,
+                date=message_date,
+                reasoning=message_delta.content,
+            )
+
         # tool calls
         elif message_delta.tool_calls is not None and len(message_delta.tool_calls) > 0:
             tool_call = message_delta.tool_calls[0]
@@ -890,7 +984,13 @@ class StreamingServerInterface(AgentChunkStreamingInterface):
 
         return processed_chunk
 
-    def process_chunk(self, chunk: ChatCompletionChunkResponse, message_id: str, message_date: datetime):
+    def process_chunk(
+        self,
+        chunk: ChatCompletionChunkResponse,
+        message_id: str,
+        message_date: datetime,
+        expect_reasoning_content: bool = False,
+    ):
         """Process a streaming chunk from an OpenAI-compatible server.
 
         Example data from non-streaming response looks like:
@@ -910,7 +1010,12 @@ class StreamingServerInterface(AgentChunkStreamingInterface):
             # processed_chunk = self._process_chunk_to_openai_style(chunk)
             raise NotImplementedError("OpenAI proxy streaming temporarily disabled")
         else:
-            processed_chunk = self._process_chunk_to_letta_style(chunk=chunk, message_id=message_id, message_date=message_date)
+            processed_chunk = self._process_chunk_to_letta_style(
+                chunk=chunk,
+                message_id=message_id,
+                message_date=message_date,
+                expect_reasoning_content=expect_reasoning_content,
+            )
         if processed_chunk is None:
             return
 

letta/server/rest_api/routers/v1/__init__.py

@@ -1,6 +1,7 @@
 from letta.server.rest_api.routers.v1.agents import router as agents_router
 from letta.server.rest_api.routers.v1.blocks import router as blocks_router
 from letta.server.rest_api.routers.v1.health import router as health_router
+from letta.server.rest_api.routers.v1.identities import router as identities_router
 from letta.server.rest_api.routers.v1.jobs import router as jobs_router
 from letta.server.rest_api.routers.v1.llms import router as llm_router
 from letta.server.rest_api.routers.v1.providers import router as providers_router
@@ -15,6 +16,7 @@ ROUTERS = [
     tools_router,
     sources_router,
     agents_router,
+    identities_router,
     llm_router,
     blocks_router,
     jobs_router,

letta/server/rest_api/routers/v1/agents.py

@@ -23,6 +23,7 @@ from letta.schemas.tool import Tool
 from letta.schemas.user import User
 from letta.server.rest_api.utils import get_letta_server
 from letta.server.server import SyncServer
+from letta.tracing import trace_method
 
 # These can be forward refs, but because Fastapi needs them at runtime the must be imported normally
 
@@ -50,6 +51,7 @@ def list_agents(
     project_id: Optional[str] = Query(None, description="Search agents by project id"),
     template_id: Optional[str] = Query(None, description="Search agents by template id"),
     base_template_id: Optional[str] = Query(None, description="Search agents by base template id"),
+    identifier_key: Optional[str] = Query(None, description="Search agents by identifier key"),
 ):
     """
     List all agents associated with a given user.
@@ -65,6 +67,7 @@ def list_agents(
             "project_id": project_id,
             "template_id": template_id,
             "base_template_id": base_template_id,
+            "identifier_key": identifier_key,
         }.items()
         if value is not None
     }
@@ -111,6 +114,7 @@ def create_agent(
     agent: CreateAgentRequest = Body(...),
     server: "SyncServer" = Depends(get_letta_server),
     user_id: Optional[str] = Header(None, alias="user_id"),  # Extract user_id from header, default to None if not present
+    x_project: Optional[str] = Header(None, alias="X-Project"),  # Only handled by next js middleware
 ):
     """
     Create a new agent with the specified configuration.
@@ -460,6 +464,7 @@ def modify_message(
     response_model=LettaResponse,
     operation_id="send_message",
 )
+@trace_method("POST /v1/agents/{agent_id}/messages")
 async def send_message(
     agent_id: str,
     server: SyncServer = Depends(get_letta_server),
@@ -498,6 +503,7 @@ async def send_message(
         }
     },
 )
+@trace_method("POST /v1/agents/{agent_id}/messages/stream")
 async def send_message_streaming(
     agent_id: str,
     server: SyncServer = Depends(get_letta_server),
@@ -509,7 +515,6 @@ async def send_message_streaming(
     This endpoint accepts a message from a user and processes it through the agent.
     It will stream the steps of the response always, and stream the tokens if 'stream_tokens' is set to True.
     """
-
     actor = server.user_manager.get_user_or_default(user_id=user_id)
     result = await server.send_message_to_agent(
         agent_id=agent_id,
@@ -574,6 +579,7 @@ async def process_message_background(
     response_model=Run,
     operation_id="create_agent_message_async",
 )
+@trace_method("POST /v1/agents/{agent_id}/messages/async")
 async def send_message_async(
     agent_id: str,
     background_tasks: BackgroundTasks,

letta/server/rest_api/routers/v1/identities.py

@@ -0,0 +1,111 @@
+from typing import TYPE_CHECKING, List, Optional
+
+from fastapi import APIRouter, Body, Depends, Header, HTTPException, Query
+
+from letta.orm.errors import NoResultFound
+from letta.schemas.identity import Identity, IdentityCreate, IdentityType, IdentityUpdate
+from letta.server.rest_api.utils import get_letta_server
+
+if TYPE_CHECKING:
+    from letta.server.server import SyncServer
+
+router = APIRouter(prefix="/identities", tags=["identities"])
+
+
+@router.get("/", tags=["identities"], response_model=List[Identity], operation_id="list_identities")
+def list_identities(
+    name: Optional[str] = Query(None),
+    project_id: Optional[str] = Query(None),
+    identity_type: Optional[IdentityType] = Query(None),
+    before: Optional[str] = Query(None),
+    after: Optional[str] = Query(None),
+    limit: Optional[int] = Query(50),
+    server: "SyncServer" = Depends(get_letta_server),
+    user_id: Optional[str] = Header(None, alias="user_id"),  # Extract user_id from header, default to None if not present
+):
+    """
+    Get a list of all identities in the database
+    """
+    try:
+        actor = server.user_manager.get_user_or_default(user_id=user_id)
+
+        identities = server.identity_manager.list_identities(
+            name=name, project_id=project_id, identity_type=identity_type, before=before, after=after, limit=limit, actor=actor
+        )
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"{e}")
+    return identities
+
+
+@router.get("/{identifier_key}", tags=["identities"], response_model=Identity, operation_id="get_identity_from_identifier_key")
+def retrieve_identity(
+    identifier_key: str,
+    server: "SyncServer" = Depends(get_letta_server),
+):
+    try:
+        return server.identity_manager.get_identity_from_identifier_key(identifier_key=identifier_key)
+    except NoResultFound as e:
+        raise HTTPException(status_code=404, detail=str(e))
+
+
+@router.post("/", tags=["identities"], response_model=Identity, operation_id="create_identity")
+def create_identity(
+    identity: IdentityCreate = Body(...),
+    server: "SyncServer" = Depends(get_letta_server),
+    user_id: Optional[str] = Header(None, alias="user_id"),  # Extract user_id from header, default to None if not present
+    x_project: Optional[str] = Header(None, alias="X-Project"),  # Only handled by next js middleware
+):
+    try:
+        actor = server.user_manager.get_user_or_default(user_id=user_id)
+        return server.identity_manager.create_identity(identity=identity, actor=actor)
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"{e}")
+
+
+@router.put("/", tags=["identities"], response_model=Identity, operation_id="upsert_identity")
+def upsert_identity(
+    identity: IdentityCreate = Body(...),
+    server: "SyncServer" = Depends(get_letta_server),
+    user_id: Optional[str] = Header(None, alias="user_id"),  # Extract user_id from header, default to None if not present
+    x_project: Optional[str] = Header(None, alias="X-Project"),  # Only handled by next js middleware
+):
+    try:
+        actor = server.user_manager.get_user_or_default(user_id=user_id)
+        return server.identity_manager.upsert_identity(identity=identity, actor=actor)
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"{e}")
+
+
+@router.patch("/{identifier_key}", tags=["identities"], response_model=Identity, operation_id="update_identity")
+def modify_identity(
+    identifier_key: str,
+    identity: IdentityUpdate = Body(...),
+    server: "SyncServer" = Depends(get_letta_server),
+    user_id: Optional[str] = Header(None, alias="user_id"),  # Extract user_id from header, default to None if not present
+):
+    try:
+        actor = server.user_manager.get_user_or_default(user_id=user_id)
+        return server.identity_manager.update_identity_by_key(identifier_key=identifier_key, identity=identity, actor=actor)
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"{e}")
+
+
+@router.delete("/{identifier_key}", tags=["identities"], operation_id="delete_identity")
+def delete_identity(
+    identifier_key: str,
+    server: "SyncServer" = Depends(get_letta_server),
+    user_id: Optional[str] = Header(None, alias="user_id"),  # Extract user_id from header, default to None if not present
+):
+    """
+    Delete an identity by its identifier key
+    """
+    actor = server.user_manager.get_user_or_default(user_id=user_id)
+    server.identity_manager.delete_identity_by_key(identifier_key=identifier_key, actor=actor)

letta/server/server.py

@@ -18,6 +18,7 @@ import letta.server.utils as server_utils
 import letta.system as system
 from letta.agent import Agent, save_agent
 from letta.chat_only_agent import ChatOnlyAgent
+from letta.config import LettaConfig
 from letta.data_sources.connectors import DataConnector, load_data
 from letta.helpers.datetime_helpers import get_utc_time
 from letta.helpers.json_helpers import json_dumps, json_loads
@@ -27,7 +28,6 @@ from letta.interface import AgentInterface  # abstract
 from letta.interface import CLIInterface  # for printing to terminal
 from letta.log import get_logger
 from letta.offline_memory_agent import OfflineMemoryAgent
-from letta.orm import Base
 from letta.orm.errors import NoResultFound
 from letta.schemas.agent import AgentState, AgentType, CreateAgent
 from letta.schemas.block import BlockUpdate
@@ -48,6 +48,7 @@ from letta.schemas.providers import (
     AnthropicBedrockProvider,
     AnthropicProvider,
     AzureProvider,
+    DeepSeekProvider,
     GoogleAIProvider,
     GoogleVertexProvider,
     GroqProvider,
@@ -70,6 +71,7 @@ from letta.server.rest_api.interface import StreamingServerInterface
 from letta.server.rest_api.utils import sse_async_generator
 from letta.services.agent_manager import AgentManager
 from letta.services.block_manager import BlockManager
+from letta.services.identity_manager import IdentityManager
 from letta.services.job_manager import JobManager
 from letta.services.message_manager import MessageManager
 from letta.services.organization_manager import OrganizationManager
@@ -82,8 +84,11 @@ from letta.services.step_manager import StepManager
 from letta.services.tool_execution_sandbox import ToolExecutionSandbox
 from letta.services.tool_manager import ToolManager
 from letta.services.user_manager import UserManager
+from letta.settings import model_settings, settings, tool_settings
+from letta.tracing import trace_method
 from letta.utils import get_friendly_error_msg
 
+config = LettaConfig.load()
 logger = get_logger(__name__)
 
 
@@ -145,118 +150,6 @@ class Server(object):
         raise NotImplementedError
 
 
-from contextlib import contextmanager
-
-from rich.console import Console
-from rich.panel import Panel
-from rich.text import Text
-from sqlalchemy import create_engine
-from sqlalchemy.orm import sessionmaker
-
-from letta.config import LettaConfig
-
-# NOTE: hack to see if single session management works
-from letta.settings import model_settings, settings, tool_settings
-
-config = LettaConfig.load()
-
-
-def print_sqlite_schema_error():
-    """Print a formatted error message for SQLite schema issues"""
-    console = Console()
-    error_text = Text()
-    error_text.append("Existing SQLite DB schema is invalid, and schema migrations are not supported for SQLite. ", style="bold red")
-    error_text.append("To have migrations supported between Letta versions, please run Letta with Docker (", style="white")
-    error_text.append("https://docs.letta.com/server/docker", style="blue underline")
-    error_text.append(") or use Postgres by setting ", style="white")
-    error_text.append("LETTA_PG_URI", style="yellow")
-    error_text.append(".\n\n", style="white")
-    error_text.append("If you wish to keep using SQLite, you can reset your database by removing the DB file with ", style="white")
-    error_text.append("rm ~/.letta/sqlite.db", style="yellow")
-    error_text.append(" or downgrade to your previous version of Letta.", style="white")
-
-    console.print(Panel(error_text, border_style="red"))
-
-
-@contextmanager
-def db_error_handler():
-    """Context manager for handling database errors"""
-    try:
-        yield
-    except Exception as e:
-        # Handle other SQLAlchemy errors
-        print(e)
-        print_sqlite_schema_error()
-        # raise ValueError(f"SQLite DB error: {str(e)}")
-        exit(1)
-
-
-if settings.letta_pg_uri_no_default:
-    print("Creating postgres engine")
-    config.recall_storage_type = "postgres"
-    config.recall_storage_uri = settings.letta_pg_uri_no_default
-    config.archival_storage_type = "postgres"
-    config.archival_storage_uri = settings.letta_pg_uri_no_default
-
-    # create engine
-    engine = create_engine(
-        settings.letta_pg_uri,
-        pool_size=settings.pg_pool_size,
-        max_overflow=settings.pg_max_overflow,
-        pool_timeout=settings.pg_pool_timeout,
-        pool_recycle=settings.pg_pool_recycle,
-        echo=settings.pg_echo,
-    )
-else:
-    # TODO: don't rely on config storage
-    engine_path = "sqlite:///" + os.path.join(config.recall_storage_path, "sqlite.db")
-    logger.info("Creating sqlite engine " + engine_path)
-
-    engine = create_engine(engine_path)
-
-    # Store the original connect method
-    original_connect = engine.connect
-
-    def wrapped_connect(*args, **kwargs):
-        with db_error_handler():
-            # Get the connection
-            connection = original_connect(*args, **kwargs)
-
-            # Store the original execution method
-            original_execute = connection.execute
-
-            # Wrap the execute method of the connection
-            def wrapped_execute(*args, **kwargs):
-                with db_error_handler():
-                    return original_execute(*args, **kwargs)
-
-            # Replace the connection's execute method
-            connection.execute = wrapped_execute
-
-            return connection
-
-    # Replace the engine's connect method
-    engine.connect = wrapped_connect
-
-    Base.metadata.create_all(bind=engine)
-
-SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
-
-
-# Dependency
-def get_db():
-    db = SessionLocal()
-    try:
-        yield db
-    finally:
-        db.close()
-
-
-from contextlib import contextmanager
-
-db_context = contextmanager(get_db)
-
-
 class SyncServer(Server):
     """Simple single-threaded / blocking server process"""
 
@@ -304,6 +197,7 @@ class SyncServer(Server):
         self.agent_manager = AgentManager()
         self.provider_manager = ProviderManager()
         self.step_manager = StepManager()
+        self.identity_manager = IdentityManager()
 
         # Managers that interface with parallelism
         self.per_agent_lock_manager = PerAgentLockManager()
@@ -415,6 +309,8 @@ class SyncServer(Server):
                 else model_settings.lmstudio_base_url + "/v1"
             )
             self._enabled_providers.append(LMStudioOpenAIProvider(base_url=lmstudio_url))
+        if model_settings.deepseek_api_key:
+            self._enabled_providers.append(DeepSeekProvider(api_key=model_settings.deepseek_api_key))
 
     def load_agent(self, agent_id: str, actor: User, interface: Union[AgentInterface, None] = None) -> Agent:
         """Updated method to load agents from persisted storage"""
@@ -1256,6 +1152,7 @@ class SyncServer(Server):
         actions = self.get_composio_client(api_key=api_key).actions.get(apps=[composio_app_name])
         return actions
 
+    @trace_method("Send Message")
     async def send_message_to_agent(
         self,
         agent_id: str,
@@ -1273,7 +1170,6 @@ class SyncServer(Server):
         metadata: Optional[dict] = None,
     ) -> Union[StreamingResponse, LettaResponse]:
         """Split off into a separate function so that it can be imported in the /chat/completion proxy."""
-
         # TODO: @charles is this the correct way to handle?
         include_final_message = True
 
@@ -1292,11 +1188,12 @@ class SyncServer(Server):
             # Disable token streaming if not OpenAI or Anthropic
             # TODO: cleanup this logic
             llm_config = letta_agent.agent_state.llm_config
+            supports_token_streaming = ["openai", "anthropic", "deepseek"]
             if stream_tokens and (
-                llm_config.model_endpoint_type not in ["openai", "anthropic"] or "inference.memgpt.ai" in llm_config.model_endpoint
+                llm_config.model_endpoint_type not in supports_token_streaming or "inference.memgpt.ai" in llm_config.model_endpoint
             ):
                 warnings.warn(
-                    f"Token streaming is only supported for models with type 'openai' or 'anthropic' in the model_endpoint: agent has endpoint type {llm_config.model_endpoint_type} and {llm_config.model_endpoint}. Setting stream_tokens to False."
+                    f"Token streaming is only supported for models with type {' or '.join(supports_token_streaming)} in the model_endpoint: agent has endpoint type {llm_config.model_endpoint_type} and {llm_config.model_endpoint}. Setting stream_tokens to False."
                 )
                 stream_tokens = False