letta-nightly 0.4.1.dev20241008104105__tar.gz → 0.4.1.dev20241010104112__tar.gz

{letta_nightly-0.4.1.dev20241008104105 → letta_nightly-0.4.1.dev20241010104112}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: letta-nightly
-Version: 0.4.1.dev20241008104105
+Version: 0.4.1.dev20241010104112
 Summary: Create LLM agents with long-term memory and custom tools
 License: Apache License
 Author: Letta Team

{letta_nightly-0.4.1.dev20241008104105 → letta_nightly-0.4.1.dev20241010104112}/letta/agent.py

@@ -239,6 +239,7 @@ class Agent(BaseAgent):
         assert isinstance(self.agent_state.memory, Memory), f"Memory object is not of type Memory: {type(self.agent_state.memory)}"
 
         # link tools
+        self.tools = tools
         self.link_tools(tools)
 
         # gpt-4, gpt-3.5-turbo, ...
@@ -338,6 +339,9 @@ class Agent(BaseAgent):
         for tool_name in self.agent_state.tools:
             assert tool_name in [tool.name for tool in tools], f"Tool name {tool_name} not included in agent tool list"
 
+        # Update tools
+        self.tools = tools
+
         # Store the functions schemas (this is passed as an argument to ChatCompletion)
         self.functions = []
         self.functions_python = {}
@@ -482,7 +486,7 @@ class Agent(BaseAgent):
                 inner_thoughts_in_kwargs_option=inner_thoughts_in_kwargs_option,
             )
 
-            if len(response.choices) == 0:
+            if len(response.choices) == 0 or response.choices[0] is None:
                 raise Exception(f"API call didn't return a message: {response}")
 
             # special case for 'length'
@@ -552,9 +556,12 @@ class Agent(BaseAgent):
             )  # extend conversation with assistant's reply
             printd(f"Function call message: {messages[-1]}")
 
+            nonnull_content = False
             if response_message.content:
                 # The content if then internal monologue, not chat
                 self.interface.internal_monologue(response_message.content, msg_obj=messages[-1])
+                # Flag to avoid printing a duplicate if inner thoughts get popped from the function call
+                nonnull_content = True
 
             # Step 3: call the function
             # Note: the JSON response may not always be valid; be sure to handle errors
@@ -615,12 +622,17 @@ class Agent(BaseAgent):
             if "inner_thoughts" in function_args:
                 response_message.content = function_args.pop("inner_thoughts")
             # The content if then internal monologue, not chat
-            if response_message.content:
+            if response_message.content and not nonnull_content:
                 self.interface.internal_monologue(response_message.content, msg_obj=messages[-1])
 
             # (Still parsing function args)
             # Handle requests for immediate heartbeat
             heartbeat_request = function_args.pop("request_heartbeat", None)
