autogen_agentchat.messages#

Dieses Modul definiert verschiedene Nachrichtentypen für die Kommunikation zwischen Agenten. Jeder Nachrichtentyp erbt entweder von der Klasse BaseChatMessage oder BaseAgentEvent und enthält spezifische Felder, die für die Art der gesendeten Nachricht relevant sind.

AgentEvent#

Der Union-Typ aller integrierten konkreten Unterklassen von BaseAgentEvent.

pydantic model BaseMessage[Quelle]#

Bases: BaseModel, ABC

Abstrakte Basisklasse für alle Nachrichten in AgentChat.

Warnung

Wenn Sie einen neuen Nachrichtentyp erstellen möchten, erben Sie nicht von dieser Klasse. Erben Sie stattdessen von BaseChatMessage oder BaseAgentEvent, um den Zweck des Nachrichtentyps zu verdeutlichen.

JSON-Schema anzeigen

{
   "title": "BaseMessage",
   "description": "Abstract base class for all message types in AgentChat.\n\n.. warning::\n\n    If you want to create a new message type, do not inherit from this class.\n    Instead, inherit from :class:`BaseChatMessage` or :class:`BaseAgentEvent`\n    to clarify the purpose of the message type.",
   "type": "object",
   "properties": {}
}

abstract to_text() → str[Quelle]#: Konvertiert den Nachrichteninhalt in eine reine Textdarstellung, die in der Konsole angezeigt und vom Benutzer oder von Bedingungen inspiziert werden kann. Dies wird nicht zum Erstellen von rein textuellen Inhalten für Modelle verwendet. Verwenden Sie für BaseChatMessage-Typen stattdessen to_model_text().

dump() → Mapping[str, Any][Quelle]#

Konvertiert die Nachricht in ein JSON-serialisierbares Wörterbuch.

Die Standardimplementierung verwendet die Methode model_dump() des Pydantic-Modells, um die Nachricht in ein Wörterbuch zu konvertieren. Datumsobjekte werden automatisch in ISO-formatierte Zeichenketten konvertiert, um die JSON-Serialisierungskompatibilität sicherzustellen. Überschreiben Sie diese Methode, wenn Sie den Serialisierungsprozess anpassen oder zusätzliche Felder zum Ausgabeergebnis hinzufügen möchten.

classmethod load(data: Mapping[str, Any]) → Self[Quelle]#

Erstellt eine Nachricht aus einem Wörterbuch mit JSON-serialisierbaren Daten.

Die Standardimplementierung verwendet die Methode model_validate() des Pydantic-Modells, um die Nachricht aus den Daten zu erstellen. Überschreiben Sie diese Methode, wenn Sie den Deserialisierungsprozess anpassen oder zusätzliche Felder zu den Eingabedaten hinzufügen möchten.

ChatMessage#

Der Union-Typ aller integrierten konkreten Unterklassen von BaseChatMessage. Er enthält keine StructuredMessage-Typen.

alias von Annotated[TextMessage | MultiModalMessage | StopMessage | ToolCallSummaryMessage | HandoffMessage, FieldInfo(annotation=NoneType, required=True, discriminator=’type’)]

pydantic model BaseChatMessage[Quelle]#

Bases: BaseMessage, ABC

Abstrakte Basisklasse für Chat-Nachrichten.

Hinweis

Wenn Sie einen neuen Nachrichtentyp für die Kommunikation zwischen Agenten erstellen möchten, erben Sie von dieser Klasse oder verwenden Sie einfach StructuredMessage, wenn Ihr Inhaltstyp eine Unterklasse von Pydantic BaseModel ist.

Diese Klasse wird für Nachrichten verwendet, die zwischen Agenten in einer Chat-Konversation gesendet werden. Agenten werden erwartet, den Inhalt der Nachricht mit Modellen zu verarbeiten und eine Antwort als weitere BaseChatMessage zurückzugeben.

JSON-Schema anzeigen

{
   "title": "BaseChatMessage",
   "description": "Abstract base class for chat messages.\n\n.. note::\n\n    If you want to create a new message type that is used for agent-to-agent\n    communication, inherit from this class, or simply use\n    :class:`StructuredMessage` if your content type is a subclass of\n    Pydantic BaseModel.\n\nThis class is used for messages that are sent between agents in a chat\nconversation. Agents are expected to process the content of the\nmessage using models and return a response as another :class:`BaseChatMessage`.",
   "type": "object",
   "properties": {
      "id": {
         "title": "Id",
         "type": "string"
      },
      "source": {
         "title": "Source",
         "type": "string"
      },
      "models_usage": {
         "anyOf": [
            {
               "$ref": "#/$defs/RequestUsage"
            },
            {
               "type": "null"
            }
         ],
         "default": null
      },
      "metadata": {
         "additionalProperties": {
            "type": "string"
         },
         "default": {},
         "title": "Metadata",
         "type": "object"
      },
      "created_at": {
         "format": "date-time",
         "title": "Created At",
         "type": "string"
      }
   },
   "$defs": {
      "RequestUsage": {
         "properties": {
            "prompt_tokens": {
               "title": "Prompt Tokens",
               "type": "integer"
            },
            "completion_tokens": {
               "title": "Completion Tokens",
               "type": "integer"
            }
         },
         "required": [
            "prompt_tokens",
            "completion_tokens"
         ],
         "title": "RequestUsage",
         "type": "object"
      }
   },
   "required": [
      "source"
   ]
}

Felder:

created_at (datetime.datetime)
id (str)
metadata (Dict[str, str])
models_usage (autogen_core.models._types.RequestUsage | None)
source (str)

field id: str [Optional]#: Eindeutiger Bezeichner für diese Nachricht.

field source: str [Required]#: Der Name des Agenten, der diese Nachricht gesendet hat.

field models_usage: RequestUsage | None = None#: Die Modellnutzung, die bei der Erstellung dieser Nachricht angefallen ist.

field metadata: Dict[str, str] = {}#: Zusätzliche Metadaten zur Nachricht.

field created_at: datetime [Optional]#: Der Zeitpunkt, zu dem die Nachricht erstellt wurde.

abstract to_model_text() → str[Quelle]#

Konvertiert den Inhalt der Nachricht in eine reine Textdarstellung. Dies wird zum Erstellen von rein textuellen Inhalten für Modelle verwendet.

Dies wird nicht zur Anzeige der Nachricht in der Konsole verwendet. Verwenden Sie hierfür to_text().

Der Unterschied zwischen dieser und to_model_message() besteht darin, dass diese zur Konstruktion von Teilen einer Nachricht für den Modellclient verwendet wird, während to_model_message() zur Erstellung einer vollständigen Nachricht für den Modellclient verwendet wird.

abstract to_model_message() → UserMessage[Quelle]#: Konvertiert den Nachrichteninhalt in eine UserMessage zur Verwendung mit einem Modellclient, z.B. ChatCompletionClient.

pydantic model BaseAgentEvent[Quelle]#

Bases: BaseMessage, ABC

Basisklasse für Agentenereignisse.

Hinweis

Wenn Sie einen neuen Nachrichtentyp zum Signalisieren beobachtbarer Ereignisse an Benutzer und Anwendungen erstellen möchten, erben Sie von dieser Klasse.

Agentenereignisse werden verwendet, um Aktionen und Gedanken von Agenten und Teams an Benutzer und Anwendungen zu signalisieren. Sie werden nicht für die Kommunikation zwischen Agenten verwendet und sollen nicht von anderen Agenten verarbeitet werden.

