跳转至

Creating traces/spans

trace 

trace(workflow_name: str, trace_id: str | None = None, group_id: str | None = None, metadata: dict[str, Any] | None = None, disabled: bool = False) -> Trace

创建一个新的 trace（追踪）。该 trace 不会自动启动；你需要将其作为上下文管理器使用（with trace(...):），或者手动调用 trace.start() 和 trace.finish()。

除了工作流名称和可选的分组标识符外，你还可以提供一个任意的元数据字典，将用户自定义的信息附加到 trace 上。

参数

workflow_name: 逻辑应用或工作流的名称。例如，你可以为编码代理提供 "code_bot"，或为客服代理提供 "customer_support_agent"。 trace_id: trace 的 ID。可选。如果未提供，我们会自动生成一个 ID。建议使用 util.gen_trace_id() 生成 trace ID，以确保格式正确。 group_id: 可选的分组标识符，用于将同一会话或流程中的多个 trace 关联起来。例如，你可以使用聊天线程 ID。 metadata: 可选的附加元数据字典，将其附加到 trace 上。 disabled: 如果为 True，我们会返回一个 Trace，但不会记录该 Trace。如果已存在 trace 且 even_if_trace_running 为 True，则不会检查此项。

返回

新创建的 trace 对象。

Source code in agents/tracing/create.py 
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
def trace(
    workflow_name: str,
    trace_id: str | None = None,
    group_id: str | None = None,
    metadata: dict[str, Any] | None = None,
    disabled: bool = False,
) -> Trace:
    """
    创建一个新的 trace（追踪）。该 trace 不会自动启动；你需要将其作为上下文管理器使用（`with trace(...):`），或者手动调用 `trace.start()` 和 `trace.finish()`。

    除了工作流名称和可选的分组标识符外，你还可以提供一个任意的元数据字典，将用户自定义的信息附加到 trace 上。

    参数:
        workflow_name: 逻辑应用或工作流的名称。例如，你可以为编码代理提供 "code_bot"，或为客服代理提供 "customer_support_agent"。
        trace_id: trace 的 ID。可选。如果未提供，我们会自动生成一个 ID。建议使用 `util.gen_trace_id()` 生成 trace ID，以确保格式正确。
        group_id: 可选的分组标识符，用于将同一会话或流程中的多个 trace 关联起来。例如，你可以使用聊天线程 ID。
        metadata: 可选的附加元数据字典，将其附加到 trace 上。
        disabled: 如果为 True，我们会返回一个 Trace，但不会记录该 Trace。如果已存在 trace 且 `even_if_trace_running` 为 True，则不会检查此项。

    返回:
        新创建的 trace 对象。
    """
    current_trace = GLOBAL_TRACE_PROVIDER.get_current_trace()
    if current_trace:
        logger.warning(
            "Trace already exists. Creating a new trace, but this is probably a mistake."
        )

    return GLOBAL_TRACE_PROVIDER.create_trace(
        name=workflow_name,
        trace_id=trace_id,
        group_id=group_id,
        metadata=metadata,
        disabled=disabled,
    )

get_current_trace 

get_current_trace() -> Trace | None

Returns the currently active trace, if present.

Source code in agents/tracing/create.py 
65
66
67
def get_current_trace() -> Trace | None:
    """Returns the currently active trace, if present."""
    return GLOBAL_TRACE_PROVIDER.get_current_trace()

get_current_span 

get_current_span() -> Span[Any] | None

Returns the currently active span, if present.

Source code in agents/tracing/create.py 
70
71
72
def get_current_span() -> Span[Any] | None:
    """Returns the currently active span, if present."""
    return GLOBAL_TRACE_PROVIDER.get_current_span()

agent_span 

agent_span(name: str, handoffs: list[str] | None = None, tools: list[str] | None = None, output_type: str | None = None, span_id: str | None = None, parent: Trace | Span[Any] | None = None, disabled: bool = False) -> Span[AgentSpanData]

创建一个新的 agent span。该 span 不会自动启动，你需要使用 with agent_span() ...，或者手动调用 span.start() 和 span.finish()。