+
+            # Edge case: heartbeat_request is returned as a stringified boolean, we will attempt to parse:
+            if isinstance(heartbeat_request, str) and heartbeat_request.lower().strip() == "true":
+                heartbeat_request = True
+
             if not isinstance(heartbeat_request, bool) or heartbeat_request is None:
                 printd(
                     f"{CLI_WARNING_PREFIX}'request_heartbeat' arg parsed was not a bool or None, type={type(heartbeat_request)}, value={heartbeat_request}"
@@ -1353,6 +1365,10 @@ def save_agent(agent: Agent, ms: MetadataStore):
     else:
         ms.create_agent(agent_state)
 
+    for tool in agent.tools:
+        if ms.get_tool(tool_name=tool.name, user_id=tool.user_id) is None:
+            ms.create_tool(tool)
+
     agent.agent_state = ms.get_agent(agent_id=agent_id)
     assert isinstance(agent.agent_state.memory, Memory), f"Memory is not a Memory object: {type(agent_state.memory)}"
 

{letta_nightly-0.4.1.dev20241008104105 → letta_nightly-0.4.1.dev20241010104112}/letta/agent_store/db.py

@@ -398,8 +398,6 @@ class PostgresStorageConnector(SQLStorageConnector):
         return records
 
     def insert_many(self, records, exists_ok=True, show_progress=False):
-        pass
-
         # TODO: this is terrible, should eventually be done the same way for all types (migrate to SQLModel)
         if len(records) == 0:
             return
@@ -506,18 +504,36 @@ class SQLLiteStorageConnector(SQLStorageConnector):
         # sqlite3.register_converter("UUID", lambda b: uuid.UUID(bytes_le=b))
 
     def insert_many(self, records, exists_ok=True, show_progress=False):
-        pass
-
         # TODO: this is terrible, should eventually be done the same way for all types (migrate to SQLModel)
         if len(records) == 0:
             return
+
+        added_ids = []  # avoid adding duplicates
+        # NOTE: this has not great performance due to the excessive commits
         with self.session_maker() as session:
             iterable = tqdm(records) if show_progress else records
             for record in iterable:
                 # db_record = self.db_model(**vars(record))
-                db_record = self.db_model(**record.dict())
-                session.add(db_record)
-            session.commit()
+
+                if record.id in added_ids:
+                    continue
+
+                existing_record = session.query(self.db_model).filter_by(id=record.id).first()
+                if existing_record:
+                    if exists_ok:
+                        fields = record.model_dump()
+                        fields.pop("id")
+                        session.query(self.db_model).filter(self.db_model.id == record.id).update(fields)
+                        session.commit()
+                    else:
+                        raise ValueError(f"Record with id {record.id} already exists.")
+
+                else:
+                    db_record = self.db_model(**record.dict())
+                    session.add(db_record)
+                    session.commit()
+
+                added_ids.append(record.id)
 
     def insert(self, record, exists_ok=True):
         self.insert_many([record], exists_ok=exists_ok)

{letta_nightly-0.4.1.dev20241008104105 → letta_nightly-0.4.1.dev20241010104112}/letta/cli/cli.py

@@ -11,6 +11,7 @@ from letta import create_client
 from letta.agent import Agent, save_agent
 from letta.config import LettaConfig
 from letta.constants import CLI_WARNING_PREFIX, LETTA_DIR
+from letta.local_llm.constants import ASSISTANT_MESSAGE_CLI_SYMBOL
 from letta.log import get_logger
 from letta.metadata import MetadataStore
 from letta.schemas.enums import OptionState
@@ -276,7 +277,7 @@ def run(
         memory = ChatMemory(human=human_obj.value, persona=persona_obj.value, limit=core_memory_limit)
         metadata = {"human": human_obj.name, "persona": persona_obj.name}
 
-        typer.secho(f"->  🤖 Using persona profile: '{persona_obj.name}'", fg=typer.colors.WHITE)
+        typer.secho(f"->  {ASSISTANT_MESSAGE_CLI_SYMBOL} Using persona profile: '{persona_obj.name}'", fg=typer.colors.WHITE)
         typer.secho(f"->  🧑 Using human profile: '{human_obj.name}'", fg=typer.colors.WHITE)
 
         # add tools

letta_nightly-0.4.1.dev20241010104112/letta/cli/cli_config.py

@@ -0,0 +1,228 @@
+import ast
+import os
+from enum import Enum
+from typing import Annotated, List, Optional
+
+import questionary
+import typer
+from prettytable.colortable import ColorTable, Themes
+from tqdm import tqdm
+
+from letta import utils
+
+app = typer.Typer()
+
+
+@app.command()
+def configure():
+    """Updates default Letta configurations
+
+    This function and quickstart should be the ONLY place where LettaConfig.save() is called
+    """
+    print("`letta configure` has been deprecated. Please see documentation on configuration, and run `letta run` instead.")
+
+
+class ListChoice(str, Enum):
+    agents = "agents"
+    humans = "humans"
+    personas = "personas"
+    sources = "sources"
+
+
+@app.command()
+def list(arg: Annotated[ListChoice, typer.Argument]):
+    from letta.client.client import create_client
+
+    client = create_client()
+    table = ColorTable(theme=Themes.OCEAN)
+    if arg == ListChoice.agents:
+        """List all agents"""
+        table.field_names = ["Name", "LLM Model", "Embedding Model", "Embedding Dim", "Persona", "Human", "Data Source", "Create Time"]
+        for agent in tqdm(client.list_agents()):
+            # TODO: add this function
+            sources = client.list_attached_sources(agent_id=agent.id)
+            source_names = [source.name for source in sources if source is not None]
+            table.add_row(
+                [
+                    agent.name,
+                    agent.llm_config.model,
+                    agent.embedding_config.embedding_model,
+                    agent.embedding_config.embedding_dim,
+                    agent.memory.get_block("persona").value[:100] + "...",
+                    agent.memory.get_block("human").value[:100] + "...",
+                    ",".join(source_names),
+                    utils.format_datetime(agent.created_at),
+                ]
+            )
+        print(table)
+    elif arg == ListChoice.humans:
+        """List all humans"""
+        table.field_names = ["Name", "Text"]
+        for human in client.list_humans():
+            table.add_row([human.name, human.value.replace("\n", "")[:100]])
+        print(table)
+    elif arg == ListChoice.personas:
+        """List all personas"""
+        table.field_names = ["Name", "Text"]
+        for persona in client.list_personas():
+            table.add_row([persona.name, persona.value.replace("\n", "")[:100]])
+        print(table)
+    elif arg == ListChoice.sources:
+        """List all data sources"""
+
+        # create table
+        table.field_names = ["Name", "Description", "Embedding Model", "Embedding Dim", "Created At"]
+        # TODO: eventually look accross all storage connections
+        # TODO: add data source stats
+        # TODO: connect to agents
+
+        # get all sources
+        for source in client.list_sources():
+            # get attached agents
+            table.add_row(
+                [
+                    source.name,
+                    source.description,
+                    source.embedding_config.embedding_model,
+                    source.embedding_config.embedding_dim,
+                    utils.format_datetime(source.created_at),
+                ]
+            )
+
+        print(table)
+    else:
+        raise ValueError(f"Unknown argument {arg}")
+    return table
+
+
+@app.command()
+def add_tool(
+    filename: str = typer.Option(..., help="Path to the Python file containing the function"),
+    name: Optional[str] = typer.Option(None, help="Name of the tool"),
+    update: bool = typer.Option(True, help="Update the tool if it already exists"),
+    tags: Optional[List[str]] = typer.Option(None, help="Tags for the tool"),
+):
+    """Add or update a tool from a Python file."""
+    from letta.client.client import create_client
+
+    client = create_client(base_url=os.getenv("MEMGPT_BASE_URL"), token=os.getenv("MEMGPT_SERVER_PASS"))
+
+    # 1. Parse the Python file
+    with open(filename, "r", encoding="utf-8") as file:
+        source_code = file.read()
+
+    # 2. Parse the source code to extract the function
+    # Note: here we assume it is one function only in the file.
+    module = ast.parse(source_code)
+    func_def = None
+    for node in module.body:
+        if isinstance(node, ast.FunctionDef):
+            func_def = node
+            break
+
+    if not func_def:
+        raise ValueError("No function found in the provided file")
+
+    # 3. Compile the function to make it callable
+    # Explanation courtesy of GPT-4:
+    # Compile the AST (Abstract Syntax Tree) node representing the function definition into a code object
+    # ast.Module creates a module node containing the function definition (func_def)
+    # compile converts the AST into a code object that can be executed by the Python interpreter
+    # The exec function executes the compiled code object in the current context,
+    # effectively defining the function within the current namespace
+    exec(compile(ast.Module([func_def], []), filename, "exec"))
+    # Retrieve the function object by evaluating its name in the current namespace
+    # eval looks up the function name in the current scope and returns the function object
+    func = eval(func_def.name)
+
+    # 4. Add or update the tool
+    tool = client.create_tool(func=func, name=name, tags=tags, update=update)
+    print(f"Tool {tool.name} added successfully")
+
+
+@app.command()
+def list_tools():
+    """List all available tools."""
+    from letta.client.client import create_client
+
+    client = create_client(base_url=os.getenv("MEMGPT_BASE_URL"), token=os.getenv("MEMGPT_SERVER_PASS"))
+
+    tools = client.list_tools()
+    for tool in tools:
+        print(f"Tool: {tool.name}")
+
+
+@app.command()
+def add(
+    option: str,  # [human, persona]
+    name: Annotated[str, typer.Option(help="Name of human/persona")],
+    text: Annotated[Optional[str], typer.Option(help="Text of human/persona")] = None,
+    filename: Annotated[Optional[str], typer.Option("-f", help="Specify filename")] = None,
+):
+    """Add a person/human"""
+    from letta.client.client import create_client
+
+    client = create_client(base_url=os.getenv("MEMGPT_BASE_URL"), token=os.getenv("MEMGPT_SERVER_PASS"))
+    if filename:  # read from file
+        assert text is None, "Cannot specify both text and filename"
+        with open(filename, "r", encoding="utf-8") as f:
+            text = f.read()
+    else:
+        assert text is not None, "Must specify either text or filename"
+    if option == "persona":
+        persona_id = client.get_persona_id(name)
+        if persona_id:
+            client.get_persona(persona_id)
+            # config if user wants to overwrite
+            if not questionary.confirm(f"Persona {name} already exists. Overwrite?").ask():
+                return
+            client.update_persona(persona_id, text=text)
+        else:
+            client.create_persona(name=name, text=text)
+
+    elif option == "human":
+        human_id = client.get_human_id(name)
+        if human_id:
+            human = client.get_human(human_id)
+            # config if user wants to overwrite
+            if not questionary.confirm(f"Human {name} already exists. Overwrite?").ask():
+                return
+            client.update_human(human_id, text=text)
+        else:
+            human = client.create_human(name=name, text=text)
+    else:
+        raise ValueError(f"Unknown kind {option}")
+
+
+@app.command()
+def delete(option: str, name: str):
+    """Delete a source from the archival memory."""
+    from letta.client.client import create_client
+
+    client = create_client(base_url=os.getenv("MEMGPT_BASE_URL"), token=os.getenv("MEMGPT_API_KEY"))
+    try:
+        # delete from metadata
+        if option == "source":
+            # delete metadata
+            source_id = client.get_source_id(name)
+            assert source_id is not None, f"Source {name} does not exist"
+            client.delete_source(source_id)
+        elif option == "agent":
+            agent_id = client.get_agent_id(name)
+            assert agent_id is not None, f"Agent {name} does not exist"
+            client.delete_agent(agent_id=agent_id)
+        elif option == "human":
+            human_id = client.get_human_id(name)
+            assert human_id is not None, f"Human {name} does not exist"
+            client.delete_human(human_id)
+        elif option == "persona":
+            persona_id = client.get_persona_id(name)
+            assert persona_id is not None, f"Persona {name} does not exist"
+            client.delete_persona(persona_id)
+        else:
+            raise ValueError(f"Option {option} not implemented")
+
+        typer.secho(f"Deleted {option} '{name}'", fg=typer.colors.GREEN)
+
+    except Exception as e:
+        typer.secho(f"Failed to delete {option}'{name}'\n{e}", fg=typer.colors.RED)

{letta_nightly-0.4.1.dev20241008104105 → letta_nightly-0.4.1.dev20241010104112}/letta/client/client.py

@@ -9,7 +9,7 @@ from letta.constants import BASE_TOOLS, DEFAULT_HUMAN, DEFAULT_PERSONA
 from letta.data_sources.connectors import DataConnector
 from letta.functions.functions import parse_source_code
 from letta.memory import get_memory_functions
-from letta.schemas.agent import AgentState, CreateAgent, UpdateAgentState
+from letta.schemas.agent import AgentState, AgentType, CreateAgent, UpdateAgentState
 from letta.schemas.block import (
     Block,
     CreateBlock,
@@ -68,6 +68,7 @@ class AbstractClient(object):
     def create_agent(
         self,
         name: Optional[str] = None,
+        agent_type: Optional[AgentType] = AgentType.memgpt_agent,
         embedding_config: Optional[EmbeddingConfig] = None,
         llm_config: Optional[LLMConfig] = None,
         memory: Memory = ChatMemory(human=get_human_text(DEFAULT_HUMAN), persona=get_persona_text(DEFAULT_PERSONA)),
@@ -319,6 +320,8 @@ class RESTClient(AbstractClient):
     def create_agent(
         self,
         name: Optional[str] = None,
+        # agent config
+        agent_type: Optional[AgentType] = AgentType.memgpt_agent,
         # model configs
         embedding_config: EmbeddingConfig = None,
         llm_config: LLMConfig = None,
@@ -381,6 +384,7 @@ class RESTClient(AbstractClient):
             memory=memory,
             tools=tool_names,
             system=system,
+            agent_type=agent_type,
             llm_config=llm_config if llm_config else self._default_llm_config,
             embedding_config=embedding_config if embedding_config else self._default_embedding_config,
         )
@@ -1462,6 +1466,8 @@ class LocalClient(AbstractClient):
     def create_agent(
         self,
         name: Optional[str] = None,
+        # agent config
+        agent_type: Optional[AgentType] = AgentType.memgpt_agent,
         # model configs
         embedding_config: EmbeddingConfig = None,
         llm_config: LLMConfig = None,
@@ -1524,6 +1530,7 @@ class LocalClient(AbstractClient):
                 memory=memory,
                 tools=tool_names,
                 system=system,
+                agent_type=agent_type,
                 llm_config=llm_config if llm_config else self._default_llm_config,
                 embedding_config=embedding_config if embedding_config else self._default_embedding_config,
             ),

{letta_nightly-0.4.1.dev20241008104105 → letta_nightly-0.4.1.dev20241010104112}/letta/client/utils.py

@@ -2,6 +2,11 @@ from datetime import datetime
 
 from IPython.display import HTML, display
 
+from letta.local_llm.constants import (
+    ASSISTANT_MESSAGE_CLI_SYMBOL,
+    INNER_THOUGHTS_CLI_SYMBOL,
+)
+
 
 def pprint(messages):
     """Utility function for pretty-printing the output of client.send_message in notebooks"""
@@ -47,13 +52,13 @@ def pprint(messages):
             html_content += f"<p><strong>🛠️ [{date_formatted}] Function Return ({return_status}):</strong></p>"
             html_content += f"<p class='function-return'>{return_string}</p>"
         elif "internal_monologue" in message:
-            html_content += f"<p><strong>💭 [{date_formatted}] Internal Monologue:</strong></p>"
+            html_content += f"<p><strong>{INNER_THOUGHTS_CLI_SYMBOL} [{date_formatted}] Internal Monologue:</strong></p>"
             html_content += f"<p class='internal-monologue'>{message['internal_monologue']}</p>"
         elif "function_call" in message:
             html_content += f"<p><strong>🛠️ [[{date_formatted}] Function Call:</strong></p>"
             html_content += f"<p class='function-call'>{message['function_call']}</p>"
         elif "assistant_message" in message:
-            html_content += f"<p><strong>🤖 [{date_formatted}] Assistant Message:</strong></p>"
+            html_content += f"<p><strong>{ASSISTANT_MESSAGE_CLI_SYMBOL} [{date_formatted}] Assistant Message:</strong></p>"
             html_content += f"<p class='assistant-message'>{message['assistant_message']}</p>"
         html_content += "<br>"
     html_content += "</div>"

{letta_nightly-0.4.1.dev20241008104105 → letta_nightly-0.4.1.dev20241010104112}/letta/credentials.py

@@ -76,7 +76,7 @@ class LettaCredentials:
                 "azure_embedding_deployment": get_field(config, "azure", "embedding_deployment"),
                 # gemini
                 "google_ai_key": get_field(config, "google_ai", "key"),
-                "google_ai_service_endpoint": get_field(config, "google_ai", "service_endpoint"),
+                # "google_ai_service_endpoint": get_field(config, "google_ai", "service_endpoint"),
                 # anthropic
                 "anthropic_key": get_field(config, "anthropic", "key"),
                 # cohere
@@ -117,7 +117,7 @@ class LettaCredentials:
 
         # gemini
         set_field(config, "google_ai", "key", self.google_ai_key)
-        set_field(config, "google_ai", "service_endpoint", self.google_ai_service_endpoint)
+        # set_field(config, "google_ai", "service_endpoint", self.google_ai_service_endpoint)
 
         # anthropic
         set_field(config, "anthropic", "key", self.anthropic_key)

{letta_nightly-0.4.1.dev20241008104105 → letta_nightly-0.4.1.dev20241010104112}/letta/embeddings.py

@@ -91,6 +91,9 @@ class EmbeddingEndpoint:
             raise ValueError(
                 f"Embeddings endpoint was provided an invalid URL (set to: '{base_url}'). Make sure embedding_endpoint is set correctly in your Letta config."
             )
+        # TODO: find a neater solution - re-mapping for letta endpoint
+        if model == "letta-free":
+            model = "BAAI/bge-large-en-v1.5"
         self.model_name = model
         self._user = user
         self._base_url = base_url

{letta_nightly-0.4.1.dev20241008104105 → letta_nightly-0.4.1.dev20241010104112}/letta/functions/schema_generator.py

@@ -130,7 +130,7 @@ def generate_schema(function, name: Optional[str] = None, description: Optional[
     if function.__name__ not in ["send_message", "pause_heartbeats"]:
         schema["parameters"]["properties"]["request_heartbeat"] = {
             "type": "boolean",
-            "description": "Request an immediate heartbeat after function execution. Set to 'true' if you want to send a follow-up message or run a follow-up function.",
+            "description": "Request an immediate heartbeat after function execution. Set to `True` if you want to send a follow-up message or run a follow-up function.",
         }
         schema["parameters"]["required"].append("request_heartbeat")
 

{letta_nightly-0.4.1.dev20241008104105 → letta_nightly-0.4.1.dev20241010104112}/letta/interface.py

@@ -5,6 +5,10 @@ from typing import List, Optional
 from colorama import Fore, Style, init
 
 from letta.constants import CLI_WARNING_PREFIX
+from letta.local_llm.constants import (
+    ASSISTANT_MESSAGE_CLI_SYMBOL,
+    INNER_THOUGHTS_CLI_SYMBOL,
+)
 from letta.schemas.message import Message
 from letta.utils import json_loads, printd
 
@@ -79,14 +83,14 @@ class CLIInterface(AgentInterface):
     @staticmethod
     def internal_monologue(msg: str, msg_obj: Optional[Message] = None):
         # ANSI escape code for italic is '\x1B[3m'
-        fstr = f"\x1B[3m{Fore.LIGHTBLACK_EX}💭 {{msg}}{Style.RESET_ALL}"
+        fstr = f"\x1B[3m{Fore.LIGHTBLACK_EX}{INNER_THOUGHTS_CLI_SYMBOL} {{msg}}{Style.RESET_ALL}"
         if STRIP_UI:
             fstr = "{msg}"
         print(fstr.format(msg=msg))
 
     @staticmethod
     def assistant_message(msg: str, msg_obj: Optional[Message] = None):
-        fstr = f"{Fore.YELLOW}{Style.BRIGHT}🤖 {Fore.YELLOW}{{msg}}{Style.RESET_ALL}"
+        fstr = f"{Fore.YELLOW}{Style.BRIGHT}{ASSISTANT_MESSAGE_CLI_SYMBOL} {Fore.YELLOW}{{msg}}{Style.RESET_ALL}"
         if STRIP_UI:
             fstr = "{msg}"
         print(fstr.format(msg=msg))

{letta_nightly-0.4.1.dev20241008104105 → letta_nightly-0.4.1.dev20241010104112}/letta/llm_api/anthropic.py

@@ -2,8 +2,7 @@ import json
 import re
 from typing import List, Optional, Union
 
-import requests
-
+from letta.llm_api.helpers import make_post_request
 from letta.schemas.message import Message
 from letta.schemas.openai.chat_completion_request import ChatCompletionRequest, Tool
 from letta.schemas.openai.chat_completion_response import (
@@ -295,7 +294,6 @@ def anthropic_chat_completions_request(
     inner_thoughts_xml_tag: Optional[str] = "thinking",
 ) -> ChatCompletionResponse:
     """https://docs.anthropic.com/claude/docs/tool-use"""
-    from letta.utils import printd
 
     url = smart_urljoin(url, "messages")
     headers = {
@@ -360,24 +358,5 @@ def anthropic_chat_completions_request(
     data.pop("user", None)
     data.pop("tool_choice", None)
 
-    printd(f"Sending request to {url}")
-    try:
-        response = requests.post(url, headers=headers, json=data)
-        printd(f"response = {response}")
-        response.raise_for_status()  # Raises HTTPError for 4XX/5XX status
-        response = response.json()  # convert to dict from string
-        printd(f"response.json = {response}")
-        response = convert_anthropic_response_to_chatcompletion(response_json=response, inner_thoughts_xml_tag=inner_thoughts_xml_tag)
-        return response
-    except requests.exceptions.HTTPError as http_err:
-        # Handle HTTP errors (e.g., response 4XX, 5XX)
-        printd(f"Got HTTPError, exception={http_err}, payload={data}")
-        raise http_err
-    except requests.exceptions.RequestException as req_err:
-        # Handle other requests-related errors (e.g., connection error)
-        printd(f"Got RequestException, exception={req_err}")
-        raise req_err
-    except Exception as e:
-        # Handle other potential errors
-        printd(f"Got unknown Exception, exception={e}")
-        raise e
+    response_json = make_post_request(url, headers, data)
+    return convert_anthropic_response_to_chatcompletion(response_json=response_json, inner_thoughts_xml_tag=inner_thoughts_xml_tag)

letta_nightly-0.4.1.dev20241010104112/letta/llm_api/azure_openai.py

@@ -0,0 +1,100 @@
+import requests
+
+from letta.llm_api.helpers import make_post_request
+from letta.schemas.llm_config import LLMConfig
+from letta.schemas.openai.chat_completion_response import ChatCompletionResponse
+from letta.schemas.openai.chat_completions import ChatCompletionRequest
+from letta.schemas.openai.embedding_response import EmbeddingResponse
+from letta.settings import ModelSettings
+
+
+def get_azure_chat_completions_endpoint(base_url: str, model: str, api_version: str):
+    return f"{base_url}/openai/deployments/{model}/chat/completions?api-version={api_version}"
+
+
+def get_azure_embeddings_endpoint(base_url: str, model: str, api_version: str):
+    return f"{base_url}/openai/deployments/{model}/embeddings?api-version={api_version}"
+
+
+def get_azure_model_list_endpoint(base_url: str, api_version: str):
+    return f"{base_url}/openai/models?api-version={api_version}"
+
+
+def azure_openai_get_model_list(base_url: str, api_key: str, api_version: str) -> list:
+    """https://learn.microsoft.com/en-us/rest/api/azureopenai/models/list?view=rest-azureopenai-2023-05-15&tabs=HTTP"""
+
+    # https://xxx.openai.azure.com/openai/models?api-version=xxx
+    headers = {"Content-Type": "application/json"}
+    if api_key is not None:
+        headers["api-key"] = f"{api_key}"
+
+    url = get_azure_model_list_endpoint(base_url, api_version)
+    try:
+        response = requests.get(url, headers=headers)
+        response.raise_for_status()
+    except requests.RequestException as e:
+        raise RuntimeError(f"Failed to retrieve model list: {e}")
+
+    return response.json().get("data", [])
+
+
+def azure_openai_get_chat_completion_model_list(base_url: str, api_key: str, api_version: str) -> list:
+    model_list = azure_openai_get_model_list(base_url, api_key, api_version)
+    # Extract models that support text generation
+    model_options = [m for m in model_list if m.get("capabilities").get("chat_completion") == True]
+    return model_options
+
+
+def azure_openai_get_embeddings_model_list(base_url: str, api_key: str, api_version: str, require_embedding_in_name: bool = True) -> list:
+    def valid_embedding_model(m: dict):
+        valid_name = True
+        if require_embedding_in_name:
+            valid_name = "embedding" in m["id"]
+
+        return m.get("capabilities").get("embeddings") == True and valid_name
+
+    model_list = azure_openai_get_model_list(base_url, api_key, api_version)
+    # Extract models that support embeddings
+
+    model_options = [m for m in model_list if valid_embedding_model(m)]
+    return model_options
+
+
+def azure_openai_chat_completions_request(
+    model_settings: ModelSettings, llm_config: LLMConfig, api_key: str, chat_completion_request: ChatCompletionRequest
+) -> ChatCompletionResponse:
+    """https://learn.microsoft.com/en-us/azure/ai-services/openai/reference#chat-completions"""
+
+    assert api_key is not None, "Missing required field when calling Azure OpenAI"
+
+    headers = {"Content-Type": "application/json", "api-key": f"{api_key}"}
+    data = chat_completion_request.model_dump(exclude_none=True)
+
+    # If functions == None, strip from the payload
+    if "functions" in data and data["functions"] is None:
+        data.pop("functions")
+        data.pop("function_call", None)  # extra safe,  should exist always (default="auto")
+
+    if "tools" in data and data["tools"] is None:
+        data.pop("tools")
+        data.pop("tool_choice", None)  # extra safe,  should exist always (default="auto")
+
+    url = get_azure_chat_completions_endpoint(model_settings.azure_base_url, llm_config.model, model_settings.api_version)
+    response_json = make_post_request(url, headers, data)
+    # NOTE: azure openai does not include "content" in the response when it is None, so we need to add it
+    if "content" not in response_json["choices"][0].get("message"):
+        response_json["choices"][0]["message"]["content"] = None
+    response = ChatCompletionResponse(**response_json)  # convert to 'dot-dict' style which is the openai python client default
+    return response
+
+
+def azure_openai_embeddings_request(
+    resource_name: str, deployment_id: str, api_version: str, api_key: str, data: dict
+) -> EmbeddingResponse:
+    """https://learn.microsoft.com/en-us/azure/ai-services/openai/reference#embeddings"""
+
+    url = f"https://{resource_name}.openai.azure.com/openai/deployments/{deployment_id}/embeddings?api-version={api_version}"
+    headers = {"Content-Type": "application/json", "api-key": f"{api_key}"}
+
+    response_json = make_post_request(url, headers, data)
+    return EmbeddingResponse(**response_json)