Sie sollten die Methode to_text() überschreiben, wenn Sie eine benutzerdefinierte Darstellung des Inhalts bereitstellen möchten.

JSON-Schema anzeigen

{
   "title": "BaseAgentEvent",
   "description": "Base class for agent events.\n\n.. note::\n\n    If you want to create a new message type for signaling observable events\n    to user and application, inherit from this class.\n\nAgent events are used to signal actions and thoughts produced by agents\nand teams to user and applications. They are not used for agent-to-agent\ncommunication and are not expected to be processed by other agents.\n\nYou should override the :meth:`to_text` method if you want to provide\na custom rendering of the content.",
   "type": "object",
   "properties": {
      "id": {
         "title": "Id",
         "type": "string"
      },
      "source": {
         "title": "Source",
         "type": "string"
      },
      "models_usage": {
         "anyOf": [
            {
               "$ref": "#/$defs/RequestUsage"
            },
            {
               "type": "null"
            }
         ],
         "default": null
      },
      "metadata": {
         "additionalProperties": {
            "type": "string"
         },
         "default": {},
         "title": "Metadata",
         "type": "object"
      },
      "created_at": {
         "format": "date-time",
         "title": "Created At",
         "type": "string"
      }
   },
   "$defs": {
      "RequestUsage": {
         "properties": {
            "prompt_tokens": {
               "title": "Prompt Tokens",
               "type": "integer"
            },
            "completion_tokens": {
               "title": "Completion Tokens",
               "type": "integer"
            }
         },
         "required": [
            "prompt_tokens",
            "completion_tokens"
         ],
         "title": "RequestUsage",
         "type": "object"
      }
   },
   "required": [
      "source"
   ]
}

Felder:

created_at (datetime.datetime)
id (str)
metadata (Dict[str, str])
models_usage (autogen_core.models._types.RequestUsage | None)
source (str)

field id: str [Optional]#: Eindeutiger Bezeichner für dieses Ereignis.

field source: str [Required]#: Der Name des Agenten, der diese Nachricht gesendet hat.

field models_usage: RequestUsage | None = None#: Die Modellnutzung, die bei der Erstellung dieser Nachricht angefallen ist.

field metadata: Dict[str, str] = {}#: Zusätzliche Metadaten zur Nachricht.

field created_at: datetime [Optional]#: Der Zeitpunkt, zu dem die Nachricht erstellt wurde.

pydantic model BaseTextChatMessage[Quelle]#

Bases: BaseChatMessage, ABC

Basisklasse für alle reine Text-BaseChatMessage-Typen. Sie enthält Implementierungen für die Methoden to_text(), to_model_text() und to_model_message().

Erben Sie von dieser Klasse, wenn Ihr Nachrichteninhalts-Typ eine Zeichenkette ist.

JSON-Schema anzeigen

{
   "title": "BaseTextChatMessage",
   "description": "Base class for all text-only :class:`BaseChatMessage` types.\nIt has implementations for :meth:`to_text`, :meth:`to_model_text`,\nand :meth:`to_model_message` methods.\n\nInherit from this class if your message content type is a string.",
   "type": "object",
   "properties": {
      "id": {
         "title": "Id",
         "type": "string"
      },
      "source": {
         "title": "Source",
         "type": "string"
      },
      "models_usage": {
         "anyOf": [
            {
               "$ref": "#/$defs/RequestUsage"
            },
            {
               "type": "null"
            }
         ],
         "default": null
      },
      "metadata": {
         "additionalProperties": {
            "type": "string"
         },
         "default": {},
         "title": "Metadata",
         "type": "object"
      },
      "created_at": {
         "format": "date-time",
         "title": "Created At",
         "type": "string"
      },
      "content": {
         "title": "Content",
         "type": "string"
      }
   },
   "$defs": {
      "RequestUsage": {
         "properties": {
            "prompt_tokens": {
               "title": "Prompt Tokens",
               "type": "integer"
            },
            "completion_tokens": {
               "title": "Completion Tokens",
               "type": "integer"
            }
         },
         "required": [
            "prompt_tokens",
            "completion_tokens"
         ],
         "title": "RequestUsage",
         "type": "object"
      }
   },
   "required": [
      "source",
      "content"
   ]
}

Felder:

content (str)

field content: str [Required]#: Der Inhalt der Nachricht.

to_text() → str[Quelle]#: Konvertiert den Nachrichteninhalt in eine reine Textdarstellung, die in der Konsole angezeigt und vom Benutzer oder von Bedingungen inspiziert werden kann. Dies wird nicht zum Erstellen von rein textuellen Inhalten für Modelle verwendet. Verwenden Sie für BaseChatMessage-Typen stattdessen to_model_text().

to_model_text() → str[Quelle]#

Konvertiert den Inhalt der Nachricht in eine reine Textdarstellung. Dies wird zum Erstellen von rein textuellen Inhalten für Modelle verwendet.

Dies wird nicht zur Anzeige der Nachricht in der Konsole verwendet. Verwenden Sie hierfür to_text().

Der Unterschied zwischen dieser und to_model_message() besteht darin, dass diese zur Konstruktion von Teilen einer Nachricht für den Modellclient verwendet wird, während to_model_message() zur Erstellung einer vollständigen Nachricht für den Modellclient verwendet wird.

to_model_message() → UserMessage[Quelle]#: Konvertiert den Nachrichteninhalt in eine UserMessage zur Verwendung mit einem Modellclient, z.B. ChatCompletionClient.

class StructuredContentType#

Typparameter für strukturierte Inhaltstypen.

alias von TypeVar(‘StructuredContentType’, bound=BaseModel, covariant=True)

pydantic model StructuredMessage[Quelle]#

Bases: BaseChatMessage, Generic[StructuredContentType]

Ein BaseChatMessage-Typ mit einem nicht spezifizierten Inhaltstyp.

Um einen neuen strukturierten Nachrichtentyp zu erstellen, spezifizieren Sie den Inhaltstyp als Unterklasse von Pydantic BaseModel.

from pydantic import BaseModel
from autogen_agentchat.messages import StructuredMessage


class MyMessageContent(BaseModel):
    text: str
    number: int


message = StructuredMessage[MyMessageContent](
    content=MyMessageContent(text="Hello", number=42),
    source="agent1",
)

print(message.to_text())  # {"text": "Hello", "number": 42}

from pydantic import BaseModel
from autogen_agentchat.messages import StructuredMessage


class MyMessageContent(BaseModel):
    text: str
    number: int


message = StructuredMessage[MyMessageContent](
    content=MyMessageContent(text="Hello", number=42),
    source="agent",
    format_string="Hello, {text} {number}!",
)

print(message.to_text())  # Hello, agent 42!

JSON-Schema anzeigen

