# OpenAI 响应删除

> 大语言模型

## 请求地址

`DELETE https://api.modelverse.cn/v1/responses/{response_id}`

## 请求参数

| Name | In | Type | Required | Description |
| --- | --- | --- | --- | --- |
| response_id | path | string | Yes | 要删除的响应的 ID。 |

## 响应

- **200** — 成功
- **404** — 未找到
- **4XX** — 错误响应。

## OpenAPI 定义

```json
{
  "openapi": "3.1.0",
  "info": {
    "title": "openai-responses接口文档",
    "description": "本文档介绍 ModelVerse 上的 OpenAI Responses 兼容接口，覆盖创建、查询、取消、删除、compact、count tokens、输入输出 item、工具调用、流式事件和错误响应等能力。",
    "version": "2.3.0",
    "termsOfService": "https://openai.com/policies/terms-of-use",
    "contact": {
      "name": "OpenAI Support",
      "url": "https://help.openai.com/"
    },
    "license": {
      "name": "MIT",
      "url": "https://github.com/openai/openai-openapi/blob/master/LICENSE"
    }
  },
  "servers": [
    {
      "url": "https://api.modelverse.cn",
      "description": "中国大陆节点，国内用户推荐，访问延迟低。"
    },
    {
      "url": "https://api-sg.umodelverse.ai",
      "description": "新加坡节点，东南亚用户推荐，访问更快。"
    },
    {
      "url": "https://api-us-ca.umodelverse.ai",
      "description": "美国洛杉矶节点，海外用户推荐，数据不回国。"
    },
    {
      "url": "https://api-ge-fra.umodelverse.ai",
      "description": "法兰克福节点，欧洲用户推荐，访问更快。"
    }
  ],
  "security": [
    {
      "ApiKeyAuth": []
    }
  ],
  "tags": [
    {
      "name": "Responses",
      "description": "创建、检索、取消、删除、压缩和计算响应的输入标记。"
    }
  ],
  "paths": {
    "/v1/responses": {
      "post": {
        "operationId": "createResponse",
        "tags": [
          "Responses"
        ],
        "summary": "OpenAI 响应创建",
        "requestBody": {
          "required": true,
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/CreateResponse"
              },
              "example": {
                "model": "model-name",
                "input": "Write a haiku about APIs."
              }
            }
          }
        },
        "responses": {
          "200": {
            "description": "成功",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Response"
                }
              },
              "text/event-stream": {
                "schema": {
                  "$ref": "#/components/schemas/ResponseStreamEvent"
                }
              }
            }
          },
          "4XX": {
            "description": "错误响应。",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            }
          }
        }
      }
    },
    "/v1/responses/{response_id}": {
      "get": {
        "operationId": "getResponse",
        "tags": [
          "Responses"
        ],
        "summary": "OpenAI 响应获取",
        "parameters": [
          {
            "in": "path",
            "name": "response_id",
            "required": true,
            "schema": {
              "type": "string",
              "example": "resp_677efb5139a88190b512bc3fef8e535d"
            },
            "description": "要检索的响应的 ID。"
          },
          {
            "in": "query",
            "name": "include",
            "schema": {
              "type": "array",
              "items": {
                "$ref": "#/components/schemas/IncludeEnum"
              }
            },
            "description": "响应中包含的其他字段。请参阅 `include`\n有关更多信息，请参阅上面的响应创建参数。"
          },
          {
            "in": "query",
            "name": "stream",
            "schema": {
              "type": "boolean"
            },
            "description": "如果设置为true，模型响应数据将流式传输到客户端\n因为它是使用[server-sent events](https://developer.mozilla.org/en-US/docs/Web/API/Server-sent_events/Using_server-sent_events#Event_stream_format) 生成的。\n请参阅下面的[流媒体部分](https://platform.openai.com/docs/api-reference/responses-streaming)\n了解更多信息。"
          },
          {
            "in": "query",
            "name": "starting_after",
            "schema": {
              "type": "integer"
            },
            "description": "开始流式传输的事件的序列号。"
          },
          {
            "in": "query",
            "name": "include_obfuscation",
            "schema": {
              "type": "boolean"
            },
            "description": "当 true 时，将启用流混淆。流混淆添加\n流式增量事件上 `obfuscation` 字段的随机字符\n标准化有效负载大小以缓解某些侧信道的影响\n攻击。默认情况下包含这些混淆字段，但添加一个\n数据流的少量开销。您可以设置\n如果您信任，将 `include_obfuscation` 设置为 false 以优化带宽\n您的应用程序和 OpenAI API 之间的网络链接。"
          }
        ],
        "responses": {
          "200": {
            "description": "成功",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Response"
                }
              }
            }
          },
          "4XX": {
            "description": "错误响应。",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            }
          }
        }
      },
      "delete": {
        "operationId": "deleteResponse",
        "tags": [
          "Responses"
        ],
        "summary": "OpenAI 响应删除",
        "parameters": [
          {
            "in": "path",
            "name": "response_id",
            "required": true,
            "schema": {
              "type": "string",
              "example": "resp_677efb5139a88190b512bc3fef8e535d"
            },
            "description": "要删除的响应的 ID。"
          }
        ],
        "responses": {
          "200": {
            "description": "成功"
          },
          "404": {
            "description": "未找到",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            }
          },
          "4XX": {
            "description": "错误响应。",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            }
          }
        }
      }
    },
    "/v1/responses/{response_id}/cancel": {
      "post": {
        "operationId": "cancelResponse",
        "tags": [
          "Responses"
        ],
        "summary": "OpenAI 响应取消",
        "parameters": [
          {
            "in": "path",
            "name": "response_id",
            "required": true,
            "schema": {
              "type": "string",
              "example": "resp_677efb5139a88190b512bc3fef8e535d"
            },
            "description": "要取消的响应的ID。"
          }
        ],
        "responses": {
          "200": {
            "description": "成功",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Response"
                }
              }
            }
          },
          "404": {
            "description": "未找到",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            }
          },
          "4XX": {
            "description": "错误响应。",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            }
          }
        }
      }
    },
    "/v1/responses/input_tokens": {
      "post": {
        "summary": "OpenAI 输入 Token 统计",
        "operationId": "Getinputtokencounts",
        "parameters": [],
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/TokenCountsBody"
              }
            },
            "application/x-www-form-urlencoded": {
              "schema": {
                "$ref": "#/components/schemas/TokenCountsBody"
              }
            }
          }
        },
        "responses": {
          "200": {
            "description": "成功",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/TokenCountsResource"
                }
              }
            }
          },
          "4XX": {
            "description": "错误响应。",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            }
          }
        },
        "tags": [
          "Responses"
        ]
      }
    },
    "/v1/responses/compact": {
      "post": {
        "summary": "OpenAI 对话压缩",
        "operationId": "Compactconversation",
        "parameters": [],
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/CompactResponseMethodPublicBody"
              }
            },
            "application/x-www-form-urlencoded": {
              "schema": {
                "$ref": "#/components/schemas/CompactResponseMethodPublicBody"
              }
            }
          }
        },
        "responses": {
          "200": {
            "description": "成功",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/CompactResource"
                }
              }
            }
          },
          "4XX": {
            "description": "错误响应。",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            }
          }
        },
        "tags": [
          "Responses"
        ]
      }
    }
  },
  "components": {
    "securitySchemes": {
      "ApiKeyAuth": {
        "type": "http",
        "scheme": "bearer"
      }
    },
    "schemas": {
      "CreateResponse": {
        "allOf": [
          {
            "$ref": "#/components/schemas/CreateModelResponseProperties"
          },
          {
            "$ref": "#/components/schemas/ResponseProperties"
          },
          {
            "type": "object",
            "properties": {
              "input": {
                "$ref": "#/components/schemas/InputParam"
              },
              "include": {
                "anyOf": [
                  {
                    "type": "array",
                    "description": "指定要包含在模型响应中的附加输出数据。目前支持的值为：\n- `web_search_call.action.sources`：包括网络搜索工具调用的来源。\n- `code_interpreter_call.outputs`：包括代码解释器工具调用项中Python代码执行的输出。\n- `computer_call_output.output.image_url`：包括计算机调用输出中的图像 URL。\n- `file_search_call.results`：包含文件搜索工具调用的搜索结果。\n- `message.input_image.image_url`：包含输入消息中的图像 URL。\n- `message.output_text.logprobs`：包括带有辅助消息的 logprobs。\n- `reasoning.encrypted_content`：在推理项输出中包含推理token的加密版本。这使得在无状态使用 Responses API 时可以在多轮对话中使用推理项（例如当 `store` 参数设置为 `false` 时，或者当组织注册零数据保留计划时）。",
                    "items": {
                      "$ref": "#/components/schemas/IncludeEnum"
                    },
                    "title": "array"
                  },
                  {
                    "type": "null",
                    "title": "null"
                  }
                ]
              },
              "parallel_tool_calls": {
                "anyOf": [
                  {
                    "type": "boolean",
                    "description": "是否允许模型并行运行工具调用。",
                    "default": true,
                    "title": "boolean"
                  },
                  {
                    "type": "null",
                    "title": "null"
                  }
                ]
              },
              "store": {
                "anyOf": [
                  {
                    "type": "boolean",
                    "description": "是否存储生成的模型响应以供以后通过\nAPI。",
                    "default": true,
                    "title": "boolean"
                  },
                  {
                    "type": "null",
                    "title": "null"
                  }
                ]
              },
              "instructions": {
                "anyOf": [
                  {
                    "type": "string",
                    "description": "插入模型上下文的系统（或开发人员）消息。\n\n当与 `previous_response_id` 一起使用时，之前的指令\n响应不会延续到下一个响应。这让事情变得简单\n在新响应中交换系统（或开发人员）消息。",
                    "title": "string"
                  },
                  {
                    "type": "null",
                    "title": "null"
                  }
                ]
              },
              "stream": {
                "anyOf": [
                  {
                    "description": "如果设置为true，模型响应数据将流式传输到客户端\n因为它是使用[server-sent events](https://developer.mozilla.org/en-US/docs/Web/API/Server-sent_events/Using_server-sent_events#Event_stream_format) 生成的。\n请参阅下面的[流媒体部分](https://platform.openai.com/docs/api-reference/responses-streaming)\n了解更多信息。",
                    "type": "boolean",
                    "default": false,
                    "title": "boolean"
                  },
                  {
                    "type": "null",
                    "title": "null"
                  }
                ]
              },
              "stream_options": {
                "$ref": "#/components/schemas/ResponseStreamOptions"
              },
              "conversation": {
                "anyOf": [
                  {
                    "$ref": "#/components/schemas/ConversationParam"
                  },
                  {
                    "type": "null",
                    "title": "null"
                  }
                ]
              },
              "context_management": {
                "anyOf": [
                  {
                    "type": "array",
                    "description": "该请求的上下文管理配置。",
                    "minItems": 1,
                    "items": {
                      "$ref": "#/components/schemas/ContextManagementParam"
                    },
                    "title": "array"
                  },
                  {
                    "type": "null",
                    "title": "null"
                  }
                ]
              },
              "max_output_tokens": {
                "anyOf": [
                  {
                    "description": "可以为响应生成的token数量的上限，包括可见输出token和[推理token](https://platform.openai.com/docs/guides/reasoning)。",
                    "type": "integer",
                    "minimum": 16,
                    "title": "integer"
                  },
                  {
                    "type": "null",
                    "title": "null"
                  }
                ]
              }
            }
          }
        ]
      },
      "Response": {
        "title": "响应对象",
        "allOf": [
          {
            "$ref": "#/components/schemas/ModelResponseProperties"
          },
          {
            "$ref": "#/components/schemas/ResponseProperties"
          },
          {
            "type": "object",
            "properties": {
              "id": {
                "type": "string",
                "description": "该响应的唯一标识符。"
              },
              "object": {
                "type": "string",
                "description": "该资源的对象类型 - 始终设置为 `response`。",
                "enum": [
                  "response"
                ],
                "x-stainless-const": true
              },
              "status": {
                "type": "string",
                "description": "响应生成的状态。 `completed`、`failed` 之一，\n`in_progress`、`cancelled`、`queued` 或 `incomplete`。",
                "enum": [
                  "completed",
                  "failed",
                  "in_progress",
                  "cancelled",
                  "queued",
                  "incomplete"
                ]
              },
              "created_at": {
                "type": "number",
                "format": "unixtime",
                "description": "创建此响应时的 Unix 时间戳（以秒为单位）。"
              },
              "completed_at": {
                "anyOf": [
                  {
                    "type": "number",
                    "format": "unixtime",
                    "description": "此响应完成时的 Unix 时间戳（以秒为单位）。\n仅当状态为 `completed` 时才出现。",
                    "title": "number"
                  },
                  {
                    "type": "null",
                    "title": "null"
                  }
                ]
              },
              "error": {
                "$ref": "#/components/schemas/ResponseError"
              },
              "incomplete_details": {
                "anyOf": [
                  {
                    "type": "object",
                    "description": "有关响应不完整原因的详细信息。",
                    "properties": {
                      "reason": {
                        "type": "string",
                        "description": "响应不完整的原因。",
                        "enum": [
                          "max_output_tokens",
                          "content_filter"
                        ]
                      }
                    },
                    "title": "object"
                  },
                  {
                    "type": "null",
                    "title": "null"
                  }
                ]
              },
              "output": {
                "type": "array",
                "description": "由模型生成的内容项的数组。\n\n- `output` 数组中项目的长度和顺序是相关的\n  关于模型的反应。\n- 而不是访问 `output` 数组中的第一项\n  假设它是一条 `assistant` 消息，其内容由\n  对于模型，您可以考虑使用 `output_text` 属性，其中\n  SDK 支持。",
                "items": {
                  "$ref": "#/components/schemas/OutputItem"
                }
              },
              "instructions": {
                "anyOf": [
                  {
                    "description": "插入模型上下文的系统（或开发人员）消息。\n\n当与 `previous_response_id` 一起使用时，之前的指令\n响应不会延续到下一个响应。这让事情变得简单\n在新响应中交换系统（或开发人员）消息。",
                    "oneOf": [
                      {
                        "type": "string",
                        "description": "模型的文本输入，相当于文本输入\n`developer` 角色。",
                        "title": "string"
                      },
                      {
                        "type": "array",
                        "title": "输入项目列表",
                        "description": "模型的一个或多个输入项的列表，包含\n不同的内容类型。",
                        "items": {
                          "$ref": "#/components/schemas/InputItem"
                        }
                      }
                    ]
                  },
                  {
                    "type": "null",
                    "title": "null"
                  }
                ]
              },
              "output_text": {
                "anyOf": [
                  {
                    "type": "string",
                    "description": "仅包含聚合文本输出的 SDK 便利属性\n来自 `output` 数组中的所有 `output_text` 项（如果存在）。\n在 Python 和 JavaScript SDK 中受支持。",
                    "x-oaiSupportedSDKs": [
                      "python",
                      "javascript"
                    ],
                    "title": "string"
                  },
                  {
                    "type": "null",
                    "title": "null"
                  }
                ]
              },
              "usage": {
                "$ref": "#/components/schemas/ResponseUsage"
              },
              "parallel_tool_calls": {
                "type": "boolean",
                "description": "是否允许模型并行运行工具调用。",
                "default": true
              },
              "conversation": {
                "anyOf": [
                  {
                    "default": null,
                    "$ref": "#/components/schemas/Conversation-2"
                  },
                  {
                    "type": "null",
                    "title": "null"
                  }
                ]
              },
              "max_output_tokens": {
                "anyOf": [
                  {
                    "description": "可以为响应生成的token数量的上限，包括可见输出token和[推理token](https://platform.openai.com/docs/guides/reasoning)。",
                    "type": "integer",
                    "title": "integer"
                  },
                  {
                    "type": "null",
                    "title": "null"
                  }
                ]
              }
            },
            "required": [
              "id",
              "object",
              "created_at",
              "error",
              "incomplete_details",
              "instructions",
              "model",
              "tools",
              "output",
              "parallel_tool_calls",
              "metadata",
              "tool_choice",
              "temperature",
              "top_p"
            ]
          }
        ],
        "example": {
          "id": "resp_123",
          "object": "response",
          "created_at": 1741476777,
          "status": "completed",
          "error": null,
          "incomplete_details": null,
          "instructions": null,
          "model": "model-name",
          "output": [
            {
              "type": "message",
              "id": "msg_123",
              "status": "completed",
              "role": "assistant",
              "content": [
                {
                  "type": "output_text",
                  "text": "Hi! How can I help?",
                  "annotations": []
                }
              ]
            }
          ],
          "parallel_tool_calls": true,
          "temperature": 1,
          "tool_choice": "auto",
          "tools": [],
          "top_p": 1,
          "metadata": {}
        }
      },
      "ResponseStreamEvent": {
        "anyOf": [
          {
            "$ref": "#/components/schemas/ResponseAudioDeltaEvent"
          },
          {
            "$ref": "#/components/schemas/ResponseAudioDoneEvent"
          },
          {
            "$ref": "#/components/schemas/ResponseAudioTranscriptDeltaEvent"
          },
          {
            "$ref": "#/components/schemas/ResponseAudioTranscriptDoneEvent"
          },
          {
            "$ref": "#/components/schemas/ResponseCodeInterpreterCallCodeDeltaEvent"
          },
          {
            "$ref": "#/components/schemas/ResponseCodeInterpreterCallCodeDoneEvent"
          },
          {
            "$ref": "#/components/schemas/ResponseCodeInterpreterCallCompletedEvent"
          },
          {
            "$ref": "#/components/schemas/ResponseCodeInterpreterCallInProgressEvent"
          },
          {
            "$ref": "#/components/schemas/ResponseCodeInterpreterCallInterpretingEvent"
          },
          {
            "$ref": "#/components/schemas/ResponseCompletedEvent"
          },
          {
            "$ref": "#/components/schemas/ResponseContentPartAddedEvent"
          },
          {
            "$ref": "#/components/schemas/ResponseContentPartDoneEvent"
          },
          {
            "$ref": "#/components/schemas/ResponseCreatedEvent"
          },
          {
            "$ref": "#/components/schemas/ResponseErrorEvent"
          },
          {
            "$ref": "#/components/schemas/ResponseFileSearchCallCompletedEvent"
          },
          {
            "$ref": "#/components/schemas/ResponseFileSearchCallInProgressEvent"
          },
          {
            "$ref": "#/components/schemas/ResponseFileSearchCallSearchingEvent"
          },
          {
            "$ref": "#/components/schemas/ResponseFunctionCallArgumentsDeltaEvent"
          },
          {
            "$ref": "#/components/schemas/ResponseFunctionCallArgumentsDoneEvent"
          },
          {
            "$ref": "#/components/schemas/ResponseInProgressEvent"
          },
          {
            "$ref": "#/components/schemas/ResponseFailedEvent"
          },
          {
            "$ref": "#/components/schemas/ResponseIncompleteEvent"
          },
          {
            "$ref": "#/components/schemas/ResponseOutputItemAddedEvent"
          },
          {
            "$ref": "#/components/schemas/ResponseOutputItemDoneEvent"
          },
          {
            "$ref": "#/components/schemas/ResponseReasoningSummaryPartAddedEvent"
          },
          {
            "$ref": "#/components/schemas/ResponseReasoningSummaryPartDoneEvent"
          },
          {
            "$ref": "#/components/schemas/ResponseReasoningSummaryTextDeltaEvent"
          },
          {
            "$ref": "#/components/schemas/ResponseReasoningSummaryTextDoneEvent"
          },
          {
            "$ref": "#/components/schemas/ResponseReasoningTextDeltaEvent"
          },
          {
            "$ref": "#/components/schemas/ResponseReasoningTextDoneEvent"
          },
          {
            "$ref": "#/components/schemas/ResponseRefusalDeltaEvent"
          },
          {
            "$ref": "#/components/schemas/ResponseRefusalDoneEvent"
          },
          {
            "$ref": "#/components/schemas/ResponseTextDeltaEvent"
          },
          {
            "$ref": "#/components/schemas/ResponseTextDoneEvent"
          },
          {
            "$ref": "#/components/schemas/ResponseWebSearchCallCompletedEvent"
          },
          {
            "$ref": "#/components/schemas/ResponseWebSearchCallInProgressEvent"
          },
          {
            "$ref": "#/components/schemas/ResponseWebSearchCallSearchingEvent"
          },
          {
            "$ref": "#/components/schemas/ResponseImageGenCallCompletedEvent"
          },
          {
            "$ref": "#/components/schemas/ResponseImageGenCallGeneratingEvent"
          },
          {
            "$ref": "#/components/schemas/ResponseImageGenCallInProgressEvent"
          },
          {
            "$ref": "#/components/schemas/ResponseImageGenCallPartialImageEvent"
          },
          {
            "$ref": "#/components/schemas/ResponseMCPCallArgumentsDeltaEvent"
          },
          {
            "$ref": "#/components/schemas/ResponseMCPCallArgumentsDoneEvent"
          },
          {
            "$ref": "#/components/schemas/ResponseMCPCallCompletedEvent"
          },
          {
            "$ref": "#/components/schemas/ResponseMCPCallFailedEvent"
          },
          {
            "$ref": "#/components/schemas/ResponseMCPCallInProgressEvent"
          },
          {
            "$ref": "#/components/schemas/ResponseMCPListToolsCompletedEvent"
          },
          {
            "$ref": "#/components/schemas/ResponseMCPListToolsFailedEvent"
          },
          {
            "$ref": "#/components/schemas/ResponseMCPListToolsInProgressEvent"
          },
          {
            "$ref": "#/components/schemas/ResponseOutputTextAnnotationAddedEvent"
          },
          {
            "$ref": "#/components/schemas/ResponseQueuedEvent"
          },
          {
            "$ref": "#/components/schemas/ResponseCustomToolCallInputDeltaEvent"
          },
          {
            "$ref": "#/components/schemas/ResponseCustomToolCallInputDoneEvent"
          }
        ],
        "discriminator": {
          "propertyName": "type"
        }
      },
      "ErrorResponse": {
        "type": "object",
        "properties": {
          "error": {
            "$ref": "#/components/schemas/Error"
          }
        },
        "required": [
          "error"
        ]
      },
      "IncludeEnum": {
        "type": "string",
        "enum": [
          "file_search_call.results",
          "web_search_call.results",
          "web_search_call.action.sources",
          "message.input_image.image_url",
          "computer_call_output.output.image_url",
          "code_interpreter_call.outputs",
          "reasoning.encrypted_content",
          "message.output_text.logprobs"
        ],
        "description": "指定要包含在模型响应中的附加输出数据。目前支持的值为：\n- `web_search_call.results`：包含网络搜索工具调用的搜索结果。\n- `web_search_call.action.sources`：包括网络搜索工具调用的来源。\n- `code_interpreter_call.outputs`：包括代码解释器工具调用项中Python代码执行的输出。\n- `computer_call_output.output.image_url`：包括计算机调用输出中的图像 URL。\n- `file_search_call.results`：包含文件搜索工具调用的搜索结果。\n- `message.input_image.image_url`：包含输入消息中的图像 URL。\n- `message.output_text.logprobs`：包括带有辅助消息的 logprobs。\n- `reasoning.encrypted_content`：在推理项输出中包含推理token的加密版本。这使得在无状态使用 Responses API 时可以在多轮对话中使用推理项（例如当 `store` 参数设置为 `false` 时，或者当组织注册零数据保留计划时）。"
      },
      "Error": {
        "type": "object",
        "properties": {
          "code": {
            "anyOf": [
              {
                "type": "string",
                "title": "string"
              },
              {
                "type": "null",
                "title": "null"
              }
            ]
          },
          "message": {
            "type": "string"
          },
          "param": {
            "anyOf": [
              {
                "type": "string",
                "title": "string"
              },
              {
                "type": "null",
                "title": "null"
              }
            ]
          },
          "type": {
            "type": "string"
          }
        },
        "required": [
          "type",
          "message",
          "param",
          "code"
        ]
      },
      "TokenCountsBody": {
        "properties": {
          "model": {
            "anyOf": [
              {
                "type": "string",
                "description": "用于生成响应的模型ID，例如`gpt-4o`或`o3`。 OpenAI 提供各种具有不同功能、性能特征和价位的模型。请参阅[型号指南](https://platform.openai.com/docs/models) 浏览和比较可用型号。",
                "title": "string"
              },
              {
                "type": "null",
                "title": "null"
              }
            ]
          },
          "input": {
            "anyOf": [
              {
                "oneOf": [
                  {
                    "type": "string",
                    "maxLength": 10485760,
                    "description": "模型的文本输入，相当于具有`user`角色的文本输入。",
                    "title": "string"
                  },
                  {
                    "items": {
                      "$ref": "#/components/schemas/InputItem"
                    },
                    "type": "array",
                    "description": "模型的一个或多个输入项的列表，包含不同的内容类型。",
                    "title": "array"
                  }
                ],
                "description": "模型的文本、图像或文件输入，用于生成响应"
              },
              {
                "type": "null",
                "title": "null"
              }
            ]
          },
          "previous_response_id": {
            "anyOf": [
              {
                "type": "string",
                "description": "先前对模型的响应的唯一 ID。用它来创建多轮对话。详细了解[对话状态](https://platform.openai.com/docs/guides/conversation-state)。不能与 `conversation` 一起使用。",
                "example": "resp_123",
                "title": "string"
              },
              {
                "type": "null",
                "title": "null"
              }
            ]
          },
          "tools": {
            "anyOf": [
              {
                "items": {
                  "$ref": "#/components/schemas/Tool"
                },
                "type": "array",
                "description": "模型在生成响应时可以调用的一系列工具。您可以通过设置 `tool_choice` 参数来指定要使用的工具。",
                "title": "array"
              },
              {
                "type": "null",
                "title": "null"
              }
            ]
          },
          "text": {
            "anyOf": [
              {
                "$ref": "#/components/schemas/ResponseTextParam"
              },
              {
                "type": "null",
                "title": "null"
              }
            ]
          },
          "reasoning": {
            "anyOf": [
              {
                "$ref": "#/components/schemas/Reasoning",
                "description": "**仅限 gpt-5 和 o 系列型号** [推理模型](https://platform.openai.com/docs/guides/reasoning) 的配置选项。"
              },
              {
                "type": "null",
                "title": "null"
              }
            ]
          },
          "truncation": {
            "$ref": "#/components/schemas/TruncationEnum",
            "description": "用于模型响应的截断策略。 - `auto`：如果此响应的输入超出模型的上下文窗口大小，模型将通过从对话开头删除项目来截断响应以适合上下文窗口。 - `disabled`（默认）：如果输入大小超出模型的上下文窗口大小，请求将失败并出现 400 错误。"
          },
          "instructions": {
            "anyOf": [
              {
                "type": "string",
                "description": "插入模型上下文的系统（或开发人员）消息。\n当与 `previous_response_id` 一起使用时，上一个响应中的指令将不会转移到下一个响应中。这使得在新响应中交换系统（或开发人员）消息变得简单。",
                "title": "string"
              },
              {
                "type": "null",
                "title": "null"
              }
            ]
          },
          "conversation": {
            "anyOf": [
              {
                "$ref": "#/components/schemas/ConversationParam"
              },
              {
                "type": "null",
                "title": "null"
              }
            ]
          },
          "tool_choice": {
            "anyOf": [
              {
                "$ref": "#/components/schemas/ToolChoiceParam",
                "description": "控制模型应使用哪个工具（如果有）。"
              },
              {
                "type": "null",
                "title": "null"
              }
            ]
          },
          "parallel_tool_calls": {
            "anyOf": [
              {
                "type": "boolean",
                "description": "是否允许模型并行运行工具调用。",
                "title": "boolean"
              },
              {
                "type": "null",
                "title": "null"
              }
            ]
          }
        },
        "type": "object",
        "required": []
      },
      "TokenCountsResource": {
        "properties": {
          "object": {
            "type": "string",
            "enum": [
              "response.input_tokens"
            ],
            "default": "response.input_tokens",
            "x-stainless-const": true
          },
          "input_tokens": {
            "type": "integer"
          }
        },
        "type": "object",
        "required": [
          "object",
          "input_tokens"
        ],
        "title": "token计数",
        "example": {
          "object": "response.input_tokens",
          "input_tokens": 123
        }
      },
      "CompactResponseMethodPublicBody": {
        "properties": {
          "model": {
            "$ref": "#/components/schemas/ModelIdsCompaction"
          },
          "input": {
            "anyOf": [
              {
                "oneOf": [
                  {
                    "type": "string",
                    "maxLength": 10485760,
                    "description": "模型的文本输入，相当于具有`user`角色的文本输入。",
                    "title": "string"
                  },
                  {
                    "items": {
                      "$ref": "#/components/schemas/InputItem"
                    },
                    "type": "array",
                    "description": "模型的一个或多个输入项的列表，包含不同的内容类型。",
                    "title": "array"
                  }
                ],
                "description": "模型的文本、图像或文件输入，用于生成响应"
              },
              {
                "type": "null",
                "title": "null"
              }
            ]
          },
          "previous_response_id": {
            "anyOf": [
              {
                "type": "string",
                "description": "先前对模型的响应的唯一 ID。用它来创建多轮对话。详细了解[对话状态](https://platform.openai.com/docs/guides/conversation-state)。不能与 `conversation` 一起使用。",
                "example": "resp_123",
                "title": "string"
              },
              {
                "type": "null",
                "title": "null"
              }
            ]
          },
          "instructions": {
            "anyOf": [
              {
                "type": "string",
                "description": "插入模型上下文的系统（或开发人员）消息。\n当与 `previous_response_id` 一起使用时，上一个响应中的指令将不会转移到下一个响应中。这使得在新响应中交换系统（或开发人员）消息变得简单。",
                "title": "string"
              },
              {
                "type": "null",
                "title": "null"
              }
            ]
          },
          "prompt_cache_key": {
            "anyOf": [
              {
                "type": "string",
                "maxLength": 64,
                "description": "读取或写入提示缓存时使用的键。",
                "title": "string"
              },
              {
                "type": "null",
                "title": "null"
              }
            ]
          },
          "prompt_cache_retention": {
            "anyOf": [
              {
                "$ref": "#/components/schemas/PromptCacheRetentionEnum",
                "description": "该请求创建的提示缓存条目保留多长时间。"
              },
              {
                "type": "null",
                "title": "null"
              }
            ]
          },
          "service_tier": {
            "anyOf": [
              {
                "$ref": "#/components/schemas/ServiceTierEnum",
                "description": "用于此请求的服务层。"
              },
              {
                "type": "null",
                "title": "null"
              }
            ]
          }
        },
        "type": "object",
        "required": [
          "model"
        ]
      },
      "CompactResource": {
        "properties": {
          "id": {
            "type": "string",
            "description": "压缩响应的唯一标识符。"
          },
          "object": {
            "type": "string",
            "enum": [
              "response.compaction"
            ],
            "description": "对象类型。始终 `response.compaction`。",
            "default": "response.compaction",
            "x-stainless-const": true
          },
          "output": {
            "items": {
              "$ref": "#/components/schemas/ItemField"
            },
            "type": "array",
            "description": "输出项目的压缩列表。"
          },
          "created_at": {
            "type": "integer",
            "format": "unixtime",
            "description": "创建压缩对话时的 Unix 时间戳（以秒为单位）。"
          },
          "usage": {
            "$ref": "#/components/schemas/ResponseUsage",
            "description": "压缩过程的token统计，包括缓存、推理和总token。"
          }
        },
        "type": "object",
        "required": [
          "id",
          "object",
          "output",
          "created_at",
          "usage"
        ],
        "title": "压缩响应对象",
        "example": {
          "id": "cmp_123",
          "object": "response.compaction",
          "output": [
            {
              "type": "message",
              "role": "user",
              "content": [
                {
                  "type": "input_text",
                  "text": "Summarize our plan."
                }
              ]
            },
            {
              "type": "compaction",
              "id": "cmp_item_123",
              "encrypted_content": "encrypted_content"
            }
          ],
          "created_at": 1731459200,
          "usage": {
            "input_tokens": 1200,
            "input_tokens_details": {
              "cached_tokens": 0
            },
            "output_tokens": 300,
            "output_tokens_details": {
              "reasoning_tokens": 0
            },
            "total_tokens": 1500
          }
        }
      },
      "CreateModelResponseProperties": {
        "allOf": [
          {
            "$ref": "#/components/schemas/ModelResponseProperties"
          },
          {
            "type": "object",
            "properties": {
              "top_logprobs": {
                "description": "0 到 20 之间的整数，指定最有可能的最大数量\n在每个token位置返回的token，每个token都有一个关联的日志\n概率。在某些情况下，返回的token数量可能少于\n要求。",
                "type": "integer",
                "minimum": 0,
                "maximum": 20
              }
            }
          }
        ]
      },
      "ResponseProperties": {
        "type": "object",
        "properties": {
          "previous_response_id": {
            "anyOf": [
              {
                "type": "string",
                "description": "先前对模型的响应的唯一 ID。用这个来\n创建多轮对话。了解更多关于\n[对话状态](https://platform.openai.com/docs/guides/conversation-state)。不能与 `conversation` 一起使用。",
                "title": "string"
              },
              {
                "type": "null",
                "title": "null"
              }
            ]
          },
          "model": {
            "description": "用于生成响应的模型 ID，例如 `gpt-4o` 或 `o3`。开放人工智能\n提供具有不同功能、性能的多种型号\n特点和价格点。请参阅[型号指南](https://platform.openai.com/docs/models)\n浏览并比较可用型号。",
            "$ref": "#/components/schemas/ModelIdsResponses"
          },
          "reasoning": {
            "anyOf": [
              {
                "$ref": "#/components/schemas/Reasoning"
              },
              {
                "type": "null",
                "title": "null"
              }
            ]
          },
          "background": {
            "anyOf": [
              {
                "type": "boolean",
                "description": "是否在后台运行模型响应。\n[了解更多](https://platform.openai.com/docs/guides/background)。",
                "default": false,
                "title": "boolean"
              },
              {
                "type": "null",
                "title": "null"
              }
            ]
          },
          "max_tool_calls": {
            "anyOf": [
              {
                "description": "响应中可处理的对内置工具的最大调用总数。此最大数量适用于所有内置工具调用，而不适用于每个单独的工具。模型调用工具的任何进一步尝试都将被忽略。",
                "type": "integer",
                "title": "integer"
              },
              {
                "type": "null",
                "title": "null"
              }
            ]
          },
          "text": {
            "$ref": "#/components/schemas/ResponseTextParam"
          },
          "tools": {
            "$ref": "#/components/schemas/ToolsArray"
          },
          "tool_choice": {
            "$ref": "#/components/schemas/ToolChoiceParam"
          },
          "prompt": {
            "$ref": "#/components/schemas/Prompt"
          },
          "truncation": {
            "anyOf": [
              {
                "type": "string",
                "description": "用于模型响应的截断策略。\n- `auto`：如果此响应的输入超过\n  模型的上下文窗口大小，模型将截断\n  通过从对话开头删除项目来响应以适应上下文窗口。\n- `disabled`（默认）：如果输入大小将超出上下文窗口\n  如果模型的大小，请求将失败并出现 400 错误。",
                "enum": [
                  "auto",
                  "disabled"
                ],
                "default": "disabled",
                "title": "string"
              },
              {
                "type": "null",
                "title": "null"
              }
            ]
          }
        }
      },
      "InputParam": {
        "description": "模型的文本、图像或文件输入，用于生成响应。\n\n了解更多：\n- [文本输入和输出](https://platform.openai.com/docs/guides/text)\n- [图像输入](https://platform.openai.com/docs/guides/images)\n- [文件输入](https://platform.openai.com/docs/guides/pdf-files)\n- [对话状态](https://platform.openai.com/docs/guides/conversation-state)\n- [函数调用](https://platform.openai.com/docs/guides/function-calling)",
        "oneOf": [
          {
            "type": "string",
            "title": "文字输入",
            "description": "模型的文本输入，相当于文本输入\n`user` 角色。"
          },
          {
            "type": "array",
            "title": "输入项目列表",
            "description": "模型的一个或多个输入项的列表，包含\n不同的内容类型。",
            "items": {
              "$ref": "#/components/schemas/InputItem"
            }
          }
        ]
      },
      "ResponseStreamOptions": {
        "anyOf": [
          {
            "description": "流响应选项。仅当设置 `stream: true` 时才设置此项。",
            "type": "object",
            "default": null,
            "properties": {
              "include_obfuscation": {
                "type": "boolean",
                "description": "当为真时，将启用流混淆。流混淆添加\n将增量事件流式传输到 `obfuscation` 字段的随机字符\n规范有效负载大小以缓解某些旁道攻击。\n默认包含这些混淆字段，但添加少量\n数据流的开销。您可以将 `include_obfuscation` 设置为\n如果您信任之间的网络链接，则为 false 以优化带宽\n您的应用程序和 OpenAI API。"
              }
            },
            "title": "object"
          },
          {
            "type": "null",
            "title": "null"
          }
        ]
      },
      "ConversationParam": {
        "description": "该响应所属的会话。对于此响应请求，此对话中的项目将添加到 `input_items` 前面。\n此响应完成后，此响应的输入项和输出项将自动添加到此对话中。",
        "default": null,
        "oneOf": [
          {
            "type": "string",
            "title": "对话ID",
            "description": "会话的唯一ID。"
          },
          {
            "$ref": "#/components/schemas/ConversationParam-2"
          }
        ]
      },
      "ContextManagementParam": {
        "properties": {
          "type": {
            "type": "string",
            "description": "上下文管理条目类型。目前仅支持 'compaction'。"
          },
          "compact_threshold": {
            "anyOf": [
              {
                "type": "integer",
                "minimum": 1000,
                "description": "应该为此条目触发压缩的token阈值。",
                "title": "integer"
              },
              {
                "type": "null",
                "title": "null"
              }
            ]
          }
        },
        "type": "object",
        "required": [
          "type"
        ]
      },
      "ModelResponseProperties": {
        "type": "object",
        "properties": {
          "metadata": {
            "$ref": "#/components/schemas/Metadata"
          },
          "top_logprobs": {
            "anyOf": [
              {
                "description": "0 到 20 之间的整数，指定最有可能的最大数量\n在每个token位置返回的token，每个token都有一个关联的日志\n概率。在某些情况下，返回的token数量可能少于\n要求。",
                "type": "integer",
                "minimum": 0,
                "maximum": 20,
                "title": "integer"
              },
              {
                "type": "null",
                "title": "null"
              }
            ]
          },
          "temperature": {
            "anyOf": [
              {
                "type": "number",
                "minimum": 0,
                "maximum": 2,
                "default": 1,
                "example": 1,
                "description": "使用什么采样温度，介于 0 和 2 之间。较高的值（如 0.8）将使输出更加随机，而较低的值（如 0.2）将使其更加集中和确定性。\n我们通常建议更改此值或 `top_p` 但不能同时更改两者。",
                "title": "number"
              },
              {
                "type": "null",
                "title": "null"
              }
            ]
          },
          "top_p": {
            "anyOf": [
              {
                "type": "number",
                "minimum": 0,
                "maximum": 1,
                "default": 1,
                "example": 1,
                "description": "温度采样的替代方案，称为核采样，\n其中模型考虑具有 top_p 概率的标记结果\n质量。因此 0.1 表示仅包含前 10% 概率质量的标记\n被考虑。\n\n我们通常建议更改此值或 `temperature` 但不能同时更改两者。",
                "title": "number"
              },
              {
                "type": "null",
                "title": "null"
              }
            ]
          },
          "user": {
            "type": "string",
            "example": "user-1234",
            "deprecated": true,
            "description": "该字段正在被 `safety_identifier` 和 `prompt_cache_key` 取代。请改用 `prompt_cache_key` 来维护缓存优化。\n最终用户的稳定标识符。\n用于通过更好地存储类似请求来提高缓存命中率，并帮助 OpenAI 检测和防止滥用。 [了解更多](https://platform.openai.com/docs/guides/safety-best-practices#safety-identifiers)。"
          },
          "safety_identifier": {
            "type": "string",
            "maxLength": 64,
            "example": "safety-identifier-1234",
            "description": "一个稳定的标识符，用于帮助检测可能违反 OpenAI 使用政策的应用程序用户。\nID 应该是唯一标识每个用户的字符串，最大长度为 64 个字符。我们建议对他们的用户名或电子邮件地址进行哈希处理，以避免向我们发送任何身份信息。 [了解更多](https://platform.openai.com/docs/guides/safety-best-practices#safety-identifiers)。"
          },
          "prompt_cache_key": {
            "type": "string",
            "example": "prompt-cache-key-1234",
            "description": "由 OpenAI 用于缓存类似请求的响应，以优化缓存命中率。替换 `user` 字段。 [了解更多](https://platform.openai.com/docs/guides/prompt-caching)。"
          },
          "service_tier": {
            "$ref": "#/components/schemas/ServiceTier"
          },
          "prompt_cache_retention": {
            "anyOf": [
              {
                "type": "string",
                "enum": [
                  "in_memory",
                  "24h"
                ],
                "description": "提示缓存的保留策略。设置为 `24h` 可启用扩展提示缓存，从而使缓存的前缀保持活动状态更长时间，最长可达 24 小时。 [了解更多](https://platform.openai.com/docs/guides/prompt-caching#prompt-cache-retention)。",
                "title": "string"
              },
              {
                "type": "null",
                "title": "null"
              }
            ]
          }
        }
      },
      "ResponseError": {
        "anyOf": [
          {
            "type": "object",
            "description": "模型无法生成响应时返回的错误对象。",
            "properties": {
              "code": {
                "$ref": "#/components/schemas/ResponseErrorCode"
              },
              "message": {
                "type": "string",
                "description": "人类可读的错误描述。"
              }
            },
            "required": [
              "code",
              "message"
            ],
            "title": "object"
          },
          {
            "type": "null",
            "title": "null"
          }
        ]
      },
      "OutputItem": {
        "oneOf": [
          {
            "$ref": "#/components/schemas/OutputMessage"
          },
          {
            "$ref": "#/components/schemas/FileSearchToolCall"
          },
          {
            "$ref": "#/components/schemas/FunctionToolCall"
          },
          {
            "$ref": "#/components/schemas/FunctionToolCallOutputResource"
          },
          {
            "$ref": "#/components/schemas/WebSearchToolCall"
          },
          {
            "$ref": "#/components/schemas/ComputerToolCall"
          },
          {
            "$ref": "#/components/schemas/ComputerToolCallOutputResource"
          },
          {
            "$ref": "#/components/schemas/ReasoningItem"
          },
          {
            "$ref": "#/components/schemas/ToolSearchCall"
          },
          {
            "$ref": "#/components/schemas/ToolSearchOutput"
          },
          {
            "$ref": "#/components/schemas/CompactionBody"
          },
          {
            "$ref": "#/components/schemas/ImageGenToolCall"
          },
          {
            "$ref": "#/components/schemas/CodeInterpreterToolCall"
          },
          {
            "$ref": "#/components/schemas/LocalShellToolCall"
          },
          {
            "$ref": "#/components/schemas/LocalShellToolCallOutput"
          },
          {
            "$ref": "#/components/schemas/FunctionShellCall"
          },
          {
            "$ref": "#/components/schemas/FunctionShellCallOutput"
          },
          {
            "$ref": "#/components/schemas/ApplyPatchToolCall"
          },
          {
            "$ref": "#/components/schemas/ApplyPatchToolCallOutput"
          },
          {
            "$ref": "#/components/schemas/MCPToolCall"
          },
          {
            "$ref": "#/components/schemas/MCPListTools"
          },
          {
            "$ref": "#/components/schemas/MCPApprovalRequest"
          },
          {
            "$ref": "#/components/schemas/MCPApprovalResponseResource"
          },
          {
            "$ref": "#/components/schemas/CustomToolCall"
          },
          {
            "$ref": "#/components/schemas/CustomToolCallOutputResource"
          }
        ],
        "discriminator": {
          "propertyName": "type"
        }
      },
      "InputItem": {
        "oneOf": [
          {
            "$ref": "#/components/schemas/EasyInputMessage"
          },
          {
            "type": "object",
            "title": "物品",
            "description": "代表响应的上下文的一部分的项目\n由模型生成。可以包含文本、图像和音频输入，\n以及之前的助理响应和工具调用输出。",
            "$ref": "#/components/schemas/Item"
          },
          {
            "$ref": "#/components/schemas/ItemReferenceParam"
          }
        ],
        "discriminator": {
          "propertyName": "type"
        }
      },
      "ResponseUsage": {
        "type": "object",
        "description": "表示token使用详细信息，包括输入token、输出token、\n输出token的明细以及使用的token总数。",
        "properties": {
          "input_tokens": {
            "type": "integer",
            "description": "输入token的数量。"
          },
          "input_tokens_details": {
            "type": "object",
            "description": "输入token的详细分类。",
            "properties": {
              "cached_tokens": {
                "type": "integer",
                "description": "从缓存中检索到的token数量。 \n[有关提示缓存的更多信息](https://platform.openai.com/docs/guides/prompt-caching)。"
              }
            },
            "required": [
              "cached_tokens"
            ]
          },
          "output_tokens": {
            "type": "integer",
            "description": "输出token的数量。"
          },
          "output_tokens_details": {
            "type": "object",
            "description": "输出token的详细分类。",
            "properties": {
              "reasoning_tokens": {
                "type": "integer",
                "description": "推理token的数量。"
              }
            },
            "required": [
              "reasoning_tokens"
            ]
          },
          "total_tokens": {
            "type": "integer",
            "description": "使用的token总数。"
          }
        },
        "required": [
          "input_tokens",
          "input_tokens_details",
          "output_tokens",
          "output_tokens_details",
          "total_tokens"
        ]
      },
      "Conversation-2": {
        "properties": {
          "id": {
            "type": "string",
            "description": "与此响应相关联的对话的唯一 ID。"
          }
        },
        "type": "object",
        "required": [
          "id"
        ],
        "title": "对话",
        "description": "该响应所属的会话。此响应的输入项和输出项会自动添加到此对话中。"
      },
      "ResponseAudioDeltaEvent": {
        "type": "object",
        "description": "当存在部分音频响应时发出。",
        "properties": {
          "type": {
            "type": "string",
            "description": "事件的类型。始终 `response.audio.delta`。",
            "enum": [
              "response.audio.delta"
            ],
            "x-stainless-const": true
          },
          "sequence_number": {
            "type": "integer",
            "description": "该流响应块的序列号。"
          },
          "delta": {
            "type": "string",
            "description": "Base64 编码响应音频字节块。"
          }
        },
        "required": [
          "type",
          "delta",
          "sequence_number"
        ]
      },
      "ResponseAudioDoneEvent": {
        "type": "object",
        "description": "当音频响应完成时发出。",
        "properties": {
          "type": {
            "type": "string",
            "description": "事件的类型。始终 `response.audio.done`。",
            "enum": [
              "response.audio.done"
            ],
            "x-stainless-const": true
          },
          "sequence_number": {
            "type": "integer",
            "description": "增量的序列号。"
          }
        },
        "required": [
          "type",
          "sequence_number",
          "response_id"
        ]
      },
      "ResponseAudioTranscriptDeltaEvent": {
        "type": "object",
        "description": "当存在部分音频转录时发出。",
        "properties": {
          "type": {
            "type": "string",
            "description": "事件的类型。始终 `response.audio.transcript.delta`。",
            "enum": [
              "response.audio.transcript.delta"
            ],
            "x-stainless-const": true
          },
          "delta": {
            "type": "string",
            "description": "音频响应的部分记录。"
          },
          "sequence_number": {
            "type": "integer",
            "description": "该事件的序列号。"
          }
        },
        "required": [
          "type",
          "response_id",
          "delta",
          "sequence_number"
        ]
      },
      "ResponseAudioTranscriptDoneEvent": {
        "type": "object",
        "description": "当完整的音频转录完成时发出。",
        "properties": {
          "type": {
            "type": "string",
            "description": "事件的类型。始终 `response.audio.transcript.done`。",
            "enum": [
              "response.audio.transcript.done"
            ],
            "x-stainless-const": true
          },
          "sequence_number": {
            "type": "integer",
            "description": "该事件的序列号。"
          }
        },
        "required": [
          "type",
          "response_id",
          "sequence_number"
        ]
      },
      "ResponseCodeInterpreterCallCodeDeltaEvent": {
        "type": "object",
        "description": "当代码解释器流式传输部分代码片段时发出。",
        "properties": {
          "type": {
            "type": "string",
            "description": "事件的类型。始终 `response.code_interpreter_call_code.delta`。",
            "enum": [
              "response.code_interpreter_call_code.delta"
            ],
            "x-stainless-const": true
          },
          "output_index": {
            "type": "integer",
            "description": "正在为其流式传输代码的响应中的输出项的索引。"
          },
          "item_id": {
            "type": "string",
            "description": "代码解释工具调用项的唯一标识。"
          },
          "delta": {
            "type": "string",
            "description": "由代码解释器流式传输的部分代码片段。"
          },
          "sequence_number": {
            "type": "integer",
            "description": "该事件的序列号，用于对流事件进行排序。"
          }
        },
        "required": [
          "type",
          "output_index",
          "item_id",
          "delta",
          "sequence_number"
        ]
      },
      "ResponseCodeInterpreterCallCodeDoneEvent": {
        "type": "object",
        "description": "当代码片段被代码解释器最终确定时发出。",
        "properties": {
          "type": {
            "type": "string",
            "description": "事件的类型。始终 `response.code_interpreter_call_code.done`。",
            "enum": [
              "response.code_interpreter_call_code.done"
            ],
            "x-stainless-const": true
          },
          "output_index": {
            "type": "integer",
            "description": "代码最终确定的响应中的输出项的索引。"
          },
          "item_id": {
            "type": "string",
            "description": "代码解释工具调用项的唯一标识。"
          },
          "code": {
            "type": "string",
            "description": "代码解释器输出的最终代码片段。"
          },
          "sequence_number": {
            "type": "integer",
            "description": "该事件的序列号，用于对流事件进行排序。"
          }
        },
        "required": [
          "type",
          "output_index",
          "item_id",
          "code",
          "sequence_number"
        ]
      },
      "ResponseCodeInterpreterCallCompletedEvent": {
        "type": "object",
        "description": "当代码解释器调用完成时发出。",
        "properties": {
          "type": {
            "type": "string",
            "description": "事件的类型。始终 `response.code_interpreter_call.completed`。",
            "enum": [
              "response.code_interpreter_call.completed"
            ],
            "x-stainless-const": true
          },
          "output_index": {
            "type": "integer",
            "description": "代码解释器调用完成的响应中的输出项的索引。"
          },
          "item_id": {
            "type": "string",
            "description": "代码解释工具调用项的唯一标识。"
          },
          "sequence_number": {
            "type": "integer",
            "description": "该事件的序列号，用于对流事件进行排序。"
          }
        },
        "required": [
          "type",
          "output_index",
          "item_id",
          "sequence_number"
        ]
      },
      "ResponseCodeInterpreterCallInProgressEvent": {
        "type": "object",
        "description": "当代码解释器调用正在进行时发出。",
        "properties": {
          "type": {
            "type": "string",
            "description": "事件的类型。始终 `response.code_interpreter_call.in_progress`。",
            "enum": [
              "response.code_interpreter_call.in_progress"
            ],
            "x-stainless-const": true
          },
          "output_index": {
            "type": "integer",
            "description": "代码解释器调用正在进行的响应中的输出项的索引。"
          },
          "item_id": {
            "type": "string",
            "description": "代码解释工具调用项的唯一标识。"
          },
          "sequence_number": {
            "type": "integer",
            "description": "该事件的序列号，用于对流事件进行排序。"
          }
        },
        "required": [
          "type",
          "output_index",
          "item_id",
          "sequence_number"
        ]
      },
      "ResponseCodeInterpreterCallInterpretingEvent": {
        "type": "object",
        "description": "当代码解释器正在主动解释代码片段时发出。",
        "properties": {
          "type": {
            "type": "string",
            "description": "事件的类型。始终 `response.code_interpreter_call.interpreting`。",
            "enum": [
              "response.code_interpreter_call.interpreting"
            ],
            "x-stainless-const": true
          },
          "output_index": {
            "type": "integer",
            "description": "代码解释器正在解释代码的响应中的输出项的索引。"
          },
          "item_id": {
            "type": "string",
            "description": "代码解释工具调用项的唯一标识。"
          },
          "sequence_number": {
            "type": "integer",
            "description": "该事件的序列号，用于对流事件进行排序。"
          }
        },
        "required": [
          "type",
          "output_index",
          "item_id",
          "sequence_number"
        ]
      },
      "ResponseCompletedEvent": {
        "type": "object",
        "description": "模型响应完成时发出。",
        "properties": {
          "type": {
            "type": "string",
            "description": "事件的类型。始终 `response.completed`。",
            "enum": [
              "response.completed"
            ],
            "x-stainless-const": true
          },
          "response": {
            "$ref": "#/components/schemas/Response",
            "description": "已完成的响应的属性。"
          },
          "sequence_number": {
            "type": "integer",
            "description": "该事件的序列号。"
          }
        },
        "required": [
          "type",
          "response",
          "sequence_number"
        ]
      },
      "ResponseContentPartAddedEvent": {
        "type": "object",
        "description": "当添加新的内容部分时发出。",
        "properties": {
          "type": {
            "type": "string",
            "description": "事件的类型。始终 `response.content_part.added`。",
            "enum": [
              "response.content_part.added"
            ],
            "x-stainless-const": true
          },
          "item_id": {
            "type": "string",
            "description": "添加了内容部分的输出项的ID。"
          },
          "output_index": {
            "type": "integer",
            "description": "添加了内容部分的输出项的索引。"
          },
          "content_index": {
            "type": "integer",
            "description": "添加的内容部分的索引。"
          },
          "part": {
            "$ref": "#/components/schemas/OutputContent",
            "description": "添加的内容部分。"
          },
          "sequence_number": {
            "type": "integer",
            "description": "该事件的序列号。"
          }
        },
        "required": [
          "type",
          "item_id",
          "output_index",
          "content_index",
          "part",
          "sequence_number"
        ]
      },
      "ResponseContentPartDoneEvent": {
        "type": "object",
        "description": "当内容部分完成时发出。",
        "properties": {
          "type": {
            "type": "string",
            "description": "事件的类型。始终 `response.content_part.done`。",
            "enum": [
              "response.content_part.done"
            ],
            "x-stainless-const": true
          },
          "item_id": {
            "type": "string",
            "description": "添加了内容部分的输出项的ID。"
          },
          "output_index": {
            "type": "integer",
            "description": "添加了内容部分的输出项的索引。"
          },
          "content_index": {
            "type": "integer",
            "description": "已完成的内容部分的索引。"
          },
          "sequence_number": {
            "type": "integer",
            "description": "该事件的序列号。"
          },
          "part": {
            "$ref": "#/components/schemas/OutputContent",
            "description": "已完成的内容部分。"
          }
        },
        "required": [
          "type",
          "item_id",
          "output_index",
          "content_index",
          "part",
          "sequence_number"
        ]
      },
      "ResponseCreatedEvent": {
        "type": "object",
        "description": "创建响应时发出的事件。",
        "properties": {
          "type": {
            "type": "string",
            "description": "事件的类型。始终 `response.created`。",
            "enum": [
              "response.created"
            ],
            "x-stainless-const": true
          },
          "response": {
            "$ref": "#/components/schemas/Response",
            "description": "创建的响应。"
          },
          "sequence_number": {
            "type": "integer",
            "description": "该事件的序列号。"
          }
        },
        "required": [
          "type",
          "response",
          "sequence_number"
        ]
      },
      "ResponseErrorEvent": {
        "type": "object",
        "description": "发生错误时发出。",
        "properties": {
          "type": {
            "type": "string",
            "description": "事件的类型。始终 `error`。",
            "enum": [
              "error"
            ],
            "x-stainless-const": true
          },
          "code": {
            "anyOf": [
              {
                "type": "string",
                "description": "错误代码。",
                "title": "string"
              },
              {
                "type": "null",
                "title": "null"
              }
            ]
          },
          "message": {
            "type": "string",
            "description": "错误消息。"
          },
          "param": {
            "anyOf": [
              {
                "type": "string",
                "description": "错误参数。",
                "title": "string"
              },
              {
                "type": "null",
                "title": "null"
              }
            ]
          },
          "sequence_number": {
            "type": "integer",
            "description": "该事件的序列号。"
          }
        },
        "required": [
          "type",
          "code",
          "message",
          "param",
          "sequence_number"
        ]
      },
      "ResponseFileSearchCallCompletedEvent": {
        "type": "object",
        "description": "当文件搜索调用完成（找到结果）时发出。",
        "properties": {
          "type": {
            "type": "string",
            "description": "事件的类型。始终 `response.file_search_call.completed`。",
            "enum": [
              "response.file_search_call.completed"
            ],
            "x-stainless-const": true
          },
          "output_index": {
            "type": "integer",
            "description": "发起文件搜索调用的输出项的索引。"
          },
          "item_id": {
            "type": "string",
            "description": "发起文件搜索调用的输出项的ID。"
          },
          "sequence_number": {
            "type": "integer",
            "description": "该事件的序列号。"
          }
        },
        "required": [
          "type",
          "output_index",
          "item_id",
          "sequence_number"
        ]
      },
      "ResponseFileSearchCallInProgressEvent": {
        "type": "object",
        "description": "当发起文件搜索调用时发出。",
        "properties": {
          "type": {
            "type": "string",
            "description": "事件的类型。始终 `response.file_search_call.in_progress`。",
            "enum": [
              "response.file_search_call.in_progress"
            ],
            "x-stainless-const": true
          },
          "output_index": {
            "type": "integer",
            "description": "发起文件搜索调用的输出项的索引。"
          },
          "item_id": {
            "type": "string",
            "description": "发起文件搜索调用的输出项的ID。"
          },
          "sequence_number": {
            "type": "integer",
            "description": "该事件的序列号。"
          }
        },
        "required": [
          "type",
          "output_index",
          "item_id",
          "sequence_number"
        ]
      },
      "ResponseFileSearchCallSearchingEvent": {
        "type": "object",
        "description": "当文件搜索当前正在搜索时发出。",
        "properties": {
          "type": {
            "type": "string",
            "description": "事件的类型。始终 `response.file_search_call.searching`。",
            "enum": [
              "response.file_search_call.searching"
            ],
            "x-stainless-const": true
          },
          "output_index": {
            "type": "integer",
            "description": "文件搜索调用正在搜索的输出项的索引。"
          },
          "item_id": {
            "type": "string",
            "description": "发起文件搜索调用的输出项的ID。"
          },
          "sequence_number": {
            "type": "integer",
            "description": "该事件的序列号。"
          }
        },
        "required": [
          "type",
          "output_index",
          "item_id",
          "sequence_number"
        ]
      },
      "ResponseFunctionCallArgumentsDeltaEvent": {
        "type": "object",
        "description": "当存在部分函数调用参数增量时发出。",
        "properties": {
          "type": {
            "type": "string",
            "description": "事件的类型。始终 `response.function_call_arguments.delta`。",
            "enum": [
              "response.function_call_arguments.delta"
            ],
            "x-stainless-const": true
          },
          "item_id": {
            "type": "string",
            "description": "添加了函数调用参数delta的输出项的ID。"
          },
          "output_index": {
            "type": "integer",
            "description": "添加了函数调用参数delta的输出项的索引。"
          },
          "sequence_number": {
            "type": "integer",
            "description": "该事件的序列号。"
          },
          "delta": {
            "type": "string",
            "description": "添加的函数调用参数增量。"
          }
        },
        "required": [
          "type",
          "item_id",
          "output_index",
          "delta",
          "sequence_number"
        ]
      },
      "ResponseFunctionCallArgumentsDoneEvent": {
        "type": "object",
        "description": "当函数调用参数完成时发出。",
        "properties": {
          "type": {
            "type": "string",
            "enum": [
              "response.function_call_arguments.done"
            ],
            "x-stainless-const": true
          },
          "item_id": {
            "type": "string",
            "description": "项目的ID。"
          },
          "name": {
            "type": "string",
            "description": "被调用的函数的名称。"
          },
          "output_index": {
            "type": "integer",
            "description": "输出项的索引。"
          },
          "sequence_number": {
            "type": "integer",
            "description": "该事件的序列号。"
          },
          "arguments": {
            "type": "string",
            "description": "函数调用参数。"
          }
        },
        "required": [
          "type",
          "item_id",
          "name",
          "output_index",
          "arguments",
          "sequence_number"
        ]
      },
      "ResponseInProgressEvent": {
        "type": "object",
        "description": "当响应正在进行时发出。",
        "properties": {
          "type": {
            "type": "string",
            "description": "事件的类型。始终 `response.in_progress`。",
            "enum": [
              "response.in_progress"
            ],
            "x-stainless-const": true
          },
          "response": {
            "$ref": "#/components/schemas/Response",
            "description": "正在进行的响应。"
          },
          "sequence_number": {
            "type": "integer",
            "description": "该事件的序列号。"
          }
        },
        "required": [
          "type",
          "response",
          "sequence_number"
        ]
      },
      "ResponseFailedEvent": {
        "type": "object",
        "description": "响应失败时发出的事件。",
        "properties": {
          "type": {
            "type": "string",
            "description": "事件的类型。始终 `response.failed`。",
            "enum": [
              "response.failed"
            ],
            "x-stainless-const": true
          },
          "sequence_number": {
            "type": "integer",
            "description": "该事件的序列号。"
          },
          "response": {
            "$ref": "#/components/schemas/Response",
            "description": "失败的响应。"
          }
        },
        "required": [
          "type",
          "response",
          "sequence_number"
        ]
      },
      "ResponseIncompleteEvent": {
        "type": "object",
        "description": "当响应未完成时发出的事件。",
        "properties": {
          "type": {
            "type": "string",
            "description": "事件的类型。始终 `response.incomplete`。",
            "enum": [
              "response.incomplete"
            ],
            "x-stainless-const": true
          },
          "response": {
            "$ref": "#/components/schemas/Response",
            "description": "响应不完整。"
          },
          "sequence_number": {
            "type": "integer",
            "description": "该事件的序列号。"
          }
        },
        "required": [
          "type",
          "response",
          "sequence_number"
        ]
      },
      "ResponseOutputItemAddedEvent": {
        "type": "object",
        "description": "添加新输出项时发出。",
        "properties": {
          "type": {
            "type": "string",
            "description": "事件的类型。始终 `response.output_item.added`。",
            "enum": [
              "response.output_item.added"
            ],
            "x-stainless-const": true
          },
          "output_index": {
            "type": "integer",
            "description": "已添加的输出项的索引。"
          },
          "sequence_number": {
            "type": "integer",
            "description": "该事件的序列号。"
          },
          "item": {
            "$ref": "#/components/schemas/OutputItem",
            "description": "添加的输出项。"
          }
        },
        "required": [
          "type",
          "output_index",
          "item",
          "sequence_number"
        ]
      },
      "ResponseOutputItemDoneEvent": {
        "type": "object",
        "description": "当输出项标记为完成时发出。",
        "properties": {
          "type": {
            "type": "string",
            "description": "事件的类型。始终 `response.output_item.done`。",
            "enum": [
              "response.output_item.done"
            ],
            "x-stainless-const": true
          },
          "output_index": {
            "type": "integer",
            "description": "标记为完成的输出项的索引。"
          },
          "sequence_number": {
            "type": "integer",
            "description": "该事件的序列号。"
          },
          "item": {
            "$ref": "#/components/schemas/OutputItem",
            "description": "标记为完成的输出项。"
          }
        },
        "required": [
          "type",
          "output_index",
          "item",
          "sequence_number"
        ]
      },
      "ResponseReasoningSummaryPartAddedEvent": {
        "type": "object",
        "description": "当添加新的推理摘要部分时发出。",
        "properties": {
          "type": {
            "type": "string",
            "description": "事件的类型。始终 `response.reasoning_summary_part.added`。",
            "enum": [
              "response.reasoning_summary_part.added"
            ],
            "x-stainless-const": true
          },
          "item_id": {
            "type": "string",
            "description": "与该摘要部分相关联的项目的ID。"
          },
          "output_index": {
            "type": "integer",
            "description": "与该摘要部分相关联的输出项的索引。"
          },
          "summary_index": {
            "type": "integer",
            "description": "推理摘要中摘要部分的索引。"
          },
          "sequence_number": {
            "type": "integer",
            "description": "该事件的序列号。"
          },
          "part": {
            "type": "object",
            "description": "新增摘要部分。",
            "properties": {
              "type": {
                "type": "string",
                "description": "摘要部分的类型。始终 `summary_text`。",
                "enum": [
                  "summary_text"
                ],
                "x-stainless-const": true
              },
              "text": {
                "type": "string",
                "description": "摘要部分的正文。"
              }
            },
            "required": [
              "type",
              "text"
            ]
          }
        },
        "required": [
          "type",
          "item_id",
          "output_index",
          "summary_index",
          "part",
          "sequence_number"
        ]
      },
      "ResponseReasoningSummaryPartDoneEvent": {
        "type": "object",
        "description": "当推理概要部分完成时发出。",
        "properties": {
          "type": {
            "type": "string",
            "description": "事件的类型。始终 `response.reasoning_summary_part.done`。",
            "enum": [
              "response.reasoning_summary_part.done"
            ],
            "x-stainless-const": true
          },
          "item_id": {
            "type": "string",
            "description": "与该摘要部分相关联的项目的ID。"
          },
          "output_index": {
            "type": "integer",
            "description": "与该摘要部分相关联的输出项的索引。"
          },
          "summary_index": {
            "type": "integer",
            "description": "推理摘要中摘要部分的索引。"
          },
          "sequence_number": {
            "type": "integer",
            "description": "该事件的序列号。"
          },
          "part": {
            "type": "object",
            "description": "完成总结部分。",
            "properties": {
              "type": {
                "type": "string",
                "description": "摘要部分的类型。始终 `summary_text`。",
                "enum": [
                  "summary_text"
                ],
                "x-stainless-const": true
              },
              "text": {
                "type": "string",
                "description": "摘要部分的正文。"
              }
            },
            "required": [
              "type",
              "text"
            ]
          }
        },
        "required": [
          "type",
          "item_id",
          "output_index",
          "summary_index",
          "part",
          "sequence_number"
        ]
      },
      "ResponseReasoningSummaryTextDeltaEvent": {
        "type": "object",
        "description": "当将增量添加到推理摘要文本时发出。",
        "properties": {
          "type": {
            "type": "string",
            "description": "事件的类型。始终 `response.reasoning_summary_text.delta`。",
            "enum": [
              "response.reasoning_summary_text.delta"
            ],
            "x-stainless-const": true
          },
          "item_id": {
            "type": "string",
            "description": "与该摘要文本增量相关联的项目的ID。"
          },
          "output_index": {
            "type": "integer",
            "description": "与该摘要文本增量相关联的输出项的索引。"
          },
          "summary_index": {
            "type": "integer",
            "description": "推理摘要中摘要部分的索引。"
          },
          "delta": {
            "type": "string",
            "description": "添加到摘要中的文本增量。"
          },
          "sequence_number": {
            "type": "integer",
            "description": "该事件的序列号。"
          }
        },
        "required": [
          "type",
          "item_id",
          "output_index",
          "summary_index",
          "delta",
          "sequence_number"
        ]
      },
      "ResponseReasoningSummaryTextDoneEvent": {
        "type": "object",
        "description": "当推理摘要文本完成时发出。",
        "properties": {
          "type": {
            "type": "string",
            "description": "事件的类型。始终 `response.reasoning_summary_text.done`。",
            "enum": [
              "response.reasoning_summary_text.done"
            ],
            "x-stainless-const": true
          },
          "item_id": {
            "type": "string",
            "description": "与该摘要文本关联的项目的ID。"
          },
          "output_index": {
            "type": "integer",
            "description": "与该摘要文本相关联的输出项的索引。"
          },
          "summary_index": {
            "type": "integer",
            "description": "推理摘要中摘要部分的索引。"
          },
          "text": {
            "type": "string",
            "description": "已完成的推理摘要全文。"
          },
          "sequence_number": {
            "type": "integer",
            "description": "该事件的序列号。"
          }
        },
        "required": [
          "type",
          "item_id",
          "output_index",
          "summary_index",
          "text",
          "sequence_number"
        ]
      },
      "ResponseReasoningTextDeltaEvent": {
        "type": "object",
        "description": "当将增量添加到推理文本时发出。",
        "properties": {
          "type": {
            "type": "string",
            "description": "事件的类型。始终 `response.reasoning_text.delta`。",
            "enum": [
              "response.reasoning_text.delta"
            ],
            "x-stainless-const": true
          },
          "item_id": {
            "type": "string",
            "description": "与该推理文本增量相关联的项目的ID。"
          },
          "output_index": {
            "type": "integer",
            "description": "与该推理文本增量相关联的输出项的索引。"
          },
          "content_index": {
            "type": "integer",
            "description": "与该增量相关联的推理内容部分的索引。"
          },
          "delta": {
            "type": "string",
            "description": "添加到推理内容的文本增量。"
          },
          "sequence_number": {
            "type": "integer",
            "description": "该事件的序列号。"
          }
        },
        "required": [
          "type",
          "item_id",
          "output_index",
          "content_index",
          "delta",
          "sequence_number"
        ]
      },
      "ResponseReasoningTextDoneEvent": {
        "type": "object",
        "description": "当推理文本完成时发出。",
        "properties": {
          "type": {
            "type": "string",
            "description": "事件的类型。始终 `response.reasoning_text.done`。",
            "enum": [
              "response.reasoning_text.done"
            ],
            "x-stainless-const": true
          },
          "item_id": {
            "type": "string",
            "description": "与该推理文本相关联的项目的ID。"
          },
          "output_index": {
            "type": "integer",
            "description": "与该推理文本相关联的输出项的索引。"
          },
          "content_index": {
            "type": "integer",
            "description": "推理内容部分索引。"
          },
          "text": {
            "type": "string",
            "description": "已完成的推理内容全文。"
          },
          "sequence_number": {
            "type": "integer",
            "description": "该事件的序列号。"
          }
        },
        "required": [
          "type",
          "item_id",
          "output_index",
          "content_index",
          "text",
          "sequence_number"
        ]
      },
      "ResponseRefusalDeltaEvent": {
        "type": "object",
        "description": "当存在部分拒绝文本时发出。",
        "properties": {
          "type": {
            "type": "string",
            "description": "事件的类型。始终 `response.refusal.delta`。",
            "enum": [
              "response.refusal.delta"
            ],
            "x-stainless-const": true
          },
          "item_id": {
            "type": "string",
            "description": "添加拒绝文本的输出项的ID。"
          },
          "output_index": {
            "type": "integer",
            "description": "添加拒绝文本的输出项的索引。"
          },
          "content_index": {
            "type": "integer",
            "description": "添加拒绝文本的内容部分的索引。"
          },
          "delta": {
            "type": "string",
            "description": "添加的拒绝文本。"
          },
          "sequence_number": {
            "type": "integer",
            "description": "该事件的序列号。"
          }
        },
        "required": [
          "type",
          "item_id",
          "output_index",
          "content_index",
          "delta",
          "sequence_number"
        ]
      },
      "ResponseRefusalDoneEvent": {
        "type": "object",
        "description": "当拒绝文本最终确定时发出。",
        "properties": {
          "type": {
            "type": "string",
            "description": "事件的类型。始终 `response.refusal.done`。",
            "enum": [
              "response.refusal.done"
            ],
            "x-stainless-const": true
          },
          "item_id": {
            "type": "string",
            "description": "拒绝文本最终确定的输出项的ID。"
          },
          "output_index": {
            "type": "integer",
            "description": "拒绝文本最终确定的输出项的索引。"
          },
          "content_index": {
            "type": "integer",
            "description": "拒绝文本最终确定的内容部分的索引。"
          },
          "refusal": {
            "type": "string",
            "description": "最终确定的拒绝文本。"
          },
          "sequence_number": {
            "type": "integer",
            "description": "该事件的序列号。"
          }
        },
        "required": [
          "type",
          "item_id",
          "output_index",
          "content_index",
          "refusal",
          "sequence_number"
        ]
      },
      "ResponseTextDeltaEvent": {
        "type": "object",
        "description": "当存在附加文本增量时发出。",
        "properties": {
          "type": {
            "type": "string",
            "description": "事件的类型。始终 `response.output_text.delta`。",
            "enum": [
              "response.output_text.delta"
            ],
            "x-stainless-const": true
          },
          "item_id": {
            "type": "string",
            "description": "添加了文本增量的输出项的ID。"
          },
          "output_index": {
            "type": "integer",
            "description": "添加了文本增量的输出项的索引。"
          },
          "content_index": {
            "type": "integer",
            "description": "添加了文本增量的内容部分的索引。"
          },
          "delta": {
            "type": "string",
            "description": "添加的文本增量。"
          },
          "sequence_number": {
            "type": "integer",
            "description": "该事件的序列号。"
          },
          "logprobs": {
            "type": "array",
            "description": "增量中token的对数概率。",
            "items": {
              "$ref": "#/components/schemas/ResponseLogProb"
            }
          }
        },
        "required": [
          "type",
          "item_id",
          "output_index",
          "content_index",
          "delta",
          "sequence_number",
          "logprobs"
        ]
      },
      "ResponseTextDoneEvent": {
        "type": "object",
        "description": "当文本内容完成时发出。",
        "properties": {
          "type": {
            "type": "string",
            "description": "事件的类型。始终 `response.output_text.done`。",
            "enum": [
              "response.output_text.done"
            ],
            "x-stainless-const": true
          },
          "item_id": {
            "type": "string",
            "description": "文本内容最终确定的输出项的ID。"
          },
          "output_index": {
            "type": "integer",
            "description": "文本内容最终确定的输出项的索引。"
          },
          "content_index": {
            "type": "integer",
            "description": "文本内容最终确定的内容部分的索引。"
          },
          "text": {
            "type": "string",
            "description": "最终确定的文本内容。"
          },
          "sequence_number": {
            "type": "integer",
            "description": "该事件的序列号。"
          },
          "logprobs": {
            "type": "array",
            "description": "增量中token的对数概率。",
            "items": {
              "$ref": "#/components/schemas/ResponseLogProb"
            }
          }
        },
        "required": [
          "type",
          "item_id",
          "output_index",
          "content_index",
          "text",
          "sequence_number",
          "logprobs"
        ]
      },
      "ResponseWebSearchCallCompletedEvent": {
        "type": "object",
        "description": "当网络搜索调用完成时发出。",
        "properties": {
          "type": {
            "type": "string",
            "description": "事件的类型。始终 `response.web_search_call.completed`。",
            "enum": [
              "response.web_search_call.completed"
            ],
            "x-stainless-const": true
          },
          "output_index": {
            "type": "integer",
            "description": "与网络搜索调用相关联的输出项的索引。"
          },
          "item_id": {
            "type": "string",
            "description": "与网络搜索调用相关联的输出项目的唯一ID。"
          },
          "sequence_number": {
            "type": "integer",
            "description": "正在处理的网络搜索调用的序列号。"
          }
        },
        "required": [
          "type",
          "output_index",
          "item_id",
          "sequence_number"
        ]
      },
      "ResponseWebSearchCallInProgressEvent": {
        "type": "object",
        "description": "发起网络搜索调用时发出。",
        "properties": {
          "type": {
            "type": "string",
            "description": "事件的类型。始终 `response.web_search_call.in_progress`。",
            "enum": [
              "response.web_search_call.in_progress"
            ],
            "x-stainless-const": true
          },
          "output_index": {
            "type": "integer",
            "description": "与网络搜索调用相关联的输出项的索引。"
          },
          "item_id": {
            "type": "string",
            "description": "与网络搜索调用相关联的输出项目的唯一ID。"
          },
          "sequence_number": {
            "type": "integer",
            "description": "正在处理的网络搜索调用的序列号。"
          }
        },
        "required": [
          "type",
          "output_index",
          "item_id",
          "sequence_number"
        ]
      },
      "ResponseWebSearchCallSearchingEvent": {
        "type": "object",
        "description": "当网络搜索调用正在执行时发出。",
        "properties": {
          "type": {
            "type": "string",
            "description": "事件的类型。始终 `response.web_search_call.searching`。",
            "enum": [
              "response.web_search_call.searching"
            ],
            "x-stainless-const": true
          },
          "output_index": {
            "type": "integer",
            "description": "与网络搜索调用相关联的输出项的索引。"
          },
          "item_id": {
            "type": "string",
            "description": "与网络搜索调用相关联的输出项目的唯一ID。"
          },
          "sequence_number": {
            "type": "integer",
            "description": "正在处理的网络搜索调用的序列号。"
          }
        },
        "required": [
          "type",
          "output_index",
          "item_id",
          "sequence_number"
        ]
      },
      "ResponseImageGenCallCompletedEvent": {
        "type": "object",
        "title": "响应图像生成调用完成事件",
        "description": "当图像生成工具调用完成并且最终图像可用时发出。",
        "properties": {
          "type": {
            "type": "string",
            "enum": [
              "response.image_generation_call.completed"
            ],
            "description": "事件的类型。始终 'response.image_generation_call.completed'。",
            "x-stainless-const": true
          },
          "output_index": {
            "type": "integer",
            "description": "响应的输出数组中的输出项的索引。"
          },
          "sequence_number": {
            "type": "integer",
            "description": "该事件的序列号。"
          },
          "item_id": {
            "type": "string",
            "description": "正在处理的图像生成项的唯一标识符。"
          }
        },
        "required": [
          "type",
          "output_index",
          "item_id",
          "sequence_number"
        ]
      },
      "ResponseImageGenCallGeneratingEvent": {
        "type": "object",
        "title": "响应图像生成调用生成事件",
        "description": "当图像生成工具调用正在主动生成图像时（中间状态）发出。",
        "properties": {
          "type": {
            "type": "string",
            "enum": [
              "response.image_generation_call.generating"
            ],
            "description": "事件的类型。始终 'response.image_generation_call.generating'。",
            "x-stainless-const": true
          },
          "output_index": {
            "type": "integer",
            "description": "响应的输出数组中的输出项的索引。"
          },
          "item_id": {
            "type": "string",
            "description": "正在处理的图像生成项的唯一标识符。"
          },
          "sequence_number": {
            "type": "integer",
            "description": "正在处理的图像生成项的序号。"
          }
        },
        "required": [
          "type",
          "output_index",
          "item_id",
          "sequence_number"
        ]
      },
      "ResponseImageGenCallInProgressEvent": {
        "type": "object",
        "title": "响应图像GenCallInProgress事件",
        "description": "当图像生成工具调用正在进行时发出。",
        "properties": {
          "type": {
            "type": "string",
            "enum": [
              "response.image_generation_call.in_progress"
            ],
            "description": "事件的类型。始终 'response.image_generation_call.in_progress'。",
            "x-stainless-const": true
          },
          "output_index": {
            "type": "integer",
            "description": "响应的输出数组中的输出项的索引。"
          },
          "item_id": {
            "type": "string",
            "description": "正在处理的图像生成项的唯一标识符。"
          },
          "sequence_number": {
            "type": "integer",
            "description": "正在处理的图像生成项的序号。"
          }
        },
        "required": [
          "type",
          "output_index",
          "item_id",
          "sequence_number"
        ]
      },
      "ResponseImageGenCallPartialImageEvent": {
        "type": "object",
        "title": "响应图像生成调用部分图像事件",
        "description": "当在图像生成流期间部分图像可用时发出。",
        "properties": {
          "type": {
            "type": "string",
            "enum": [
              "response.image_generation_call.partial_image"
            ],
            "description": "事件的类型。始终 'response.image_generation_call.partial_image'。",
            "x-stainless-const": true
          },
          "output_index": {
            "type": "integer",
            "description": "响应的输出数组中的输出项的索引。"
          },
          "item_id": {
            "type": "string",
            "description": "正在处理的图像生成项的唯一标识符。"
          },
          "sequence_number": {
            "type": "integer",
            "description": "正在处理的图像生成项的序号。"
          },
          "partial_image_index": {
            "type": "integer",
            "description": "部分图像的从0开始的索引（后端是从1开始的，但对于用户来说这是从0开始的）。"
          },
          "partial_image_b64": {
            "type": "string",
            "description": "Base64编码的部分图像数据，适合渲染为图像。"
          }
        },
        "required": [
          "type",
          "output_index",
          "item_id",
          "sequence_number",
          "partial_image_index",
          "partial_image_b64"
        ]
      },
      "ResponseMCPCallArgumentsDeltaEvent": {
        "type": "object",
        "title": "响应MCPCallArgumentsDeltaEvent",
        "description": "当 MCP 工具调用的参数存在增量（部分更新）时发出。",
        "properties": {
          "type": {
            "type": "string",
            "enum": [
              "response.mcp_call_arguments.delta"
            ],
            "description": "事件的类型。始终 'response.mcp_call_arguments.delta'。",
            "x-stainless-const": true
          },
          "output_index": {
            "type": "integer",
            "description": "响应的输出数组中的输出项的索引。"
          },
          "item_id": {
            "type": "string",
            "description": "正在处理的MCP工具调用项的唯一标识符。"
          },
          "delta": {
            "type": "string",
            "description": "包含 MCP 工具调用参数的部分更新的 JSON 字符串。"
          },
          "sequence_number": {
            "type": "integer",
            "description": "该事件的序列号。"
          }
        },
        "required": [
          "type",
          "output_index",
          "item_id",
          "delta",
          "sequence_number"
        ]
      },
      "ResponseMCPCallArgumentsDoneEvent": {
        "type": "object",
        "title": "响应MCPCallArgumentsDoneEvent",
        "description": "当 MCP 工具调用的参数最终确定时发出。",
        "properties": {
          "type": {
            "type": "string",
            "enum": [
              "response.mcp_call_arguments.done"
            ],
            "description": "事件的类型。始终 'response.mcp_call_arguments.done'。",
            "x-stainless-const": true
          },
          "output_index": {
            "type": "integer",
            "description": "响应的输出数组中的输出项的索引。"
          },
          "item_id": {
            "type": "string",
            "description": "正在处理的MCP工具调用项的唯一标识符。"
          },
          "arguments": {
            "type": "string",
            "description": "包含 MCP 工具调用的最终参数的 JSON 字符串。"
          },
          "sequence_number": {
            "type": "integer",
            "description": "该事件的序列号。"
          }
        },
        "required": [
          "type",
          "output_index",
          "item_id",
          "arguments",
          "sequence_number"
        ]
      },
      "ResponseMCPCallCompletedEvent": {
        "type": "object",
        "title": "响应MCPCallCompletedEvent",
        "description": "当MCP工具调用成功完成时发出。",
        "properties": {
          "type": {
            "type": "string",
            "enum": [
              "response.mcp_call.completed"
            ],
            "description": "事件的类型。始终 'response.mcp_call.completed'。",
            "x-stainless-const": true
          },
          "item_id": {
            "type": "string",
            "description": "已完成的MCP工具调用项的ID。"
          },
          "output_index": {
            "type": "integer",
            "description": "已完成的输出项的索引。"
          },
          "sequence_number": {
            "type": "integer",
            "description": "该事件的序列号。"
          }
        },
        "required": [
          "type",
          "item_id",
          "output_index",
          "sequence_number"
        ]
      },
      "ResponseMCPCallFailedEvent": {
        "type": "object",
        "title": "响应MCPCallFailed事件",
        "description": "当MCP工具调用失败时发出。",
        "properties": {
          "type": {
            "type": "string",
            "enum": [
              "response.mcp_call.failed"
            ],
            "description": "事件的类型。始终 'response.mcp_call.failed'。",
            "x-stainless-const": true
          },
          "item_id": {
            "type": "string",
            "description": "失败的MCP工具调用项的ID。"
          },
          "output_index": {
            "type": "integer",
            "description": "失败的输出项的索引。"
          },
          "sequence_number": {
            "type": "integer",
            "description": "该事件的序列号。"
          }
        },
        "required": [
          "type",
          "item_id",
          "output_index",
          "sequence_number"
        ]
      },
      "ResponseMCPCallInProgressEvent": {
        "type": "object",
        "title": "响应MCPCallInProgressEvent",
        "description": "当 MCP 工具调用正在进行时发出。",
        "properties": {
          "type": {
            "type": "string",
            "enum": [
              "response.mcp_call.in_progress"
            ],
            "description": "事件的类型。始终 'response.mcp_call.in_progress'。",
            "x-stainless-const": true
          },
          "sequence_number": {
            "type": "integer",
            "description": "该事件的序列号。"
          },
          "output_index": {
            "type": "integer",
            "description": "响应的输出数组中的输出项的索引。"
          },
          "item_id": {
            "type": "string",
            "description": "正在处理的MCP工具调用项的唯一标识符。"
          }
        },
        "required": [
          "type",
          "output_index",
          "item_id",
          "sequence_number"
        ]
      },
      "ResponseMCPListToolsCompletedEvent": {
        "type": "object",
        "title": "响应MCPListToolsCompletedEvent",
        "description": "当成功检索可用 MCP 工具列表时发出。",
        "properties": {
          "type": {
            "type": "string",
            "enum": [
              "response.mcp_list_tools.completed"
            ],
            "description": "事件的类型。始终 'response.mcp_list_tools.completed'。",
            "x-stainless-const": true
          },
          "item_id": {
            "type": "string",
            "description": "产生此输出的 MCP 工具调用项的 ID。"
          },
          "output_index": {
            "type": "integer",
            "description": "已处理的输出项的索引。"
          },
          "sequence_number": {
            "type": "integer",
            "description": "该事件的序列号。"
          }
        },
        "required": [
          "type",
          "item_id",
          "output_index",
          "sequence_number"
        ]
      },
      "ResponseMCPListToolsFailedEvent": {
        "type": "object",
        "title": "响应MCPListToolsFailedEvent",
        "description": "当尝试列出可用 MCP 工具失败时发出。",
        "properties": {
          "type": {
            "type": "string",
            "enum": [
              "response.mcp_list_tools.failed"
            ],
            "description": "事件的类型。始终 'response.mcp_list_tools.failed'。",
            "x-stainless-const": true
          },
          "item_id": {
            "type": "string",
            "description": "失败的MCP工具调用项的ID。"
          },
          "output_index": {
            "type": "integer",
            "description": "失败的输出项的索引。"
          },
          "sequence_number": {
            "type": "integer",
            "description": "该事件的序列号。"
          }
        },
        "required": [
          "type",
          "item_id",
          "output_index",
          "sequence_number"
        ]
      },
      "ResponseMCPListToolsInProgressEvent": {
        "type": "object",
        "title": "响应MCPListToolsInProgressEvent",
        "description": "当系统正在检索可用 MCP 工具列表时发出。",
        "properties": {
          "type": {
            "type": "string",
            "enum": [
              "response.mcp_list_tools.in_progress"
            ],
            "description": "事件的类型。始终 'response.mcp_list_tools.in_progress'。",
            "x-stainless-const": true
          },
          "item_id": {
            "type": "string",
            "description": "正在处理的MCP工具调用项的ID。"
          },
          "output_index": {
            "type": "integer",
            "description": "正在处理的输出项的索引。"
          },
          "sequence_number": {
            "type": "integer",
            "description": "该事件的序列号。"
          }
        },
        "required": [
          "type",
          "item_id",
          "output_index",
          "sequence_number"
        ]
      },
      "ResponseOutputTextAnnotationAddedEvent": {
        "type": "object",
        "title": "响应输出文本注释添加事件",
        "description": "当输出文本内容添加注释时发出。",
        "properties": {
          "type": {
            "type": "string",
            "enum": [
              "response.output_text.annotation.added"
            ],
            "description": "事件的类型。始终 'response.output_text.annotation.added'。",
            "x-stainless-const": true
          },
          "item_id": {
            "type": "string",
            "description": "正在添加注释的项目的唯一标识符。"
          },
          "output_index": {
            "type": "integer",
            "description": "响应的输出数组中的输出项的索引。"
          },
          "content_index": {
            "type": "integer",
            "description": "输出项内的内容部分的索引。"
          },
          "annotation_index": {
            "type": "integer",
            "description": "内容部分内注释的索引。"
          },
          "sequence_number": {
            "type": "integer",
            "description": "该事件的序列号。"
          },
          "annotation": {
            "type": "object",
            "description": "正在添加的注释对象。 （有关详细信息，请参阅注释架构。）"
          }
        },
        "required": [
          "type",
          "item_id",
          "output_index",
          "content_index",
          "annotation_index",
          "annotation",
          "sequence_number"
        ]
      },
      "ResponseQueuedEvent": {
        "type": "object",
        "title": "响应队列事件",
        "description": "当响应排队并等待处理时发出。",
        "properties": {
          "type": {
            "type": "string",
            "enum": [
              "response.queued"
            ],
            "description": "事件的类型。始终 'response.queued'。",
            "x-stainless-const": true
          },
          "response": {
            "$ref": "#/components/schemas/Response",
            "description": "排队的完整响应对象。"
          },
          "sequence_number": {
            "type": "integer",
            "description": "该事件的序列号。"
          }
        },
        "required": [
          "type",
          "response",
          "sequence_number"
        ]
      },
      "ResponseCustomToolCallInputDeltaEvent": {
        "title": "响应自定义工具调用输入增量",
        "type": "object",
        "description": "表示自定义工具调用的输入的增量（部分更新）的事件。",
        "properties": {
          "type": {
            "type": "string",
            "enum": [
              "response.custom_tool_call_input.delta"
            ],
            "description": "事件类型标识符。",
            "x-stainless-const": true
          },
          "sequence_number": {
            "type": "integer",
            "description": "该事件的序列号。"
          },
          "output_index": {
            "type": "integer",
            "description": "该增量适用的输出的索引。"
          },
          "item_id": {
            "type": "string",
            "description": "与该事件关联的API项的唯一标识符。"
          },
          "delta": {
            "type": "string",
            "description": "自定义工具调用的增量输入数据（delta）。"
          }
        },
        "required": [
          "type",
          "output_index",
          "item_id",
          "delta",
          "sequence_number"
        ]
      },
      "ResponseCustomToolCallInputDoneEvent": {
        "title": "响应自定义工具调用输入完成",
        "type": "object",
        "description": "自定义工具调用输入完成的事件。",
        "properties": {
          "type": {
            "type": "string",
            "enum": [
              "response.custom_tool_call_input.done"
            ],
            "description": "事件类型标识符。",
            "x-stainless-const": true
          },
          "sequence_number": {
            "type": "integer",
            "description": "该事件的序列号。"
          },
          "output_index": {
            "type": "integer",
            "description": "该事件适用的输出的索引。"
          },
          "item_id": {
            "type": "string",
            "description": "与该事件关联的API项的唯一标识符。"
          },
          "input": {
            "type": "string",
            "description": "自定义工具调用的完整输入数据。"
          }
        },
        "required": [
          "type",
          "output_index",
          "item_id",
          "input",
          "sequence_number"
        ]
      },
      "Tool": {
        "description": "可用于生成响应的工具。",
        "discriminator": {
          "propertyName": "type"
        },
        "oneOf": [
          {
            "$ref": "#/components/schemas/FunctionTool"
          },
          {
            "$ref": "#/components/schemas/FileSearchTool"
          },
          {
            "$ref": "#/components/schemas/ComputerTool"
          },
          {
            "$ref": "#/components/schemas/ComputerUsePreviewTool"
          },
          {
            "$ref": "#/components/schemas/WebSearchTool"
          },
          {
            "$ref": "#/components/schemas/MCPTool"
          },
          {
            "$ref": "#/components/schemas/CodeInterpreterTool"
          },
          {
            "$ref": "#/components/schemas/ImageGenTool"
          },
          {
            "$ref": "#/components/schemas/LocalShellToolParam"
          },
          {
            "$ref": "#/components/schemas/FunctionShellToolParam"
          },
          {
            "$ref": "#/components/schemas/CustomToolParam"
          },
          {
            "$ref": "#/components/schemas/NamespaceToolParam"
          },
          {
            "$ref": "#/components/schemas/ToolSearchToolParam"
          },
          {
            "$ref": "#/components/schemas/WebSearchPreviewTool"
          },
          {
            "$ref": "#/components/schemas/ApplyPatchToolParam"
          }
        ]
      },
      "ResponseTextParam": {
        "type": "object",
        "description": "模型文本响应的配置选项。可以是平淡的\n文本或结构化 JSON 数据。了解更多：\n- [文本输入和输出](https://platform.openai.com/docs/guides/text)\n- [结构化输出](https://platform.openai.com/docs/guides/structured-outputs)",
        "properties": {
          "format": {
            "$ref": "#/components/schemas/TextResponseFormatConfiguration"
          },
          "verbosity": {
            "$ref": "#/components/schemas/Verbosity"
          }
        }
      },
      "Reasoning": {
        "type": "object",
        "description": "**仅限 gpt-5 和 o 系列型号**\n\n配置选项\n[推理模型](https://platform.openai.com/docs/guides/reasoning)。",
        "title": "推理",
        "properties": {
          "effort": {
            "$ref": "#/components/schemas/ReasoningEffort"
          },
          "summary": {
            "anyOf": [
              {
                "type": "string",
                "description": "模型执行的推理的总结。这可以是\n对于调试和理解模型的推理过程很有用。\n`auto`、`concise` 或 `detailed` 之一。\n\n`computer-use-preview` 模型和 `gpt-5` 之后的所有推理模型都支持 `concise`。",
                "enum": [
                  "auto",
                  "concise",
                  "detailed"
                ],
                "title": "string"
              },
              {
                "type": "null",
                "title": "null"
              }
            ]
          },
          "generate_summary": {
            "anyOf": [
              {
                "type": "string",
                "deprecated": true,
                "description": "**已弃用：** 使用 `summary` 代替。\n\n模型执行的推理的摘要。这可以是\n对于调试和理解模型的推理过程很有用。\n`auto`、`concise` 或 `detailed` 之一。",
                "enum": [
                  "auto",
                  "concise",
                  "detailed"
                ],
                "title": "string"
              },
              {
                "type": "null",
                "title": "null"
              }
            ]
          }
        }
      },
      "TruncationEnum": {
        "type": "string",
        "enum": [
          "auto",
          "disabled"
        ]
      },
      "ToolChoiceParam": {
        "description": "模型在生成时应该如何选择使用哪个工具（或多个工具）\n一个响应。请参阅 `tools` 参数以了解如何指定哪些工具\n模型可以调用。",
        "oneOf": [
          {
            "$ref": "#/components/schemas/ToolChoiceOptions"
          },
          {
            "$ref": "#/components/schemas/ToolChoiceAllowed"
          },
          {
            "$ref": "#/components/schemas/ToolChoiceTypes"
          },
          {
            "$ref": "#/components/schemas/ToolChoiceFunction"
          },
          {
            "$ref": "#/components/schemas/ToolChoiceMCP"
          },
          {
            "$ref": "#/components/schemas/ToolChoiceCustom"
          },
          {
            "$ref": "#/components/schemas/SpecificApplyPatchParam"
          },
          {
            "$ref": "#/components/schemas/SpecificFunctionShellParam"
          }
        ]
      },
      "ModelIdsCompaction": {
        "anyOf": [
          {
            "$ref": "#/components/schemas/ModelIdsResponses"
          },
          {
            "type": "string",
            "title": "string"
          },
          {
            "type": "null",
            "title": "null"
          }
        ],
        "description": "用于生成响应的模型ID，例如`gpt-5`或`o3`。 OpenAI 提供各种具有不同功能、性能特征和价位的模型。请参阅[型号指南](https://platform.openai.com/docs/models) 浏览和比较可用型号。"
      },
      "PromptCacheRetentionEnum": {
        "type": "string",
        "enum": [
          "in_memory",
          "24h"
        ]
      },
      "ServiceTierEnum": {
        "type": "string",
        "enum": [
          "auto",
          "default",
          "flex",
          "priority"
        ]
      },
      "ItemField": {
        "oneOf": [
          {
            "$ref": "#/components/schemas/Message"
          },
          {
            "$ref": "#/components/schemas/FunctionToolCall"
          },
          {
            "$ref": "#/components/schemas/ToolSearchCall"
          },
          {
            "$ref": "#/components/schemas/ToolSearchOutput"
          },
          {
            "$ref": "#/components/schemas/FunctionToolCallOutput"
          },
          {
            "$ref": "#/components/schemas/FileSearchToolCall"
          },
          {
            "$ref": "#/components/schemas/WebSearchToolCall"
          },
          {
            "$ref": "#/components/schemas/ImageGenToolCall"
          },
          {
            "$ref": "#/components/schemas/ComputerToolCall"
          },
          {
            "$ref": "#/components/schemas/ComputerToolCallOutputResource"
          },
          {
            "$ref": "#/components/schemas/ReasoningItem"
          },
          {
            "$ref": "#/components/schemas/CompactionBody"
          },
          {
            "$ref": "#/components/schemas/CodeInterpreterToolCall"
          },
          {
            "$ref": "#/components/schemas/LocalShellToolCall",
            "deprecated": true
          },
          {
            "$ref": "#/components/schemas/LocalShellToolCallOutput",
            "deprecated": true
          },
          {
            "$ref": "#/components/schemas/FunctionShellCall"
          },
          {
            "$ref": "#/components/schemas/FunctionShellCallOutput"
          },
          {
            "$ref": "#/components/schemas/ApplyPatchToolCall"
          },
          {
            "$ref": "#/components/schemas/ApplyPatchToolCallOutput"
          },
          {
            "$ref": "#/components/schemas/MCPListTools"
          },
          {
            "$ref": "#/components/schemas/MCPApprovalRequest"
          },
          {
            "$ref": "#/components/schemas/MCPApprovalResponseResource"
          },
          {
            "$ref": "#/components/schemas/MCPToolCall"
          },
          {
            "$ref": "#/components/schemas/CustomToolCall"
          },
          {
            "$ref": "#/components/schemas/CustomToolCallOutput"
          }
        ],
        "description": "表示消息、工具调用、工具输出、推理或其他响应元素的项目。",
        "discriminator": {
          "propertyName": "type"
        }
      },
      "ModelIdsResponses": {
        "example": "model-name",
        "anyOf": [
          {
            "$ref": "#/components/schemas/ModelIdsShared"
          },
          {
            "type": "string",
            "title": "仅响应模型",
            "enum": [
              "o1-pro",
              "o1-pro-2025-03-19",
              "o3-pro",
              "o3-pro-2025-06-10",
              "o3-deep-research",
              "o3-deep-research-2025-06-26",
              "o4-mini-deep-research",
              "o4-mini-deep-research-2025-06-26",
              "computer-use-preview",
              "computer-use-preview-2025-03-11",
              "gpt-5-codex",
              "gpt-5-pro",
              "gpt-5-pro-2025-10-06",
              "gpt-5.1-codex-max"
            ]
          }
        ]
      },
      "ToolsArray": {
        "type": "array",
        "description": "模型在生成响应时可以调用的一系列工具。你\n可以通过设置 `tool_choice` 参数来指定使用哪个工具。\n\n我们支持以下类别的工具：\n- **内置工具**：OpenAI 提供的工具扩展了\n  模型的功能，例如[网络搜索](https://platform.openai.com/docs/guides/tools-web-search)\n  或[文件搜索](https://platform.openai.com/docs/guides/tools-file-search)。了解更多关于\n  [内置工具](https://platform.openai.com/docs/guides/tools)。\n- **MCP 工具**：通过自定义 MCP 服务器与第三方系统集成\n  或预定义的连接器，例如 Google Drive 和 SharePoint。了解更多关于\n  [MCP 工具](https://platform.openai.com/docs/guides/tools-connectors-mcp)。\n- **函数调用（自定义工具）**：由您定义的函数，\n  使模型能够使用强类型参数调用您自己的代码\n  和输出。了解更多关于\n  [函数调用](https://platform.openai.com/docs/guides/function-calling)。您还可以使用\n  自定义工具来调用您自己的代码。",
        "items": {
          "$ref": "#/components/schemas/Tool"
        }
      },
      "Prompt": {
        "anyOf": [
          {
            "type": "object",
            "description": "对提示模板及其变量的引用。\n[了解更多](https://platform.openai.com/docs/guides/text?api-mode=responses#reusable-prompts)。",
            "required": [
              "id"
            ],
            "properties": {
              "id": {
                "type": "string",
                "description": "要使用的提示模板的唯一标识符。"
              },
              "version": {
                "anyOf": [
                  {
                    "type": "string",
                    "description": "提示模板的可选版本。",
                    "title": "string"
                  },
                  {
                    "type": "null",
                    "title": "null"
                  }
                ]
              },
              "variables": {
                "$ref": "#/components/schemas/ResponsePromptVariables"
              }
            },
            "title": "object"
          },
          {
            "type": "null",
            "title": "null"
          }
        ]
      },
      "ConversationParam-2": {
        "properties": {
          "id": {
            "type": "string",
            "description": "会话的唯一ID。",
            "example": "conv_123"
          }
        },
        "type": "object",
        "required": [
          "id"
        ],
        "title": "对话对象",
        "description": "该响应所属的会话。"
      },
      "Metadata": {
        "anyOf": [
          {
            "type": "object",
            "description": "可以附加到对象的 16 个键值对的集合。这可以是\n对于以结构化方式存储有关对象的附加信息非常有用\n格式，并通过 API 或仪表板查询对象。\n\n键是最大长度为 64 个字符的字符串。值是字符串\n最大长度为 512 个字符。",
            "additionalProperties": {
              "type": "string"
            },
            "x-oaiTypeLabel": "map",
            "title": "object"
          },
          {
            "type": "null",
            "title": "null"
          }
        ]
      },
      "ServiceTier": {
        "anyOf": [
          {
            "type": "string",
            "description": "指定用于服务请求的处理类型。\n  - 如果设置为 'auto'，则将使用项目设置中配置的服务层处理请求。除非另有配置，否则项目将使用 'default'。\n  - 如果设置为 'default'，则将使用所选型号的标准定价和性能来处理请求。\n  - 如果设置为“[flex](https://platform.openai.com/docs/guides/flex-processing)”或“[priority](https://openai.com/api-priority-processing/)”，则请求将使用相应的服务层进行处理。\n  - 未设置时，默认行为为 'auto'。\n\n  当设置 `service_tier` 参数时，响应正文将包含基于实际用于服务请求的处理模式的 `service_tier` 值。该响应值可能与参数中设置的值不同。",
            "enum": [
              "auto",
              "default",
              "flex",
              "scale",
              "priority"
            ],
            "default": "auto",
            "title": "string"
          },
          {
            "type": "null",
            "title": "null"
          }
        ]
      },
      "ResponseErrorCode": {
        "type": "string",
        "description": "响应的错误代码。",
        "enum": [
          "server_error",
          "rate_limit_exceeded",
          "invalid_prompt",
          "vector_store_timeout",
          "invalid_image",
          "invalid_image_format",
          "invalid_base64_image",
          "invalid_image_url",
          "image_too_large",
          "image_too_small",
          "image_parse_error",
          "image_content_policy_violation",
          "invalid_image_mode",
          "image_file_too_large",
          "unsupported_image_media_type",
          "empty_image_file",
          "failed_to_download_image",
          "image_file_not_found"
        ]
      },
      "OutputMessage": {
        "type": "object",
        "title": "输出消息",
        "description": "来自模型的输出消息。",
        "properties": {
          "id": {
            "type": "string",
            "description": "输出消息的唯一ID。"
          },
          "type": {
            "type": "string",
            "description": "输出消息的类型。始终 `message`。",
            "enum": [
              "message"
            ],
            "x-stainless-const": true
          },
          "role": {
            "type": "string",
            "description": "输出消息的作用。始终 `assistant`。",
            "enum": [
              "assistant"
            ],
            "x-stainless-const": true
          },
          "content": {
            "type": "array",
            "description": "输出消息的内容。",
            "items": {
              "$ref": "#/components/schemas/OutputMessageContent"
            }
          },
          "phase": {
            "anyOf": [
              {
                "$ref": "#/components/schemas/MessagePhase"
              },
              {
                "type": "null",
                "title": "null"
              }
            ]
          },
          "status": {
            "type": "string",
            "description": "消息输入的状态。 `in_progress`、`completed` 之一，或\n`incomplete`。当通过 API 返回输入项时填充。",
            "enum": [
              "in_progress",
              "completed",
              "incomplete"
            ]
          }
        },
        "required": [
          "id",
          "type",
          "role",
          "content",
          "status"
        ]
      },
      "FileSearchToolCall": {
        "type": "object",
        "title": "文件搜索工具调用",
        "description": "文件搜索工具调用的结果。请参阅\n[文件搜索指南](https://platform.openai.com/docs/guides/tools-file-search) 了解更多信息。",
        "properties": {
          "id": {
            "type": "string",
            "description": "文件搜索工具调用的唯一ID。"
          },
          "type": {
            "type": "string",
            "enum": [
              "file_search_call"
            ],
            "description": "文件搜索工具调用的类型。始终 `file_search_call`。",
            "x-stainless-const": true
          },
          "status": {
            "type": "string",
            "description": "文件搜索工具调用的状态。 `in_progress` 之一，\n`searching`、`incomplete` 或 `failed`，",
            "enum": [
              "in_progress",
              "searching",
              "completed",
              "incomplete",
              "failed"
            ]
          },
          "queries": {
            "type": "array",
            "items": {
              "type": "string"
            },
            "description": "用于搜索文件的查询。"
          },
          "results": {
            "anyOf": [
              {
                "type": "array",
                "description": "文件搜索工具调用的结果。",
                "items": {
                  "type": "object",
                  "properties": {
                    "file_id": {
                      "type": "string",
                      "description": "文件的唯一ID。"
                    },
                    "text": {
                      "type": "string",
                      "description": "从文件中检索的文本。"
                    },
                    "filename": {
                      "type": "string",
                      "description": "文件名。"
                    },
                    "attributes": {
                      "$ref": "#/components/schemas/VectorStoreFileAttributes"
                    },
                    "score": {
                      "type": "number",
                      "format": "float",
                      "description": "文件的相关性分数 - 0 到 1 之间的值。"
                    }
                  }
                },
                "title": "array"
              },
              {
                "type": "null",
                "title": "null"
              }
            ]
          }
        },
        "required": [
          "id",
          "type",
          "status",
          "queries"
        ]
      },
      "FunctionToolCall": {
        "type": "object",
        "title": "功能工具调用",
        "description": "运行函数的工具调用。请参阅 \n[函数调用指南](https://platform.openai.com/docs/guides/function-calling) 了解更多信息。",
        "properties": {
          "id": {
            "type": "string",
            "description": "功能工具调用的唯一ID。"
          },
          "type": {
            "type": "string",
            "enum": [
              "function_call"
            ],
            "description": "功能工具调用的类型。始终 `function_call`。",
            "x-stainless-const": true
          },
          "call_id": {
            "type": "string",
            "description": "模型生成的功能工具调用的唯一ID。"
          },
          "namespace": {
            "type": "string",
            "description": "要运行的函数的命名空间。"
          },
          "name": {
            "type": "string",
            "description": "要运行的函数的名称。"
          },
          "arguments": {
            "type": "string",
            "description": "要传递给函数的参数的 JSON 字符串。"
          },
          "status": {
            "type": "string",
            "description": "项目的状态。 `in_progress`、`completed` 之一，或\n`incomplete`。当通过 API 返回项目时填充。",
            "enum": [
              "in_progress",
              "completed",
              "incomplete"
            ]
          }
        },
        "required": [
          "type",
          "call_id",
          "name",
          "arguments"
        ]
      },
      "FunctionToolCallOutputResource": {
        "allOf": [
          {
            "$ref": "#/components/schemas/FunctionToolCallOutput"
          },
          {
            "type": "object",
            "properties": {
              "id": {
                "type": "string",
                "description": "函数调用工具输出的唯一ID。"
              },
              "status": {
                "description": "项目的状态。 `in_progress`、`completed` 之一，或\n`incomplete`。当通过 API 返回项目时填充。",
                "$ref": "#/components/schemas/FunctionCallOutputStatusEnum"
              },
              "created_by": {
                "type": "string",
                "description": "创建该项目的参与者的标识符。"
              }
            },
            "required": [
              "id",
              "status"
            ]
          }
        ]
      },
      "WebSearchToolCall": {
        "type": "object",
        "title": "网页搜索工具调用",
        "description": "网络搜索工具调用的结果。请参阅\n[网络搜索指南](https://platform.openai.com/docs/guides/tools-web-search) 了解更多信息。",
        "properties": {
          "id": {
            "type": "string",
            "description": "网页搜索工具调用的唯一ID。"
          },
          "type": {
            "type": "string",
            "enum": [
              "web_search_call"
            ],
            "description": "网络搜索工具调用的类型。始终 `web_search_call`。",
            "x-stainless-const": true
          },
          "status": {
            "type": "string",
            "description": "网络搜索工具调用的状态。",
            "enum": [
              "in_progress",
              "searching",
              "completed",
              "failed"
            ]
          },
          "action": {
            "type": "object",
            "description": "描述此网络搜索调用中所采取的特定操作的对象。\n包括有关模型如何使用网络（搜索、open_page、find_in_page）的详细信息。",
            "oneOf": [
              {
                "$ref": "#/components/schemas/WebSearchActionSearch"
              },
              {
                "$ref": "#/components/schemas/WebSearchActionOpenPage"
              },
              {
                "$ref": "#/components/schemas/WebSearchActionFind"
              }
            ],
            "discriminator": {
              "propertyName": "type"
            }
          }
        },
        "required": [
          "id",
          "type",
          "status",
          "action"
        ]
      },
      "ComputerToolCall": {
        "type": "object",
        "title": "计算机工具调用",
        "description": "对计算机使用工具的工具调用。请参阅\n[计算机使用指南](https://platform.openai.com/docs/guides/tools-computer-use) 了解更多信息。",
        "properties": {
          "type": {
            "type": "string",
            "description": "计算机调用的类型。始终 `computer_call`。",
            "enum": [
              "computer_call"
            ],
            "default": "computer_call"
          },
          "id": {
            "type": "string",
            "description": "计算机调用的唯一ID。"
          },
          "call_id": {
            "type": "string",
            "description": "当用输出响应工具调用时使用的标识符。"
          },
          "action": {
            "$ref": "#/components/schemas/ComputerAction"
          },
          "actions": {
            "$ref": "#/components/schemas/ComputerActionList"
          },
          "pending_safety_checks": {
            "type": "array",
            "items": {
              "$ref": "#/components/schemas/ComputerCallSafetyCheckParam"
            },
            "description": "计算机调用的未决安全检查。"
          },
          "status": {
            "type": "string",
            "description": "项目的状态。 `in_progress`、`completed` 之一，或\n`incomplete`。当通过 API 返回项目时填充。",
            "enum": [
              "in_progress",
              "completed",
              "incomplete"
            ]
          }
        },
        "required": [
          "type",
          "id",
          "call_id",
          "pending_safety_checks",
          "status"
        ]
      },
      "ComputerToolCallOutputResource": {
        "allOf": [
          {
            "$ref": "#/components/schemas/ComputerToolCallOutput"
          },
          {
            "type": "object",
            "properties": {
              "id": {
                "type": "string",
                "description": "计算机调用工具输出的唯一ID。"
              },
              "status": {
                "description": "消息输入的状态。 `in_progress`、`completed` 之一，或\n`incomplete`。当通过 API 返回输入项时填充。",
                "$ref": "#/components/schemas/ComputerCallOutputStatus"
              },
              "created_by": {
                "type": "string",
                "description": "创建该项目的参与者的标识符。"
              }
            },
            "required": [
              "id",
              "status"
            ]
          }
        ]
      },
      "ReasoningItem": {
        "type": "object",
        "description": "推理模型在生成时所使用的思路链的描述\n一个响应。请务必将这些项目包含在响应 API 的 `input` 中\n如果您手动进行后续对话\n[管理上下文](https://platform.openai.com/docs/guides/conversation-state)。",
        "title": "推理",
        "properties": {
          "type": {
            "type": "string",
            "description": "对象的类型。始终 `reasoning`。",
            "enum": [
              "reasoning"
            ],
            "x-stainless-const": true
          },
          "id": {
            "type": "string",
            "description": "推理内容的唯一标识。"
          },
          "encrypted_content": {
            "anyOf": [
              {
                "type": "string",
                "description": "推理项的加密内容-当响应时填充\n使用 `include` 参数中的 `reasoning.encrypted_content` 生成。",
                "title": "string"
              },
              {
                "type": "null",
                "title": "null"
              }
            ]
          },
          "summary": {
            "type": "array",
            "description": "推理概要内容。",
            "items": {
              "$ref": "#/components/schemas/SummaryTextContent"
            }
          },
          "content": {
            "type": "array",
            "description": "推理文本内容。",
            "items": {
              "$ref": "#/components/schemas/ReasoningTextContent"
            }
          },
          "status": {
            "type": "string",
            "description": "项目的状态。 `in_progress`、`completed` 之一，或\n`incomplete`。当通过 API 返回项目时填充。",
            "enum": [
              "in_progress",
              "completed",
              "incomplete"
            ]
          }
        },
        "required": [
          "id",
          "summary",
          "type"
        ]
      },
      "ToolSearchCall": {
        "properties": {
          "type": {
            "type": "string",
            "enum": [
              "tool_search_call"
            ],
            "description": "项目的类型。始终 `tool_search_call`。",
            "default": "tool_search_call",
            "x-stainless-const": true
          },
          "id": {
            "type": "string",
            "description": "工具搜索调用项的唯一ID。"
          },
          "call_id": {
            "anyOf": [
              {
                "type": "string",
                "description": "模型生成的工具搜索调用的唯一ID。",
                "title": "string"
              },
              {
                "type": "null",
                "title": "null"
              }
            ]
          },
          "execution": {
            "$ref": "#/components/schemas/ToolSearchExecutionType",
            "description": "工具搜索是由服务器执行还是由客户端执行。"
          },
          "arguments": {
            "description": "用于工具搜索调用的参数。"
          },
          "status": {
            "$ref": "#/components/schemas/FunctionCallStatus",
            "description": "记录的工具搜索调用项的状态。"
          },
          "created_by": {
            "type": "string",
            "description": "创建该项目的参与者的标识符。"
          }
        },
        "type": "object",
        "required": [
          "type",
          "id",
          "call_id",
          "execution",
          "arguments",
          "status"
        ]
      },
      "ToolSearchOutput": {
        "properties": {
          "type": {
            "type": "string",
            "enum": [
              "tool_search_output"
            ],
            "description": "项目的类型。始终 `tool_search_output`。",
            "default": "tool_search_output",
            "x-stainless-const": true
          },
          "id": {
            "type": "string",
            "description": "工具搜索输出项的唯一ID。"
          },
          "call_id": {
            "anyOf": [
              {
                "type": "string",
                "description": "模型生成的工具搜索调用的唯一ID。",
                "title": "string"
              },
              {
                "type": "null",
                "title": "null"
              }
            ]
          },
          "execution": {
            "$ref": "#/components/schemas/ToolSearchExecutionType",
            "description": "工具搜索是由服务器执行还是由客户端执行。"
          },
          "tools": {
            "items": {
              "$ref": "#/components/schemas/Tool"
            },
            "type": "array",
            "description": "工具搜索返回的加载的工具定义。"
          },
          "status": {
            "$ref": "#/components/schemas/FunctionCallOutputStatusEnum",
            "description": "记录的工具搜索输出项目的状态。"
          },
          "created_by": {
            "type": "string",
            "description": "创建该项目的参与者的标识符。"
          }
        },
        "type": "object",
        "required": [
          "type",
          "id",
          "call_id",
          "execution",
          "tools",
          "status"
        ]
      },
      "CompactionBody": {
        "properties": {
          "type": {
            "type": "string",
            "enum": [
              "compaction"
            ],
            "description": "项目的类型。始终 `compaction`。",
            "default": "compaction",
            "x-stainless-const": true
          },
          "id": {
            "type": "string",
            "description": "压缩项的唯一ID。"
          },
          "encrypted_content": {
            "type": "string",
            "description": "压缩产生的加密内容。"
          },
          "created_by": {
            "type": "string",
            "description": "创建该项目的参与者的标识符。"
          }
        },
        "type": "object",
        "required": [
          "type",
          "id",
          "encrypted_content"
        ],
        "title": "压实项目",
        "description": "由[`v1/responses/compact` API](https://platform.openai.com/docs/api-reference/responses/compact)生成的压缩项。"
      },
      "ImageGenToolCall": {
        "type": "object",
        "title": "图像生成调用",
        "description": "模型发出的图像生成请求。",
        "properties": {
          "type": {
            "type": "string",
            "enum": [
              "image_generation_call"
            ],
            "description": "图像生成调用的类型。始终 `image_generation_call`。",
            "x-stainless-const": true
          },
          "id": {
            "type": "string",
            "description": "图像生成调用的唯一ID。"
          },
          "status": {
            "type": "string",
            "enum": [
              "in_progress",
              "completed",
              "generating",
              "failed"
            ],
            "description": "图像生成调用的状态。"
          },
          "result": {
            "anyOf": [
              {
                "type": "string",
                "description": "生成的以base64编码的图像。",
                "title": "string"
              },
              {
                "type": "null",
                "title": "null"
              }
            ]
          }
        },
        "required": [
          "type",
          "id",
          "status",
          "result"
        ]
      },
      "CodeInterpreterToolCall": {
        "type": "object",
        "title": "代码解释器工具调用",
        "description": "运行代码的工具调用。",
        "properties": {
          "type": {
            "type": "string",
            "enum": [
              "code_interpreter_call"
            ],
            "default": "code_interpreter_call",
            "x-stainless-const": true,
            "description": "代码解释器工具调用的类型。始终 `code_interpreter_call`。"
          },
          "id": {
            "type": "string",
            "description": "代码解释器工具调用的唯一ID。"
          },
          "status": {
            "type": "string",
            "enum": [
              "in_progress",
              "completed",
              "incomplete",
              "interpreting",
              "failed"
            ],
            "description": "代码解释器工具调用的状态。有效值为 `in_progress`、`completed`、`incomplete`、`interpreting` 和 `failed`。"
          },
          "container_id": {
            "type": "string",
            "description": "用于运行代码的容器的ID。"
          },
          "code": {
            "anyOf": [
              {
                "type": "string",
                "description": "要运行的代码，如果不可用则为 null。",
                "title": "string"
              },
              {
                "type": "null",
                "title": "null"
              }
            ]
          },
          "outputs": {
            "anyOf": [
              {
                "type": "array",
                "items": {
                  "oneOf": [
                    {
                      "$ref": "#/components/schemas/CodeInterpreterOutputLogs"
                    },
                    {
                      "$ref": "#/components/schemas/CodeInterpreterOutputImage"
                    }
                  ],
                  "discriminator": {
                    "propertyName": "type"
                  }
                },
                "discriminator": {
                  "propertyName": "type"
                },
                "description": "代码解释器生成的输出，例如日志或图像。\n如果没有可用的输出，则可以为 null。",
                "title": "array"
              },
              {
                "type": "null",
                "title": "null"
              }
            ]
          }
        },
        "required": [
          "type",
          "id",
          "status",
          "container_id",
          "code",
          "outputs"
        ]
      },
      "LocalShellToolCall": {
        "type": "object",
        "title": "本地shell调用",
        "description": "在本地 shell 上运行命令的工具调用。",
        "properties": {
          "type": {
            "type": "string",
            "enum": [
              "local_shell_call"
            ],
            "description": "本地shell调用的类型。始终 `local_shell_call`。",
            "x-stainless-const": true
          },
          "id": {
            "type": "string",
            "description": "本地shell调用的唯一ID。"
          },
          "call_id": {
            "type": "string",
            "description": "模型生成的本地shell工具调用的唯一ID。"
          },
          "action": {
            "$ref": "#/components/schemas/LocalShellExecAction"
          },
          "status": {
            "type": "string",
            "enum": [
              "in_progress",
              "completed",
              "incomplete"
            ],
            "description": "本地 shell 调用的状态。"
          }
        },
        "required": [
          "type",
          "id",
          "call_id",
          "action",
          "status"
        ]
      },
      "LocalShellToolCallOutput": {
        "type": "object",
        "title": "本地shell调用输出",
        "description": "本地shell工具调用的输出。",
        "properties": {
          "type": {
            "type": "string",
            "enum": [
              "local_shell_call_output"
            ],
            "description": "本地shell工具调用输出的类型。始终 `local_shell_call_output`。",
            "x-stainless-const": true
          },
          "id": {
            "type": "string",
            "description": "模型生成的本地shell工具调用的唯一ID。"
          },
          "output": {
            "type": "string",
            "description": "本地 shell 工具调用的输出的 JSON 字符串。"
          },
          "status": {
            "anyOf": [
              {
                "type": "string",
                "enum": [
                  "in_progress",
                  "completed",
                  "incomplete"
                ],
                "description": "项目的状态。 `in_progress`、`completed` 或 `incomplete` 之一。",
                "title": "string"
              },
              {
                "type": "null",
                "title": "null"
              }
            ]
          }
        },
        "required": [
          "id",
          "type",
          "call_id",
          "output"
        ]
      },
      "FunctionShellCall": {
        "properties": {
          "type": {
            "type": "string",
            "enum": [
              "shell_call"
            ],
            "description": "项目的类型。始终 `shell_call`。",
            "default": "shell_call",
            "x-stainless-const": true
          },
          "id": {
            "type": "string",
            "description": "shell工具调用的唯一ID。当通过 API 返回此项时填充。"
          },
          "call_id": {
            "type": "string",
            "description": "模型生成的shell工具调用的唯一ID。"
          },
          "action": {
            "$ref": "#/components/schemas/FunctionShellAction",
            "description": "描述如何运行工具调用的 shell 命令和限制。"
          },
          "status": {
            "$ref": "#/components/schemas/FunctionShellCallStatus",
            "description": "shell 调用的状态。 `in_progress`、`completed` 或 `incomplete` 之一。"
          },
          "environment": {
            "anyOf": [
              {
                "oneOf": [
                  {
                    "$ref": "#/components/schemas/LocalEnvironmentResource"
                  },
                  {
                    "$ref": "#/components/schemas/ContainerReferenceResource"
                  }
                ],
                "discriminator": {
                  "propertyName": "type"
                }
              },
              {
                "type": "null",
                "title": "null"
              }
            ]
          },
          "created_by": {
            "type": "string",
            "description": "创建此工具调用的实体的ID。"
          }
        },
        "type": "object",
        "required": [
          "type",
          "id",
          "call_id",
          "action",
          "status",
          "environment"
        ],
        "title": "Shell工具调用",
        "description": "在托管环境中执行一个或多个 shell 命令的工具调用。"
      },
      "FunctionShellCallOutput": {
        "properties": {
          "type": {
            "type": "string",
            "enum": [
              "shell_call_output"
            ],
            "description": "shell 调用输出的类型。始终 `shell_call_output`。",
            "default": "shell_call_output",
            "x-stainless-const": true
          },
          "id": {
            "type": "string",
            "description": "shell 调用输出的唯一 ID。当通过 API 返回此项时填充。"
          },
          "call_id": {
            "type": "string",
            "description": "模型生成的shell工具调用的唯一ID。"
          },
          "status": {
            "$ref": "#/components/schemas/FunctionShellCallOutputStatusEnum",
            "description": "shell 调用输出的状态。 `in_progress`、`completed` 或 `incomplete` 之一。"
          },
          "output": {
            "items": {
              "$ref": "#/components/schemas/FunctionShellCallOutputContent"
            },
            "type": "array",
            "description": "shell调用输出内容数组"
          },
          "max_output_length": {
            "anyOf": [
              {
                "type": "integer",
                "description": "shell命令输出的最大长度。这是由模型生成的，应与原始输出一起传回。",
                "title": "integer"
              },
              {
                "type": "null",
                "title": "null"
              }
            ]
          },
          "created_by": {
            "type": "string",
            "description": "创建该项目的参与者的标识符。"
          }
        },
        "type": "object",
        "required": [
          "type",
          "id",
          "call_id",
          "status",
          "output",
          "max_output_length"
        ],
        "title": "Shell 调用输出",
        "description": "发出的 shell 工具调用的输出。"
      },
      "ApplyPatchToolCall": {
        "properties": {
          "type": {
            "type": "string",
            "enum": [
              "apply_patch_call"
            ],
            "description": "项目的类型。始终 `apply_patch_call`。",
            "default": "apply_patch_call",
            "x-stainless-const": true
          },
          "id": {
            "type": "string",
            "description": "应用补丁工具调用的唯一ID。当通过 API 返回此项时填充。"
          },
          "call_id": {
            "type": "string",
            "description": "模型生成的应用补丁工具调用的唯一ID。"
          },
          "status": {
            "$ref": "#/components/schemas/ApplyPatchCallStatus",
            "description": "应用补丁工具调用的状态。 `in_progress` 或 `completed` 之一。"
          },
          "operation": {
            "oneOf": [
              {
                "$ref": "#/components/schemas/ApplyPatchCreateFileOperation"
              },
              {
                "$ref": "#/components/schemas/ApplyPatchDeleteFileOperation"
              },
              {
                "$ref": "#/components/schemas/ApplyPatchUpdateFileOperation"
              }
            ],
            "title": "应用补丁操作",
            "description": "通过apply_patch应用的create_file、delete_file或update_file操作之一。",
            "discriminator": {
              "propertyName": "type"
            }
          },
          "created_by": {
            "type": "string",
            "description": "创建此工具调用的实体的ID。"
          }
        },
        "type": "object",
        "required": [
          "type",
          "id",
          "call_id",
          "status",
          "operation"
        ],
        "title": "应用补丁工具调用",
        "description": "通过创建、删除或更新文件来应用文件差异的工具调用。"
      },
      "ApplyPatchToolCallOutput": {
        "properties": {
          "type": {
            "type": "string",
            "enum": [
              "apply_patch_call_output"
            ],
            "description": "项目的类型。始终 `apply_patch_call_output`。",
            "default": "apply_patch_call_output",
            "x-stainless-const": true
          },
          "id": {
            "type": "string",
            "description": "应用补丁工具调用输出的唯一ID。当通过 API 返回此项时填充。"
          },
          "call_id": {
            "type": "string",
            "description": "模型生成的应用补丁工具调用的唯一ID。"
          },
          "status": {
            "$ref": "#/components/schemas/ApplyPatchCallOutputStatus",
            "description": "应用补丁工具调用输出的状态。 `completed` 或 `failed` 之一。"
          },
          "output": {
            "anyOf": [
              {
                "type": "string",
                "description": "应用补丁工具返回的可选文本输出。",
                "title": "string"
              },
              {
                "type": "null",
                "title": "null"
              }
            ]
          },
          "created_by": {
            "type": "string",
            "description": "创建此工具调用输出的实体的 ID。"
          }
        },
        "type": "object",
        "required": [
          "type",
          "id",
          "call_id",
          "status"
        ],
        "title": "应用补丁工具调用输出",
        "description": "应用补丁工具调用发出的输出。"
      },
      "MCPToolCall": {
        "type": "object",
        "title": "MCP工具调用",
        "description": "MCP服务器上的工具的调用。",
        "properties": {
          "type": {
            "type": "string",
            "enum": [
              "mcp_call"
            ],
            "description": "项目的类型。始终 `mcp_call`。",
            "x-stainless-const": true
          },
          "id": {
            "type": "string",
            "description": "工具调用的唯一ID。"
          },
          "server_label": {
            "type": "string",
            "description": "运行该工具的MCP服务器的标签。"
          },
          "name": {
            "type": "string",
            "description": "运行的工具的名称。"
          },
          "arguments": {
            "type": "string",
            "description": "传递给工具的参数的 JSON 字符串。"
          },
          "output": {
            "anyOf": [
              {
                "type": "string",
                "description": "工具调用的输出。",
                "title": "string"
              },
              {
                "type": "null",
                "title": "null"
              }
            ]
          },
          "error": {
            "anyOf": [
              {
                "type": "string",
                "description": "工具调用的错误（如果有）。",
                "title": "string"
              },
              {
                "type": "null",
                "title": "null"
              }
            ]
          },
          "status": {
            "$ref": "#/components/schemas/MCPToolCallStatus",
            "description": "工具调用的状态。 `in_progress`、`completed`、`incomplete`、`calling` 或 `failed` 之一。"
          },
          "approval_request_id": {
            "anyOf": [
              {
                "type": "string",
                "description": "MCP工具调用批准请求的唯一标识符。\n将此值包含在后续的 `mcp_approval_response` 输入中以批准或拒绝相应的工具调用。",
                "title": "string"
              },
              {
                "type": "null",
                "title": "null"
              }
            ]
          }
        },
        "required": [
          "type",
          "id",
          "server_label",
          "name",
          "arguments"
        ]
      },
      "MCPListTools": {
        "type": "object",
        "title": "MCP列表工具",
        "description": "MCP服务器上可用的工具列表。",
        "properties": {
          "type": {
            "type": "string",
            "enum": [
              "mcp_list_tools"
            ],
            "description": "项目的类型。始终 `mcp_list_tools`。",
            "x-stainless-const": true
          },
          "id": {
            "type": "string",
            "description": "列表的唯一ID。"
          },
          "server_label": {
            "type": "string",
            "description": "MCP服务器的标签。"
          },
          "tools": {
            "type": "array",
            "items": {
              "$ref": "#/components/schemas/MCPListToolsTool"
            },
            "description": "服务器上可用的工具。"
          },
          "error": {
            "anyOf": [
              {
                "type": "string",
                "description": "如果服务器无法列出工具，则会出现错误消息。",
                "title": "string"
              },
              {
                "type": "null",
                "title": "null"
              }
            ]
          }
        },
        "required": [
          "type",
          "id",
          "server_label",
          "tools"
        ]
      },
      "MCPApprovalRequest": {
        "type": "object",
        "title": "MCP 批准请求",
        "description": "工具调用的人工批准请求。",
        "properties": {
          "type": {
            "type": "string",
            "enum": [
              "mcp_approval_request"
            ],
            "description": "项目的类型。始终 `mcp_approval_request`。",
            "x-stainless-const": true
          },
          "id": {
            "type": "string",
            "description": "批准请求的唯一ID。"
          },
          "server_label": {
            "type": "string",
            "description": "发出请求的MCP服务器的标签。"
          },
          "name": {
            "type": "string",
            "description": "要运行的工具的名称。"
          },
          "arguments": {
            "type": "string",
            "description": "该工具的 JSON 参数字符串。"
          }
        },
        "required": [
          "type",
          "id",
          "server_label",
          "name",
          "arguments"
        ]
      },
      "MCPApprovalResponseResource": {
        "type": "object",
        "title": "MCP批准响应",
        "description": "对MCP批准请求的响应。",
        "properties": {
          "type": {
            "type": "string",
            "enum": [
              "mcp_approval_response"
            ],
            "description": "项目的类型。始终 `mcp_approval_response`。",
            "x-stainless-const": true
          },
          "id": {
            "type": "string",
            "description": "批准响应的唯一ID"
          },
          "approval_request_id": {
            "type": "string",
            "description": "正在答复的批准请求的ID。"
          },
          "approve": {
            "type": "boolean",
            "description": "请求是否被批准。"
          },
          "reason": {
            "anyOf": [
              {
                "type": "string",
                "description": "可选的决定原因。",
                "title": "string"
              },
              {
                "type": "null",
                "title": "null"
              }
            ]
          }
        },
        "required": [
          "type",
          "id",
          "request_id",
          "approve",
          "approval_request_id"
        ]
      },
      "CustomToolCall": {
        "type": "object",
        "title": "自定义工具调用",
        "description": "对模型创建的自定义工具的调用。",
        "properties": {
          "type": {
            "type": "string",
            "enum": [
              "custom_tool_call"
            ],
            "x-stainless-const": true,
            "description": "自定义工具调用的类型。始终 `custom_tool_call`。"
          },
          "id": {
            "type": "string",
            "description": "自定义工具调用在OpenAI平台中的唯一ID。"
          },
          "call_id": {
            "type": "string",
            "description": "用于将该自定义工具调用映射到工具调用输出的标识符。"
          },
          "namespace": {
            "type": "string",
            "description": "被调用的自定义工具的命名空间。"
          },
          "name": {
            "type": "string",
            "description": "被调用的自定义工具的名称。"
          },
          "input": {
            "type": "string",
            "description": "模型生成的自定义工具调用的输入。"
          }
        },
        "required": [
          "type",
          "call_id",
          "name",
          "input"
        ]
      },
      "CustomToolCallOutputResource": {
        "title": "响应自定义工具调用输出项",
        "allOf": [
          {
            "$ref": "#/components/schemas/CustomToolCallOutput"
          },
          {
            "type": "object",
            "properties": {
              "id": {
                "type": "string",
                "description": "自定义工具调用输出项的唯一ID。"
              },
              "status": {
                "description": "项目的状态。 `in_progress`、`completed` 之一，或\n`incomplete`。当通过 API 返回项目时填充。",
                "$ref": "#/components/schemas/FunctionCallOutputStatusEnum"
              },
              "created_by": {
                "type": "string",
                "description": "创建该项目的参与者的标识符。"
              }
            },
            "required": [
              "id",
              "status"
            ]
          }
        ]
      },
      "EasyInputMessage": {
        "type": "object",
        "title": "输入消息",
        "description": "输入到模型的消息，其角色指示后面的指令\n层次结构。使用 `developer` 或 `system` 角色给出的指令\n优先于 `user` 角色给出的指令。消息与\n`assistant` 角色被假定是由之前的模型生成的\n互动。",
        "properties": {
          "role": {
            "type": "string",
            "description": "消息输入的作用。 `user`、`assistant`、`system` 之一，或\n`developer`。",
            "enum": [
              "user",
              "assistant",
              "system",
              "developer"
            ]
          },
          "content": {
            "description": "输入到模型的文本、图像或音频，用于生成响应。\n还可以包含以前的助理回复。",
            "oneOf": [
              {
                "type": "string",
                "title": "文字输入",
                "description": "输入到模型的文本。"
              },
              {
                "$ref": "#/components/schemas/InputMessageContentList"
              }
            ]
          },
          "phase": {
            "anyOf": [
              {
                "$ref": "#/components/schemas/MessagePhase"
              },
              {
                "type": "null",
                "title": "null"
              }
            ]
          },
          "type": {
            "type": "string",
            "description": "消息输入的类型。始终 `message`。",
            "enum": [
              "message"
            ],
            "x-stainless-const": true
          }
        },
        "required": [
          "role",
          "content"
        ]
      },
      "Item": {
        "type": "object",
        "description": "用于生成响应的内容项。",
        "oneOf": [
          {
            "$ref": "#/components/schemas/InputMessage"
          },
          {
            "$ref": "#/components/schemas/OutputMessage"
          },
          {
            "$ref": "#/components/schemas/FileSearchToolCall"
          },
          {
            "$ref": "#/components/schemas/ComputerToolCall"
          },
          {
            "$ref": "#/components/schemas/ComputerCallOutputItemParam"
          },
          {
            "$ref": "#/components/schemas/WebSearchToolCall"
          },
          {
            "$ref": "#/components/schemas/FunctionToolCall"
          },
          {
            "$ref": "#/components/schemas/FunctionCallOutputItemParam"
          },
          {
            "$ref": "#/components/schemas/ToolSearchCallItemParam"
          },
          {
            "$ref": "#/components/schemas/ToolSearchOutputItemParam"
          },
          {
            "$ref": "#/components/schemas/ReasoningItem"
          },
          {
            "$ref": "#/components/schemas/CompactionSummaryItemParam"
          },
          {
            "$ref": "#/components/schemas/ImageGenToolCall"
          },
          {
            "$ref": "#/components/schemas/CodeInterpreterToolCall"
          },
          {
            "$ref": "#/components/schemas/LocalShellToolCall"
          },
          {
            "$ref": "#/components/schemas/LocalShellToolCallOutput"
          },
          {
            "$ref": "#/components/schemas/FunctionShellCallItemParam"
          },
          {
            "$ref": "#/components/schemas/FunctionShellCallOutputItemParam"
          },
          {
            "$ref": "#/components/schemas/ApplyPatchToolCallItemParam"
          },
          {
            "$ref": "#/components/schemas/ApplyPatchToolCallOutputItemParam"
          },
          {
            "$ref": "#/components/schemas/MCPListTools"
          },
          {
            "$ref": "#/components/schemas/MCPApprovalRequest"
          },
          {
            "$ref": "#/components/schemas/MCPApprovalResponse"
          },
          {
            "$ref": "#/components/schemas/MCPToolCall"
          },
          {
            "$ref": "#/components/schemas/CustomToolCallOutput"
          },
          {
            "$ref": "#/components/schemas/CustomToolCall"
          }
        ],
        "discriminator": {
          "propertyName": "type"
        }
      },
      "ItemReferenceParam": {
        "properties": {
          "type": {
            "anyOf": [
              {
                "type": "string",
                "enum": [
                  "item_reference"
                ],
                "description": "要引用的项目的类型。始终 `item_reference`。",
                "default": "item_reference",
                "x-stainless-const": true,
                "title": "string"
              },
              {
                "type": "null",
                "title": "null"
              }
            ]
          },
          "id": {
            "type": "string",
            "description": "要引用的项目的ID。"
          }
        },
        "type": "object",
        "required": [
          "id"
        ],
        "title": "物品参考",
        "description": "要引用的项目的内部标识符。"
      },
      "OutputContent": {
        "oneOf": [
          {
            "$ref": "#/components/schemas/OutputTextContent"
          },
          {
            "$ref": "#/components/schemas/RefusalContent"
          },
          {
            "$ref": "#/components/schemas/ReasoningTextContent"
          }
        ],
        "discriminator": {
          "propertyName": "type"
        }
      },
      "ResponseLogProb": {
        "type": "object",
        "description": "logprob 是模型分配给生产的对数概率 \n序列中给定位置处的特定标记。负值较小（较高） \nlogprob 值表明模型对该标记选择的置信度更高。",
        "properties": {
          "token": {
            "description": "可能的文本标记。",
            "type": "string"
          },
          "logprob": {
            "description": "该token的对数概率。",
            "type": "number"
          },
          "top_logprobs": {
            "description": "最多 20 个最可能标记的对数概率。",
            "type": "array",
            "items": {
              "type": "object",
              "properties": {
                "token": {
                  "description": "可能的文本标记。",
                  "type": "string"
                },
                "logprob": {
                  "description": "该token的对数概率。",
                  "type": "number"
                }
              }
            }
          }
        },
        "required": [
          "token",
          "logprob"
        ]
      },
      "FunctionTool": {
        "properties": {
          "type": {
            "type": "string",
            "enum": [
              "function"
            ],
            "description": "功能工具的类型。始终 `function`。",
            "default": "function",
            "x-stainless-const": true
          },
          "name": {
            "type": "string",
            "description": "要调用的函数的名称。"
          },
          "description": {
            "anyOf": [
              {
                "type": "string",
                "description": "功能的描述。模型使用它来确定是否调用该函数。",
                "title": "string"
              },
              {
                "type": "null",
                "title": "null"
              }
            ]
          },
          "parameters": {
            "anyOf": [
              {
                "additionalProperties": {},
                "type": "object",
                "description": "描述函数参数的JSON模式对象。",
                "x-oaiTypeLabel": "map",
                "title": "object"
              },
              {
                "type": "null",
                "title": "null"
              }
            ]
          },
          "strict": {
            "anyOf": [
              {
                "type": "boolean",
                "description": "是否强制执行严格的参数验证。默认 `true`。",
                "title": "boolean"
              },
              {
                "type": "null",
                "title": "null"
              }
            ]
          },
          "defer_loading": {
            "type": "boolean",
            "description": "该函数是否通过工具搜索延迟加载。"
          }
        },
        "type": "object",
        "required": [
          "type",
          "name",
          "strict",
          "parameters"
        ],
        "title": "功能",
        "description": "在您自己的代码中定义模型可以选择调用的函数。了解有关[函数调用](https://platform.openai.com/docs/guides/function-calling) 的更多信息。"
      },
      "FileSearchTool": {
        "properties": {
          "type": {
            "type": "string",
            "enum": [
              "file_search"
            ],
            "description": "文件搜索工具的类型。始终 `file_search`。",
            "default": "file_search",
            "x-stainless-const": true
          },
          "vector_store_ids": {
            "items": {
              "type": "string"
            },
            "type": "array",
            "description": "要搜索的向量存储的ID。"
          },
          "max_num_results": {
            "type": "integer",
            "description": "返回结果的最大数量。该数字应介于 1 到 50 之间（含 1 和 50）。"
          },
          "ranking_options": {
            "$ref": "#/components/schemas/RankingOptions",
            "description": "搜索排名选项。"
          },
          "filters": {
            "anyOf": [
              {
                "$ref": "#/components/schemas/Filters",
                "description": "要应用的过滤器。"
              },
              {
                "type": "null",
                "title": "null"
              }
            ]
          }
        },
        "type": "object",
        "required": [
          "type",
          "vector_store_ids"
        ],
        "title": "文件搜索",
        "description": "从上传的文件中搜索相关内容的工具。了解有关[文件搜索工具](https://platform.openai.com/docs/guides/tools-file-search) 的更多信息。"
      },
      "ComputerTool": {
        "properties": {
          "type": {
            "type": "string",
            "enum": [
              "computer"
            ],
            "description": "计算机工具的类型。始终 `computer`。",
            "default": "computer",
            "x-stainless-const": true
          }
        },
        "type": "object",
        "required": [
          "type"
        ],
        "title": "电脑",
        "description": "控制虚拟计算机的工具。了解有关[计算机工具](https://platform.openai.com/docs/guides/tools-computer-use) 的更多信息。"
      },
      "ComputerUsePreviewTool": {
        "properties": {
          "type": {
            "type": "string",
            "enum": [
              "computer_use_preview"
            ],
            "description": "计算机使用工具的类型。始终 `computer_use_preview`。",
            "default": "computer_use_preview",
            "x-stainless-const": true
          },
          "environment": {
            "$ref": "#/components/schemas/ComputerEnvironment",
            "description": "要控制的计算机环境的类型。"
          },
          "display_width": {
            "type": "integer",
            "description": "计算机显示屏的宽度。"
          },
          "display_height": {
            "type": "integer",
            "description": "计算机显示器的高度。"
          }
        },
        "type": "object",
        "required": [
          "type",
          "environment",
          "display_width",
          "display_height"
        ],
        "title": "电脑使用预览",
        "description": "控制虚拟计算机的工具。了解有关[计算机工具](https://platform.openai.com/docs/guides/tools-computer-use) 的更多信息。"
      },
      "WebSearchTool": {
        "type": "object",
        "title": "网络搜索",
        "description": "在互联网上搜索与该提示相关的来源。了解更多关于\n[网络搜索工具](https://platform.openai.com/docs/guides/tools-web-search)。",
        "properties": {
          "type": {
            "type": "string",
            "enum": [
              "web_search",
              "web_search_2025_08_26"
            ],
            "description": "网络搜索工具的类型。 `web_search` 或 `web_search_2025_08_26` 之一。",
            "default": "web_search"
          },
          "filters": {
            "anyOf": [
              {
                "type": "object",
                "description": "搜索过滤器。",
                "properties": {
                  "allowed_domains": {
                    "anyOf": [
                      {
                        "type": "array",
                        "title": "允许搜索的域。",
                        "description": "允许搜索的域。如果未提供，则允许所有域。\n所提供域的子域也是允许的。\n\n示例：`[\"pubmed.ncbi.nlm.nih.gov\"]`",
                        "items": {
                          "type": "string",
                          "description": "允许搜索的域。"
                        },
                        "default": []
                      },
                      {
                        "type": "null",
                        "title": "null"
                      }
                    ]
                  }
                },
                "title": "object"
              },
              {
                "type": "null",
                "title": "null"
              }
            ]
          },
          "user_location": {
            "$ref": "#/components/schemas/WebSearchApproximateLocation"
          },
          "search_context_size": {
            "type": "string",
            "enum": [
              "low",
              "medium",
              "high"
            ],
            "default": "medium",
            "description": "用于搜索的上下文窗口空间量的高级指南。 `low`、`medium` 或 `high` 之一。 `medium` 是默认值。"
          }
        },
        "required": [
          "type"
        ]
      },
      "MCPTool": {
        "type": "object",
        "title": "MCP工具",
        "description": "通过远程模型上下文协议让模型访问其他工具\n（MCP）服务器。 [了解有关 MCP 的更多信息](https://platform.openai.com/docs/guides/tools-remote-mcp)。",
        "properties": {
          "type": {
            "type": "string",
            "enum": [
              "mcp"
            ],
            "description": "MCP工具的类型。始终 `mcp`。",
            "x-stainless-const": true
          },
          "server_label": {
            "type": "string",
            "description": "该MCP服务器的标签，用于在工具调用中识别它。"
          },
          "server_url": {
            "type": "string",
            "format": "uri",
            "description": "MCP服务器的URL。 `server_url` 或 `connector_id` 之一必须是\n提供。"
          },
          "connector_id": {
            "type": "string",
            "enum": [
              "connector_dropbox",
              "connector_gmail",
              "connector_googlecalendar",
              "connector_googledrive",
              "connector_microsoftteams",
              "connector_outlookcalendar",
              "connector_outlookemail",
              "connector_sharepoint"
            ],
            "description": "服务连接器的标识符，如 ChatGPT 中提供的标识符。其中之一\n必须提供 `server_url` 或 `connector_id`。了解更多服务信息\n连接器[此处](https://platform.openai.com/docs/guides/tools-remote-mcp#connectors)。\n\n目前支持的 `connector_id` 值有：\n\n- Dropbox：`connector_dropbox`\n- Gmail：`connector_gmail`\n- 谷歌日历：`connector_googlecalendar`\n- 谷歌云端硬盘：`connector_googledrive`\n- 微软团队：`connector_microsoftteams`\n- Outlook 日历：`connector_outlookcalendar`\n- Outlook 电子邮件：`connector_outlookemail`\n- SharePoint：`connector_sharepoint`"
          },
          "authorization": {
            "type": "string",
            "description": "可与远程 MCP 服务器一起使用的 OAuth 访问token\n使用自定义 MCP 服务器 URL 或服务连接器。您的申请\n必须处理 OAuth 授权流程并在此处提供token。"
          },
          "server_description": {
            "type": "string",
            "description": "MCP服务器的可选描述，用于提供更多上下文。"
          },
          "headers": {
            "anyOf": [
              {
                "type": "object",
                "additionalProperties": {
                  "type": "string"
                },
                "description": "发送到MCP服务器的可选HTTP标头。用于身份验证\n或其他目的。",
                "title": "object"
              },
              {
                "type": "null",
                "title": "null"
              }
            ]
          },
          "allowed_tools": {
            "anyOf": [
              {
                "description": "允许的工具名称或过滤器对象的列表。",
                "oneOf": [
                  {
                    "type": "array",
                    "title": "MCP允许的工具",
                    "description": "允许的工具名称的字符串数组",
                    "items": {
                      "type": "string"
                    }
                  },
                  {
                    "$ref": "#/components/schemas/MCPToolFilter"
                  }
                ]
              },
              {
                "type": "null",
                "title": "null"
              }
            ]
          },
          "require_approval": {
            "anyOf": [
              {
                "description": "指定哪些MCP服务器工具需要批准。",
                "oneOf": [
                  {
                    "type": "object",
                    "title": "MCP工具批准过滤器",
                    "description": "指定哪些MCP服务器工具需要批准。可以是\n`always`、`never` 或与工具关联的过滤器对象\n需要批准的。",
                    "properties": {
                      "always": {
                        "$ref": "#/components/schemas/MCPToolFilter"
                      },
                      "never": {
                        "$ref": "#/components/schemas/MCPToolFilter"
                      }
                    },
                    "additionalProperties": false
                  },
                  {
                    "type": "string",
                    "title": "MCP工具认可设置",
                    "description": "为所有工具指定单一批准策略。 `always` 或之一\n`never`。当设置为 `always` 时，所有工具都需要批准。当\n设置为 `never`，所有工具都不需要批准。",
                    "enum": [
                      "always",
                      "never"
                    ]
                  }
                ],
                "default": "always"
              },
              {
                "type": "null",
                "title": "null"
              }
            ]
          },
          "defer_loading": {
            "type": "boolean",
            "description": "该MCP工具是否被推迟并通过工具搜索发现。"
          }
        },
        "required": [
          "type",
          "server_label"
        ]
      },
      "CodeInterpreterTool": {
        "type": "object",
        "title": "代码解释器",
        "description": "运行 Python 代码以帮助生成对提示的响应的工具。",
        "properties": {
          "type": {
            "type": "string",
            "enum": [
              "code_interpreter"
            ],
            "description": "代码解释工具的类型。始终 `code_interpreter`。",
            "x-stainless-const": true
          },
          "container": {
            "description": "代码解释器容器。可以是容器 ID 或对象\n指定上传的文件 ID 以供您的代码使用，以及\n可选 `memory_limit` 设置。",
            "oneOf": [
              {
                "type": "string",
                "description": "容器ID。",
                "title": "string"
              },
              {
                "$ref": "#/components/schemas/AutoCodeInterpreterToolParam"
              }
            ]
          }
        },
        "required": [
          "type",
          "container"
        ]
      },
      "ImageGenTool": {
        "type": "object",
        "title": "图像生成工具",
        "description": "使用GPT图像模型生成图像的工具。",
        "properties": {
          "type": {
            "type": "string",
            "enum": [
              "image_generation"
            ],
            "description": "图像生成工具的类型。始终 `image_generation`。",
            "x-stainless-const": true
          },
          "model": {
            "anyOf": [
              {
                "type": "string",
                "title": "string"
              },
              {
                "type": "string",
                "enum": [
                  "gpt-image-1",
                  "gpt-image-1-mini",
                  "gpt-image-1.5"
                ],
                "description": "要使用的图像生成模型。默认值：`gpt-image-1`。",
                "default": "gpt-image-1",
                "title": "string"
              }
            ]
          },
          "quality": {
            "type": "string",
            "enum": [
              "low",
              "medium",
              "high",
              "auto"
            ],
            "description": "生成的图像的质量。 `low`、`medium`、`high` 之一，\n或 `auto`。默认值：`auto`。",
            "default": "auto"
          },
          "size": {
            "anyOf": [
              {
                "type": "string",
                "title": "string"
              },
              {
                "type": "string",
                "enum": [
                  "1024x1024",
                  "1024x1536",
                  "1536x1024",
                  "auto"
                ],
                "title": "string"
              }
            ],
            "description": "生成图像的尺寸。对于 `gpt-image-2` 和 `gpt-image-2-2026-04-21`，支持任意分辨率作为 `WIDTHxHEIGHT` 字符串，例如 `1536x864`。宽度和高度必须都能被 16 整除，并且请求的长宽比必须在 1:3 到 3:1 之间。 `2560x1440` 以上的分辨率是实验性的，支持的最大分辨率是 `3840x2160`。请求的大小还必须满足模型当前的像素和边缘限制。 GPT 图像模型支持标准尺寸 `1024x1024`、`1536x1024` 和 `1024x1536`；允许自动调整大小的型号支持 `auto`。对于 `dall-e-2`，请使用 `256x256`、`512x512` 或 `1024x1024` 之一。对于 `dall-e-3`，请使用 `1024x1024`、`1792x1024` 或 `1024x1792` 之一。",
            "default": "auto"
          },
          "output_format": {
            "type": "string",
            "enum": [
              "png",
              "webp",
              "jpeg"
            ],
            "description": "生成图像的输出格式。 `png`、`webp` 之一，或\n`jpeg`。默认值：`png`。",
            "default": "png"
          },
          "output_compression": {
            "type": "integer",
            "minimum": 0,
            "maximum": 100,
            "description": "输出图像的压缩级别。默认值：100。",
            "default": 100
          },
          "moderation": {
            "type": "string",
            "enum": [
              "auto",
              "low"
            ],
            "description": "生成的图像的审核级别。默认值：`auto`。",
            "default": "auto"
          },
          "background": {
            "type": "string",
            "enum": [
              "transparent",
              "opaque",
              "auto"
            ],
            "description": "生成的图像的背景类型。 `transparent` 之一，\n`opaque` 或 `auto`。默认值：`auto`。",
            "default": "auto"
          },
          "input_fidelity": {
            "anyOf": [
              {
                "$ref": "#/components/schemas/InputFidelity"
              },
              {
                "type": "null",
                "title": "null"
              }
            ]
          },
          "input_image_mask": {
            "type": "object",
            "description": "可选的修复掩模。包含 `image_url`\n（字符串，可选）和 `file_id` （字符串，可选）。",
            "properties": {
              "image_url": {
                "type": "string",
                "description": "Base64编码的掩模图像。"
              },
              "file_id": {
                "type": "string",
                "description": "掩模图像的文件ID。"
              }
            },
            "required": [],
            "additionalProperties": false
          },
          "partial_images": {
            "type": "integer",
            "minimum": 0,
            "maximum": 3,
            "description": "流模式下生成的部分图像的数量，从0（默认值）到3。",
            "default": 0
          },
          "action": {
            "description": "是否生成新图像或编辑现有图像。默认值：`auto`。",
            "$ref": "#/components/schemas/ImageGenActionEnum"
          }
        },
        "required": [
          "type"
        ]
      },
      "LocalShellToolParam": {
        "properties": {
          "type": {
            "type": "string",
            "enum": [
              "local_shell"
            ],
            "description": "本地shell工具的类型。始终 `local_shell`。",
            "default": "local_shell",
            "x-stainless-const": true
          }
        },
        "type": "object",
        "required": [
          "type"
        ],
        "title": "本地shell工具",
        "description": "允许模型在本地环境中执行shell命令的工具。"
      },
      "FunctionShellToolParam": {
        "properties": {
          "type": {
            "type": "string",
            "enum": [
              "shell"
            ],
            "description": "shell工具的类型。始终 `shell`。",
            "default": "shell",
            "x-stainless-const": true
          },
          "environment": {
            "anyOf": [
              {
                "oneOf": [
                  {
                    "$ref": "#/components/schemas/ContainerAutoParam"
                  },
                  {
                    "$ref": "#/components/schemas/LocalEnvironmentParam"
                  },
                  {
                    "$ref": "#/components/schemas/ContainerReferenceParam"
                  }
                ],
                "discriminator": {
                  "propertyName": "type"
                }
              },
              {
                "type": "null",
                "title": "null"
              }
            ]
          }
        },
        "type": "object",
        "required": [
          "type"
        ],
        "title": "脱壳工具",
        "description": "允许模型执行shell命令的工具。"
      },
      "CustomToolParam": {
        "properties": {
          "type": {
            "type": "string",
            "enum": [
              "custom"
            ],
            "description": "自定义工具的类型。始终 `custom`。",
            "default": "custom",
            "x-stainless-const": true
          },
          "name": {
            "type": "string",
            "description": "自定义工具的名称，用于在工具调用中标识它。"
          },
          "description": {
            "type": "string",
            "description": "自定义工具的可选描述，用于提供更多上下文。"
          },
          "format": {
            "oneOf": [
              {
                "$ref": "#/components/schemas/CustomTextFormatParam"
              },
              {
                "$ref": "#/components/schemas/CustomGrammarFormatParam"
              }
            ],
            "description": "自定义工具的输入格式。默认为不受约束的文本。",
            "discriminator": {
              "propertyName": "type"
            }
          },
          "defer_loading": {
            "type": "boolean",
            "description": "是否应推迟并通过工具搜索发现该工具。"
          }
        },
        "type": "object",
        "required": [
          "type",
          "name"
        ],
        "title": "自定义工具",
        "description": "使用指定格式处理输入的自定义工具。了解有关[自定义工具](https://platform.openai.com/docs/guides/function-calling#custom-tools)的更多信息"
      },
      "NamespaceToolParam": {
        "properties": {
          "type": {
            "type": "string",
            "enum": [
              "namespace"
            ],
            "description": "工具的类型。始终 `namespace`。",
            "default": "namespace",
            "x-stainless-const": true
          },
          "name": {
            "type": "string",
            "minLength": 1,
            "description": "工具调用中使用的命名空间名称（例如，`crm`）。"
          },
          "description": {
            "type": "string",
            "minLength": 1,
            "description": "向模型显示的命名空间的描述。"
          },
          "tools": {
            "items": {
              "oneOf": [
                {
                  "$ref": "#/components/schemas/FunctionToolParam"
                },
                {
                  "$ref": "#/components/schemas/CustomToolParam"
                }
              ],
              "description": "属于命名空间的函数或自定义工具。",
              "discriminator": {
                "propertyName": "type"
              }
            },
            "type": "array",
            "minItems": 1,
            "description": "该命名空间内可用的函数/自定义工具。"
          }
        },
        "type": "object",
        "required": [
          "type",
          "name",
          "description",
          "tools"
        ],
        "title": "命名空间",
        "description": "将功能/自定义工具分组到共享命名空间下。"
      },
      "ToolSearchToolParam": {
        "properties": {
          "type": {
            "type": "string",
            "enum": [
              "tool_search"
            ],
            "description": "工具的类型。始终 `tool_search`。",
            "default": "tool_search",
            "x-stainless-const": true
          },
          "execution": {
            "$ref": "#/components/schemas/ToolSearchExecutionType",
            "description": "工具搜索是由服务器执行还是由客户端执行。"
          },
          "description": {
            "anyOf": [
              {
                "type": "string",
                "description": "对客户端执行工具搜索工具的模型进行说明。",
                "title": "string"
              },
              {
                "type": "null",
                "title": "null"
              }
            ]
          },
          "parameters": {
            "anyOf": [
              {
                "$ref": "#/components/schemas/EmptyModelParam",
                "description": "客户端执行的工具搜索工具的参数模式。"
              },
              {
                "type": "null",
                "title": "null"
              }
            ]
          }
        },
        "type": "object",
        "required": [
          "type"
        ],
        "title": "工具搜索工具",
        "description": "延迟工具的托管或 BYOT 工具搜索配置。"
      },
      "WebSearchPreviewTool": {
        "properties": {
          "type": {
            "type": "string",
            "enum": [
              "web_search_preview",
              "web_search_preview_2025_03_11"
            ],
            "description": "网络搜索工具的类型。 `web_search_preview` 或 `web_search_preview_2025_03_11` 之一。",
            "default": "web_search_preview",
            "x-stainless-const": true
          },
          "user_location": {
            "anyOf": [
              {
                "$ref": "#/components/schemas/ApproximateLocation",
                "description": "用户的位置。"
              },
              {
                "type": "null",
                "title": "null"
              }
            ]
          },
          "search_context_size": {
            "$ref": "#/components/schemas/SearchContextSize",
            "description": "用于搜索的上下文窗口空间量的高级指南。 `low`、`medium` 或 `high` 之一。 `medium` 是默认值。"
          },
          "search_content_types": {
            "items": {
              "$ref": "#/components/schemas/SearchContentType"
            },
            "type": "array"
          }
        },
        "type": "object",
        "required": [
          "type"
        ],
        "title": "网页搜索预览",
        "description": "该工具在网络上搜索相关结果以在响应中使用。了解有关[网络搜索工具](https://platform.openai.com/docs/guides/tools-web-search) 的更多信息。"
      },
      "ApplyPatchToolParam": {
        "properties": {
          "type": {
            "type": "string",
            "enum": [
              "apply_patch"
            ],
            "description": "工具的类型。始终 `apply_patch`。",
            "default": "apply_patch",
            "x-stainless-const": true
          }
        },
        "type": "object",
        "required": [
          "type"
        ],
        "title": "应用补丁工具",
        "description": "允许助手使用统一差异创建、删除或更新文件。"
      },
      "TextResponseFormatConfiguration": {
        "description": "指定模型必须输出的格式的对象。\n\n配置 `{ \"type\": \"json_schema\" }` 启用结构化输出， \n这可确保模型与您提供的 JSON 架构匹配。了解更多信息 \n[结构化输出指南](https://platform.openai.com/docs/guides/structured-outputs)。\n\n默认格式为 `{ \"type\": \"text\" }`，没有其他选项。\n\n**不推荐用于 gpt-4o 及更新型号：**\n\n设置为 `{ \"type\": \"json_object\" }` 启用旧的 JSON 模式，这\n确保模型生成的消息是有效的 JSON。使用 `json_schema`\n对于支持它的模型是首选。",
        "oneOf": [
          {
            "$ref": "#/components/schemas/ResponseFormatText"
          },
          {
            "$ref": "#/components/schemas/TextResponseFormatJsonSchema"
          },
          {
            "$ref": "#/components/schemas/ResponseFormatJsonObject"
          }
        ]
      },
      "Verbosity": {
        "anyOf": [
          {
            "type": "string",
            "enum": [
              "low",
              "medium",
              "high"
            ],
            "default": "medium",
            "description": "限制模型响应的冗长程度。较低的值将导致\n更简洁的响应，而更高的值将导致更详细的响应。\n当前支持的值为 `low`、`medium` 和 `high`。",
            "title": "string"
          },
          {
            "type": "null",
            "title": "null"
          }
        ]
      },
      "ReasoningEffort": {
        "anyOf": [
          {
            "type": "string",
            "enum": [
              "none",
              "minimal",
              "low",
              "medium",
              "high",
              "xhigh"
            ],
            "default": "medium",
            "description": "限制推理的努力\n[推理模型](https://platform.openai.com/docs/guides/reasoning)。\n当前支持的值为 `none`、`minimal`、`low`、`medium`、`high` 和 `xhigh`。减少\n推理工作可以导致更快的响应和更少的token使用\n关于响应中的推理。\n\n- `gpt-5.1` 默认为 `none`，不进行推理。 `gpt-5.1` 支持的推理值为 `none`、`low`、`medium` 和 `high`。 gpt-5.1 中的所有推理值都支持工具调用。\n- `gpt-5.1`之前的所有模型默认为`medium`推理工作，并且不支持`none`。\n- `gpt-5-pro` 模型默认为（且仅支持）`high` 推理工作。\n- `gpt-5.1-codex-max` 之后的所有型号均支持 `xhigh`。",
            "title": "string"
          },
          {
            "type": "null",
            "title": "null"
          }
        ]
      },
      "ToolChoiceOptions": {
        "type": "string",
        "title": "刀具选择模式",
        "description": "控制模型调用哪个（如果有）工具。\n\n`none` 表示模型不会调用任何工具，而是生成一条消息。\n\n`auto` 表示模型可以在生成消息或调用一个或多个消息之间进行选择\n更多工具。\n\n`required` 表示模型必须调用一个或多个工具。",
        "enum": [
          "none",
          "auto",
          "required"
        ]
      },
      "ToolChoiceAllowed": {
        "type": "object",
        "title": "允许的工具",
        "description": "将模型可用的工具限制为预定义的集合。",
        "properties": {
          "type": {
            "type": "string",
            "enum": [
              "allowed_tools"
            ],
            "description": "允许的工具配置类型。始终 `allowed_tools`。",
            "x-stainless-const": true
          },
          "mode": {
            "type": "string",
            "enum": [
              "auto",
              "required"
            ],
            "description": "将模型可用的工具限制为预定义的集合。\n\n`auto` 允许模型从允许的工具中进行选择并生成\n消息。\n\n`required` 要求模型调用一个或多个允许的工具。"
          },
          "tools": {
            "type": "array",
            "description": "应该允许模型调用的工具定义列表。\n\n对于响应 API，工具定义列表可能如下所示：\n```json\n[\n  { \"type\": \"function\", \"name\": \"get_weather\" },\n  { \"type\": \"mcp\", \"server_label\": \"deepwiki\" },\n  { \"type\": \"image_generation\" }\n]\n```",
            "items": {
              "type": "object",
              "description": "应该允许模型调用的工具定义。",
              "additionalProperties": true,
              "x-oaiExpandable": false
            }
          }
        },
        "required": [
          "type",
          "mode",
          "tools"
        ]
      },
      "ToolChoiceTypes": {
        "type": "object",
        "title": "托管工具",
        "description": "指示模型应使用内置工具来生成响应。\n[了解有关内置工具的更多信息](https://platform.openai.com/docs/guides/tools)。",
        "properties": {
          "type": {
            "type": "string",
            "description": "模型应使用的托管工具的类型。了解更多关于\n[内置工具](https://platform.openai.com/docs/guides/tools)。\n\n允许的值为：\n- `file_search`\n- `web_search_preview`\n- `computer`\n- `computer_use_preview`\n- `computer_use`\n- `code_interpreter`\n- `image_generation`",
            "enum": [
              "file_search",
              "web_search_preview",
              "computer",
              "computer_use_preview",
              "computer_use",
              "web_search_preview_2025_03_11",
              "image_generation",
              "code_interpreter"
            ]
          }
        },
        "required": [
          "type"
        ]
      },
      "ToolChoiceFunction": {
        "type": "object",
        "title": "功能工具",
        "description": "使用此选项强制模型调用特定函数。",
        "properties": {
          "type": {
            "type": "string",
            "enum": [
              "function"
            ],
            "description": "对于函数调用，类型始终为`function`。",
            "x-stainless-const": true
          },
          "name": {
            "type": "string",
            "description": "要调用的函数的名称。"
          }
        },
        "required": [
          "type",
          "name"
        ]
      },
      "ToolChoiceMCP": {
        "type": "object",
        "title": "MCP工具",
        "description": "使用此选项强制模型调用远程 MCP 服务器上的特定工具。",
        "properties": {
          "type": {
            "type": "string",
            "enum": [
              "mcp"
            ],
            "description": "对于 MCP 工具，类型始终为 `mcp`。",
            "x-stainless-const": true
          },
          "server_label": {
            "type": "string",
            "description": "要使用的MCP服务器的标签。"
          },
          "name": {
            "anyOf": [
              {
                "type": "string",
                "description": "服务器上调用的工具的名称。",
                "title": "string"
              },
              {
                "type": "null",
                "title": "null"
              }
            ]
          }
        },
        "required": [
          "type",
          "server_label"
        ]
      },
      "ToolChoiceCustom": {
        "type": "object",
        "title": "自定义工具",
        "description": "使用此选项强制模型调用特定的自定义工具。",
        "properties": {
          "type": {
            "type": "string",
            "enum": [
              "custom"
            ],
            "description": "对于自定义工具调用，类型始终为`custom`。",
            "x-stainless-const": true
          },
          "name": {
            "type": "string",
            "description": "要调用的自定义工具的名称。"
          }
        },
        "required": [
          "type",
          "name"
        ]
      },
      "SpecificApplyPatchParam": {
        "properties": {
          "type": {
            "type": "string",
            "enum": [
              "apply_patch"
            ],
            "description": "要调用的工具。始终 `apply_patch`。",
            "default": "apply_patch",
            "x-stainless-const": true
          }
        },
        "type": "object",
        "required": [
          "type"
        ],
        "title": "具体应用补丁工具选择",
        "description": "强制模型在执行工具调用时调用apply_patch工具。"
      },
      "SpecificFunctionShellParam": {
        "properties": {
          "type": {
            "type": "string",
            "enum": [
              "shell"
            ],
            "description": "要调用的工具。始终 `shell`。",
            "default": "shell",
            "x-stainless-const": true
          }
        },
        "type": "object",
        "required": [
          "type"
        ],
        "title": "具体的shell工具选择",
        "description": "当需要调用工具时，强制模型调用shell工具。"
      },
      "Message": {
        "properties": {
          "type": {
            "type": "string",
            "enum": [
              "message"
            ],
            "description": "消息的类型。始终设置为 `message`。",
            "default": "message",
            "x-stainless-const": true
          },
          "id": {
            "type": "string",
            "description": "消息的唯一ID。"
          },
          "status": {
            "$ref": "#/components/schemas/MessageStatus",
            "description": "项目的状态。 `in_progress`、`completed` 或 `incomplete` 之一。当通过 API 返回项目时填充。"
          },
          "role": {
            "$ref": "#/components/schemas/MessageRole",
            "description": "消息的作用。 `unknown`、`user`、`assistant`、`system`、`critic`、`discriminator`、`developer` 或 `tool` 之一。"
          },
          "content": {
            "items": {
              "oneOf": [
                {
                  "$ref": "#/components/schemas/InputTextContent"
                },
                {
                  "$ref": "#/components/schemas/OutputTextContent"
                },
                {
                  "$ref": "#/components/schemas/TextContent"
                },
                {
                  "$ref": "#/components/schemas/SummaryTextContent"
                },
                {
                  "$ref": "#/components/schemas/ReasoningTextContent"
                },
                {
                  "$ref": "#/components/schemas/RefusalContent"
                },
                {
                  "$ref": "#/components/schemas/InputImageContent"
                },
                {
                  "$ref": "#/components/schemas/ComputerScreenshotContent"
                },
                {
                  "$ref": "#/components/schemas/InputFileContent"
                }
              ],
              "description": "组成输入或输出项的内容部分。",
              "discriminator": {
                "propertyName": "type"
              }
            },
            "type": "array",
            "description": "消息内容"
          },
          "phase": {
            "anyOf": [
              {
                "$ref": "#/components/schemas/MessagePhase-2",
                "description": "将 `assistant` 消息标记为中间评论 (`commentary`) 或最终答案 (`final_answer`)。对于 `gpt-5.3-codex` 及更高版本的模型，在发送后续请求时，保留并重新发送所有助理消息的阶段 - 删除它会降低性能。不用于用户消息。"
              },
              {
                "type": "null",
                "title": "null"
              }
            ]
          }
        },
        "type": "object",
        "required": [
          "type",
          "id",
          "status",
          "role",
          "content"
        ],
        "title": "留言",
        "description": "发送至模型或来自模型的消息。"
      },
      "FunctionToolCallOutput": {
        "type": "object",
        "title": "功能工具调用输出",
        "description": "功能工具调用的输出。",
        "properties": {
          "id": {
            "type": "string",
            "description": "功能工具调用输出的唯一ID。填充此项目时\n通过API返回。"
          },
          "type": {
            "type": "string",
            "enum": [
              "function_call_output"
            ],
            "description": "功能工具调用输出的类型。始终 `function_call_output`。",
            "x-stainless-const": true
          },
          "call_id": {
            "type": "string",
            "description": "模型生成的功能工具调用的唯一ID。"
          },
          "output": {
            "description": "由代码生成的函数调用的输出。\n可以是输出内容的字符串或列表。",
            "oneOf": [
              {
                "type": "string",
                "description": "函数调用的输出字符串。",
                "title": "字符串输出"
              },
              {
                "type": "array",
                "items": {
                  "$ref": "#/components/schemas/FunctionAndCustomToolCallOutput"
                },
                "title": "输出内容列表",
                "description": "函数调用的文本、图像或文件输出。"
              }
            ]
          },
          "status": {
            "type": "string",
            "description": "项目的状态。 `in_progress`、`completed` 之一，或\n`incomplete`。当通过 API 返回项目时填充。",
            "enum": [
              "in_progress",
              "completed",
              "incomplete"
            ]
          }
        },
        "required": [
          "type",
          "call_id",
          "output"
        ]
      },
      "CustomToolCallOutput": {
        "type": "object",
        "title": "自定义工具调用输出",
        "description": "来自代码的自定义工具调用的输出，被发送回模型。",
        "properties": {
          "type": {
            "type": "string",
            "enum": [
              "custom_tool_call_output"
            ],
            "x-stainless-const": true,
            "description": "自定义工具调用输出的类型。始终 `custom_tool_call_output`。"
          },
          "id": {
            "type": "string",
            "description": "自定义工具调用输出在OpenAI平台中的唯一ID。"
          },
          "call_id": {
            "type": "string",
            "description": "调用ID，用于将此自定义工具调用输出映射到自定义工具调用。"
          },
          "output": {
            "description": "由您的代码生成的自定义工具调用的输出。\n可以是输出内容的字符串或列表。",
            "oneOf": [
              {
                "type": "string",
                "description": "自定义工具调用的输出字符串。",
                "title": "字符串输出"
              },
              {
                "type": "array",
                "items": {
                  "$ref": "#/components/schemas/FunctionAndCustomToolCallOutput"
                },
                "title": "输出内容列表",
                "description": "自定义工具调用的文本、图像或文件输出。"
              }
            ]
          }
        },
        "required": [
          "type",
          "call_id",
          "output"
        ]
      },
      "ModelIdsShared": {
        "example": "gpt-5.4",
        "anyOf": [
          {
            "type": "string",
            "title": "string"
          },
          {
            "type": "string",
            "enum": [
              "gpt-5.4",
              "gpt-5.4-mini",
              "gpt-5.4-nano",
              "gpt-5.4-mini-2026-03-17",
              "gpt-5.4-nano-2026-03-17",
              "gpt-5.3-chat-latest",
              "gpt-5.2",
              "gpt-5.2-2025-12-11",
              "gpt-5.2-chat-latest",
              "gpt-5.2-pro",
              "gpt-5.2-pro-2025-12-11",
              "gpt-5.1",
              "gpt-5.1-2025-11-13",
              "gpt-5.1-codex",
              "gpt-5.1-mini",
              "gpt-5.1-chat-latest",
              "gpt-5",
              "gpt-5-mini",
              "gpt-5-nano",
              "gpt-5-2025-08-07",
              "gpt-5-mini-2025-08-07",
              "gpt-5-nano-2025-08-07",
              "gpt-5-chat-latest",
              "gpt-4.1",
              "gpt-4.1-mini",
              "gpt-4.1-nano",
              "gpt-4.1-2025-04-14",
              "gpt-4.1-mini-2025-04-14",
              "gpt-4.1-nano-2025-04-14",
              "o4-mini",
              "o4-mini-2025-04-16",
              "o3",
              "o3-2025-04-16",
              "o3-mini",
              "o3-mini-2025-01-31",
              "o1",
              "o1-2024-12-17",
              "o1-preview",
              "o1-preview-2024-09-12",
              "o1-mini",
              "o1-mini-2024-09-12",
              "gpt-4o",
              "gpt-4o-2024-11-20",
              "gpt-4o-2024-08-06",
              "gpt-4o-2024-05-13",
              "gpt-4o-audio-preview",
              "gpt-4o-audio-preview-2024-10-01",
              "gpt-4o-audio-preview-2024-12-17",
              "gpt-4o-audio-preview-2025-06-03",
              "gpt-4o-mini-audio-preview",
              "gpt-4o-mini-audio-preview-2024-12-17",
              "gpt-4o-search-preview",
              "gpt-4o-mini-search-preview",
              "gpt-4o-search-preview-2025-03-11",
              "gpt-4o-mini-search-preview-2025-03-11",
              "chatgpt-4o-latest",
              "codex-mini-latest",
              "gpt-4o-mini",
              "gpt-4o-mini-2024-07-18",
              "gpt-4-turbo",
              "gpt-4-turbo-2024-04-09",
              "gpt-4-0125-preview",
              "gpt-4-turbo-preview",
              "gpt-4-1106-preview",
              "gpt-4-vision-preview",
              "gpt-4",
              "gpt-4-0314",
              "gpt-4-0613",
              "gpt-4-32k",
              "gpt-4-32k-0314",
              "gpt-4-32k-0613",
              "gpt-3.5-turbo",
              "gpt-3.5-turbo-16k",
              "gpt-3.5-turbo-0301",
              "gpt-3.5-turbo-0613",
              "gpt-3.5-turbo-1106",
              "gpt-3.5-turbo-0125",
              "gpt-3.5-turbo-16k-0613"
            ],
            "title": "string"
          }
        ]
      },
      "ResponsePromptVariables": {
        "anyOf": [
          {
            "type": "object",
            "title": "提示变量",
            "description": "可选的值映射，用于替换您的变量中的变量\n提示。替换值可以是字符串，也可以是其他值\n响应输入类型，例如图像或文件。",
            "x-oaiExpandable": true,
            "x-oaiTypeLabel": "map",
            "additionalProperties": {
              "x-oaiExpandable": true,
              "x-oaiTypeLabel": "map",
              "oneOf": [
                {
                  "type": "string",
                  "title": "string"
                },
                {
                  "$ref": "#/components/schemas/InputTextContent"
                },
                {
                  "$ref": "#/components/schemas/InputImageContent"
                },
                {
                  "$ref": "#/components/schemas/InputFileContent"
                }
              ]
            }
          },
          {
            "type": "null",
            "title": "null"
          }
        ]
      },
      "OutputMessageContent": {
        "oneOf": [
          {
            "$ref": "#/components/schemas/OutputTextContent"
          },
          {
            "$ref": "#/components/schemas/RefusalContent"
          }
        ],
        "discriminator": {
          "propertyName": "type"
        }
      },
      "MessagePhase": {
        "type": "string",
        "description": "将 `assistant` 消息标记为中间评论 (`commentary`) 或最终答案 (`final_answer`)。\n对于 `gpt-5.3-codex` 及更高版本的模型，在发送后续请求时，保留并重新发送\n所有助理消息上的阶段 - 删除它会降低性能。不用于用户消息。",
        "enum": [
          "commentary",
          "final_answer"
        ]
      },
      "VectorStoreFileAttributes": {
        "anyOf": [
          {
            "type": "object",
            "description": "可以附加到对象的 16 个键值对的集合。这可以是\n对于以结构化方式存储有关对象的附加信息非常有用\n格式，并通过 API 或仪表板查询对象。键是字符串\n最大长度为 64 个字符。值是具有最大值的字符串\n长度为 512 个字符、布尔值或数字。",
            "maxProperties": 16,
            "propertyNames": {
              "type": "string",
              "maxLength": 64
            },
            "additionalProperties": {
              "oneOf": [
                {
                  "type": "string",
                  "maxLength": 512,
                  "title": "string"
                },
                {
                  "type": "number",
                  "title": "number"
                },
                {
                  "type": "boolean",
                  "title": "boolean"
                }
              ]
            },
            "x-oaiTypeLabel": "map",
            "title": "object"
          },
          {
            "type": "null",
            "title": "null"
          }
        ]
      },
      "FunctionCallOutputStatusEnum": {
        "type": "string",
        "enum": [
          "in_progress",
          "completed",
          "incomplete"
        ]
      },
      "WebSearchActionSearch": {
        "type": "object",
        "title": "搜索动作",
        "description": "动作类型“搜索”-执行网络搜索查询。",
        "properties": {
          "type": {
            "type": "string",
            "enum": [
              "search"
            ],
            "description": "动作类型。",
            "x-stainless-const": true
          },
          "query": {
            "type": "string",
            "description": "[已弃用] 搜索查询。"
          },
          "queries": {
            "type": "array",
            "title": "搜索查询",
            "description": "搜索查询。",
            "items": {
              "type": "string",
              "description": "搜索查询。"
            }
          },
          "sources": {
            "type": "array",
            "title": "网络搜索来源",
            "description": "搜索中使用的来源。",
            "items": {
              "type": "object",
              "title": "网络搜索源",
              "description": "搜索中使用的来源。",
              "properties": {
                "type": {
                  "type": "string",
                  "enum": [
                    "url"
                  ],
                  "description": "源的类型。始终 `url`。",
                  "x-stainless-const": true
                },
                "url": {
                  "type": "string",
                  "format": "uri",
                  "description": "源的URL。"
                }
              },
              "required": [
                "type",
                "url"
              ]
            }
          }
        },
        "required": [
          "type",
          "query"
        ]
      },
      "WebSearchActionOpenPage": {
        "type": "object",
        "title": "打开页面动作",
        "description": "操作类型“open_page”-从搜索结果中打开特定URL。",
        "properties": {
          "type": {
            "type": "string",
            "enum": [
              "open_page"
            ],
            "description": "动作类型。",
            "x-stainless-const": true
          },
          "url": {
            "description": "模型打开的URL。",
            "anyOf": [
              {
                "type": "string",
                "format": "uri",
                "title": "string"
              },
              {
                "type": "null",
                "title": "null"
              }
            ]
          }
        },
        "required": [
          "type"
        ]
      },
      "WebSearchActionFind": {
        "type": "object",
        "title": "查找动作",
        "description": "动作类型“find_in_page”：在加载的页面内搜索模式。",
        "properties": {
          "type": {
            "type": "string",
            "enum": [
              "find_in_page"
            ],
            "description": "动作类型。",
            "x-stainless-const": true
          },
          "url": {
            "type": "string",
            "format": "uri",
            "description": "搜索该模式的页面的URL。"
          },
          "pattern": {
            "type": "string",
            "description": "要在页面内搜索的图案或文本。"
          }
        },
        "required": [
          "type",
          "url",
          "pattern"
        ]
      },
      "ComputerAction": {
        "oneOf": [
          {
            "$ref": "#/components/schemas/ClickParam"
          },
          {
            "$ref": "#/components/schemas/DoubleClickAction"
          },
          {
            "$ref": "#/components/schemas/DragParam"
          },
          {
            "$ref": "#/components/schemas/KeyPressAction"
          },
          {
            "$ref": "#/components/schemas/MoveParam"
          },
          {
            "$ref": "#/components/schemas/ScreenshotParam"
          },
          {
            "$ref": "#/components/schemas/ScrollParam"
          },
          {
            "$ref": "#/components/schemas/TypeParam"
          },
          {
            "$ref": "#/components/schemas/WaitParam"
          }
        ],
        "discriminator": {
          "propertyName": "type"
        }
      },
      "ComputerActionList": {
        "title": "计算机操作列表",
        "type": "array",
        "description": "`computer_use` 的扁平化批量操作。每个动作都包含一个\n`type` 鉴别器和特定操作字段。",
        "items": {
          "$ref": "#/components/schemas/ComputerAction"
        }
      },
      "ComputerCallSafetyCheckParam": {
        "properties": {
          "id": {
            "type": "string",
            "description": "待处理的安全检查的ID。"
          },
          "code": {
            "anyOf": [
              {
                "type": "string",
                "description": "待处理的安全检查的类型。",
                "title": "string"
              },
              {
                "type": "null",
                "title": "null"
              }
            ]
          },
          "message": {
            "anyOf": [
              {
                "type": "string",
                "description": "有关待处理安全检查的详细信息。",
                "title": "string"
              },
              {
                "type": "null",
                "title": "null"
              }
            ]
          }
        },
        "type": "object",
        "required": [
          "id"
        ],
        "description": "计算机调用的待定安全检查。"
      },
      "ComputerToolCallOutput": {
        "type": "object",
        "title": "计算机工具调用输出",
        "description": "计算机工具调用的输出。",
        "properties": {
          "type": {
            "type": "string",
            "description": "计算机工具调用输出的类型。始终 `computer_call_output`。",
            "enum": [
              "computer_call_output"
            ],
            "default": "computer_call_output",
            "x-stainless-const": true
          },
          "id": {
            "type": "string",
            "description": "计算机工具调用输出的ID。"
          },
          "call_id": {
            "type": "string",
            "description": "产生输出的计算机工具调用的ID。"
          },
          "acknowledged_safety_checks": {
            "type": "array",
            "description": "API 报告的安全检查已得到 API 确认\n开发商。",
            "items": {
              "$ref": "#/components/schemas/ComputerCallSafetyCheckParam"
            }
          },
          "output": {
            "$ref": "#/components/schemas/ComputerScreenshotImage"
          },
          "status": {
            "type": "string",
            "description": "消息输入的状态。 `in_progress`、`completed` 之一，或\n`incomplete`。当通过 API 返回输入项时填充。",
            "enum": [
              "in_progress",
              "completed",
              "incomplete"
            ]
          }
        },
        "required": [
          "type",
          "call_id",
          "output"
        ]
      },
      "ComputerCallOutputStatus": {
        "type": "string",
        "enum": [
          "completed",
          "incomplete",
          "failed"
        ]
      },
      "SummaryTextContent": {
        "properties": {
          "type": {
            "type": "string",
            "enum": [
              "summary_text"
            ],
            "description": "对象的类型。始终 `summary_text`。",
            "default": "summary_text",
            "x-stainless-const": true
          },
          "text": {
            "type": "string",
            "description": "迄今为止模型的推理输出的摘要。"
          }
        },
        "type": "object",
        "required": [
          "type",
          "text"
        ],
        "title": "摘要文本",
        "description": "模型的摘要文本。"
      },
      "ReasoningTextContent": {
        "properties": {
          "type": {
            "type": "string",
            "enum": [
              "reasoning_text"
            ],
            "description": "推理文本的类型。始终 `reasoning_text`。",
            "default": "reasoning_text",
            "x-stainless-const": true
          },
          "text": {
            "type": "string",
            "description": "模型的推理文本。"
          }
        },
        "type": "object",
        "required": [
          "type",
          "text"
        ],
        "title": "推理文本",
        "description": "从模型推理文本。"
      },
      "ToolSearchExecutionType": {
        "type": "string",
        "enum": [
          "server",
          "client"
        ]
      },
      "FunctionCallStatus": {
        "type": "string",
        "enum": [
          "in_progress",
          "completed",
          "incomplete"
        ]
      },
      "CodeInterpreterOutputLogs": {
        "properties": {
          "type": {
            "type": "string",
            "enum": [
              "logs"
            ],
            "description": "输出的类型。始终 `logs`。",
            "default": "logs",
            "x-stainless-const": true
          },
          "logs": {
            "type": "string",
            "description": "代码解释器输出的日志。"
          }
        },
        "type": "object",
        "required": [
          "type",
          "logs"
        ],
        "title": "代码解释器输出日志",
        "description": "代码解释器输出的日志。"
      },
      "CodeInterpreterOutputImage": {
        "properties": {
          "type": {
            "type": "string",
            "enum": [
              "image"
            ],
            "description": "输出的类型。始终 `image`。",
            "default": "image",
            "x-stainless-const": true
          },
          "url": {
            "type": "string",
            "format": "uri",
            "description": "从代码解释器输出的图像的URL。"
          }
        },
        "type": "object",
        "required": [
          "type",
          "url"
        ],
        "title": "代码解释器输出图像",
        "description": "从代码解释器输出的图像。"
      },
      "LocalShellExecAction": {
        "properties": {
          "type": {
            "type": "string",
            "enum": [
              "exec"
            ],
            "description": "本地 shell 操作的类型。始终 `exec`。",
            "default": "exec",
            "x-stainless-const": true
          },
          "command": {
            "items": {
              "type": "string"
            },
            "type": "array",
            "description": "要运行的命令。"
          },
          "timeout_ms": {
            "anyOf": [
              {
                "type": "integer",
                "description": "命令的可选超时（以毫秒为单位）。",
                "title": "integer"
              },
              {
                "type": "null",
                "title": "null"
              }
            ]
          },
          "working_directory": {
            "anyOf": [
              {
                "type": "string",
                "description": "运行命令的可选工作目录。",
                "title": "string"
              },
              {
                "type": "null",
                "title": "null"
              }
            ]
          },
          "env": {
            "additionalProperties": {
              "type": "string"
            },
            "type": "object",
            "description": "为命令设置的环境变量。",
            "x-oaiTypeLabel": "map"
          },
          "user": {
            "anyOf": [
              {
                "type": "string",
                "description": "运行命令的可选用户。",
                "title": "string"
              },
              {
                "type": "null",
                "title": "null"
              }
            ]
          }
        },
        "type": "object",
        "required": [
          "type",
          "command",
          "env"
        ],
        "title": "本地 shell 执行操作",
        "description": "在服务器上执行shell命令。"
      },
      "FunctionShellAction": {
        "properties": {
          "commands": {
            "items": {
              "type": "string",
              "description": "要运行的命令列表。"
            },
            "type": "array"
          },
          "timeout_ms": {
            "anyOf": [
              {
                "type": "integer",
                "description": "命令的可选超时（以毫秒为单位）。",
                "title": "integer"
              },
              {
                "type": "null",
                "title": "null"
              }
            ]
          },
          "max_output_length": {
            "anyOf": [
              {
                "type": "integer",
                "description": "从每个命令返回的可选最大字符数。",
                "title": "integer"
              },
              {
                "type": "null",
                "title": "null"
              }
            ]
          }
        },
        "type": "object",
        "required": [
          "commands",
          "timeout_ms",
          "max_output_length"
        ],
        "title": "Shell 执行操作",
        "description": "执行shell命令。"
      },
      "FunctionShellCallStatus": {
        "type": "string",
        "enum": [
          "in_progress",
          "completed",
          "incomplete"
        ]
      },
      "LocalEnvironmentResource": {
        "properties": {
          "type": {
            "type": "string",
            "enum": [
              "local"
            ],
            "description": "环境类型。始终 `local`。",
            "default": "local",
            "x-stainless-const": true
          }
        },
        "type": "object",
        "required": [
          "type"
        ],
        "title": "当地环境",
        "description": "表示使用本地环境来执行shell操作。"
      },
      "ContainerReferenceResource": {
        "properties": {
          "type": {
            "type": "string",
            "enum": [
              "container_reference"
            ],
            "description": "环境类型。始终 `container_reference`。",
            "default": "container_reference",
            "x-stainless-const": true
          },
          "container_id": {
            "type": "string"
          }
        },
        "type": "object",
        "required": [
          "type",
          "container_id"
        ],
        "title": "容器参考",
        "description": "代表用/v1/containers.创建的容器"
      },
      "FunctionShellCallOutputStatusEnum": {
        "type": "string",
        "enum": [
          "in_progress",
          "completed",
          "incomplete"
        ]
      },
      "FunctionShellCallOutputContent": {
        "properties": {
          "stdout": {
            "type": "string",
            "description": "捕获的标准输出。"
          },
          "stderr": {
            "type": "string",
            "description": "捕获的标准错误输出。"
          },
          "outcome": {
            "oneOf": [
              {
                "$ref": "#/components/schemas/FunctionShellCallOutputTimeoutOutcome"
              },
              {
                "$ref": "#/components/schemas/FunctionShellCallOutputExitOutcome"
              }
            ],
            "title": "shell 调用结果",
            "description": "表示 shell 调用输出块的退出结果（带有退出代码）或超时结果。",
            "discriminator": {
              "propertyName": "type"
            }
          },
          "created_by": {
            "type": "string",
            "description": "创建该项目的参与者的标识符。"
          }
        },
        "type": "object",
        "required": [
          "stdout",
          "stderr",
          "outcome"
        ],
        "title": "Shell调用输出内容",
        "description": "发出的 shell 工具调用输出的内容。"
      },
      "ApplyPatchCallStatus": {
        "type": "string",
        "enum": [
          "in_progress",
          "completed"
        ]
      },
      "ApplyPatchCreateFileOperation": {
        "properties": {
          "type": {
            "type": "string",
            "enum": [
              "create_file"
            ],
            "description": "使用提供的差异创建一个新文件。",
            "default": "create_file",
            "x-stainless-const": true
          },
          "path": {
            "type": "string",
            "description": "要创建的文件的路径。"
          },
          "diff": {
            "type": "string",
            "description": "差异应用。"
          }
        },
        "type": "object",
        "required": [
          "type",
          "path",
          "diff"
        ],
        "title": "应用补丁创建文件操作",
        "description": "描述如何通过 apply_patch 工具创建文件的说明。"
      },
      "ApplyPatchDeleteFileOperation": {
        "properties": {
          "type": {
            "type": "string",
            "enum": [
              "delete_file"
            ],
            "description": "删除指定文件。",
            "default": "delete_file",
            "x-stainless-const": true
          },
          "path": {
            "type": "string",
            "description": "要删除的文件的路径。"
          }
        },
        "type": "object",
        "required": [
          "type",
          "path"
        ],
        "title": "应用补丁删除文件操作",
        "description": "描述如何通过 apply_patch 工具删除文件的说明。"
      },
      "ApplyPatchUpdateFileOperation": {
        "properties": {
          "type": {
            "type": "string",
            "enum": [
              "update_file"
            ],
            "description": "使用提供的差异更新现有文件。",
            "default": "update_file",
            "x-stainless-const": true
          },
          "path": {
            "type": "string",
            "description": "要更新的文件的路径。"
          },
          "diff": {
            "type": "string",
            "description": "差异应用。"
          }
        },
        "type": "object",
        "required": [
          "type",
          "path",
          "diff"
        ],
        "title": "应用补丁更新文件操作",
        "description": "描述如何通过apply_patch工具更新文件的指令。"
      },
      "ApplyPatchCallOutputStatus": {
        "type": "string",
        "enum": [
          "completed",
          "failed"
        ]
      },
      "MCPToolCallStatus": {
        "type": "string",
        "enum": [
          "in_progress",
          "completed",
          "incomplete",
          "calling",
          "failed"
        ]
      },
      "MCPListToolsTool": {
        "type": "object",
        "title": "MCP列表工具工具",
        "description": "MCP服务器上可用的工具。",
        "properties": {
          "name": {
            "type": "string",
            "description": "工具的名称。"
          },
          "description": {
            "anyOf": [
              {
                "type": "string",
                "description": "工具的描述。",
                "title": "string"
              },
              {
                "type": "null",
                "title": "null"
              }
            ]
          },
          "input_schema": {
            "type": "object",
            "description": "描述工具输入的 JSON 模式。"
          },
          "annotations": {
            "anyOf": [
              {
                "type": "object",
                "description": "有关该工具的附加注释。",
                "title": "object"
              },
              {
                "type": "null",
                "title": "null"
              }
            ]
          }
        },
        "required": [
          "name",
          "input_schema"
        ]
      },
      "InputMessageContentList": {
        "type": "array",
        "title": "输入项目内容列表",
        "description": "模型的一个或多个输入项的列表，包含不同的内容 \n类型。",
        "items": {
          "$ref": "#/components/schemas/InputContent"
        }
      },
      "InputMessage": {
        "type": "object",
        "title": "输入消息",
        "description": "输入到模型的消息，带有指示后面的指令的角色\n层次结构。使用 `developer` 或 `system` 角色给出的指令\n优先于 `user` 角色给出的指令。",
        "properties": {
          "type": {
            "type": "string",
            "description": "消息输入的类型。始终设置为 `message`。",
            "enum": [
              "message"
            ],
            "x-stainless-const": true
          },
          "role": {
            "type": "string",
            "description": "消息输入的作用。 `user`、`system` 或 `developer` 之一。",
            "enum": [
              "user",
              "system",
              "developer"
            ]
          },
          "status": {
            "type": "string",
            "description": "项目的状态。 `in_progress`、`completed` 之一，或\n`incomplete`。当通过 API 返回项目时填充。",
            "enum": [
              "in_progress",
              "completed",
              "incomplete"
            ]
          },
          "content": {
            "$ref": "#/components/schemas/InputMessageContentList"
          }
        },
        "required": [
          "role",
          "content"
        ]
      },
      "ComputerCallOutputItemParam": {
        "properties": {
          "id": {
            "anyOf": [
              {
                "type": "string",
                "description": "计算机工具调用输出的ID。",
                "example": "cuo_123",
                "title": "string"
              },
              {
                "type": "null",
                "title": "null"
              }
            ]
          },
          "call_id": {
            "type": "string",
            "maxLength": 64,
            "minLength": 1,
            "description": "产生输出的计算机工具调用的 ID。"
          },
          "type": {
            "type": "string",
            "enum": [
              "computer_call_output"
            ],
            "description": "计算机工具调用输出的类型。始终 `computer_call_output`。",
            "default": "computer_call_output",
            "x-stainless-const": true
          },
          "output": {
            "$ref": "#/components/schemas/ComputerScreenshotImage"
          },
          "acknowledged_safety_checks": {
            "anyOf": [
              {
                "items": {
                  "$ref": "#/components/schemas/ComputerCallSafetyCheckParam"
                },
                "type": "array",
                "description": "API报告的已得到开发者认可的安全检查。",
                "title": "array"
              },
              {
                "type": "null",
                "title": "null"
              }
            ]
          },
          "status": {
            "anyOf": [
              {
                "$ref": "#/components/schemas/FunctionCallItemStatus",
                "description": "消息输入的状态。 `in_progress`、`completed` 或 `incomplete` 之一。当通过 API 返回输入项时填充。"
              },
              {
                "type": "null",
                "title": "null"
              }
            ]
          }
        },
        "type": "object",
        "required": [
          "call_id",
          "type",
          "output"
        ],
        "title": "计算机工具调用输出",
        "description": "计算机工具调用的输出。"
      },
      "FunctionCallOutputItemParam": {
        "properties": {
          "id": {
            "anyOf": [
              {
                "type": "string",
                "description": "功能工具调用输出的唯一ID。当通过 API 返回此项时填充。",
                "example": "fc_123",
                "title": "string"
              },
              {
                "type": "null",
                "title": "null"
              }
            ]
          },
          "call_id": {
            "type": "string",
            "maxLength": 64,
            "minLength": 1,
            "description": "模型生成的功能工具调用的唯一ID。"
          },
          "type": {
            "type": "string",
            "enum": [
              "function_call_output"
            ],
            "description": "功能工具调用输出的类型。始终 `function_call_output`。",
            "default": "function_call_output",
            "x-stainless-const": true
          },
          "output": {
            "oneOf": [
              {
                "type": "string",
                "maxLength": 10485760,
                "description": "函数工具调用的输出的JSON字符串。",
                "title": "string"
              },
              {
                "items": {
                  "oneOf": [
                    {
                      "$ref": "#/components/schemas/InputTextContentParam"
                    },
                    {
                      "$ref": "#/components/schemas/InputImageContentParamAutoParam"
                    },
                    {
                      "$ref": "#/components/schemas/InputFileContentParam"
                    }
                  ],
                  "description": "一条消息内容，例如文本、图像或文件。",
                  "discriminator": {
                    "propertyName": "type"
                  }
                },
                "type": "array",
                "description": "用于功能工具调用的内容输出数组（文本、图像、文件）。",
                "title": "array"
              }
            ],
            "description": "功能工具调用的文本、图像或文件输出。"
          },
          "status": {
            "anyOf": [
              {
                "$ref": "#/components/schemas/FunctionCallItemStatus",
                "description": "项目的状态。 `in_progress`、`completed` 或 `incomplete` 之一。当通过 API 返回项目时填充。"
              },
              {
                "type": "null",
                "title": "null"
              }
            ]
          }
        },
        "type": "object",
        "required": [
          "call_id",
          "type",
          "output"
        ],
        "title": "功能工具调用输出",
        "description": "功能工具调用的输出。"
      },
      "ToolSearchCallItemParam": {
        "properties": {
          "id": {
            "anyOf": [
              {
                "type": "string",
                "description": "该工具搜索调用的唯一ID。",
                "example": "tsc_123",
                "title": "string"
              },
              {
                "type": "null",
                "title": "null"
              }
            ]
          },
          "call_id": {
            "anyOf": [
              {
                "type": "string",
                "maxLength": 64,
                "minLength": 1,
                "description": "模型生成的工具搜索调用的唯一ID。",
                "title": "string"
              },
              {
                "type": "null",
                "title": "null"
              }
            ]
          },
          "type": {
            "type": "string",
            "enum": [
              "tool_search_call"
            ],
            "description": "物品类型。始终 `tool_search_call`。",
            "default": "tool_search_call",
            "x-stainless-const": true
          },
          "execution": {
            "$ref": "#/components/schemas/ToolSearchExecutionType",
            "description": "工具搜索是由服务器执行还是由客户端执行。"
          },
          "arguments": {
            "$ref": "#/components/schemas/EmptyModelParam",
            "description": "提供给工具搜索调用的参数。"
          },
          "status": {
            "anyOf": [
              {
                "$ref": "#/components/schemas/FunctionCallItemStatus",
                "description": "刀具搜索调用的状态。"
              },
              {
                "type": "null",
                "title": "null"
              }
            ]
          }
        },
        "type": "object",
        "required": [
          "type",
          "arguments"
        ]
      },
      "ToolSearchOutputItemParam": {
        "properties": {
          "id": {
            "anyOf": [
              {
                "type": "string",
                "description": "该工具搜索输出的唯一ID。",
                "example": "tso_123",
                "title": "string"
              },
              {
                "type": "null",
                "title": "null"
              }
            ]
          },
          "call_id": {
            "anyOf": [
              {
                "type": "string",
                "maxLength": 64,
                "minLength": 1,
                "description": "模型生成的工具搜索调用的唯一ID。",
                "title": "string"
              },
              {
                "type": "null",
                "title": "null"
              }
            ]
          },
          "type": {
            "type": "string",
            "enum": [
              "tool_search_output"
            ],
            "description": "物品类型。始终 `tool_search_output`。",
            "default": "tool_search_output",
            "x-stainless-const": true
          },
          "execution": {
            "$ref": "#/components/schemas/ToolSearchExecutionType",
            "description": "工具搜索是由服务器执行还是由客户端执行。"
          },
          "tools": {
            "items": {
              "$ref": "#/components/schemas/Tool"
            },
            "type": "array",
            "description": "工具搜索输出返回的加载的工具定义。"
          },
          "status": {
            "anyOf": [
              {
                "$ref": "#/components/schemas/FunctionCallItemStatus",
                "description": "刀具搜索输出的状态。"
              },
              {
                "type": "null",
                "title": "null"
              }
            ]
          }
        },
        "type": "object",
        "required": [
          "type",
          "tools"
        ]
      },
      "CompactionSummaryItemParam": {
        "properties": {
          "id": {
            "anyOf": [
              {
                "type": "string",
                "description": "压缩项的ID。",
                "example": "cmp_123",
                "title": "string"
              },
              {
                "type": "null",
                "title": "null"
              }
            ]
          },
          "type": {
            "type": "string",
            "enum": [
              "compaction"
            ],
            "description": "项目的类型。始终 `compaction`。",
            "default": "compaction",
            "x-stainless-const": true
          },
          "encrypted_content": {
            "type": "string",
            "maxLength": 10485760,
            "description": "压缩摘要的加密内容。"
          }
        },
        "type": "object",
        "required": [
          "type",
          "encrypted_content"
        ],
        "title": "压实项目",
        "description": "由[`v1/responses/compact` API](https://platform.openai.com/docs/api-reference/responses/compact)生成的压缩项。"
      },
      "FunctionShellCallItemParam": {
        "properties": {
          "id": {
            "anyOf": [
              {
                "type": "string",
                "description": "shell工具调用的唯一ID。当通过 API 返回此项时填充。",
                "example": "sh_123",
                "title": "string"
              },
              {
                "type": "null",
                "title": "null"
              }
            ]
          },
          "call_id": {
            "type": "string",
            "maxLength": 64,
            "minLength": 1,
            "description": "模型生成的shell工具调用的唯一ID。"
          },
          "type": {
            "type": "string",
            "enum": [
              "shell_call"
            ],
            "description": "项目的类型。始终 `shell_call`。",
            "default": "shell_call",
            "x-stainless-const": true
          },
          "action": {
            "$ref": "#/components/schemas/FunctionShellActionParam",
            "description": "描述如何运行工具调用的 shell 命令和限制。"
          },
          "status": {
            "anyOf": [
              {
                "$ref": "#/components/schemas/FunctionShellCallItemStatus",
                "description": "shell 调用的状态。 `in_progress`、`completed` 或 `incomplete` 之一。"
              },
              {
                "type": "null",
                "title": "null"
              }
            ]
          },
          "environment": {
            "anyOf": [
              {
                "oneOf": [
                  {
                    "$ref": "#/components/schemas/LocalEnvironmentParam"
                  },
                  {
                    "$ref": "#/components/schemas/ContainerReferenceParam"
                  }
                ],
                "description": "执行shell命令的环境。",
                "discriminator": {
                  "propertyName": "type"
                }
              },
              {
                "type": "null",
                "title": "null"
              }
            ]
          }
        },
        "type": "object",
        "required": [
          "call_id",
          "type",
          "action"
        ],
        "title": "Shell工具调用",
        "description": "一种表示执行一个或多个shell命令的请求的工具。"
      },
      "FunctionShellCallOutputItemParam": {
        "properties": {
          "id": {
            "anyOf": [
              {
                "type": "string",
                "description": "shell工具调用输出的唯一ID。当通过 API 返回此项时填充。",
                "example": "sho_123",
                "title": "string"
              },
              {
                "type": "null",
                "title": "null"
              }
            ]
          },
          "call_id": {
            "type": "string",
            "maxLength": 64,
            "minLength": 1,
            "description": "模型生成的shell工具调用的唯一ID。"
          },
          "type": {
            "type": "string",
            "enum": [
              "shell_call_output"
            ],
            "description": "项目的类型。始终 `shell_call_output`。",
            "default": "shell_call_output",
            "x-stainless-const": true
          },
          "output": {
            "items": {
              "$ref": "#/components/schemas/FunctionShellCallOutputContentParam"
            },
            "type": "array",
            "description": "捕获 stdout 和 stderr 输出块及其相关结果。"
          },
          "status": {
            "anyOf": [
              {
                "$ref": "#/components/schemas/FunctionShellCallItemStatus",
                "description": "shell调用输出的状态。"
              },
              {
                "type": "null",
                "title": "null"
              }
            ]
          },
          "max_output_length": {
            "anyOf": [
              {
                "type": "integer",
                "description": "为此 shell 调用的组合输出捕获的最大 UTF-8 字符数。",
                "title": "integer"
              },
              {
                "type": "null",
                "title": "null"
              }
            ]
          }
        },
        "type": "object",
        "required": [
          "call_id",
          "type",
          "output"
        ],
        "title": "Shell工具调用输出",
        "description": "由外壳工具调用发出的流式输出项。"
      },
      "ApplyPatchToolCallItemParam": {
        "properties": {
          "type": {
            "type": "string",
            "enum": [
              "apply_patch_call"
            ],
            "description": "项目的类型。始终 `apply_patch_call`。",
            "default": "apply_patch_call",
            "x-stainless-const": true
          },
          "id": {
            "anyOf": [
              {
                "type": "string",
                "description": "应用补丁工具调用的唯一ID。当通过 API 返回此项时填充。",
                "example": "apc_123",
                "title": "string"
              },
              {
                "type": "null",
                "title": "null"
              }
            ]
          },
          "call_id": {
            "type": "string",
            "maxLength": 64,
            "minLength": 1,
            "description": "模型生成的应用补丁工具调用的唯一ID。"
          },
          "status": {
            "$ref": "#/components/schemas/ApplyPatchCallStatusParam",
            "description": "应用补丁工具调用的状态。 `in_progress` 或 `completed` 之一。"
          },
          "operation": {
            "$ref": "#/components/schemas/ApplyPatchOperationParam",
            "description": "apply_patch工具调用的具体创建、删除或更新指令。"
          }
        },
        "type": "object",
        "required": [
          "type",
          "call_id",
          "status",
          "operation"
        ],
        "title": "应用补丁工具调用",
        "description": "表示使用差异补丁创建、删除或更新文件的请求的工具调用。"
      },
      "ApplyPatchToolCallOutputItemParam": {
        "properties": {
          "type": {
            "type": "string",
            "enum": [
              "apply_patch_call_output"
            ],
            "description": "项目的类型。始终 `apply_patch_call_output`。",
            "default": "apply_patch_call_output",
            "x-stainless-const": true
          },
          "id": {
            "anyOf": [
              {
                "type": "string",
                "description": "应用补丁工具调用输出的唯一ID。当通过 API 返回此项时填充。",
                "example": "apco_123",
                "title": "string"
              },
              {
                "type": "null",
                "title": "null"
              }
            ]
          },
          "call_id": {
            "type": "string",
            "maxLength": 64,
            "minLength": 1,
            "description": "模型生成的应用补丁工具调用的唯一ID。"
          },
          "status": {
            "$ref": "#/components/schemas/ApplyPatchCallOutputStatusParam",
            "description": "应用补丁工具调用输出的状态。 `completed` 或 `failed` 之一。"
          },
          "output": {
            "anyOf": [
              {
                "type": "string",
                "maxLength": 10485760,
                "description": "来自应用补丁工具的可选的人类可读日志文本（例如，补丁结果或错误）。",
                "title": "string"
              },
              {
                "type": "null",
                "title": "null"
              }
            ]
          }
        },
        "type": "object",
        "required": [
          "type",
          "call_id",
          "status"
        ],
        "title": "应用补丁工具调用输出",
        "description": "应用补丁工具调用发出的流式输出。"
      },
      "MCPApprovalResponse": {
        "type": "object",
        "title": "MCP批准响应",
        "description": "对MCP批准请求的响应。",
        "properties": {
          "type": {
            "type": "string",
            "enum": [
              "mcp_approval_response"
            ],
            "description": "项目的类型。始终 `mcp_approval_response`。",
            "x-stainless-const": true
          },
          "id": {
            "anyOf": [
              {
                "type": "string",
                "description": "批准响应的唯一ID",
                "title": "string"
              },
              {
                "type": "null",
                "title": "null"
              }
            ]
          },
          "approval_request_id": {
            "type": "string",
            "description": "正在答复的批准请求的ID。"
          },
          "approve": {
            "type": "boolean",
            "description": "请求是否被批准。"
          },
          "reason": {
            "anyOf": [
              {
                "type": "string",
                "description": "可选的决定原因。",
                "title": "string"
              },
              {
                "type": "null",
                "title": "null"
              }
            ]
          }
        },
        "required": [
          "type",
          "request_id",
          "approve",
          "approval_request_id"
        ]
      },
      "OutputTextContent": {
        "properties": {
          "type": {
            "type": "string",
            "enum": [
              "output_text"
            ],
            "description": "输出文本的类型。始终 `output_text`。",
            "default": "output_text",
            "x-stainless-const": true
          },
          "text": {
            "type": "string",
            "description": "模型输出的文本。"
          },
          "annotations": {
            "items": {
              "$ref": "#/components/schemas/Annotation"
            },
            "type": "array",
            "description": "文本输出的注释。"
          },
          "logprobs": {
            "items": {
              "$ref": "#/components/schemas/LogProb"
            },
            "type": "array"
          }
        },
        "type": "object",
        "required": [
          "type",
          "text",
          "annotations",
          "logprobs"
        ],
        "title": "输出文本",
        "description": "模型的文本输出。"
      },
      "RefusalContent": {
        "properties": {
          "type": {
            "type": "string",
            "enum": [
              "refusal"
            ],
            "description": "拒绝的类型。始终 `refusal`。",
            "default": "refusal",
            "x-stainless-const": true
          },
          "refusal": {
            "type": "string",
            "description": "模型的拒绝解释。"
          }
        },
        "type": "object",
        "required": [
          "type",
          "refusal"
        ],
        "title": "拒绝",
        "description": "模型的拒绝。"
      },
      "RankingOptions": {
        "properties": {
          "ranker": {
            "$ref": "#/components/schemas/RankerVersionType",
            "description": "用于文件搜索的排序器。"
          },
          "score_threshold": {
            "type": "number",
            "description": "文件搜索的分数阈值，0到1之间的数字。接近1的数字将尝试仅返回最相关的结果，但可能返回较少的结果。"
          },
          "hybrid_search": {
            "$ref": "#/components/schemas/HybridSearchOptions",
            "description": "当启用混合搜索时，控制倒数排名融合如何平衡语义嵌入匹配与稀疏关键字匹配的权重。"
          }
        },
        "type": "object",
        "required": []
      },
      "Filters": {
        "anyOf": [
          {
            "$ref": "#/components/schemas/ComparisonFilter"
          },
          {
            "$ref": "#/components/schemas/CompoundFilter"
          }
        ]
      },
      "ComputerEnvironment": {
        "type": "string",
        "enum": [
          "windows",
          "mac",
          "linux",
          "ubuntu",
          "browser"
        ]
      },
      "WebSearchApproximateLocation": {
        "anyOf": [
          {
            "type": "object",
            "title": "网页搜索大概位置",
            "description": "用户的大致位置。",
            "properties": {
              "type": {
                "type": "string",
                "enum": [
                  "approximate"
                ],
                "description": "位置近似的类型。始终 `approximate`。",
                "default": "approximate",
                "x-stainless-const": true
              },
              "country": {
                "anyOf": [
                  {
                    "type": "string",
                    "description": "用户的两个字母的 [ISO 国家代码](https://en.wikipedia.org/wiki/ISO_3166-1)，例如`US`。",
                    "title": "string"
                  },
                  {
                    "type": "null",
                    "title": "null"
                  }
                ]
              },
              "region": {
                "anyOf": [
                  {
                    "type": "string",
                    "description": "用户所在区域的自由文本输入，例如： `California`。",
                    "title": "string"
                  },
                  {
                    "type": "null",
                    "title": "null"
                  }
                ]
              },
              "city": {
                "anyOf": [
                  {
                    "type": "string",
                    "description": "用户所在城市的自由文本输入，例如： `San Francisco`。",
                    "title": "string"
                  },
                  {
                    "type": "null",
                    "title": "null"
                  }
                ]
              },
              "timezone": {
                "anyOf": [
                  {
                    "type": "string",
                    "description": "用户的 [IANA 时区](https://timeapi.io/documentation/iana-timezones)，例如`America/Los_Angeles`。",
                    "title": "string"
                  },
                  {
                    "type": "null",
                    "title": "null"
                  }
                ]
              }
            }
          },
          {
            "type": "null",
            "title": "null"
          }
        ]
      },
      "MCPToolFilter": {
        "type": "object",
        "title": "MCP工具过滤器",
        "description": "用于指定允许哪些工具的过滤器对象。",
        "properties": {
          "tool_names": {
            "type": "array",
            "title": "MCP允许的工具",
            "items": {
              "type": "string"
            },
            "description": "允许的工具名称列表。"
          },
          "read_only": {
            "type": "boolean",
            "description": "指示工具是否修改数据或只读。如果一个\nMCP 服务器[用 `readOnlyHint` 注释](https://modelcontextprotocol.io/specification/2025-06-18/schema#toolannotations-readonlyhint)，\n它将匹配此过滤器。"
          }
        },
        "required": [],
        "additionalProperties": false
      },
      "AutoCodeInterpreterToolParam": {
        "properties": {
          "type": {
            "type": "string",
            "enum": [
              "auto"
            ],
            "description": "始终 `auto`。",
            "default": "auto",
            "x-stainless-const": true
          },
          "file_ids": {
            "items": {
              "type": "string",
              "example": "file-123"
            },
            "type": "array",
            "maxItems": 50,
            "description": "可供您的代码使用的上传文件的可选列表。"
          },
          "memory_limit": {
            "anyOf": [
              {
                "$ref": "#/components/schemas/ContainerMemoryLimit",
                "description": "代码解释器容器的内存限制。"
              },
              {
                "type": "null",
                "title": "null"
              }
            ]
          },
          "network_policy": {
            "oneOf": [
              {
                "$ref": "#/components/schemas/ContainerNetworkPolicyDisabledParam"
              },
              {
                "$ref": "#/components/schemas/ContainerNetworkPolicyAllowlistParam"
              }
            ],
            "description": "容器的网络访问策略。",
            "discriminator": {
              "propertyName": "type"
            }
          }
        },
        "type": "object",
        "required": [
          "type"
        ],
        "title": "代码解释器工具自动",
        "description": "代码解释器容器的配置。 （可选）指定要运行代码的文件的 ID。"
      },
      "InputFidelity": {
        "type": "string",
        "enum": [
          "high",
          "low"
        ],
        "description": "控制模型将付出多少努力来匹配输入图像的风格和特征，特别是面部特征。仅 `gpt-image-1` 和 `gpt-image-1.5` 及更高版本支持此参数，`gpt-image-1-mini` 不支持。支持 `high` 和 `low`。默认为 `low`。"
      },
      "ImageGenActionEnum": {
        "type": "string",
        "enum": [
          "generate",
          "edit",
          "auto"
        ]
      },
      "ContainerAutoParam": {
        "properties": {
          "type": {
            "type": "string",
            "enum": [
              "container_auto"
            ],
            "description": "自动为此请求创建容器",
            "default": "container_auto",
            "x-stainless-const": true
          },
          "file_ids": {
            "items": {
              "type": "string",
              "example": "file-123"
            },
            "type": "array",
            "maxItems": 50,
            "description": "可供您的代码使用的上传文件的可选列表。"
          },
          "memory_limit": {
            "anyOf": [
              {
                "$ref": "#/components/schemas/ContainerMemoryLimit",
                "description": "容器的内存限制。"
              },
              {
                "type": "null",
                "title": "null"
              }
            ]
          },
          "network_policy": {
            "oneOf": [
              {
                "$ref": "#/components/schemas/ContainerNetworkPolicyDisabledParam"
              },
              {
                "$ref": "#/components/schemas/ContainerNetworkPolicyAllowlistParam"
              }
            ],
            "description": "容器的网络访问策略。",
            "discriminator": {
              "propertyName": "type"
            }
          },
          "skills": {
            "items": {
              "oneOf": [
                {
                  "$ref": "#/components/schemas/SkillReferenceParam"
                },
                {
                  "$ref": "#/components/schemas/InlineSkillParam"
                }
              ],
              "discriminator": {
                "propertyName": "type"
              }
            },
            "type": "array",
            "maxItems": 200,
            "description": "由 id 或内联数据引用的可选技能列表。"
          }
        },
        "type": "object",
        "required": [
          "type"
        ]
      },
      "LocalEnvironmentParam": {
        "properties": {
          "type": {
            "type": "string",
            "enum": [
              "local"
            ],
            "description": "使用本地计算机环境。",
            "default": "local",
            "x-stainless-const": true
          },
          "skills": {
            "items": {
              "$ref": "#/components/schemas/LocalSkillParam"
            },
            "type": "array",
            "maxItems": 200,
            "description": "可选技能列表。"
          }
        },
        "type": "object",
        "required": [
          "type"
        ]
      },
      "ContainerReferenceParam": {
        "properties": {
          "type": {
            "type": "string",
            "enum": [
              "container_reference"
            ],
            "description": "引用使用 /v1/containers 端点创建的容器",
            "default": "container_reference",
            "x-stainless-const": true
          },
          "container_id": {
            "type": "string",
            "description": "引用的容器的ID。",
            "example": "cntr_123"
          }
        },
        "type": "object",
        "required": [
          "type",
          "container_id"
        ]
      },
      "CustomTextFormatParam": {
        "properties": {
          "type": {
            "type": "string",
            "enum": [
              "text"
            ],
            "description": "不受约束的文本格式。始终 `text`。",
            "default": "text",
            "x-stainless-const": true
          }
        },
        "type": "object",
        "required": [
          "type"
        ],
        "title": "文本格式",
        "description": "无约束的自由格式文本。"
      },
      "CustomGrammarFormatParam": {
        "properties": {
          "type": {
            "type": "string",
            "enum": [
              "grammar"
            ],
            "description": "语法格式。始终 `grammar`。",
            "default": "grammar",
            "x-stainless-const": true
          },
          "syntax": {
            "$ref": "#/components/schemas/GrammarSyntax1",
            "description": "语法定义的语法。 `lark` 或 `regex` 之一。"
          },
          "definition": {
            "type": "string",
            "description": "语法定义。"
          }
        },
        "type": "object",
        "required": [
          "type",
          "syntax",
          "definition"
        ],
        "title": "语法格式",
        "description": "用户定义的语法。"
      },
      "FunctionToolParam": {
        "properties": {
          "name": {
            "type": "string",
            "maxLength": 128,
            "minLength": 1,
            "pattern": "^[a-zA-Z0-9_-]+$"
          },
          "description": {
            "anyOf": [
              {
                "type": "string",
                "title": "string"
              },
              {
                "type": "null",
                "title": "null"
              }
            ]
          },
          "parameters": {
            "anyOf": [
              {
                "$ref": "#/components/schemas/EmptyModelParam"
              },
              {
                "type": "null",
                "title": "null"
              }
            ]
          },
          "strict": {
            "anyOf": [
              {
                "type": "boolean",
                "title": "boolean"
              },
              {
                "type": "null",
                "title": "null"
              }
            ]
          },
          "type": {
            "type": "string",
            "enum": [
              "function"
            ],
            "default": "function",
            "x-stainless-const": true
          },
          "defer_loading": {
            "type": "boolean",
            "description": "该功能是否应该推迟并通过工具搜索来发现。"
          }
        },
        "type": "object",
        "required": [
          "name",
          "type"
        ]
      },
      "EmptyModelParam": {
        "properties": {},
        "type": "object",
        "required": []
      },
      "ApproximateLocation": {
        "properties": {
          "type": {
            "type": "string",
            "enum": [
              "approximate"
            ],
            "description": "位置近似的类型。始终 `approximate`。",
            "default": "approximate",
            "x-stainless-const": true
          },
          "country": {
            "anyOf": [
              {
                "type": "string",
                "description": "用户的两个字母的 [ISO 国家代码](https://en.wikipedia.org/wiki/ISO_3166-1)，例如`US`。",
                "title": "string"
              },
              {
                "type": "null",
                "title": "null"
              }
            ]
          },
          "region": {
            "anyOf": [
              {
                "type": "string",
                "description": "用户所在区域的自由文本输入，例如： `California`。",
                "title": "string"
              },
              {
                "type": "null",
                "title": "null"
              }
            ]
          },
          "city": {
            "anyOf": [
              {
                "type": "string",
                "description": "用户所在城市的自由文本输入，例如： `San Francisco`。",
                "title": "string"
              },
              {
                "type": "null",
                "title": "null"
              }
            ]
          },
          "timezone": {
            "anyOf": [
              {
                "type": "string",
                "description": "用户的 [IANA 时区](https://timeapi.io/documentation/iana-timezones)，例如`America/Los_Angeles`。",
                "title": "string"
              },
              {
                "type": "null",
                "title": "null"
              }
            ]
          }
        },
        "type": "object",
        "required": [
          "type"
        ]
      },
      "SearchContextSize": {
        "type": "string",
        "enum": [
          "low",
          "medium",
          "high"
        ]
      },
      "SearchContentType": {
        "type": "string",
        "enum": [
          "text",
          "image"
        ]
      },
      "ResponseFormatText": {
        "type": "object",
        "title": "正文",
        "description": "默认响应格式。用于生成文本响应。",
        "properties": {
          "type": {
            "type": "string",
            "description": "正在定义的响应格式的类型。始终 `text`。",
            "enum": [
              "text"
            ],
            "x-stainless-const": true
          }
        },
        "required": [
          "type"
        ]
      },
      "TextResponseFormatJsonSchema": {
        "type": "object",
        "title": "JSON 模式",
        "description": "JSON Schema 响应格式。用于生成结构化 JSON 响应。\n了解有关[结构化输出](https://platform.openai.com/docs/guides/structured-outputs) 的更多信息。",
        "properties": {
          "type": {
            "type": "string",
            "description": "正在定义的响应格式的类型。始终 `json_schema`。",
            "enum": [
              "json_schema"
            ],
            "x-stainless-const": true
          },
          "description": {
            "type": "string",
            "description": "响应格式用途的描述，模型使用它来\n确定如何响应的格式。"
          },
          "name": {
            "type": "string",
            "description": "响应格式的名称。必须是 a-z、A-Z、0-9，或包含\n下划线和破折号，最大长度为 64。"
          },
          "schema": {
            "$ref": "#/components/schemas/ResponseFormatJsonSchemaSchema"
          },
          "strict": {
            "anyOf": [
              {
                "type": "boolean",
                "default": false,
                "description": "生成输出时是否启用严格模式遵守。\n如果设置为 true，模型将始终遵循定义的确切模式\n在 `schema` 字段中。仅支持 JSON 模式的子集：\n`strict` 是 `true`。要了解更多信息，请阅读[结构化输出\n指南](https://platform.openai.com/docs/guides/structured-outputs)。",
                "title": "boolean"
              },
              {
                "type": "null",
                "title": "null"
              }
            ]
          }
        },
        "required": [
          "type",
          "schema",
          "name"
        ]
      },
      "ResponseFormatJsonObject": {
        "type": "object",
        "title": "JSON对象",
        "description": "JSON对象响应格式。生成 JSON 响应的旧方法。\n对于支持它的型号，建议使用 `json_schema`。请注意，\n如果没有系统或用户消息指示，模型将不会生成 JSON\n这样做。",
        "properties": {
          "type": {
            "type": "string",
            "description": "正在定义的响应格式的类型。始终 `json_object`。",
            "enum": [
              "json_object"
            ],
            "x-stainless-const": true
          }
        },
        "required": [
          "type"
        ]
      },
      "MessageStatus": {
        "type": "string",
        "enum": [
          "in_progress",
          "completed",
          "incomplete"
        ]
      },
      "MessageRole": {
        "type": "string",
        "enum": [
          "unknown",
          "user",
          "assistant",
          "system",
          "critic",
          "discriminator",
          "developer",
          "tool"
        ]
      },
      "InputTextContent": {
        "properties": {
          "type": {
            "type": "string",
            "enum": [
              "input_text"
            ],
            "description": "输入项的类型。始终 `input_text`。",
            "default": "input_text",
            "x-stainless-const": true
          },
          "text": {
            "type": "string",
            "description": "输入模型的文本。"
          }
        },
        "type": "object",
        "required": [
          "type",
          "text"
        ],
        "title": "输入文字",
        "description": "模型的文本输入。"
      },
      "TextContent": {
        "properties": {
          "type": {
            "type": "string",
            "enum": [
              "text"
            ],
            "default": "text",
            "x-stainless-const": true
          },
          "text": {
            "type": "string"
          }
        },
        "type": "object",
        "required": [
          "type",
          "text"
        ],
        "title": "文字内容",
        "description": "文本内容。"
      },
      "InputImageContent": {
        "properties": {
          "type": {
            "type": "string",
            "enum": [
              "input_image"
            ],
            "description": "输入项的类型。始终 `input_image`。",
            "default": "input_image",
            "x-stainless-const": true
          },
          "image_url": {
            "anyOf": [
              {
                "type": "string",
                "format": "uri",
                "description": "要发送给模型的图像的URL。数据 URL 中的完全限定 URL 或 base64 编码图像。",
                "title": "string"
              },
              {
                "type": "null",
                "title": "null"
              }
            ]
          },
          "file_id": {
            "anyOf": [
              {
                "type": "string",
                "description": "要发送给模型的文件的ID。",
                "title": "string"
              },
              {
                "type": "null",
                "title": "null"
              }
            ]
          },
          "detail": {
            "$ref": "#/components/schemas/ImageDetail",
            "description": "要发送到模型的图像的细节级别。 `high`、`low`、`auto` 或 `original` 之一。默认为 `auto`。"
          }
        },
        "type": "object",
        "required": [
          "type",
          "detail"
        ],
        "title": "输入图像",
        "description": "输入到模型的图像。了解[图像输入](https://platform.openai.com/docs/guides/vision)。"
      },
      "ComputerScreenshotContent": {
        "properties": {
          "type": {
            "type": "string",
            "enum": [
              "computer_screenshot"
            ],
            "description": "指定事件类型。对于计算机屏幕截图，此属性始终设置为 `computer_screenshot`。",
            "default": "computer_screenshot",
            "x-stainless-const": true
          },
          "image_url": {
            "anyOf": [
              {
                "type": "string",
                "format": "uri",
                "description": "截图图片的URL。",
                "title": "string"
              },
              {
                "type": "null",
                "title": "null"
              }
            ]
          },
          "file_id": {
            "anyOf": [
              {
                "type": "string",
                "description": "包含截图的上传文件的标识。",
                "title": "string"
              },
              {
                "type": "null",
                "title": "null"
              }
            ]
          },
          "detail": {
            "$ref": "#/components/schemas/ImageDetail",
            "description": "要发送给模型的屏幕截图图像的细节级别。 `high`、`low`、`auto` 或 `original` 之一。默认为 `auto`。"
          }
        },
        "type": "object",
        "required": [
          "type",
          "image_url",
          "file_id",
          "detail"
        ],
        "title": "电脑截图",
        "description": "电脑截图。"
      },
      "InputFileContent": {
        "properties": {
          "type": {
            "type": "string",
            "enum": [
              "input_file"
            ],
            "description": "输入项的类型。始终 `input_file`。",
            "default": "input_file",
            "x-stainless-const": true
          },
          "file_id": {
            "anyOf": [
              {
                "type": "string",
                "description": "要发送给模型的文件的ID。",
                "title": "string"
              },
              {
                "type": "null",
                "title": "null"
              }
            ]
          },
          "filename": {
            "type": "string",
            "description": "要发送到模型的文件的名称。"
          },
          "file_data": {
            "type": "string",
            "description": "要发送到模型的文件的内容。"
          },
          "file_url": {
            "type": "string",
            "format": "uri",
            "description": "要发送到模型的文件的URL。"
          },
          "detail": {
            "$ref": "#/components/schemas/FileInputDetail",
            "description": "要发送到模型的文件的详细程度。使用 `low` 进行默认渲染行为，或使用 `high` 以更高的质量渲染文件。默认为 `low`。"
          }
        },
        "type": "object",
        "required": [
          "type"
        ],
        "title": "输入文件",
        "description": "输入到模型的文件。"
      },
      "MessagePhase-2": {
        "type": "string",
        "enum": [
          "commentary",
          "final_answer"
        ]
      },
      "FunctionAndCustomToolCallOutput": {
        "oneOf": [
          {
            "$ref": "#/components/schemas/InputTextContent"
          },
          {
            "$ref": "#/components/schemas/InputImageContent"
          },
          {
            "$ref": "#/components/schemas/InputFileContent"
          }
        ],
        "discriminator": {
          "propertyName": "type"
        }
      },
      "ClickParam": {
        "properties": {
          "type": {
            "type": "string",
            "enum": [
              "click"
            ],
            "description": "指定事件类型。对于单击操作，此属性始终为 `click`。",
            "default": "click",
            "x-stainless-const": true
          },
          "button": {
            "$ref": "#/components/schemas/ClickButtonType",
            "description": "指示在单击过程中按下了哪个鼠标按钮。 `left`、`right`、`wheel`、`back` 或 `forward` 之一。"
          },
          "x": {
            "type": "integer",
            "description": "发生点击的x坐标。"
          },
          "y": {
            "type": "integer",
            "description": "发生点击的y坐标。"
          },
          "keys": {
            "anyOf": [
              {
                "items": {
                  "type": "string"
                },
                "type": "array",
                "description": "单击时按住的键。",
                "title": "array"
              },
              {
                "type": "null",
                "title": "null"
              }
            ]
          }
        },
        "type": "object",
        "required": [
          "type",
          "button",
          "x",
          "y"
        ],
        "title": "点击",
        "description": "点击动作。"
      },
      "DoubleClickAction": {
        "properties": {
          "type": {
            "type": "string",
            "enum": [
              "double_click"
            ],
            "description": "指定事件类型。对于双击操作，此属性始终设置为 `double_click`。",
            "default": "double_click",
            "x-stainless-const": true
          },
          "x": {
            "type": "integer",
            "description": "双击发生处的x坐标。"
          },
          "y": {
            "type": "integer",
            "description": "双击发生处的y坐标。"
          },
          "keys": {
            "anyOf": [
              {
                "items": {
                  "type": "string"
                },
                "type": "array",
                "description": "双击时按住的键。",
                "title": "array"
              },
              {
                "type": "null",
                "title": "null"
              }
            ]
          }
        },
        "type": "object",
        "required": [
          "type",
          "x",
          "y",
          "keys"
        ],
        "title": "双击",
        "description": "双击动作。"
      },
      "DragParam": {
        "properties": {
          "type": {
            "type": "string",
            "enum": [
              "drag"
            ],
            "description": "指定事件类型。对于拖动操作，此属性始终设置为 `drag`。",
            "default": "drag",
            "x-stainless-const": true
          },
          "path": {
            "items": {
              "$ref": "#/components/schemas/CoordParam"
            },
            "type": "array",
            "description": "表示拖动动作的路径的坐标数组。坐标将显示为对象数组，例如\n```\n[\n  { x: 100, y: 200 },\n  { x: 200, y: 300 }\n]\n```"
          },
          "keys": {
            "anyOf": [
              {
                "items": {
                  "type": "string"
                },
                "type": "array",
                "description": "拖动鼠标时按住的键。",
                "title": "array"
              },
              {
                "type": "null",
                "title": "null"
              }
            ]
          }
        },
        "type": "object",
        "required": [
          "type",
          "path"
        ],
        "title": "拖动",
        "description": "拖动动作。"
      },
      "KeyPressAction": {
        "properties": {
          "type": {
            "type": "string",
            "enum": [
              "keypress"
            ],
            "description": "指定事件类型。对于按键操作，此属性始终设置为 `keypress`。",
            "default": "keypress",
            "x-stainless-const": true
          },
          "keys": {
            "items": {
              "type": "string",
              "description": "模型请求按下的键之一。"
            },
            "type": "array",
            "description": "模型请求按下的按键组合。这是一个字符串数组，每个字符串代表一个键。"
          }
        },
        "type": "object",
        "required": [
          "type",
          "keys"
        ],
        "title": "按键",
        "description": "模型想要执行的按键集合。"
      },
      "MoveParam": {
        "properties": {
          "type": {
            "type": "string",
            "enum": [
              "move"
            ],
            "description": "指定事件类型。对于移动操作，此属性始终设置为 `move`。",
            "default": "move",
            "x-stainless-const": true
          },
          "x": {
            "type": "integer",
            "description": "要移动到的x坐标。"
          },
          "y": {
            "type": "integer",
            "description": "要移动到的y坐标。"
          },
          "keys": {
            "anyOf": [
              {
                "items": {
                  "type": "string"
                },
                "type": "array",
                "description": "移动鼠标时按住的键。",
                "title": "array"
              },
              {
                "type": "null",
                "title": "null"
              }
            ]
          }
        },
        "type": "object",
        "required": [
          "type",
          "x",
          "y"
        ],
        "title": "移动",
        "description": "鼠标移动动作。"
      },
      "ScreenshotParam": {
        "properties": {
          "type": {
            "type": "string",
            "enum": [
              "screenshot"
            ],
            "description": "指定事件类型。对于屏幕截图操作，此属性始终设置为 `screenshot`。",
            "default": "screenshot",
            "x-stainless-const": true
          }
        },
        "type": "object",
        "required": [
          "type"
        ],
        "title": "截图",
        "description": "截图动作。"
      },
      "ScrollParam": {
        "properties": {
          "type": {
            "type": "string",
            "enum": [
              "scroll"
            ],
            "description": "指定事件类型。对于滚动操作，此属性始终设置为 `scroll`。",
            "default": "scroll",
            "x-stainless-const": true
          },
          "x": {
            "type": "integer",
            "description": "发生滚动的 x 坐标。"
          },
          "y": {
            "type": "integer",
            "description": "发生滚动的 y 坐标。"
          },
          "scroll_x": {
            "type": "integer",
            "description": "水平滚动距离。"
          },
          "scroll_y": {
            "type": "integer",
            "description": "垂直滚动距离。"
          },
          "keys": {
            "anyOf": [
              {
                "items": {
                  "type": "string"
                },
                "type": "array",
                "description": "滚动时按住的键。",
                "title": "array"
              },
              {
                "type": "null",
                "title": "null"
              }
            ]
          }
        },
        "type": "object",
        "required": [
          "type",
          "x",
          "y",
          "scroll_x",
          "scroll_y"
        ],
        "title": "卷轴",
        "description": "滚动动作。"
      },
      "TypeParam": {
        "properties": {
          "type": {
            "type": "string",
            "enum": [
              "type"
            ],
            "description": "指定事件类型。对于类型操作，此属性始终设置为 `type`。",
            "default": "type",
            "x-stainless-const": true
          },
          "text": {
            "type": "string",
            "description": "要输入的文本。"
          }
        },
        "type": "object",
        "required": [
          "type",
          "text"
        ],
        "title": "类型",
        "description": "输入文本的动作。"
      },
      "WaitParam": {
        "properties": {
          "type": {
            "type": "string",
            "enum": [
              "wait"
            ],
            "description": "指定事件类型。对于等待操作，此属性始终设置为 `wait`。",
            "default": "wait",
            "x-stainless-const": true
          }
        },
        "type": "object",
        "required": [
          "type"
        ],
        "title": "等等",
        "description": "等待动作。"
      },
      "ComputerScreenshotImage": {
        "type": "object",
        "description": "与计算机使用工具一起使用的计算机屏幕截图图像。",
        "properties": {
          "type": {
            "type": "string",
            "enum": [
              "computer_screenshot"
            ],
            "default": "computer_screenshot",
            "description": "指定事件类型。对于计算机屏幕截图，此属性是 \n始终设置为 `computer_screenshot`。",
            "x-stainless-const": true
          },
          "image_url": {
            "type": "string",
            "format": "uri",
            "description": "截图图片的URL。"
          },
          "file_id": {
            "type": "string",
            "description": "包含截图的上传文件的标识。"
          }
        },
        "required": [
          "type"
        ]
      },
      "FunctionShellCallOutputTimeoutOutcome": {
        "properties": {
          "type": {
            "type": "string",
            "enum": [
              "timeout"
            ],
            "description": "结果类型。始终 `timeout`。",
            "default": "timeout",
            "x-stainless-const": true
          }
        },
        "type": "object",
        "required": [
          "type"
        ],
        "title": "Shell 调用超时结果",
        "description": "表示 shell 调用超出了其配置的时间限制。"
      },
      "FunctionShellCallOutputExitOutcome": {
        "properties": {
          "type": {
            "type": "string",
            "enum": [
              "exit"
            ],
            "description": "结果类型。始终 `exit`。",
            "default": "exit",
            "x-stainless-const": true
          },
          "exit_code": {
            "type": "integer",
            "description": "从 shell 进程中退出代码。"
          }
        },
        "type": "object",
        "required": [
          "type",
          "exit_code"
        ],
        "title": "Shell 调用退出结果",
        "description": "表示 shell 命令已完成并返回退出代码。"
      },
      "InputContent": {
        "oneOf": [
          {
            "$ref": "#/components/schemas/InputTextContent"
          },
          {
            "$ref": "#/components/schemas/InputImageContent"
          },
          {
            "$ref": "#/components/schemas/InputFileContent"
          }
        ],
        "discriminator": {
          "propertyName": "type"
        }
      },
      "FunctionCallItemStatus": {
        "type": "string",
        "enum": [
          "in_progress",
          "completed",
          "incomplete"
        ]
      },
      "InputTextContentParam": {
        "properties": {
          "type": {
            "type": "string",
            "enum": [
              "input_text"
            ],
            "description": "输入项的类型。始终 `input_text`。",
            "default": "input_text",
            "x-stainless-const": true
          },
          "text": {
            "type": "string",
            "maxLength": 10485760,
            "description": "输入模型的文本。"
          }
        },
        "type": "object",
        "required": [
          "type",
          "text"
        ],
        "title": "输入文字",
        "description": "模型的文本输入。"
      },
      "InputImageContentParamAutoParam": {
        "properties": {
          "type": {
            "type": "string",
            "enum": [
              "input_image"
            ],
            "description": "输入项的类型。始终 `input_image`。",
            "default": "input_image",
            "x-stainless-const": true
          },
          "image_url": {
            "anyOf": [
              {
                "type": "string",
                "maxLength": 20971520,
                "format": "uri",
                "description": "要发送给模型的图像的URL。数据 URL 中的完全限定 URL 或 base64 编码图像。",
                "title": "string"
              },
              {
                "type": "null",
                "title": "null"
              }
            ]
          },
          "file_id": {
            "anyOf": [
              {
                "type": "string",
                "description": "要发送给模型的文件的ID。",
                "example": "file-123",
                "title": "string"
              },
              {
                "type": "null",
                "title": "null"
              }
            ]
          },
          "detail": {
            "anyOf": [
              {
                "$ref": "#/components/schemas/DetailEnum",
                "description": "要发送到模型的图像的细节级别。 `high`、`low`、`auto` 或 `original` 之一。默认为 `auto`。"
              },
              {
                "type": "null",
                "title": "null"
              }
            ]
          }
        },
        "type": "object",
        "required": [
          "type"
        ],
        "title": "输入图像",
        "description": "输入到模型的图像。了解[图像输入](https://platform.openai.com/docs/guides/vision)"
      },
      "InputFileContentParam": {
        "properties": {
          "type": {
            "type": "string",
            "enum": [
              "input_file"
            ],
            "description": "输入项的类型。始终 `input_file`。",
            "default": "input_file",
            "x-stainless-const": true
          },
          "file_id": {
            "anyOf": [
              {
                "type": "string",
                "description": "要发送给模型的文件的ID。",
                "example": "file-123",
                "title": "string"
              },
              {
                "type": "null",
                "title": "null"
              }
            ]
          },
          "filename": {
            "anyOf": [
              {
                "type": "string",
                "description": "要发送到模型的文件的名称。",
                "title": "string"
              },
              {
                "type": "null",
                "title": "null"
              }
            ]
          },
          "file_data": {
            "anyOf": [
              {
                "type": "string",
                "maxLength": 73400320,
                "description": "要发送到模型的文件的base64编码数据。",
                "title": "string"
              },
              {
                "type": "null",
                "title": "null"
              }
            ]
          },
          "file_url": {
            "anyOf": [
              {
                "type": "string",
                "format": "uri",
                "description": "要发送到模型的文件的URL。",
                "title": "string"
              },
              {
                "type": "null",
                "title": "null"
              }
            ]
          },
          "detail": {
            "$ref": "#/components/schemas/FileDetailEnum",
            "description": "要发送到模型的文件的详细程度。使用 `low` 进行默认渲染行为，或使用 `high` 以更高的质量渲染文件。默认为 `low`。"
          }
        },
        "type": "object",
        "required": [
          "type"
        ],
        "title": "输入文件",
        "description": "输入到模型的文件。"
      },
      "FunctionShellActionParam": {
        "properties": {
          "commands": {
            "items": {
              "type": "string"
            },
            "type": "array",
            "description": "命令执行环境运行的shell命令。"
          },
          "timeout_ms": {
            "anyOf": [
              {
                "type": "integer",
                "description": "允许 shell 命令运行的最大挂钟时间（以毫秒为单位）。",
                "title": "integer"
              },
              {
                "type": "null",
                "title": "null"
              }
            ]
          },
          "max_output_length": {
            "anyOf": [
              {
                "type": "integer",
                "description": "从组合的 stdout 和 stderr 输出中捕获的 UTF-8 字符的最大数量。",
                "title": "integer"
              },
              {
                "type": "null",
                "title": "null"
              }
            ]
          }
        },
        "type": "object",
        "required": [
          "commands"
        ],
        "title": "炮弹行动",
        "description": "描述如何运行 shell 工具调用的命令和限制。"
      },
      "FunctionShellCallItemStatus": {
        "type": "string",
        "enum": [
          "in_progress",
          "completed",
          "incomplete"
        ],
        "title": "shell 调用状态",
        "description": "报告 shell 工具调用的状态值。"
      },
      "FunctionShellCallOutputContentParam": {
        "properties": {
          "stdout": {
            "type": "string",
            "maxLength": 10485760,
            "description": "捕获 shell 调用的标准输出输出。"
          },
          "stderr": {
            "type": "string",
            "maxLength": 10485760,
            "description": "捕获 shell 调用的 stderr 输出。"
          },
          "outcome": {
            "$ref": "#/components/schemas/FunctionShellCallOutputOutcomeParam",
            "description": "与此 shell 调用相关的退出或超时结果。"
          }
        },
        "type": "object",
        "required": [
          "stdout",
          "stderr",
          "outcome"
        ],
        "title": "Shell输出内容",
        "description": "捕获 shell 工具调用输出的一部分的 stdout 和 stderr。"
      },
      "ApplyPatchCallStatusParam": {
        "type": "string",
        "enum": [
          "in_progress",
          "completed"
        ],
        "title": "应用补丁调用状态",
        "description": "报告 apply_patch 工具调用的状态值。"
      },
      "ApplyPatchOperationParam": {
        "oneOf": [
          {
            "$ref": "#/components/schemas/ApplyPatchCreateFileOperationParam"
          },
          {
            "$ref": "#/components/schemas/ApplyPatchDeleteFileOperationParam"
          },
          {
            "$ref": "#/components/schemas/ApplyPatchUpdateFileOperationParam"
          }
        ],
        "title": "应用补丁操作",
        "description": "提供给apply_patch工具的create_file、delete_file或update_file操作之一。",
        "discriminator": {
          "propertyName": "type"
        }
      },
      "ApplyPatchCallOutputStatusParam": {
        "type": "string",
        "enum": [
          "completed",
          "failed"
        ],
        "title": "应用补丁调用输出状态",
        "description": "为 apply_patch 工具调用输出报告的结果值。"
      },
      "Annotation": {
        "oneOf": [
          {
            "$ref": "#/components/schemas/FileCitationBody"
          },
          {
            "$ref": "#/components/schemas/UrlCitationBody"
          },
          {
            "$ref": "#/components/schemas/ContainerFileCitationBody"
          },
          {
            "$ref": "#/components/schemas/FilePath"
          }
        ],
        "description": "适用于输出文本范围的注释。",
        "discriminator": {
          "propertyName": "type"
        }
      },
      "LogProb": {
        "properties": {
          "token": {
            "type": "string"
          },
          "logprob": {
            "type": "number"
          },
          "bytes": {
            "items": {
              "type": "integer"
            },
            "type": "array"
          },
          "top_logprobs": {
            "items": {
              "$ref": "#/components/schemas/TopLogProb"
            },
            "type": "array"
          }
        },
        "type": "object",
        "required": [
          "token",
          "logprob",
          "bytes",
          "top_logprobs"
        ],
        "title": "对数概率",
        "description": "token的对数概率。"
      },
      "RankerVersionType": {
        "type": "string",
        "enum": [
          "auto",
          "default-2024-11-15"
        ]
      },
      "HybridSearchOptions": {
        "properties": {
          "embedding_weight": {
            "type": "number",
            "description": "倒数排序融合中嵌入的权重。"
          },
          "text_weight": {
            "type": "number",
            "description": "倒数排名融合中文本的权重。"
          }
        },
        "type": "object",
        "required": [
          "embedding_weight",
          "text_weight"
        ]
      },
      "ComparisonFilter": {
        "type": "object",
        "additionalProperties": false,
        "title": "比较过滤器",
        "description": "用于使用定义的比较操作来将指定属性键与给定值进行比较的过滤器。",
        "properties": {
          "type": {
            "type": "string",
            "default": "eq",
            "enum": [
              "eq",
              "ne",
              "gt",
              "gte",
              "lt",
              "lte",
              "in",
              "nin"
            ],
            "description": "指定比较运算符：`eq`、`ne`、`gt`、`gte`、`lt`、`lte`、`in`、`nin`。\n- `eq`：等于\n- `ne`：不等于\n- `gt`：大于\n- `gte`：大于或等于\n- `lt`：小于\n- `lte`：小于或等于\n- `in`：在\n- `nin`：不在"
          },
          "key": {
            "type": "string",
            "description": "与值进行比较的键。"
          },
          "value": {
            "oneOf": [
              {
                "type": "string",
                "title": "string"
              },
              {
                "type": "number",
                "title": "number"
              },
              {
                "type": "boolean",
                "title": "boolean"
              },
              {
                "type": "array",
                "items": {
                  "oneOf": [
                    {
                      "type": "string",
                      "title": "string"
                    },
                    {
                      "type": "number",
                      "title": "number"
                    }
                  ]
                },
                "title": "array"
              }
            ],
            "description": "与属性键进行比较的值；支持字符串、数字或布尔类型。"
          }
        },
        "required": [
          "type",
          "key",
          "value"
        ]
      },
      "CompoundFilter": {
        "type": "object",
        "additionalProperties": false,
        "title": "复合过滤器",
        "description": "使用`and`或`or`组合多个过滤器。",
        "properties": {
          "type": {
            "type": "string",
            "description": "操作类型：`and`或`or`。",
            "enum": [
              "and",
              "or"
            ]
          },
          "filters": {
            "type": "array",
            "description": "要组合的过滤器阵列。项目可以是 `ComparisonFilter` 或 `CompoundFilter`。",
            "items": {
              "oneOf": [
                {
                  "$ref": "#/components/schemas/ComparisonFilter"
                },
                {
                  "$ref": "#/components/schemas/CompoundFilter"
                }
              ],
              "discriminator": {
                "propertyName": "type"
              }
            }
          }
        },
        "required": [
          "type",
          "filters"
        ]
      },
      "ContainerMemoryLimit": {
        "type": "string",
        "enum": [
          "1g",
          "4g",
          "16g",
          "64g"
        ]
      },
      "ContainerNetworkPolicyDisabledParam": {
        "properties": {
          "type": {
            "type": "string",
            "enum": [
              "disabled"
            ],
            "description": "禁用出站网络访问。始终 `disabled`。",
            "default": "disabled",
            "x-stainless-const": true
          }
        },
        "type": "object",
        "required": [
          "type"
        ]
      },
      "ContainerNetworkPolicyAllowlistParam": {
        "properties": {
          "type": {
            "type": "string",
            "enum": [
              "allowlist"
            ],
            "description": "仅允许对指定域的出站网络访问。始终 `allowlist`。",
            "default": "allowlist",
            "x-stainless-const": true
          },
          "allowed_domains": {
            "items": {
              "type": "string"
            },
            "type": "array",
            "minItems": 1,
            "description": "类型为`allowlist`时允许的域列表。"
          },
          "domain_secrets": {
            "items": {
              "$ref": "#/components/schemas/ContainerNetworkPolicyDomainSecretParam"
            },
            "type": "array",
            "minItems": 1,
            "description": "白名单域的可选域范围秘密。"
          }
        },
        "type": "object",
        "required": [
          "type",
          "allowed_domains"
        ]
      },
      "SkillReferenceParam": {
        "properties": {
          "type": {
            "type": "string",
            "enum": [
              "skill_reference"
            ],
            "description": "引用使用 /v1/skills 端点创建的技能。",
            "default": "skill_reference",
            "x-stainless-const": true
          },
          "skill_id": {
            "type": "string",
            "maxLength": 64,
            "minLength": 1,
            "description": "引用的技能的ID。"
          },
          "version": {
            "type": "string",
            "description": "可选技能版本。使用正整数或 'latest'。默认省略。"
          }
        },
        "type": "object",
        "required": [
          "type",
          "skill_id"
        ]
      },
      "InlineSkillParam": {
        "properties": {
          "type": {
            "type": "string",
            "enum": [
              "inline"
            ],
            "description": "定义该请求的内联技能。",
            "default": "inline",
            "x-stainless-const": true
          },
          "name": {
            "type": "string",
            "description": "技能名称。"
          },
          "description": {
            "type": "string",
            "description": "技能的描述。"
          },
          "source": {
            "$ref": "#/components/schemas/InlineSkillSourceParam",
            "description": "内嵌技能负载"
          }
        },
        "type": "object",
        "required": [
          "type",
          "name",
          "description",
          "source"
        ]
      },
      "LocalSkillParam": {
        "properties": {
          "name": {
            "type": "string",
            "description": "技能名称。"
          },
          "description": {
            "type": "string",
            "description": "技能的描述。"
          },
          "path": {
            "type": "string",
            "description": "包含技能的目录的路径。"
          }
        },
        "type": "object",
        "required": [
          "name",
          "description",
          "path"
        ]
      },
      "GrammarSyntax1": {
        "type": "string",
        "enum": [
          "lark",
          "regex"
        ]
      },
      "ResponseFormatJsonSchemaSchema": {
        "type": "object",
        "title": "JSON 模式",
        "description": "响应格式的模式，描述为JSON模式对象。\n了解如何构建 JSON 架构 [此处](https://json-schema.org/)。",
        "additionalProperties": true
      },
      "ImageDetail": {
        "type": "string",
        "enum": [
          "low",
          "high",
          "auto",
          "original"
        ]
      },
      "FileInputDetail": {
        "type": "string",
        "enum": [
          "low",
          "high"
        ]
      },
      "ClickButtonType": {
        "type": "string",
        "enum": [
          "left",
          "right",
          "wheel",
          "back",
          "forward"
        ]
      },
      "CoordParam": {
        "properties": {
          "x": {
            "type": "integer",
            "description": "x坐标。"
          },
          "y": {
            "type": "integer",
            "description": "y坐标。"
          }
        },
        "type": "object",
        "required": [
          "x",
          "y"
        ],
        "title": "坐标",
        "description": "x/y坐标对，例如`{ x: 100, y: 200 }`。"
      },
      "DetailEnum": {
        "type": "string",
        "enum": [
          "low",
          "high",
          "auto",
          "original"
        ]
      },
      "FileDetailEnum": {
        "type": "string",
        "enum": [
          "low",
          "high"
        ]
      },
      "FunctionShellCallOutputOutcomeParam": {
        "oneOf": [
          {
            "$ref": "#/components/schemas/FunctionShellCallOutputTimeoutOutcomeParam"
          },
          {
            "$ref": "#/components/schemas/FunctionShellCallOutputExitOutcomeParam"
          }
        ],
        "title": "shell 调用结果",
        "description": "与此 shell 调用相关的退出或超时结果。",
        "discriminator": {
          "propertyName": "type"
        }
      },
      "ApplyPatchCreateFileOperationParam": {
        "properties": {
          "type": {
            "type": "string",
            "enum": [
              "create_file"
            ],
            "description": "操作类型。始终 `create_file`。",
            "default": "create_file",
            "x-stainless-const": true
          },
          "path": {
            "type": "string",
            "minLength": 1,
            "description": "要创建的文件相对于工作空间根的路径。"
          },
          "diff": {
            "type": "string",
            "maxLength": 10485760,
            "description": "创建文件时要应用的统一差异内容。"
          }
        },
        "type": "object",
        "required": [
          "type",
          "path",
          "diff"
        ],
        "title": "应用补丁创建文件操作",
        "description": "通过apply_patch工具创建新文件的说明。"
      },
      "ApplyPatchDeleteFileOperationParam": {
        "properties": {
          "type": {
            "type": "string",
            "enum": [
              "delete_file"
            ],
            "description": "操作类型。始终 `delete_file`。",
            "default": "delete_file",
            "x-stainless-const": true
          },
          "path": {
            "type": "string",
            "minLength": 1,
            "description": "要删除的文件相对于工作空间根的路径。"
          }
        },
        "type": "object",
        "required": [
          "type",
          "path"
        ],
        "title": "应用补丁删除文件操作",
        "description": "通过apply_patch工具删除现有文件的说明。"
      },
      "ApplyPatchUpdateFileOperationParam": {
        "properties": {
          "type": {
            "type": "string",
            "enum": [
              "update_file"
            ],
            "description": "操作类型。始终 `update_file`。",
            "default": "update_file",
            "x-stainless-const": true
          },
          "path": {
            "type": "string",
            "minLength": 1,
            "description": "要更新的文件相对于工作空间根的路径。"
          },
          "diff": {
            "type": "string",
            "maxLength": 10485760,
            "description": "统一差异内容以应用于现有文件。"
          }
        },
        "type": "object",
        "required": [
          "type",
          "path",
          "diff"
        ],
        "title": "应用补丁更新文件操作",
        "description": "通过apply_patch工具更新现有文件的指令。"
      },
      "FileCitationBody": {
        "properties": {
          "type": {
            "type": "string",
            "enum": [
              "file_citation"
            ],
            "description": "文件引用的类型。始终 `file_citation`。",
            "default": "file_citation",
            "x-stainless-const": true
          },
          "file_id": {
            "type": "string",
            "description": "文件的ID。"
          },
          "index": {
            "type": "integer",
            "description": "文件在文件列表中的索引。"
          },
          "filename": {
            "type": "string",
            "description": "引用的文件的文件名。"
          }
        },
        "type": "object",
        "required": [
          "type",
          "file_id",
          "index",
          "filename"
        ],
        "title": "文件引用",
        "description": "对文件的引用。"
      },
      "UrlCitationBody": {
        "properties": {
          "type": {
            "type": "string",
            "enum": [
              "url_citation"
            ],
            "description": "URL引用的类型。始终 `url_citation`。",
            "default": "url_citation",
            "x-stainless-const": true
          },
          "url": {
            "type": "string",
            "format": "uri",
            "description": "网络资源的URL。"
          },
          "start_index": {
            "type": "integer",
            "description": "消息中URL引用的第一个字符的索引。"
          },
          "end_index": {
            "type": "integer",
            "description": "消息中URL引用的最后一个字符的索引。"
          },
          "title": {
            "type": "string",
            "description": "网络资源的标题。"
          }
        },
        "type": "object",
        "required": [
          "type",
          "url",
          "start_index",
          "end_index",
          "title"
        ],
        "title": "网址引用",
        "description": "对用于生成模型响应的网络资源的引用。"
      },
      "ContainerFileCitationBody": {
        "properties": {
          "type": {
            "type": "string",
            "enum": [
              "container_file_citation"
            ],
            "description": "容器文件引用的类型。始终 `container_file_citation`。",
            "default": "container_file_citation",
            "x-stainless-const": true
          },
          "container_id": {
            "type": "string",
            "description": "容器文件的ID。"
          },
          "file_id": {
            "type": "string",
            "description": "文件的ID。"
          },
          "start_index": {
            "type": "integer",
            "description": "消息中容器文件引用的第一个字符的索引。"
          },
          "end_index": {
            "type": "integer",
            "description": "消息中容器文件引用的最后一个字符的索引。"
          },
          "filename": {
            "type": "string",
            "description": "引用的容器文件的文件名。"
          }
        },
        "type": "object",
        "required": [
          "type",
          "container_id",
          "file_id",
          "start_index",
          "end_index",
          "filename"
        ],
        "title": "容器文件引用",
        "description": "用于生成模型响应的容器文件的引用。"
      },
      "FilePath": {
        "type": "object",
        "title": "文件路径",
        "description": "文件的路径。",
        "properties": {
          "type": {
            "type": "string",
            "description": "文件路径的类型。始终 `file_path`。",
            "enum": [
              "file_path"
            ],
            "x-stainless-const": true
          },
          "file_id": {
            "type": "string",
            "description": "文件的 ID。"
          },
          "index": {
            "type": "integer",
            "description": "文件在文件列表中的索引。"
          }
        },
        "required": [
          "type",
          "file_id",
          "index"
        ]
      },
      "TopLogProb": {
        "properties": {
          "token": {
            "type": "string"
          },
          "logprob": {
            "type": "number"
          },
          "bytes": {
            "items": {
              "type": "integer"
            },
            "type": "array"
          }
        },
        "type": "object",
        "required": [
          "token",
          "logprob",
          "bytes"
        ],
        "title": "最高对数概率",
        "description": "token的顶部对数概率。"
      },
      "ContainerNetworkPolicyDomainSecretParam": {
        "properties": {
          "domain": {
            "type": "string",
            "minLength": 1,
            "description": "与秘密关联的域。"
          },
          "name": {
            "type": "string",
            "minLength": 1,
            "description": "为域注入的秘密的名称。"
          },
          "value": {
            "type": "string",
            "maxLength": 10485760,
            "minLength": 1,
            "description": "为域注入的秘密值。"
          }
        },
        "type": "object",
        "required": [
          "domain",
          "name",
          "value"
        ]
      },
      "InlineSkillSourceParam": {
        "properties": {
          "type": {
            "type": "string",
            "enum": [
              "base64"
            ],
            "description": "内嵌技能来源的类型。必须是 `base64`。",
            "default": "base64",
            "x-stainless-const": true
          },
          "media_type": {
            "type": "string",
            "enum": [
              "application/zip"
            ],
            "description": "内联技能负载的媒体类型。必须是 `application/zip`。",
            "default": "application/zip",
            "x-stainless-const": true
          },
          "data": {
            "type": "string",
            "maxLength": 70254592,
            "minLength": 1,
            "description": "Base64 编码的技能 zip 包。"
          }
        },
        "type": "object",
        "required": [
          "type",
          "media_type",
          "data"
        ],
        "description": "内嵌技能负载"
      },
      "FunctionShellCallOutputTimeoutOutcomeParam": {
        "properties": {
          "type": {
            "type": "string",
            "enum": [
              "timeout"
            ],
            "description": "结果类型。始终 `timeout`。",
            "default": "timeout",
            "x-stainless-const": true
          }
        },
        "type": "object",
        "required": [
          "type"
        ],
        "title": "Shell 调用超时结果",
        "description": "表示 shell 调用超出了其配置的时间限制。"
      },
      "FunctionShellCallOutputExitOutcomeParam": {
        "properties": {
          "type": {
            "type": "string",
            "enum": [
              "exit"
            ],
            "description": "结果类型。始终 `exit`。",
            "default": "exit",
            "x-stainless-const": true
          },
          "exit_code": {
            "type": "integer",
            "description": "shell进程返回的退出代码。"
          }
        },
        "type": "object",
        "required": [
          "type",
          "exit_code"
        ],
        "title": "Shell 调用退出结果",
        "description": "表示 shell 命令已完成并返回退出代码。"
      }
    }
  },
  "x-source-openapi": "https://raw.githubusercontent.com/openai/openai-openapi/master/openapi.yaml",
  "x-filtered-paths": [
    "POST /v1/responses",
    "GET /v1/responses/{response_id}",
    "DELETE /v1/responses/{response_id}",
    "POST /v1/responses/{response_id}/cancel",
    "POST /v1/responses/input_tokens",
    "POST /v1/responses/compact"
  ],
  "x-filtered-operation-count": 6,
  "x-filtered-schema-count": 284
}
```
