clone/codex
1
0
Fork 0
mirror of https://github.com/openai/codex.git synced 2026-04-25 15:15:15 +00:00
Code Issues Packages Projects Releases Wiki Activity
Files
4e6b694137626ca8be2536316e215a6cee47cefe
codex/codex-rs/app-server-protocol/schema/python/codex_app_server_protocol/models.py
sdcoffey 4e6b694137 address generator warnings
2026-03-09 21:37:55 -07:00

8236 lines
244 KiB
Python
Raw Blame History

# generated by datamodel-codegen:
# filename: codex_app_server_protocol.python.schemas.json
from __future__ import annotations
from pydantic import BaseModel as _BaseModel, ConfigDict, Field, RootModel
from typing import Annotated, Any, Literal
from enum import StrEnum
class BaseModel(_BaseModel):
model_config = ConfigDict(populate_by_name=True)
class CodexAppServerProtocol(BaseModel):
pass
class AbsolutePathBuf(RootModel[str]):
root: Annotated[
str,
Field(
description="A path that is guaranteed to be absolute and normalized (though it is not guaranteed to be canonicalized or exist on the filesystem).\n\nIMPORTANT: When deserializing an `AbsolutePathBuf`, a base path must be set using [AbsolutePathBufGuard::new]. If no base path is set, the deserialization will fail unless the path being deserialized is already absolute."
),
]
class AccountLoginCompletedNotification(BaseModel):
error: str | None = None
login_id: Annotated[str | None, Field(alias="loginId")] = None
success: bool
class AdditionalFileSystemPermissions(BaseModel):
read: list[AbsolutePathBuf] | None = None
write: list[AbsolutePathBuf] | None = None
class AdditionalNetworkPermissions(BaseModel):
enabled: bool | None = None
class TextAgentMessageContentType(RootModel[Literal["Text"]]):
root: Annotated[Literal["Text"], Field(title="TextAgentMessageContentType")]
class TextAgentMessageContent(BaseModel):
text: str
type: Annotated[
TextAgentMessageContentType, Field(title="TextAgentMessageContentType")
]
class AgentMessageContent(RootModel[TextAgentMessageContent]):
root: TextAgentMessageContent
class AgentMessageDeltaNotification(BaseModel):
delta: str
item_id: Annotated[str, Field(alias="itemId")]
thread_id: Annotated[str, Field(alias="threadId")]
turn_id: Annotated[str, Field(alias="turnId")]
class CompletedAgentStatus(BaseModel):
model_config = ConfigDict(
extra="forbid",
)
completed: str | None
class ErroredAgentStatus(BaseModel):
model_config = ConfigDict(
extra="forbid",
)
errored: str
class AgentStatus(
RootModel[
Literal["pending_init"]
| Literal["running"]
| CompletedAgentStatus
| ErroredAgentStatus
| Literal["shutdown"]
| Literal["not_found"]
]
):
root: Annotated[
Literal["pending_init"]
| Literal["running"]
| CompletedAgentStatus
| ErroredAgentStatus
| Literal["shutdown"]
| Literal["not_found"],
Field(description="Agent lifecycle status, derived from emitted events."),
]
class AppBranding(BaseModel):
category: str | None = None
developer: str | None = None
is_discoverable_app: Annotated[bool, Field(alias="isDiscoverableApp")]
privacy_policy: Annotated[str | None, Field(alias="privacyPolicy")] = None
terms_of_service: Annotated[str | None, Field(alias="termsOfService")] = None
website: str | None = None
class AppReview(BaseModel):
status: str
class AppScreenshot(BaseModel):
file_id: Annotated[str | None, Field(alias="fileId")] = None
url: str | None = None
user_prompt: Annotated[str, Field(alias="userPrompt")]
class AppsListParams(BaseModel):
cursor: Annotated[
str | None,
Field(description="Opaque pagination cursor returned by a previous call."),
] = None
force_refetch: Annotated[
bool | None,
Field(
alias="forceRefetch",
description="When true, bypass app caches and fetch the latest data from sources.",
),
] = None
limit: Annotated[
int | None,
Field(
description="Optional page size; defaults to a reasonable server-side value.",
ge=0,
le=4294967295,
),
] = None
thread_id: Annotated[
str | None,
Field(
alias="threadId",
description="Optional thread id used to evaluate app feature gating from that thread's config.",
),
] = None
class AskForApproval1(StrEnum):
untrusted = "untrusted"
on_failure = "on-failure"
on_request = "on-request"
never = "never"
class Reject(BaseModel):
mcp_elicitations: bool
request_permissions: bool
rules: bool
sandbox_approval: bool
class RejectAskForApproval(BaseModel):
model_config = ConfigDict(
extra="forbid",
)
reject: Reject
class AskForApproval(RootModel[AskForApproval1 | RejectAskForApproval]):
root: AskForApproval1 | RejectAskForApproval
class AuthMode(
RootModel[Literal["apikey"] | Literal["chatgpt"] | Literal["chatgptAuthTokens"]]
):
root: Annotated[
Literal["apikey"] | Literal["chatgpt"] | Literal["chatgptAuthTokens"],
Field(description="Authentication mode for OpenAI-backed providers."),
]
class ByteRange(BaseModel):
end: Annotated[int, Field(ge=0)]
start: Annotated[int, Field(ge=0)]
class CallToolResult(BaseModel):
field_meta: Annotated[Any | None, Field(alias="_meta")] = None
content: list[Any]
is_error: Annotated[bool | None, Field(alias="isError")] = None
structured_content: Annotated[Any | None, Field(alias="structuredContent")] = None
class CancelLoginAccountParams(BaseModel):
login_id: Annotated[str, Field(alias="loginId")]
class ChatgptAuthTokensRefreshReason(RootModel[Literal["unauthorized"]]):
root: Literal["unauthorized"]
class ChatgptAuthTokensRefreshResponse(BaseModel):
access_token: Annotated[str, Field(alias="accessToken")]
chatgpt_account_id: Annotated[str, Field(alias="chatgptAccountId")]
chatgpt_plan_type: Annotated[str | None, Field(alias="chatgptPlanType")] = None
class ClientInfo(BaseModel):
name: str
title: str | None = None
version: str
class InitializedClientNotificationMethod(RootModel[Literal["initialized"]]):
root: Annotated[
Literal["initialized"], Field(title="InitializedClientNotificationMethod")
]
class InitializedClientNotification(BaseModel):
method: Annotated[
InitializedClientNotificationMethod,
Field(title="InitializedClientNotificationMethod"),
]
class ClientNotification(RootModel[InitializedClientNotification]):
root: Annotated[InitializedClientNotification, Field(title="ClientNotification")]
class InitializeClientRequestMethod(RootModel[Literal["initialize"]]):
root: Annotated[Literal["initialize"], Field(title="InitializeClientRequestMethod")]
class ThreadStartClientRequestMethod(RootModel[Literal["thread/start"]]):
root: Annotated[
Literal["thread/start"], Field(title="Thread/startClientRequestMethod")
]
class ThreadResumeClientRequestMethod(RootModel[Literal["thread/resume"]]):
root: Annotated[
Literal["thread/resume"], Field(title="Thread/resumeClientRequestMethod")
]
class ThreadForkClientRequestMethod(RootModel[Literal["thread/fork"]]):
root: Annotated[
Literal["thread/fork"], Field(title="Thread/forkClientRequestMethod")
]
class ThreadArchiveClientRequestMethod(RootModel[Literal["thread/archive"]]):
root: Annotated[
Literal["thread/archive"], Field(title="Thread/archiveClientRequestMethod")
]
class ThreadUnsubscribeClientRequestMethod(RootModel[Literal["thread/unsubscribe"]]):
root: Annotated[
Literal["thread/unsubscribe"],
Field(title="Thread/unsubscribeClientRequestMethod"),
]
class ThreadNameSetClientRequestMethod(RootModel[Literal["thread/name/set"]]):
root: Annotated[
Literal["thread/name/set"], Field(title="Thread/name/setClientRequestMethod")
]
class ThreadMetadataUpdateClientRequestMethod(
RootModel[Literal["thread/metadata/update"]]
):
root: Annotated[
Literal["thread/metadata/update"],
Field(title="Thread/metadata/updateClientRequestMethod"),
]
class ThreadUnarchiveClientRequestMethod(RootModel[Literal["thread/unarchive"]]):
root: Annotated[
Literal["thread/unarchive"], Field(title="Thread/unarchiveClientRequestMethod")
]
class ThreadCompactStartClientRequestMethod(RootModel[Literal["thread/compact/start"]]):
root: Annotated[
Literal["thread/compact/start"],
Field(title="Thread/compact/startClientRequestMethod"),
]
class ThreadRollbackClientRequestMethod(RootModel[Literal["thread/rollback"]]):
root: Annotated[
Literal["thread/rollback"], Field(title="Thread/rollbackClientRequestMethod")
]
class ThreadListClientRequestMethod(RootModel[Literal["thread/list"]]):
root: Annotated[
Literal["thread/list"], Field(title="Thread/listClientRequestMethod")
]
class ThreadLoadedListClientRequestMethod(RootModel[Literal["thread/loaded/list"]]):
root: Annotated[
Literal["thread/loaded/list"],
Field(title="Thread/loaded/listClientRequestMethod"),
]
class ThreadReadClientRequestMethod(RootModel[Literal["thread/read"]]):
root: Annotated[
Literal["thread/read"], Field(title="Thread/readClientRequestMethod")
]
class SkillsListClientRequestMethod(RootModel[Literal["skills/list"]]):
root: Annotated[
Literal["skills/list"], Field(title="Skills/listClientRequestMethod")
]
class PluginListClientRequestMethod(RootModel[Literal["plugin/list"]]):
root: Annotated[
Literal["plugin/list"], Field(title="Plugin/listClientRequestMethod")
]
class SkillsRemoteListClientRequestMethod(RootModel[Literal["skills/remote/list"]]):
root: Annotated[
Literal["skills/remote/list"],
Field(title="Skills/remote/listClientRequestMethod"),
]
class SkillsRemoteExportClientRequestMethod(RootModel[Literal["skills/remote/export"]]):
root: Annotated[
Literal["skills/remote/export"],
Field(title="Skills/remote/exportClientRequestMethod"),
]
class AppListClientRequestMethod(RootModel[Literal["app/list"]]):
root: Annotated[Literal["app/list"], Field(title="App/listClientRequestMethod")]
class SkillsConfigWriteClientRequestMethod(RootModel[Literal["skills/config/write"]]):
root: Annotated[
Literal["skills/config/write"],
Field(title="Skills/config/writeClientRequestMethod"),
]
class PluginInstallClientRequestMethod(RootModel[Literal["plugin/install"]]):
root: Annotated[
Literal["plugin/install"], Field(title="Plugin/installClientRequestMethod")
]
class PluginUninstallClientRequestMethod(RootModel[Literal["plugin/uninstall"]]):
root: Annotated[
Literal["plugin/uninstall"], Field(title="Plugin/uninstallClientRequestMethod")
]
class TurnStartClientRequestMethod(RootModel[Literal["turn/start"]]):
root: Annotated[Literal["turn/start"], Field(title="Turn/startClientRequestMethod")]
class TurnSteerClientRequestMethod(RootModel[Literal["turn/steer"]]):
root: Annotated[Literal["turn/steer"], Field(title="Turn/steerClientRequestMethod")]
class TurnInterruptClientRequestMethod(RootModel[Literal["turn/interrupt"]]):
root: Annotated[
Literal["turn/interrupt"], Field(title="Turn/interruptClientRequestMethod")
]
class ReviewStartClientRequestMethod(RootModel[Literal["review/start"]]):
root: Annotated[
Literal["review/start"], Field(title="Review/startClientRequestMethod")
]
class ModelListClientRequestMethod(RootModel[Literal["model/list"]]):
root: Annotated[Literal["model/list"], Field(title="Model/listClientRequestMethod")]
class ExperimentalFeatureListClientRequestMethod(
RootModel[Literal["experimentalFeature/list"]]
):
root: Annotated[
Literal["experimentalFeature/list"],
Field(title="ExperimentalFeature/listClientRequestMethod"),
]
class McpServerOauthLoginClientRequestMethod(
RootModel[Literal["mcpServer/oauth/login"]]
):
root: Annotated[
Literal["mcpServer/oauth/login"],
Field(title="McpServer/oauth/loginClientRequestMethod"),
]
class ConfigMcpServerReloadClientRequestMethod(
RootModel[Literal["config/mcpServer/reload"]]
):
root: Annotated[
Literal["config/mcpServer/reload"],
Field(title="Config/mcpServer/reloadClientRequestMethod"),
]
class McpServerStatusListClientRequestMethod(
RootModel[Literal["mcpServerStatus/list"]]
):
root: Annotated[
Literal["mcpServerStatus/list"],
Field(title="McpServerStatus/listClientRequestMethod"),
]
class WindowsSandboxSetupStartClientRequestMethod(
RootModel[Literal["windowsSandbox/setupStart"]]
):
root: Annotated[
Literal["windowsSandbox/setupStart"],
Field(title="WindowsSandbox/setupStartClientRequestMethod"),
]
class AccountLoginStartClientRequestMethod(RootModel[Literal["account/login/start"]]):
root: Annotated[
Literal["account/login/start"],
Field(title="Account/login/startClientRequestMethod"),
]
class AccountLoginCancelClientRequestMethod(RootModel[Literal["account/login/cancel"]]):
root: Annotated[
Literal["account/login/cancel"],
Field(title="Account/login/cancelClientRequestMethod"),
]
class AccountLogoutClientRequestMethod(RootModel[Literal["account/logout"]]):
root: Annotated[
Literal["account/logout"], Field(title="Account/logoutClientRequestMethod")
]
class AccountRateLimitsReadClientRequestMethod(
RootModel[Literal["account/rateLimits/read"]]
):
root: Annotated[
Literal["account/rateLimits/read"],
Field(title="Account/rateLimits/readClientRequestMethod"),
]
class FeedbackUploadClientRequestMethod(RootModel[Literal["feedback/upload"]]):
root: Annotated[
Literal["feedback/upload"], Field(title="Feedback/uploadClientRequestMethod")
]
class CommandExecClientRequestMethod(RootModel[Literal["command/exec"]]):
root: Annotated[
Literal["command/exec"], Field(title="Command/execClientRequestMethod")
]
class CommandExecWriteClientRequestMethod(RootModel[Literal["command/exec/write"]]):
root: Annotated[
Literal["command/exec/write"],
Field(title="Command/exec/writeClientRequestMethod"),
]
class CommandExecTerminateClientRequestMethod(
RootModel[Literal["command/exec/terminate"]]
):
root: Annotated[
Literal["command/exec/terminate"],
Field(title="Command/exec/terminateClientRequestMethod"),
]
class CommandExecResizeClientRequestMethod(RootModel[Literal["command/exec/resize"]]):
root: Annotated[
Literal["command/exec/resize"],
Field(title="Command/exec/resizeClientRequestMethod"),
]
class ConfigReadClientRequestMethod(RootModel[Literal["config/read"]]):
root: Annotated[
Literal["config/read"], Field(title="Config/readClientRequestMethod")
]
class ExternalAgentConfigDetectClientRequestMethod(
RootModel[Literal["externalAgentConfig/detect"]]
):
root: Annotated[
Literal["externalAgentConfig/detect"],
Field(title="ExternalAgentConfig/detectClientRequestMethod"),
]
class ExternalAgentConfigImportClientRequestMethod(
RootModel[Literal["externalAgentConfig/import"]]
):
root: Annotated[
Literal["externalAgentConfig/import"],
Field(title="ExternalAgentConfig/importClientRequestMethod"),
]
class ConfigValueWriteClientRequestMethod(RootModel[Literal["config/value/write"]]):
root: Annotated[
Literal["config/value/write"],
Field(title="Config/value/writeClientRequestMethod"),
]
class ConfigBatchWriteClientRequestMethod(RootModel[Literal["config/batchWrite"]]):
root: Annotated[
Literal["config/batchWrite"],
Field(title="Config/batchWriteClientRequestMethod"),
]
class ConfigRequirementsReadClientRequestMethod(
RootModel[Literal["configRequirements/read"]]
):
root: Annotated[
Literal["configRequirements/read"],
Field(title="ConfigRequirements/readClientRequestMethod"),
]
class AccountReadClientRequestMethod(RootModel[Literal["account/read"]]):
root: Annotated[
Literal["account/read"], Field(title="Account/readClientRequestMethod")
]
class FuzzyFileSearchClientRequestMethod(RootModel[Literal["fuzzyFileSearch"]]):
root: Annotated[
Literal["fuzzyFileSearch"], Field(title="FuzzyFileSearchClientRequestMethod")
]
class CodexErrorInfo1(StrEnum):
context_window_exceeded = "contextWindowExceeded"
usage_limit_exceeded = "usageLimitExceeded"
server_overloaded = "serverOverloaded"
internal_server_error = "internalServerError"
unauthorized = "unauthorized"
bad_request = "badRequest"
thread_rollback_failed = "threadRollbackFailed"
sandbox_error = "sandboxError"
other = "other"
class HttpConnectionFailed(BaseModel):
http_status_code: Annotated[
int | None, Field(alias="httpStatusCode", ge=0, le=65535)
] = None
class HttpConnectionFailedCodexErrorInfo(BaseModel):
model_config = ConfigDict(
extra="forbid",
)
http_connection_failed: Annotated[
HttpConnectionFailed, Field(alias="httpConnectionFailed")
]
class ResponseStreamConnectionFailed(BaseModel):
http_status_code: Annotated[
int | None, Field(alias="httpStatusCode", ge=0, le=65535)
] = None
class ResponseStreamConnectionFailedCodexErrorInfo(BaseModel):
model_config = ConfigDict(
extra="forbid",
)
response_stream_connection_failed: Annotated[
ResponseStreamConnectionFailed, Field(alias="responseStreamConnectionFailed")
]
class ResponseStreamDisconnected(BaseModel):
http_status_code: Annotated[
int | None, Field(alias="httpStatusCode", ge=0, le=65535)
] = None
class ResponseStreamDisconnectedCodexErrorInfo(BaseModel):
model_config = ConfigDict(
extra="forbid",
)
response_stream_disconnected: Annotated[
ResponseStreamDisconnected, Field(alias="responseStreamDisconnected")
]
class ResponseTooManyFailedAttempts(BaseModel):
http_status_code: Annotated[
int | None, Field(alias="httpStatusCode", ge=0, le=65535)
] = None
class ResponseTooManyFailedAttemptsCodexErrorInfo(BaseModel):
model_config = ConfigDict(
extra="forbid",
)
response_too_many_failed_attempts: Annotated[
ResponseTooManyFailedAttempts, Field(alias="responseTooManyFailedAttempts")
]
class CodexErrorInfo(
RootModel[
CodexErrorInfo1
| HttpConnectionFailedCodexErrorInfo
| ResponseStreamConnectionFailedCodexErrorInfo
| ResponseStreamDisconnectedCodexErrorInfo
| ResponseTooManyFailedAttemptsCodexErrorInfo
]
):
root: Annotated[
CodexErrorInfo1
| HttpConnectionFailedCodexErrorInfo
| ResponseStreamConnectionFailedCodexErrorInfo
| ResponseStreamDisconnectedCodexErrorInfo
| ResponseTooManyFailedAttemptsCodexErrorInfo,
Field(
description="This translation layer make sure that we expose codex error code in camel case.\n\nWhen an upstream HTTP status is available (for example, from the Responses API or a provider), it is forwarded in `httpStatusCode` on the relevant `codexErrorInfo` variant."
),
]
class CollabAgentStatus(StrEnum):
pending_init = "pendingInit"
running = "running"
completed = "completed"
errored = "errored"
shutdown = "shutdown"
not_found = "notFound"
class CollabAgentTool(StrEnum):
spawn_agent = "spawnAgent"
send_input = "sendInput"
resume_agent = "resumeAgent"
wait = "wait"
close_agent = "closeAgent"
class CollabAgentToolCallStatus(StrEnum):
in_progress = "inProgress"
completed = "completed"
failed = "failed"
class ReadCommandActionType(RootModel[Literal["read"]]):
root: Annotated[Literal["read"], Field(title="ReadCommandActionType")]
class ReadCommandAction(BaseModel):
command: str
name: str
path: str
type: Annotated[ReadCommandActionType, Field(title="ReadCommandActionType")]
class ListFilesCommandActionType(RootModel[Literal["listFiles"]]):
root: Annotated[Literal["listFiles"], Field(title="ListFilesCommandActionType")]
class ListFilesCommandAction(BaseModel):
command: str
path: str | None = None
type: Annotated[
ListFilesCommandActionType, Field(title="ListFilesCommandActionType")
]
class SearchCommandActionType(RootModel[Literal["search"]]):
root: Annotated[Literal["search"], Field(title="SearchCommandActionType")]
class SearchCommandAction(BaseModel):
command: str
path: str | None = None
query: str | None = None
type: Annotated[SearchCommandActionType, Field(title="SearchCommandActionType")]
class UnknownCommandActionType(RootModel[Literal["unknown"]]):
root: Annotated[Literal["unknown"], Field(title="UnknownCommandActionType")]
class UnknownCommandAction(BaseModel):
command: str
type: Annotated[UnknownCommandActionType, Field(title="UnknownCommandActionType")]
class CommandAction(
RootModel[
ReadCommandAction
| ListFilesCommandAction
| SearchCommandAction
| UnknownCommandAction
]
):
root: (
ReadCommandAction
| ListFilesCommandAction
| SearchCommandAction
| UnknownCommandAction
)
class CommandExecOutputStream(RootModel[Literal["stdout"] | Literal["stderr"]]):
root: Annotated[
Literal["stdout"] | Literal["stderr"],
Field(description="Stream label for `command/exec/outputDelta` notifications."),
]
class CommandExecTerminalSize(BaseModel):
cols: Annotated[
int, Field(description="Terminal width in character cells.", ge=0, le=65535)
]
rows: Annotated[
int, Field(description="Terminal height in character cells.", ge=0, le=65535)
]
class CommandExecTerminateParams(BaseModel):
process_id: Annotated[
str,
Field(
alias="processId",
description="Client-supplied, connection-scoped `processId` from the original `command/exec` request.",
),
]
class CommandExecWriteParams(BaseModel):
close_stdin: Annotated[
bool | None,
Field(
alias="closeStdin",
description="Close stdin after writing `deltaBase64`, if present.",
),
] = None
delta_base64: Annotated[
str | None,
Field(
alias="deltaBase64",
description="Optional base64-encoded stdin bytes to write.",
),
] = None
process_id: Annotated[
str,
Field(
alias="processId",
description="Client-supplied, connection-scoped `processId` from the original `command/exec` request.",
),
]
class AcceptWithExecpolicyAmendment(BaseModel):
execpolicy_amendment: list[str]
class AcceptWithExecpolicyAmendmentCommandExecutionApprovalDecision(BaseModel):
model_config = ConfigDict(
extra="forbid",
)
accept_with_execpolicy_amendment: Annotated[
AcceptWithExecpolicyAmendment, Field(alias="acceptWithExecpolicyAmendment")
]
class CommandExecutionOutputDeltaNotification(BaseModel):
delta: str
item_id: Annotated[str, Field(alias="itemId")]
thread_id: Annotated[str, Field(alias="threadId")]
turn_id: Annotated[str, Field(alias="turnId")]
class CommandExecutionRequestApprovalSkillMetadata(BaseModel):
path_to_skills_md: Annotated[str, Field(alias="pathToSkillsMd")]
class CommandExecutionStatus(StrEnum):
in_progress = "inProgress"
completed = "completed"
failed = "failed"
declined = "declined"
class ConfigReadParams(BaseModel):
cwd: Annotated[
str | None,
Field(
description="Optional working directory to resolve project config layers. If specified, return the effective config as seen from that directory (i.e., including any project layers between `cwd` and the project/repo root)."
),
] = None
include_layers: Annotated[bool | None, Field(alias="includeLayers")] = False
class InputTextContentItemType(RootModel[Literal["input_text"]]):
root: Annotated[Literal["input_text"], Field(title="InputTextContentItemType")]
class InputTextContentItem(BaseModel):
text: str
type: Annotated[InputTextContentItemType, Field(title="InputTextContentItemType")]
class InputImageContentItemType(RootModel[Literal["input_image"]]):
root: Annotated[Literal["input_image"], Field(title="InputImageContentItemType")]
class InputImageContentItem(BaseModel):
image_url: str
type: Annotated[InputImageContentItemType, Field(title="InputImageContentItemType")]
class OutputTextContentItemType(RootModel[Literal["output_text"]]):
root: Annotated[Literal["output_text"], Field(title="OutputTextContentItemType")]
class OutputTextContentItem(BaseModel):
text: str
type: Annotated[OutputTextContentItemType, Field(title="OutputTextContentItemType")]
class ContentItem(
RootModel[InputTextContentItem | InputImageContentItem | OutputTextContentItem]
):
root: InputTextContentItem | InputImageContentItem | OutputTextContentItem
class ContextCompactedNotification(BaseModel):
thread_id: Annotated[str, Field(alias="threadId")]
turn_id: Annotated[str, Field(alias="turnId")]
class CreditsSnapshot(BaseModel):
balance: str | None = None
has_credits: Annotated[bool, Field(alias="hasCredits")]
unlimited: bool
class CustomPrompt(BaseModel):
argument_hint: str | None = None
content: str
description: str | None = None
name: str
path: str
class DeprecationNoticeNotification(BaseModel):
details: Annotated[
str | None,
Field(
description="Optional extra guidance, such as migration steps or rationale."
),
] = None
summary: Annotated[str, Field(description="Concise summary of what is deprecated.")]
class Duration(BaseModel):
nanos: Annotated[int, Field(ge=0, le=4294967295)]
secs: Annotated[int, Field(ge=0, le=18446744073709551615)]
class InputTextDynamicToolCallOutputContentItemType(RootModel[Literal["inputText"]]):
root: Annotated[
Literal["inputText"],
Field(title="InputTextDynamicToolCallOutputContentItemType"),
]
class InputTextDynamicToolCallOutputContentItem(BaseModel):
text: str
type: Annotated[
InputTextDynamicToolCallOutputContentItemType,
Field(title="InputTextDynamicToolCallOutputContentItemType"),
]
class InputImageDynamicToolCallOutputContentItemType(RootModel[Literal["inputImage"]]):
root: Annotated[
Literal["inputImage"],
Field(title="InputImageDynamicToolCallOutputContentItemType"),
]
class InputImageDynamicToolCallOutputContentItem(BaseModel):
image_url: Annotated[str, Field(alias="imageUrl")]
type: Annotated[
InputImageDynamicToolCallOutputContentItemType,
Field(title="InputImageDynamicToolCallOutputContentItemType"),
]
class DynamicToolCallOutputContentItem(
RootModel[
InputTextDynamicToolCallOutputContentItem
| InputImageDynamicToolCallOutputContentItem
]
):
root: (
InputTextDynamicToolCallOutputContentItem
| InputImageDynamicToolCallOutputContentItem
)
class DynamicToolCallParams(BaseModel):
arguments: Any
call_id: Annotated[str, Field(alias="callId")]
thread_id: Annotated[str, Field(alias="threadId")]
tool: str
turn_id: Annotated[str, Field(alias="turnId")]
class DynamicToolCallResponse(BaseModel):
content_items: Annotated[
list[DynamicToolCallOutputContentItem], Field(alias="contentItems")
]
success: bool
class DynamicToolCallStatus(StrEnum):
in_progress = "inProgress"
completed = "completed"
failed = "failed"
class ElicitationRequest1(BaseModel):
field_meta: Annotated[Any | None, Field(alias="_meta")] = None
message: str
mode: Literal["form"]
requested_schema: Any
class ElicitationRequest2(BaseModel):
field_meta: Annotated[Any | None, Field(alias="_meta")] = None
elicitation_id: str
message: str
mode: Literal["url"]
url: str
class ElicitationRequest(RootModel[ElicitationRequest1 | ElicitationRequest2]):
root: ElicitationRequest1 | ElicitationRequest2
class ErrorEventMsgType(RootModel[Literal["error"]]):
root: Annotated[Literal["error"], Field(title="ErrorEventMsgType")]
class ErrorEventMsg(BaseModel):
codex_error_info: CodexErrorInfo | None = None
message: str
type: Annotated[ErrorEventMsgType, Field(title="ErrorEventMsgType")]
class WarningEventMsgType(RootModel[Literal["warning"]]):
root: Annotated[Literal["warning"], Field(title="WarningEventMsgType")]
class WarningEventMsg(BaseModel):
message: str
type: Annotated[WarningEventMsgType, Field(title="WarningEventMsgType")]
class RealtimeConversationStartedEventMsgType(
RootModel[Literal["realtime_conversation_started"]]
):
root: Annotated[
Literal["realtime_conversation_started"],
Field(title="RealtimeConversationStartedEventMsgType"),
]
class RealtimeConversationStartedEventMsg(BaseModel):
session_id: str | None = None
type: Annotated[
RealtimeConversationStartedEventMsgType,
Field(title="RealtimeConversationStartedEventMsgType"),
]
class RealtimeConversationRealtimeEventMsgType(
RootModel[Literal["realtime_conversation_realtime"]]
):
root: Annotated[
Literal["realtime_conversation_realtime"],
Field(title="RealtimeConversationRealtimeEventMsgType"),
]
class RealtimeConversationClosedEventMsgType(
RootModel[Literal["realtime_conversation_closed"]]
):
root: Annotated[
Literal["realtime_conversation_closed"],
Field(title="RealtimeConversationClosedEventMsgType"),
]
class RealtimeConversationClosedEventMsg(BaseModel):
reason: str | None = None
type: Annotated[
RealtimeConversationClosedEventMsgType,
Field(title="RealtimeConversationClosedEventMsgType"),
]
class ModelRerouteEventMsgType(RootModel[Literal["model_reroute"]]):
root: Annotated[Literal["model_reroute"], Field(title="ModelRerouteEventMsgType")]
class ContextCompactedEventMsgType(RootModel[Literal["context_compacted"]]):
root: Annotated[
Literal["context_compacted"], Field(title="ContextCompactedEventMsgType")
]
class ContextCompactedEventMsg(BaseModel):
type: Annotated[
ContextCompactedEventMsgType, Field(title="ContextCompactedEventMsgType")
]
class ThreadRolledBackEventMsgType(RootModel[Literal["thread_rolled_back"]]):
root: Annotated[
Literal["thread_rolled_back"], Field(title="ThreadRolledBackEventMsgType")
]
class ThreadRolledBackEventMsg(BaseModel):
num_turns: Annotated[
int,
Field(
description="Number of user turns that were removed from context.",
ge=0,
le=4294967295,
),
]
type: Annotated[
ThreadRolledBackEventMsgType, Field(title="ThreadRolledBackEventMsgType")
]
class TaskStartedEventMsgType(RootModel[Literal["task_started"]]):
root: Annotated[Literal["task_started"], Field(title="TaskStartedEventMsgType")]
class TaskCompleteEventMsgType(RootModel[Literal["task_complete"]]):
root: Annotated[Literal["task_complete"], Field(title="TaskCompleteEventMsgType")]
class TaskCompleteEventMsg(BaseModel):
last_agent_message: str | None = None
turn_id: str
type: Annotated[TaskCompleteEventMsgType, Field(title="TaskCompleteEventMsgType")]
class TokenCountEventMsgType(RootModel[Literal["token_count"]]):
root: Annotated[Literal["token_count"], Field(title="TokenCountEventMsgType")]
class AgentMessageEventMsgType(RootModel[Literal["agent_message"]]):
root: Annotated[Literal["agent_message"], Field(title="AgentMessageEventMsgType")]
class UserMessageEventMsgType(RootModel[Literal["user_message"]]):
root: Annotated[Literal["user_message"], Field(title="UserMessageEventMsgType")]
class AgentMessageDeltaEventMsgType(RootModel[Literal["agent_message_delta"]]):
root: Annotated[
Literal["agent_message_delta"], Field(title="AgentMessageDeltaEventMsgType")
]
class AgentMessageDeltaEventMsg(BaseModel):
delta: str
type: Annotated[
AgentMessageDeltaEventMsgType, Field(title="AgentMessageDeltaEventMsgType")
]
class AgentReasoningEventMsgType(RootModel[Literal["agent_reasoning"]]):
root: Annotated[
Literal["agent_reasoning"], Field(title="AgentReasoningEventMsgType")
]
class AgentReasoningEventMsg(BaseModel):
text: str
type: Annotated[
AgentReasoningEventMsgType, Field(title="AgentReasoningEventMsgType")
]
class AgentReasoningDeltaEventMsgType(RootModel[Literal["agent_reasoning_delta"]]):
root: Annotated[
Literal["agent_reasoning_delta"], Field(title="AgentReasoningDeltaEventMsgType")
]
class AgentReasoningDeltaEventMsg(BaseModel):
delta: str
type: Annotated[
AgentReasoningDeltaEventMsgType, Field(title="AgentReasoningDeltaEventMsgType")
]
class AgentReasoningRawContentEventMsgType(
RootModel[Literal["agent_reasoning_raw_content"]]
):
root: Annotated[
Literal["agent_reasoning_raw_content"],
Field(title="AgentReasoningRawContentEventMsgType"),
]
class AgentReasoningRawContentEventMsg(BaseModel):
text: str
type: Annotated[
AgentReasoningRawContentEventMsgType,
Field(title="AgentReasoningRawContentEventMsgType"),
]
class AgentReasoningRawContentDeltaEventMsgType(
RootModel[Literal["agent_reasoning_raw_content_delta"]]
):
root: Annotated[
Literal["agent_reasoning_raw_content_delta"],
Field(title="AgentReasoningRawContentDeltaEventMsgType"),
]
class AgentReasoningRawContentDeltaEventMsg(BaseModel):
delta: str
type: Annotated[
AgentReasoningRawContentDeltaEventMsgType,
Field(title="AgentReasoningRawContentDeltaEventMsgType"),
]
class AgentReasoningSectionBreakEventMsgType(
RootModel[Literal["agent_reasoning_section_break"]]
):
root: Annotated[
Literal["agent_reasoning_section_break"],
Field(title="AgentReasoningSectionBreakEventMsgType"),
]
class AgentReasoningSectionBreakEventMsg(BaseModel):
item_id: str | None = ""
summary_index: int | None = 0
type: Annotated[
AgentReasoningSectionBreakEventMsgType,
Field(title="AgentReasoningSectionBreakEventMsgType"),
]
class SessionConfiguredEventMsgType(RootModel[Literal["session_configured"]]):
root: Annotated[
Literal["session_configured"], Field(title="SessionConfiguredEventMsgType")
]
class ThreadNameUpdatedEventMsgType(RootModel[Literal["thread_name_updated"]]):
root: Annotated[
Literal["thread_name_updated"], Field(title="ThreadNameUpdatedEventMsgType")
]
class McpStartupUpdateEventMsgType(RootModel[Literal["mcp_startup_update"]]):
root: Annotated[
Literal["mcp_startup_update"], Field(title="McpStartupUpdateEventMsgType")
]
class McpStartupCompleteEventMsgType(RootModel[Literal["mcp_startup_complete"]]):
root: Annotated[
Literal["mcp_startup_complete"], Field(title="McpStartupCompleteEventMsgType")
]
class McpToolCallBeginEventMsgType(RootModel[Literal["mcp_tool_call_begin"]]):
root: Annotated[
Literal["mcp_tool_call_begin"], Field(title="McpToolCallBeginEventMsgType")
]
class McpToolCallEndEventMsgType(RootModel[Literal["mcp_tool_call_end"]]):
root: Annotated[
Literal["mcp_tool_call_end"], Field(title="McpToolCallEndEventMsgType")
]
class WebSearchBeginEventMsgType(RootModel[Literal["web_search_begin"]]):
root: Annotated[
Literal["web_search_begin"], Field(title="WebSearchBeginEventMsgType")
]
class WebSearchBeginEventMsg(BaseModel):
call_id: str
type: Annotated[
WebSearchBeginEventMsgType, Field(title="WebSearchBeginEventMsgType")
]
class WebSearchEndEventMsgType(RootModel[Literal["web_search_end"]]):
root: Annotated[Literal["web_search_end"], Field(title="WebSearchEndEventMsgType")]
class ImageGenerationBeginEventMsgType(RootModel[Literal["image_generation_begin"]]):
root: Annotated[
Literal["image_generation_begin"],
Field(title="ImageGenerationBeginEventMsgType"),
]
class ImageGenerationBeginEventMsg(BaseModel):
call_id: str
type: Annotated[
ImageGenerationBeginEventMsgType,
Field(title="ImageGenerationBeginEventMsgType"),
]
class ImageGenerationEndEventMsgType(RootModel[Literal["image_generation_end"]]):
root: Annotated[
Literal["image_generation_end"], Field(title="ImageGenerationEndEventMsgType")
]
class ImageGenerationEndEventMsg(BaseModel):
call_id: str
result: str
revised_prompt: str | None = None
saved_path: str | None = None
status: str
type: Annotated[
ImageGenerationEndEventMsgType, Field(title="ImageGenerationEndEventMsgType")
]
class ExecCommandBeginEventMsgType(RootModel[Literal["exec_command_begin"]]):
root: Annotated[
Literal["exec_command_begin"], Field(title="ExecCommandBeginEventMsgType")
]
class ExecCommandOutputDeltaEventMsgType(
RootModel[Literal["exec_command_output_delta"]]
):
root: Annotated[
Literal["exec_command_output_delta"],
Field(title="ExecCommandOutputDeltaEventMsgType"),
]
class TerminalInteractionEventMsgType(RootModel[Literal["terminal_interaction"]]):
root: Annotated[
Literal["terminal_interaction"], Field(title="TerminalInteractionEventMsgType")
]
class TerminalInteractionEventMsg(BaseModel):
call_id: Annotated[
str,
Field(
description="Identifier for the ExecCommandBegin that produced this chunk."
),
]
process_id: Annotated[
str, Field(description="Process id associated with the running command.")
]
stdin: Annotated[str, Field(description="Stdin sent to the running session.")]
type: Annotated[
TerminalInteractionEventMsgType, Field(title="TerminalInteractionEventMsgType")
]
class ExecCommandEndEventMsgType(RootModel[Literal["exec_command_end"]]):
root: Annotated[
Literal["exec_command_end"], Field(title="ExecCommandEndEventMsgType")
]
class ViewImageToolCallEventMsgType(RootModel[Literal["view_image_tool_call"]]):
root: Annotated[
Literal["view_image_tool_call"], Field(title="ViewImageToolCallEventMsgType")
]
class ViewImageToolCallEventMsg(BaseModel):
call_id: Annotated[
str, Field(description="Identifier for the originating tool call.")
]
path: Annotated[
str, Field(description="Local filesystem path provided to the tool.")
]
type: Annotated[
ViewImageToolCallEventMsgType, Field(title="ViewImageToolCallEventMsgType")
]
class ExecApprovalRequestEventMsgType(RootModel[Literal["exec_approval_request"]]):
root: Annotated[
Literal["exec_approval_request"], Field(title="ExecApprovalRequestEventMsgType")
]
class RequestPermissionsEventMsgType(RootModel[Literal["request_permissions"]]):
root: Annotated[
Literal["request_permissions"], Field(title="RequestPermissionsEventMsgType")
]
class RequestUserInputEventMsgType(RootModel[Literal["request_user_input"]]):
root: Annotated[
Literal["request_user_input"], Field(title="RequestUserInputEventMsgType")
]
class DynamicToolCallRequestEventMsgType(
RootModel[Literal["dynamic_tool_call_request"]]
):
root: Annotated[
Literal["dynamic_tool_call_request"],
Field(title="DynamicToolCallRequestEventMsgType"),
]
class DynamicToolCallRequestEventMsg(BaseModel):
arguments: Any
call_id: Annotated[str, Field(alias="callId")]
tool: str
turn_id: Annotated[str, Field(alias="turnId")]
type: Annotated[
DynamicToolCallRequestEventMsgType,
Field(title="DynamicToolCallRequestEventMsgType"),
]
class DynamicToolCallResponseEventMsgType(
RootModel[Literal["dynamic_tool_call_response"]]
):
root: Annotated[
Literal["dynamic_tool_call_response"],
Field(title="DynamicToolCallResponseEventMsgType"),
]
class DynamicToolCallResponseEventMsg(BaseModel):
arguments: Annotated[Any, Field(description="Dynamic tool call arguments.")]
call_id: Annotated[
str,
Field(description="Identifier for the corresponding DynamicToolCallRequest."),
]
content_items: Annotated[
list[DynamicToolCallOutputContentItem],
Field(description="Dynamic tool response content items."),
]
duration: Annotated[
Duration, Field(description="The duration of the dynamic tool call.")
]
error: Annotated[
str | None,
Field(
description="Optional error text when the tool call failed before producing a response."
),
] = None
success: Annotated[bool, Field(description="Whether the tool call succeeded.")]
tool: Annotated[str, Field(description="Dynamic tool name.")]
turn_id: Annotated[
str, Field(description="Turn ID that this dynamic tool call belongs to.")
]
type: Annotated[
DynamicToolCallResponseEventMsgType,
Field(title="DynamicToolCallResponseEventMsgType"),
]
class ElicitationRequestEventMsgType(RootModel[Literal["elicitation_request"]]):
root: Annotated[
Literal["elicitation_request"], Field(title="ElicitationRequestEventMsgType")
]
class ApplyPatchApprovalRequestEventMsgType(
RootModel[Literal["apply_patch_approval_request"]]
):
root: Annotated[
Literal["apply_patch_approval_request"],
Field(title="ApplyPatchApprovalRequestEventMsgType"),
]
class DeprecationNoticeEventMsgType(RootModel[Literal["deprecation_notice"]]):
root: Annotated[
Literal["deprecation_notice"], Field(title="DeprecationNoticeEventMsgType")
]
class DeprecationNoticeEventMsg(BaseModel):
details: Annotated[
str | None,
Field(
description="Optional extra guidance, such as migration steps or rationale."
),
] = None
summary: Annotated[str, Field(description="Concise summary of what is deprecated.")]
type: Annotated[
DeprecationNoticeEventMsgType, Field(title="DeprecationNoticeEventMsgType")
]
class BackgroundEventEventMsgType(RootModel[Literal["background_event"]]):
root: Annotated[
Literal["background_event"], Field(title="BackgroundEventEventMsgType")
]
class BackgroundEventEventMsg(BaseModel):
message: str
type: Annotated[
BackgroundEventEventMsgType, Field(title="BackgroundEventEventMsgType")
]
class UndoStartedEventMsgType(RootModel[Literal["undo_started"]]):
root: Annotated[Literal["undo_started"], Field(title="UndoStartedEventMsgType")]
class UndoStartedEventMsg(BaseModel):
message: str | None = None
type: Annotated[UndoStartedEventMsgType, Field(title="UndoStartedEventMsgType")]
class UndoCompletedEventMsgType(RootModel[Literal["undo_completed"]]):
root: Annotated[Literal["undo_completed"], Field(title="UndoCompletedEventMsgType")]
class UndoCompletedEventMsg(BaseModel):
message: str | None = None
success: bool
type: Annotated[UndoCompletedEventMsgType, Field(title="UndoCompletedEventMsgType")]
class StreamErrorEventMsgType(RootModel[Literal["stream_error"]]):
root: Annotated[Literal["stream_error"], Field(title="StreamErrorEventMsgType")]
class StreamErrorEventMsg(BaseModel):
additional_details: Annotated[
str | None,
Field(
description="Optional details about the underlying stream failure (often the same human-readable message that is surfaced as the terminal error if retries are exhausted)."
),
] = None
codex_error_info: CodexErrorInfo | None = None
message: str
type: Annotated[StreamErrorEventMsgType, Field(title="StreamErrorEventMsgType")]
class PatchApplyBeginEventMsgType(RootModel[Literal["patch_apply_begin"]]):
root: Annotated[
Literal["patch_apply_begin"], Field(title="PatchApplyBeginEventMsgType")
]
class PatchApplyEndEventMsgType(RootModel[Literal["patch_apply_end"]]):
root: Annotated[
Literal["patch_apply_end"], Field(title="PatchApplyEndEventMsgType")
]
class TurnDiffEventMsgType(RootModel[Literal["turn_diff"]]):
root: Annotated[Literal["turn_diff"], Field(title="TurnDiffEventMsgType")]
class TurnDiffEventMsg(BaseModel):
type: Annotated[TurnDiffEventMsgType, Field(title="TurnDiffEventMsgType")]
unified_diff: str
class GetHistoryEntryResponseEventMsgType(
RootModel[Literal["get_history_entry_response"]]
):
root: Annotated[
Literal["get_history_entry_response"],
Field(title="GetHistoryEntryResponseEventMsgType"),
]
class McpListToolsResponseEventMsgType(RootModel[Literal["mcp_list_tools_response"]]):
root: Annotated[
Literal["mcp_list_tools_response"],
Field(title="McpListToolsResponseEventMsgType"),
]
class ListCustomPromptsResponseEventMsgType(
RootModel[Literal["list_custom_prompts_response"]]
):
root: Annotated[
Literal["list_custom_prompts_response"],
Field(title="ListCustomPromptsResponseEventMsgType"),
]
class ListCustomPromptsResponseEventMsg(BaseModel):
custom_prompts: list[CustomPrompt]
type: Annotated[
ListCustomPromptsResponseEventMsgType,
Field(title="ListCustomPromptsResponseEventMsgType"),
]
class ListSkillsResponseEventMsgType(RootModel[Literal["list_skills_response"]]):
root: Annotated[
Literal["list_skills_response"], Field(title="ListSkillsResponseEventMsgType")
]
class ListRemoteSkillsResponseEventMsgType(
RootModel[Literal["list_remote_skills_response"]]
):
root: Annotated[
Literal["list_remote_skills_response"],
Field(title="ListRemoteSkillsResponseEventMsgType"),
]
class RemoteSkillDownloadedEventMsgType(RootModel[Literal["remote_skill_downloaded"]]):
root: Annotated[
Literal["remote_skill_downloaded"],
Field(title="RemoteSkillDownloadedEventMsgType"),
]
class RemoteSkillDownloadedEventMsg(BaseModel):
id: str
name: str
path: str
type: Annotated[
RemoteSkillDownloadedEventMsgType,
Field(title="RemoteSkillDownloadedEventMsgType"),
]
class SkillsUpdateAvailableEventMsgType(RootModel[Literal["skills_update_available"]]):
root: Annotated[
Literal["skills_update_available"],
Field(title="SkillsUpdateAvailableEventMsgType"),
]
class SkillsUpdateAvailableEventMsg(BaseModel):
type: Annotated[
SkillsUpdateAvailableEventMsgType,
Field(title="SkillsUpdateAvailableEventMsgType"),
]
class PlanUpdateEventMsgType(RootModel[Literal["plan_update"]]):
root: Annotated[Literal["plan_update"], Field(title="PlanUpdateEventMsgType")]
class TurnAbortedEventMsgType(RootModel[Literal["turn_aborted"]]):
root: Annotated[Literal["turn_aborted"], Field(title="TurnAbortedEventMsgType")]
class ShutdownCompleteEventMsgType(RootModel[Literal["shutdown_complete"]]):
root: Annotated[
Literal["shutdown_complete"], Field(title="ShutdownCompleteEventMsgType")
]
class ShutdownCompleteEventMsg(BaseModel):
type: Annotated[
ShutdownCompleteEventMsgType, Field(title="ShutdownCompleteEventMsgType")
]
class EnteredReviewModeEventMsgType(RootModel[Literal["entered_review_mode"]]):
root: Annotated[
Literal["entered_review_mode"], Field(title="EnteredReviewModeEventMsgType")
]
class ExitedReviewModeEventMsgType(RootModel[Literal["exited_review_mode"]]):
root: Annotated[
Literal["exited_review_mode"], Field(title="ExitedReviewModeEventMsgType")
]
class RawResponseItemEventMsgType(RootModel[Literal["raw_response_item"]]):
root: Annotated[
Literal["raw_response_item"], Field(title="RawResponseItemEventMsgType")
]
class ItemStartedEventMsgType(RootModel[Literal["item_started"]]):
root: Annotated[Literal["item_started"], Field(title="ItemStartedEventMsgType")]
class ItemCompletedEventMsgType(RootModel[Literal["item_completed"]]):
root: Annotated[Literal["item_completed"], Field(title="ItemCompletedEventMsgType")]
class AgentMessageContentDeltaEventMsgType(
RootModel[Literal["agent_message_content_delta"]]
):
root: Annotated[
Literal["agent_message_content_delta"],
Field(title="AgentMessageContentDeltaEventMsgType"),
]
class AgentMessageContentDeltaEventMsg(BaseModel):
delta: str
item_id: str
thread_id: str
turn_id: str
type: Annotated[
AgentMessageContentDeltaEventMsgType,
Field(title="AgentMessageContentDeltaEventMsgType"),
]
class PlanDeltaEventMsgType(RootModel[Literal["plan_delta"]]):
root: Annotated[Literal["plan_delta"], Field(title="PlanDeltaEventMsgType")]
class PlanDeltaEventMsg(BaseModel):
delta: str
item_id: str
thread_id: str
turn_id: str
type: Annotated[PlanDeltaEventMsgType, Field(title="PlanDeltaEventMsgType")]
class ReasoningContentDeltaEventMsgType(RootModel[Literal["reasoning_content_delta"]]):
root: Annotated[
Literal["reasoning_content_delta"],
Field(title="ReasoningContentDeltaEventMsgType"),
]
class ReasoningContentDeltaEventMsg(BaseModel):
delta: str
item_id: str
summary_index: int | None = 0
thread_id: str
turn_id: str
type: Annotated[
ReasoningContentDeltaEventMsgType,
Field(title="ReasoningContentDeltaEventMsgType"),
]
class ReasoningRawContentDeltaEventMsgType(
RootModel[Literal["reasoning_raw_content_delta"]]
):
root: Annotated[
Literal["reasoning_raw_content_delta"],
Field(title="ReasoningRawContentDeltaEventMsgType"),
]
class ReasoningRawContentDeltaEventMsg(BaseModel):
content_index: int | None = 0
delta: str
item_id: str
thread_id: str
turn_id: str
type: Annotated[
ReasoningRawContentDeltaEventMsgType,
Field(title="ReasoningRawContentDeltaEventMsgType"),
]
class CollabAgentSpawnBeginEventMsgType(RootModel[Literal["collab_agent_spawn_begin"]]):
root: Annotated[
Literal["collab_agent_spawn_begin"],
Field(title="CollabAgentSpawnBeginEventMsgType"),
]
class CollabAgentSpawnEndEventMsgType(RootModel[Literal["collab_agent_spawn_end"]]):
root: Annotated[
Literal["collab_agent_spawn_end"],
Field(title="CollabAgentSpawnEndEventMsgType"),
]
class CollabAgentInteractionBeginEventMsgType(
RootModel[Literal["collab_agent_interaction_begin"]]
):
root: Annotated[
Literal["collab_agent_interaction_begin"],
Field(title="CollabAgentInteractionBeginEventMsgType"),
]
class CollabAgentInteractionEndEventMsgType(
RootModel[Literal["collab_agent_interaction_end"]]
):
root: Annotated[
Literal["collab_agent_interaction_end"],
Field(title="CollabAgentInteractionEndEventMsgType"),
]
class CollabWaitingBeginEventMsgType(RootModel[Literal["collab_waiting_begin"]]):
root: Annotated[
Literal["collab_waiting_begin"], Field(title="CollabWaitingBeginEventMsgType")
]
class CollabWaitingEndEventMsgType(RootModel[Literal["collab_waiting_end"]]):
root: Annotated[
Literal["collab_waiting_end"], Field(title="CollabWaitingEndEventMsgType")
]
class CollabCloseBeginEventMsgType(RootModel[Literal["collab_close_begin"]]):
root: Annotated[
Literal["collab_close_begin"], Field(title="CollabCloseBeginEventMsgType")
]
class CollabCloseEndEventMsgType(RootModel[Literal["collab_close_end"]]):
root: Annotated[
Literal["collab_close_end"], Field(title="CollabCloseEndEventMsgType")
]
class CollabResumeBeginEventMsgType(RootModel[Literal["collab_resume_begin"]]):
root: Annotated[
Literal["collab_resume_begin"], Field(title="CollabResumeBeginEventMsgType")
]
class CollabResumeEndEventMsgType(RootModel[Literal["collab_resume_end"]]):
root: Annotated[
Literal["collab_resume_end"], Field(title="CollabResumeEndEventMsgType")
]
class ExecApprovalRequestSkillMetadata(BaseModel):
path_to_skills_md: str
class ExecCommandSource(StrEnum):
agent = "agent"
user_shell = "user_shell"
unified_exec_startup = "unified_exec_startup"
unified_exec_interaction = "unified_exec_interaction"
class ExecCommandStatus(StrEnum):
completed = "completed"
failed = "failed"
declined = "declined"
class ExecOutputStream(StrEnum):
stdout = "stdout"
stderr = "stderr"
class ExperimentalFeatureListParams(BaseModel):
cursor: Annotated[
str | None,
Field(description="Opaque pagination cursor returned by a previous call."),
] = None
limit: Annotated[
int | None,
Field(
description="Optional page size; defaults to a reasonable server-side value.",
ge=0,
le=4294967295,
),
] = None
class ExternalAgentConfigDetectParams(BaseModel):
cwds: Annotated[
list[str] | None,
Field(
description="Zero or more working directories to include for repo-scoped detection."
),
] = None
include_home: Annotated[
bool | None,
Field(
alias="includeHome",
description="If true, include detection under the user's home (~/.claude, ~/.codex, etc.).",
),
] = None
class ExternalAgentConfigMigrationItemType(StrEnum):
agents_md = "AGENTS_MD"
config = "CONFIG"
skills = "SKILLS"
mcp_server_config = "MCP_SERVER_CONFIG"
class FeedbackUploadParams(BaseModel):
classification: str
extra_log_files: Annotated[list[str] | None, Field(alias="extraLogFiles")] = None
include_logs: Annotated[bool, Field(alias="includeLogs")]
reason: str | None = None
thread_id: Annotated[str | None, Field(alias="threadId")] = None
class AddFileChangeType(RootModel[Literal["add"]]):
root: Annotated[Literal["add"], Field(title="AddFileChangeType")]
class AddFileChange(BaseModel):
content: str
type: Annotated[AddFileChangeType, Field(title="AddFileChangeType")]
class DeleteFileChangeType(RootModel[Literal["delete"]]):
root: Annotated[Literal["delete"], Field(title="DeleteFileChangeType")]
class DeleteFileChange(BaseModel):
content: str
type: Annotated[DeleteFileChangeType, Field(title="DeleteFileChangeType")]
class UpdateFileChangeType(RootModel[Literal["update"]]):
root: Annotated[Literal["update"], Field(title="UpdateFileChangeType")]
class UpdateFileChange(BaseModel):
move_path: str | None = None
type: Annotated[UpdateFileChangeType, Field(title="UpdateFileChangeType")]
unified_diff: str
class FileChange(RootModel[AddFileChange | DeleteFileChange | UpdateFileChange]):
root: AddFileChange | DeleteFileChange | UpdateFileChange
class FileChangeApprovalDecision(
RootModel[
Literal["accept"]
| Literal["acceptForSession"]
| Literal["decline"]
| Literal["cancel"]
]
):
root: (
Literal["accept"]
| Literal["acceptForSession"]
| Literal["decline"]
| Literal["cancel"]
)
class FileChangeOutputDeltaNotification(BaseModel):
delta: str
item_id: Annotated[str, Field(alias="itemId")]
thread_id: Annotated[str, Field(alias="threadId")]
turn_id: Annotated[str, Field(alias="turnId")]
class FileChangeRequestApprovalParams(BaseModel):
grant_root: Annotated[
str | None,
Field(
alias="grantRoot",
description="[UNSTABLE] When set, the agent is asking the user to allow writes under this root for the remainder of the session (unclear if this is honored today).",
),
] = None
item_id: Annotated[str, Field(alias="itemId")]
reason: Annotated[
str | None,
Field(
description="Optional explanatory reason (e.g. request for extra write access)."
),
] = None
thread_id: Annotated[str, Field(alias="threadId")]
turn_id: Annotated[str, Field(alias="turnId")]
class FileChangeRequestApprovalResponse(BaseModel):
decision: FileChangeApprovalDecision
class FileSystemPermissions(BaseModel):
read: list[AbsolutePathBuf] | None = None
write: list[AbsolutePathBuf] | None = None
class InputTextFunctionCallOutputContentItemType(RootModel[Literal["input_text"]]):
root: Annotated[
Literal["input_text"], Field(title="InputTextFunctionCallOutputContentItemType")
]
class InputTextFunctionCallOutputContentItem(BaseModel):
text: str
type: Annotated[
InputTextFunctionCallOutputContentItemType,
Field(title="InputTextFunctionCallOutputContentItemType"),
]
class InputImageFunctionCallOutputContentItemType(RootModel[Literal["input_image"]]):
root: Annotated[
Literal["input_image"],
Field(title="InputImageFunctionCallOutputContentItemType"),
]
class FuzzyFileSearchParams(BaseModel):
cancellation_token: Annotated[str | None, Field(alias="cancellationToken")] = None
query: str
roots: list[str]
class Indice(RootModel[int]):
root: Annotated[int, Field(ge=0, le=4294967295)]
class FuzzyFileSearchResult(BaseModel):
file_name: str
indices: list[Indice] | None = None
path: str
root: str
score: Annotated[int, Field(ge=0, le=4294967295)]
class FuzzyFileSearchSessionCompletedNotification(BaseModel):
session_id: Annotated[str, Field(alias="sessionId")]
class FuzzyFileSearchSessionUpdatedNotification(BaseModel):
files: list[FuzzyFileSearchResult]
query: str
session_id: Annotated[str, Field(alias="sessionId")]
class GetAccountParams(BaseModel):
refresh_token: Annotated[
bool | None,
Field(
alias="refreshToken",
description="When `true`, requests a proactive token refresh before returning.\n\nIn managed auth mode this triggers the normal refresh-token flow. In external auth mode this flag is ignored. Clients should refresh tokens themselves and call `account/login/start` with `chatgptAuthTokens`.",
),
] = False
class GhostCommit(BaseModel):
id: str
parent: str | None = None
preexisting_untracked_dirs: list[str]
preexisting_untracked_files: list[str]
class GitInfo(BaseModel):
branch: str | None = None
origin_url: Annotated[str | None, Field(alias="originUrl")] = None
sha: str | None = None
class HazelnutScope(StrEnum):
example = "example"
workspace_shared = "workspace-shared"
all_shared = "all-shared"
personal = "personal"
class HistoryEntry(BaseModel):
conversation_id: str
text: str
ts: Annotated[int, Field(ge=0, le=18446744073709551615)]
class ImageDetail(StrEnum):
auto = "auto"
low = "low"
high = "high"
original = "original"
class InitializeCapabilities(BaseModel):
experimental_api: Annotated[
bool | None,
Field(
alias="experimentalApi",
description="Opt into receiving experimental API methods and fields.",
),
] = False
opt_out_notification_methods: Annotated[
list[str] | None,
Field(
alias="optOutNotificationMethods",
description="Exact notification method names that should be suppressed for this connection (for example `codex/event/session_configured`).",
),
] = None
class InitializeParams(BaseModel):
capabilities: InitializeCapabilities | None = None
client_info: Annotated[ClientInfo, Field(alias="clientInfo")]
class InitializeResponse(BaseModel):
user_agent: Annotated[str, Field(alias="userAgent")]
class JSONRPCErrorError(BaseModel):
code: int
data: Any | None = None
message: str
class JSONRPCNotification(BaseModel):
method: str
params: Any | None = None
class ListMcpServerStatusParams(BaseModel):
cursor: Annotated[
str | None,
Field(description="Opaque pagination cursor returned by a previous call."),
] = None
limit: Annotated[
int | None,
Field(
description="Optional page size; defaults to a server-defined value.",
ge=0,
le=4294967295,
),
] = None
class ExecLocalShellActionType(RootModel[Literal["exec"]]):
root: Annotated[Literal["exec"], Field(title="ExecLocalShellActionType")]
class ExecLocalShellAction(BaseModel):
command: list[str]
env: dict[str, Any] | None = None
timeout_ms: Annotated[int | None, Field(ge=0, le=18446744073709551615)] = None
type: Annotated[ExecLocalShellActionType, Field(title="ExecLocalShellActionType")]
user: str | None = None
working_directory: str | None = None
class LocalShellAction(RootModel[ExecLocalShellAction]):
root: ExecLocalShellAction
class LocalShellStatus(StrEnum):
completed = "completed"
in_progress = "in_progress"
incomplete = "incomplete"
class ApiKeyv2LoginAccountParamsType(RootModel[Literal["apiKey"]]):
root: Annotated[Literal["apiKey"], Field(title="ApiKeyv2::LoginAccountParamsType")]
class ApiKeyv2LoginAccountParams(BaseModel):
api_key: Annotated[str, Field(alias="apiKey")]
type: Annotated[
ApiKeyv2LoginAccountParamsType, Field(title="ApiKeyv2::LoginAccountParamsType")
]
class Chatgptv2LoginAccountParamsType(RootModel[Literal["chatgpt"]]):
root: Annotated[
Literal["chatgpt"], Field(title="Chatgptv2::LoginAccountParamsType")
]
class Chatgptv2LoginAccountParams(BaseModel):
type: Annotated[
Chatgptv2LoginAccountParamsType,
Field(title="Chatgptv2::LoginAccountParamsType"),
]
class ChatgptAuthTokensv2LoginAccountParamsType(
RootModel[Literal["chatgptAuthTokens"]]
):
root: Annotated[
Literal["chatgptAuthTokens"],
Field(title="ChatgptAuthTokensv2::LoginAccountParamsType"),
]
class ChatgptAuthTokensv2LoginAccountParams(BaseModel):
access_token: Annotated[
str,
Field(
alias="accessToken",
description="Access token (JWT) supplied by the client. This token is used for backend API requests and email extraction.",
),
]
chatgpt_account_id: Annotated[
str,
Field(
alias="chatgptAccountId",
description="Workspace/account identifier supplied by the client.",
),
]
chatgpt_plan_type: Annotated[
str | None,
Field(
alias="chatgptPlanType",
description="Optional plan type supplied by the client.\n\nWhen `null`, Codex attempts to derive the plan type from access-token claims. If unavailable, the plan defaults to `unknown`.",
),
] = None
type: Annotated[
ChatgptAuthTokensv2LoginAccountParamsType,
Field(title="ChatgptAuthTokensv2::LoginAccountParamsType"),
]
class LoginAccountParams(
RootModel[
ApiKeyv2LoginAccountParams
| Chatgptv2LoginAccountParams
| ChatgptAuthTokensv2LoginAccountParams
]
):
root: Annotated[
ApiKeyv2LoginAccountParams
| Chatgptv2LoginAccountParams
| ChatgptAuthTokensv2LoginAccountParams,
Field(title="LoginAccountParams"),
]
class MacOsAutomationPermission1(StrEnum):
none = "none"
all = "all"
class BundleIdsMacOsAutomationPermission(BaseModel):
model_config = ConfigDict(
extra="forbid",
)
bundle_ids: list[str]
class MacOsAutomationPermission(
RootModel[MacOsAutomationPermission1 | BundleIdsMacOsAutomationPermission]
):
root: MacOsAutomationPermission1 | BundleIdsMacOsAutomationPermission
class MacOsPreferencesPermission(StrEnum):
none = "none"
read_only = "read_only"
read_write = "read_write"
class MacOsSeatbeltProfileExtensions(BaseModel):
macos_accessibility: bool | None = False
macos_automation: Annotated[
MacOsAutomationPermission | None,
Field(default_factory=lambda: MacOsAutomationPermission("none")),
]
macos_calendar: bool | None = False
macos_preferences: MacOsPreferencesPermission | None = "read_only"
class McpAuthStatus(StrEnum):
unsupported = "unsupported"
not_logged_in = "notLoggedIn"
bearer_token = "bearerToken"
o_auth = "oAuth"
class McpElicitationArrayType(RootModel[Literal["array"]]):
root: Literal["array"]
class McpElicitationBooleanType(RootModel[Literal["boolean"]]):
root: Literal["boolean"]
class McpElicitationConstOption(BaseModel):
model_config = ConfigDict(
extra="forbid",
)
const: str
title: str
class McpElicitationNumberType(StrEnum):
number = "number"
integer = "integer"
class McpElicitationObjectType(RootModel[Literal["object"]]):
root: Literal["object"]
class McpElicitationStringFormat(StrEnum):
email = "email"
uri = "uri"
date = "date"
date_time = "date-time"
class McpElicitationStringType(RootModel[Literal["string"]]):
root: Literal["string"]
class McpElicitationTitledEnumItems(BaseModel):
model_config = ConfigDict(
extra="forbid",
)
any_of: Annotated[list[McpElicitationConstOption], Field(alias="anyOf")]
class McpElicitationTitledMultiSelectEnumSchema(BaseModel):
model_config = ConfigDict(
extra="forbid",
)
default: list[str] | None = None
description: str | None = None
items: McpElicitationTitledEnumItems
max_items: Annotated[
int | None, Field(alias="maxItems", ge=0, le=18446744073709551615)
] = None
min_items: Annotated[
int | None, Field(alias="minItems", ge=0, le=18446744073709551615)
] = None
title: str | None = None
type: McpElicitationArrayType
class McpElicitationTitledSingleSelectEnumSchema(BaseModel):
model_config = ConfigDict(
extra="forbid",
)
default: str | None = None
description: str | None = None
one_of: Annotated[list[McpElicitationConstOption], Field(alias="oneOf")]
title: str | None = None
type: McpElicitationStringType
class McpElicitationUntitledEnumItems(BaseModel):
model_config = ConfigDict(
extra="forbid",
)
enum: list[str]
type: McpElicitationStringType
class McpElicitationUntitledMultiSelectEnumSchema(BaseModel):
model_config = ConfigDict(
extra="forbid",
)
default: list[str] | None = None
description: str | None = None
items: McpElicitationUntitledEnumItems
max_items: Annotated[
int | None, Field(alias="maxItems", ge=0, le=18446744073709551615)
] = None
min_items: Annotated[
int | None, Field(alias="minItems", ge=0, le=18446744073709551615)
] = None
title: str | None = None
type: McpElicitationArrayType
class McpElicitationUntitledSingleSelectEnumSchema(BaseModel):
model_config = ConfigDict(
extra="forbid",
)
default: str | None = None
description: str | None = None
enum: list[str]
title: str | None = None
type: McpElicitationStringType
class McpInvocation(BaseModel):
arguments: Annotated[
Any | None, Field(description="Arguments to the tool call.")
] = None
server: Annotated[
str, Field(description="Name of the MCP server as defined in the config.")
]
tool: Annotated[
str, Field(description="Name of the tool as given by the MCP server.")
]
class McpServerElicitationAction(StrEnum):
accept = "accept"
decline = "decline"
cancel = "cancel"
class McpServerElicitationRequestParams2(BaseModel):
server_name: Annotated[str, Field(alias="serverName")]
thread_id: Annotated[str, Field(alias="threadId")]
turn_id: Annotated[
str | None,
Field(
alias="turnId",
description="Active Codex turn when this elicitation was observed, if app-server could correlate one.\n\nThis is nullable because MCP models elicitation as a standalone server-to-client request identified by the MCP server request id. It may be triggered during a turn, but turn context is app-server correlation rather than part of the protocol identity of the elicitation itself.",
),
] = None
field_meta: Annotated[Any | None, Field(alias="_meta")] = None
elicitation_id: Annotated[str, Field(alias="elicitationId")]
message: str
mode: Literal["url"]
url: str
class McpServerElicitationRequestResponse(BaseModel):
field_meta: Annotated[
Any | None,
Field(
alias="_meta",
description="Optional client metadata for form-mode action handling.",
),
] = None
action: McpServerElicitationAction
content: Annotated[
Any | None,
Field(
description="Structured user input for accepted elicitations, mirroring RMCP `CreateElicitationResult`.\n\nThis is nullable because decline/cancel responses have no content."
),
] = None
class McpServerOauthLoginCompletedNotification(BaseModel):
error: str | None = None
name: str
success: bool
class McpServerOauthLoginParams(BaseModel):
name: str
scopes: list[str] | None = None
timeout_secs: Annotated[int | None, Field(alias="timeoutSecs")] = None
class McpStartupFailure(BaseModel):
error: str
server: str
class StartingMcpStartupStatus(BaseModel):
state: Literal["starting"]
class ReadyMcpStartupStatus(BaseModel):
state: Literal["ready"]
class McpStartupStatus1(BaseModel):
error: str
state: Literal["failed"]
class CancelledMcpStartupStatus(BaseModel):
state: Literal["cancelled"]
class McpStartupStatus(
RootModel[
StartingMcpStartupStatus
| ReadyMcpStartupStatus
| McpStartupStatus1
| CancelledMcpStartupStatus
]
):
root: (
StartingMcpStartupStatus
| ReadyMcpStartupStatus
| McpStartupStatus1
| CancelledMcpStartupStatus
)
class McpToolCallError(BaseModel):
message: str
class McpToolCallProgressNotification(BaseModel):
item_id: Annotated[str, Field(alias="itemId")]
message: str
thread_id: Annotated[str, Field(alias="threadId")]
turn_id: Annotated[str, Field(alias="turnId")]
class McpToolCallResult(BaseModel):
content: list[Any]
structured_content: Annotated[Any | None, Field(alias="structuredContent")] = None
class McpToolCallStatus(StrEnum):
in_progress = "inProgress"
completed = "completed"
failed = "failed"
class MergeStrategy(StrEnum):
replace = "replace"
upsert = "upsert"
class MessagePhase(RootModel[Literal["commentary"] | Literal["final_answer"]]):
root: Annotated[
Literal["commentary"] | Literal["final_answer"],
Field(
description='Classifies an assistant message as interim commentary or final answer text.\n\nProviders do not emit this consistently, so callers must treat `None` as "phase unknown" and keep compatibility behavior for legacy models.'
),
]
class ModeKind(StrEnum):
plan = "plan"
default = "default"
class ModelListParams(BaseModel):
cursor: Annotated[
str | None,
Field(description="Opaque pagination cursor returned by a previous call."),
] = None
include_hidden: Annotated[
bool | None,
Field(
alias="includeHidden",
description="When true, include models that are hidden from the default picker list.",
),
] = None
limit: Annotated[
int | None,
Field(
description="Optional page size; defaults to a reasonable server-side value.",
ge=0,
le=4294967295,
),
] = None
class ModelRerouteReason(RootModel[Literal["highRiskCyberActivity"]]):
root: Literal["highRiskCyberActivity"]
class ModelReroutedNotification(BaseModel):
from_model: Annotated[str, Field(alias="fromModel")]
reason: ModelRerouteReason
thread_id: Annotated[str, Field(alias="threadId")]
to_model: Annotated[str, Field(alias="toModel")]
turn_id: Annotated[str, Field(alias="turnId")]
class NetworkAccess(StrEnum):
restricted = "restricted"
enabled = "enabled"
class NetworkApprovalProtocol(StrEnum):
http = "http"
https = "https"
socks5_tcp = "socks5Tcp"
socks5_udp = "socks5Udp"
class NetworkPermissions(BaseModel):
enabled: bool | None = None
class NetworkPolicyRuleAction(StrEnum):
allow = "allow"
deny = "deny"
class ReadParsedCommandType(RootModel[Literal["read"]]):
root: Annotated[Literal["read"], Field(title="ReadParsedCommandType")]
class ReadParsedCommand(BaseModel):
cmd: str
name: str
path: Annotated[
str,
Field(
description="(Best effort) Path to the file being read by the command. When possible, this is an absolute path, though when relative, it should be resolved against the `cwd`` that will be used to run the command to derive the absolute path."
),
]
type: Annotated[ReadParsedCommandType, Field(title="ReadParsedCommandType")]
class ListFilesParsedCommandType(RootModel[Literal["list_files"]]):
root: Annotated[Literal["list_files"], Field(title="ListFilesParsedCommandType")]
class ListFilesParsedCommand(BaseModel):
cmd: str
path: str | None = None
type: Annotated[
ListFilesParsedCommandType, Field(title="ListFilesParsedCommandType")
]
class SearchParsedCommandType(RootModel[Literal["search"]]):
root: Annotated[Literal["search"], Field(title="SearchParsedCommandType")]
class SearchParsedCommand(BaseModel):
cmd: str
path: str | None = None
query: str | None = None
type: Annotated[SearchParsedCommandType, Field(title="SearchParsedCommandType")]
class UnknownParsedCommandType(RootModel[Literal["unknown"]]):
root: Annotated[Literal["unknown"], Field(title="UnknownParsedCommandType")]
class UnknownParsedCommand(BaseModel):
cmd: str
type: Annotated[UnknownParsedCommandType, Field(title="UnknownParsedCommandType")]
class ParsedCommand(
RootModel[
ReadParsedCommand
| ListFilesParsedCommand
| SearchParsedCommand
| UnknownParsedCommand
]
):
root: (
ReadParsedCommand
| ListFilesParsedCommand
| SearchParsedCommand
| UnknownParsedCommand
)
class PatchApplyStatus(StrEnum):
in_progress = "inProgress"
completed = "completed"
failed = "failed"
declined = "declined"
class AddPatchChangeKindType(RootModel[Literal["add"]]):
root: Annotated[Literal["add"], Field(title="AddPatchChangeKindType")]
class AddPatchChangeKind(BaseModel):
type: Annotated[AddPatchChangeKindType, Field(title="AddPatchChangeKindType")]
class DeletePatchChangeKindType(RootModel[Literal["delete"]]):
root: Annotated[Literal["delete"], Field(title="DeletePatchChangeKindType")]
class DeletePatchChangeKind(BaseModel):
type: Annotated[DeletePatchChangeKindType, Field(title="DeletePatchChangeKindType")]
class UpdatePatchChangeKindType(RootModel[Literal["update"]]):
root: Annotated[Literal["update"], Field(title="UpdatePatchChangeKindType")]
class UpdatePatchChangeKind(BaseModel):
move_path: str | None = None
type: Annotated[UpdatePatchChangeKindType, Field(title="UpdatePatchChangeKindType")]
class PatchChangeKind(
RootModel[AddPatchChangeKind | DeletePatchChangeKind | UpdatePatchChangeKind]
):
root: AddPatchChangeKind | DeletePatchChangeKind | UpdatePatchChangeKind
class PermissionGrantScope(StrEnum):
turn = "turn"
session = "session"
class PermissionProfile(BaseModel):
file_system: FileSystemPermissions | None = None
macos: MacOsSeatbeltProfileExtensions | None = None
network: NetworkPermissions | None = None
class Personality(StrEnum):
none = "none"
friendly = "friendly"
pragmatic = "pragmatic"
class PlanDeltaNotification(BaseModel):
delta: str
item_id: Annotated[str, Field(alias="itemId")]
thread_id: Annotated[str, Field(alias="threadId")]
turn_id: Annotated[str, Field(alias="turnId")]
class PlanType(StrEnum):
free = "free"
go = "go"
plus = "plus"
pro = "pro"
team = "team"
business = "business"
enterprise = "enterprise"
edu = "edu"
unknown = "unknown"
class PluginInstallParams(BaseModel):
marketplace_path: Annotated[AbsolutePathBuf, Field(alias="marketplacePath")]
plugin_name: Annotated[str, Field(alias="pluginName")]
class PluginListParams(BaseModel):
cwds: Annotated[
list[AbsolutePathBuf] | None,
Field(
description="Optional working directories used to discover repo marketplaces. When omitted, only home-scoped marketplaces and the official curated marketplace are considered."
),
] = None
class PluginUninstallParams(BaseModel):
plugin_id: Annotated[str, Field(alias="pluginId")]
class ProductSurface(StrEnum):
chatgpt = "chatgpt"
codex = "codex"
api = "api"
atlas = "atlas"
class RateLimitWindow(BaseModel):
resets_at: Annotated[int | None, Field(alias="resetsAt")] = None
used_percent: Annotated[int, Field(alias="usedPercent")]
window_duration_mins: Annotated[int | None, Field(alias="windowDurationMins")] = (
None
)
class RestrictedReadOnlyAccessType(RootModel[Literal["restricted"]]):
root: Annotated[Literal["restricted"], Field(title="RestrictedReadOnlyAccessType")]
class RestrictedReadOnlyAccess(BaseModel):
include_platform_defaults: Annotated[
bool | None, Field(alias="includePlatformDefaults")
] = True
readable_roots: Annotated[
list[AbsolutePathBuf] | None, Field(default_factory=list, alias="readableRoots")
]
type: Annotated[
RestrictedReadOnlyAccessType, Field(title="RestrictedReadOnlyAccessType")
]
class FullAccessReadOnlyAccessType(RootModel[Literal["fullAccess"]]):
root: Annotated[Literal["fullAccess"], Field(title="FullAccessReadOnlyAccessType")]
class FullAccessReadOnlyAccess(BaseModel):
type: Annotated[
FullAccessReadOnlyAccessType, Field(title="FullAccessReadOnlyAccessType")
]
class ReadOnlyAccess(RootModel[RestrictedReadOnlyAccess | FullAccessReadOnlyAccess]):
root: RestrictedReadOnlyAccess | FullAccessReadOnlyAccess
class RealtimeAudioFrame(BaseModel):
data: str
num_channels: Annotated[int, Field(ge=0, le=65535)]
sample_rate: Annotated[int, Field(ge=0, le=4294967295)]
samples_per_channel: Annotated[int | None, Field(ge=0, le=4294967295)] = None
class SessionUpdated(BaseModel):
instructions: str | None = None
session_id: str
class SessionUpdatedRealtimeEvent(BaseModel):
model_config = ConfigDict(
extra="forbid",
)
session_updated: Annotated[SessionUpdated, Field(alias="SessionUpdated")]
class AudioOutRealtimeEvent(BaseModel):
model_config = ConfigDict(
extra="forbid",
)
audio_out: Annotated[RealtimeAudioFrame, Field(alias="AudioOut")]
class ConversationItemAddedRealtimeEvent(BaseModel):
model_config = ConfigDict(
extra="forbid",
)
conversation_item_added: Annotated[Any, Field(alias="ConversationItemAdded")]
class ConversationItemDone(BaseModel):
item_id: str
class ConversationItemDoneRealtimeEvent(BaseModel):
model_config = ConfigDict(
extra="forbid",
)
conversation_item_done: Annotated[
ConversationItemDone, Field(alias="ConversationItemDone")
]
class ErrorRealtimeEvent(BaseModel):
model_config = ConfigDict(
extra="forbid",
)
error: Annotated[str, Field(alias="Error")]
class RealtimeHandoffMessage(BaseModel):
role: str
text: str
class RealtimeHandoffRequested(BaseModel):
handoff_id: str
input_transcript: str
item_id: str
messages: list[RealtimeHandoffMessage]
class ReasoningEffort(StrEnum):
none = "none"
minimal = "minimal"
low = "low"
medium = "medium"
high = "high"
xhigh = "xhigh"
class ReasoningTextReasoningItemContentType(RootModel[Literal["reasoning_text"]]):
root: Annotated[
Literal["reasoning_text"], Field(title="ReasoningTextReasoningItemContentType")
]
class ReasoningTextReasoningItemContent(BaseModel):
text: str
type: Annotated[
ReasoningTextReasoningItemContentType,
Field(title="ReasoningTextReasoningItemContentType"),
]
class TextReasoningItemContentType(RootModel[Literal["text"]]):
root: Annotated[Literal["text"], Field(title="TextReasoningItemContentType")]
class TextReasoningItemContent(BaseModel):
text: str
type: Annotated[
TextReasoningItemContentType, Field(title="TextReasoningItemContentType")
]
class ReasoningItemContent(
RootModel[ReasoningTextReasoningItemContent | TextReasoningItemContent]
):
root: ReasoningTextReasoningItemContent | TextReasoningItemContent
class SummaryTextReasoningItemReasoningSummaryType(RootModel[Literal["summary_text"]]):
root: Annotated[
Literal["summary_text"],
Field(title="SummaryTextReasoningItemReasoningSummaryType"),
]
class SummaryTextReasoningItemReasoningSummary(BaseModel):
text: str
type: Annotated[
SummaryTextReasoningItemReasoningSummaryType,
Field(title="SummaryTextReasoningItemReasoningSummaryType"),
]
class ReasoningItemReasoningSummary(
RootModel[SummaryTextReasoningItemReasoningSummary]
):
root: SummaryTextReasoningItemReasoningSummary
class ReasoningSummary1(StrEnum):
auto = "auto"
concise = "concise"
detailed = "detailed"
class ReasoningSummary(RootModel[ReasoningSummary1 | Literal["none"]]):
root: Annotated[
ReasoningSummary1 | Literal["none"],
Field(
description="A summary of the reasoning performed by the model. This can be useful for debugging and understanding the model's reasoning process. See https://platform.openai.com/docs/guides/reasoning?api-mode=responses#reasoning-summaries"
),
]
class ReasoningSummaryPartAddedNotification(BaseModel):
item_id: Annotated[str, Field(alias="itemId")]
summary_index: Annotated[int, Field(alias="summaryIndex")]
thread_id: Annotated[str, Field(alias="threadId")]
turn_id: Annotated[str, Field(alias="turnId")]
class ReasoningSummaryTextDeltaNotification(BaseModel):
delta: str
item_id: Annotated[str, Field(alias="itemId")]
summary_index: Annotated[int, Field(alias="summaryIndex")]
thread_id: Annotated[str, Field(alias="threadId")]
turn_id: Annotated[str, Field(alias="turnId")]
class ReasoningTextDeltaNotification(BaseModel):
content_index: Annotated[int, Field(alias="contentIndex")]
delta: str
item_id: Annotated[str, Field(alias="itemId")]
thread_id: Annotated[str, Field(alias="threadId")]
turn_id: Annotated[str, Field(alias="turnId")]
class RejectConfig(BaseModel):
mcp_elicitations: Annotated[
bool, Field(description="Reject MCP elicitation prompts.")
]
request_permissions: Annotated[
bool,
Field(
description="Reject approval prompts related to built-in permission requests."
),
]
rules: Annotated[
bool,
Field(description="Reject prompts triggered by execpolicy `prompt` rules."),
]
sandbox_approval: Annotated[
bool,
Field(description="Reject approval prompts related to sandbox escalation."),
]
class RemoteSkillSummary(BaseModel):
description: str
id: str
name: str
class RequestId(RootModel[str | int]):
root: Annotated[str | int, Field(title="RequestId")]
class RequestUserInputQuestionOption(BaseModel):
description: str
label: str
class Resource(BaseModel):
field_meta: Annotated[Any | None, Field(alias="_meta")] = None
annotations: Any | None = None
description: str | None = None
icons: list[Any] | None = None
mime_type: Annotated[str | None, Field(alias="mimeType")] = None
name: str
size: int | None = None
title: str | None = None
uri: str
class ResourceTemplate(BaseModel):
annotations: Any | None = None
description: str | None = None
mime_type: Annotated[str | None, Field(alias="mimeType")] = None
name: str
title: str | None = None
uri_template: Annotated[str, Field(alias="uriTemplate")]
class MessageResponseItemType(RootModel[Literal["message"]]):
root: Annotated[Literal["message"], Field(title="MessageResponseItemType")]
class MessageResponseItem(BaseModel):
content: list[ContentItem]
end_turn: bool | None = None
id: str | None = None
phase: MessagePhase | None = None
role: str
type: Annotated[MessageResponseItemType, Field(title="MessageResponseItemType")]
class ReasoningResponseItemType(RootModel[Literal["reasoning"]]):
root: Annotated[Literal["reasoning"], Field(title="ReasoningResponseItemType")]
class ReasoningResponseItem(BaseModel):
content: list[ReasoningItemContent] | None = None
encrypted_content: str | None = None
id: str
summary: list[ReasoningItemReasoningSummary]
type: Annotated[ReasoningResponseItemType, Field(title="ReasoningResponseItemType")]
class LocalShellCallResponseItemType(RootModel[Literal["local_shell_call"]]):
root: Annotated[
Literal["local_shell_call"], Field(title="LocalShellCallResponseItemType")
]
class LocalShellCallResponseItem(BaseModel):
action: LocalShellAction
call_id: Annotated[
str | None, Field(description="Set when using the Responses API.")
] = None
id: Annotated[
str | None,
Field(
description="Legacy id field retained for compatibility with older payloads."
),
] = None
status: LocalShellStatus
type: Annotated[
LocalShellCallResponseItemType, Field(title="LocalShellCallResponseItemType")
]
class FunctionCallResponseItemType(RootModel[Literal["function_call"]]):
root: Annotated[
Literal["function_call"], Field(title="FunctionCallResponseItemType")
]
class FunctionCallResponseItem(BaseModel):
arguments: str
call_id: str
id: str | None = None
name: str
type: Annotated[
FunctionCallResponseItemType, Field(title="FunctionCallResponseItemType")
]
class FunctionCallOutputResponseItemType(RootModel[Literal["function_call_output"]]):
root: Annotated[
Literal["function_call_output"],
Field(title="FunctionCallOutputResponseItemType"),
]
class CustomToolCallResponseItemType(RootModel[Literal["custom_tool_call"]]):
root: Annotated[
Literal["custom_tool_call"], Field(title="CustomToolCallResponseItemType")
]
class CustomToolCallResponseItem(BaseModel):
call_id: str
id: str | None = None
input: str
name: str
status: str | None = None
type: Annotated[
CustomToolCallResponseItemType, Field(title="CustomToolCallResponseItemType")
]
class CustomToolCallOutputResponseItemType(
RootModel[Literal["custom_tool_call_output"]]
):
root: Annotated[
Literal["custom_tool_call_output"],
Field(title="CustomToolCallOutputResponseItemType"),
]
class WebSearchCallResponseItemType(RootModel[Literal["web_search_call"]]):
root: Annotated[
Literal["web_search_call"], Field(title="WebSearchCallResponseItemType")
]
class ImageGenerationCallResponseItemType(RootModel[Literal["image_generation_call"]]):
root: Annotated[
Literal["image_generation_call"],
Field(title="ImageGenerationCallResponseItemType"),
]
class ImageGenerationCallResponseItem(BaseModel):
id: str
result: str
revised_prompt: str | None = None
status: str
type: Annotated[
ImageGenerationCallResponseItemType,
Field(title="ImageGenerationCallResponseItemType"),
]
class GhostSnapshotResponseItemType(RootModel[Literal["ghost_snapshot"]]):
root: Annotated[
Literal["ghost_snapshot"], Field(title="GhostSnapshotResponseItemType")
]
class GhostSnapshotResponseItem(BaseModel):
ghost_commit: GhostCommit
type: Annotated[
GhostSnapshotResponseItemType, Field(title="GhostSnapshotResponseItemType")
]
class CompactionResponseItemType(RootModel[Literal["compaction"]]):
root: Annotated[Literal["compaction"], Field(title="CompactionResponseItemType")]
class CompactionResponseItem(BaseModel):
encrypted_content: str
type: Annotated[
CompactionResponseItemType, Field(title="CompactionResponseItemType")
]
class OtherResponseItemType(RootModel[Literal["other"]]):
root: Annotated[Literal["other"], Field(title="OtherResponseItemType")]
class OtherResponseItem(BaseModel):
type: Annotated[OtherResponseItemType, Field(title="OtherResponseItemType")]
class SearchResponsesApiWebSearchActionType(RootModel[Literal["search"]]):
root: Annotated[
Literal["search"], Field(title="SearchResponsesApiWebSearchActionType")
]
class SearchResponsesApiWebSearchAction(BaseModel):
queries: list[str] | None = None
query: str | None = None
type: Annotated[
SearchResponsesApiWebSearchActionType,
Field(title="SearchResponsesApiWebSearchActionType"),
]
class OpenPageResponsesApiWebSearchActionType(RootModel[Literal["open_page"]]):
root: Annotated[
Literal["open_page"], Field(title="OpenPageResponsesApiWebSearchActionType")
]
class OpenPageResponsesApiWebSearchAction(BaseModel):
type: Annotated[
OpenPageResponsesApiWebSearchActionType,
Field(title="OpenPageResponsesApiWebSearchActionType"),
]
url: str | None = None
class FindInPageResponsesApiWebSearchActionType(RootModel[Literal["find_in_page"]]):
root: Annotated[
Literal["find_in_page"],
Field(title="FindInPageResponsesApiWebSearchActionType"),
]
class FindInPageResponsesApiWebSearchAction(BaseModel):
pattern: str | None = None
type: Annotated[
FindInPageResponsesApiWebSearchActionType,
Field(title="FindInPageResponsesApiWebSearchActionType"),
]
url: str | None = None
class OtherResponsesApiWebSearchActionType(RootModel[Literal["other"]]):
root: Annotated[
Literal["other"], Field(title="OtherResponsesApiWebSearchActionType")
]
class OtherResponsesApiWebSearchAction(BaseModel):
type: Annotated[
OtherResponsesApiWebSearchActionType,
Field(title="OtherResponsesApiWebSearchActionType"),
]
class ResponsesApiWebSearchAction(
RootModel[
SearchResponsesApiWebSearchAction
| OpenPageResponsesApiWebSearchAction
| FindInPageResponsesApiWebSearchAction
| OtherResponsesApiWebSearchAction
]
):
root: (
SearchResponsesApiWebSearchAction
| OpenPageResponsesApiWebSearchAction
| FindInPageResponsesApiWebSearchAction
| OtherResponsesApiWebSearchAction
)
class OkResultOfCallToolResultOrString(BaseModel):
ok: Annotated[CallToolResult, Field(alias="Ok")]
class ErrResultOfCallToolResultOrString(BaseModel):
err: Annotated[str, Field(alias="Err")]
class ResultOfCallToolResultOrString(
RootModel[OkResultOfCallToolResultOrString | ErrResultOfCallToolResultOrString]
):
root: OkResultOfCallToolResultOrString | ErrResultOfCallToolResultOrString
class ApprovedExecpolicyAmendment(BaseModel):
proposed_execpolicy_amendment: list[str]
class ApprovedExecpolicyAmendmentReviewDecision(BaseModel):
model_config = ConfigDict(
extra="forbid",
)
approved_execpolicy_amendment: ApprovedExecpolicyAmendment
class ReviewDelivery(StrEnum):
inline = "inline"
detached = "detached"
class ReviewLineRange(BaseModel):
end: Annotated[int, Field(ge=0, le=4294967295)]
start: Annotated[int, Field(ge=0, le=4294967295)]
class UncommittedChangesReviewTargetType(RootModel[Literal["uncommittedChanges"]]):
root: Annotated[
Literal["uncommittedChanges"], Field(title="UncommittedChangesReviewTargetType")
]
class UncommittedChangesReviewTarget(BaseModel):
type: Annotated[
UncommittedChangesReviewTargetType,
Field(title="UncommittedChangesReviewTargetType"),
]
class BaseBranchReviewTargetType(RootModel[Literal["baseBranch"]]):
root: Annotated[Literal["baseBranch"], Field(title="BaseBranchReviewTargetType")]
class BaseBranchReviewTarget(BaseModel):
branch: str
type: Annotated[
BaseBranchReviewTargetType, Field(title="BaseBranchReviewTargetType")
]
class CommitReviewTargetType(RootModel[Literal["commit"]]):
root: Annotated[Literal["commit"], Field(title="CommitReviewTargetType")]
class CommitReviewTarget(BaseModel):
sha: str
title: Annotated[
str | None,
Field(
description="Optional human-readable label (e.g., commit subject) for UIs."
),
] = None
type: Annotated[CommitReviewTargetType, Field(title="CommitReviewTargetType")]
class CustomReviewTargetType(RootModel[Literal["custom"]]):
root: Annotated[Literal["custom"], Field(title="CustomReviewTargetType")]
class CustomReviewTarget(BaseModel):
instructions: str
type: Annotated[CustomReviewTargetType, Field(title="CustomReviewTargetType")]
class ReviewTarget(
RootModel[
UncommittedChangesReviewTarget
| BaseBranchReviewTarget
| CommitReviewTarget
| CustomReviewTarget
]
):
root: (
UncommittedChangesReviewTarget
| BaseBranchReviewTarget
| CommitReviewTarget
| CustomReviewTarget
)
class SandboxMode(StrEnum):
read_only = "read-only"
workspace_write = "workspace-write"
danger_full_access = "danger-full-access"
class DangerFullAccessSandboxPolicyType(RootModel[Literal["dangerFullAccess"]]):
root: Annotated[
Literal["dangerFullAccess"], Field(title="DangerFullAccessSandboxPolicyType")
]
class DangerFullAccessSandboxPolicy(BaseModel):
type: Annotated[
DangerFullAccessSandboxPolicyType,
Field(title="DangerFullAccessSandboxPolicyType"),
]
class ReadOnlySandboxPolicyType(RootModel[Literal["readOnly"]]):
root: Annotated[Literal["readOnly"], Field(title="ReadOnlySandboxPolicyType")]
class ReadOnlySandboxPolicy(BaseModel):
access: Annotated[
ReadOnlyAccess | None,
Field(default_factory=lambda: ReadOnlyAccess({"type": "fullAccess"})),
]
network_access: Annotated[bool | None, Field(alias="networkAccess")] = False
type: Annotated[ReadOnlySandboxPolicyType, Field(title="ReadOnlySandboxPolicyType")]
class ExternalSandboxSandboxPolicyType(RootModel[Literal["externalSandbox"]]):
root: Annotated[
Literal["externalSandbox"], Field(title="ExternalSandboxSandboxPolicyType")
]
class ExternalSandboxSandboxPolicy(BaseModel):
network_access: Annotated[NetworkAccess | None, Field(alias="networkAccess")] = (
"restricted"
)
type: Annotated[
ExternalSandboxSandboxPolicyType,
Field(title="ExternalSandboxSandboxPolicyType"),
]
class WorkspaceWriteSandboxPolicyType(RootModel[Literal["workspaceWrite"]]):
root: Annotated[
Literal["workspaceWrite"], Field(title="WorkspaceWriteSandboxPolicyType")
]
class WorkspaceWriteSandboxPolicy(BaseModel):
exclude_slash_tmp: Annotated[bool | None, Field(alias="excludeSlashTmp")] = False
exclude_tmpdir_env_var: Annotated[
bool | None, Field(alias="excludeTmpdirEnvVar")
] = False
network_access: Annotated[bool | None, Field(alias="networkAccess")] = False
read_only_access: Annotated[
ReadOnlyAccess | None,
Field(
default_factory=lambda: ReadOnlyAccess({"type": "fullAccess"}),
alias="readOnlyAccess",
),
]
type: Annotated[
WorkspaceWriteSandboxPolicyType, Field(title="WorkspaceWriteSandboxPolicyType")
]
writable_roots: Annotated[
list[AbsolutePathBuf] | None, Field(default_factory=list, alias="writableRoots")
]
class SandboxPolicy(
RootModel[
DangerFullAccessSandboxPolicy
| ReadOnlySandboxPolicy
| ExternalSandboxSandboxPolicy
| WorkspaceWriteSandboxPolicy
]
):
root: (
DangerFullAccessSandboxPolicy
| ReadOnlySandboxPolicy
| ExternalSandboxSandboxPolicy
| WorkspaceWriteSandboxPolicy
)
class ErrorServerNotificationMethod(RootModel[Literal["error"]]):
root: Annotated[Literal["error"], Field(title="ErrorServerNotificationMethod")]
class ThreadStartedServerNotificationMethod(RootModel[Literal["thread/started"]]):
root: Annotated[
Literal["thread/started"], Field(title="Thread/startedServerNotificationMethod")
]
class ThreadStatusChangedServerNotificationMethod(
RootModel[Literal["thread/status/changed"]]
):
root: Annotated[
Literal["thread/status/changed"],
Field(title="Thread/status/changedServerNotificationMethod"),
]
class ThreadArchivedServerNotificationMethod(RootModel[Literal["thread/archived"]]):
root: Annotated[
Literal["thread/archived"],
Field(title="Thread/archivedServerNotificationMethod"),
]
class ThreadUnarchivedServerNotificationMethod(RootModel[Literal["thread/unarchived"]]):
root: Annotated[
Literal["thread/unarchived"],
Field(title="Thread/unarchivedServerNotificationMethod"),
]
class ThreadClosedServerNotificationMethod(RootModel[Literal["thread/closed"]]):
root: Annotated[
Literal["thread/closed"], Field(title="Thread/closedServerNotificationMethod")
]
class SkillsChangedServerNotificationMethod(RootModel[Literal["skills/changed"]]):
root: Annotated[
Literal["skills/changed"], Field(title="Skills/changedServerNotificationMethod")
]
class ThreadNameUpdatedServerNotificationMethod(
RootModel[Literal["thread/name/updated"]]
):
root: Annotated[
Literal["thread/name/updated"],
Field(title="Thread/name/updatedServerNotificationMethod"),
]
class ThreadTokenUsageUpdatedServerNotificationMethod(
RootModel[Literal["thread/tokenUsage/updated"]]
):
root: Annotated[
Literal["thread/tokenUsage/updated"],
Field(title="Thread/tokenUsage/updatedServerNotificationMethod"),
]
class TurnStartedServerNotificationMethod(RootModel[Literal["turn/started"]]):
root: Annotated[
Literal["turn/started"], Field(title="Turn/startedServerNotificationMethod")
]
class TurnCompletedServerNotificationMethod(RootModel[Literal["turn/completed"]]):
root: Annotated[
Literal["turn/completed"], Field(title="Turn/completedServerNotificationMethod")
]
class TurnDiffUpdatedServerNotificationMethod(RootModel[Literal["turn/diff/updated"]]):
root: Annotated[
Literal["turn/diff/updated"],
Field(title="Turn/diff/updatedServerNotificationMethod"),
]
class TurnPlanUpdatedServerNotificationMethod(RootModel[Literal["turn/plan/updated"]]):
root: Annotated[
Literal["turn/plan/updated"],
Field(title="Turn/plan/updatedServerNotificationMethod"),
]
class ItemStartedServerNotificationMethod(RootModel[Literal["item/started"]]):
root: Annotated[
Literal["item/started"], Field(title="Item/startedServerNotificationMethod")
]
class ItemCompletedServerNotificationMethod(RootModel[Literal["item/completed"]]):
root: Annotated[
Literal["item/completed"], Field(title="Item/completedServerNotificationMethod")
]
class ItemAgentMessageDeltaServerNotificationMethod(
RootModel[Literal["item/agentMessage/delta"]]
):
root: Annotated[
Literal["item/agentMessage/delta"],
Field(title="Item/agentMessage/deltaServerNotificationMethod"),
]
class ItemAgentMessageDeltaServerNotification(BaseModel):
method: Annotated[
ItemAgentMessageDeltaServerNotificationMethod,
Field(title="Item/agentMessage/deltaServerNotificationMethod"),
]
params: AgentMessageDeltaNotification
class ItemPlanDeltaServerNotificationMethod(RootModel[Literal["item/plan/delta"]]):
root: Annotated[
Literal["item/plan/delta"],
Field(title="Item/plan/deltaServerNotificationMethod"),
]
class ItemPlanDeltaServerNotification(BaseModel):
method: Annotated[
ItemPlanDeltaServerNotificationMethod,
Field(title="Item/plan/deltaServerNotificationMethod"),
]
params: PlanDeltaNotification
class CommandExecOutputDeltaServerNotificationMethod(
RootModel[Literal["command/exec/outputDelta"]]
):
root: Annotated[
Literal["command/exec/outputDelta"],
Field(title="Command/exec/outputDeltaServerNotificationMethod"),
]
class ItemCommandExecutionOutputDeltaServerNotificationMethod(
RootModel[Literal["item/commandExecution/outputDelta"]]
):
root: Annotated[
Literal["item/commandExecution/outputDelta"],
Field(title="Item/commandExecution/outputDeltaServerNotificationMethod"),
]
class ItemCommandExecutionOutputDeltaServerNotification(BaseModel):
method: Annotated[
ItemCommandExecutionOutputDeltaServerNotificationMethod,
Field(title="Item/commandExecution/outputDeltaServerNotificationMethod"),
]
params: CommandExecutionOutputDeltaNotification
class ItemCommandExecutionTerminalInteractionServerNotificationMethod(
RootModel[Literal["item/commandExecution/terminalInteraction"]]
):
root: Annotated[
Literal["item/commandExecution/terminalInteraction"],
Field(
title="Item/commandExecution/terminalInteractionServerNotificationMethod"
),
]
class ItemFileChangeOutputDeltaServerNotificationMethod(
RootModel[Literal["item/fileChange/outputDelta"]]
):
root: Annotated[
Literal["item/fileChange/outputDelta"],
Field(title="Item/fileChange/outputDeltaServerNotificationMethod"),
]
class ItemFileChangeOutputDeltaServerNotification(BaseModel):
method: Annotated[
ItemFileChangeOutputDeltaServerNotificationMethod,
Field(title="Item/fileChange/outputDeltaServerNotificationMethod"),
]
params: FileChangeOutputDeltaNotification
class ServerRequestResolvedServerNotificationMethod(
RootModel[Literal["serverRequest/resolved"]]
):
root: Annotated[
Literal["serverRequest/resolved"],
Field(title="ServerRequest/resolvedServerNotificationMethod"),
]
class ItemMcpToolCallProgressServerNotificationMethod(
RootModel[Literal["item/mcpToolCall/progress"]]
):
root: Annotated[
Literal["item/mcpToolCall/progress"],
Field(title="Item/mcpToolCall/progressServerNotificationMethod"),
]
class ItemMcpToolCallProgressServerNotification(BaseModel):
method: Annotated[
ItemMcpToolCallProgressServerNotificationMethod,
Field(title="Item/mcpToolCall/progressServerNotificationMethod"),
]
params: McpToolCallProgressNotification
class McpServerOauthLoginCompletedServerNotificationMethod(
RootModel[Literal["mcpServer/oauthLogin/completed"]]
):
root: Annotated[
Literal["mcpServer/oauthLogin/completed"],
Field(title="McpServer/oauthLogin/completedServerNotificationMethod"),
]
class McpServerOauthLoginCompletedServerNotification(BaseModel):
method: Annotated[
McpServerOauthLoginCompletedServerNotificationMethod,
Field(title="McpServer/oauthLogin/completedServerNotificationMethod"),
]
params: McpServerOauthLoginCompletedNotification
class AccountUpdatedServerNotificationMethod(RootModel[Literal["account/updated"]]):
root: Annotated[
Literal["account/updated"],
Field(title="Account/updatedServerNotificationMethod"),
]
class AccountRateLimitsUpdatedServerNotificationMethod(
RootModel[Literal["account/rateLimits/updated"]]
):
root: Annotated[
Literal["account/rateLimits/updated"],
Field(title="Account/rateLimits/updatedServerNotificationMethod"),
]
class AppListUpdatedServerNotificationMethod(RootModel[Literal["app/list/updated"]]):
root: Annotated[
Literal["app/list/updated"],
Field(title="App/list/updatedServerNotificationMethod"),
]
class ItemReasoningSummaryTextDeltaServerNotificationMethod(
RootModel[Literal["item/reasoning/summaryTextDelta"]]
):
root: Annotated[
Literal["item/reasoning/summaryTextDelta"],
Field(title="Item/reasoning/summaryTextDeltaServerNotificationMethod"),
]
class ItemReasoningSummaryTextDeltaServerNotification(BaseModel):
method: Annotated[
ItemReasoningSummaryTextDeltaServerNotificationMethod,
Field(title="Item/reasoning/summaryTextDeltaServerNotificationMethod"),
]
params: ReasoningSummaryTextDeltaNotification
class ItemReasoningSummaryPartAddedServerNotificationMethod(
RootModel[Literal["item/reasoning/summaryPartAdded"]]
):
root: Annotated[
Literal["item/reasoning/summaryPartAdded"],
Field(title="Item/reasoning/summaryPartAddedServerNotificationMethod"),
]
class ItemReasoningSummaryPartAddedServerNotification(BaseModel):
method: Annotated[
ItemReasoningSummaryPartAddedServerNotificationMethod,
Field(title="Item/reasoning/summaryPartAddedServerNotificationMethod"),
]
params: ReasoningSummaryPartAddedNotification
class ItemReasoningTextDeltaServerNotificationMethod(
RootModel[Literal["item/reasoning/textDelta"]]
):
root: Annotated[
Literal["item/reasoning/textDelta"],
Field(title="Item/reasoning/textDeltaServerNotificationMethod"),
]
class ItemReasoningTextDeltaServerNotification(BaseModel):
method: Annotated[
ItemReasoningTextDeltaServerNotificationMethod,
Field(title="Item/reasoning/textDeltaServerNotificationMethod"),
]
params: ReasoningTextDeltaNotification
class ThreadCompactedServerNotificationMethod(RootModel[Literal["thread/compacted"]]):
root: Annotated[
Literal["thread/compacted"],
Field(title="Thread/compactedServerNotificationMethod"),
]
class ThreadCompactedServerNotification(BaseModel):
method: Annotated[
ThreadCompactedServerNotificationMethod,
Field(title="Thread/compactedServerNotificationMethod"),
]
params: ContextCompactedNotification
class ModelReroutedServerNotificationMethod(RootModel[Literal["model/rerouted"]]):
root: Annotated[
Literal["model/rerouted"], Field(title="Model/reroutedServerNotificationMethod")
]
class ModelReroutedServerNotification(BaseModel):
method: Annotated[
ModelReroutedServerNotificationMethod,
Field(title="Model/reroutedServerNotificationMethod"),
]
params: ModelReroutedNotification
class DeprecationNoticeServerNotificationMethod(
RootModel[Literal["deprecationNotice"]]
):
root: Annotated[
Literal["deprecationNotice"],
Field(title="DeprecationNoticeServerNotificationMethod"),
]
class DeprecationNoticeServerNotification(BaseModel):
method: Annotated[
DeprecationNoticeServerNotificationMethod,
Field(title="DeprecationNoticeServerNotificationMethod"),
]
params: DeprecationNoticeNotification
class ConfigWarningServerNotificationMethod(RootModel[Literal["configWarning"]]):
root: Annotated[
Literal["configWarning"], Field(title="ConfigWarningServerNotificationMethod")
]
class FuzzyFileSearchSessionUpdatedServerNotificationMethod(
RootModel[Literal["fuzzyFileSearch/sessionUpdated"]]
):
root: Annotated[
Literal["fuzzyFileSearch/sessionUpdated"],
Field(title="FuzzyFileSearch/sessionUpdatedServerNotificationMethod"),
]
class FuzzyFileSearchSessionUpdatedServerNotification(BaseModel):
method: Annotated[
FuzzyFileSearchSessionUpdatedServerNotificationMethod,
Field(title="FuzzyFileSearch/sessionUpdatedServerNotificationMethod"),
]
params: FuzzyFileSearchSessionUpdatedNotification
class FuzzyFileSearchSessionCompletedServerNotificationMethod(
RootModel[Literal["fuzzyFileSearch/sessionCompleted"]]
):
root: Annotated[
Literal["fuzzyFileSearch/sessionCompleted"],
Field(title="FuzzyFileSearch/sessionCompletedServerNotificationMethod"),
]
class FuzzyFileSearchSessionCompletedServerNotification(BaseModel):
method: Annotated[
FuzzyFileSearchSessionCompletedServerNotificationMethod,
Field(title="FuzzyFileSearch/sessionCompletedServerNotificationMethod"),
]
params: FuzzyFileSearchSessionCompletedNotification
class ThreadRealtimeStartedServerNotificationMethod(
RootModel[Literal["thread/realtime/started"]]
):
root: Annotated[
Literal["thread/realtime/started"],
Field(title="Thread/realtime/startedServerNotificationMethod"),
]
class ThreadRealtimeItemAddedServerNotificationMethod(
RootModel[Literal["thread/realtime/itemAdded"]]
):
root: Annotated[
Literal["thread/realtime/itemAdded"],
Field(title="Thread/realtime/itemAddedServerNotificationMethod"),
]
class ThreadRealtimeOutputAudioDeltaServerNotificationMethod(
RootModel[Literal["thread/realtime/outputAudio/delta"]]
):
root: Annotated[
Literal["thread/realtime/outputAudio/delta"],
Field(title="Thread/realtime/outputAudio/deltaServerNotificationMethod"),
]
class ThreadRealtimeErrorServerNotificationMethod(
RootModel[Literal["thread/realtime/error"]]
):
root: Annotated[
Literal["thread/realtime/error"],
Field(title="Thread/realtime/errorServerNotificationMethod"),
]
class ThreadRealtimeClosedServerNotificationMethod(
RootModel[Literal["thread/realtime/closed"]]
):
root: Annotated[
Literal["thread/realtime/closed"],
Field(title="Thread/realtime/closedServerNotificationMethod"),
]
class WindowsWorldWritableWarningServerNotificationMethod(
RootModel[Literal["windows/worldWritableWarning"]]
):
root: Annotated[
Literal["windows/worldWritableWarning"],
Field(title="Windows/worldWritableWarningServerNotificationMethod"),
]
class WindowsSandboxSetupCompletedServerNotificationMethod(
RootModel[Literal["windowsSandbox/setupCompleted"]]
):
root: Annotated[
Literal["windowsSandbox/setupCompleted"],
Field(title="WindowsSandbox/setupCompletedServerNotificationMethod"),
]
class AccountLoginCompletedServerNotificationMethod(
RootModel[Literal["account/login/completed"]]
):
root: Annotated[
Literal["account/login/completed"],
Field(title="Account/login/completedServerNotificationMethod"),
]
class AccountLoginCompletedServerNotification(BaseModel):
method: Annotated[
AccountLoginCompletedServerNotificationMethod,
Field(title="Account/login/completedServerNotificationMethod"),
]
params: AccountLoginCompletedNotification
class ItemCommandExecutionRequestApprovalServerRequestMethod(
RootModel[Literal["item/commandExecution/requestApproval"]]
):
root: Annotated[
Literal["item/commandExecution/requestApproval"],
Field(title="Item/commandExecution/requestApprovalServerRequestMethod"),
]
class ItemFileChangeRequestApprovalServerRequestMethod(
RootModel[Literal["item/fileChange/requestApproval"]]
):
root: Annotated[
Literal["item/fileChange/requestApproval"],
Field(title="Item/fileChange/requestApprovalServerRequestMethod"),
]
class ItemFileChangeRequestApprovalServerRequest(BaseModel):
id: RequestId
method: Annotated[
ItemFileChangeRequestApprovalServerRequestMethod,
Field(title="Item/fileChange/requestApprovalServerRequestMethod"),
]
params: FileChangeRequestApprovalParams
class ItemToolRequestUserInputServerRequestMethod(
RootModel[Literal["item/tool/requestUserInput"]]
):
root: Annotated[
Literal["item/tool/requestUserInput"],
Field(title="Item/tool/requestUserInputServerRequestMethod"),
]
class McpServerElicitationRequestServerRequestMethod(
RootModel[Literal["mcpServer/elicitation/request"]]
):
root: Annotated[
Literal["mcpServer/elicitation/request"],
Field(title="McpServer/elicitation/requestServerRequestMethod"),
]
class ItemPermissionsRequestApprovalServerRequestMethod(
RootModel[Literal["item/permissions/requestApproval"]]
):
root: Annotated[
Literal["item/permissions/requestApproval"],
Field(title="Item/permissions/requestApprovalServerRequestMethod"),
]
class ItemToolCallServerRequestMethod(RootModel[Literal["item/tool/call"]]):
root: Annotated[
Literal["item/tool/call"], Field(title="Item/tool/callServerRequestMethod")
]
class ItemToolCallServerRequest(BaseModel):
id: RequestId
method: Annotated[
ItemToolCallServerRequestMethod,
Field(title="Item/tool/callServerRequestMethod"),
]
params: DynamicToolCallParams
class AccountChatgptAuthTokensRefreshServerRequestMethod(
RootModel[Literal["account/chatgptAuthTokens/refresh"]]
):
root: Annotated[
Literal["account/chatgptAuthTokens/refresh"],
Field(title="Account/chatgptAuthTokens/refreshServerRequestMethod"),
]
class ApplyPatchApprovalServerRequestMethod(RootModel[Literal["applyPatchApproval"]]):
root: Annotated[
Literal["applyPatchApproval"],
Field(title="ApplyPatchApprovalServerRequestMethod"),
]
class ExecCommandApprovalServerRequestMethod(RootModel[Literal["execCommandApproval"]]):
root: Annotated[
Literal["execCommandApproval"],
Field(title="ExecCommandApprovalServerRequestMethod"),
]
class ServerRequestResolvedNotification(BaseModel):
request_id: Annotated[RequestId, Field(alias="requestId")]
thread_id: Annotated[str, Field(alias="threadId")]
class ServiceTier(StrEnum):
fast = "fast"
flex = "flex"
class SessionNetworkProxyRuntime(BaseModel):
http_addr: str
socks_addr: str
class SessionSource1(StrEnum):
cli = "cli"
vscode = "vscode"
exec = "exec"
app_server = "appServer"
unknown = "unknown"
class SkillErrorInfo(BaseModel):
message: str
path: str
class SkillInterface(BaseModel):
brand_color: Annotated[str | None, Field(alias="brandColor")] = None
default_prompt: Annotated[str | None, Field(alias="defaultPrompt")] = None
display_name: Annotated[str | None, Field(alias="displayName")] = None
icon_large: Annotated[str | None, Field(alias="iconLarge")] = None
icon_small: Annotated[str | None, Field(alias="iconSmall")] = None
short_description: Annotated[str | None, Field(alias="shortDescription")] = None
class SkillScope(StrEnum):
user = "user"
repo = "repo"
system = "system"
admin = "admin"
class SkillToolDependency(BaseModel):
command: str | None = None
description: str | None = None
transport: str | None = None
type: str
url: str | None = None
value: str
class SkillsChangedNotification(BaseModel):
pass
class SkillsConfigWriteParams(BaseModel):
enabled: bool
path: str
class SkillsListExtraRootsForCwd(BaseModel):
cwd: str
extra_user_roots: Annotated[list[str], Field(alias="extraUserRoots")]
class SkillsListParams(BaseModel):
cwds: Annotated[
list[str] | None,
Field(
description="When empty, defaults to the current session working directory."
),
] = None
force_reload: Annotated[
bool | None,
Field(
alias="forceReload",
description="When true, bypass the skills cache and re-scan skills from disk.",
),
] = None
per_cwd_extra_user_roots: Annotated[
list[SkillsListExtraRootsForCwd] | None,
Field(
alias="perCwdExtraUserRoots",
description="Optional per-cwd extra roots to scan as user-scoped skills.",
),
] = None
class SkillsRemoteReadParams(BaseModel):
enabled: bool | None = False
hazelnut_scope: Annotated[HazelnutScope | None, Field(alias="hazelnutScope")] = (
"example"
)
product_surface: Annotated[ProductSurface | None, Field(alias="productSurface")] = (
"codex"
)
class SkillsRemoteWriteParams(BaseModel):
hazelnut_id: Annotated[str, Field(alias="hazelnutId")]
class StepStatus(StrEnum):
pending = "pending"
in_progress = "in_progress"
completed = "completed"
class SubAgentSource1(StrEnum):
review = "review"
compact = "compact"
memory_consolidation = "memory_consolidation"
class OtherSubAgentSource(BaseModel):
model_config = ConfigDict(
extra="forbid",
)
other: str
class TerminalInteractionNotification(BaseModel):
item_id: Annotated[str, Field(alias="itemId")]
process_id: Annotated[str, Field(alias="processId")]
stdin: str
thread_id: Annotated[str, Field(alias="threadId")]
turn_id: Annotated[str, Field(alias="turnId")]
class TextElement(BaseModel):
byte_range: Annotated[
ByteRange,
Field(
alias="byteRange",
description="Byte range in the parent `text` buffer that this element occupies.",
),
]
placeholder: Annotated[
str | None,
Field(
description="Optional human-readable placeholder for the element, displayed in the UI."
),
] = None
class TextPosition(BaseModel):
column: Annotated[
int,
Field(description="1-based column number (in Unicode scalar values).", ge=0),
]
line: Annotated[int, Field(description="1-based line number.", ge=0)]
class TextRange(BaseModel):
end: TextPosition
start: TextPosition
class ThreadActiveFlag(StrEnum):
waiting_on_approval = "waitingOnApproval"
waiting_on_user_input = "waitingOnUserInput"
class ThreadArchiveParams(BaseModel):
thread_id: Annotated[str, Field(alias="threadId")]
class ThreadArchivedNotification(BaseModel):
thread_id: Annotated[str, Field(alias="threadId")]
class ThreadClosedNotification(BaseModel):
thread_id: Annotated[str, Field(alias="threadId")]
class ThreadCompactStartParams(BaseModel):
thread_id: Annotated[str, Field(alias="threadId")]
class ThreadForkParams(BaseModel):
approval_policy: Annotated[AskForApproval | None, Field(alias="approvalPolicy")] = (
None
)
base_instructions: Annotated[str | None, Field(alias="baseInstructions")] = None
config: dict[str, Any] | None = None
cwd: str | None = None
developer_instructions: Annotated[
str | None, Field(alias="developerInstructions")
] = None
model: Annotated[
str | None,
Field(description="Configuration overrides for the forked thread, if any."),
] = None
model_provider: Annotated[str | None, Field(alias="modelProvider")] = None
sandbox: SandboxMode | None = None
service_tier: Annotated[ServiceTier | None, Field(alias="serviceTier")] = None
thread_id: Annotated[str, Field(alias="threadId")]
class ThreadId(RootModel[str]):
root: str
class UserMessageThreadItemType(RootModel[Literal["userMessage"]]):
root: Annotated[Literal["userMessage"], Field(title="UserMessageThreadItemType")]
class AgentMessageThreadItemType(RootModel[Literal["agentMessage"]]):
root: Annotated[Literal["agentMessage"], Field(title="AgentMessageThreadItemType")]
class AgentMessageThreadItem(BaseModel):
id: str
phase: MessagePhase | None = None
text: str
type: Annotated[
AgentMessageThreadItemType, Field(title="AgentMessageThreadItemType")
]
class PlanThreadItemType(RootModel[Literal["plan"]]):
root: Annotated[Literal["plan"], Field(title="PlanThreadItemType")]
class PlanThreadItem(BaseModel):
id: str
text: str
type: Annotated[PlanThreadItemType, Field(title="PlanThreadItemType")]
class ReasoningThreadItemType(RootModel[Literal["reasoning"]]):
root: Annotated[Literal["reasoning"], Field(title="ReasoningThreadItemType")]
class ReasoningThreadItem(BaseModel):
content: list[str] | None = []
id: str
summary: list[str] | None = []
type: Annotated[ReasoningThreadItemType, Field(title="ReasoningThreadItemType")]
class CommandExecutionThreadItemType(RootModel[Literal["commandExecution"]]):
root: Annotated[
Literal["commandExecution"], Field(title="CommandExecutionThreadItemType")
]
class CommandExecutionThreadItem(BaseModel):
aggregated_output: Annotated[
str | None,
Field(
alias="aggregatedOutput",
description="The command's output, aggregated from stdout and stderr.",
),
] = None
command: Annotated[str, Field(description="The command to be executed.")]
command_actions: Annotated[
list[CommandAction],
Field(
alias="commandActions",
description="A best-effort parsing of the command to understand the action(s) it will perform. This returns a list of CommandAction objects because a single shell command may be composed of many commands piped together.",
),
]
cwd: Annotated[str, Field(description="The command's working directory.")]
duration_ms: Annotated[
int | None,
Field(
alias="durationMs",
description="The duration of the command execution in milliseconds.",
),
] = None
exit_code: Annotated[
int | None, Field(alias="exitCode", description="The command's exit code.")
] = None
id: str
process_id: Annotated[
str | None,
Field(
alias="processId",
description="Identifier for the underlying PTY process (when available).",
),
] = None
status: CommandExecutionStatus
type: Annotated[
CommandExecutionThreadItemType, Field(title="CommandExecutionThreadItemType")
]
class FileChangeThreadItemType(RootModel[Literal["fileChange"]]):
root: Annotated[Literal["fileChange"], Field(title="FileChangeThreadItemType")]
class McpToolCallThreadItemType(RootModel[Literal["mcpToolCall"]]):
root: Annotated[Literal["mcpToolCall"], Field(title="McpToolCallThreadItemType")]
class McpToolCallThreadItem(BaseModel):
arguments: Any
duration_ms: Annotated[
int | None,
Field(
alias="durationMs",
description="The duration of the MCP tool call in milliseconds.",
),
] = None
error: McpToolCallError | None = None
id: str
result: McpToolCallResult | None = None
server: str
status: McpToolCallStatus
tool: str
type: Annotated[McpToolCallThreadItemType, Field(title="McpToolCallThreadItemType")]
class DynamicToolCallThreadItemType(RootModel[Literal["dynamicToolCall"]]):
root: Annotated[
Literal["dynamicToolCall"], Field(title="DynamicToolCallThreadItemType")
]
class DynamicToolCallThreadItem(BaseModel):
arguments: Any
content_items: Annotated[
list[DynamicToolCallOutputContentItem] | None, Field(alias="contentItems")
] = None
duration_ms: Annotated[
int | None,
Field(
alias="durationMs",
description="The duration of the dynamic tool call in milliseconds.",
),
] = None
id: str
status: DynamicToolCallStatus
success: bool | None = None
tool: str
type: Annotated[
DynamicToolCallThreadItemType, Field(title="DynamicToolCallThreadItemType")
]
class CollabAgentToolCallThreadItemType(RootModel[Literal["collabAgentToolCall"]]):
root: Annotated[
Literal["collabAgentToolCall"], Field(title="CollabAgentToolCallThreadItemType")
]
class WebSearchThreadItemType(RootModel[Literal["webSearch"]]):
root: Annotated[Literal["webSearch"], Field(title="WebSearchThreadItemType")]
class ImageViewThreadItemType(RootModel[Literal["imageView"]]):
root: Annotated[Literal["imageView"], Field(title="ImageViewThreadItemType")]
class ImageViewThreadItem(BaseModel):
id: str
path: str
type: Annotated[ImageViewThreadItemType, Field(title="ImageViewThreadItemType")]
class ImageGenerationThreadItemType(RootModel[Literal["imageGeneration"]]):
root: Annotated[
Literal["imageGeneration"], Field(title="ImageGenerationThreadItemType")
]
class ImageGenerationThreadItem(BaseModel):
id: str
result: str
revised_prompt: Annotated[str | None, Field(alias="revisedPrompt")] = None
status: str
type: Annotated[
ImageGenerationThreadItemType, Field(title="ImageGenerationThreadItemType")
]
class EnteredReviewModeThreadItemType(RootModel[Literal["enteredReviewMode"]]):
root: Annotated[
Literal["enteredReviewMode"], Field(title="EnteredReviewModeThreadItemType")
]
class EnteredReviewModeThreadItem(BaseModel):
id: str
review: str
type: Annotated[
EnteredReviewModeThreadItemType, Field(title="EnteredReviewModeThreadItemType")
]
class ExitedReviewModeThreadItemType(RootModel[Literal["exitedReviewMode"]]):
root: Annotated[
Literal["exitedReviewMode"], Field(title="ExitedReviewModeThreadItemType")
]
class ExitedReviewModeThreadItem(BaseModel):
id: str
review: str
type: Annotated[
ExitedReviewModeThreadItemType, Field(title="ExitedReviewModeThreadItemType")
]
class ContextCompactionThreadItemType(RootModel[Literal["contextCompaction"]]):
root: Annotated[
Literal["contextCompaction"], Field(title="ContextCompactionThreadItemType")
]
class ContextCompactionThreadItem(BaseModel):
id: str
type: Annotated[
ContextCompactionThreadItemType, Field(title="ContextCompactionThreadItemType")
]
class ThreadLoadedListParams(BaseModel):
cursor: Annotated[
str | None,
Field(description="Opaque pagination cursor returned by a previous call."),
] = None
limit: Annotated[
int | None,
Field(
description="Optional page size; defaults to no limit.", ge=0, le=4294967295
),
] = None
class ThreadMetadataGitInfoUpdateParams(BaseModel):
branch: Annotated[
str | None,
Field(
description="Omit to leave the stored branch unchanged, set to `null` to clear it, or provide a non-empty string to replace it."
),
] = None
origin_url: Annotated[
str | None,
Field(
alias="originUrl",
description="Omit to leave the stored origin URL unchanged, set to `null` to clear it, or provide a non-empty string to replace it.",
),
] = None
sha: Annotated[
str | None,
Field(
description="Omit to leave the stored commit unchanged, set to `null` to clear it, or provide a non-empty string to replace it."
),
] = None
class ThreadMetadataUpdateParams(BaseModel):
git_info: Annotated[
ThreadMetadataGitInfoUpdateParams | None,
Field(
alias="gitInfo",
description="Patch the stored Git metadata for this thread. Omit a field to leave it unchanged, set it to `null` to clear it, or provide a string to replace the stored value.",
),
] = None
thread_id: Annotated[str, Field(alias="threadId")]
class ThreadNameUpdatedNotification(BaseModel):
thread_id: Annotated[str, Field(alias="threadId")]
thread_name: Annotated[str | None, Field(alias="threadName")] = None
class ThreadReadParams(BaseModel):
include_turns: Annotated[
bool | None,
Field(
alias="includeTurns",
description="When true, include turns and their items from rollout history.",
),
] = False
thread_id: Annotated[str, Field(alias="threadId")]
class ThreadRealtimeAudioChunk(BaseModel):
data: str
num_channels: Annotated[int, Field(alias="numChannels", ge=0, le=65535)]
sample_rate: Annotated[int, Field(alias="sampleRate", ge=0, le=4294967295)]
samples_per_channel: Annotated[
int | None, Field(alias="samplesPerChannel", ge=0, le=4294967295)
] = None
class ThreadRealtimeClosedNotification(BaseModel):
reason: str | None = None
thread_id: Annotated[str, Field(alias="threadId")]
class ThreadRealtimeErrorNotification(BaseModel):
message: str
thread_id: Annotated[str, Field(alias="threadId")]
class ThreadRealtimeItemAddedNotification(BaseModel):
item: Any
thread_id: Annotated[str, Field(alias="threadId")]
class ThreadRealtimeOutputAudioDeltaNotification(BaseModel):
audio: ThreadRealtimeAudioChunk
thread_id: Annotated[str, Field(alias="threadId")]
class ThreadRealtimeStartedNotification(BaseModel):
session_id: Annotated[str | None, Field(alias="sessionId")] = None
thread_id: Annotated[str, Field(alias="threadId")]
class ThreadResumeParams(BaseModel):
approval_policy: Annotated[AskForApproval | None, Field(alias="approvalPolicy")] = (
None
)
base_instructions: Annotated[str | None, Field(alias="baseInstructions")] = None
config: dict[str, Any] | None = None
cwd: str | None = None
developer_instructions: Annotated[
str | None, Field(alias="developerInstructions")
] = None
model: Annotated[
str | None,
Field(description="Configuration overrides for the resumed thread, if any."),
] = None
model_provider: Annotated[str | None, Field(alias="modelProvider")] = None
personality: Personality | None = None
sandbox: SandboxMode | None = None
service_tier: Annotated[ServiceTier | None, Field(alias="serviceTier")] = None
thread_id: Annotated[str, Field(alias="threadId")]
class ThreadRollbackParams(BaseModel):
num_turns: Annotated[
int,
Field(
alias="numTurns",
description="The number of turns to drop from the end of the thread. Must be >= 1.\n\nThis only modifies the thread's history and does not revert local file changes that have been made by the agent. Clients are responsible for reverting these changes.",
ge=0,
le=4294967295,
),
]
thread_id: Annotated[str, Field(alias="threadId")]
class ThreadSetNameParams(BaseModel):
name: str
thread_id: Annotated[str, Field(alias="threadId")]
class ThreadSortKey(StrEnum):
created_at = "created_at"
updated_at = "updated_at"
class ThreadSourceKind(StrEnum):
cli = "cli"
vscode = "vscode"
exec = "exec"
app_server = "appServer"
sub_agent = "subAgent"
sub_agent_review = "subAgentReview"
sub_agent_compact = "subAgentCompact"
sub_agent_thread_spawn = "subAgentThreadSpawn"
sub_agent_other = "subAgentOther"
unknown = "unknown"
class ThreadStartParams(BaseModel):
approval_policy: Annotated[AskForApproval | None, Field(alias="approvalPolicy")] = (
None
)
base_instructions: Annotated[str | None, Field(alias="baseInstructions")] = None
config: dict[str, Any] | None = None
cwd: str | None = None
developer_instructions: Annotated[
str | None, Field(alias="developerInstructions")
] = None
ephemeral: bool | None = None
model: str | None = None
model_provider: Annotated[str | None, Field(alias="modelProvider")] = None
personality: Personality | None = None
sandbox: SandboxMode | None = None
service_name: Annotated[str | None, Field(alias="serviceName")] = None
service_tier: Annotated[ServiceTier | None, Field(alias="serviceTier")] = None
class NotLoadedThreadStatusType(RootModel[Literal["notLoaded"]]):
root: Annotated[Literal["notLoaded"], Field(title="NotLoadedThreadStatusType")]
class NotLoadedThreadStatus(BaseModel):
type: Annotated[NotLoadedThreadStatusType, Field(title="NotLoadedThreadStatusType")]
class IdleThreadStatusType(RootModel[Literal["idle"]]):
root: Annotated[Literal["idle"], Field(title="IdleThreadStatusType")]
class IdleThreadStatus(BaseModel):
type: Annotated[IdleThreadStatusType, Field(title="IdleThreadStatusType")]
class SystemErrorThreadStatusType(RootModel[Literal["systemError"]]):
root: Annotated[Literal["systemError"], Field(title="SystemErrorThreadStatusType")]
class SystemErrorThreadStatus(BaseModel):
type: Annotated[
SystemErrorThreadStatusType, Field(title="SystemErrorThreadStatusType")
]
class ActiveThreadStatusType(RootModel[Literal["active"]]):
root: Annotated[Literal["active"], Field(title="ActiveThreadStatusType")]
class ActiveThreadStatus(BaseModel):
active_flags: Annotated[list[ThreadActiveFlag], Field(alias="activeFlags")]
type: Annotated[ActiveThreadStatusType, Field(title="ActiveThreadStatusType")]
class ThreadStatus(
RootModel[
NotLoadedThreadStatus
| IdleThreadStatus
| SystemErrorThreadStatus
| ActiveThreadStatus
]
):
root: (
NotLoadedThreadStatus
| IdleThreadStatus
| SystemErrorThreadStatus
| ActiveThreadStatus
)
class ThreadStatusChangedNotification(BaseModel):
status: ThreadStatus
thread_id: Annotated[str, Field(alias="threadId")]
class ThreadUnarchiveParams(BaseModel):
thread_id: Annotated[str, Field(alias="threadId")]
class ThreadUnarchivedNotification(BaseModel):
thread_id: Annotated[str, Field(alias="threadId")]
class ThreadUnsubscribeParams(BaseModel):
thread_id: Annotated[str, Field(alias="threadId")]
class TokenUsage(BaseModel):
cached_input_tokens: int
input_tokens: int
output_tokens: int
reasoning_output_tokens: int
total_tokens: int
class TokenUsageBreakdown(BaseModel):
cached_input_tokens: Annotated[int, Field(alias="cachedInputTokens")]
input_tokens: Annotated[int, Field(alias="inputTokens")]
output_tokens: Annotated[int, Field(alias="outputTokens")]
reasoning_output_tokens: Annotated[int, Field(alias="reasoningOutputTokens")]
total_tokens: Annotated[int, Field(alias="totalTokens")]
class TokenUsageInfo(BaseModel):
last_token_usage: TokenUsage
model_context_window: int | None = None
total_token_usage: TokenUsage
class Tool(BaseModel):
field_meta: Annotated[Any | None, Field(alias="_meta")] = None
annotations: Any | None = None
description: str | None = None
icons: list[Any] | None = None
input_schema: Annotated[Any, Field(alias="inputSchema")]
name: str
output_schema: Annotated[Any | None, Field(alias="outputSchema")] = None
title: str | None = None
class ToolRequestUserInputAnswer(BaseModel):
answers: list[str]
class ToolRequestUserInputOption(BaseModel):
description: str
label: str
class ToolRequestUserInputQuestion(BaseModel):
header: str
id: str
is_other: Annotated[bool | None, Field(alias="isOther")] = False
is_secret: Annotated[bool | None, Field(alias="isSecret")] = False
options: list[ToolRequestUserInputOption] | None = None
question: str
class ToolRequestUserInputResponse(BaseModel):
answers: dict[str, ToolRequestUserInputAnswer]
class TurnAbortReason(StrEnum):
interrupted = "interrupted"
replaced = "replaced"
review_ended = "review_ended"
class TurnDiffUpdatedNotification(BaseModel):
diff: str
thread_id: Annotated[str, Field(alias="threadId")]
turn_id: Annotated[str, Field(alias="turnId")]
class TurnError(BaseModel):
additional_details: Annotated[str | None, Field(alias="additionalDetails")] = None
codex_error_info: Annotated[
CodexErrorInfo | None, Field(alias="codexErrorInfo")
] = None
message: str
class TurnInterruptParams(BaseModel):
thread_id: Annotated[str, Field(alias="threadId")]
turn_id: Annotated[str, Field(alias="turnId")]
class UserMessageTurnItemType(RootModel[Literal["UserMessage"]]):
root: Annotated[Literal["UserMessage"], Field(title="UserMessageTurnItemType")]
class AgentMessageTurnItemType(RootModel[Literal["AgentMessage"]]):
root: Annotated[Literal["AgentMessage"], Field(title="AgentMessageTurnItemType")]
class AgentMessageTurnItem(BaseModel):
content: list[AgentMessageContent]
id: str
phase: Annotated[
MessagePhase | None,
Field(
description="Optional phase metadata carried through from `ResponseItem::Message`.\n\nThis is currently used by TUI rendering to distinguish mid-turn commentary from a final answer and avoid status-indicator jitter."
),
] = None
type: Annotated[AgentMessageTurnItemType, Field(title="AgentMessageTurnItemType")]
class PlanTurnItemType(RootModel[Literal["Plan"]]):
root: Annotated[Literal["Plan"], Field(title="PlanTurnItemType")]
class PlanTurnItem(BaseModel):
id: str
text: str
type: Annotated[PlanTurnItemType, Field(title="PlanTurnItemType")]
class ReasoningTurnItemType(RootModel[Literal["Reasoning"]]):
root: Annotated[Literal["Reasoning"], Field(title="ReasoningTurnItemType")]
class ReasoningTurnItem(BaseModel):
id: str
raw_content: list[str] | None = []
summary_text: list[str]
type: Annotated[ReasoningTurnItemType, Field(title="ReasoningTurnItemType")]
class WebSearchTurnItemType(RootModel[Literal["WebSearch"]]):
root: Annotated[Literal["WebSearch"], Field(title="WebSearchTurnItemType")]
class WebSearchTurnItem(BaseModel):
action: ResponsesApiWebSearchAction
id: str
query: str
type: Annotated[WebSearchTurnItemType, Field(title="WebSearchTurnItemType")]
class ImageGenerationTurnItemType(RootModel[Literal["ImageGeneration"]]):
root: Annotated[
Literal["ImageGeneration"], Field(title="ImageGenerationTurnItemType")
]
class ImageGenerationTurnItem(BaseModel):
id: str
result: str
revised_prompt: str | None = None
saved_path: str | None = None
status: str
type: Annotated[
ImageGenerationTurnItemType, Field(title="ImageGenerationTurnItemType")
]
class ContextCompactionTurnItemType(RootModel[Literal["ContextCompaction"]]):
root: Annotated[
Literal["ContextCompaction"], Field(title="ContextCompactionTurnItemType")
]
class ContextCompactionTurnItem(BaseModel):
id: str
type: Annotated[
ContextCompactionTurnItemType, Field(title="ContextCompactionTurnItemType")
]
class TurnPlanStepStatus(StrEnum):
pending = "pending"
in_progress = "inProgress"
completed = "completed"
class TurnStatus(StrEnum):
completed = "completed"
interrupted = "interrupted"
failed = "failed"
in_progress = "inProgress"
class TextUserInputType(RootModel[Literal["text"]]):
root: Annotated[Literal["text"], Field(title="TextUserInputType")]
class TextUserInput(BaseModel):
text: str
text_elements: Annotated[
list[TextElement] | None,
Field(
default_factory=list,
description="UI-defined spans within `text` used to render or persist special elements.",
),
]
type: Annotated[TextUserInputType, Field(title="TextUserInputType")]
class ImageUserInputType(RootModel[Literal["image"]]):
root: Annotated[Literal["image"], Field(title="ImageUserInputType")]
class ImageUserInput(BaseModel):
type: Annotated[ImageUserInputType, Field(title="ImageUserInputType")]
url: str
class LocalImageUserInputType(RootModel[Literal["localImage"]]):
root: Annotated[Literal["localImage"], Field(title="LocalImageUserInputType")]
class LocalImageUserInput(BaseModel):
path: str
type: Annotated[LocalImageUserInputType, Field(title="LocalImageUserInputType")]
class SkillUserInputType(RootModel[Literal["skill"]]):
root: Annotated[Literal["skill"], Field(title="SkillUserInputType")]
class SkillUserInput(BaseModel):
name: str
path: str
type: Annotated[SkillUserInputType, Field(title="SkillUserInputType")]
class MentionUserInputType(RootModel[Literal["mention"]]):
root: Annotated[Literal["mention"], Field(title="MentionUserInputType")]
class MentionUserInput(BaseModel):
name: str
path: str
type: Annotated[MentionUserInputType, Field(title="MentionUserInputType")]
class UserInput(
RootModel[
TextUserInput
| ImageUserInput
| LocalImageUserInput
| SkillUserInput
| MentionUserInput
]
):
root: (
TextUserInput
| ImageUserInput
| LocalImageUserInput
| SkillUserInput
| MentionUserInput
)
class W3cTraceContext(BaseModel):
traceparent: str | None = None
tracestate: str | None = None
class SearchWebSearchActionType(RootModel[Literal["search"]]):
root: Annotated[Literal["search"], Field(title="SearchWebSearchActionType")]
class SearchWebSearchAction(BaseModel):
queries: list[str] | None = None
query: str | None = None
type: Annotated[SearchWebSearchActionType, Field(title="SearchWebSearchActionType")]
class OpenPageWebSearchActionType(RootModel[Literal["openPage"]]):
root: Annotated[Literal["openPage"], Field(title="OpenPageWebSearchActionType")]
class OpenPageWebSearchAction(BaseModel):
type: Annotated[
OpenPageWebSearchActionType, Field(title="OpenPageWebSearchActionType")
]
url: str | None = None
class FindInPageWebSearchActionType(RootModel[Literal["findInPage"]]):
root: Annotated[Literal["findInPage"], Field(title="FindInPageWebSearchActionType")]
class FindInPageWebSearchAction(BaseModel):
pattern: str | None = None
type: Annotated[
FindInPageWebSearchActionType, Field(title="FindInPageWebSearchActionType")
]
url: str | None = None
class OtherWebSearchActionType(RootModel[Literal["other"]]):
root: Annotated[Literal["other"], Field(title="OtherWebSearchActionType")]
class OtherWebSearchAction(BaseModel):
type: Annotated[OtherWebSearchActionType, Field(title="OtherWebSearchActionType")]
class WebSearchAction(
RootModel[
SearchWebSearchAction
| OpenPageWebSearchAction
| FindInPageWebSearchAction
| OtherWebSearchAction
]
):
root: (
SearchWebSearchAction
| OpenPageWebSearchAction
| FindInPageWebSearchAction
| OtherWebSearchAction
)
class WindowsSandboxSetupMode(StrEnum):
elevated = "elevated"
unelevated = "unelevated"
class WindowsSandboxSetupStartParams(BaseModel):
cwd: AbsolutePathBuf | None = None
mode: WindowsSandboxSetupMode
class WindowsWorldWritableWarningNotification(BaseModel):
extra_count: Annotated[int, Field(alias="extraCount", ge=0)]
failed_scan: Annotated[bool, Field(alias="failedScan")]
sample_paths: Annotated[list[str], Field(alias="samplePaths")]
class AccountUpdatedNotification(BaseModel):
auth_mode: Annotated[AuthMode | None, Field(alias="authMode")] = None
plan_type: Annotated[PlanType | None, Field(alias="planType")] = None
class AdditionalMacOsPermissions(BaseModel):
accessibility: bool
automations: MacOsAutomationPermission
calendar: bool
preferences: MacOsPreferencesPermission
class AdditionalPermissionProfile(BaseModel):
file_system: Annotated[
AdditionalFileSystemPermissions | None, Field(alias="fileSystem")
] = None
macos: AdditionalMacOsPermissions | None = None
network: AdditionalNetworkPermissions | None = None
class AppMetadata(BaseModel):
categories: list[str] | None = None
developer: str | None = None
first_party_requires_install: Annotated[
bool | None, Field(alias="firstPartyRequiresInstall")
] = None
first_party_type: Annotated[str | None, Field(alias="firstPartyType")] = None
review: AppReview | None = None
screenshots: list[AppScreenshot] | None = None
seo_description: Annotated[str | None, Field(alias="seoDescription")] = None
show_in_composer_when_unlinked: Annotated[
bool | None, Field(alias="showInComposerWhenUnlinked")
] = None
sub_categories: Annotated[list[str] | None, Field(alias="subCategories")] = None
version: str | None = None
version_id: Annotated[str | None, Field(alias="versionId")] = None
version_notes: Annotated[str | None, Field(alias="versionNotes")] = None
class ApplyPatchApprovalParams(BaseModel):
call_id: Annotated[
str,
Field(
alias="callId",
description="Use to correlate this with [codex_protocol::protocol::PatchApplyBeginEvent] and [codex_protocol::protocol::PatchApplyEndEvent].",
),
]
conversation_id: Annotated[ThreadId, Field(alias="conversationId")]
file_changes: Annotated[dict[str, FileChange], Field(alias="fileChanges")]
grant_root: Annotated[
str | None,
Field(
alias="grantRoot",
description="When set, the agent is asking the user to allow writes under this root for the remainder of the session (unclear if this is honored today).",
),
] = None
reason: Annotated[
str | None,
Field(
description="Optional explanatory reason (e.g. request for extra write access)."
),
] = None
class ChatgptAuthTokensRefreshParams(BaseModel):
previous_account_id: Annotated[
str | None,
Field(
alias="previousAccountId",
description="Workspace/account identifier that Codex was previously using.\n\nClients that manage multiple accounts/workspaces can use this as a hint to refresh the token for the correct workspace.\n\nThis may be `null` when the prior auth state did not include a workspace identifier (`chatgpt_account_id`).",
),
] = None
reason: ChatgptAuthTokensRefreshReason
class InitializeClientRequest(BaseModel):
id: RequestId
method: Annotated[
InitializeClientRequestMethod, Field(title="InitializeClientRequestMethod")
]
params: InitializeParams
class ThreadStartClientRequest(BaseModel):
id: RequestId
method: Annotated[
ThreadStartClientRequestMethod, Field(title="Thread/startClientRequestMethod")
]
params: ThreadStartParams
class ThreadResumeClientRequest(BaseModel):
id: RequestId
method: Annotated[
ThreadResumeClientRequestMethod, Field(title="Thread/resumeClientRequestMethod")
]
params: ThreadResumeParams
class ThreadForkClientRequest(BaseModel):
id: RequestId
method: Annotated[
ThreadForkClientRequestMethod, Field(title="Thread/forkClientRequestMethod")
]
params: ThreadForkParams
class ThreadArchiveClientRequest(BaseModel):
id: RequestId
method: Annotated[
ThreadArchiveClientRequestMethod,
Field(title="Thread/archiveClientRequestMethod"),
]
params: ThreadArchiveParams
class ThreadUnsubscribeClientRequest(BaseModel):
id: RequestId
method: Annotated[
ThreadUnsubscribeClientRequestMethod,
Field(title="Thread/unsubscribeClientRequestMethod"),
]
params: ThreadUnsubscribeParams
class ThreadNameSetClientRequest(BaseModel):
id: RequestId
method: Annotated[
ThreadNameSetClientRequestMethod,
Field(title="Thread/name/setClientRequestMethod"),
]
params: ThreadSetNameParams
class ThreadMetadataUpdateClientRequest(BaseModel):
id: RequestId
method: Annotated[
ThreadMetadataUpdateClientRequestMethod,
Field(title="Thread/metadata/updateClientRequestMethod"),
]
params: ThreadMetadataUpdateParams
class ThreadUnarchiveClientRequest(BaseModel):
id: RequestId
method: Annotated[
ThreadUnarchiveClientRequestMethod,
Field(title="Thread/unarchiveClientRequestMethod"),
]
params: ThreadUnarchiveParams
class ThreadCompactStartClientRequest(BaseModel):
id: RequestId
method: Annotated[
ThreadCompactStartClientRequestMethod,
Field(title="Thread/compact/startClientRequestMethod"),
]
params: ThreadCompactStartParams
class ThreadRollbackClientRequest(BaseModel):
id: RequestId
method: Annotated[
ThreadRollbackClientRequestMethod,
Field(title="Thread/rollbackClientRequestMethod"),
]
params: ThreadRollbackParams
class ThreadLoadedListClientRequest(BaseModel):
id: RequestId
method: Annotated[
ThreadLoadedListClientRequestMethod,
Field(title="Thread/loaded/listClientRequestMethod"),
]
params: ThreadLoadedListParams
class ThreadReadClientRequest(BaseModel):
id: RequestId
method: Annotated[
ThreadReadClientRequestMethod, Field(title="Thread/readClientRequestMethod")
]
params: ThreadReadParams
class SkillsListClientRequest(BaseModel):
id: RequestId
method: Annotated[
SkillsListClientRequestMethod, Field(title="Skills/listClientRequestMethod")
]
params: SkillsListParams
class PluginListClientRequest(BaseModel):
id: RequestId
method: Annotated[
PluginListClientRequestMethod, Field(title="Plugin/listClientRequestMethod")
]
params: PluginListParams
class SkillsRemoteListClientRequest(BaseModel):
id: RequestId
method: Annotated[
SkillsRemoteListClientRequestMethod,
Field(title="Skills/remote/listClientRequestMethod"),
]
params: SkillsRemoteReadParams
class SkillsRemoteExportClientRequest(BaseModel):
id: RequestId
method: Annotated[
SkillsRemoteExportClientRequestMethod,
Field(title="Skills/remote/exportClientRequestMethod"),
]
params: SkillsRemoteWriteParams
class AppListClientRequest(BaseModel):
id: RequestId
method: Annotated[
AppListClientRequestMethod, Field(title="App/listClientRequestMethod")
]
params: AppsListParams
class SkillsConfigWriteClientRequest(BaseModel):
id: RequestId
method: Annotated[
SkillsConfigWriteClientRequestMethod,
Field(title="Skills/config/writeClientRequestMethod"),
]
params: SkillsConfigWriteParams
class PluginInstallClientRequest(BaseModel):
id: RequestId
method: Annotated[
PluginInstallClientRequestMethod,
Field(title="Plugin/installClientRequestMethod"),
]
params: PluginInstallParams
class PluginUninstallClientRequest(BaseModel):
id: RequestId
method: Annotated[
PluginUninstallClientRequestMethod,
Field(title="Plugin/uninstallClientRequestMethod"),
]
params: PluginUninstallParams
class TurnInterruptClientRequest(BaseModel):
id: RequestId
method: Annotated[
TurnInterruptClientRequestMethod,
Field(title="Turn/interruptClientRequestMethod"),
]
params: TurnInterruptParams
class ModelListClientRequest(BaseModel):
id: RequestId
method: Annotated[
ModelListClientRequestMethod, Field(title="Model/listClientRequestMethod")
]
params: ModelListParams
class ExperimentalFeatureListClientRequest(BaseModel):
id: RequestId
method: Annotated[
ExperimentalFeatureListClientRequestMethod,
Field(title="ExperimentalFeature/listClientRequestMethod"),
]
params: ExperimentalFeatureListParams
class McpServerOauthLoginClientRequest(BaseModel):
id: RequestId
method: Annotated[
McpServerOauthLoginClientRequestMethod,
Field(title="McpServer/oauth/loginClientRequestMethod"),
]
params: McpServerOauthLoginParams
class ConfigMcpServerReloadClientRequest(BaseModel):
id: RequestId
method: Annotated[
ConfigMcpServerReloadClientRequestMethod,
Field(title="Config/mcpServer/reloadClientRequestMethod"),
]
params: None = None
class McpServerStatusListClientRequest(BaseModel):
id: RequestId
method: Annotated[
McpServerStatusListClientRequestMethod,
Field(title="McpServerStatus/listClientRequestMethod"),
]
params: ListMcpServerStatusParams
class WindowsSandboxSetupStartClientRequest(BaseModel):
id: RequestId
method: Annotated[
WindowsSandboxSetupStartClientRequestMethod,
Field(title="WindowsSandbox/setupStartClientRequestMethod"),
]
params: WindowsSandboxSetupStartParams
class AccountLoginStartClientRequest(BaseModel):
id: RequestId
method: Annotated[
AccountLoginStartClientRequestMethod,
Field(title="Account/login/startClientRequestMethod"),
]
params: LoginAccountParams
class AccountLoginCancelClientRequest(BaseModel):
id: RequestId
method: Annotated[
AccountLoginCancelClientRequestMethod,
Field(title="Account/login/cancelClientRequestMethod"),
]
params: CancelLoginAccountParams
class AccountLogoutClientRequest(BaseModel):
id: RequestId
method: Annotated[
AccountLogoutClientRequestMethod,
Field(title="Account/logoutClientRequestMethod"),
]
params: None = None
class AccountRateLimitsReadClientRequest(BaseModel):
id: RequestId
method: Annotated[
AccountRateLimitsReadClientRequestMethod,
Field(title="Account/rateLimits/readClientRequestMethod"),
]
params: None = None
class FeedbackUploadClientRequest(BaseModel):
id: RequestId
method: Annotated[
FeedbackUploadClientRequestMethod,
Field(title="Feedback/uploadClientRequestMethod"),
]
params: FeedbackUploadParams
class CommandExecWriteClientRequest(BaseModel):
id: RequestId
method: Annotated[
CommandExecWriteClientRequestMethod,
Field(title="Command/exec/writeClientRequestMethod"),
]
params: CommandExecWriteParams
class CommandExecTerminateClientRequest(BaseModel):
id: RequestId
method: Annotated[
CommandExecTerminateClientRequestMethod,
Field(title="Command/exec/terminateClientRequestMethod"),
]
params: CommandExecTerminateParams
class ConfigReadClientRequest(BaseModel):
id: RequestId
method: Annotated[
ConfigReadClientRequestMethod, Field(title="Config/readClientRequestMethod")
]
params: ConfigReadParams
class ExternalAgentConfigDetectClientRequest(BaseModel):
id: RequestId
method: Annotated[
ExternalAgentConfigDetectClientRequestMethod,
Field(title="ExternalAgentConfig/detectClientRequestMethod"),
]
params: ExternalAgentConfigDetectParams
class ConfigRequirementsReadClientRequest(BaseModel):
id: RequestId
method: Annotated[
ConfigRequirementsReadClientRequestMethod,
Field(title="ConfigRequirements/readClientRequestMethod"),
]
params: None = None
class AccountReadClientRequest(BaseModel):
id: RequestId
method: Annotated[
AccountReadClientRequestMethod, Field(title="Account/readClientRequestMethod")
]
params: GetAccountParams
class FuzzyFileSearchClientRequest(BaseModel):
id: RequestId
method: Annotated[
FuzzyFileSearchClientRequestMethod,
Field(title="FuzzyFileSearchClientRequestMethod"),
]
params: FuzzyFileSearchParams
class CollabAgentRef(BaseModel):
agent_nickname: Annotated[
str | None,
Field(
description="Optional nickname assigned to an AgentControl-spawned sub-agent."
),
] = None
agent_role: Annotated[
str | None,
Field(
description="Optional role (agent_role) assigned to an AgentControl-spawned sub-agent."
),
] = None
thread_id: Annotated[
ThreadId, Field(description="Thread ID of the receiver/new agent.")
]
class CollabAgentState(BaseModel):
message: str | None = None
status: CollabAgentStatus
class CollabAgentStatusEntry(BaseModel):
agent_nickname: Annotated[
str | None,
Field(
description="Optional nickname assigned to an AgentControl-spawned sub-agent."
),
] = None
agent_role: Annotated[
str | None,
Field(
description="Optional role (agent_role) assigned to an AgentControl-spawned sub-agent."
),
] = None
status: Annotated[AgentStatus, Field(description="Last known status of the agent.")]
thread_id: Annotated[
ThreadId, Field(description="Thread ID of the receiver/new agent.")
]
class CommandExecOutputDeltaNotification(BaseModel):
cap_reached: Annotated[
bool,
Field(
alias="capReached",
description="`true` on the final streamed chunk for a stream when `outputBytesCap` truncated later output on that stream.",
),
]
delta_base64: Annotated[
str, Field(alias="deltaBase64", description="Base64-encoded output bytes.")
]
process_id: Annotated[
str,
Field(
alias="processId",
description="Client-supplied, connection-scoped `processId` from the original `command/exec` request.",
),
]
stream: Annotated[
CommandExecOutputStream, Field(description="Output stream for this chunk.")
]
class CommandExecParams(BaseModel):
command: Annotated[
list[str], Field(description="Command argv vector. Empty arrays are rejected.")
]
cwd: Annotated[
str | None,
Field(description="Optional working directory. Defaults to the server cwd."),
] = None
disable_output_cap: Annotated[
bool | None,
Field(
alias="disableOutputCap",
description="Disable stdout/stderr capture truncation for this request.\n\nCannot be combined with `outputBytesCap`.",
),
] = None
disable_timeout: Annotated[
bool | None,
Field(
alias="disableTimeout",
description="Disable the timeout entirely for this request.\n\nCannot be combined with `timeoutMs`.",
),
] = None
env: Annotated[
dict[str, Any] | None,
Field(
description="Optional environment overrides merged into the server-computed environment.\n\nMatching names override inherited values. Set a key to `null` to unset an inherited variable."
),
] = None
output_bytes_cap: Annotated[
int | None,
Field(
alias="outputBytesCap",
description="Optional per-stream stdout/stderr capture cap in bytes.\n\nWhen omitted, the server default applies. Cannot be combined with `disableOutputCap`.",
ge=0,
),
] = None
process_id: Annotated[
str | None,
Field(
alias="processId",
description="Optional client-supplied, connection-scoped process id.\n\nRequired for `tty`, `streamStdin`, `streamStdoutStderr`, and follow-up `command/exec/write`, `command/exec/resize`, and `command/exec/terminate` calls. When omitted, buffered execution gets an internal id that is not exposed to the client.",
),
] = None
sandbox_policy: Annotated[
SandboxPolicy | None,
Field(
alias="sandboxPolicy",
description="Optional sandbox policy for this command.\n\nUses the same shape as thread/turn execution sandbox configuration and defaults to the user's configured policy when omitted.",
),
] = None
size: Annotated[
CommandExecTerminalSize | None,
Field(
description="Optional initial PTY size in character cells. Only valid when `tty` is true."
),
] = None
stream_stdin: Annotated[
bool | None,
Field(
alias="streamStdin",
description="Allow follow-up `command/exec/write` requests to write stdin bytes.\n\nRequires a client-supplied `processId`.",
),
] = None
stream_stdout_stderr: Annotated[
bool | None,
Field(
alias="streamStdoutStderr",
description="Stream stdout/stderr via `command/exec/outputDelta` notifications.\n\nStreamed bytes are not duplicated into the final response and require a client-supplied `processId`.",
),
] = None
timeout_ms: Annotated[
int | None,
Field(
alias="timeoutMs",
description="Optional timeout in milliseconds.\n\nWhen omitted, the server default applies. Cannot be combined with `disableTimeout`.",
),
] = None
tty: Annotated[
bool | None,
Field(
description="Enable PTY mode.\n\nThis implies `streamStdin` and `streamStdoutStderr`."
),
] = None
class CommandExecResizeParams(BaseModel):
process_id: Annotated[
str,
Field(
alias="processId",
description="Client-supplied, connection-scoped `processId` from the original `command/exec` request.",
),
]
size: Annotated[
CommandExecTerminalSize, Field(description="New PTY size in character cells.")
]
class ConfigEdit(BaseModel):
key_path: Annotated[str, Field(alias="keyPath")]
merge_strategy: Annotated[MergeStrategy, Field(alias="mergeStrategy")]
value: Any
class ConfigValueWriteParams(BaseModel):
expected_version: Annotated[str | None, Field(alias="expectedVersion")] = None
file_path: Annotated[
str | None,
Field(
alias="filePath",
description="Path to the config file to write; defaults to the user's `config.toml` when omitted.",
),
] = None
key_path: Annotated[str, Field(alias="keyPath")]
merge_strategy: Annotated[MergeStrategy, Field(alias="mergeStrategy")]
value: Any
class ConfigWarningNotification(BaseModel):
details: Annotated[
str | None, Field(description="Optional extra guidance or error details.")
] = None
path: Annotated[
str | None,
Field(
description="Optional path to the config file that triggered the warning."
),
] = None
range: Annotated[
TextRange | None,
Field(
description="Optional range for the error location inside the config file."
),
] = None
summary: Annotated[str, Field(description="Concise summary of the warning.")]
class ErrorNotification(BaseModel):
error: TurnError
thread_id: Annotated[str, Field(alias="threadId")]
turn_id: Annotated[str, Field(alias="turnId")]
will_retry: Annotated[bool, Field(alias="willRetry")]
class ModelRerouteEventMsg(BaseModel):
from_model: str
reason: ModelRerouteReason
to_model: str
type: Annotated[ModelRerouteEventMsgType, Field(title="ModelRerouteEventMsgType")]
class TaskStartedEventMsg(BaseModel):
collaboration_mode_kind: ModeKind | None = "default"
model_context_window: int | None = None
turn_id: str
type: Annotated[TaskStartedEventMsgType, Field(title="TaskStartedEventMsgType")]
class AgentMessageEventMsg(BaseModel):
message: str
phase: MessagePhase | None = None
type: Annotated[AgentMessageEventMsgType, Field(title="AgentMessageEventMsgType")]
class UserMessageEventMsg(BaseModel):
images: Annotated[
list[str] | None,
Field(
description="Image URLs sourced from `UserInput::Image`. These are safe to replay in legacy UI history events and correspond to images sent to the model."
),
] = None
local_images: Annotated[
list[str] | None,
Field(
description="Local file paths sourced from `UserInput::LocalImage`. These are kept so the UI can reattach images when editing history, and should not be sent to the model or treated as API-ready URLs."
),
] = []
message: str
text_elements: Annotated[
list[TextElement] | None,
Field(
default_factory=list,
description="UI-defined spans within `message` used to render or persist special elements.",
),
]
type: Annotated[UserMessageEventMsgType, Field(title="UserMessageEventMsgType")]
class ThreadNameUpdatedEventMsg(BaseModel):
thread_id: ThreadId
thread_name: str | None = None
type: Annotated[
ThreadNameUpdatedEventMsgType, Field(title="ThreadNameUpdatedEventMsgType")
]
class McpStartupUpdateEventMsg(BaseModel):
server: Annotated[str, Field(description="Server name being started.")]
status: Annotated[McpStartupStatus, Field(description="Current startup status.")]
type: Annotated[
McpStartupUpdateEventMsgType, Field(title="McpStartupUpdateEventMsgType")
]
class McpStartupCompleteEventMsg(BaseModel):
cancelled: list[str]
failed: list[McpStartupFailure]
ready: list[str]
type: Annotated[
McpStartupCompleteEventMsgType, Field(title="McpStartupCompleteEventMsgType")
]
class McpToolCallBeginEventMsg(BaseModel):
call_id: Annotated[
str,
Field(
description="Identifier so this can be paired with the McpToolCallEnd event."
),
]
invocation: McpInvocation
type: Annotated[
McpToolCallBeginEventMsgType, Field(title="McpToolCallBeginEventMsgType")
]
class McpToolCallEndEventMsg(BaseModel):
call_id: Annotated[
str,
Field(
description="Identifier for the corresponding McpToolCallBegin that finished."
),
]
duration: Duration
invocation: McpInvocation
result: Annotated[
ResultOfCallToolResultOrString,
Field(description="Result of the tool call. Note this could be an error."),
]
type: Annotated[
McpToolCallEndEventMsgType, Field(title="McpToolCallEndEventMsgType")
]
class WebSearchEndEventMsg(BaseModel):
action: ResponsesApiWebSearchAction
call_id: str
query: str
type: Annotated[WebSearchEndEventMsgType, Field(title="WebSearchEndEventMsgType")]
class ExecCommandBeginEventMsg(BaseModel):
call_id: Annotated[
str,
Field(
description="Identifier so this can be paired with the ExecCommandEnd event."
),
]
command: Annotated[list[str], Field(description="The command to be executed.")]
cwd: Annotated[
str,
Field(
description="The command's working directory if not the default cwd for the agent."
),
]
interaction_input: Annotated[
str | None,
Field(
description="Raw input sent to a unified exec session (if this is an interaction event)."
),
] = None
parsed_cmd: list[ParsedCommand]
process_id: Annotated[
str | None,
Field(
description="Identifier for the underlying PTY process (when available)."
),
] = None
source: Annotated[
ExecCommandSource | None,
Field(
description="Where the command originated. Defaults to Agent for backward compatibility."
),
] = "agent"
turn_id: Annotated[str, Field(description="Turn ID that this command belongs to.")]
type: Annotated[
ExecCommandBeginEventMsgType, Field(title="ExecCommandBeginEventMsgType")
]
class ExecCommandOutputDeltaEventMsg(BaseModel):
call_id: Annotated[
str,
Field(
description="Identifier for the ExecCommandBegin that produced this chunk."
),
]
chunk: Annotated[
str, Field(description="Raw bytes from the stream (may not be valid UTF-8).")
]
stream: Annotated[
ExecOutputStream, Field(description="Which stream produced this chunk.")
]
type: Annotated[
ExecCommandOutputDeltaEventMsgType,
Field(title="ExecCommandOutputDeltaEventMsgType"),
]
class ExecCommandEndEventMsg(BaseModel):
aggregated_output: Annotated[
str | None, Field(description="Captured aggregated output")
] = ""
call_id: Annotated[
str, Field(description="Identifier for the ExecCommandBegin that finished.")
]
command: Annotated[list[str], Field(description="The command that was executed.")]
cwd: Annotated[
str,
Field(
description="The command's working directory if not the default cwd for the agent."
),
]
duration: Annotated[
Duration, Field(description="The duration of the command execution.")
]
exit_code: Annotated[int, Field(description="The command's exit code.")]
formatted_output: Annotated[
str,
Field(description="Formatted output from the command, as seen by the model."),
]
interaction_input: Annotated[
str | None,
Field(
description="Raw input sent to a unified exec session (if this is an interaction event)."
),
] = None
parsed_cmd: list[ParsedCommand]
process_id: Annotated[
str | None,
Field(
description="Identifier for the underlying PTY process (when available)."
),
] = None
source: Annotated[
ExecCommandSource | None,
Field(
description="Where the command originated. Defaults to Agent for backward compatibility."
),
] = "agent"
status: Annotated[
ExecCommandStatus,
Field(description="Completion status for this command execution."),
]
stderr: Annotated[str, Field(description="Captured stderr")]
stdout: Annotated[str, Field(description="Captured stdout")]
turn_id: Annotated[str, Field(description="Turn ID that this command belongs to.")]
type: Annotated[
ExecCommandEndEventMsgType, Field(title="ExecCommandEndEventMsgType")
]
class RequestPermissionsEventMsg(BaseModel):
call_id: Annotated[
str,
Field(
description="Responses API call id for the associated tool call, if available."
),
]
permissions: PermissionProfile
reason: str | None = None
turn_id: Annotated[
str | None,
Field(
description="Turn ID that this request belongs to. Uses `#[serde(default)]` for backwards compatibility."
),
] = ""
type: Annotated[
RequestPermissionsEventMsgType, Field(title="RequestPermissionsEventMsgType")
]
class ElicitationRequestEventMsg(BaseModel):
id: RequestId
request: ElicitationRequest
server_name: str
turn_id: Annotated[
str | None,
Field(description="Turn ID that this elicitation belongs to, when known."),
] = None
type: Annotated[
ElicitationRequestEventMsgType, Field(title="ElicitationRequestEventMsgType")
]
class ApplyPatchApprovalRequestEventMsg(BaseModel):
call_id: Annotated[
str,
Field(
description="Responses API call id for the associated patch apply call, if available."
),
]
changes: dict[str, FileChange]
grant_root: Annotated[
str | None,
Field(
description="When set, the agent is asking the user to allow writes under this root for the remainder of the session."
),
] = None
reason: Annotated[
str | None,
Field(
description="Optional explanatory reason (e.g. request for extra write access)."
),
] = None
turn_id: Annotated[
str | None,
Field(
description="Turn ID that this patch belongs to. Uses `#[serde(default)]` for backwards compatibility with older senders."
),
] = ""
type: Annotated[
ApplyPatchApprovalRequestEventMsgType,
Field(title="ApplyPatchApprovalRequestEventMsgType"),
]
class PatchApplyBeginEventMsg(BaseModel):
auto_approved: Annotated[
bool,
Field(
description="If true, there was no ApplyPatchApprovalRequest for this patch."
),
]
call_id: Annotated[
str,
Field(
description="Identifier so this can be paired with the PatchApplyEnd event."
),
]
changes: Annotated[
dict[str, FileChange], Field(description="The changes to be applied.")
]
turn_id: Annotated[
str | None,
Field(
description="Turn ID that this patch belongs to. Uses `#[serde(default)]` for backwards compatibility."
),
] = ""
type: Annotated[
PatchApplyBeginEventMsgType, Field(title="PatchApplyBeginEventMsgType")
]
class PatchApplyEndEventMsg(BaseModel):
call_id: Annotated[
str, Field(description="Identifier for the PatchApplyBegin that finished.")
]
changes: Annotated[
dict[str, FileChange] | None,
Field(
default_factory=lambda: FileChange({}),
description="The changes that were applied (mirrors PatchApplyBeginEvent::changes).",
),
]
status: Annotated[
PatchApplyStatus,
Field(description="Completion status for this patch application."),
]
stderr: Annotated[
str, Field(description="Captured stderr (parser errors, IO failures, etc.).")
]
stdout: Annotated[
str, Field(description="Captured stdout (summary printed by apply_patch).")
]
success: Annotated[
bool, Field(description="Whether the patch was applied successfully.")
]
turn_id: Annotated[
str | None,
Field(
description="Turn ID that this patch belongs to. Uses `#[serde(default)]` for backwards compatibility."
),
] = ""
type: Annotated[PatchApplyEndEventMsgType, Field(title="PatchApplyEndEventMsgType")]
class GetHistoryEntryResponseEventMsg(BaseModel):
entry: Annotated[
HistoryEntry | None,
Field(
description="The entry at the requested offset, if available and parseable."
),
] = None
log_id: Annotated[int, Field(ge=0, le=18446744073709551615)]
offset: Annotated[int, Field(ge=0)]
type: Annotated[
GetHistoryEntryResponseEventMsgType,
Field(title="GetHistoryEntryResponseEventMsgType"),
]
class McpListToolsResponseEventMsg(BaseModel):
auth_statuses: Annotated[
dict[str, McpAuthStatus],
Field(description="Authentication status for each configured MCP server."),
]
resource_templates: Annotated[
dict[str, list[ResourceTemplate]],
Field(description="Known resource templates grouped by server name."),
]
resources: Annotated[
dict[str, list[Resource]],
Field(description="Known resources grouped by server name."),
]
tools: Annotated[
dict[str, Tool],
Field(description="Fully qualified tool name -> tool definition."),
]
type: Annotated[
McpListToolsResponseEventMsgType,
Field(title="McpListToolsResponseEventMsgType"),
]
class ListRemoteSkillsResponseEventMsg(BaseModel):
skills: list[RemoteSkillSummary]
type: Annotated[
ListRemoteSkillsResponseEventMsgType,
Field(title="ListRemoteSkillsResponseEventMsgType"),
]
class TurnAbortedEventMsg(BaseModel):
reason: TurnAbortReason
turn_id: str | None = None
type: Annotated[TurnAbortedEventMsgType, Field(title="TurnAbortedEventMsgType")]
class EnteredReviewModeEventMsg(BaseModel):
target: ReviewTarget
type: Annotated[
EnteredReviewModeEventMsgType, Field(title="EnteredReviewModeEventMsgType")
]
user_facing_hint: str | None = None
class CollabAgentSpawnBeginEventMsg(BaseModel):
call_id: Annotated[str, Field(description="Identifier for the collab tool call.")]
prompt: Annotated[
str,
Field(
description="Initial prompt sent to the agent. Can be empty to prevent CoT leaking at the beginning."
),
]
sender_thread_id: Annotated[ThreadId, Field(description="Thread ID of the sender.")]
type: Annotated[
CollabAgentSpawnBeginEventMsgType,
Field(title="CollabAgentSpawnBeginEventMsgType"),
]
class CollabAgentSpawnEndEventMsg(BaseModel):
call_id: Annotated[str, Field(description="Identifier for the collab tool call.")]
new_agent_nickname: Annotated[
str | None, Field(description="Optional nickname assigned to the new agent.")
] = None
new_agent_role: Annotated[
str | None, Field(description="Optional role assigned to the new agent.")
] = None
new_thread_id: Annotated[
ThreadId | None,
Field(description="Thread ID of the newly spawned agent, if it was created."),
] = None
prompt: Annotated[
str,
Field(
description="Initial prompt sent to the agent. Can be empty to prevent CoT leaking at the beginning."
),
]
sender_thread_id: Annotated[ThreadId, Field(description="Thread ID of the sender.")]
status: Annotated[
AgentStatus,
Field(
description="Last known status of the new agent reported to the sender agent."
),
]
type: Annotated[
CollabAgentSpawnEndEventMsgType, Field(title="CollabAgentSpawnEndEventMsgType")
]
class CollabAgentInteractionBeginEventMsg(BaseModel):
call_id: Annotated[str, Field(description="Identifier for the collab tool call.")]
prompt: Annotated[
str,
Field(
description="Prompt sent from the sender to the receiver. Can be empty to prevent CoT leaking at the beginning."
),
]
receiver_thread_id: Annotated[
ThreadId, Field(description="Thread ID of the receiver.")
]
sender_thread_id: Annotated[ThreadId, Field(description="Thread ID of the sender.")]
type: Annotated[
CollabAgentInteractionBeginEventMsgType,
Field(title="CollabAgentInteractionBeginEventMsgType"),
]
class CollabAgentInteractionEndEventMsg(BaseModel):
call_id: Annotated[str, Field(description="Identifier for the collab tool call.")]
prompt: Annotated[
str,
Field(
description="Prompt sent from the sender to the receiver. Can be empty to prevent CoT leaking at the beginning."
),
]
receiver_agent_nickname: Annotated[
str | None,
Field(description="Optional nickname assigned to the receiver agent."),
] = None
receiver_agent_role: Annotated[
str | None, Field(description="Optional role assigned to the receiver agent.")
] = None
receiver_thread_id: Annotated[
ThreadId, Field(description="Thread ID of the receiver.")
]
sender_thread_id: Annotated[ThreadId, Field(description="Thread ID of the sender.")]
status: Annotated[
AgentStatus,
Field(
description="Last known status of the receiver agent reported to the sender agent."
),
]
type: Annotated[
CollabAgentInteractionEndEventMsgType,
Field(title="CollabAgentInteractionEndEventMsgType"),
]
class CollabWaitingBeginEventMsg(BaseModel):
call_id: Annotated[str, Field(description="ID of the waiting call.")]
receiver_agents: Annotated[
list[CollabAgentRef] | None,
Field(description="Optional nicknames/roles for receivers."),
] = None
receiver_thread_ids: Annotated[
list[ThreadId], Field(description="Thread ID of the receivers.")
]
sender_thread_id: Annotated[ThreadId, Field(description="Thread ID of the sender.")]
type: Annotated[
CollabWaitingBeginEventMsgType, Field(title="CollabWaitingBeginEventMsgType")
]
class CollabWaitingEndEventMsg(BaseModel):
agent_statuses: Annotated[
list[CollabAgentStatusEntry] | None,
Field(description="Optional receiver metadata paired with final statuses."),
] = None
call_id: Annotated[str, Field(description="ID of the waiting call.")]
sender_thread_id: Annotated[ThreadId, Field(description="Thread ID of the sender.")]
statuses: Annotated[
dict[str, AgentStatus],
Field(
description="Last known status of the receiver agents reported to the sender agent."
),
]
type: Annotated[
CollabWaitingEndEventMsgType, Field(title="CollabWaitingEndEventMsgType")
]
class CollabCloseBeginEventMsg(BaseModel):
call_id: Annotated[str, Field(description="Identifier for the collab tool call.")]
receiver_thread_id: Annotated[
ThreadId, Field(description="Thread ID of the receiver.")
]
sender_thread_id: Annotated[ThreadId, Field(description="Thread ID of the sender.")]
type: Annotated[
CollabCloseBeginEventMsgType, Field(title="CollabCloseBeginEventMsgType")
]
class CollabCloseEndEventMsg(BaseModel):
call_id: Annotated[str, Field(description="Identifier for the collab tool call.")]
receiver_agent_nickname: Annotated[
str | None,
Field(description="Optional nickname assigned to the receiver agent."),
] = None
receiver_agent_role: Annotated[
str | None, Field(description="Optional role assigned to the receiver agent.")
] = None
receiver_thread_id: Annotated[
ThreadId, Field(description="Thread ID of the receiver.")
]
sender_thread_id: Annotated[ThreadId, Field(description="Thread ID of the sender.")]
status: Annotated[
AgentStatus,
Field(
description="Last known status of the receiver agent reported to the sender agent before the close."
),
]
type: Annotated[
CollabCloseEndEventMsgType, Field(title="CollabCloseEndEventMsgType")
]
class CollabResumeBeginEventMsg(BaseModel):
call_id: Annotated[str, Field(description="Identifier for the collab tool call.")]
receiver_agent_nickname: Annotated[
str | None,
Field(description="Optional nickname assigned to the receiver agent."),
] = None
receiver_agent_role: Annotated[
str | None, Field(description="Optional role assigned to the receiver agent.")
] = None
receiver_thread_id: Annotated[
ThreadId, Field(description="Thread ID of the receiver.")
]
sender_thread_id: Annotated[ThreadId, Field(description="Thread ID of the sender.")]
type: Annotated[
CollabResumeBeginEventMsgType, Field(title="CollabResumeBeginEventMsgType")
]
class CollabResumeEndEventMsg(BaseModel):
call_id: Annotated[str, Field(description="Identifier for the collab tool call.")]
receiver_agent_nickname: Annotated[
str | None,
Field(description="Optional nickname assigned to the receiver agent."),
] = None
receiver_agent_role: Annotated[
str | None, Field(description="Optional role assigned to the receiver agent.")
] = None
receiver_thread_id: Annotated[
ThreadId, Field(description="Thread ID of the receiver.")
]
sender_thread_id: Annotated[ThreadId, Field(description="Thread ID of the sender.")]
status: Annotated[
AgentStatus,
Field(
description="Last known status of the receiver agent reported to the sender agent after resume."
),
]
type: Annotated[
CollabResumeEndEventMsgType, Field(title="CollabResumeEndEventMsgType")
]
class ExecCommandApprovalParams(BaseModel):
approval_id: Annotated[
str | None,
Field(
alias="approvalId",
description="Identifier for this specific approval callback.",
),
] = None
call_id: Annotated[
str,
Field(
alias="callId",
description="Use to correlate this with [codex_protocol::protocol::ExecCommandBeginEvent] and [codex_protocol::protocol::ExecCommandEndEvent].",
),
]
command: list[str]
conversation_id: Annotated[ThreadId, Field(alias="conversationId")]
cwd: str
parsed_cmd: Annotated[list[ParsedCommand], Field(alias="parsedCmd")]
reason: str | None = None
class ExternalAgentConfigMigrationItem(BaseModel):
cwd: Annotated[
str | None,
Field(
description="Null or empty means home-scoped migration; non-empty means repo-scoped migration."
),
] = None
description: str
item_type: Annotated[ExternalAgentConfigMigrationItemType, Field(alias="itemType")]
class FileUpdateChange(BaseModel):
diff: str
kind: PatchChangeKind
path: str
class InputImageFunctionCallOutputContentItem(BaseModel):
detail: ImageDetail | None = None
image_url: str
type: Annotated[
InputImageFunctionCallOutputContentItemType,
Field(title="InputImageFunctionCallOutputContentItemType"),
]
class FunctionCallOutputContentItem(
RootModel[
InputTextFunctionCallOutputContentItem | InputImageFunctionCallOutputContentItem
]
):
root: Annotated[
InputTextFunctionCallOutputContentItem
| InputImageFunctionCallOutputContentItem,
Field(
description="Responses API compatible content items that can be returned by a tool call. This is a subset of ContentItem with the types we support as function call outputs."
),
]
class FuzzyFileSearchResponse(BaseModel):
files: list[FuzzyFileSearchResult]
class GrantedMacOsPermissions(BaseModel):
accessibility: bool | None = None
automations: MacOsAutomationPermission | None = None
calendar: bool | None = None
preferences: MacOsPreferencesPermission | None = None
class GrantedPermissionProfile(BaseModel):
file_system: Annotated[
AdditionalFileSystemPermissions | None, Field(alias="fileSystem")
] = None
macos: GrantedMacOsPermissions | None = None
network: AdditionalNetworkPermissions | None = None
class JSONRPCError(BaseModel):
error: JSONRPCErrorError
id: RequestId
class JSONRPCRequest(BaseModel):
id: RequestId
method: str
params: Any | None = None
trace: Annotated[
W3cTraceContext | None,
Field(description="Optional W3C Trace Context for distributed tracing."),
] = None
class JSONRPCResponse(BaseModel):
id: RequestId
result: Any
class McpElicitationBooleanSchema(BaseModel):
model_config = ConfigDict(
extra="forbid",
)
default: bool | None = None
description: str | None = None
title: str | None = None
type: McpElicitationBooleanType
class McpElicitationLegacyTitledEnumSchema(BaseModel):
model_config = ConfigDict(
extra="forbid",
)
default: str | None = None
description: str | None = None
enum: list[str]
enum_names: Annotated[list[str] | None, Field(alias="enumNames")] = None
title: str | None = None
type: McpElicitationStringType
class McpElicitationMultiSelectEnumSchema(
RootModel[
McpElicitationUntitledMultiSelectEnumSchema
| McpElicitationTitledMultiSelectEnumSchema
]
):
root: (
McpElicitationUntitledMultiSelectEnumSchema
| McpElicitationTitledMultiSelectEnumSchema
)
class McpElicitationNumberSchema(BaseModel):
model_config = ConfigDict(
extra="forbid",
)
default: float | None = None
description: str | None = None
maximum: float | None = None
minimum: float | None = None
title: str | None = None
type: McpElicitationNumberType
class McpElicitationSingleSelectEnumSchema(
RootModel[
McpElicitationUntitledSingleSelectEnumSchema
| McpElicitationTitledSingleSelectEnumSchema
]
):
root: (
McpElicitationUntitledSingleSelectEnumSchema
| McpElicitationTitledSingleSelectEnumSchema
)
class McpElicitationStringSchema(BaseModel):
model_config = ConfigDict(
extra="forbid",
)
default: str | None = None
description: str | None = None
format: McpElicitationStringFormat | None = None
max_length: Annotated[int | None, Field(alias="maxLength", ge=0, le=4294967295)] = (
None
)
min_length: Annotated[int | None, Field(alias="minLength", ge=0, le=4294967295)] = (
None
)
title: str | None = None
type: McpElicitationStringType
class NetworkApprovalContext(BaseModel):
host: str
protocol: NetworkApprovalProtocol
class NetworkPolicyAmendment(BaseModel):
action: NetworkPolicyRuleAction
host: str
class PermissionsRequestApprovalParams(BaseModel):
item_id: Annotated[str, Field(alias="itemId")]
permissions: AdditionalPermissionProfile
reason: str | None = None
thread_id: Annotated[str, Field(alias="threadId")]
turn_id: Annotated[str, Field(alias="turnId")]
class PermissionsRequestApprovalResponse(BaseModel):
permissions: GrantedPermissionProfile
scope: PermissionGrantScope | None = "turn"
class PlanItemArg(BaseModel):
model_config = ConfigDict(
extra="forbid",
)
status: StepStatus
step: str
class RateLimitSnapshot(BaseModel):
credits: CreditsSnapshot | None = None
limit_id: Annotated[str | None, Field(alias="limitId")] = None
limit_name: Annotated[str | None, Field(alias="limitName")] = None
plan_type: Annotated[PlanType | None, Field(alias="planType")] = None
primary: RateLimitWindow | None = None
secondary: RateLimitWindow | None = None
class HandoffRequestedRealtimeEvent(BaseModel):
model_config = ConfigDict(
extra="forbid",
)
handoff_requested: Annotated[
RealtimeHandoffRequested, Field(alias="HandoffRequested")
]
class RealtimeEvent(
RootModel[
SessionUpdatedRealtimeEvent
| AudioOutRealtimeEvent
| ConversationItemAddedRealtimeEvent
| ConversationItemDoneRealtimeEvent
| HandoffRequestedRealtimeEvent
| ErrorRealtimeEvent
]
):
root: (
SessionUpdatedRealtimeEvent
| AudioOutRealtimeEvent
| ConversationItemAddedRealtimeEvent
| ConversationItemDoneRealtimeEvent
| HandoffRequestedRealtimeEvent
| ErrorRealtimeEvent
)
class RequestUserInputQuestion(BaseModel):
header: str
id: str
is_other: Annotated[bool | None, Field(alias="isOther")] = False
is_secret: Annotated[bool | None, Field(alias="isSecret")] = False
options: list[RequestUserInputQuestionOption] | None = None
question: str
class WebSearchCallResponseItem(BaseModel):
action: ResponsesApiWebSearchAction | None = None
id: str | None = None
status: str | None = None
type: Annotated[
WebSearchCallResponseItemType, Field(title="WebSearchCallResponseItemType")
]
class ReviewCodeLocation(BaseModel):
absolute_file_path: str
line_range: ReviewLineRange
class NetworkPolicyAmendment1(BaseModel):
network_policy_amendment: NetworkPolicyAmendment
class NetworkPolicyAmendmentReviewDecision(BaseModel):
model_config = ConfigDict(
extra="forbid",
)
network_policy_amendment: NetworkPolicyAmendment1
class ReviewDecision(
RootModel[
Literal["approved"]
| ApprovedExecpolicyAmendmentReviewDecision
| Literal["approved_for_session"]
| NetworkPolicyAmendmentReviewDecision
| Literal["denied"]
| Literal["abort"]
]
):
root: Annotated[
Literal["approved"]
| ApprovedExecpolicyAmendmentReviewDecision
| Literal["approved_for_session"]
| NetworkPolicyAmendmentReviewDecision
| Literal["denied"]
| Literal["abort"],
Field(description="User's decision in response to an ExecApprovalRequest."),
]
class ReviewFinding(BaseModel):
body: str
code_location: ReviewCodeLocation
confidence_score: float
priority: int
title: str
class ReviewOutputEvent(BaseModel):
findings: list[ReviewFinding]
overall_confidence_score: float
overall_correctness: str
overall_explanation: str
class ReviewStartParams(BaseModel):
delivery: Annotated[
ReviewDelivery | None,
Field(
description="Where to run the review: inline (default) on the current thread or detached on a new thread (returned in `reviewThreadId`)."
),
] = None
target: ReviewTarget
thread_id: Annotated[str, Field(alias="threadId")]
class ErrorServerNotification(BaseModel):
method: Annotated[
ErrorServerNotificationMethod, Field(title="ErrorServerNotificationMethod")
]
params: ErrorNotification
class ThreadStatusChangedServerNotification(BaseModel):
method: Annotated[
ThreadStatusChangedServerNotificationMethod,
Field(title="Thread/status/changedServerNotificationMethod"),
]
params: ThreadStatusChangedNotification
class ThreadArchivedServerNotification(BaseModel):
method: Annotated[
ThreadArchivedServerNotificationMethod,
Field(title="Thread/archivedServerNotificationMethod"),
]
params: ThreadArchivedNotification
class ThreadUnarchivedServerNotification(BaseModel):
method: Annotated[
ThreadUnarchivedServerNotificationMethod,
Field(title="Thread/unarchivedServerNotificationMethod"),
]
params: ThreadUnarchivedNotification
class ThreadClosedServerNotification(BaseModel):
method: Annotated[
ThreadClosedServerNotificationMethod,
Field(title="Thread/closedServerNotificationMethod"),
]
params: ThreadClosedNotification
class SkillsChangedServerNotification(BaseModel):
method: Annotated[
SkillsChangedServerNotificationMethod,
Field(title="Skills/changedServerNotificationMethod"),
]
params: SkillsChangedNotification
class ThreadNameUpdatedServerNotification(BaseModel):
method: Annotated[
ThreadNameUpdatedServerNotificationMethod,
Field(title="Thread/name/updatedServerNotificationMethod"),
]
params: ThreadNameUpdatedNotification
class TurnDiffUpdatedServerNotification(BaseModel):
method: Annotated[
TurnDiffUpdatedServerNotificationMethod,
Field(title="Turn/diff/updatedServerNotificationMethod"),
]
params: TurnDiffUpdatedNotification
class CommandExecOutputDeltaServerNotification(BaseModel):
method: Annotated[
CommandExecOutputDeltaServerNotificationMethod,
Field(title="Command/exec/outputDeltaServerNotificationMethod"),
]
params: CommandExecOutputDeltaNotification
class ItemCommandExecutionTerminalInteractionServerNotification(BaseModel):
method: Annotated[
ItemCommandExecutionTerminalInteractionServerNotificationMethod,
Field(
title="Item/commandExecution/terminalInteractionServerNotificationMethod"
),
]
params: TerminalInteractionNotification
class ServerRequestResolvedServerNotification(BaseModel):
method: Annotated[
ServerRequestResolvedServerNotificationMethod,
Field(title="ServerRequest/resolvedServerNotificationMethod"),
]
params: ServerRequestResolvedNotification
class AccountUpdatedServerNotification(BaseModel):
method: Annotated[
AccountUpdatedServerNotificationMethod,
Field(title="Account/updatedServerNotificationMethod"),
]
params: AccountUpdatedNotification
class ConfigWarningServerNotification(BaseModel):
method: Annotated[
ConfigWarningServerNotificationMethod,
Field(title="ConfigWarningServerNotificationMethod"),
]
params: ConfigWarningNotification
class ThreadRealtimeStartedServerNotification(BaseModel):
method: Annotated[
ThreadRealtimeStartedServerNotificationMethod,
Field(title="Thread/realtime/startedServerNotificationMethod"),
]
params: ThreadRealtimeStartedNotification
class ThreadRealtimeItemAddedServerNotification(BaseModel):
method: Annotated[
ThreadRealtimeItemAddedServerNotificationMethod,
Field(title="Thread/realtime/itemAddedServerNotificationMethod"),
]
params: ThreadRealtimeItemAddedNotification
class ThreadRealtimeOutputAudioDeltaServerNotification(BaseModel):
method: Annotated[
ThreadRealtimeOutputAudioDeltaServerNotificationMethod,
Field(title="Thread/realtime/outputAudio/deltaServerNotificationMethod"),
]
params: ThreadRealtimeOutputAudioDeltaNotification
class ThreadRealtimeErrorServerNotification(BaseModel):
method: Annotated[
ThreadRealtimeErrorServerNotificationMethod,
Field(title="Thread/realtime/errorServerNotificationMethod"),
]
params: ThreadRealtimeErrorNotification
class ThreadRealtimeClosedServerNotification(BaseModel):
method: Annotated[
ThreadRealtimeClosedServerNotificationMethod,
Field(title="Thread/realtime/closedServerNotificationMethod"),
]
params: ThreadRealtimeClosedNotification
class WindowsWorldWritableWarningServerNotification(BaseModel):
method: Annotated[
WindowsWorldWritableWarningServerNotificationMethod,
Field(title="Windows/worldWritableWarningServerNotificationMethod"),
]
params: WindowsWorldWritableWarningNotification
class ItemPermissionsRequestApprovalServerRequest(BaseModel):
id: RequestId
method: Annotated[
ItemPermissionsRequestApprovalServerRequestMethod,
Field(title="Item/permissions/requestApprovalServerRequestMethod"),
]
params: PermissionsRequestApprovalParams
class AccountChatgptAuthTokensRefreshServerRequest(BaseModel):
id: RequestId
method: Annotated[
AccountChatgptAuthTokensRefreshServerRequestMethod,
Field(title="Account/chatgptAuthTokens/refreshServerRequestMethod"),
]
params: ChatgptAuthTokensRefreshParams
class ApplyPatchApprovalServerRequest(BaseModel):
id: RequestId
method: Annotated[
ApplyPatchApprovalServerRequestMethod,
Field(title="ApplyPatchApprovalServerRequestMethod"),
]
params: ApplyPatchApprovalParams
class ExecCommandApprovalServerRequest(BaseModel):
id: RequestId
method: Annotated[
ExecCommandApprovalServerRequestMethod,
Field(title="ExecCommandApprovalServerRequestMethod"),
]
params: ExecCommandApprovalParams
class SkillDependencies(BaseModel):
tools: list[SkillToolDependency]
class SkillMetadata(BaseModel):
dependencies: SkillDependencies | None = None
description: str
enabled: bool
interface: SkillInterface | None = None
name: str
path: str
scope: SkillScope
short_description: Annotated[
str | None,
Field(
alias="shortDescription",
description="Legacy short_description from SKILL.md. Prefer SKILL.json interface.short_description.",
),
] = None
class SkillsListEntry(BaseModel):
cwd: str
errors: list[SkillErrorInfo]
skills: list[SkillMetadata]
class ThreadSpawn(BaseModel):
agent_nickname: str | None = None
agent_role: str | None = None
depth: int
parent_thread_id: ThreadId
class ThreadSpawnSubAgentSource(BaseModel):
model_config = ConfigDict(
extra="forbid",
)
thread_spawn: ThreadSpawn
class SubAgentSource(
RootModel[SubAgentSource1 | ThreadSpawnSubAgentSource | OtherSubAgentSource]
):
root: SubAgentSource1 | ThreadSpawnSubAgentSource | OtherSubAgentSource
class UserMessageThreadItem(BaseModel):
content: list[UserInput]
id: str
type: Annotated[UserMessageThreadItemType, Field(title="UserMessageThreadItemType")]
class FileChangeThreadItem(BaseModel):
changes: list[FileUpdateChange]
id: str
status: PatchApplyStatus
type: Annotated[FileChangeThreadItemType, Field(title="FileChangeThreadItemType")]
class CollabAgentToolCallThreadItem(BaseModel):
agents_states: Annotated[
dict[str, CollabAgentState],
Field(
alias="agentsStates",
description="Last known status of the target agents, when available.",
),
]
id: Annotated[
str, Field(description="Unique identifier for this collab tool call.")
]
prompt: Annotated[
str | None,
Field(
description="Prompt text sent as part of the collab tool call, when available."
),
] = None
receiver_thread_ids: Annotated[
list[str],
Field(
alias="receiverThreadIds",
description="Thread ID of the receiving agent, when applicable. In case of spawn operation, this corresponds to the newly spawned agent.",
),
]
sender_thread_id: Annotated[
str,
Field(
alias="senderThreadId",
description="Thread ID of the agent issuing the collab request.",
),
]
status: Annotated[
CollabAgentToolCallStatus,
Field(description="Current status of the collab tool call."),
]
tool: Annotated[
CollabAgentTool, Field(description="Name of the collab tool that was invoked.")
]
type: Annotated[
CollabAgentToolCallThreadItemType,
Field(title="CollabAgentToolCallThreadItemType"),
]
class WebSearchThreadItem(BaseModel):
action: WebSearchAction | None = None
id: str
query: str
type: Annotated[WebSearchThreadItemType, Field(title="WebSearchThreadItemType")]
class ThreadItem(
RootModel[
UserMessageThreadItem
| AgentMessageThreadItem
| PlanThreadItem
| ReasoningThreadItem
| CommandExecutionThreadItem
| FileChangeThreadItem
| McpToolCallThreadItem
| DynamicToolCallThreadItem
| CollabAgentToolCallThreadItem
| WebSearchThreadItem
| ImageViewThreadItem
| ImageGenerationThreadItem
| EnteredReviewModeThreadItem
| ExitedReviewModeThreadItem
| ContextCompactionThreadItem
]
):
root: (
UserMessageThreadItem
| AgentMessageThreadItem
| PlanThreadItem
| ReasoningThreadItem
| CommandExecutionThreadItem
| FileChangeThreadItem
| McpToolCallThreadItem
| DynamicToolCallThreadItem
| CollabAgentToolCallThreadItem
| WebSearchThreadItem
| ImageViewThreadItem
| ImageGenerationThreadItem
| EnteredReviewModeThreadItem
| ExitedReviewModeThreadItem
| ContextCompactionThreadItem
)
class ThreadListParams(BaseModel):
archived: Annotated[
bool | None,
Field(
description="Optional archived filter; when set to true, only archived threads are returned. If false or null, only non-archived threads are returned."
),
] = None
cursor: Annotated[
str | None,
Field(description="Opaque pagination cursor returned by a previous call."),
] = None
cwd: Annotated[
str | None,
Field(
description="Optional cwd filter; when set, only threads whose session cwd exactly matches this path are returned."
),
] = None
limit: Annotated[
int | None,
Field(
description="Optional page size; defaults to a reasonable server-side value.",
ge=0,
le=4294967295,
),
] = None
model_providers: Annotated[
list[str] | None,
Field(
alias="modelProviders",
description="Optional provider filter; when set, only sessions recorded under these providers are returned. When present but empty, includes all providers.",
),
] = None
search_term: Annotated[
str | None,
Field(
alias="searchTerm",
description="Optional substring filter for the extracted thread title.",
),
] = None
sort_key: Annotated[
ThreadSortKey | None,
Field(
alias="sortKey", description="Optional sort key; defaults to created_at."
),
] = None
source_kinds: Annotated[
list[ThreadSourceKind] | None,
Field(
alias="sourceKinds",
description="Optional source filter; when set, only sessions from these source kinds are returned. When omitted or empty, defaults to interactive sources.",
),
] = None
class ThreadTokenUsage(BaseModel):
last: TokenUsageBreakdown
model_context_window: Annotated[int | None, Field(alias="modelContextWindow")] = (
None
)
total: TokenUsageBreakdown
class ThreadTokenUsageUpdatedNotification(BaseModel):
thread_id: Annotated[str, Field(alias="threadId")]
token_usage: Annotated[ThreadTokenUsage, Field(alias="tokenUsage")]
turn_id: Annotated[str, Field(alias="turnId")]
class ToolRequestUserInputParams(BaseModel):
item_id: Annotated[str, Field(alias="itemId")]
questions: list[ToolRequestUserInputQuestion]
thread_id: Annotated[str, Field(alias="threadId")]
turn_id: Annotated[str, Field(alias="turnId")]
class Turn(BaseModel):
error: Annotated[
TurnError | None,
Field(description="Only populated when the Turn's status is failed."),
] = None
id: str
items: Annotated[
list[ThreadItem],
Field(
description="Only populated on a `thread/resume` or `thread/fork` response. For all other responses and notifications returning a Turn, the items field will be an empty list."
),
]
status: TurnStatus
class TurnCompletedNotification(BaseModel):
thread_id: Annotated[str, Field(alias="threadId")]
turn: Turn
class UserMessageTurnItem(BaseModel):
content: list[UserInput]
id: str
type: Annotated[UserMessageTurnItemType, Field(title="UserMessageTurnItemType")]
class TurnItem(
RootModel[
UserMessageTurnItem
| AgentMessageTurnItem
| PlanTurnItem
| ReasoningTurnItem
| WebSearchTurnItem
| ImageGenerationTurnItem
| ContextCompactionTurnItem
]
):
root: (
UserMessageTurnItem
| AgentMessageTurnItem
| PlanTurnItem
| ReasoningTurnItem
| WebSearchTurnItem
| ImageGenerationTurnItem
| ContextCompactionTurnItem
)
class TurnPlanStep(BaseModel):
status: TurnPlanStepStatus
step: str
class TurnPlanUpdatedNotification(BaseModel):
explanation: str | None = None
plan: list[TurnPlanStep]
thread_id: Annotated[str, Field(alias="threadId")]
turn_id: Annotated[str, Field(alias="turnId")]
class TurnStartParams(BaseModel):
approval_policy: Annotated[
AskForApproval | None,
Field(
alias="approvalPolicy",
description="Override the approval policy for this turn and subsequent turns.",
),
] = None
cwd: Annotated[
str | None,
Field(
description="Override the working directory for this turn and subsequent turns."
),
] = None
effort: Annotated[
ReasoningEffort | None,
Field(
description="Override the reasoning effort for this turn and subsequent turns."
),
] = None
input: list[UserInput]
model: Annotated[
str | None,
Field(description="Override the model for this turn and subsequent turns."),
] = None
output_schema: Annotated[
Any | None,
Field(
alias="outputSchema",
description="Optional JSON Schema used to constrain the final assistant message for this turn.",
),
] = None
personality: Annotated[
Personality | None,
Field(
description="Override the personality for this turn and subsequent turns."
),
] = None
sandbox_policy: Annotated[
SandboxPolicy | None,
Field(
alias="sandboxPolicy",
description="Override the sandbox policy for this turn and subsequent turns.",
),
] = None
service_tier: Annotated[
ServiceTier | None,
Field(
alias="serviceTier",
description="Override the service tier for this turn and subsequent turns.",
),
] = None
summary: Annotated[
ReasoningSummary | None,
Field(
description="Override the reasoning summary for this turn and subsequent turns."
),
] = None
thread_id: Annotated[str, Field(alias="threadId")]
class TurnStartedNotification(BaseModel):
thread_id: Annotated[str, Field(alias="threadId")]
turn: Turn
class TurnSteerParams(BaseModel):
expected_turn_id: Annotated[
str,
Field(
alias="expectedTurnId",
description="Required active turn id precondition. The request fails when it does not match the currently active turn.",
),
]
input: list[UserInput]
thread_id: Annotated[str, Field(alias="threadId")]
class WindowsSandboxSetupCompletedNotification(BaseModel):
error: str | None = None
mode: WindowsSandboxSetupMode
success: bool
class AccountRateLimitsUpdatedNotification(BaseModel):
rate_limits: Annotated[RateLimitSnapshot, Field(alias="rateLimits")]
class AppInfo(BaseModel):
app_metadata: Annotated[AppMetadata | None, Field(alias="appMetadata")] = None
branding: AppBranding | None = None
description: str | None = None
distribution_channel: Annotated[str | None, Field(alias="distributionChannel")] = (
None
)
id: str
install_url: Annotated[str | None, Field(alias="installUrl")] = None
is_accessible: Annotated[bool | None, Field(alias="isAccessible")] = False
is_enabled: Annotated[
bool | None,
Field(
alias="isEnabled",
description="Whether this app is enabled in config.toml. Example: ```toml [apps.bad_app] enabled = false ```",
),
] = True
labels: dict[str, Any] | None = None
logo_url: Annotated[str | None, Field(alias="logoUrl")] = None
logo_url_dark: Annotated[str | None, Field(alias="logoUrlDark")] = None
name: str
plugin_display_names: Annotated[
list[str] | None, Field(alias="pluginDisplayNames")
] = []
class AppListUpdatedNotification(BaseModel):
data: list[AppInfo]
class ApplyPatchApprovalResponse(BaseModel):
decision: ReviewDecision
class ThreadListClientRequest(BaseModel):
id: RequestId
method: Annotated[
ThreadListClientRequestMethod, Field(title="Thread/listClientRequestMethod")
]
params: ThreadListParams
class TurnStartClientRequest(BaseModel):
id: RequestId
method: Annotated[
TurnStartClientRequestMethod, Field(title="Turn/startClientRequestMethod")
]
params: TurnStartParams
class TurnSteerClientRequest(BaseModel):
id: RequestId
method: Annotated[
TurnSteerClientRequestMethod, Field(title="Turn/steerClientRequestMethod")
]
params: TurnSteerParams
class ReviewStartClientRequest(BaseModel):
id: RequestId
method: Annotated[
ReviewStartClientRequestMethod, Field(title="Review/startClientRequestMethod")
]
params: ReviewStartParams
class CommandExecClientRequest(BaseModel):
id: RequestId
method: Annotated[
CommandExecClientRequestMethod, Field(title="Command/execClientRequestMethod")
]
params: CommandExecParams
class CommandExecResizeClientRequest(BaseModel):
id: RequestId
method: Annotated[
CommandExecResizeClientRequestMethod,
Field(title="Command/exec/resizeClientRequestMethod"),
]
params: CommandExecResizeParams
class ConfigValueWriteClientRequest(BaseModel):
id: RequestId
method: Annotated[
ConfigValueWriteClientRequestMethod,
Field(title="Config/value/writeClientRequestMethod"),
]
params: ConfigValueWriteParams
class ApplyNetworkPolicyAmendment(BaseModel):
network_policy_amendment: NetworkPolicyAmendment
class ApplyNetworkPolicyAmendmentCommandExecutionApprovalDecision(BaseModel):
model_config = ConfigDict(
extra="forbid",
)
apply_network_policy_amendment: Annotated[
ApplyNetworkPolicyAmendment, Field(alias="applyNetworkPolicyAmendment")
]
class CommandExecutionApprovalDecision(
RootModel[
Literal["accept"]
| Literal["acceptForSession"]
| AcceptWithExecpolicyAmendmentCommandExecutionApprovalDecision
| ApplyNetworkPolicyAmendmentCommandExecutionApprovalDecision
| Literal["decline"]
| Literal["cancel"]
]
):
root: (
Literal["accept"]
| Literal["acceptForSession"]
| AcceptWithExecpolicyAmendmentCommandExecutionApprovalDecision
| ApplyNetworkPolicyAmendmentCommandExecutionApprovalDecision
| Literal["decline"]
| Literal["cancel"]
)
class CommandExecutionRequestApprovalParams(BaseModel):
approval_id: Annotated[
str | None,
Field(
alias="approvalId",
description="Unique identifier for this specific approval callback.\n\nFor regular shell/unified_exec approvals, this is null.\n\nFor zsh-exec-bridge subcommand approvals, multiple callbacks can belong to one parent `itemId`, so `approvalId` is a distinct opaque callback id (a UUID) used to disambiguate routing.",
),
] = None
command: Annotated[str | None, Field(description="The command to be executed.")] = (
None
)
command_actions: Annotated[
list[CommandAction] | None,
Field(
alias="commandActions",
description="Best-effort parsed command actions for friendly display.",
),
] = None
cwd: Annotated[
str | None, Field(description="The command's working directory.")
] = None
item_id: Annotated[str, Field(alias="itemId")]
network_approval_context: Annotated[
NetworkApprovalContext | None,
Field(
alias="networkApprovalContext",
description="Optional context for a managed-network approval prompt.",
),
] = None
proposed_execpolicy_amendment: Annotated[
list[str] | None,
Field(
alias="proposedExecpolicyAmendment",
description="Optional proposed execpolicy amendment to allow similar commands without prompting.",
),
] = None
proposed_network_policy_amendments: Annotated[
list[NetworkPolicyAmendment] | None,
Field(
alias="proposedNetworkPolicyAmendments",
description="Optional proposed network policy amendments (allow/deny host) for future requests.",
),
] = None
reason: Annotated[
str | None,
Field(
description="Optional explanatory reason (e.g. request for network access)."
),
] = None
thread_id: Annotated[str, Field(alias="threadId")]
turn_id: Annotated[str, Field(alias="turnId")]
class CommandExecutionRequestApprovalResponse(BaseModel):
decision: CommandExecutionApprovalDecision
class ConfigBatchWriteParams(BaseModel):
edits: list[ConfigEdit]
expected_version: Annotated[str | None, Field(alias="expectedVersion")] = None
file_path: Annotated[
str | None,
Field(
alias="filePath",
description="Path to the config file to write; defaults to the user's `config.toml` when omitted.",
),
] = None
reload_user_config: Annotated[
bool | None,
Field(
alias="reloadUserConfig",
description="When true, hot-reload the updated user config into all loaded threads after writing.",
),
] = None
class RealtimeConversationRealtimeEventMsg(BaseModel):
payload: RealtimeEvent
type: Annotated[
RealtimeConversationRealtimeEventMsgType,
Field(title="RealtimeConversationRealtimeEventMsgType"),
]
class TokenCountEventMsg(BaseModel):
info: TokenUsageInfo | None = None
rate_limits: RateLimitSnapshot | None = None
type: Annotated[TokenCountEventMsgType, Field(title="TokenCountEventMsgType")]
class ExecApprovalRequestEventMsg(BaseModel):
additional_permissions: Annotated[
PermissionProfile | None,
Field(
description="Optional additional filesystem permissions requested for this command."
),
] = None
approval_id: Annotated[
str | None,
Field(
description="Identifier for this specific approval callback.\n\nWhen absent, the approval is for the command item itself (`call_id`). This is present for subcommand approvals (via execve intercept)."
),
] = None
available_decisions: Annotated[
list[ReviewDecision] | None,
Field(
description="Ordered list of decisions the client may present for this prompt.\n\nWhen absent, clients should derive the legacy default set from the other fields on this request."
),
] = None
call_id: Annotated[
str, Field(description="Identifier for the associated command execution item.")
]
command: Annotated[list[str], Field(description="The command to be executed.")]
cwd: Annotated[str, Field(description="The command's working directory.")]
network_approval_context: Annotated[
NetworkApprovalContext | None,
Field(
description="Optional network context for a blocked request that can be approved."
),
] = None
parsed_cmd: list[ParsedCommand]
proposed_execpolicy_amendment: Annotated[
list[str] | None,
Field(
description="Proposed execpolicy amendment that can be applied to allow future runs."
),
] = None
proposed_network_policy_amendments: Annotated[
list[NetworkPolicyAmendment] | None,
Field(
description="Proposed network policy amendments (for example allow/deny this host in future)."
),
] = None
reason: Annotated[
str | None,
Field(
description="Optional human-readable reason for the approval (e.g. retry without sandbox)."
),
] = None
skill_metadata: Annotated[
ExecApprovalRequestSkillMetadata | None,
Field(
description="Optional skill metadata when the approval was triggered by a skill script."
),
] = None
turn_id: Annotated[
str | None,
Field(
description="Turn ID that this command belongs to. Uses `#[serde(default)]` for backwards compatibility."
),
] = ""
type: Annotated[
ExecApprovalRequestEventMsgType, Field(title="ExecApprovalRequestEventMsgType")
]
class RequestUserInputEventMsg(BaseModel):
call_id: Annotated[
str,
Field(
description="Responses API call id for the associated tool call, if available."
),
]
questions: list[RequestUserInputQuestion]
turn_id: Annotated[
str | None,
Field(
description="Turn ID that this request belongs to. Uses `#[serde(default)]` for backwards compatibility."
),
] = ""
type: Annotated[
RequestUserInputEventMsgType, Field(title="RequestUserInputEventMsgType")
]
class ListSkillsResponseEventMsg(BaseModel):
skills: list[SkillsListEntry]
type: Annotated[
ListSkillsResponseEventMsgType, Field(title="ListSkillsResponseEventMsgType")
]
class PlanUpdateEventMsg(BaseModel):
explanation: Annotated[
str | None,
Field(
description="Arguments for the `update_plan` todo/checklist tool (not plan mode)."
),
] = None
plan: list[PlanItemArg]
type: Annotated[PlanUpdateEventMsgType, Field(title="PlanUpdateEventMsgType")]
class ExitedReviewModeEventMsg(BaseModel):
review_output: ReviewOutputEvent | None = None
type: Annotated[
ExitedReviewModeEventMsgType, Field(title="ExitedReviewModeEventMsgType")
]
class ItemStartedEventMsg(BaseModel):
item: TurnItem
thread_id: ThreadId
turn_id: str
type: Annotated[ItemStartedEventMsgType, Field(title="ItemStartedEventMsgType")]
class ItemCompletedEventMsg(BaseModel):
item: TurnItem
thread_id: ThreadId
turn_id: str
type: Annotated[ItemCompletedEventMsgType, Field(title="ItemCompletedEventMsgType")]
class ExecCommandApprovalResponse(BaseModel):
decision: ReviewDecision
class ExternalAgentConfigImportParams(BaseModel):
migration_items: Annotated[
list[ExternalAgentConfigMigrationItem], Field(alias="migrationItems")
]
class FunctionCallOutputBody(RootModel[str | list[FunctionCallOutputContentItem]]):
root: str | list[FunctionCallOutputContentItem]
class FunctionCallOutputPayload(BaseModel):
body: FunctionCallOutputBody
success: bool | None = None
class ItemCompletedNotification(BaseModel):
item: ThreadItem
thread_id: Annotated[str, Field(alias="threadId")]
turn_id: Annotated[str, Field(alias="turnId")]
class ItemStartedNotification(BaseModel):
item: ThreadItem
thread_id: Annotated[str, Field(alias="threadId")]
turn_id: Annotated[str, Field(alias="turnId")]
class JSONRPCMessage(
RootModel[JSONRPCRequest | JSONRPCNotification | JSONRPCResponse | JSONRPCError]
):
root: Annotated[
JSONRPCRequest | JSONRPCNotification | JSONRPCResponse | JSONRPCError,
Field(
description="Refers to any valid JSON-RPC object that can be decoded off the wire, or encoded to be sent.",
title="JSONRPCMessage",
),
]
class McpElicitationEnumSchema(
RootModel[
McpElicitationSingleSelectEnumSchema
| McpElicitationMultiSelectEnumSchema
| McpElicitationLegacyTitledEnumSchema
]
):
root: (
McpElicitationSingleSelectEnumSchema
| McpElicitationMultiSelectEnumSchema
| McpElicitationLegacyTitledEnumSchema
)
class McpElicitationPrimitiveSchema(
RootModel[
McpElicitationEnumSchema
| McpElicitationStringSchema
| McpElicitationNumberSchema
| McpElicitationBooleanSchema
]
):
root: (
McpElicitationEnumSchema
| McpElicitationStringSchema
| McpElicitationNumberSchema
| McpElicitationBooleanSchema
)
class McpElicitationSchema(BaseModel):
model_config = ConfigDict(
extra="forbid",
)
field_schema: Annotated[str | None, Field(alias="$schema")] = None
properties: dict[str, McpElicitationPrimitiveSchema]
required: list[str] | None = None
type: McpElicitationObjectType
class McpServerElicitationRequestParams1(BaseModel):
server_name: Annotated[str, Field(alias="serverName")]
thread_id: Annotated[str, Field(alias="threadId")]
turn_id: Annotated[
str | None,
Field(
alias="turnId",
description="Active Codex turn when this elicitation was observed, if app-server could correlate one.\n\nThis is nullable because MCP models elicitation as a standalone server-to-client request identified by the MCP server request id. It may be triggered during a turn, but turn context is app-server correlation rather than part of the protocol identity of the elicitation itself.",
),
] = None
field_meta: Annotated[Any | None, Field(alias="_meta")] = None
message: str
mode: Literal["form"]
requested_schema: Annotated[McpElicitationSchema, Field(alias="requestedSchema")]
class McpServerElicitationRequestParams(
RootModel[McpServerElicitationRequestParams1 | McpServerElicitationRequestParams2]
):
root: Annotated[
McpServerElicitationRequestParams1 | McpServerElicitationRequestParams2,
Field(title="McpServerElicitationRequestParams"),
]
class FunctionCallOutputResponseItem(BaseModel):
call_id: str
output: FunctionCallOutputPayload
type: Annotated[
FunctionCallOutputResponseItemType,
Field(title="FunctionCallOutputResponseItemType"),
]
class CustomToolCallOutputResponseItem(BaseModel):
call_id: str
output: FunctionCallOutputPayload
type: Annotated[
CustomToolCallOutputResponseItemType,
Field(title="CustomToolCallOutputResponseItemType"),
]
class ResponseItem(
RootModel[
MessageResponseItem
| ReasoningResponseItem
| LocalShellCallResponseItem
| FunctionCallResponseItem
| FunctionCallOutputResponseItem
| CustomToolCallResponseItem
| CustomToolCallOutputResponseItem
| WebSearchCallResponseItem
| ImageGenerationCallResponseItem
| GhostSnapshotResponseItem
| CompactionResponseItem
| OtherResponseItem
]
):
root: (
MessageResponseItem
| ReasoningResponseItem
| LocalShellCallResponseItem
| FunctionCallResponseItem
| FunctionCallOutputResponseItem
| CustomToolCallResponseItem
| CustomToolCallOutputResponseItem
| WebSearchCallResponseItem
| ImageGenerationCallResponseItem
| GhostSnapshotResponseItem
| CompactionResponseItem
| OtherResponseItem
)
class ThreadTokenUsageUpdatedServerNotification(BaseModel):
method: Annotated[
ThreadTokenUsageUpdatedServerNotificationMethod,
Field(title="Thread/tokenUsage/updatedServerNotificationMethod"),
]
params: ThreadTokenUsageUpdatedNotification
class TurnStartedServerNotification(BaseModel):
method: Annotated[
TurnStartedServerNotificationMethod,
Field(title="Turn/startedServerNotificationMethod"),
]
params: TurnStartedNotification
class TurnCompletedServerNotification(BaseModel):
method: Annotated[
TurnCompletedServerNotificationMethod,
Field(title="Turn/completedServerNotificationMethod"),
]
params: TurnCompletedNotification
class TurnPlanUpdatedServerNotification(BaseModel):
method: Annotated[
TurnPlanUpdatedServerNotificationMethod,
Field(title="Turn/plan/updatedServerNotificationMethod"),
]
params: TurnPlanUpdatedNotification
class ItemStartedServerNotification(BaseModel):
method: Annotated[
ItemStartedServerNotificationMethod,
Field(title="Item/startedServerNotificationMethod"),
]
params: ItemStartedNotification
class ItemCompletedServerNotification(BaseModel):
method: Annotated[
ItemCompletedServerNotificationMethod,
Field(title="Item/completedServerNotificationMethod"),
]
params: ItemCompletedNotification
class AccountRateLimitsUpdatedServerNotification(BaseModel):
method: Annotated[
AccountRateLimitsUpdatedServerNotificationMethod,
Field(title="Account/rateLimits/updatedServerNotificationMethod"),
]
params: AccountRateLimitsUpdatedNotification
class AppListUpdatedServerNotification(BaseModel):
method: Annotated[
AppListUpdatedServerNotificationMethod,
Field(title="App/list/updatedServerNotificationMethod"),
]
params: AppListUpdatedNotification
class WindowsSandboxSetupCompletedServerNotification(BaseModel):
method: Annotated[
WindowsSandboxSetupCompletedServerNotificationMethod,
Field(title="WindowsSandbox/setupCompletedServerNotificationMethod"),
]
params: WindowsSandboxSetupCompletedNotification
class ItemCommandExecutionRequestApprovalServerRequest(BaseModel):
id: RequestId
method: Annotated[
ItemCommandExecutionRequestApprovalServerRequestMethod,
Field(title="Item/commandExecution/requestApprovalServerRequestMethod"),
]
params: CommandExecutionRequestApprovalParams
class ItemToolRequestUserInputServerRequest(BaseModel):
id: RequestId
method: Annotated[
ItemToolRequestUserInputServerRequestMethod,
Field(title="Item/tool/requestUserInputServerRequestMethod"),
]
params: ToolRequestUserInputParams
class McpServerElicitationRequestServerRequest(BaseModel):
id: RequestId
method: Annotated[
McpServerElicitationRequestServerRequestMethod,
Field(title="McpServer/elicitation/requestServerRequestMethod"),
]
params: McpServerElicitationRequestParams
class ServerRequest(
RootModel[
ItemCommandExecutionRequestApprovalServerRequest
| ItemFileChangeRequestApprovalServerRequest
| ItemToolRequestUserInputServerRequest
| McpServerElicitationRequestServerRequest
| ItemPermissionsRequestApprovalServerRequest
| ItemToolCallServerRequest
| AccountChatgptAuthTokensRefreshServerRequest
| ApplyPatchApprovalServerRequest
| ExecCommandApprovalServerRequest
]
):
root: Annotated[
ItemCommandExecutionRequestApprovalServerRequest
| ItemFileChangeRequestApprovalServerRequest
| ItemToolRequestUserInputServerRequest
| McpServerElicitationRequestServerRequest
| ItemPermissionsRequestApprovalServerRequest
| ItemToolCallServerRequest
| AccountChatgptAuthTokensRefreshServerRequest
| ApplyPatchApprovalServerRequest
| ExecCommandApprovalServerRequest,
Field(
description="Request initiated from the server and sent to the client.",
title="ServerRequest",
),
]
class SubAgentSessionSource(BaseModel):
model_config = ConfigDict(
extra="forbid",
)
sub_agent: Annotated[SubAgentSource, Field(alias="subAgent")]
class SessionSource(RootModel[SessionSource1 | SubAgentSessionSource]):
root: SessionSource1 | SubAgentSessionSource
class Thread(BaseModel):
agent_nickname: Annotated[
str | None,
Field(
alias="agentNickname",
description="Optional random unique nickname assigned to an AgentControl-spawned sub-agent.",
),
] = None
agent_role: Annotated[
str | None,
Field(
alias="agentRole",
description="Optional role (agent_role) assigned to an AgentControl-spawned sub-agent.",
),
] = None
cli_version: Annotated[
str,
Field(
alias="cliVersion",
description="Version of the CLI that created the thread.",
),
]
created_at: Annotated[
int,
Field(
alias="createdAt",
description="Unix timestamp (in seconds) when the thread was created.",
),
]
cwd: Annotated[str, Field(description="Working directory captured for the thread.")]
ephemeral: Annotated[
bool,
Field(
description="Whether the thread is ephemeral and should not be materialized on disk."
),
]
git_info: Annotated[
GitInfo | None,
Field(
alias="gitInfo",
description="Optional Git metadata captured when the thread was created.",
),
] = None
id: str
model_provider: Annotated[
str,
Field(
alias="modelProvider",
description="Model provider used for this thread (for example, 'openai').",
),
]
name: Annotated[
str | None, Field(description="Optional user-facing thread title.")
] = None
path: Annotated[
str | None, Field(description="[UNSTABLE] Path to the thread on disk.")
] = None
preview: Annotated[
str,
Field(
description="Usually the first user message in the thread, if available."
),
]
source: Annotated[
SessionSource,
Field(
description="Origin of the thread (CLI, VSCode, codex exec, codex app-server, etc.)."
),
]
status: Annotated[
ThreadStatus, Field(description="Current runtime status for the thread.")
]
turns: Annotated[
list[Turn],
Field(
description="Only populated on `thread/resume`, `thread/rollback`, `thread/fork`, and `thread/read` (when `includeTurns` is true) responses. For all other responses and notifications returning a Thread, the turns field will be an empty list."
),
]
updated_at: Annotated[
int,
Field(
alias="updatedAt",
description="Unix timestamp (in seconds) when the thread was last updated.",
),
]
class ThreadStartedNotification(BaseModel):
thread: Thread
class ExternalAgentConfigImportClientRequest(BaseModel):
id: RequestId
method: Annotated[
ExternalAgentConfigImportClientRequestMethod,
Field(title="ExternalAgentConfig/importClientRequestMethod"),
]
params: ExternalAgentConfigImportParams
class ConfigBatchWriteClientRequest(BaseModel):
id: RequestId
method: Annotated[
ConfigBatchWriteClientRequestMethod,
Field(title="Config/batchWriteClientRequestMethod"),
]
params: ConfigBatchWriteParams
class ClientRequest(
RootModel[
InitializeClientRequest
| ThreadStartClientRequest
| ThreadResumeClientRequest
| ThreadForkClientRequest
| ThreadArchiveClientRequest
| ThreadUnsubscribeClientRequest
| ThreadNameSetClientRequest
| ThreadMetadataUpdateClientRequest
| ThreadUnarchiveClientRequest
| ThreadCompactStartClientRequest
| ThreadRollbackClientRequest
| ThreadListClientRequest
| ThreadLoadedListClientRequest
| ThreadReadClientRequest
| SkillsListClientRequest
| PluginListClientRequest
| SkillsRemoteListClientRequest
| SkillsRemoteExportClientRequest
| AppListClientRequest
| SkillsConfigWriteClientRequest
| PluginInstallClientRequest
| PluginUninstallClientRequest
| TurnStartClientRequest
| TurnSteerClientRequest
| TurnInterruptClientRequest
| ReviewStartClientRequest
| ModelListClientRequest
| ExperimentalFeatureListClientRequest
| McpServerOauthLoginClientRequest
| ConfigMcpServerReloadClientRequest
| McpServerStatusListClientRequest
| WindowsSandboxSetupStartClientRequest
| AccountLoginStartClientRequest
| AccountLoginCancelClientRequest
| AccountLogoutClientRequest
| AccountRateLimitsReadClientRequest
| FeedbackUploadClientRequest
| CommandExecClientRequest
| CommandExecWriteClientRequest
| CommandExecTerminateClientRequest
| CommandExecResizeClientRequest
| ConfigReadClientRequest
| ExternalAgentConfigDetectClientRequest
| ExternalAgentConfigImportClientRequest
| ConfigValueWriteClientRequest
| ConfigBatchWriteClientRequest
| ConfigRequirementsReadClientRequest
| AccountReadClientRequest
| FuzzyFileSearchClientRequest
]
):
root: Annotated[
InitializeClientRequest
| ThreadStartClientRequest
| ThreadResumeClientRequest
| ThreadForkClientRequest
| ThreadArchiveClientRequest
| ThreadUnsubscribeClientRequest
| ThreadNameSetClientRequest
| ThreadMetadataUpdateClientRequest
| ThreadUnarchiveClientRequest
| ThreadCompactStartClientRequest
| ThreadRollbackClientRequest
| ThreadListClientRequest
| ThreadLoadedListClientRequest
| ThreadReadClientRequest
| SkillsListClientRequest
| PluginListClientRequest
| SkillsRemoteListClientRequest
| SkillsRemoteExportClientRequest
| AppListClientRequest
| SkillsConfigWriteClientRequest
| PluginInstallClientRequest
| PluginUninstallClientRequest
| TurnStartClientRequest
| TurnSteerClientRequest
| TurnInterruptClientRequest
| ReviewStartClientRequest
| ModelListClientRequest
| ExperimentalFeatureListClientRequest
| McpServerOauthLoginClientRequest
| ConfigMcpServerReloadClientRequest
| McpServerStatusListClientRequest
| WindowsSandboxSetupStartClientRequest
| AccountLoginStartClientRequest
| AccountLoginCancelClientRequest
| AccountLogoutClientRequest
| AccountRateLimitsReadClientRequest
| FeedbackUploadClientRequest
| CommandExecClientRequest
| CommandExecWriteClientRequest
| CommandExecTerminateClientRequest
| CommandExecResizeClientRequest
| ConfigReadClientRequest
| ExternalAgentConfigDetectClientRequest
| ExternalAgentConfigImportClientRequest
| ConfigValueWriteClientRequest
| ConfigBatchWriteClientRequest
| ConfigRequirementsReadClientRequest
| AccountReadClientRequest
| FuzzyFileSearchClientRequest,
Field(
description="Request from the client to the server.", title="ClientRequest"
),
]
class RawResponseItemEventMsg(BaseModel):
item: ResponseItem
type: Annotated[
RawResponseItemEventMsgType, Field(title="RawResponseItemEventMsgType")
]
class ThreadStartedServerNotification(BaseModel):
method: Annotated[
ThreadStartedServerNotificationMethod,
Field(title="Thread/startedServerNotificationMethod"),
]
params: ThreadStartedNotification
class ServerNotification(
RootModel[
ErrorServerNotification
| ThreadStartedServerNotification
| ThreadStatusChangedServerNotification
| ThreadArchivedServerNotification
| ThreadUnarchivedServerNotification
| ThreadClosedServerNotification
| SkillsChangedServerNotification
| ThreadNameUpdatedServerNotification
| ThreadTokenUsageUpdatedServerNotification
| TurnStartedServerNotification
| TurnCompletedServerNotification
| TurnDiffUpdatedServerNotification
| TurnPlanUpdatedServerNotification
| ItemStartedServerNotification
| ItemCompletedServerNotification
| ItemAgentMessageDeltaServerNotification
| ItemPlanDeltaServerNotification
| CommandExecOutputDeltaServerNotification
| ItemCommandExecutionOutputDeltaServerNotification
| ItemCommandExecutionTerminalInteractionServerNotification
| ItemFileChangeOutputDeltaServerNotification
| ServerRequestResolvedServerNotification
| ItemMcpToolCallProgressServerNotification
| McpServerOauthLoginCompletedServerNotification
| AccountUpdatedServerNotification
| AccountRateLimitsUpdatedServerNotification
| AppListUpdatedServerNotification
| ItemReasoningSummaryTextDeltaServerNotification
| ItemReasoningSummaryPartAddedServerNotification
| ItemReasoningTextDeltaServerNotification
| ThreadCompactedServerNotification
| ModelReroutedServerNotification
| DeprecationNoticeServerNotification
| ConfigWarningServerNotification
| FuzzyFileSearchSessionUpdatedServerNotification
| FuzzyFileSearchSessionCompletedServerNotification
| ThreadRealtimeStartedServerNotification
| ThreadRealtimeItemAddedServerNotification
| ThreadRealtimeOutputAudioDeltaServerNotification
| ThreadRealtimeErrorServerNotification
| ThreadRealtimeClosedServerNotification
| WindowsWorldWritableWarningServerNotification
| WindowsSandboxSetupCompletedServerNotification
| AccountLoginCompletedServerNotification
]
):
root: Annotated[
ErrorServerNotification
| ThreadStartedServerNotification
| ThreadStatusChangedServerNotification
| ThreadArchivedServerNotification
| ThreadUnarchivedServerNotification
| ThreadClosedServerNotification
| SkillsChangedServerNotification
| ThreadNameUpdatedServerNotification
| ThreadTokenUsageUpdatedServerNotification
| TurnStartedServerNotification
| TurnCompletedServerNotification
| TurnDiffUpdatedServerNotification
| TurnPlanUpdatedServerNotification
| ItemStartedServerNotification
| ItemCompletedServerNotification
| ItemAgentMessageDeltaServerNotification
| ItemPlanDeltaServerNotification
| CommandExecOutputDeltaServerNotification
| ItemCommandExecutionOutputDeltaServerNotification
| ItemCommandExecutionTerminalInteractionServerNotification
| ItemFileChangeOutputDeltaServerNotification
| ServerRequestResolvedServerNotification
| ItemMcpToolCallProgressServerNotification
| McpServerOauthLoginCompletedServerNotification
| AccountUpdatedServerNotification
| AccountRateLimitsUpdatedServerNotification
| AppListUpdatedServerNotification
| ItemReasoningSummaryTextDeltaServerNotification
| ItemReasoningSummaryPartAddedServerNotification
| ItemReasoningTextDeltaServerNotification
| ThreadCompactedServerNotification
| ModelReroutedServerNotification
| DeprecationNoticeServerNotification
| ConfigWarningServerNotification
| FuzzyFileSearchSessionUpdatedServerNotification
| FuzzyFileSearchSessionCompletedServerNotification
| ThreadRealtimeStartedServerNotification
| ThreadRealtimeItemAddedServerNotification
| ThreadRealtimeOutputAudioDeltaServerNotification
| ThreadRealtimeErrorServerNotification
| ThreadRealtimeClosedServerNotification
| WindowsWorldWritableWarningServerNotification
| WindowsSandboxSetupCompletedServerNotification
| AccountLoginCompletedServerNotification,
Field(
description="Notification sent from the server to the client.",
title="ServerNotification",
),
]
class SessionConfiguredEventMsg(BaseModel):
approval_policy: Annotated[
AskForApproval, Field(description="When to escalate for approval for execution")
]
cwd: Annotated[
str,
Field(
description="Working directory that should be treated as the *root* of the session."
),
]
forked_from_id: ThreadId | None = None
history_entry_count: Annotated[
int, Field(description="Current number of entries in the history log.", ge=0)
]
history_log_id: Annotated[
int,
Field(
description="Identifier of the history log file (inode on Unix, 0 otherwise).",
ge=0,
le=18446744073709551615,
),
]
initial_messages: Annotated[
list[EventMsg] | None,
Field(
description="Optional initial messages (as events) for resumed sessions. When present, UIs can use these to seed the history."
),
] = None
model: Annotated[
str, Field(description="Tell the client what model is being queried.")
]
model_provider_id: str
network_proxy: Annotated[
SessionNetworkProxyRuntime | None,
Field(
description="Runtime proxy bind addresses, when the managed proxy was started for this session."
),
] = None
reasoning_effort: Annotated[
ReasoningEffort | None,
Field(
description="The effort the model is putting into reasoning about the user's request."
),
] = None
rollout_path: Annotated[
str | None,
Field(
description="Path in which the rollout is stored. Can be `None` for ephemeral threads"
),
] = None
sandbox_policy: Annotated[
SandboxPolicy,
Field(description="How to sandbox commands executed in the system"),
]
service_tier: ServiceTier | None = None
session_id: ThreadId
thread_name: Annotated[
str | None,
Field(description="Optional user-facing thread name (may be unset)."),
] = None
type: Annotated[
SessionConfiguredEventMsgType, Field(title="SessionConfiguredEventMsgType")
]
class EventMsg(
RootModel[
ErrorEventMsg
| WarningEventMsg
| RealtimeConversationStartedEventMsg
| RealtimeConversationRealtimeEventMsg
| RealtimeConversationClosedEventMsg
| ModelRerouteEventMsg
| ContextCompactedEventMsg
| ThreadRolledBackEventMsg
| TaskStartedEventMsg
| TaskCompleteEventMsg
| TokenCountEventMsg
| AgentMessageEventMsg
| UserMessageEventMsg
| AgentMessageDeltaEventMsg
| AgentReasoningEventMsg
| AgentReasoningDeltaEventMsg
| AgentReasoningRawContentEventMsg
| AgentReasoningRawContentDeltaEventMsg
| AgentReasoningSectionBreakEventMsg
| SessionConfiguredEventMsg
| ThreadNameUpdatedEventMsg
| McpStartupUpdateEventMsg
| McpStartupCompleteEventMsg
| McpToolCallBeginEventMsg
| McpToolCallEndEventMsg
| WebSearchBeginEventMsg
| WebSearchEndEventMsg
| ImageGenerationBeginEventMsg
| ImageGenerationEndEventMsg
| ExecCommandBeginEventMsg
| ExecCommandOutputDeltaEventMsg
| TerminalInteractionEventMsg
| ExecCommandEndEventMsg
| ViewImageToolCallEventMsg
| ExecApprovalRequestEventMsg
| RequestPermissionsEventMsg
| RequestUserInputEventMsg
| DynamicToolCallRequestEventMsg
| DynamicToolCallResponseEventMsg
| ElicitationRequestEventMsg
| ApplyPatchApprovalRequestEventMsg
| DeprecationNoticeEventMsg
| BackgroundEventEventMsg
| UndoStartedEventMsg
| UndoCompletedEventMsg
| StreamErrorEventMsg
| PatchApplyBeginEventMsg
| PatchApplyEndEventMsg
| TurnDiffEventMsg
| GetHistoryEntryResponseEventMsg
| McpListToolsResponseEventMsg
| ListCustomPromptsResponseEventMsg
| ListSkillsResponseEventMsg
| ListRemoteSkillsResponseEventMsg
| RemoteSkillDownloadedEventMsg
| SkillsUpdateAvailableEventMsg
| PlanUpdateEventMsg
| TurnAbortedEventMsg
| ShutdownCompleteEventMsg
| EnteredReviewModeEventMsg
| ExitedReviewModeEventMsg
| RawResponseItemEventMsg
| ItemStartedEventMsg
| ItemCompletedEventMsg
| AgentMessageContentDeltaEventMsg
| PlanDeltaEventMsg
| ReasoningContentDeltaEventMsg
| ReasoningRawContentDeltaEventMsg
| CollabAgentSpawnBeginEventMsg
| CollabAgentSpawnEndEventMsg
| CollabAgentInteractionBeginEventMsg
| CollabAgentInteractionEndEventMsg
| CollabWaitingBeginEventMsg
| CollabWaitingEndEventMsg
| CollabCloseBeginEventMsg
| CollabCloseEndEventMsg
| CollabResumeBeginEventMsg
| CollabResumeEndEventMsg
]
):
root: Annotated[
ErrorEventMsg
| WarningEventMsg
| RealtimeConversationStartedEventMsg
| RealtimeConversationRealtimeEventMsg
| RealtimeConversationClosedEventMsg
| ModelRerouteEventMsg
| ContextCompactedEventMsg
| ThreadRolledBackEventMsg
| TaskStartedEventMsg
| TaskCompleteEventMsg
| TokenCountEventMsg
| AgentMessageEventMsg
| UserMessageEventMsg
| AgentMessageDeltaEventMsg
| AgentReasoningEventMsg
| AgentReasoningDeltaEventMsg
| AgentReasoningRawContentEventMsg
| AgentReasoningRawContentDeltaEventMsg
| AgentReasoningSectionBreakEventMsg
| SessionConfiguredEventMsg
| ThreadNameUpdatedEventMsg
| McpStartupUpdateEventMsg
| McpStartupCompleteEventMsg
| McpToolCallBeginEventMsg
| McpToolCallEndEventMsg
| WebSearchBeginEventMsg
| WebSearchEndEventMsg
| ImageGenerationBeginEventMsg
| ImageGenerationEndEventMsg
| ExecCommandBeginEventMsg
| ExecCommandOutputDeltaEventMsg
| TerminalInteractionEventMsg
| ExecCommandEndEventMsg
| ViewImageToolCallEventMsg
| ExecApprovalRequestEventMsg
| RequestPermissionsEventMsg
| RequestUserInputEventMsg
| DynamicToolCallRequestEventMsg
| DynamicToolCallResponseEventMsg
| ElicitationRequestEventMsg
| ApplyPatchApprovalRequestEventMsg
| DeprecationNoticeEventMsg
| BackgroundEventEventMsg
| UndoStartedEventMsg
| UndoCompletedEventMsg
| StreamErrorEventMsg
| PatchApplyBeginEventMsg
| PatchApplyEndEventMsg
| TurnDiffEventMsg
| GetHistoryEntryResponseEventMsg
| McpListToolsResponseEventMsg
| ListCustomPromptsResponseEventMsg
| ListSkillsResponseEventMsg
| ListRemoteSkillsResponseEventMsg
| RemoteSkillDownloadedEventMsg
| SkillsUpdateAvailableEventMsg
| PlanUpdateEventMsg
| TurnAbortedEventMsg
| ShutdownCompleteEventMsg
| EnteredReviewModeEventMsg
| ExitedReviewModeEventMsg
| RawResponseItemEventMsg
| ItemStartedEventMsg
| ItemCompletedEventMsg
| AgentMessageContentDeltaEventMsg
| PlanDeltaEventMsg
| ReasoningContentDeltaEventMsg
| ReasoningRawContentDeltaEventMsg
| CollabAgentSpawnBeginEventMsg
| CollabAgentSpawnEndEventMsg
| CollabAgentInteractionBeginEventMsg
| CollabAgentInteractionEndEventMsg
| CollabWaitingBeginEventMsg
| CollabWaitingEndEventMsg
| CollabCloseBeginEventMsg
| CollabCloseEndEventMsg
| CollabResumeBeginEventMsg
| CollabResumeEndEventMsg,
Field(
description="Response event from the agent NOTE: Make sure none of these values have optional types, as it will mess up the extension code-gen.",
title="EventMsg",
),
]
SessionConfiguredEventMsg.model_rebuild()
Reference in New Issue View Git Blame Copy Permalink