[Question] Does it only support, agent, system and user roles?

[zerocorebeta]

I am working on a system where 1 agent does a job, and then other agent comes.

but when i try passing convo with different agent names to it, it throws errors why?

So, my question is : is there anyhack or dirty way or any feature? I went through documentation including "ask ai" one but didn't return anything.

Here's sample of what i am trying to achieve:

   {
      "role": "assistant",
      "content": "**Implementation Briefing**\n\n**1. Objective:**\nAdd a new function `helloworld9999` to `main.py` that prints \"hello world\".\n\n**2. Final Plan:**\n1.  Add a new function named `helloworld9999` to the `main.py` file.\n2.  Inside the `helloworld9999` function, add a statement to `print(\"hello world\")`. The new function will be appended to the end of the file.\n\n**3. File Impact Analysis:**\n*   **Files to Modify:**\n    *   `main.py`\n*   **Files to Create:**\n    *   None\n\n**4. Rationale and Context Map:**\n*   `main.py`: This file will be modified to include the new `helloworld9999` function as per the user's request.\n\n<files_to_edit>\nmain.py\n</files_to_edit>",
      "chatmode": "ask",
      "edit_format": "ask"
    },
    {
      "role": "coding_agent",
      "content": "Okay, I will add the `helloworld9999` function to `main.py`. Here is the plan:\n\n1.  Add the `helloworld9999` function, which prints \"hello world\", to the end of `main.py`.\n\nHere is the required *SEARCH/REPLACE* block:\n\n```python\nmain.py\n<<<<<<< SEARCH\n# Run the calculator\ncalculator()\n=======\n# Run the calculator\ncalculator()\n\ndef helloworld9999():\n    print(\"hello world\")\n>>>>>>> REPLACE\n```",
      "chatmode": "code",
      "edit_format": "diff-fenced"
    },
    {
      "role": "user",
      "content": "I committed the changes with git hash ed87f0c & commit msg: feat: Add helloworld9999 function",
      "chatmode": "code",
      "edit_format": "diff-fenced"
    },
    {
      "role": "coding_agent",
      "content": "Ok.",
      "chatmode": "code",
      "edit_format": "diff-fenced"

[zerocorebeta]

Reading here: https://docs.litellm.ai/docs/completion/input

role: string - The role of the message's author. Roles can be: system, user, assistant, function or tool.

So, how can you make two assistants + 1 user conversation with this?

[zerocorebeta]

Upon further investigation i found this!

The roles supported by liteLLM—primarily system, user, and assistant—are a direct reflection of the capabilities of the underlying language models it connects to. This limitation isn't arbitrary on liteLLM's part; rather, it standardizes the most common conversational structure that major AI models are trained to understand.

Models from providers like OpenAI, Anthropic, and open-source options like Llama 3 are all fundamentally designed to work with these core roles:

• system: This role sets the stage for the conversation. It's used to provide high-level instructions, context, or persona for the AI assistant throughout the interaction.
• user: This represents the input from the human user. It's what you are asking or telling the model.
• assistant: This is for the AI model's own responses. It's how the model participates in the conversation.
• tool (formerly function): This role is used for the results of any tools or functions the model decides to call.

Because these roles are fundamental to how the models are trained, introducing a custom role like "assistant2" wouldn't be understood by the model without specific fine-tuning. liteLLM, as a universal interface, adheres to this established standard to ensure consistent behavior across over 100 different LLM providers.

Implementing a Conversation with Two Assistants and One User

While there isn't a separate, built-in role for a second assistant, you can effectively manage a multi-assistant conversation by structuring the messages list programmatically. The key is to maintain the alternating user and assistant turn structure that the models expect, while indicating which assistant is "speaking" within your application's logic.

The most common and reliable method is to prefix the content of the assistant's message with a name or identifier. Here is an example of how you can structure the messages list for a scenario with a user and two assistants, "Assistant_A" and "Assistant_B":

import litellm

# Example conversation flow:
# User -> Assistant_A -> User -> Assistant_B

messages = [
    {
        "role": "system",
        "content": "You are in a conversation with two helpful assistants, Assistant_A and Assistant_B."
    },
    {
        "role": "user",
        "content": "Hello, can Assistant_A tell me about the weather, and Assistant_B tell me a fun fact?"
    },
    # Your application logic would first call the LLM for Assistant_A's response
    # and then append it to the message history.
    {
        "role": "assistant",
        "content": "Assistant_A: The weather today is sunny with a high of 75°F."
    },
    # Now, let's say the user has a follow-up for Assistant_B
    {
        "role": "user",
        "content": "Thanks! Now for that fun fact."
    },
    # Your application would now generate and append Assistant_B's response.
    # The entire history is passed back to the model to maintain context.
    {
        "role": "assistant",
        "content": "Assistant_B: A single strand of spaghetti is called a 'spaghetto'!"
    }
]

# When you want the next response from a specific assistant, you can prompt the model.
# For example, to prompt Assistant_A to speak next:
messages.append({
    "role": "user",
    "content": "Assistant_A, what is the forecast for tomorrow?"
})

# response = litellm.completion(
#     model="gpt-4",
#     messages=messages
# )

# print(response.choices[0].message.content)

How this approach works:

1. Maintain a single conversation history. All messages from the user and both assistants are kept in one list.
2. Use the assistant role for all AI responses. You don't try to create a new role.
3. Distinguish speakers in the content. By starting the content with "Assistant_A:" or "Assistant_B:", you provide clear context within the conversation for both the user and the LLM to understand who said what.
4. Control the flow externally. Your application logic is responsible for deciding which assistant should respond next, calling the litellm.completion function, and appending the correctly prefixed response to the messages list.

While the messages object in the OpenAI API (which liteLLM follows) has an optional name parameter, its primary purpose is to identify the source of a tool call's result. While you could technically use it to name assistants, its support and interpretation can vary between different models, making the content-prefixing method more robust and universally understood.

[github-actions]

This issue has been automatically marked as stale because it has not had recent activity. It will be closed if no further activity occurs.