{
   "title": "StructuredMessage",
   "description": "A :class:`BaseChatMessage` type with an unspecified content type.\n\nTo create a new structured message type, specify the content type\nas a subclass of `Pydantic BaseModel <https://docs.pydantic.dev/latest/concepts/models/>`_.\n\n.. code-block:: python\n\n    from pydantic import BaseModel\n    from autogen_agentchat.messages import StructuredMessage\n\n\n    class MyMessageContent(BaseModel):\n        text: str\n        number: int\n\n\n    message = StructuredMessage[MyMessageContent](\n        content=MyMessageContent(text=\"Hello\", number=42),\n        source=\"agent1\",\n    )\n\n    print(message.to_text())  # {\"text\": \"Hello\", \"number\": 42}\n\n.. code-block:: python\n\n    from pydantic import BaseModel\n    from autogen_agentchat.messages import StructuredMessage\n\n\n    class MyMessageContent(BaseModel):\n        text: str\n        number: int\n\n\n    message = StructuredMessage[MyMessageContent](\n        content=MyMessageContent(text=\"Hello\", number=42),\n        source=\"agent\",\n        format_string=\"Hello, {text} {number}!\",\n    )\n\n    print(message.to_text())  # Hello, agent 42!",
   "type": "object",
   "properties": {
      "id": {
         "title": "Id",
         "type": "string"
      },
      "source": {
         "title": "Source",
         "type": "string"
      },
      "models_usage": {
         "anyOf": [
            {
               "$ref": "#/$defs/RequestUsage"
            },
            {
               "type": "null"
            }
         ],
         "default": null
      },
      "metadata": {
         "additionalProperties": {
            "type": "string"
         },
         "default": {},
         "title": "Metadata",
         "type": "object"
      },
      "created_at": {
         "format": "date-time",
         "title": "Created At",
         "type": "string"
      },
      "content": {
         "$ref": "#/$defs/BaseModel"
      },
      "format_string": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Format String"
      }
   },
   "$defs": {
      "BaseModel": {
         "properties": {},
         "title": "BaseModel",
         "type": "object"
      },
      "RequestUsage": {
         "properties": {
            "prompt_tokens": {
               "title": "Prompt Tokens",
               "type": "integer"
            },
            "completion_tokens": {
               "title": "Completion Tokens",
               "type": "integer"
            }
         },
         "required": [
            "prompt_tokens",
            "completion_tokens"
         ],
         "title": "RequestUsage",
         "type": "object"
      }
   },
   "required": [
      "source",
      "content"
   ]
}

Felder:

content (autogen_agentchat.messages.StructuredContentType)
format_string (str | None)

field content: StructuredContentType [Required]#: Der Inhalt der Nachricht. Muss eine Unterklasse von Pydantic BaseModel sein.

field format_string: str | None = None#: (Experimentell) Eine optionale Formatierungszeichenkette zur Darstellung des Inhalts in einem für Menschen lesbaren Format. Die Formatierungszeichenkette kann die Felder des Inhaltsmodells als Platzhalter verwenden. Wenn das Inhaltsmodell beispielsweise ein Feld name hat, können Sie {name} in der Formatierungszeichenkette verwenden, um den Wert dieses Feldes einzufügen. Die Formatierungszeichenkette wird in der Methode to_text() verwendet, um eine menschenlesbare Darstellung der Nachricht zu erstellen. Diese Einstellung ist experimentell und wird sich in Zukunft ändern.

property type: str#

to_text() → str[Quelle]#: Konvertiert den Nachrichteninhalt in eine reine Textdarstellung, die in der Konsole angezeigt und vom Benutzer oder von Bedingungen inspiziert werden kann. Dies wird nicht zum Erstellen von rein textuellen Inhalten für Modelle verwendet. Verwenden Sie für BaseChatMessage-Typen stattdessen to_model_text().

to_model_text() → str[Quelle]#

Konvertiert den Inhalt der Nachricht in eine reine Textdarstellung. Dies wird zum Erstellen von rein textuellen Inhalten für Modelle verwendet.

Dies wird nicht zur Anzeige der Nachricht in der Konsole verwendet. Verwenden Sie hierfür to_text().

Der Unterschied zwischen dieser und to_model_message() besteht darin, dass diese zur Konstruktion von Teilen einer Nachricht für den Modellclient verwendet wird, während to_model_message() zur Erstellung einer vollständigen Nachricht für den Modellclient verwendet wird.

to_model_message() → UserMessage[Quelle]#: Konvertiert den Nachrichteninhalt in eine UserMessage zur Verwendung mit einem Modellclient, z.B. ChatCompletionClient.

pydantic model HandoffMessage[Quelle]#

Bases: BaseTextChatMessage

Eine Nachricht, die eine Übergabe einer Konversation an einen anderen Agenten anfordert.

JSON-Schema anzeigen

