跳至内容

Items

TResponse module-attribute 

TResponse = Response

OpenAI SDK中Response类型的类型别名。

TResponseInputItem module-attribute 

TResponseInputItem = ResponseInputItemParam

OpenAI SDK中ResponseInputItemParam类型的类型别名。

TResponseOutputItem module-attribute 

TResponseOutputItem = ResponseOutputItem

OpenAI SDK中ResponseOutputItem类型的类型别名。

TResponseStreamEvent module-attribute 

TResponseStreamEvent = ResponseStreamEvent

OpenAI SDK中ResponseStreamEvent类型的类型别名。

ToolCallItemTypes module-attribute 

ToolCallItemTypes: TypeAlias = Union[
    ResponseFunctionToolCall,
    ResponseComputerToolCall,
    ResponseFileSearchToolCall,
    ResponseFunctionWebSearch,
]

表示工具调用项的类型。

运行项 module-attribute 

RunItem: TypeAlias = Union[
    MessageOutputItem,
    HandoffCallItem,
    HandoffOutputItem,
    ToolCallItem,
    ToolCallOutputItem,
    ReasoningItem,
]

由代理生成的条目。

RunItemBase dataclass

基类: Generic[T], ABC

Source code in src/agents/items.py 
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
@dataclass
class RunItemBase(Generic[T], abc.ABC):
    agent: Agent[Any]
    """The agent whose run caused this item to be generated."""

    raw_item: T
    """The raw Responses item from the run. This will always be a either an output item (i.e.
    `openai.types.responses.ResponseOutputItem` or an input item
    (i.e. `openai.types.responses.ResponseInputItemParam`).
    """

    def to_input_item(self) -> TResponseInputItem:
        """Converts this item into an input item suitable for passing to the model."""
        if isinstance(self.raw_item, dict):
            # We know that input items are dicts, so we can ignore the type error
            return self.raw_item  # type: ignore
        elif isinstance(self.raw_item, BaseModel):
            # All output items are Pydantic models that can be converted to input items.
            return self.raw_item.model_dump(exclude_unset=True)  # type: ignore
        else:
            raise AgentsException(f"Unexpected raw item type: {type(self.raw_item)}")

代理 instance-attribute 

agent: Agent[Any]

生成此项目的代理运行。

原始数据项 instance-attribute 

raw_item: T

运行中的原始响应项。这将始终是一个输出项（即openai.types.responses.ResponseOutputItem）或一个输入项（即openai.types.responses.ResponseInputItemParam）。

to_input_item 

to_input_item() -> TResponseInputItem

将此项目转换为适合传递给模型的输入项目。

Source code in src/agents/items.py 
58
59
60
61
62
63
64
65
66
67
def to_input_item(self) -> TResponseInputItem:
    """Converts this item into an input item suitable for passing to the model."""
    if isinstance(self.raw_item, dict):
        # We know that input items are dicts, so we can ignore the type error
        return self.raw_item  # type: ignore
    elif isinstance(self.raw_item, BaseModel):
        # All output items are Pydantic models that can be converted to input items.
        return self.raw_item.model_dump(exclude_unset=True)  # type: ignore
    else:
        raise AgentsException(f"Unexpected raw item type: {type(self.raw_item)}")

消息输出项 dataclass

基类: RunItemBase[ResponseOutputMessage]

表示来自LLM的消息。

Source code in src/agents/items.py 
70
71
72
73
74
75
76
77
@dataclass
class MessageOutputItem(RunItemBase[ResponseOutputMessage]):
    """Represents a message from the LLM."""

    raw_item: ResponseOutputMessage
    """The raw response output message."""

    type: Literal["message_output_item"] = "message_output_item"

代理 instance-attribute 

agent: Agent[Any]

生成此项目的代理运行。

原始项 instance-attribute 

raw_item: ResponseOutputMessage

原始响应输出消息。

to_input_item 

to_input_item() -> TResponseInputItem