参数

name: agent 的名称。 handoffs: 可选，agent 可以交接控制权的其他 agent 名称列表。 tools: 可选，该 agent 可用的工具名称列表。 output_type: 可选，agent 产生的输出类型名称。 span_id: span 的 ID。可选。如果未提供，我们会自动生成一个 ID。建议使用 util.gen_span_id() 生成 span ID，以确保格式正确。 parent: 父级 span 或 trace。如果未提供，我们会自动使用当前的 trace/span 作为父级。 disabled: 如果为 True，我们会返回一个 Span，但不会记录该 Span。

返回

新创建的 agent span。

Source code in agents/tracing/create.py 
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
def agent_span(
    name: str,
    handoffs: list[str] | None = None,
    tools: list[str] | None = None,
    output_type: str | None = None,
    span_id: str | None = None,
    parent: Trace | Span[Any] | None = None,
    disabled: bool = False,
) -> Span[AgentSpanData]:
    """创建一个新的 agent span。该 span 不会自动启动，你需要使用 `with agent_span() ...`，或者手动调用 `span.start()` 和 `span.finish()`。

    参数:
        name: agent 的名称。
        handoffs: 可选，agent 可以交接控制权的其他 agent 名称列表。
        tools: 可选，该 agent 可用的工具名称列表。
        output_type: 可选，agent 产生的输出类型名称。
        span_id: span 的 ID。可选。如果未提供，我们会自动生成一个 ID。建议使用 `util.gen_span_id()` 生成 span ID，以确保格式正确。
        parent: 父级 span 或 trace。如果未提供，我们会自动使用当前的 trace/span 作为父级。
        disabled: 如果为 True，我们会返回一个 Span，但不会记录该 Span。

    返回:
        新创建的 agent span。
    """
    return GLOBAL_TRACE_PROVIDER.create_span(
        span_data=AgentSpanData(name=name, handoffs=handoffs, tools=tools, output_type=output_type),
        span_id=span_id,
        parent=parent,
        disabled=disabled,
    )

function_span 

function_span(name: str, input: str | None = None, output: str | None = None, span_id: str | None = None, parent: Trace | Span[Any] | None = None, disabled: bool = False) -> Span[FunctionSpanData]

创建一个新的 function span。该 span 不会自动启动，你需要使用 with function_span() ...，或者手动调用 span.start() 和 span.finish()。

参数

name: 函数的名称。 input: 传递给函数的输入。 output: 函数的输出。 span_id: span 的 ID。可选。如果未提供，我们会自动生成一个 ID。建议使用 util.gen_span_id() 生成 span ID，以确保格式正确。 parent: 父级 span 或 trace。如果未提供，我们会自动使用当前的 trace/span 作为父级。 disabled: 如果为 True，我们会返回一个 Span，但不会记录该 Span。

返回

新创建的 function span。

Source code in agents/tracing/create.py 
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
def function_span(
    name: str,
    input: str | None = None,
    output: str | None = None,
    span_id: str | None = None,
    parent: Trace | Span[Any] | None = None,
    disabled: bool = False,
) -> Span[FunctionSpanData]:
    """创建一个新的 function span。该 span 不会自动启动，你需要使用 `with function_span() ...`，或者手动调用 `span.start()` 和 `span.finish()`。

    参数:
        name: 函数的名称。
        input: 传递给函数的输入。
        output: 函数的输出。
        span_id: span 的 ID。可选。如果未提供，我们会自动生成一个 ID。建议使用 `util.gen_span_id()` 生成 span ID，以确保格式正确。
        parent: 父级 span 或 trace。如果未提供，我们会自动使用当前的 trace/span 作为父级。
        disabled: 如果为 True，我们会返回一个 Span，但不会记录该 Span。

    返回:
        新创建的 function span。
    """
    return GLOBAL_TRACE_PROVIDER.create_span(
        span_data=FunctionSpanData(name=name, input=input, output=output),
        span_id=span_id,
        parent=parent,
        disabled=disabled,
    )

generation_span 

