使用 webhook 即可响应会话状态变化,无需持续保持事件流连接。webhook 处理程序可以启动或重新连接沙盒计算资源、更新您的应用或触发工作流。
| 事件 |
触发时机 |
agent.session.created |
会话创建时。 |
agent.session.action_required |
会话需要函数调用结果、环境连接或计算机使用审批时。 |
agent.session.in_progress |
会话开始处理一轮交互时。 |
agent.session.idle |
会话进入空闲状态,可以接收更多输入时。 |
agent.session.failed |
会话进入失败状态时。 |
agent.session.action_required 事件包含会话 ID 和 required_action.type 字段。该字段的值为 function_call、environment_connection 或 computer_use_approval_request。
1234567{
"type": "agent.session.action_required",
"data": {
"id": "sess_abc123",
"required_action": { "type": "function_call" }
}
}
获取会话并查看 required_actions,从中读取调用 ID、参数、环境 ID 或计算机使用审批详情。webhook 不包含这些信息。对于计算机使用,嵌套字段 request.type 表明请求涉及浏览器来源访问还是身份验证。向用户展示当前请求,然后通过会话事件端点返回用户的答复。有关请求和响应的数据结构,请参阅计算机使用。
按照通用的 webhook 设置指南创建端点,并选择 Agents API 事件。保存端点的签名密钥,用于验证签名。
每当您订阅的事件发生时,OpenAI 都会发送带签名的 HTTP POST 请求:
1234567891011121314{
"id": "evt_123",
"object": "event",
"created_at": 1750287018,
"type": "agent.session.created",
"data": {
"id": "sess_abc123",
"environment_id": "ccarenv_abc123",
"environment_type": "self_hosted",
"connect": {
"remote_url": "https://api.openai.com/v1/agents/api"
}
}
}
在为会话分配沙盒之前,先获取会话的当前状态。请参阅沙盒生命周期。
对于自托管会话,agent.session.created 包含启动执行器所需的环境 ID 和连接 URL。将 ENVIRONMENT_ID 设为 data.environment_id 的值,将 REMOTE_URL 设为 data.connect.remote_url 的值。该 URL 与会话的 environment.remote_url 字段返回的 URL 相同。保存这两个值,以便重新连接时使用:
1234CODEX_API_KEY="$OPENAI_ENVIRONMENT_KEY" \
codex exec-server \
--remote "$REMOTE_URL" \
--environment-id "$ENVIRONMENT_ID"
使用环境密钥作为 CODEX_API_KEY。请将应用的 API 密钥保存在该环境之外。
设置 OPENAI_API_KEY 和 OPENAI_WEBHOOK_SECRET。如果使用 Python,请安装 fastapi、uvicorn 和 openai。如果使用 JavaScript,请安装 express 和 openai。
这些处理程序会验证签名,并监听 8000 端口。您可以设置 PORT 来更改端口。在生产环境中,请将耗时较长的任务放入队列。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33import express from "express";
import OpenAI from "openai";
const app = express();
const webhooks = new OpenAI({
webhookSecret: process.env.OPENAI_WEBHOOK_SECRET,
});
app.post(
"/webhooks/openai",
express.raw({ type: "application/json" }),
async (request, response) => {
const payload = request.body.toString("utf8");
try {
await webhooks.webhooks.verifySignature(payload, request.headers);
} catch {
response.status(400).send("Invalid signature");
return;
}
const event = JSON.parse(payload);
if (event.type === "agent.session.idle") {
const session = await webhooks.beta.agents.sessions.retrieve(
event.data.id
);
console.log("session idle event:", session.id);
} else {
console.log("session event:", event.type, event.data.id);
}
response.sendStatus(200);
}
);
app.listen(Number(process.env.PORT ?? 8000));
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31import json
import os
import uvicorn
from fastapi import FastAPI, Request, Response
from openai import AsyncOpenAI, InvalidWebhookSignatureError
app = FastAPI()
webhooks = AsyncOpenAI(webhook_secret=os.environ["OPENAI_WEBHOOK_SECRET"])
@app.post("/webhooks/openai")
async def handle_webhook(request: Request):
payload = await request.body()
try:
webhooks.webhooks.verify_signature(payload=payload, headers=request.headers)
except (InvalidWebhookSignatureError, ValueError):
return Response("Invalid signature", status_code=400)
event = json.loads(payload)
if event["type"] == "agent.session.idle":
session_id = event["data"]["id"]
session = await webhooks.beta.agents.sessions.retrieve(session_id, timeout=10)
print("session idle event:", session.id)
else:
print("session event:", event["type"], event["data"]["id"])
return Response(status_code=200)
if __name__ == "__main__":
uvicorn.run(app, port=int(os.environ.get("PORT", "8000")))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54import (
"encoding/json"
"fmt"
"io"
"net/http"
"os"
"github.com/openai/openai-go/v3"
)
client := openai.NewClient()
http.HandleFunc("/webhooks/openai", func(w http.ResponseWriter, r *http.Request) {
if r.Method != http.MethodPost {
w.WriteHeader(http.StatusMethodNotAllowed)
return
}
body, err := io.ReadAll(r.Body)
if err != nil {
http.Error(w, "Invalid body", http.StatusBadRequest)
return
}
if err := client.Webhooks.VerifySignature(body, r.Header); err != nil {
http.Error(w, "Invalid signature", http.StatusBadRequest)
return
}
var event struct {
Type string `json:"type"`
Data struct {
ID string `json:"id"`
} `json:"data"`
}
if err := json.Unmarshal(body, &event); err != nil {
http.Error(w, "Invalid JSON", http.StatusBadRequest)
return
}
if event.Type == "agent.session.idle" {
session, err := client.Beta.Agents.Sessions.Get(r.Context(), event.Data.ID)
if err != nil {
http.Error(w, "Could not retrieve session", http.StatusInternalServerError)
return
}
fmt.Println("session idle event:", session.ID)
} else {
fmt.Println("session event:", event.Type, event.Data.ID)
}
w.WriteHeader(http.StatusOK)
})
port := os.Getenv("PORT")
if port == "" {
port = "8000"
}
if err := http.ListenAndServe(":"+port, nil); err != nil {
panic(err)
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56import com.fasterxml.jackson.databind.json.JsonMapper;
import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.core.http.Headers;
import com.openai.errors.InvalidWebhookSignatureException;
import com.openai.models.webhooks.WebhookVerificationParams;
import com.sun.net.httpserver.HttpServer;
import java.net.InetSocketAddress;
import java.nio.charset.StandardCharsets;
OpenAIClient client = OpenAIOkHttpClient.fromEnv();
var json = new JsonMapper();
int port = Integer.parseInt(System.getenv().getOrDefault("PORT", "8000"));
var server = HttpServer.create(new InetSocketAddress(port), 0);
server.createContext(
"/webhooks/openai",
exchange -> {
try (exchange) {
if (!exchange.getRequestMethod().equals("POST")) {
exchange.sendResponseHeaders(405, -1);
return;
}
String payload =
new String(exchange.getRequestBody().readAllBytes(), StandardCharsets.UTF_8);
try {
client
.webhooks()
.verifySignature(
WebhookVerificationParams.builder()
.payload(payload)
.headers(Headers.builder().putAll(exchange.getRequestHeaders()).build())
.build());
} catch (InvalidWebhookSignatureException e) {
exchange.sendResponseHeaders(400, -1);
return;
}
var event = json.readTree(payload);
if (event.path("type").asText().equals("agent.session.idle")) {
var session =
client
.beta()
.agents()
.sessions()
.retrieve(event.path("data").path("id").asText());
System.out.println("session idle event: " + session.id());
} else {
System.out.println(
"session event: "
+ event.path("type").asText()
+ " "
+ event.path("data").path("id").asText());
}
exchange.sendResponseHeaders(200, -1);
}
});
server.start();
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30require "openai"
require "webrick"
require "json"
client = OpenAI::Client.new
server = WEBrick::HTTPServer.new(Port: Integer(ENV.fetch("PORT", "8000")))
server.mount_proc "/webhooks/openai" do |request, response|
if request.request_method != "POST"
response.status = 405
next
end
payload = request.body
begin
client.webhooks.verify_signature(payload, request.header.transform_values(&:first))
rescue OpenAI::Errors::InvalidWebhookSignatureError
response.status = 400
response.body = "Invalid signature"
next
end
event = JSON.parse(payload)
if event["type"] == "agent.session.idle"
session = client.beta.agents.sessions.retrieve(event.fetch("data").fetch("id"))
puts "session idle event: #{session.id}"
else
puts "session event: #{event["type"]} #{event.dig("data", "id")}"
end
response.status = 200
end
trap("INT") { server.shutdown }
server.start
如果处理初始输入或后续输入需要用到当前未连接的自托管执行器,API 会添加一项类型为 environment_connection 的必需操作。API 会发出 agent.session.action_required 事件,然后才开始等待连接。
获取会话,确认 required_actions 仍要求建立连接。使用 session.environment.id 和 session.environment.remote_url 启动执行器。此 webhook 不包含 connect.remote_url。如果执行器在等待超时前建立连接,API 会清除这项必需操作,继续处理已提交的输入,无需客户端重新提交。
API 最多等待五分钟。在此期间,后续输入请求可能会一直保持打开状态。请据此配置客户端和代理的超时时间。agent.session.in_progress 表示执行已经开始,并不表示 API 正在等待连接。
如果等待超时,本次提交就会失败。初始输入可能会异步失败,使会话处于 failed 状态。等待连接的机制不提供持久化输入队列。如果进程崩溃或客户端断开连接,可能需要重试。
agent.session.idle 表示会话可以接收更多输入,但不能据此判断上一轮交互是否成功。请检查该轮交互的状态,或在会话事件流中观察 agent.session.turn.completed、agent.session.turn.failed 或 agent.session.turn.cancelled 事件。即使一轮交互已完成,其中仍可能有失败的工具调用。请检查工具结果和智能体的最终回复。
agent.session.failed 表示会话失败,单轮交互失败不一定会触发此事件。删除会话没有对应的 webhook,也不会停止提供商侧计算资源的运行。