将此项目转换为适合传递给模型的输入项目。

Source code in src/agents/items.py 
58
59
60
61
62
63
64
65
66
67
def to_input_item(self) -> TResponseInputItem:
    """Converts this item into an input item suitable for passing to the model."""
    if isinstance(self.raw_item, dict):
        # We know that input items are dicts, so we can ignore the type error
        return self.raw_item  # type: ignore
    elif isinstance(self.raw_item, BaseModel):
        # All output items are Pydantic models that can be converted to input items.
        return self.raw_item.model_dump(exclude_unset=True)  # type: ignore
    else:
        raise AgentsException(f"Unexpected raw item type: {type(self.raw_item)}")

HandoffCallItem dataclass

基类: RunItemBase[ResponseFunctionToolCall]

表示一个工具调用，用于从一个智能体交接给另一个智能体。

Source code in src/agents/items.py 
80
81
82
83
84
85
86
87
@dataclass
class HandoffCallItem(RunItemBase[ResponseFunctionToolCall]):
    """Represents a tool call for a handoff from one agent to another."""

    raw_item: ResponseFunctionToolCall
    """The raw response function tool call that represents the handoff."""

    type: Literal["handoff_call_item"] = "handoff_call_item"

代理 instance-attribute 

agent: Agent[Any]

生成此项目的代理运行。

原始项目 instance-attribute 

raw_item: ResponseFunctionToolCall

表示交接的原始响应函数工具调用。

to_input_item 

to_input_item() -> TResponseInputItem

将此项目转换为适合传递给模型的输入项目。

Source code in src/agents/items.py 
58
59
60
61
62
63
64
65
66
67
def to_input_item(self) -> TResponseInputItem:
    """Converts this item into an input item suitable for passing to the model."""
    if isinstance(self.raw_item, dict):
        # We know that input items are dicts, so we can ignore the type error
        return self.raw_item  # type: ignore
    elif isinstance(self.raw_item, BaseModel):
        # All output items are Pydantic models that can be converted to input items.
        return self.raw_item.model_dump(exclude_unset=True)  # type: ignore
    else:
        raise AgentsException(f"Unexpected raw item type: {type(self.raw_item)}")

交接输出项 dataclass

基类：RunItemBase[TResponseInputItem]

表示交接的输出结果。

Source code in src/agents/items.py 
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
@dataclass
class HandoffOutputItem(RunItemBase[TResponseInputItem]):
    """Represents the output of a handoff."""

    raw_item: TResponseInputItem
    """The raw input item that represents the handoff taking place."""

    source_agent: Agent[Any]
    """The agent that made the handoff."""

    target_agent: Agent[Any]
    """The agent that is being handed off to."""

    type: Literal["handoff_output_item"] = "handoff_output_item"

代理 instance-attribute 

agent: Agent[Any]

生成此项目的代理运行。

原始数据项 instance-attribute 

raw_item: TResponseInputItem

表示交接发生的原始输入项。

source_agent instance-attribute 

source_agent: Agent[Any]

执行交接的代理程序。

目标代理 instance-attribute 

target_agent: Agent[Any]

正在移交的代理。

to_input_item 

to_input_item() -> TResponseInputItem

将此项目转换为适合传递给模型的输入项目。

Source code in src/agents/items.py 
58
59
60
61
62
63
64
65
66
67
def to_input_item(self) -> TResponseInputItem:
    """Converts this item into an input item suitable for passing to the model."""
    if isinstance(self.raw_item, dict):
        # We know that input items are dicts, so we can ignore the type error
        return self.raw_item  # type: ignore
    elif isinstance(self.raw_item, BaseModel):
        # All output items are Pydantic models that can be converted to input items.
        return self.raw_item.model_dump(exclude_unset=True)  # type: ignore
    else:
        raise AgentsException(f"Unexpected raw item type: {type(self.raw_item)}")

ToolCallItem dataclass

基类：RunItemBase[ToolCallItemTypes]