generation_span(input: Sequence[Mapping[str, Any]] | None = None, output: Sequence[Mapping[str, Any]] | None = None, model: str | None = None, model_config: Mapping[str, Any] | None = None, usage: dict[str, Any] | None = None, span_id: str | None = None, parent: Trace | Span[Any] | None = None, disabled: bool = False) -> Span[GenerationSpanData]

创建一个新的 generation span。该 span 不会自动启动，你需要使用 with generation_span() ...， 或者手动调用 span.start() 和 span.finish()。

该 span 用于捕获模型生成的详细信息，包括输入消息序列、生成的输出、模型名称与配置，以及用量数据。 如果你只需要捕获模型响应标识符，请使用 response_span()。

参数

input: 发送给模型的输入消息序列。 output: 从模型接收到的输出消息序列。 model: 用于生成的模型标识符。 model_config: 使用的模型配置（超参数）。 usage: 用量信息字典（如输入 token 数、输出 token 数等）。 span_id: span 的 ID。可选。如果未提供，我们会自动生成一个 ID。建议使用 util.gen_span_id() 生成 span ID，以确保格式正确。 parent: 父级 span 或 trace。如果未提供，我们会自动使用当前的 trace/span 作为父级。 disabled: 如果为 True，我们会返回一个 Span，但不会记录该 Span。

返回

新创建的 generation span。

Source code in agents/tracing/create.py 
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
def generation_span(
    input: Sequence[Mapping[str, Any]] | None = None,
    output: Sequence[Mapping[str, Any]] | None = None,
    model: str | None = None,
    model_config: Mapping[str, Any] | None = None,
    usage: dict[str, Any] | None = None,
    span_id: str | None = None,
    parent: Trace | Span[Any] | None = None,
    disabled: bool = False,
) -> Span[GenerationSpanData]:
    """创建一个新的 generation span。该 span 不会自动启动，你需要使用 `with generation_span() ...`，
    或者手动调用 `span.start()` 和 `span.finish()`。

    该 span 用于捕获模型生成的详细信息，包括输入消息序列、生成的输出、模型名称与配置，以及用量数据。
    如果你只需要捕获模型响应标识符，请使用 `response_span()`。

    参数:
        input: 发送给模型的输入消息序列。
        output: 从模型接收到的输出消息序列。
        model: 用于生成的模型标识符。
        model_config: 使用的模型配置（超参数）。
        usage: 用量信息字典（如输入 token 数、输出 token 数等）。
        span_id: span 的 ID。可选。如果未提供，我们会自动生成一个 ID。建议使用 `util.gen_span_id()` 生成 span ID，以确保格式正确。
        parent: 父级 span 或 trace。如果未提供，我们会自动使用当前的 trace/span 作为父级。
        disabled: 如果为 True，我们会返回一个 Span，但不会记录该 Span。

    返回:
        新创建的 generation span。
    """
    return GLOBAL_TRACE_PROVIDER.create_span(
        span_data=GenerationSpanData(
            input=input,
            output=output,
            model=model,
            model_config=model_config,
            usage=usage,
        ),
        span_id=span_id,
        parent=parent,
        disabled=disabled,
    )

response_span 

response_span(response: Response | None = None, span_id: str | None = None, parent: Trace | Span[Any] | None = None, disabled: bool = False) -> Span[ResponseSpanData]

创建一个新的 response span。该 span 不会自动启动，你需要使用 with response_span() ...， 或者手动调用 span.start() 和 span.finish()。

参数

response: OpenAI 的 Response 对象。 span_id: span 的 ID。可选。如果未提供，我们会自动生成一个 ID。建议使用 util.gen_span_id() 生成 span ID，以确保格式正确。 parent: 父级 span 或 trace。如果未提供，我们会自动使用当前的 trace/span 作为父级。 disabled: 如果为 True，我们会返回一个 Span，但不会记录该 Span。

