Skip to content

ResponseSchema

autogen.beta.response.schema.ResponseSchema #

ResponseSchema(types: type[T], /, name: str | None = None, description: str | None = None, embed: bool = True)

ResponseSchema(types: ClassInfo, /, name: str | None = None, description: str | None = None, embed: bool = True)

ResponseSchema(types, /, name=None, description=None, embed=True)

Bases: ResponseProto[T]

Source code in autogen/beta/response/schema.py 
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
def __init__(
    self,
    types: ClassInfo,
    /,
    name: str | None = None,
    description: str | None = None,
    embed: bool = True,
) -> None:
    self._adapter, self._embedded_type = make_adapter(types, embed=embed)
    schema = self._adapter.json_schema() if self._adapter else None

    if not name:
        name = schema_title if (schema_title := (schema or {}).pop("title", None)) else "ResponseSchema"
    self.name = name

    if not description:
        if schema_description := (schema or {}).pop("description", None):
            self.description = schema_description
        elif (docstring := getattr(types, "__doc__", None)) and "PEP" not in docstring:
            self.description = docstring
        else:
            self.description = None
    else:
        self.description = description

    self.json_schema = schema
    self.system_prompt = None

name instance-attribute #

name = name

description instance-attribute #

description = schema_description

json_schema instance-attribute #

json_schema = schema

system_prompt instance-attribute #

system_prompt = None

ensure_schema classmethod #

ensure_schema(obj: ResponseProto[T] | type[T] | ClassInfo) -> ResponseSchema[T]

ensure_schema(obj: None) -> None

ensure_schema(obj)
Source code in autogen/beta/response/schema.py 
85
86
87
88
89
90
91
92
93
94
@classmethod
def ensure_schema(
    cls,
    obj: "ResponseProto[T] | type[T] | ClassInfo | None",
) -> "ResponseProto[T] | None":
    if obj is None:
        return None
    if isinstance(obj, ResponseProto):
        return obj
    return ResponseSchema[T](obj)

from_schema classmethod #

from_schema(schema, /, name, description=None)
Source code in autogen/beta/response/schema.py 
 96
 97
 98
 99
100
101
102
103
104
@classmethod
def from_schema(
    cls,
    schema: dict[str, Any],
    /,
    name: str,
    description: str | None = None,
) -> "RawSchema":
    return RawSchema(schema, name=name, description=description)

validate async #

validate(response, context, provider=None)
Source code in autogen/beta/response/schema.py 
106
107
108
109
110
111
112
113
114
115
116
117
async def validate(
    self,
    response: str,
    context: "Context",
    provider: "Provider | None" = None,
) -> T:
    if self._adapter is None:
        return response
    result = self._adapter.validate_json(response)
    if self._embedded_type:
        return result.data
    return result