表示一个工具调用，例如函数调用或计算机操作调用。

Source code in src/agents/items.py 
115
116
117
118
119
120
121
122
@dataclass
class ToolCallItem(RunItemBase[ToolCallItemTypes]):
    """Represents a tool call e.g. a function call or computer action call."""

    raw_item: ToolCallItemTypes
    """The raw tool call item."""

    type: Literal["tool_call_item"] = "tool_call_item"

代理 instance-attribute 

agent: Agent[Any]

生成此项目的代理运行。

原始项目 instance-attribute 

raw_item: ToolCallItemTypes

原始工具调用项。

to_input_item 

to_input_item() -> TResponseInputItem

将此项目转换为适合传递给模型的输入项目。

Source code in src/agents/items.py 
58
59
60
61
62
63
64
65
66
67
def to_input_item(self) -> TResponseInputItem:
    """Converts this item into an input item suitable for passing to the model."""
    if isinstance(self.raw_item, dict):
        # We know that input items are dicts, so we can ignore the type error
        return self.raw_item  # type: ignore
    elif isinstance(self.raw_item, BaseModel):
        # All output items are Pydantic models that can be converted to input items.
        return self.raw_item.model_dump(exclude_unset=True)  # type: ignore
    else:
        raise AgentsException(f"Unexpected raw item type: {type(self.raw_item)}")

工具调用输出项 dataclass

基类: RunItemBase[Union[FunctionCallOutput, ComputerCallOutput]]

表示工具调用的输出。

Source code in src/agents/items.py 
125
126
127
128
129
130
131
132
133
134
135
136
137
@dataclass
class ToolCallOutputItem(RunItemBase[Union[FunctionCallOutput, ComputerCallOutput]]):
    """Represents the output of a tool call."""

    raw_item: FunctionCallOutput | ComputerCallOutput
    """The raw item from the model."""

    output: Any
    """The output of the tool call. This is whatever the tool call returned; the `raw_item`
    contains a string representation of the output.
    """

    type: Literal["tool_call_output_item"] = "tool_call_output_item"

代理 instance-attribute 

agent: Agent[Any]

生成此项目的代理运行。

原始项目 instance-attribute 

raw_item: FunctionCallOutput | ComputerCallOutput

模型输出的原始项。

输出 instance-attribute 

output: Any

工具调用的输出结果。这是工具调用返回的任何内容；raw_item包含输出的字符串表示形式。

to_input_item 

to_input_item() -> TResponseInputItem

将此项目转换为适合传递给模型的输入项目。

Source code in src/agents/items.py 
58
59
60
61
62
63
64
65
66
67
def to_input_item(self) -> TResponseInputItem:
    """Converts this item into an input item suitable for passing to the model."""
    if isinstance(self.raw_item, dict):
        # We know that input items are dicts, so we can ignore the type error
        return self.raw_item  # type: ignore
    elif isinstance(self.raw_item, BaseModel):
        # All output items are Pydantic models that can be converted to input items.
        return self.raw_item.model_dump(exclude_unset=True)  # type: ignore
    else:
        raise AgentsException(f"Unexpected raw item type: {type(self.raw_item)}")

推理项 dataclass

基类：RunItemBase[ResponseReasoningItem]

表示一个推理项。

Source code in src/agents/items.py 
140
141
142
143
144
145
146
147
@dataclass
class ReasoningItem(RunItemBase[ResponseReasoningItem]):
    """Represents a reasoning item."""

    raw_item: ResponseReasoningItem
    """The raw reasoning item."""

    type: Literal["reasoning_item"] = "reasoning_item"

代理 instance-attribute 

agent: Agent[Any]

生成此项目的代理运行。

原始项目 instance-attribute 

raw_item: ResponseReasoningItem

原始推理项。

to_input_item 

to_input_item() -> TResponseInputItem

将此项目转换为适合传递给模型的输入项目。