Source code in agents/tracing/create.py 
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
def response_span(
    response: Response | None = None,
    span_id: str | None = None,
    parent: Trace | Span[Any] | None = None,
    disabled: bool = False,
) -> Span[ResponseSpanData]:
    """创建一个新的 response span。该 span 不会自动启动，你需要使用 `with response_span() ...`，
    或者手动调用 `span.start()` 和 `span.finish()`。

    参数:
        response: OpenAI 的 Response 对象。
        span_id: span 的 ID。可选。如果未提供，我们会自动生成一个 ID。建议使用 `util.gen_span_id()` 生成 span ID，以确保格式正确。
        parent: 父级 span 或 trace。如果未提供，我们会自动使用当前的 trace/span 作为父级。
        disabled: 如果为 True，我们会返回一个 Span，但不会记录该 Span。
    """
    return GLOBAL_TRACE_PROVIDER.create_span(
        span_data=ResponseSpanData(response=response),
        span_id=span_id,
        parent=parent,
        disabled=disabled,
    )

handoff_span 

handoff_span(from_agent: str | None = None, to_agent: str | None = None, span_id: str | None = None, parent: Trace | Span[Any] | None = None, disabled: bool = False) -> Span[HandoffSpanData]

创建一个新的 handoff span。该 span 不会自动启动，你需要使用 with handoff_span() ...， 或者手动调用 span.start() 和 span.finish()。

参数

from_agent: 发起交接的 agent 名称。 to_agent: 接收交接的 agent 名称。 span_id: span 的 ID。可选。如果未提供，我们会自动生成一个 ID。建议使用 util.gen_span_id() 生成 span ID，以确保格式正确。 parent: 父级 span 或 trace。如果未提供，我们会自动使用当前的 trace/span 作为父级。 disabled: 如果为 True，我们会返回一个 Span，但不会记录该 Span。

返回

新创建的 handoff span。

Source code in agents/tracing/create.py 
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
def handoff_span(
    from_agent: str | None = None,
    to_agent: str | None = None,
    span_id: str | None = None,
    parent: Trace | Span[Any] | None = None,
    disabled: bool = False,
) -> Span[HandoffSpanData]:
    """创建一个新的 handoff span。该 span 不会自动启动，你需要使用 `with handoff_span() ...`，
    或者手动调用 `span.start()` 和 `span.finish()`。

    参数:
        from_agent: 发起交接的 agent 名称。
        to_agent: 接收交接的 agent 名称。
        span_id: span 的 ID。可选。如果未提供，我们会自动生成一个 ID。建议使用 `util.gen_span_id()` 生成 span ID，以确保格式正确。
        parent: 父级 span 或 trace。如果未提供，我们会自动使用当前的 trace/span 作为父级。
        disabled: 如果为 True，我们会返回一个 Span，但不会记录该 Span。

    返回:
        新创建的 handoff span。
    """
    return GLOBAL_TRACE_PROVIDER.create_span(
        span_data=HandoffSpanData(from_agent=from_agent, to_agent=to_agent),
        span_id=span_id,
        parent=parent,
        disabled=disabled,
    )

custom_span 

custom_span(name: str, data: dict[str, Any] | None = None, span_id: str | None = None, parent: Trace | Span[Any] | None = None, disabled: bool = False) -> Span[CustomSpanData]

创建一个新的自定义 span，你可以为其添加自定义元数据。该 span 不会自动启动，你需要使用 with custom_span() ...，或者手动调用 span.start() 和 span.finish()。

参数

name: 自定义 span 的名称。 data: 要关联到 span 的任意结构化数据。 span_id: span 的 ID。可选。如果未提供，我们会自动生成一个 ID。建议使用 util.gen_span_id() 生成 span ID，以确保格式正确。 parent: 父级 span 或 trace。如果未提供，我们会自动使用当前的 trace/span 作为父级。 disabled: 如果为 True，我们会返回一个 Span，但不会记录该 Span。

返回

新创建的自定义 span。