{
   "title": "HandoffMessage",
   "description": "A message requesting handoff of a conversation to another agent.",
   "type": "object",
   "properties": {
      "id": {
         "title": "Id",
         "type": "string"
      },
      "source": {
         "title": "Source",
         "type": "string"
      },
      "models_usage": {
         "anyOf": [
            {
               "$ref": "#/$defs/RequestUsage"
            },
            {
               "type": "null"
            }
         ],
         "default": null
      },
      "metadata": {
         "additionalProperties": {
            "type": "string"
         },
         "default": {},
         "title": "Metadata",
         "type": "object"
      },
      "created_at": {
         "format": "date-time",
         "title": "Created At",
         "type": "string"
      },
      "content": {
         "title": "Content",
         "type": "string"
      },
      "target": {
         "title": "Target",
         "type": "string"
      },
      "context": {
         "default": [],
         "items": {
            "discriminator": {
               "mapping": {
                  "AssistantMessage": "#/$defs/AssistantMessage",
                  "FunctionExecutionResultMessage": "#/$defs/FunctionExecutionResultMessage",
                  "SystemMessage": "#/$defs/SystemMessage",
                  "UserMessage": "#/$defs/UserMessage"
               },
               "propertyName": "type"
            },
            "oneOf": [
               {
                  "$ref": "#/$defs/SystemMessage"
               },
               {
                  "$ref": "#/$defs/UserMessage"
               },
               {
                  "$ref": "#/$defs/AssistantMessage"
               },
               {
                  "$ref": "#/$defs/FunctionExecutionResultMessage"
               }
            ]
         },
         "title": "Context",
         "type": "array"
      },
      "type": {
         "const": "HandoffMessage",
         "default": "HandoffMessage",
         "title": "Type",
         "type": "string"
      }
   },
   "$defs": {
      "AssistantMessage": {
         "description": "Assistant message are sampled from the language model.",
         "properties": {
            "content": {
               "anyOf": [
                  {
                     "type": "string"
                  },
                  {
                     "items": {
                        "$ref": "#/$defs/FunctionCall"
                     },
                     "type": "array"
                  }
               ],
               "title": "Content"
            },
            "thought": {
               "anyOf": [
                  {
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Thought"
            },
            "source": {
               "title": "Source",
               "type": "string"
            },
            "type": {
               "const": "AssistantMessage",
               "default": "AssistantMessage",
               "title": "Type",
               "type": "string"
            }
         },
         "required": [
            "content",
            "source"
         ],
         "title": "AssistantMessage",
         "type": "object"
      },
      "FunctionCall": {
         "properties": {
            "id": {
               "title": "Id",
               "type": "string"
            },
            "arguments": {
               "title": "Arguments",
               "type": "string"
            },
            "name": {
               "title": "Name",
               "type": "string"
            }
         },
         "required": [
            "id",
            "arguments",
            "name"
         ],
         "title": "FunctionCall",
         "type": "object"
      },
      "FunctionExecutionResult": {
         "description": "Function execution result contains the output of a function call.",
         "properties": {
            "content": {
               "title": "Content",
               "type": "string"
            },
            "name": {
               "title": "Name",
               "type": "string"
            },
            "call_id": {
               "title": "Call Id",
               "type": "string"
            },
            "is_error": {
               "anyOf": [
                  {
                     "type": "boolean"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Is Error"
            }
         },
         "required": [
            "content",
            "name",
            "call_id"
         ],
         "title": "FunctionExecutionResult",
         "type": "object"
      },
      "FunctionExecutionResultMessage": {
         "description": "Function execution result message contains the output of multiple function calls.",
         "properties": {
            "content": {
               "items": {
                  "$ref": "#/$defs/FunctionExecutionResult"
               },
               "title": "Content",
               "type": "array"
            },
            "type": {
               "const": "FunctionExecutionResultMessage",
               "default": "FunctionExecutionResultMessage",
               "title": "Type",
               "type": "string"
            }
         },
         "required": [
            "content"
         ],
         "title": "FunctionExecutionResultMessage",
         "type": "object"
      },
      "RequestUsage": {
         "properties": {
            "prompt_tokens": {
               "title": "Prompt Tokens",
               "type": "integer"
            },
            "completion_tokens": {
               "title": "Completion Tokens",
               "type": "integer"
            }
         },
         "required": [
            "prompt_tokens",
            "completion_tokens"
         ],
         "title": "RequestUsage",
         "type": "object"
      },
      "SystemMessage": {
         "description": "System message contains instructions for the model coming from the developer.\n\n.. note::\n\n    Open AI is moving away from using 'system' role in favor of 'developer' role.\n    See `Model Spec <https://cdn.openai.com/spec/model-spec-2024-05-08.html#definitions>`_ for more details.\n    However, the 'system' role is still allowed in their API and will be automatically converted to 'developer' role\n    on the server side.\n    So, you can use `SystemMessage` for developer messages.",
         "properties": {
            "content": {
               "title": "Content",
               "type": "string"
            },
            "type": {
               "const": "SystemMessage",
               "default": "SystemMessage",
               "title": "Type",
               "type": "string"
            }
         },
         "required": [
            "content"
         ],
         "title": "SystemMessage",
         "type": "object"
      },
      "UserMessage": {
         "description": "User message contains input from end users, or a catch-all for data provided to the model.",
         "properties": {
            "content": {
               "anyOf": [
                  {
                     "type": "string"
                  },
                  {
                     "items": {
                        "anyOf": [
                           {
                              "type": "string"
                           },
                           {}
                        ]
                     },
                     "type": "array"
                  }
               ],
               "title": "Content"
            },
            "source": {
               "title": "Source",
               "type": "string"
            },
            "type": {
               "const": "UserMessage",
               "default": "UserMessage",
               "title": "Type",
               "type": "string"
            }
         },
         "required": [
            "content",
            "source"
         ],
         "title": "UserMessage",
         "type": "object"
      }
   },
   "required": [
      "source",
      "content",
      "target"
   ]
}

Felder:

context (List[Annotated[autogen_core.models._types.SystemMessage | autogen_core.models._types.UserMessage | autogen_core.models._types.AssistantMessage | autogen_core.models._types.FunctionExecutionResultMessage, FieldInfo(annotation=NoneType, required=True, discriminator='type')]])
target (str)
type (Literal['HandoffMessage'])

field target: str [Required]#: Der Name des Zielagenten, an den die Übergabe erfolgen soll.

field context: List[Annotated[SystemMessage | UserMessage | AssistantMessage | FunctionExecutionResultMessage, FieldInfo(annotation=NoneType, required=True, discriminator='type')]] = []#: Der Modellkontext, der an den Zielagenten übergeben werden soll.

field type: Literal['HandoffMessage'] = 'HandoffMessage'#

pydantic model MultiModalMessage[source]#

Bases: BaseChatMessage

Eine multimodale Nachricht.

JSON-Schema anzeigen

{
   "title": "MultiModalMessage",
   "description": "A multimodal message.",
   "type": "object",
   "properties": {
      "id": {
         "title": "Id",
         "type": "string"
      },
      "source": {
         "title": "Source",
         "type": "string"
      },
      "models_usage": {
         "anyOf": [
            {
               "$ref": "#/$defs/RequestUsage"
            },
            {
               "type": "null"
            }
         ],
         "default": null
      },
      "metadata": {
         "additionalProperties": {
            "type": "string"
         },
         "default": {},
         "title": "Metadata",
         "type": "object"
      },
      "created_at": {
         "format": "date-time",
         "title": "Created At",
         "type": "string"
      },
      "content": {
         "items": {
            "anyOf": [
               {
                  "type": "string"
               },
               {}
            ]
         },
         "title": "Content",
         "type": "array"
      },
      "type": {
         "const": "MultiModalMessage",
         "default": "MultiModalMessage",
         "title": "Type",
         "type": "string"
      }
   },
   "$defs": {
      "RequestUsage": {
         "properties": {
            "prompt_tokens": {
               "title": "Prompt Tokens",
               "type": "integer"
            },
            "completion_tokens": {
               "title": "Completion Tokens",
               "type": "integer"
            }
         },
         "required": [
            "prompt_tokens",
            "completion_tokens"
         ],
         "title": "RequestUsage",
         "type": "object"
      }
   },
   "required": [
      "source",
      "content"
   ]
}

Felder:

content (List[str | autogen_core._image.Image])
type (Literal['MultiModalMessage'])

field content: List[str | Image] [Required]#: Der Inhalt der Nachricht.

field type: Literal['MultiModalMessage'] = 'MultiModalMessage'#

to_model_text(image_placeholder: str | None = '[image]') → str[source]#: Konvertiert den Nachrichteninhalt in eine reine Textdarstellung. Wenn ein Bild vorhanden ist, wird es standardmäßig durch den Bildplatzhalter ersetzt, andernfalls wird es als Base64-String dargestellt, wenn es auf None gesetzt ist.

to_text(iterm: bool = False) → str[source]#: Konvertiert den Nachrichteninhalt in eine reine Textdarstellung, die in der Konsole gerendert und vom Benutzer oder von Bedingungen inspiziert werden kann. Dies wird nicht zur Erstellung von rein textbasierten Inhalten für Modelle verwendet. Für BaseChatMessage-Typen verwenden Sie stattdessen to_model_text().

to_model_message() → UserMessage[source]#: Konvertiert den Nachrichteninhalt in eine UserMessage zur Verwendung mit einem Modellclient, z.B. ChatCompletionClient.

pydantic model StopMessage[source]#

Bases: BaseTextChatMessage

Eine Nachricht, die die Beendigung einer Konversation anfordert.

JSON-Schema anzeigen

{
   "title": "StopMessage",
   "description": "A message requesting stop of a conversation.",
   "type": "object",
   "properties": {
      "id": {
         "title": "Id",
         "type": "string"
      },
      "source": {
         "title": "Source",
         "type": "string"
      },
      "models_usage": {
         "anyOf": [
            {
               "$ref": "#/$defs/RequestUsage"
            },
            {
               "type": "null"
            }
         ],
         "default": null
      },
      "metadata": {
         "additionalProperties": {
            "type": "string"
         },
         "default": {},
         "title": "Metadata",
         "type": "object"
      },
      "created_at": {
         "format": "date-time",
         "title": "Created At",
         "type": "string"
      },
      "content": {
         "title": "Content",
         "type": "string"
      },
      "type": {
         "const": "StopMessage",
         "default": "StopMessage",
         "title": "Type",
         "type": "string"
      }
   },
   "$defs": {
      "RequestUsage": {
         "properties": {
            "prompt_tokens": {
               "title": "Prompt Tokens",
               "type": "integer"
            },
            "completion_tokens": {
               "title": "Completion Tokens",
               "type": "integer"
            }
         },
         "required": [
            "prompt_tokens",
            "completion_tokens"
         ],
         "title": "RequestUsage",
         "type": "object"
      }
   },
   "required": [
      "source",
      "content"
   ]
}

Felder:

type (Literal['StopMessage'])

field type: Literal['StopMessage'] = 'StopMessage'#

pydantic model TextMessage[source]#

Bases: BaseTextChatMessage

Eine Textnachricht mit rein textbasiertem Inhalt.

JSON-Schema anzeigen

{
   "title": "TextMessage",
   "description": "A text message with string-only content.",
   "type": "object",
   "properties": {
      "id": {
         "title": "Id",
         "type": "string"
      },
      "source": {
         "title": "Source",
         "type": "string"
      },
      "models_usage": {
         "anyOf": [
            {
               "$ref": "#/$defs/RequestUsage"
            },
            {
               "type": "null"
            }
         ],
         "default": null
      },
      "metadata": {
         "additionalProperties": {
            "type": "string"
         },
         "default": {},
         "title": "Metadata",
         "type": "object"
      },
      "created_at": {
         "format": "date-time",
         "title": "Created At",
         "type": "string"
      },
      "content": {
         "title": "Content",
         "type": "string"
      },
      "type": {
         "const": "TextMessage",
         "default": "TextMessage",
         "title": "Type",
         "type": "string"
      }
   },
   "$defs": {
      "RequestUsage": {
         "properties": {
            "prompt_tokens": {
               "title": "Prompt Tokens",
               "type": "integer"
            },
            "completion_tokens": {
               "title": "Completion Tokens",
               "type": "integer"
            }
         },
         "required": [
            "prompt_tokens",
            "completion_tokens"
         ],
         "title": "RequestUsage",
         "type": "object"
      }
   },
   "required": [
      "source",
      "content"
   ]
}

Felder:

type (Literal['TextMessage'])

field type: Literal['TextMessage'] = 'TextMessage'#

pydantic model ToolCallExecutionEvent[source]#

Bases: BaseAgentEvent

Ein Ereignis, das die Ausführung von Tool-Aufrufen signalisiert.

JSON-Schema anzeigen

{
   "title": "ToolCallExecutionEvent",
   "description": "An event signaling the execution of tool calls.",
   "type": "object",
   "properties": {
      "id": {
         "title": "Id",
         "type": "string"
      },
      "source": {
         "title": "Source",
         "type": "string"
      },
      "models_usage": {
         "anyOf": [
            {
               "$ref": "#/$defs/RequestUsage"
            },
            {
               "type": "null"
            }
         ],
         "default": null
      },
      "metadata": {
         "additionalProperties": {
            "type": "string"
         },
         "default": {},
         "title": "Metadata",
         "type": "object"
      },
      "created_at": {
         "format": "date-time",
         "title": "Created At",
         "type": "string"
      },
      "content": {
         "items": {
            "$ref": "#/$defs/FunctionExecutionResult"
         },
         "title": "Content",
         "type": "array"
      },
      "type": {
         "const": "ToolCallExecutionEvent",
         "default": "ToolCallExecutionEvent",
         "title": "Type",
         "type": "string"
      }
   },
   "$defs": {
      "FunctionExecutionResult": {
         "description": "Function execution result contains the output of a function call.",
         "properties": {
            "content": {
               "title": "Content",
               "type": "string"
            },
            "name": {
               "title": "Name",
               "type": "string"
            },
            "call_id": {
               "title": "Call Id",
               "type": "string"
            },
            "is_error": {
               "anyOf": [
                  {
                     "type": "boolean"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Is Error"
            }
         },
         "required": [
            "content",
            "name",
            "call_id"
         ],
         "title": "FunctionExecutionResult",
         "type": "object"
      },
      "RequestUsage": {
         "properties": {
            "prompt_tokens": {
               "title": "Prompt Tokens",
               "type": "integer"
            },
            "completion_tokens": {
               "title": "Completion Tokens",
               "type": "integer"
            }
         },
         "required": [
            "prompt_tokens",
            "completion_tokens"
         ],
         "title": "RequestUsage",
         "type": "object"
      }
   },
   "required": [
      "source",
      "content"
   ]
}

Felder:

content (List[autogen_core.models._types.FunctionExecutionResult])
type (Literal['ToolCallExecutionEvent'])

field content: List[FunctionExecutionResult] [Required]#: Die Ergebnisse der Tool-Aufrufe.

field type: Literal['ToolCallExecutionEvent'] = 'ToolCallExecutionEvent'#

to_text() → str[source]#: Konvertiert den Nachrichteninhalt in eine reine Textdarstellung, die in der Konsole angezeigt und vom Benutzer oder von Bedingungen inspiziert werden kann. Dies wird nicht zum Erstellen von rein textuellen Inhalten für Modelle verwendet. Verwenden Sie für BaseChatMessage-Typen stattdessen to_model_text().

pydantic model ToolCallRequestEvent[source]#

Bases: BaseAgentEvent

Ein Ereignis, das eine Anforderung zur Verwendung von Tools signalisiert.

JSON-Schema anzeigen

{
   "title": "ToolCallRequestEvent",
   "description": "An event signaling a request to use tools.",
   "type": "object",
   "properties": {
      "id": {
         "title": "Id",
         "type": "string"
      },
      "source": {
         "title": "Source",
         "type": "string"
      },
      "models_usage": {
         "anyOf": [
            {
               "$ref": "#/$defs/RequestUsage"
            },
            {
               "type": "null"
            }
         ],
         "default": null
      },
      "metadata": {
         "additionalProperties": {
            "type": "string"
         },
         "default": {},
         "title": "Metadata",
         "type": "object"
      },
      "created_at": {
         "format": "date-time",
         "title": "Created At",
         "type": "string"
      },
      "content": {
         "items": {
            "$ref": "#/$defs/FunctionCall"
         },
         "title": "Content",
         "type": "array"
      },
      "type": {
         "const": "ToolCallRequestEvent",
         "default": "ToolCallRequestEvent",
         "title": "Type",
         "type": "string"
      }
   },
   "$defs": {
      "FunctionCall": {
         "properties": {
            "id": {
               "title": "Id",
               "type": "string"
            },
            "arguments": {
               "title": "Arguments",
               "type": "string"
            },
            "name": {
               "title": "Name",
               "type": "string"
            }
         },
         "required": [
            "id",
            "arguments",
            "name"
         ],
         "title": "FunctionCall",
         "type": "object"
      },
      "RequestUsage": {
         "properties": {
            "prompt_tokens": {
               "title": "Prompt Tokens",
               "type": "integer"
            },
            "completion_tokens": {
               "title": "Completion Tokens",
               "type": "integer"
            }
         },
         "required": [
            "prompt_tokens",
            "completion_tokens"
         ],
         "title": "RequestUsage",
         "type": "object"
      }
   },
   "required": [
      "source",
      "content"
   ]
}

Felder:

content (List[autogen_core._types.FunctionCall])
type (Literal['ToolCallRequestEvent'])

field content: List[FunctionCall] [Required]#: Die Tool-Aufrufe.

field type: Literal['ToolCallRequestEvent'] = 'ToolCallRequestEvent'#

to_text() → str[source]#: Konvertiert den Nachrichteninhalt in eine reine Textdarstellung, die in der Konsole angezeigt und vom Benutzer oder von Bedingungen inspiziert werden kann. Dies wird nicht zum Erstellen von rein textuellen Inhalten für Modelle verwendet. Verwenden Sie für BaseChatMessage-Typen stattdessen to_model_text().

pydantic model ToolCallSummaryMessage[source]#

Bases: BaseTextChatMessage

Eine Nachricht, die die Zusammenfassung der Ergebnisse von Tool-Aufrufen signalisiert.

JSON-Schema anzeigen

{
   "title": "ToolCallSummaryMessage",
   "description": "A message signaling the summary of tool call results.",
   "type": "object",
   "properties": {
      "id": {
         "title": "Id",
         "type": "string"
      },
      "source": {
         "title": "Source",
         "type": "string"
      },
      "models_usage": {
         "anyOf": [
            {
               "$ref": "#/$defs/RequestUsage"
            },
            {
               "type": "null"
            }
         ],
         "default": null
      },
      "metadata": {
         "additionalProperties": {
            "type": "string"
         },
         "default": {},
         "title": "Metadata",
         "type": "object"
      },
      "created_at": {
         "format": "date-time",
         "title": "Created At",
         "type": "string"
      },
      "content": {
         "title": "Content",
         "type": "string"
      },
      "type": {
         "const": "ToolCallSummaryMessage",
         "default": "ToolCallSummaryMessage",
         "title": "Type",
         "type": "string"
      },
      "tool_calls": {
         "items": {
            "$ref": "#/$defs/FunctionCall"
         },
         "title": "Tool Calls",
         "type": "array"
      },
      "results": {
         "items": {
            "$ref": "#/$defs/FunctionExecutionResult"
         },
         "title": "Results",
         "type": "array"
      }
   },
   "$defs": {
      "FunctionCall": {
         "properties": {
            "id": {
               "title": "Id",
               "type": "string"
            },
            "arguments": {
               "title": "Arguments",
               "type": "string"
            },
            "name": {
               "title": "Name",
               "type": "string"
            }
         },
         "required": [
            "id",
            "arguments",
            "name"
         ],
         "title": "FunctionCall",
         "type": "object"
      },
      "FunctionExecutionResult": {
         "description": "Function execution result contains the output of a function call.",
         "properties": {
            "content": {
               "title": "Content",
               "type": "string"
            },
            "name": {
               "title": "Name",
               "type": "string"
            },
            "call_id": {
               "title": "Call Id",
               "type": "string"
            },
            "is_error": {
               "anyOf": [
                  {
                     "type": "boolean"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Is Error"
            }
         },
         "required": [
            "content",
            "name",
            "call_id"
         ],
         "title": "FunctionExecutionResult",
         "type": "object"
      },
      "RequestUsage": {
         "properties": {
            "prompt_tokens": {
               "title": "Prompt Tokens",
               "type": "integer"
            },
            "completion_tokens": {
               "title": "Completion Tokens",
               "type": "integer"
            }
         },
         "required": [
            "prompt_tokens",
            "completion_tokens"
         ],
         "title": "RequestUsage",
         "type": "object"
      }
   },
   "required": [
      "source",
      "content",
      "tool_calls",
      "results"
   ]
}

Felder:

results (List[autogen_core.models._types.FunctionExecutionResult])
tool_calls (List[autogen_core._types.FunctionCall])
type (Literal['ToolCallSummaryMessage'])

field type: Literal['ToolCallSummaryMessage'] = 'ToolCallSummaryMessage'#

field tool_calls: List[FunctionCall] [Required]#: Die durchgeführten Tool-Aufrufe.

field results: List[FunctionExecutionResult] [Required]#: Die Ergebnisse der Tool-Aufrufe.

pydantic model MemoryQueryEvent[source]#

Bases: BaseAgentEvent

Ein Ereignis, das die Ergebnisse von Speicherabfragen signalisiert.

JSON-Schema anzeigen

{
   "title": "MemoryQueryEvent",
   "description": "An event signaling the results of memory queries.",
   "type": "object",
   "properties": {
      "id": {
         "title": "Id",
         "type": "string"
      },
      "source": {
         "title": "Source",
         "type": "string"
      },
      "models_usage": {
         "anyOf": [
            {
               "$ref": "#/$defs/RequestUsage"
            },
            {
               "type": "null"
            }
         ],
         "default": null
      },
      "metadata": {
         "additionalProperties": {
            "type": "string"
         },
         "default": {},
         "title": "Metadata",
         "type": "object"
      },
      "created_at": {
         "format": "date-time",
         "title": "Created At",
         "type": "string"
      },
      "content": {
         "items": {
            "$ref": "#/$defs/MemoryContent"
         },
         "title": "Content",
         "type": "array"
      },
      "type": {
         "const": "MemoryQueryEvent",
         "default": "MemoryQueryEvent",
         "title": "Type",
         "type": "string"
      }
   },
   "$defs": {
      "MemoryContent": {
         "description": "A memory content item.",
         "properties": {
            "content": {
               "anyOf": [
                  {
                     "type": "string"
                  },
                  {
                     "format": "binary",
                     "type": "string"
                  },
                  {
                     "type": "object"
                  },
                  {}
               ],
               "title": "Content"
            },
            "mime_type": {
               "anyOf": [
                  {
                     "$ref": "#/$defs/MemoryMimeType"
                  },
                  {
                     "type": "string"
                  }
               ],
               "title": "Mime Type"
            },
            "metadata": {
               "anyOf": [
                  {
                     "type": "object"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Metadata"
            }
         },
         "required": [
            "content",
            "mime_type"
         ],
         "title": "MemoryContent",
         "type": "object"
      },
      "MemoryMimeType": {
         "description": "Supported MIME types for memory content.",
         "enum": [
            "text/plain",
            "application/json",
            "text/markdown",
            "image/*",
            "application/octet-stream"
         ],
         "title": "MemoryMimeType",
         "type": "string"
      },
      "RequestUsage": {
         "properties": {
            "prompt_tokens": {
               "title": "Prompt Tokens",
               "type": "integer"
            },
            "completion_tokens": {
               "title": "Completion Tokens",
               "type": "integer"
            }
         },
         "required": [
            "prompt_tokens",
            "completion_tokens"
         ],
         "title": "RequestUsage",
         "type": "object"
      }
   },
   "required": [
      "source",
      "content"
   ]
}

Felder:

content (List[autogen_core.memory._base_memory.MemoryContent])
type (Literal['MemoryQueryEvent'])

field content: List[MemoryContent] [Required]#: Die Ergebnisse der Speicherabfrage.

field type: Literal['MemoryQueryEvent'] = 'MemoryQueryEvent'#

to_text() → str[source]#: Konvertiert den Nachrichteninhalt in eine reine Textdarstellung, die in der Konsole angezeigt und vom Benutzer oder von Bedingungen inspiziert werden kann. Dies wird nicht zum Erstellen von rein textuellen Inhalten für Modelle verwendet. Verwenden Sie für BaseChatMessage-Typen stattdessen to_model_text().

pydantic model UserInputRequestedEvent[source]#

Bases: BaseAgentEvent

Ein Ereignis, das signalisiert, dass der Benutzer-Proxy die Eingabe des Benutzers angefordert hat. Wird vor dem Aufruf des Eingabe-Callbacks veröffentlicht.

JSON-Schema anzeigen

{
   "title": "UserInputRequestedEvent",
   "description": "An event signaling a that the user proxy has requested user input. Published prior to invoking the input callback.",
   "type": "object",
   "properties": {
      "id": {
         "title": "Id",
         "type": "string"
      },
      "source": {
         "title": "Source",
         "type": "string"
      },
      "models_usage": {
         "anyOf": [
            {
               "$ref": "#/$defs/RequestUsage"
            },
            {
               "type": "null"
            }
         ],
         "default": null
      },
      "metadata": {
         "additionalProperties": {
            "type": "string"
         },
         "default": {},
         "title": "Metadata",
         "type": "object"
      },
      "created_at": {
         "format": "date-time",
         "title": "Created At",
         "type": "string"
      },
      "request_id": {
         "title": "Request Id",
         "type": "string"
      },
      "content": {
         "const": "",
         "default": "",
         "title": "Content",
         "type": "string"
      },
      "type": {
         "const": "UserInputRequestedEvent",
         "default": "UserInputRequestedEvent",
         "title": "Type",
         "type": "string"
      }
   },
   "$defs": {
      "RequestUsage": {
         "properties": {
            "prompt_tokens": {
               "title": "Prompt Tokens",
               "type": "integer"
            },
            "completion_tokens": {
               "title": "Completion Tokens",
               "type": "integer"
            }
         },
         "required": [
            "prompt_tokens",
            "completion_tokens"
         ],
         "title": "RequestUsage",
         "type": "object"
      }
   },
   "required": [
      "source",
      "request_id"
   ]
}

Felder:

content (Literal[''])
request_id (str)
type (Literal['UserInputRequestedEvent'])

field request_id: str [Required]#: Identifikator für die Anforderung der Benutzereingabe.

field content: Literal[''] = ''#: Leerer Inhalt zur Kompatibilität mit Konsumenten, die ein Content-Feld erwarten.

field type: Literal['UserInputRequestedEvent'] = 'UserInputRequestedEvent'#

to_text() → str[source]#: Konvertiert den Nachrichteninhalt in eine reine Textdarstellung, die in der Konsole angezeigt und vom Benutzer oder von Bedingungen inspiziert werden kann. Dies wird nicht zum Erstellen von rein textuellen Inhalten für Modelle verwendet. Verwenden Sie für BaseChatMessage-Typen stattdessen to_model_text().

pydantic model ModelClientStreamingChunkEvent[source]#

Bases: BaseAgentEvent

Ein Ereignis, das einen Textausgabe-Chunk von einem Modellclient im Streaming-Modus signalisiert.

JSON-Schema anzeigen

{
   "title": "ModelClientStreamingChunkEvent",
   "description": "An event signaling a text output chunk from a model client in streaming mode.",
   "type": "object",
   "properties": {
      "id": {
         "title": "Id",
         "type": "string"
      },
      "source": {
         "title": "Source",
         "type": "string"
      },
      "models_usage": {
         "anyOf": [
            {
               "$ref": "#/$defs/RequestUsage"
            },
            {
               "type": "null"
            }
         ],
         "default": null
      },
      "metadata": {
         "additionalProperties": {
            "type": "string"
         },
         "default": {},
         "title": "Metadata",
         "type": "object"
      },
      "created_at": {
         "format": "date-time",
         "title": "Created At",
         "type": "string"
      },
      "content": {
         "title": "Content",
         "type": "string"
      },
      "full_message_id": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Full Message Id"
      },
      "type": {
         "const": "ModelClientStreamingChunkEvent",
         "default": "ModelClientStreamingChunkEvent",
         "title": "Type",
         "type": "string"
      }
   },
   "$defs": {
      "RequestUsage": {
         "properties": {
            "prompt_tokens": {
               "title": "Prompt Tokens",
               "type": "integer"
            },
            "completion_tokens": {
               "title": "Completion Tokens",
               "type": "integer"
            }
         },
         "required": [
            "prompt_tokens",
            "completion_tokens"
         ],
         "title": "RequestUsage",
         "type": "object"
      }
   },
   "required": [
      "source",
      "content"
   ]
}

Felder:

content (str)
full_message_id (str | None)
type (Literal['ModelClientStreamingChunkEvent'])

field content: str [Required]#: Ein String-Chunk vom Modellclient.

field full_message_id: str | None = None#: Optionaler Verweis auf die vollständige Nachricht, die nach den Chunks kommen kann. Dies ermöglicht es den Konsumenten des Streams, Chunks mit der endgültigen abgeschlossenen Nachricht zu korrelieren.

field type: Literal['ModelClientStreamingChunkEvent'] = 'ModelClientStreamingChunkEvent'#

to_text() → str[source]#: Konvertiert den Nachrichteninhalt in eine reine Textdarstellung, die in der Konsole angezeigt und vom Benutzer oder von Bedingungen inspiziert werden kann. Dies wird nicht zum Erstellen von rein textuellen Inhalten für Modelle verwendet. Verwenden Sie für BaseChatMessage-Typen stattdessen to_model_text().

pydantic model ThoughtEvent[source]#

Bases: BaseAgentEvent

Ein Ereignis, das den Denkprozess eines Modells signalisiert. Es wird verwendet, um die vom Denkmodell generierten Argumentationstoken oder den vom Funktionsaufruf generierten zusätzlichen Textinhalt zu kommunizieren.

JSON-Schema anzeigen

{
   "title": "ThoughtEvent",
   "description": "An event signaling the thought process of a model.\nIt is used to communicate the reasoning tokens generated by a reasoning model,\nor the extra text content generated by a function call.",
   "type": "object",
   "properties": {
      "id": {
         "title": "Id",
         "type": "string"
      },
      "source": {
         "title": "Source",
         "type": "string"
      },
      "models_usage": {
         "anyOf": [
            {
               "$ref": "#/$defs/RequestUsage"
            },
            {
               "type": "null"
            }
         ],
         "default": null
      },
      "metadata": {
         "additionalProperties": {
            "type": "string"
         },
         "default": {},
         "title": "Metadata",
         "type": "object"
      },
      "created_at": {
         "format": "date-time",
         "title": "Created At",
         "type": "string"
      },
      "content": {
         "title": "Content",
         "type": "string"
      },
      "type": {
         "const": "ThoughtEvent",
         "default": "ThoughtEvent",
         "title": "Type",
         "type": "string"
      }
   },
   "$defs": {
      "RequestUsage": {
         "properties": {
            "prompt_tokens": {
               "title": "Prompt Tokens",
               "type": "integer"
            },
            "completion_tokens": {
               "title": "Completion Tokens",
               "type": "integer"
            }
         },
         "required": [
            "prompt_tokens",
            "completion_tokens"
         ],
         "title": "RequestUsage",
         "type": "object"
      }
   },
   "required": [
      "source",
      "content"
   ]
}

Felder:

content (str)
type (Literal['ThoughtEvent'])

field content: str [Required]#: Der Denkprozess des Modells.

field type: Literal['ThoughtEvent'] = 'ThoughtEvent'#

to_text() → str[source]#: Konvertiert den Nachrichteninhalt in eine reine Textdarstellung, die in der Konsole angezeigt und vom Benutzer oder von Bedingungen inspiziert werden kann. Dies wird nicht zum Erstellen von rein textuellen Inhalten für Modelle verwendet. Verwenden Sie für BaseChatMessage-Typen stattdessen to_model_text().

pydantic model SelectSpeakerEvent[source]#

Bases: BaseAgentEvent

Ein Ereignis, das die Auswahl von Sprechern für eine Konversation signalisiert.

JSON-Schema anzeigen

{
   "title": "SelectSpeakerEvent",
   "description": "An event signaling the selection of speakers for a conversation.",
   "type": "object",
   "properties": {
      "id": {
         "title": "Id",
         "type": "string"
      },
      "source": {
         "title": "Source",
         "type": "string"
      },
      "models_usage": {
         "anyOf": [
            {
               "$ref": "#/$defs/RequestUsage"
            },
            {
               "type": "null"
            }
         ],
         "default": null
      },
      "metadata": {
         "additionalProperties": {
            "type": "string"
         },
         "default": {},
         "title": "Metadata",
         "type": "object"
      },
      "created_at": {
         "format": "date-time",
         "title": "Created At",
         "type": "string"
      },
      "content": {
         "items": {
            "type": "string"
         },
         "title": "Content",
         "type": "array"
      },
      "type": {
         "const": "SelectSpeakerEvent",
         "default": "SelectSpeakerEvent",
         "title": "Type",
         "type": "string"
      }
   },
   "$defs": {
      "RequestUsage": {
         "properties": {
            "prompt_tokens": {
               "title": "Prompt Tokens",
               "type": "integer"
            },
            "completion_tokens": {
               "title": "Completion Tokens",
               "type": "integer"
            }
         },
         "required": [
            "prompt_tokens",
            "completion_tokens"
         ],
         "title": "RequestUsage",
         "type": "object"
      }
   },
   "required": [
      "source",
      "content"
   ]
}

Felder:

content (List[str])
type (Literal['SelectSpeakerEvent'])

field content: List[str] [Required]#: Die Namen der ausgewählten Sprecher.

field type: Literal['SelectSpeakerEvent'] = 'SelectSpeakerEvent'#

to_text() → str[source]#: Konvertiert den Nachrichteninhalt in eine reine Textdarstellung, die in der Konsole angezeigt und vom Benutzer oder von Bedingungen inspiziert werden kann. Dies wird nicht zum Erstellen von rein textuellen Inhalten für Modelle verwendet. Verwenden Sie für BaseChatMessage-Typen stattdessen to_model_text().

pydantic model CodeGenerationEvent[source]#

Bases: BaseAgentEvent

Ein Ereignis, das ein Code-Generierungsereignis signalisiert.

JSON-Schema anzeigen

{
   "title": "CodeGenerationEvent",
   "description": "An event signaling code generation event.",
   "type": "object",
   "properties": {
      "id": {
         "title": "Id",
         "type": "string"
      },
      "source": {
         "title": "Source",
         "type": "string"
      },
      "models_usage": {
         "anyOf": [
            {
               "$ref": "#/$defs/RequestUsage"
            },
            {
               "type": "null"
            }
         ],
         "default": null
      },
      "metadata": {
         "additionalProperties": {
            "type": "string"
         },
         "default": {},
         "title": "Metadata",
         "type": "object"
      },
      "created_at": {
         "format": "date-time",
         "title": "Created At",
         "type": "string"
      },
      "retry_attempt": {
         "title": "Retry Attempt",
         "type": "integer"
      },
      "content": {
         "title": "Content",
         "type": "string"
      },
      "code_blocks": {
         "items": {
            "$ref": "#/$defs/CodeBlock"
         },
         "title": "Code Blocks",
         "type": "array"
      },
      "type": {
         "const": "CodeGenerationEvent",
         "default": "CodeGenerationEvent",
         "title": "Type",
         "type": "string"
      }
   },
   "$defs": {
      "CodeBlock": {
         "properties": {
            "code": {
               "title": "Code",
               "type": "string"
            },
            "language": {
               "title": "Language",
               "type": "string"
            }
         },
         "required": [
            "code",
            "language"
         ],
         "title": "CodeBlock",
         "type": "object"
      },
      "RequestUsage": {
         "properties": {
            "prompt_tokens": {
               "title": "Prompt Tokens",
               "type": "integer"
            },
            "completion_tokens": {
               "title": "Completion Tokens",
               "type": "integer"
            }
         },
         "required": [
            "prompt_tokens",
            "completion_tokens"
         ],
         "title": "RequestUsage",
         "type": "object"
      }
   },
   "required": [
      "source",
      "retry_attempt",
      "content",
      "code_blocks"
   ]
}

Felder:

code_blocks (List[autogen_core.code_executor._base.CodeBlock])
content (str)
retry_attempt (int)
type (Literal['CodeGenerationEvent'])

field retry_attempt: int [Required]#: Wiederholungsversuch-Nummer, 0 bedeutet erste Generierung

field content: str [Required]#: Der vollständige Inhalt als String.

field code_blocks: List[CodeBlock] [Required]#: Liste der im Inhalt enthaltenen Code-Blöcke

field type: Literal['CodeGenerationEvent'] = 'CodeGenerationEvent'#

to_text() → str[source]#: Konvertiert den Nachrichteninhalt in eine reine Textdarstellung, die in der Konsole angezeigt und vom Benutzer oder von Bedingungen inspiziert werden kann. Dies wird nicht zum Erstellen von rein textuellen Inhalten für Modelle verwendet. Verwenden Sie für BaseChatMessage-Typen stattdessen to_model_text().

pydantic model CodeExecutionEvent[source]#

Bases: BaseAgentEvent

Ein Ereignis, das ein Code-Ausführungsereignis signalisiert.

JSON-Schema anzeigen

{
   "title": "CodeExecutionEvent",
   "description": "An event signaling code execution event.",
   "type": "object",
   "properties": {
      "id": {
         "title": "Id",
         "type": "string"
      },
      "source": {
         "title": "Source",
         "type": "string"
      },
      "models_usage": {
         "anyOf": [
            {
               "$ref": "#/$defs/RequestUsage"
            },
            {
               "type": "null"
            }
         ],
         "default": null
      },
      "metadata": {
         "additionalProperties": {
            "type": "string"
         },
         "default": {},
         "title": "Metadata",
         "type": "object"
      },
      "created_at": {
         "format": "date-time",
         "title": "Created At",
         "type": "string"
      },
      "retry_attempt": {
         "title": "Retry Attempt",
         "type": "integer"
      },
      "result": {
         "$ref": "#/$defs/CodeResult"
      },
      "type": {
         "const": "CodeExecutionEvent",
         "default": "CodeExecutionEvent",
         "title": "Type",
         "type": "string"
      }
   },
   "$defs": {
      "CodeResult": {
         "properties": {
            "exit_code": {
               "title": "Exit Code",
               "type": "integer"
            },
            "output": {
               "title": "Output",
               "type": "string"
            }
         },
         "required": [
            "exit_code",
            "output"
         ],
         "title": "CodeResult",
         "type": "object"
      },
      "RequestUsage": {
         "properties": {
            "prompt_tokens": {
               "title": "Prompt Tokens",
               "type": "integer"
            },
            "completion_tokens": {
               "title": "Completion Tokens",
               "type": "integer"
            }
         },
         "required": [
            "prompt_tokens",
            "completion_tokens"
         ],
         "title": "RequestUsage",
         "type": "object"
      }
   },
   "required": [
      "source",
      "retry_attempt",
      "result"
   ]
}

Felder:

result (autogen_core.code_executor._base.CodeResult)
retry_attempt (int)
type (Literal['CodeExecutionEvent'])

Feld retry_attempt: int [Erforderlich]#: Wiederholungsnummer, 0 bedeutet erste Ausführung

Feld result: CodeResult [Erforderlich]#: Ergebnis der Code-Ausführung

Feld type: Literal['CodeExecutionEvent'] = 'CodeExecutionEvent'#

to_text() → str[Quelle]#: Konvertiert den Nachrichteninhalt in eine reine Textdarstellung, die in der Konsole angezeigt und vom Benutzer oder von Bedingungen inspiziert werden kann. Dies wird nicht zum Erstellen von rein textuellen Inhalten für Modelle verwendet. Verwenden Sie für BaseChatMessage-Typen stattdessen to_model_text().