Source code in src/agents/items.py 
58
59
60
61
62
63
64
65
66
67
def to_input_item(self) -> TResponseInputItem:
    """Converts this item into an input item suitable for passing to the model."""
    if isinstance(self.raw_item, dict):
        # We know that input items are dicts, so we can ignore the type error
        return self.raw_item  # type: ignore
    elif isinstance(self.raw_item, BaseModel):
        # All output items are Pydantic models that can be converted to input items.
        return self.raw_item.model_dump(exclude_unset=True)  # type: ignore
    else:
        raise AgentsException(f"Unexpected raw item type: {type(self.raw_item)}")

模型响应 dataclass

Source code in src/agents/items.py 
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
@dataclass
class ModelResponse:
    output: list[TResponseOutputItem]
    """A list of outputs (messages, tool calls, etc) generated by the model"""

    usage: Usage
    """The usage information for the response."""

    referenceable_id: str | None
    """An ID for the response which can be used to refer to the response in subsequent calls to the
    model. Not supported by all model providers.
    """

    def to_input_items(self) -> list[TResponseInputItem]:
        """Convert the output into a list of input items suitable for passing to the model."""
        # We happen to know that the shape of the Pydantic output items are the same as the
        # equivalent TypedDict input items, so we can just convert each one.
        # This is also tested via unit tests.
        return [it.model_dump(exclude_unset=True) for it in self.output]  # type: ignore

输出 instance-attribute 

output: list[TResponseOutputItem]

模型生成的一系列输出（消息、工具调用等）

用法 instance-attribute 

usage: Usage

响应的使用信息。

referenceable_id instance-attribute 

referenceable_id: str | None

一个响应ID，可用于在后续调用模型时引用该响应。并非所有模型提供商都支持此功能。

to_input_items 

to_input_items() -> list[TResponseInputItem]

将输出转换为适合传递给模型的输入项列表。

Source code in src/agents/items.py 
174
175
176
177
178
179
def to_input_items(self) -> list[TResponseInputItem]:
    """Convert the output into a list of input items suitable for passing to the model."""
    # We happen to know that the shape of the Pydantic output items are the same as the
    # equivalent TypedDict input items, so we can just convert each one.
    # This is also tested via unit tests.
    return [it.model_dump(exclude_unset=True) for it in self.output]  # type: ignore

项目助手

Source code in src/agents/items.py 
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
class ItemHelpers:
    @classmethod
    def extract_last_content(cls, message: TResponseOutputItem) -> str:
        """Extracts the last text content or refusal from a message."""
        if not isinstance(message, ResponseOutputMessage):
            return ""

        last_content = message.content[-1]
        if isinstance(last_content, ResponseOutputText):
            return last_content.text
        elif isinstance(last_content, ResponseOutputRefusal):
            return last_content.refusal
        else:
            raise ModelBehaviorError(f"Unexpected content type: {type(last_content)}")

    @classmethod
    def extract_last_text(cls, message: TResponseOutputItem) -> str | None:
        """Extracts the last text content from a message, if any. Ignores refusals."""
        if isinstance(message, ResponseOutputMessage):
            last_content = message.content[-1]
            if isinstance(last_content, ResponseOutputText):
                return last_content.text

        return None

    @classmethod
    def input_to_new_input_list(
        cls, input: str | list[TResponseInputItem]
    ) -> list[TResponseInputItem]:
        """Converts a string or list of input items into a list of input items."""
        if isinstance(input, str):
            return [
                {
                    "content": input,
                    "role": "user",
                }
            ]
        return copy.deepcopy(input)

    @classmethod
    def text_message_outputs(cls, items: list[RunItem]) -> str:
        """Concatenates all the text content from a list of message output items."""
        text = ""
        for item in items:
            if isinstance(item, MessageOutputItem):
                text += cls.text_message_output(item)
        return text

    @classmethod
    def text_message_output(cls, message: MessageOutputItem) -> str:
        """Extracts all the text content from a single message output item."""
        text = ""
        for item in message.raw_item.content:
            if isinstance(item, ResponseOutputText):
                text += item.text
        return text

    @classmethod
    def tool_call_output_item(
        cls, tool_call: ResponseFunctionToolCall, output: str
    ) -> FunctionCallOutput:
        """Creates a tool call output item from a tool call and its output."""
        return {
            "call_id": tool_call.call_id,
            "output": output,
            "type": "function_call_output",
        }