Source code in agents/tracing/create.py 
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
def custom_span(
    name: str,
    data: dict[str, Any] | None = None,
    span_id: str | None = None,
    parent: Trace | Span[Any] | None = None,
    disabled: bool = False,
) -> Span[CustomSpanData]:
    """创建一个新的自定义 span，你可以为其添加自定义元数据。该 span 不会自动启动，你需要使用 `with custom_span() ...`，或者手动调用 `span.start()` 和 `span.finish()`。

    参数:
        name: 自定义 span 的名称。
        data: 要关联到 span 的任意结构化数据。
        span_id: span 的 ID。可选。如果未提供，我们会自动生成一个 ID。建议使用 `util.gen_span_id()` 生成 span ID，以确保格式正确。
        parent: 父级 span 或 trace。如果未提供，我们会自动使用当前的 trace/span 作为父级。
        disabled: 如果为 True，我们会返回一个 Span，但不会记录该 Span。

    返回:
        新创建的自定义 span。
    """
    return GLOBAL_TRACE_PROVIDER.create_span(
        span_data=CustomSpanData(name=name, data=data or {}),
        span_id=span_id,
        parent=parent,
        disabled=disabled,
    )

guardrail_span 

guardrail_span(name: str, triggered: bool = False, span_id: str | None = None, parent: Trace | Span[Any] | None = None, disabled: bool = False) -> Span[GuardrailSpanData]

创建一个新的 guardrail span。该 span 不会自动启动，你需要使用 with guardrail_span() ...， 或者手动调用 span.start() 和 span.finish()。

参数

name: guardrail 的名称。 triggered: guardrail 是否被触发。 span_id: span 的 ID。可选。如果未提供，我们会自动生成一个 ID。建议使用 util.gen_span_id() 生成 span ID，以确保格式正确。 parent: 父级 span 或 trace。如果未提供，我们会自动使用当前的 trace/span 作为父级。 disabled: 如果为 True，我们会返回一个 Span，但不会记录该 Span。

Source code in agents/tracing/create.py 
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
def guardrail_span(
    name: str,
    triggered: bool = False,
    span_id: str | None = None,
    parent: Trace | Span[Any] | None = None,
    disabled: bool = False,
) -> Span[GuardrailSpanData]:
    """创建一个新的 guardrail span。该 span 不会自动启动，你需要使用 `with guardrail_span() ...`，
    或者手动调用 `span.start()` 和 `span.finish()`。

    参数:
        name: guardrail 的名称。
        triggered: guardrail 是否被触发。
        span_id: span 的 ID。可选。如果未提供，我们会自动生成一个 ID。建议使用 `util.gen_span_id()` 生成 span ID，以确保格式正确。
        parent: 父级 span 或 trace。如果未提供，我们会自动使用当前的 trace/span 作为父级。
        disabled: 如果为 True，我们会返回一个 Span，但不会记录该 Span。
    """
    return GLOBAL_TRACE_PROVIDER.create_span(
        span_data=GuardrailSpanData(name=name, triggered=triggered),
        span_id=span_id,
        parent=parent,
        disabled=disabled,
    )

transcription_span 

transcription_span(model: str | None = None, input: str | None = None, input_format: str | None = 'pcm', output: str | None = None, model_config: Mapping[str, Any] | None = None, span_id: str | None = None, parent: Trace | Span[Any] | None = None, disabled: bool = False) -> Span[TranscriptionSpanData]

创建一个新的转录（transcription）span。该 span 不会自动启动，你需要使用 with transcription_span() ...， 或者手动调用 span.start() 和 span.finish()。

参数

model: 用于语音转文本的模型名称。 input: 语音转文本的音频输入，作为 base64 编码的音频字节字符串。 input_format: 音频输入的格式（默认为 "pcm"）。 output: 语音转文本的输出文本。 model_config: 使用的模型配置（超参数）。 span_id: span 的 ID。可选。如果未提供，我们会自动生成一个 ID。建议使用 util.gen_span_id() 生成 span ID，以确保格式正确。 parent: 父级 span 或 trace。如果未提供，我们会自动使用当前的 trace/span 作为父级。 disabled: 如果为 True，我们会返回一个 Span，但不会记录该 Span。

返回

新创建的语音转文本 span。

Source code in agents/tracing/create.py 
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
def transcription_span(
    model: str | None = None,
    input: str | None = None,
    input_format: str | None = "pcm",
    output: str | None = None,
    model_config: Mapping[str, Any] | None = None,
    span_id: str | None = None,
    parent: Trace | Span[Any] | None = None,
    disabled: bool = False,
) -> Span[TranscriptionSpanData]:
    """创建一个新的转录（transcription）span。该 span 不会自动启动，你需要使用 `with transcription_span() ...`，
    或者手动调用 `span.start()` 和 `span.finish()`。

    参数:
        model: 用于语音转文本的模型名称。
        input: 语音转文本的音频输入，作为 base64 编码的音频字节字符串。
        input_format: 音频输入的格式（默认为 "pcm"）。
        output: 语音转文本的输出文本。
        model_config: 使用的模型配置（超参数）。
        span_id: span 的 ID。可选。如果未提供，我们会自动生成一个 ID。建议使用 `util.gen_span_id()` 生成 span ID，以确保格式正确。
        parent: 父级 span 或 trace。如果未提供，我们会自动使用当前的 trace/span 作为父级。
        disabled: 如果为 True，我们会返回一个 Span，但不会记录该 Span。

    返回:
        新创建的语音转文本 span。
    """
    return GLOBAL_TRACE_PROVIDER.create_span(
        span_data=TranscriptionSpanData(
            input=input,
            input_format=input_format,
            output=output,
            model=model,
            model_config=model_config,
        ),
        span_id=span_id,
        parent=parent,
        disabled=disabled,
    )

speech_span 

speech_span(model: str | None = None, input: str | None = None, output: str | None = None, output_format: str | None = 'pcm', model_config: Mapping[str, Any] | None = None, first_content_at: str | None = None, span_id: str | None = None, parent: Trace | Span[Any] | None = None, disabled: bool = False) -> Span[SpeechSpanData]

创建一个新的 speech span。该 span 不会自动启动，你需要使用 with speech_span() ...，或者手动调用 span.start() 和 span.finish()。

参数

model: 用于文本转语音的模型名称。 input: 文本转语音的输入文本。 output: 文本转语音的音频输出，作为 base64 编码的 PCM 音频字节字符串。 output_format: 音频输出的格式（默认为 "pcm"）。 model_config: 使用的模型配置（超参数）。 first_content_at: 音频输出第一个字节的时间。 span_id: span 的 ID。可选。如果未提供，我们会自动生成一个 ID。建议使用 util.gen_span_id() 生成 span ID，以确保格式正确。 parent: 父级 span 或 trace。如果未提供，我们会自动使用当前的 trace/span 作为父级。 disabled: 如果为 True，我们会返回一个 Span，但不会记录该 Span。

Source code in agents/tracing/create.py 
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
def speech_span(
    model: str | None = None,
    input: str | None = None,
    output: str | None = None,
    output_format: str | None = "pcm",
    model_config: Mapping[str, Any] | None = None,
    first_content_at: str | None = None,
    span_id: str | None = None,
    parent: Trace | Span[Any] | None = None,
    disabled: bool = False,
) -> Span[SpeechSpanData]:
    """创建一个新的 speech span。该 span 不会自动启动，你需要使用 `with speech_span() ...`，或者手动调用 `span.start()` 和 `span.finish()`。

    参数:
        model: 用于文本转语音的模型名称。
        input: 文本转语音的输入文本。
        output: 文本转语音的音频输出，作为 base64 编码的 PCM 音频字节字符串。
        output_format: 音频输出的格式（默认为 "pcm"）。
        model_config: 使用的模型配置（超参数）。
        first_content_at: 音频输出第一个字节的时间。
        span_id: span 的 ID。可选。如果未提供，我们会自动生成一个 ID。建议使用 `util.gen_span_id()` 生成 span ID，以确保格式正确。
        parent: 父级 span 或 trace。如果未提供，我们会自动使用当前的 trace/span 作为父级。
        disabled: 如果为 True，我们会返回一个 Span，但不会记录该 Span。
    """
    return GLOBAL_TRACE_PROVIDER.create_span(
        span_data=SpeechSpanData(
            model=model,
            input=input,
            output=output,
            output_format=output_format,
            model_config=model_config,
            first_content_at=first_content_at,
        ),
        span_id=span_id,
        parent=parent,
        disabled=disabled,
    )