extract_last_content classmethod 

extract_last_content(message: TResponseOutputItem) -> str

提取消息中的最后文本内容或拒绝信息。

Source code in src/agents/items.py 
183
184
185
186
187
188
189
190
191
192
193
194
195
@classmethod
def extract_last_content(cls, message: TResponseOutputItem) -> str:
    """Extracts the last text content or refusal from a message."""
    if not isinstance(message, ResponseOutputMessage):
        return ""

    last_content = message.content[-1]
    if isinstance(last_content, ResponseOutputText):
        return last_content.text
    elif isinstance(last_content, ResponseOutputRefusal):
        return last_content.refusal
    else:
        raise ModelBehaviorError(f"Unexpected content type: {type(last_content)}")

extract_last_text classmethod 

extract_last_text(
    message: TResponseOutputItem,
) -> str | None

从消息中提取最后的文本内容（如果有的话）。忽略拒绝回复。

Source code in src/agents/items.py 
197
198
199
200
201
202
203
204
205
@classmethod
def extract_last_text(cls, message: TResponseOutputItem) -> str | None:
    """Extracts the last text content from a message, if any. Ignores refusals."""
    if isinstance(message, ResponseOutputMessage):
        last_content = message.content[-1]
        if isinstance(last_content, ResponseOutputText):
            return last_content.text

    return None

input_to_new_input_list classmethod 

input_to_new_input_list(
    input: str | list[TResponseInputItem],
) -> list[TResponseInputItem]

将字符串或输入项列表转换为输入项列表。

Source code in src/agents/items.py 
207
208
209
210
211
212
213
214
215
216
217
218
219
@classmethod
def input_to_new_input_list(
    cls, input: str | list[TResponseInputItem]
) -> list[TResponseInputItem]:
    """Converts a string or list of input items into a list of input items."""
    if isinstance(input, str):
        return [
            {
                "content": input,
                "role": "user",
            }
        ]
    return copy.deepcopy(input)

文本消息输出 classmethod 

text_message_outputs(items: list[RunItem]) -> str

将消息输出项列表中的所有文本内容连接起来。

Source code in src/agents/items.py 
221
222
223
224
225
226
227
228
@classmethod
def text_message_outputs(cls, items: list[RunItem]) -> str:
    """Concatenates all the text content from a list of message output items."""
    text = ""
    for item in items:
        if isinstance(item, MessageOutputItem):
            text += cls.text_message_output(item)
    return text

text_message_output classmethod 

text_message_output(message: MessageOutputItem) -> str

从单个消息输出项中提取所有文本内容。

Source code in src/agents/items.py 
230
231
232
233
234
235
236
237
@classmethod
def text_message_output(cls, message: MessageOutputItem) -> str:
    """Extracts all the text content from a single message output item."""
    text = ""
    for item in message.raw_item.content:
        if isinstance(item, ResponseOutputText):
            text += item.text
    return text

工具调用输出项 classmethod 

tool_call_output_item(
    tool_call: ResponseFunctionToolCall, output: str
) -> FunctionCallOutput

根据工具调用及其输出创建一个工具调用输出项。

Source code in src/agents/items.py 
239
240
241
242
243
244
245
246
247
248
@classmethod
def tool_call_output_item(
    cls, tool_call: ResponseFunctionToolCall, output: str
) -> FunctionCallOutput:
    """Creates a tool call output item from a tool call and its output."""
    return {
        "call_id": tool_call.call_id,
        "output": output,
        "type": "function_call_output",
    }