speech_group_span 

speech_group_span(input: str | None = None, span_id: str | None = None, parent: Trace | Span[Any] | None = None, disabled: bool = False) -> Span[SpeechGroupSpanData]

创建一个新的 speech group span。该 span 不会自动启动，你需要使用 with speech_group_span() ...， 或者手动调用 span.start() 和 span.finish()。

参数

input: 用于语音请求的输入文本。 span_id: span 的 ID。可选。如果未提供，我们会自动生成一个 ID。建议使用 util.gen_span_id() 生成 span ID，以确保格式正确。 parent: 父级 span 或 trace。如果未提供，我们会自动使用当前的 trace/span 作为父级。 disabled: 如果为 True，我们会返回一个 Span，但不会记录该 Span。

Source code in agents/tracing/create.py 
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
def speech_group_span(
    input: str | None = None,
    span_id: str | None = None,
    parent: Trace | Span[Any] | None = None,
    disabled: bool = False,
) -> Span[SpeechGroupSpanData]:
    """创建一个新的 speech group span。该 span 不会自动启动，你需要使用 `with speech_group_span() ...`，
    或者手动调用 `span.start()` 和 `span.finish()`。

    参数:
        input: 用于语音请求的输入文本。
        span_id: span 的 ID。可选。如果未提供，我们会自动生成一个 ID。建议使用 `util.gen_span_id()` 生成 span ID，以确保格式正确。
        parent: 父级 span 或 trace。如果未提供，我们会自动使用当前的 trace/span 作为父级。
        disabled: 如果为 True，我们会返回一个 Span，但不会记录该 Span。
    """
    return GLOBAL_TRACE_PROVIDER.create_span(
        span_data=SpeechGroupSpanData(input=input),
        span_id=span_id,
        parent=parent,
        disabled=disabled,
    )

mcp_tools_span 

mcp_tools_span(server: str | None = None, result: list[str] | None = None, span_id: str | None = None, parent: Trace | Span[Any] | None = None, disabled: bool = False) -> Span[MCPListToolsSpanData]

创建一个新的 MCP list tools span。该 span 不会自动启动，你需要使用 with mcp_tools_span() ...， 或者手动调用 span.start() 和 span.finish()。

参数

server: MCP 服务器的名称。 result: MCP list tools 调用的结果。 span_id: span 的 ID。可选。如果未提供，我们会自动生成一个 ID。建议使用 util.gen_span_id() 生成 span ID，以确保格式正确。 parent: 父级 span 或 trace。如果未提供，我们会自动使用当前的 trace/span 作为父级。 disabled: 如果为 True，我们会返回一个 Span，但不会记录该 Span。

Source code in agents/tracing/create.py 
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
def mcp_tools_span(
    server: str | None = None,
    result: list[str] | None = None,
    span_id: str | None = None,
    parent: Trace | Span[Any] | None = None,
    disabled: bool = False,
) -> Span[MCPListToolsSpanData]:
    """创建一个新的 MCP list tools span。该 span 不会自动启动，你需要使用 `with mcp_tools_span() ...`，
    或者手动调用 `span.start()` 和 `span.finish()`。

    参数:
        server: MCP 服务器的名称。
        result: MCP list tools 调用的结果。
        span_id: span 的 ID。可选。如果未提供，我们会自动生成一个 ID。建议使用 `util.gen_span_id()` 生成 span ID，以确保格式正确。
        parent: 父级 span 或 trace。如果未提供，我们会自动使用当前的 trace/span 作为父级。
        disabled: 如果为 True，我们会返回一个 Span，但不会记录该 Span。
    """
    return GLOBAL_TRACE_PROVIDER.create_span(
        span_data=MCPListToolsSpanData(server=server, result=result),
        span_id=span_id,
        parent=parent,
        disabled=disabled,
    )