protocol

package
v0.20.0 Latest Latest
Warning

This package is not in the latest version of its module.

Go to latest
Published: Sep 15, 2026 License: AGPL-3.0 Imports: 6 Imported by: 0

Documentation

Overview

Package protocol implements the wire contract Memoh speaks with the codex app-server: JSON-RPC 2.0 semantics over newline-delimited JSON on stdio, with the `jsonrpc` version field omitted, as the app-server does.

The typed protocol surface (*.gen.go) is generated from the vendored JSON Schema snapshot by cmd/gen-codex-protocol; this file holds the version-independent core: envelopes, request ids, inbound classification, and the union runtime helpers the generated code relies on.

Decoding is deliberately tolerant: unknown methods, notification kinds, and union variants never fail — they surface with their raw bytes retained — so a pinned CLI upgrade can only add information, not break the stream.

Index

Constants

View Source
const (
	MethodInitialize            = "initialize"
	MethodThreadStart           = "thread/start"
	MethodThreadResume          = "thread/resume"
	MethodThreadSettingsUpdate  = "thread/settings/update"
	MethodThreadFork            = "thread/fork"
	MethodThreadRead            = "thread/read"
	MethodThreadGoalSet         = "thread/goal/set"
	MethodThreadGoalGet         = "thread/goal/get"
	MethodThreadGoalClear       = "thread/goal/clear"
	MethodThreadCompactStart    = "thread/compact/start"
	MethodReviewStart           = "review/start"
	MethodSkillsList            = "skills/list"
	MethodMCPServerStatusList   = "mcpServerStatus/list"
	MethodTurnStart             = "turn/start"
	MethodTurnSteer             = "turn/steer"
	MethodTurnInterrupt         = "turn/interrupt"
	MethodModelList             = "model/list"
	MethodAccountRead           = "account/read"
	MethodAccountRateLimitsRead = "account/rateLimits/read"
	MethodAccountLoginStart     = "account/login/start"
	MethodAccountLoginCancel    = "account/login/cancel"
	MethodAccountLogout         = "account/logout"
)

Client request methods (Memoh → app-server).

View Source
const (
	MethodItemCommandExecutionRequestApproval = "item/commandExecution/requestApproval"
	MethodItemFileChangeRequestApproval       = "item/fileChange/requestApproval"
	MethodItemPermissionsRequestApproval      = "item/permissions/requestApproval"
	MethodItemToolRequestUserInput            = "item/tool/requestUserInput"
	MethodMCPServerElicitationRequest         = "mcpServer/elicitation/request"
	MethodAccountChatgptAuthTokensRefresh     = "account/chatgptAuthTokens/refresh"
)

Server request methods (app-server → Memoh, expect a response).

View Source
const (
	MethodError                           = "error"
	MethodWarning                         = "warning"
	MethodConfigWarning                   = "configWarning"
	MethodDeprecationNotice               = "deprecationNotice"
	MethodThreadStarted                   = "thread/started"
	MethodThreadStatusChanged             = "thread/status/changed"
	MethodThreadTokenUsageUpdated         = "thread/tokenUsage/updated"
	MethodThreadCompacted                 = "thread/compacted"
	MethodThreadGoalUpdated               = "thread/goal/updated"
	MethodThreadGoalCleared               = "thread/goal/cleared"
	MethodTurnStarted                     = "turn/started"
	MethodTurnCompleted                   = "turn/completed"
	MethodTurnPlanUpdated                 = "turn/plan/updated"
	MethodItemStarted                     = "item/started"
	MethodItemCompleted                   = "item/completed"
	MethodItemAgentMessageDelta           = "item/agentMessage/delta"
	MethodItemReasoningTextDelta          = "item/reasoning/textDelta"
	MethodItemReasoningSummaryTextDelta   = "item/reasoning/summaryTextDelta"
	MethodItemReasoningSummaryPartAdded   = "item/reasoning/summaryPartAdded"
	MethodItemCommandExecutionOutputDelta = "item/commandExecution/outputDelta"
	MethodItemFileChangeOutputDelta       = "item/fileChange/outputDelta"
	MethodAccountUpdated                  = "account/updated"
	MethodAccountLoginCompleted           = "account/login/completed"
	MethodAccountRateLimitsUpdated        = "account/rateLimits/updated"
	MethodServerRequestResolved           = "serverRequest/resolved"
)

Server notification methods decoded into typed params.

View Source
const (
	AccountTagAmazonBedrock = "amazonBedrock"
	AccountTagAPIKey        = "apiKey"
	AccountTagChatgpt       = "chatgpt"
)
View Source
const (
	AgentMessageInputContentTagEncryptedContent = "encrypted_content"
	AgentMessageInputContentTagInputText        = "input_text"
)
View Source
const (
	AskForApprovalUnitNever     = "never"
	AskForApprovalUnitOnRequest = "on-request"
	AskForApprovalUnitUntrusted = "untrusted"
)
View Source
const (
	CodexErrorInfoUnitBadRequest                  = "badRequest"
	CodexErrorInfoUnitContextWindowExceeded       = "contextWindowExceeded"
	CodexErrorInfoUnitCyberPolicy                 = "cyberPolicy"
	CodexErrorInfoUnitInternalServerError         = "internalServerError"
	CodexErrorInfoUnitMisalignmentPolicyViolation = "misalignmentPolicyViolation"
	CodexErrorInfoUnitOther                       = "other"
	CodexErrorInfoUnitRateLimitExceeded           = "rateLimitExceeded"
	CodexErrorInfoUnitSandboxError                = "sandboxError"
	CodexErrorInfoUnitServerOverloaded            = "serverOverloaded"
	CodexErrorInfoUnitSessionBudgetExceeded       = "sessionBudgetExceeded"
	CodexErrorInfoUnitThreadRollbackFailed        = "threadRollbackFailed"
	CodexErrorInfoUnitUnauthorized                = "unauthorized"
	CodexErrorInfoUnitUsageLimitExceeded          = "usageLimitExceeded"
)
View Source
const (
	CommandActionTagListFiles = "listFiles"
	CommandActionTagRead      = "read"
	CommandActionTagSearch    = "search"
	CommandActionTagUnknown   = "unknown"
)
View Source
const (
	CommandExecutionApprovalDecisionUnitAccept           = "accept"
	CommandExecutionApprovalDecisionUnitAcceptForSession = "acceptForSession"
	CommandExecutionApprovalDecisionUnitCancel           = "cancel"
	CommandExecutionApprovalDecisionUnitDecline          = "decline"
)
View Source
const (
	ContentItemTagInputAudio = "input_audio"
	ContentItemTagInputImage = "input_image"
	ContentItemTagInputText  = "input_text"
	ContentItemTagOutputText = "output_text"
)
View Source
const (
	DynamicToolCallOutputContentItemTagInputAudio = "inputAudio"
	DynamicToolCallOutputContentItemTagInputImage = "inputImage"
	DynamicToolCallOutputContentItemTagInputText  = "inputText"
)
View Source
const (
	DynamicToolSpecTagFunction  = "function"
	DynamicToolSpecTagNamespace = "namespace"
)
View Source
const (
	FileSystemPathTagGlobPattern = "glob_pattern"
	FileSystemPathTagPath        = "path"
	FileSystemPathTagSpecial     = "special"
)
View Source
const (
	FileSystemSpecialPathTagMinimal      = "minimal"
	FileSystemSpecialPathTagProjectRoots = "project_roots"
	FileSystemSpecialPathTagRoot         = "root"
	FileSystemSpecialPathTagSlashTmp     = "slash_tmp"
	FileSystemSpecialPathTagTmpdir       = "tmpdir"
	FileSystemSpecialPathTagUnknown      = "unknown"
)
View Source
const (
	FunctionCallOutputContentItemTagEncryptedContent = "encrypted_content"
	FunctionCallOutputContentItemTagInputAudio       = "input_audio"
	FunctionCallOutputContentItemTagInputImage       = "input_image"
	FunctionCallOutputContentItemTagInputText        = "input_text"
)
View Source
const (
	LoginAccountParamsTagAmazonBedrock           = "amazonBedrock"
	LoginAccountParamsTagAmazonBedrockAccessKeys = "amazonBedrockAccessKeys"
	LoginAccountParamsTagAPIKey                  = "apiKey"
	LoginAccountParamsTagChatgpt                 = "chatgpt"
	LoginAccountParamsTagChatgptAuthTokens       = "chatgptAuthTokens"
	LoginAccountParamsTagChatgptDeviceCode       = "chatgptDeviceCode"
)
View Source
const (
	LoginAccountResponseTagAmazonBedrock     = "amazonBedrock"
	LoginAccountResponseTagAPIKey            = "apiKey"
	LoginAccountResponseTagChatgpt           = "chatgpt"
	LoginAccountResponseTagChatgptAuthTokens = "chatgptAuthTokens"
	LoginAccountResponseTagChatgptDeviceCode = "chatgptDeviceCode"
)
View Source
const (
	McpServerElicitationRequestParamsTagForm                   = "form"
	McpServerElicitationRequestParamsTagOpenaiForm             = "openai/form"
	McpServerElicitationRequestParamsTagOpenaiUserVerification = "openai/userVerification"
	McpServerElicitationRequestParamsTagOpenaiFormCamelCase    = "openaiForm"
	McpServerElicitationRequestParamsTagURL                    = "url"
)
View Source
const (
	MultiAgentModeUnitExplicitRequestOnly = "explicitRequestOnly"
	MultiAgentModeUnitProactive           = "proactive"
)
View Source
const (
	PatchChangeKindTagAdd    = "add"
	PatchChangeKindTagDelete = "delete"
	PatchChangeKindTagUpdate = "update"
)
View Source
const (
	ReasoningItemContentTagReasoningText = "reasoning_text"
	ReasoningItemContentTagText          = "text"
)
View Source
const (
	ResponseItemTagAgentMessage         = "agent_message"
	ResponseItemTagCompaction           = "compaction"
	ResponseItemTagCompactionTrigger    = "compaction_trigger"
	ResponseItemTagConfigurationUpdate  = "configuration_update"
	ResponseItemTagContextCompaction    = "context_compaction"
	ResponseItemTagCustomToolCall       = "custom_tool_call"
	ResponseItemTagCustomToolCallOutput = "custom_tool_call_output"
	ResponseItemTagFunctionCall         = "function_call"
	ResponseItemTagFunctionCallOutput   = "function_call_output"
	ResponseItemTagImageGenerationCall  = "image_generation_call"
	ResponseItemTagLocalShellCall       = "local_shell_call"
	ResponseItemTagMessage              = "message"
	ResponseItemTagOther                = "other"
	ResponseItemTagReasoning            = "reasoning"
	ResponseItemTagToolSearchCall       = "tool_search_call"
	ResponseItemTagToolSearchOutput     = "tool_search_output"
	ResponseItemTagWebSearchCall        = "web_search_call"
)
View Source
const (
	ResponsesApiWebSearchActionTagFindInPage = "find_in_page"
	ResponsesApiWebSearchActionTagOpenPage   = "open_page"
	ResponsesApiWebSearchActionTagOther      = "other"
	ResponsesApiWebSearchActionTagSearch     = "search"
)
View Source
const (
	ReviewTargetTagBaseBranch         = "baseBranch"
	ReviewTargetTagCommit             = "commit"
	ReviewTargetTagCustom             = "custom"
	ReviewTargetTagUncommittedChanges = "uncommittedChanges"
)
View Source
const (
	SandboxPolicyTagDangerFullAccess = "dangerFullAccess"
	SandboxPolicyTagExternalSandbox  = "externalSandbox"
	SandboxPolicyTagReadOnly         = "readOnly"
	SandboxPolicyTagWorkspaceWrite   = "workspaceWrite"
)
View Source
const (
	SessionSourceUnitAppServer = "appServer"
	SessionSourceUnitCli       = "cli"
	SessionSourceUnitExec      = "exec"
	SessionSourceUnitUnknown   = "unknown"
	SessionSourceUnitVscode    = "vscode"
)
View Source
const (
	SubAgentSourceUnitCompact             = "compact"
	SubAgentSourceUnitMemoryConsolidation = "memory_consolidation"
	SubAgentSourceUnitReview              = "review"
)
View Source
const (
	ThreadItemTagAgentMessage        = "agentMessage"
	ThreadItemTagCollabAgentToolCall = "collabAgentToolCall"
	ThreadItemTagCommandExecution    = "commandExecution"
	ThreadItemTagContextCompaction   = "contextCompaction"
	ThreadItemTagDynamicToolCall     = "dynamicToolCall"
	ThreadItemTagEnteredReviewMode   = "enteredReviewMode"
	ThreadItemTagExitedReviewMode    = "exitedReviewMode"
	ThreadItemTagFileChange          = "fileChange"
	ThreadItemTagFunctionCallOutput  = "functionCallOutput"
	ThreadItemTagHookPrompt          = "hookPrompt"
	ThreadItemTagImageGeneration     = "imageGeneration"
	ThreadItemTagImageView           = "imageView"
	ThreadItemTagMCPToolCall         = "mcpToolCall"
	ThreadItemTagPlan                = "plan"
	ThreadItemTagReasoning           = "reasoning"
	ThreadItemTagSleep               = "sleep"
	ThreadItemTagSubAgentActivity    = "subAgentActivity"
	ThreadItemTagUserMessage         = "userMessage"
	ThreadItemTagWebSearch           = "webSearch"
)
View Source
const (
	ThreadStatusTagActive      = "active"
	ThreadStatusTagIdle        = "idle"
	ThreadStatusTagNotLoaded   = "notLoaded"
	ThreadStatusTagSystemError = "systemError"
)
View Source
const (
	UserInputTagAudio      = "audio"
	UserInputTagImage      = "image"
	UserInputTagLocalAudio = "localAudio"
	UserInputTagLocalImage = "localImage"
	UserInputTagMention    = "mention"
	UserInputTagSkill      = "skill"
	UserInputTagText       = "text"
)
View Source
const (
	WebSearchActionTagFindInPage = "findInPage"
	WebSearchActionTagOpenPage   = "openPage"
	WebSearchActionTagOther      = "other"
	WebSearchActionTagSearch     = "search"
)
View Source
const (
	CapabilityRootLocationTagEnvironment = "environment"
)
View Source
const (
	DynamicToolNamespaceToolTagFunction = "function"
)
View Source
const (
	ImageGenerationFailureTagUsageLimitExceeded = "usageLimitExceeded"
)
View Source
const (
	LocalShellActionTagExec = "exec"
)
View Source
const MethodInitialized = "initialized"

MethodInitialized is the client notification completing the handshake.

View Source
const PinnedCodexVersion = "0.154.0"

PinnedCodexVersion is the codex CLI version the vendored schema snapshot (and therefore these generated types) corresponds to.

View Source
const (
	ReasoningItemReasoningSummaryTagSummaryText = "summary_text"
)

Variables

This section is empty.

Functions

func DecodeServerNotificationParams

func DecodeServerNotificationParams(method string, params []byte) (decoded any, ok bool, err error)

DecodeServerNotificationParams decodes the params of an app-server notification into its generated type. ok is false for methods outside the typed subset; those still surface to the caller as raw envelopes.

func DecodeServerRequestParams

func DecodeServerRequestParams(method string, params []byte) (decoded any, ok bool, err error)

DecodeServerRequestParams decodes the params of an app-server → Memoh request into its generated type. ok is false for unknown methods; the caller keeps the raw envelope in that case.

func NewResponseForMethod

func NewResponseForMethod(method string) (resp any, ok bool)

NewResponseForMethod returns a pointer to the zero response value for a client request method, ready for unmarshaling. ok is false for methods whose responses are not generated (initialize) or unknown methods.

Types

type APIKeyLoginAccountParams

type APIKeyLoginAccountParams struct {
	APIKey string `json:"apiKey"`
}

type APIKeyLoginAccountResponse

type APIKeyLoginAccountResponse struct {
}

type AbsolutePathBuf

type AbsolutePathBuf = string

A path that is guaranteed to be absolute and normalized (though it is not guaranteed to be canonicalized or exist on the filesystem).

type Account

type Account struct {
	// Tag is the value of the "type" property observed on decode.
	Tag           string
	AmazonBedrock *AmazonBedrockAccount
	APIKey        *ApiKeyAccount
	Chatgpt       *ChatgptAccount
	// contains filtered or unexported fields
}

Account is an internally-tagged union (tag property "type"). Unknown variants decode without error: only Tag and Raw() are populated.

func (Account) MarshalJSON

func (u Account) MarshalJSON() ([]byte, error)

func (Account) Raw

func (u Account) Raw() []byte

Raw returns the original JSON for this union value, if it was decoded.

func (*Account) UnmarshalJSON

func (u *Account) UnmarshalJSON(data []byte) error

type AccountLoginCompletedNotification

type AccountLoginCompletedNotification struct {
	Error                *string                      `json:"error,omitempty"`
	LoginID              *string                      `json:"loginId,omitempty"`
	OnboardingEntrypoint *DesktopOnboardingEntrypoint `json:"onboardingEntrypoint,omitempty"`
	Success              bool                         `json:"success"`
}

type AccountRateLimitsUpdatedNotification

type AccountRateLimitsUpdatedNotification struct {
	RateLimits RateLimitSnapshot `json:"rateLimits"`
}

Sparse rolling rate-limit update.

type AccountUpdatedNotification

type AccountUpdatedNotification struct {
	AuthMode *AuthMode `json:"authMode,omitempty"`
	PlanType *PlanType `json:"planType,omitempty"`
}

type ActivePermissionProfile

type ActivePermissionProfile struct {
	// Parent profile identifier from the selected permissions profile's `extends` setting, when present.
	Extends *string `json:"extends,omitempty"`
	// Identifier from `default_permissions` or the implicit built-in default, such as `:workspace` or a user-defined `[permissions.<id>]` profile.
	ID string `json:"id"`
}

type ActiveThreadStatus

type ActiveThreadStatus struct {
	ActiveFlags []ThreadActiveFlag `json:"activeFlags"`
}

func (ActiveThreadStatus) MarshalJSON

func (v ActiveThreadStatus) MarshalJSON() ([]byte, error)

type AddPatchChangeKind

type AddPatchChangeKind struct {
}

type AdditionalContextEntry

type AdditionalContextEntry struct {
	Kind  AdditionalContextKind `json:"kind"`
	Value string                `json:"value"`
}

type AdditionalContextKind

type AdditionalContextKind string
const (
	AdditionalContextKindApplication AdditionalContextKind = "application"
	AdditionalContextKindUntrusted   AdditionalContextKind = "untrusted"
)

type AdditionalFileSystemPermissions

type AdditionalFileSystemPermissions struct {
	Entries          []FileSystemSandboxEntry `json:"entries,omitempty"`
	GlobScanMaxDepth *uint64                  `json:"globScanMaxDepth,omitempty"`
	// This will be removed in favor of `entries`.
	Read []LegacyAppPathString `json:"read,omitempty"`
	// This will be removed in favor of `entries`.
	Write []LegacyAppPathString `json:"write,omitempty"`
}

type AdditionalNetworkPermissions

type AdditionalNetworkPermissions struct {
	Enabled *bool `json:"enabled,omitempty"`
}

type AdditionalPermissionProfile

type AdditionalPermissionProfile struct {
	FileSystem *AdditionalFileSystemPermissions `json:"fileSystem,omitempty"`
	// Partial overlay used for per-command permission requests.
	Network *AdditionalNetworkPermissions `json:"network,omitempty"`
}

type AgentMessageDelivery

type AgentMessageDelivery string
const (
	AgentMessageDeliveryAsync AgentMessageDelivery = "async"
)

type AgentMessageDeltaNotification

type AgentMessageDeltaNotification struct {
	Delta    string `json:"delta"`
	ItemID   string `json:"itemId"`
	ThreadID string `json:"threadId"`
	TurnID   string `json:"turnId"`
}

type AgentMessageInputContent

type AgentMessageInputContent struct {
	// Tag is the value of the "type" property observed on decode.
	Tag              string
	EncryptedContent *EncryptedContentAgentMessageInputContent
	InputText        *InputTextAgentMessageInputContent
	// contains filtered or unexported fields
}

AgentMessageInputContent is an internally-tagged union (tag property "type"). Unknown variants decode without error: only Tag and Raw() are populated.

func (AgentMessageInputContent) MarshalJSON

func (u AgentMessageInputContent) MarshalJSON() ([]byte, error)

func (AgentMessageInputContent) Raw

func (u AgentMessageInputContent) Raw() []byte

Raw returns the original JSON for this union value, if it was decoded.

func (*AgentMessageInputContent) UnmarshalJSON

func (u *AgentMessageInputContent) UnmarshalJSON(data []byte) error

type AgentMessageResponseItem

type AgentMessageResponseItem struct {
	Author                                 string                                  `json:"author"`
	Content                                []AgentMessageInputContent              `json:"content"`
	ID                                     *string                                 `json:"id,omitempty"`
	InternalChatMessageMetadataPassthrough *InternalChatMessageMetadataPassthrough `json:"internal_chat_message_metadata_passthrough,omitempty"`
	Recipient                              string                                  `json:"recipient"`
}

func (AgentMessageResponseItem) MarshalJSON

func (v AgentMessageResponseItem) MarshalJSON() ([]byte, error)

type AgentMessageThreadItem

type AgentMessageThreadItem struct {
	Delivery       *AgentMessageDelivery    `json:"delivery,omitempty"`
	ID             string                   `json:"id"`
	MemoryCitation *MemoryCitation          `json:"memoryCitation,omitempty"`
	Phase          *MessagePhase            `json:"phase,omitempty"`
	Questions      []AsyncUserInputQuestion `json:"questions,omitempty"`
	Text           string                   `json:"text"`
}

type AgentPath

type AgentPath = string

type AmazonBedrockAccessKeysLoginAccountParams

type AmazonBedrockAccessKeysLoginAccountParams struct {
	AccessKeyID     string  `json:"accessKeyId"`
	Region          string  `json:"region"`
	SecretAccessKey string  `json:"secretAccessKey"`
	SessionToken    *string `json:"sessionToken,omitempty"`
}

[UNSTABLE] Managed Amazon Bedrock AWS access key login is experimental.

type AmazonBedrockAccount

type AmazonBedrockAccount struct {
	UsesCodexManagedCredentials *bool `json:"usesCodexManagedCredentials,omitempty"`
}

type AmazonBedrockLoginAccountParams

type AmazonBedrockLoginAccountParams struct {
	APIKey string `json:"apiKey"`
	Region string `json:"region"`
}

[UNSTABLE] Managed Amazon Bedrock login is experimental.

type AmazonBedrockLoginAccountResponse

type AmazonBedrockLoginAccountResponse struct {
}

type ApiKeyAccount

type ApiKeyAccount struct {
}

type ApprovalsReviewer

type ApprovalsReviewer string

Configures who approval requests are routed to for review. Examples include sandbox escapes, blocked network access, MCP approval prompts, and ARC escalations. Defaults to `user`. `auto_review` uses a carefully prompted subagent to gather relevant context and apply a risk-based decision framework before approving or denying the request. The legacy value `guardian_subagent` is accepted for compatibility.

const (
	ApprovalsReviewerAutoReview       ApprovalsReviewer = "auto_review"
	ApprovalsReviewerGuardianSubagent ApprovalsReviewer = "guardian_subagent"
	ApprovalsReviewerUser             ApprovalsReviewer = "user"
)

type AskForApproval

type AskForApproval struct {
	// Unit holds the bare-string variant value, if that form was used.
	Unit     string
	Granular *AskForApprovalGranular
	// contains filtered or unexported fields
}

AskForApproval is a mixed union: on the wire it is either a bare string (Unit) or a single-key object (one payload field set). Unknown variants decode without error and are retained in Raw().

func (AskForApproval) MarshalJSON

func (u AskForApproval) MarshalJSON() ([]byte, error)

func (AskForApproval) Raw

func (u AskForApproval) Raw() []byte

Raw returns the original JSON for this union value, if it was decoded.

func (*AskForApproval) UnmarshalJSON

func (u *AskForApproval) UnmarshalJSON(data []byte) error

type AskForApprovalGranular

type AskForApprovalGranular struct {
	MCPElicitations    bool  `json:"mcp_elicitations"`
	RequestPermissions *bool `json:"request_permissions,omitempty"`
	Rules              bool  `json:"rules"`
	SandboxApproval    bool  `json:"sandbox_approval"`
	SkillApproval      *bool `json:"skill_approval,omitempty"`
}

type AsyncUserInputQuestion

type AsyncUserInputQuestion struct {
	Options []string `json:"options,omitempty"`
	Title   string   `json:"title"`
}

type AudioUserInput

type AudioUserInput struct {
	URL string `json:"url"`
}

type AuthMode

type AuthMode string

Authentication mode for OpenAI-backed providers.

const (
	AuthModeAgentIdentity       AuthMode = "agentIdentity"
	AuthModeApikey              AuthMode = "apikey"
	AuthModeBedrockAccessKeys   AuthMode = "bedrockAccessKeys"
	AuthModeBedrockAPIKey       AuthMode = "bedrockApiKey"
	AuthModeChatgpt             AuthMode = "chatgpt"
	AuthModeChatgptAuthTokens   AuthMode = "chatgptAuthTokens"
	AuthModeHeaders             AuthMode = "headers"
	AuthModePersonalAccessToken AuthMode = "personalAccessToken"
)

type BaseBranchReviewTarget

type BaseBranchReviewTarget struct {
	Branch string `json:"branch"`
}

Review changes between the current branch and the given base branch.

type ByteRange

type ByteRange struct {
	End   uint64 `json:"end"`
	Start uint64 `json:"start"`
}

type CancelLoginAccountParams

type CancelLoginAccountParams struct {
	LoginID string `json:"loginId"`
}

type CancelLoginAccountResponse

type CancelLoginAccountResponse struct {
	Status CancelLoginAccountStatus `json:"status"`
}

type CancelLoginAccountStatus

type CancelLoginAccountStatus string
const (
	CancelLoginAccountStatusCanceled CancelLoginAccountStatus = "canceled"
	CancelLoginAccountStatusNotFound CancelLoginAccountStatus = "notFound"
)

type CapabilityRootLocation

type CapabilityRootLocation struct {
	// Tag is the value of the "type" property observed on decode.
	Tag         string
	Environment *EnvironmentCapabilityRootLocation
	// contains filtered or unexported fields
}

Location used to resolve a selected capability root. CapabilityRootLocation is an internally-tagged union (tag property "type"). Unknown variants decode without error: only Tag and Raw() are populated.

func (CapabilityRootLocation) MarshalJSON

func (u CapabilityRootLocation) MarshalJSON() ([]byte, error)

func (CapabilityRootLocation) Raw

func (u CapabilityRootLocation) Raw() []byte

Raw returns the original JSON for this union value, if it was decoded.

func (*CapabilityRootLocation) UnmarshalJSON

func (u *CapabilityRootLocation) UnmarshalJSON(data []byte) error

type ChatgptAccount

type ChatgptAccount struct {
	Email    *string  `json:"email"`
	PlanType PlanType `json:"planType"`
}

type ChatgptAuthTokensLoginAccountParams

type ChatgptAuthTokensLoginAccountParams struct {
	// Access token (JWT) supplied by the client. This token is used for backend API requests and email extraction.
	AccessToken string `json:"accessToken"`
	// Workspace/account identifier supplied by the client.
	ChatgptAccountID string `json:"chatgptAccountId"`
	// Optional plan type supplied by the client.
	ChatgptPlanType *string `json:"chatgptPlanType,omitempty"`
}

[UNSTABLE] FOR OPENAI INTERNAL USE ONLY - DO NOT USE. The access token must contain the same scopes that Codex-managed ChatGPT auth tokens have.

type ChatgptAuthTokensLoginAccountResponse

type ChatgptAuthTokensLoginAccountResponse struct {
}

type ChatgptAuthTokensRefreshParams

type ChatgptAuthTokensRefreshParams struct {
	// Workspace/account identifier that Codex was previously using.
	PreviousAccountID *string                        `json:"previousAccountId,omitempty"`
	Reason            ChatgptAuthTokensRefreshReason `json:"reason"`
}

type ChatgptAuthTokensRefreshReason

type ChatgptAuthTokensRefreshReason string
const (
	ChatgptAuthTokensRefreshReasonUnauthorized ChatgptAuthTokensRefreshReason = "unauthorized"
)

type ChatgptAuthTokensRefreshResponse

type ChatgptAuthTokensRefreshResponse struct {
	AccessToken      string  `json:"accessToken"`
	ChatgptAccountID string  `json:"chatgptAccountId"`
	ChatgptPlanType  *string `json:"chatgptPlanType,omitempty"`
}

type ChatgptDeviceCodeLoginAccountParams

type ChatgptDeviceCodeLoginAccountParams struct {
}

type ChatgptDeviceCodeLoginAccountResponse

type ChatgptDeviceCodeLoginAccountResponse struct {
	LoginID string `json:"loginId"`
	// One-time code the user must enter after signing in.
	UserCode string `json:"userCode"`
	// URL the client should open in a browser to complete device code authorization.
	VerificationURL string `json:"verificationUrl"`
}

type ChatgptLoginAccountParams

type ChatgptLoginAccountParams struct {
	AppBrand                  *LoginAppBrand `json:"appBrand,omitempty"`
	CodexStreamlinedLogin     *bool          `json:"codexStreamlinedLogin,omitempty"`
	UseHostedLoginSuccessPage *bool          `json:"useHostedLoginSuccessPage,omitempty"`
}

type ChatgptLoginAccountResponse

type ChatgptLoginAccountResponse struct {
	// URL the client should open in a browser to initiate the OAuth flow.
	AuthURL string `json:"authUrl"`
	LoginID string `json:"loginId"`
}

type ClientInfo

type ClientInfo struct {
	Name    string  `json:"name"`
	Title   *string `json:"title,omitempty"`
	Version string  `json:"version"`
}

type CodexErrorInfo

type CodexErrorInfo struct {
	// Unit holds the bare-string variant value, if that form was used.
	Unit                           string
	ActiveTurnNotSteerable         *CodexErrorInfoActiveTurnNotSteerable
	HTTPConnectionFailed           *CodexErrorInfoHTTPConnectionFailed
	ResponseStreamConnectionFailed *CodexErrorInfoResponseStreamConnectionFailed
	ResponseStreamDisconnected     *CodexErrorInfoResponseStreamDisconnected
	ResponseTooManyFailedAttempts  *CodexErrorInfoResponseTooManyFailedAttempts
	// contains filtered or unexported fields
}

This translation layer make sure that we expose codex error code in camel case. CodexErrorInfo is a mixed union: on the wire it is either a bare string (Unit) or a single-key object (one payload field set). Unknown variants decode without error and are retained in Raw().

func (CodexErrorInfo) MarshalJSON

func (u CodexErrorInfo) MarshalJSON() ([]byte, error)

func (CodexErrorInfo) Raw

func (u CodexErrorInfo) Raw() []byte

Raw returns the original JSON for this union value, if it was decoded.

func (*CodexErrorInfo) UnmarshalJSON

func (u *CodexErrorInfo) UnmarshalJSON(data []byte) error

type CodexErrorInfoActiveTurnNotSteerable

type CodexErrorInfoActiveTurnNotSteerable struct {
	TurnKind NonSteerableTurnKind `json:"turnKind"`
}

type CodexErrorInfoHTTPConnectionFailed

type CodexErrorInfoHTTPConnectionFailed struct {
	HTTPStatusCode *uint64 `json:"httpStatusCode,omitempty"`
}

type CodexErrorInfoResponseStreamConnectionFailed

type CodexErrorInfoResponseStreamConnectionFailed struct {
	HTTPStatusCode *uint64 `json:"httpStatusCode,omitempty"`
}

type CodexErrorInfoResponseStreamDisconnected

type CodexErrorInfoResponseStreamDisconnected struct {
	HTTPStatusCode *uint64 `json:"httpStatusCode,omitempty"`
}

type CodexErrorInfoResponseTooManyFailedAttempts

type CodexErrorInfoResponseTooManyFailedAttempts struct {
	HTTPStatusCode *uint64 `json:"httpStatusCode,omitempty"`
}

type CollabAgentState

type CollabAgentState struct {
	Message *string           `json:"message,omitempty"`
	Status  CollabAgentStatus `json:"status"`
}

type CollabAgentStatus

type CollabAgentStatus string
const (
	CollabAgentStatusCompleted   CollabAgentStatus = "completed"
	CollabAgentStatusErrored     CollabAgentStatus = "errored"
	CollabAgentStatusInterrupted CollabAgentStatus = "interrupted"
	CollabAgentStatusNotFound    CollabAgentStatus = "notFound"
	CollabAgentStatusPendingInit CollabAgentStatus = "pendingInit"
	CollabAgentStatusRunning     CollabAgentStatus = "running"
	CollabAgentStatusShutdown    CollabAgentStatus = "shutdown"
)

type CollabAgentTool

type CollabAgentTool string
const (
	CollabAgentToolCloseAgent     CollabAgentTool = "closeAgent"
	CollabAgentToolFollowupTask   CollabAgentTool = "followupTask"
	CollabAgentToolInterruptAgent CollabAgentTool = "interruptAgent"
	CollabAgentToolListAgents     CollabAgentTool = "listAgents"
	CollabAgentToolResumeAgent    CollabAgentTool = "resumeAgent"
	CollabAgentToolSendInput      CollabAgentTool = "sendInput"
	CollabAgentToolSendMessage    CollabAgentTool = "sendMessage"
	CollabAgentToolSpawnAgent     CollabAgentTool = "spawnAgent"
	CollabAgentToolWait           CollabAgentTool = "wait"
)

type CollabAgentToolCallStatus

type CollabAgentToolCallStatus string
const (
	CollabAgentToolCallStatusCompleted   CollabAgentToolCallStatus = "completed"
	CollabAgentToolCallStatusFailed      CollabAgentToolCallStatus = "failed"
	CollabAgentToolCallStatusInProgress  CollabAgentToolCallStatus = "inProgress"
	CollabAgentToolCallStatusInterrupted CollabAgentToolCallStatus = "interrupted"
)

type CollabAgentToolCallThreadItem

type CollabAgentToolCallThreadItem struct {
	// Last known status of the target agents, when available.
	AgentsStates map[string]CollabAgentState `json:"agentsStates"`
	// Unique identifier for this collab tool call.
	ID string `json:"id"`
	// Model requested for the spawned agent, when applicable.
	Model *string `json:"model,omitempty"`
	// Prompt text sent as part of the collab tool call, when available.
	Prompt *string `json:"prompt,omitempty"`
	// Reasoning effort requested for the spawned agent, when applicable.
	ReasoningEffort *ReasoningEffort `json:"reasoningEffort,omitempty"`
	// Thread ID of the receiving agent, when applicable. In case of spawn operation, this corresponds to the newly spawned agent.
	ReceiverThreadIds []string `json:"receiverThreadIds"`
	// Thread ID of the agent issuing the collab request.
	SenderThreadID string `json:"senderThreadId"`
	// Current status of the collab tool call.
	Status CollabAgentToolCallStatus `json:"status"`
	// Name of the collab tool that was invoked.
	Tool CollabAgentTool `json:"tool"`
}

func (CollabAgentToolCallThreadItem) MarshalJSON

func (v CollabAgentToolCallThreadItem) MarshalJSON() ([]byte, error)

type CollaborationMode

type CollaborationMode struct {
	Mode     ModeKind `json:"mode"`
	Settings Settings `json:"settings"`
}

Collaboration mode for a Codex session.

type CommandAction

type CommandAction struct {
	// Tag is the value of the "type" property observed on decode.
	Tag       string
	ListFiles *ListFilesCommandAction
	Read      *ReadCommandAction
	Search    *SearchCommandAction
	Unknown   *UnknownCommandAction
	// contains filtered or unexported fields
}

CommandAction is an internally-tagged union (tag property "type"). Unknown variants decode without error: only Tag and Raw() are populated.

func (CommandAction) MarshalJSON

func (u CommandAction) MarshalJSON() ([]byte, error)

func (CommandAction) Raw

func (u CommandAction) Raw() []byte

Raw returns the original JSON for this union value, if it was decoded.

func (*CommandAction) UnmarshalJSON

func (u *CommandAction) UnmarshalJSON(data []byte) error

type CommandExecutionApprovalDecision

type CommandExecutionApprovalDecision struct {
	// Unit holds the bare-string variant value, if that form was used.
	Unit                          string
	AcceptWithExecpolicyAmendment *CommandExecutionApprovalDecisionAcceptWithExecpolicyAmendment
	ApplyNetworkPolicyAmendment   *CommandExecutionApprovalDecisionApplyNetworkPolicyAmendment
	// contains filtered or unexported fields
}

CommandExecutionApprovalDecision is a mixed union: on the wire it is either a bare string (Unit) or a single-key object (one payload field set). Unknown variants decode without error and are retained in Raw().

func (CommandExecutionApprovalDecision) MarshalJSON

func (u CommandExecutionApprovalDecision) MarshalJSON() ([]byte, error)

func (CommandExecutionApprovalDecision) Raw

Raw returns the original JSON for this union value, if it was decoded.

func (*CommandExecutionApprovalDecision) UnmarshalJSON

func (u *CommandExecutionApprovalDecision) UnmarshalJSON(data []byte) error

type CommandExecutionApprovalDecisionAcceptWithExecpolicyAmendment

type CommandExecutionApprovalDecisionAcceptWithExecpolicyAmendment struct {
	ExecpolicyAmendment []string `json:"execpolicy_amendment"`
}

func (CommandExecutionApprovalDecisionAcceptWithExecpolicyAmendment) MarshalJSON

type CommandExecutionApprovalDecisionApplyNetworkPolicyAmendment

type CommandExecutionApprovalDecisionApplyNetworkPolicyAmendment struct {
	NetworkPolicyAmendment NetworkPolicyAmendment `json:"network_policy_amendment"`
}

type CommandExecutionApprovalKind

type CommandExecutionApprovalKind string

Distinguishes a command approval from input sent to an existing terminal.

const (
	CommandExecutionApprovalKindCommand    CommandExecutionApprovalKind = "command"
	CommandExecutionApprovalKindWriteStdin CommandExecutionApprovalKind = "writeStdin"
)

type CommandExecutionOutputDeltaNotification

type CommandExecutionOutputDeltaNotification struct {
	Delta    string `json:"delta"`
	ItemID   string `json:"itemId"`
	ThreadID string `json:"threadId"`
	TurnID   string `json:"turnId"`
}

type CommandExecutionRequestApprovalParams

type CommandExecutionRequestApprovalParams struct {
	// Optional additional permissions requested for this command.
	AdditionalPermissions *AdditionalPermissionProfile `json:"additionalPermissions,omitempty"`
	// Unique identifier for this specific approval callback.
	ApprovalID *string `json:"approvalId,omitempty"`
	// Ordered list of decisions the client may present for this prompt.
	AvailableDecisions []CommandExecutionApprovalDecision `json:"availableDecisions,omitempty"`
	// The command to be executed.
	Command *string `json:"command,omitempty"`
	// Best-effort parsed command actions for friendly display.
	CommandActions []CommandAction `json:"commandActions,omitempty"`
	// The command's working directory.
	Cwd *LegacyAppPathString `json:"cwd,omitempty"`
	// Environment in which the command will run.
	EnvironmentID *string `json:"environmentId,omitempty"`
	ItemID        string  `json:"itemId"`
	// Kind of action under review. Defaults to `command` for older servers.
	Kind *CommandExecutionApprovalKind `json:"kind,omitempty"`
	// Optional context for a managed-network approval prompt.
	NetworkApprovalContext *NetworkApprovalContext `json:"networkApprovalContext,omitempty"`
	// Optional proposed execpolicy amendment to allow similar commands without prompting.
	ProposedExecpolicyAmendment []string `json:"proposedExecpolicyAmendment,omitempty"`
	// Optional proposed network policy amendments (allow/deny host) for future requests.
	ProposedNetworkPolicyAmendments []NetworkPolicyAmendment `json:"proposedNetworkPolicyAmendments,omitempty"`
	// Optional explanatory reason (e.g. request for network access).
	Reason *string `json:"reason,omitempty"`
	// Unix timestamp (in milliseconds) when this approval request started.
	StartedAtMs int64  `json:"startedAtMs"`
	ThreadID    string `json:"threadId"`
	TurnID      string `json:"turnId"`
}

type CommandExecutionRequestApprovalResponse

type CommandExecutionRequestApprovalResponse struct {
	Decision CommandExecutionApprovalDecision `json:"decision"`
}

type CommandExecutionSource

type CommandExecutionSource string
const (
	CommandExecutionSourceAgent                  CommandExecutionSource = "agent"
	CommandExecutionSourceUnifiedExecInteraction CommandExecutionSource = "unifiedExecInteraction"
	CommandExecutionSourceUnifiedExecStartup     CommandExecutionSource = "unifiedExecStartup"
	CommandExecutionSourceUserShell              CommandExecutionSource = "userShell"
)

type CommandExecutionStatus

type CommandExecutionStatus string
const (
	CommandExecutionStatusCompleted  CommandExecutionStatus = "completed"
	CommandExecutionStatusDeclined   CommandExecutionStatus = "declined"
	CommandExecutionStatusFailed     CommandExecutionStatus = "failed"
	CommandExecutionStatusInProgress CommandExecutionStatus = "inProgress"
)

type CommandExecutionThreadItem

type CommandExecutionThreadItem struct {
	// The command's output, aggregated from stdout and stderr.
	AggregatedOutput *string `json:"aggregatedOutput,omitempty"`
	// The command to be executed.
	Command string `json:"command"`
	// 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.
	CommandActions []CommandAction `json:"commandActions"`
	// The command's working directory.
	Cwd LegacyAppPathString `json:"cwd"`
	// The duration of the command execution in milliseconds.
	DurationMs *int64 `json:"durationMs,omitempty"`
	// The command's exit code.
	ExitCode *int64 `json:"exitCode,omitempty"`
	ID       string `json:"id"`
	// Trusted first-party plugin id when this command resolves to one plugin script.
	PluginID *string `json:"pluginId,omitempty"`
	// Identifier for the underlying PTY process (when available).
	ProcessID *string `json:"processId,omitempty"`
	// Safe plugin-relative path when this command resolves to one plugin script.
	ScriptPath *string                 `json:"scriptPath,omitempty"`
	Source     *CommandExecutionSource `json:"source,omitempty"`
	Status     CommandExecutionStatus  `json:"status"`
}

func (CommandExecutionThreadItem) MarshalJSON

func (v CommandExecutionThreadItem) MarshalJSON() ([]byte, error)

type CommitReviewTarget

type CommitReviewTarget struct {
	Sha string `json:"sha"`
	// Optional human-readable label (e.g., commit subject) for UIs.
	Title *string `json:"title,omitempty"`
}

Review the changes introduced by a specific commit.

type CompactionResponseItem

type CompactionResponseItem struct {
	EncryptedContent                       string                                  `json:"encrypted_content"`
	ID                                     *string                                 `json:"id,omitempty"`
	InternalChatMessageMetadataPassthrough *InternalChatMessageMetadataPassthrough `json:"internal_chat_message_metadata_passthrough,omitempty"`
}

type CompactionTriggerResponseItem

type CompactionTriggerResponseItem struct {
}

type ConfigWarningNotification

type ConfigWarningNotification struct {
	// Optional extra guidance or error details.
	Details *string `json:"details,omitempty"`
	// Optional path to the config file that triggered the warning.
	Path *string `json:"path,omitempty"`
	// Optional range for the error location inside the config file.
	Range *TextRange `json:"range,omitempty"`
	// Concise summary of the warning.
	Summary string `json:"summary"`
}

type ConfigurationReasoning

type ConfigurationReasoning struct {
	Effort ReasoningEffort `json:"effort"`
}

Reasoning settings interpreted by the backend for the routed model.

type ConfigurationUpdateResponseItem

type ConfigurationUpdateResponseItem struct {
	Reasoning ConfigurationReasoning `json:"reasoning"`
}

A durable input control interpreted by the backend at its position in history.

type ContentItem

type ContentItem struct {
	// Tag is the value of the "type" property observed on decode.
	Tag        string
	InputAudio *InputAudioContentItem
	InputImage *InputImageContentItem
	InputText  *InputTextContentItem
	OutputText *OutputTextContentItem
	// contains filtered or unexported fields
}

ContentItem is an internally-tagged union (tag property "type"). Unknown variants decode without error: only Tag and Raw() are populated.

func (ContentItem) MarshalJSON

func (u ContentItem) MarshalJSON() ([]byte, error)

func (ContentItem) Raw

func (u ContentItem) Raw() []byte

Raw returns the original JSON for this union value, if it was decoded.

func (*ContentItem) UnmarshalJSON

func (u *ContentItem) UnmarshalJSON(data []byte) error

type ContextCompactedNotification deprecated

type ContextCompactedNotification struct {
	ThreadID string `json:"threadId"`
	TurnID   string `json:"turnId"`
}

Deprecated: Use `ContextCompaction` item type instead.

type ContextCompactionResponseItem

type ContextCompactionResponseItem struct {
	EncryptedContent                       *string                                 `json:"encrypted_content,omitempty"`
	ID                                     *string                                 `json:"id,omitempty"`
	InternalChatMessageMetadataPassthrough *InternalChatMessageMetadataPassthrough `json:"internal_chat_message_metadata_passthrough,omitempty"`
}

type ContextCompactionThreadItem

type ContextCompactionThreadItem struct {
	ID string `json:"id"`
}

type CreditsSnapshot

type CreditsSnapshot struct {
	Balance    *string `json:"balance,omitempty"`
	HasCredits bool    `json:"hasCredits"`
	Unlimited  bool    `json:"unlimited"`
}

type CustomReviewTarget

type CustomReviewTarget struct {
	Instructions string `json:"instructions"`
}

Arbitrary instructions, equivalent to the old free-form prompt.

type CustomToolCallOutputResponseItem

type CustomToolCallOutputResponseItem struct {
	CallID                                 string                                  `json:"call_id"`
	ID                                     *string                                 `json:"id,omitempty"`
	InternalChatMessageMetadataPassthrough *InternalChatMessageMetadataPassthrough `json:"internal_chat_message_metadata_passthrough,omitempty"`
	Name                                   *string                                 `json:"name,omitempty"`
	Output                                 rawMessage                              `json:"output"`
}

type CustomToolCallResponseItem

type CustomToolCallResponseItem struct {
	CallID                                 string                                  `json:"call_id"`
	ID                                     *string                                 `json:"id,omitempty"`
	Input                                  string                                  `json:"input"`
	InternalChatMessageMetadataPassthrough *InternalChatMessageMetadataPassthrough `json:"internal_chat_message_metadata_passthrough,omitempty"`
	Name                                   string                                  `json:"name"`
	Namespace                              *string                                 `json:"namespace,omitempty"`
	Status                                 *string                                 `json:"status,omitempty"`
}

type CyberAccessProgram

type CyberAccessProgram string

Requested cyber treatment for a ChatGPT-authenticated Codex turn. Authorization and model-tier restrictions remain server-owned.

const (
	CyberAccessProgramDaybreakBlue CyberAccessProgram = "daybreakBlue"
	CyberAccessProgramDaybreakRed  CyberAccessProgram = "daybreakRed"
	CyberAccessProgramStandard     CyberAccessProgram = "standard"
)

type DangerFullAccessSandboxPolicy

type DangerFullAccessSandboxPolicy struct {
}

type DeletePatchChangeKind

type DeletePatchChangeKind struct {
}

type DeprecationNoticeNotification

type DeprecationNoticeNotification struct {
	// Optional extra guidance, such as migration steps or rationale.
	Details *string `json:"details,omitempty"`
	// Concise summary of what is deprecated.
	Summary string `json:"summary"`
}

type DesktopOnboardingEntrypoint

type DesktopOnboardingEntrypoint string
const (
	DesktopOnboardingEntrypointLifeSciences DesktopOnboardingEntrypoint = "life_sciences"
)

type DynamicToolCallOutputContentItem

type DynamicToolCallOutputContentItem struct {
	// Tag is the value of the "type" property observed on decode.
	Tag        string
	InputAudio *InputAudioDynamicToolCallOutputContentItem
	InputImage *InputImageDynamicToolCallOutputContentItem
	InputText  *InputTextDynamicToolCallOutputContentItem
	// contains filtered or unexported fields
}

DynamicToolCallOutputContentItem is an internally-tagged union (tag property "type"). Unknown variants decode without error: only Tag and Raw() are populated.

func (DynamicToolCallOutputContentItem) MarshalJSON

func (u DynamicToolCallOutputContentItem) MarshalJSON() ([]byte, error)

func (DynamicToolCallOutputContentItem) Raw

Raw returns the original JSON for this union value, if it was decoded.

func (*DynamicToolCallOutputContentItem) UnmarshalJSON

func (u *DynamicToolCallOutputContentItem) UnmarshalJSON(data []byte) error

type DynamicToolCallStatus

type DynamicToolCallStatus string
const (
	DynamicToolCallStatusCompleted  DynamicToolCallStatus = "completed"
	DynamicToolCallStatusFailed     DynamicToolCallStatus = "failed"
	DynamicToolCallStatusInProgress DynamicToolCallStatus = "inProgress"
)

type DynamicToolCallThreadItem

type DynamicToolCallThreadItem struct {
	Arguments    any                                `json:"arguments"`
	ContentItems []DynamicToolCallOutputContentItem `json:"contentItems,omitempty"`
	// The duration of the dynamic tool call in milliseconds.
	DurationMs *int64                `json:"durationMs,omitempty"`
	ID         string                `json:"id"`
	Namespace  *string               `json:"namespace,omitempty"`
	Status     DynamicToolCallStatus `json:"status"`
	Success    *bool                 `json:"success,omitempty"`
	Tool       string                `json:"tool"`
}

type DynamicToolNamespaceTool

type DynamicToolNamespaceTool struct {
	// Tag is the value of the "type" property observed on decode.
	Tag      string
	Function *FunctionDynamicToolNamespaceTool
	// contains filtered or unexported fields
}

DynamicToolNamespaceTool is an internally-tagged union (tag property "type"). Unknown variants decode without error: only Tag and Raw() are populated.

func (DynamicToolNamespaceTool) MarshalJSON

func (u DynamicToolNamespaceTool) MarshalJSON() ([]byte, error)

func (DynamicToolNamespaceTool) Raw

func (u DynamicToolNamespaceTool) Raw() []byte

Raw returns the original JSON for this union value, if it was decoded.

func (*DynamicToolNamespaceTool) UnmarshalJSON

func (u *DynamicToolNamespaceTool) UnmarshalJSON(data []byte) error

type DynamicToolSpec

type DynamicToolSpec struct {
	// Tag is the value of the "type" property observed on decode.
	Tag       string
	Function  *FunctionDynamicToolSpec
	Namespace *NamespaceDynamicToolSpec
	// contains filtered or unexported fields
}

DynamicToolSpec is an internally-tagged union (tag property "type"). Unknown variants decode without error: only Tag and Raw() are populated.

func (DynamicToolSpec) MarshalJSON

func (u DynamicToolSpec) MarshalJSON() ([]byte, error)

func (DynamicToolSpec) Raw

func (u DynamicToolSpec) Raw() []byte

Raw returns the original JSON for this union value, if it was decoded.

func (*DynamicToolSpec) UnmarshalJSON

func (u *DynamicToolSpec) UnmarshalJSON(data []byte) error

type EncryptedContentAgentMessageInputContent

type EncryptedContentAgentMessageInputContent struct {
	EncryptedContent string `json:"encrypted_content"`
}

type EncryptedContentFunctionCallOutputContentItem

type EncryptedContentFunctionCallOutputContentItem struct {
	EncryptedContent string `json:"encrypted_content"`
}

type EnteredReviewModeThreadItem

type EnteredReviewModeThreadItem struct {
	ID     string `json:"id"`
	Review string `json:"review"`
}

type EnvironmentCapabilityRootLocation

type EnvironmentCapabilityRootLocation struct {
	EnvironmentID string `json:"environmentId"`
	// Absolute path for the root in the selected environment.
	Path string `json:"path"`
}

A path owned by an execution environment.

type ErrorNotification

type ErrorNotification struct {
	Error     TurnError `json:"error"`
	ThreadID  string    `json:"threadId"`
	TurnID    string    `json:"turnId"`
	WillRetry bool      `json:"willRetry"`
}

type ErrorResponse

type ErrorResponse struct {
	ID    RequestID `json:"id"`
	Error *RPCError `json:"error"`
}

ErrorResponse rejects an app-server → Memoh request.

type ExecLocalShellAction

type ExecLocalShellAction struct {
	Command          []string          `json:"command"`
	Env              map[string]string `json:"env,omitempty"`
	TimeoutMs        *uint64           `json:"timeout_ms,omitempty"`
	User             *string           `json:"user,omitempty"`
	WorkingDirectory *string           `json:"working_directory,omitempty"`
}

func (ExecLocalShellAction) MarshalJSON

func (v ExecLocalShellAction) MarshalJSON() ([]byte, error)

type ExitedReviewModeThreadItem

type ExitedReviewModeThreadItem struct {
	ID     string `json:"id"`
	Review string `json:"review"`
}

type ExternalSandboxSandboxPolicy

type ExternalSandboxSandboxPolicy struct {
	NetworkAccess *NetworkAccess `json:"networkAccess,omitempty"`
}

type FileChangeApprovalDecision

type FileChangeApprovalDecision string
const (
	FileChangeApprovalDecisionAccept           FileChangeApprovalDecision = "accept"
	FileChangeApprovalDecisionAcceptForSession FileChangeApprovalDecision = "acceptForSession"
	FileChangeApprovalDecisionCancel           FileChangeApprovalDecision = "cancel"
	FileChangeApprovalDecisionDecline          FileChangeApprovalDecision = "decline"
)

type FileChangeOutputDeltaNotification

type FileChangeOutputDeltaNotification struct {
	Delta    string `json:"delta"`
	ItemID   string `json:"itemId"`
	ThreadID string `json:"threadId"`
	TurnID   string `json:"turnId"`
}

Deprecated legacy notification for `apply_patch` textual output.

type FileChangeRequestApprovalParams

type FileChangeRequestApprovalParams struct {
	// [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).
	GrantRoot *string `json:"grantRoot,omitempty"`
	ItemID    string  `json:"itemId"`
	// Optional explanatory reason (e.g. request for extra write access).
	Reason *string `json:"reason,omitempty"`
	// Unix timestamp (in milliseconds) when this approval request started.
	StartedAtMs int64  `json:"startedAtMs"`
	ThreadID    string `json:"threadId"`
	TurnID      string `json:"turnId"`
}

type FileChangeRequestApprovalResponse

type FileChangeRequestApprovalResponse struct {
	Decision FileChangeApprovalDecision `json:"decision"`
}

type FileChangeThreadItem

type FileChangeThreadItem struct {
	Changes []FileUpdateChange `json:"changes"`
	ID      string             `json:"id"`
	Status  PatchApplyStatus   `json:"status"`
}

func (FileChangeThreadItem) MarshalJSON

func (v FileChangeThreadItem) MarshalJSON() ([]byte, error)

type FileSystemAccessMode

type FileSystemAccessMode string
const (
	FileSystemAccessModeDeny  FileSystemAccessMode = "deny"
	FileSystemAccessModeRead  FileSystemAccessMode = "read"
	FileSystemAccessModeWrite FileSystemAccessMode = "write"
)

type FileSystemPath

type FileSystemPath struct {
	// Tag is the value of the "type" property observed on decode.
	Tag         string
	GlobPattern *GlobPatternFileSystemPath
	Path        *PathFileSystemPath
	Special     *SpecialFileSystemPath
	// contains filtered or unexported fields
}

FileSystemPath is an internally-tagged union (tag property "type"). Unknown variants decode without error: only Tag and Raw() are populated.

func (FileSystemPath) MarshalJSON

func (u FileSystemPath) MarshalJSON() ([]byte, error)

func (FileSystemPath) Raw

func (u FileSystemPath) Raw() []byte

Raw returns the original JSON for this union value, if it was decoded.

func (*FileSystemPath) UnmarshalJSON

func (u *FileSystemPath) UnmarshalJSON(data []byte) error

type FileSystemSandboxEntry

type FileSystemSandboxEntry struct {
	Access FileSystemAccessMode `json:"access"`
	Path   FileSystemPath       `json:"path"`
}

type FileSystemSpecialPath

type FileSystemSpecialPath struct {
	// Tag is the value of the "kind" property observed on decode.
	Tag          string
	Minimal      *MinimalFileSystemSpecialPath
	ProjectRoots *KindFileSystemSpecialPath
	Root         *RootFileSystemSpecialPath
	SlashTmp     *SlashTmpFileSystemSpecialPath
	Tmpdir       *TmpdirFileSystemSpecialPath
	Unknown      *UnknownFileSystemSpecialPath
	// contains filtered or unexported fields
}

FileSystemSpecialPath is an internally-tagged union (tag property "kind"). Unknown variants decode without error: only Tag and Raw() are populated.

func (FileSystemSpecialPath) MarshalJSON

func (u FileSystemSpecialPath) MarshalJSON() ([]byte, error)

func (FileSystemSpecialPath) Raw

func (u FileSystemSpecialPath) Raw() []byte

Raw returns the original JSON for this union value, if it was decoded.

func (*FileSystemSpecialPath) UnmarshalJSON

func (u *FileSystemSpecialPath) UnmarshalJSON(data []byte) error

type FileUpdateChange

type FileUpdateChange struct {
	Diff string          `json:"diff"`
	Kind PatchChangeKind `json:"kind"`
	Path string          `json:"path"`
}

type FindInPageResponsesApiWebSearchAction

type FindInPageResponsesApiWebSearchAction struct {
	Pattern *string `json:"pattern,omitempty"`
	URL     *string `json:"url,omitempty"`
}

type FindInPageWebSearchAction

type FindInPageWebSearchAction struct {
	Pattern *string `json:"pattern,omitempty"`
	URL     *string `json:"url,omitempty"`
}

type FormMcpServerElicitationRequestParams

type FormMcpServerElicitationRequestParams struct {
	Meta            any                  `json:"_meta,omitempty"`
	Message         string               `json:"message"`
	RequestedSchema McpElicitationSchema `json:"requestedSchema"`
}

type FunctionCallOutputContentItem

type FunctionCallOutputContentItem struct {
	// Tag is the value of the "type" property observed on decode.
	Tag              string
	EncryptedContent *EncryptedContentFunctionCallOutputContentItem
	InputAudio       *InputAudioFunctionCallOutputContentItem
	InputImage       *InputImageFunctionCallOutputContentItem
	InputText        *InputTextFunctionCallOutputContentItem
	// contains filtered or unexported fields
}

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. FunctionCallOutputContentItem is an internally-tagged union (tag property "type"). Unknown variants decode without error: only Tag and Raw() are populated.

func (FunctionCallOutputContentItem) MarshalJSON

func (u FunctionCallOutputContentItem) MarshalJSON() ([]byte, error)

func (FunctionCallOutputContentItem) Raw

Raw returns the original JSON for this union value, if it was decoded.

func (*FunctionCallOutputContentItem) UnmarshalJSON

func (u *FunctionCallOutputContentItem) UnmarshalJSON(data []byte) error

type FunctionCallOutputResponseItem

type FunctionCallOutputResponseItem struct {
	CallID                                 *string                                 `json:"call_id,omitempty"`
	ID                                     *string                                 `json:"id,omitempty"`
	InternalChatMessageMetadataPassthrough *InternalChatMessageMetadataPassthrough `json:"internal_chat_message_metadata_passthrough,omitempty"`
	Name                                   *string                                 `json:"name,omitempty"`
	Namespace                              *string                                 `json:"namespace,omitempty"`
	Output                                 rawMessage                              `json:"output"`
}

type FunctionCallOutputThreadItem

type FunctionCallOutputThreadItem struct {
	ID        string     `json:"id"`
	Name      string     `json:"name"`
	Namespace *string    `json:"namespace,omitempty"`
	Output    rawMessage `json:"output"`
}

type FunctionCallResponseItem

type FunctionCallResponseItem struct {
	Arguments                              string                                  `json:"arguments"`
	CallID                                 string                                  `json:"call_id"`
	EncryptedFunctionArgs                  []string                                `json:"encrypted_function_args,omitempty"`
	ID                                     *string                                 `json:"id,omitempty"`
	InternalChatMessageMetadataPassthrough *InternalChatMessageMetadataPassthrough `json:"internal_chat_message_metadata_passthrough,omitempty"`
	Name                                   string                                  `json:"name"`
	Namespace                              *string                                 `json:"namespace,omitempty"`
}

type FunctionDynamicToolNamespaceTool

type FunctionDynamicToolNamespaceTool struct {
	DeferLoading *bool  `json:"deferLoading,omitempty"`
	Description  string `json:"description"`
	InputSchema  any    `json:"inputSchema"`
	Name         string `json:"name"`
}

type FunctionDynamicToolSpec

type FunctionDynamicToolSpec struct {
	DeferLoading *bool  `json:"deferLoading,omitempty"`
	Description  string `json:"description"`
	InputSchema  any    `json:"inputSchema"`
	Name         string `json:"name"`
}

type GetAccountParams

type GetAccountParams struct {
	// When `true`, requests a proactive token refresh before returning.
	RefreshToken *bool `json:"refreshToken,omitempty"`
}

type GetAccountRateLimitsResponse

type GetAccountRateLimitsResponse struct {
	// Account associated with this usage snapshot, when supplied by the backend.
	AccountID *string `json:"accountId,omitempty"`
	// Backend permission for ordinary included usage, validated against the active account. Null means unavailable; clients must not infer recovery from percentages or reset times.
	OrdinaryUsageAllowed  *bool                         `json:"ordinaryUsageAllowed,omitempty"`
	RateLimitResetCredits *RateLimitResetCreditsSummary `json:"rateLimitResetCredits,omitempty"`
	// Optional backend-owned banner from the same usage read. Its nested keys retain the backend's snake_case contract; an absent banner leaves the client's existing UI unchanged.
	RateLimitUpsell any `json:"rateLimitUpsell,omitempty"`
	// Backward-compatible single-bucket view; mirrors the historical payload.
	RateLimits RateLimitSnapshot `json:"rateLimits"`
	// Multi-bucket view keyed by metered `limit_id` (for example, `codex`).
	RateLimitsByLimitID map[string]RateLimitSnapshot `json:"rateLimitsByLimitId,omitempty"`
}

type GetAccountResponse

type GetAccountResponse struct {
	Account            *Account `json:"account,omitempty"`
	RequiresOpenaiAuth bool     `json:"requiresOpenaiAuth"`
}

type GitInfo

type GitInfo struct {
	Branch    *string `json:"branch,omitempty"`
	OriginURL *string `json:"originUrl,omitempty"`
	Sha       *string `json:"sha,omitempty"`
}

type GlobPatternFileSystemPath

type GlobPatternFileSystemPath struct {
	Pattern string `json:"pattern"`
}

type GrantedPermissionProfile

type GrantedPermissionProfile struct {
	FileSystem *AdditionalFileSystemPermissions `json:"fileSystem,omitempty"`
	Network    *AdditionalNetworkPermissions    `json:"network,omitempty"`
}

type HookPromptFragment

type HookPromptFragment struct {
	HookRunID string `json:"hookRunId"`
	Text      string `json:"text"`
}

type HookPromptThreadItem

type HookPromptThreadItem struct {
	Fragments []HookPromptFragment `json:"fragments"`
	ID        string               `json:"id"`
}

func (HookPromptThreadItem) MarshalJSON

func (v HookPromptThreadItem) MarshalJSON() ([]byte, error)

type IdleThreadStatus

type IdleThreadStatus struct {
}

type ImageDetail

type ImageDetail string
const (
	ImageDetailAuto     ImageDetail = "auto"
	ImageDetailHigh     ImageDetail = "high"
	ImageDetailLow      ImageDetail = "low"
	ImageDetailOriginal ImageDetail = "original"
)

type ImageGenerationCallResponseItem

type ImageGenerationCallResponseItem struct {
	ID                                     *string                                 `json:"id,omitempty"`
	InternalChatMessageMetadataPassthrough *InternalChatMessageMetadataPassthrough `json:"internal_chat_message_metadata_passthrough,omitempty"`
	Result                                 string                                  `json:"result"`
	RevisedPrompt                          *string                                 `json:"revised_prompt,omitempty"`
	Status                                 string                                  `json:"status"`
}

type ImageGenerationFailure

type ImageGenerationFailure struct {
	// Tag is the value of the "type" property observed on decode.
	Tag                string
	UsageLimitExceeded *UsageLimitExceededImageGenerationFailure
	// contains filtered or unexported fields
}

ImageGenerationFailure is an internally-tagged union (tag property "type"). Unknown variants decode without error: only Tag and Raw() are populated.

func (ImageGenerationFailure) MarshalJSON

func (u ImageGenerationFailure) MarshalJSON() ([]byte, error)

func (ImageGenerationFailure) Raw

func (u ImageGenerationFailure) Raw() []byte

Raw returns the original JSON for this union value, if it was decoded.

func (*ImageGenerationFailure) UnmarshalJSON

func (u *ImageGenerationFailure) UnmarshalJSON(data []byte) error

type ImageGenerationThreadItem

type ImageGenerationThreadItem struct {
	Failure               *ImageGenerationFailure `json:"failure,omitempty"`
	ID                    string                  `json:"id"`
	Result                string                  `json:"result"`
	RevisedPrompt         *string                 `json:"revisedPrompt,omitempty"`
	SavedPath             *AbsolutePathBuf        `json:"savedPath,omitempty"`
	Status                string                  `json:"status"`
	TransparentBackground *bool                   `json:"transparentBackground,omitempty"`
}

type ImageUserInput

type ImageUserInput struct {
	Detail *ImageDetail `json:"detail,omitempty"`
	URL    string       `json:"url"`
}

type ImageViewThreadItem

type ImageViewThreadItem struct {
	ID   string              `json:"id"`
	Path LegacyAppPathString `json:"path"`
}

type Inbound

type Inbound struct {
	Kind   InboundKind
	ID     RequestID       // requests and responses
	Method string          // requests and notifications
	Params json.RawMessage // requests and notifications
	Result json.RawMessage // successful responses
	Err    *RPCError       // failed responses
	Raw    json.RawMessage // the full original line
}

Inbound is one decoded line from the app-server stream.

func DecodeInbound

func DecodeInbound(line []byte) (*Inbound, error)

DecodeInbound classifies one NDJSON line from the app-server.

type InboundKind

type InboundKind int

InboundKind classifies a line received from the app-server.

const (
	// InboundResponse answers one of our requests.
	InboundResponse InboundKind = iota + 1
	// InboundRequest is a server → client request that expects a Response.
	InboundRequest
	// InboundNotification is fire-and-forget.
	InboundNotification
)

type InitializeCapabilities

type InitializeCapabilities struct {
	// Opt into receiving experimental API methods and fields.
	ExperimentalAPI *bool `json:"experimentalApi,omitempty"`
	// MCP extension settings declared by the app-server client.
	Extensions map[string]any `json:"extensions,omitempty"`
	// Legacy opt-in for the `openai/form` MCP extension.
	MCPServerOpenaiFormElicitation *bool `json:"mcpServerOpenaiFormElicitation,omitempty"`
	// Exact notification method names that should be suppressed for this connection (for example `thread/started`).
	OptOutNotificationMethods []string `json:"optOutNotificationMethods,omitempty"`
	// Opt into `attestation/generate` requests for upstream `x-oai-attestation`.
	RequestAttestation *bool `json:"requestAttestation,omitempty"`
}

Client-declared capabilities negotiated during initialize.

type InitializeParams

type InitializeParams struct {
	Capabilities *InitializeCapabilities `json:"capabilities,omitempty"`
	ClientInfo   ClientInfo              `json:"clientInfo"`
}

type InitializeResponse

type InitializeResponse struct {
	UserAgent      string `json:"userAgent"`
	CodexHome      string `json:"codexHome"`
	PlatformFamily string `json:"platformFamily"`
	PlatformOS     string `json:"platformOs"`
}

InitializeResponse is the app-server's answer to `initialize`. It belongs to the version-independent bootstrap layer, which is why it is not part of the generated v2 surface.

type InputAudioContentItem

type InputAudioContentItem struct {
	AudioURL string `json:"audio_url"`
}

type InputAudioDynamicToolCallOutputContentItem

type InputAudioDynamicToolCallOutputContentItem struct {
	AudioURL string `json:"audioUrl"`
}

type InputAudioFunctionCallOutputContentItem

type InputAudioFunctionCallOutputContentItem struct {
	AudioURL string `json:"audio_url"`
}

type InputImageContentItem

type InputImageContentItem struct {
	Detail   *ImageDetail `json:"detail,omitempty"`
	ImageURL string       `json:"image_url"`
}

type InputImageDynamicToolCallOutputContentItem

type InputImageDynamicToolCallOutputContentItem struct {
	ImageURL string `json:"imageUrl"`
}

type InputImageFunctionCallOutputContentItem

type InputImageFunctionCallOutputContentItem struct {
	Detail   *ImageDetail `json:"detail,omitempty"`
	ImageURL string       `json:"image_url"`
}

type InputModality

type InputModality string

Canonical user-input modality tags advertised by a model.

const (
	InputModalityAudio InputModality = "audio"
	InputModalityImage InputModality = "image"
	InputModalityText  InputModality = "text"
)

type InputTextAgentMessageInputContent

type InputTextAgentMessageInputContent struct {
	Text string `json:"text"`
}

type InputTextContentItem

type InputTextContentItem struct {
	Text string `json:"text"`
}

type InputTextDynamicToolCallOutputContentItem

type InputTextDynamicToolCallOutputContentItem struct {
	Text string `json:"text"`
}

type InputTextFunctionCallOutputContentItem

type InputTextFunctionCallOutputContentItem struct {
	Text string `json:"text"`
}

type InternalChatMessageMetadataPassthrough

type InternalChatMessageMetadataPassthrough struct {
	TurnID *string `json:"turn_id,omitempty"`
}

Internal Responses API passthrough metadata copied into underlying chat messages.

type ItemCompletedNotification

type ItemCompletedNotification struct {
	// Unix timestamp (in milliseconds) when this item lifecycle completed.
	CompletedAtMs int64      `json:"completedAtMs"`
	Item          ThreadItem `json:"item"`
	ThreadID      string     `json:"threadId"`
	TurnID        string     `json:"turnId"`
}

type ItemStartedNotification

type ItemStartedNotification struct {
	Item ThreadItem `json:"item"`
	// Unix timestamp (in milliseconds) when this item lifecycle started.
	StartedAtMs int64  `json:"startedAtMs"`
	ThreadID    string `json:"threadId"`
	TurnID      string `json:"turnId"`
}

type KindFileSystemSpecialPath

type KindFileSystemSpecialPath struct {
	Subpath *LegacyAppPathString `json:"subpath,omitempty"`
}

type LegacyAppPathString

type LegacyAppPathString = string

type ListFilesCommandAction

type ListFilesCommandAction struct {
	Command string  `json:"command"`
	Path    *string `json:"path,omitempty"`
}

type ListMcpServerStatusParams

type ListMcpServerStatusParams struct {
	// Opaque pagination cursor returned by a previous call.
	Cursor *string `json:"cursor,omitempty"`
	// Controls how much MCP inventory data to fetch for each server. Defaults to `Full` when omitted.
	Detail *McpServerStatusDetail `json:"detail,omitempty"`
	// Optional page size; defaults to a server-defined value.
	Limit    *uint64 `json:"limit,omitempty"`
	ThreadID *string `json:"threadId,omitempty"`
}

type ListMcpServerStatusResponse

type ListMcpServerStatusResponse struct {
	Data []McpServerStatus `json:"data"`
	// Opaque cursor to pass to the next call to continue after the last item. If None, there are no more items to return.
	NextCursor *string `json:"nextCursor,omitempty"`
}

func (ListMcpServerStatusResponse) MarshalJSON

func (v ListMcpServerStatusResponse) MarshalJSON() ([]byte, error)

type LocalAudioUserInput

type LocalAudioUserInput struct {
	Path string `json:"path"`
}

type LocalImageUserInput

type LocalImageUserInput struct {
	Detail *ImageDetail `json:"detail,omitempty"`
	Path   string       `json:"path"`
}

type LocalShellAction

type LocalShellAction struct {
	// Tag is the value of the "type" property observed on decode.
	Tag  string
	Exec *ExecLocalShellAction
	// contains filtered or unexported fields
}

LocalShellAction is an internally-tagged union (tag property "type"). Unknown variants decode without error: only Tag and Raw() are populated.

func (LocalShellAction) MarshalJSON

func (u LocalShellAction) MarshalJSON() ([]byte, error)

func (LocalShellAction) Raw

func (u LocalShellAction) Raw() []byte

Raw returns the original JSON for this union value, if it was decoded.

func (*LocalShellAction) UnmarshalJSON

func (u *LocalShellAction) UnmarshalJSON(data []byte) error

type LocalShellCallResponseItem

type LocalShellCallResponseItem struct {
	Action LocalShellAction `json:"action"`
	// Set when using the Responses API.
	CallID *string `json:"call_id,omitempty"`
	// Legacy id field retained for compatibility with older payloads.
	ID                                     *string                                 `json:"id,omitempty"`
	InternalChatMessageMetadataPassthrough *InternalChatMessageMetadataPassthrough `json:"internal_chat_message_metadata_passthrough,omitempty"`
	Status                                 LocalShellStatus                        `json:"status"`
}

type LocalShellStatus

type LocalShellStatus string
const (
	LocalShellStatusCompleted  LocalShellStatus = "completed"
	LocalShellStatusInProgress LocalShellStatus = "in_progress"
	LocalShellStatusIncomplete LocalShellStatus = "incomplete"
)

type LoginAccountParams

type LoginAccountParams struct {
	// Tag is the value of the "type" property observed on decode.
	Tag                     string
	AmazonBedrock           *AmazonBedrockLoginAccountParams
	AmazonBedrockAccessKeys *AmazonBedrockAccessKeysLoginAccountParams
	APIKey                  *APIKeyLoginAccountParams
	Chatgpt                 *ChatgptLoginAccountParams
	ChatgptAuthTokens       *ChatgptAuthTokensLoginAccountParams
	ChatgptDeviceCode       *ChatgptDeviceCodeLoginAccountParams
	// contains filtered or unexported fields
}

LoginAccountParams is an internally-tagged union (tag property "type"). Unknown variants decode without error: only Tag and Raw() are populated.

func (LoginAccountParams) MarshalJSON

func (u LoginAccountParams) MarshalJSON() ([]byte, error)

func (LoginAccountParams) Raw

func (u LoginAccountParams) Raw() []byte

Raw returns the original JSON for this union value, if it was decoded.

func (*LoginAccountParams) UnmarshalJSON

func (u *LoginAccountParams) UnmarshalJSON(data []byte) error

type LoginAccountResponse

type LoginAccountResponse struct {
	// Tag is the value of the "type" property observed on decode.
	Tag               string
	AmazonBedrock     *AmazonBedrockLoginAccountResponse
	APIKey            *APIKeyLoginAccountResponse
	Chatgpt           *ChatgptLoginAccountResponse
	ChatgptAuthTokens *ChatgptAuthTokensLoginAccountResponse
	ChatgptDeviceCode *ChatgptDeviceCodeLoginAccountResponse
	// contains filtered or unexported fields
}

LoginAccountResponse is an internally-tagged union (tag property "type"). Unknown variants decode without error: only Tag and Raw() are populated.

func (LoginAccountResponse) MarshalJSON

func (u LoginAccountResponse) MarshalJSON() ([]byte, error)

func (LoginAccountResponse) Raw

func (u LoginAccountResponse) Raw() []byte

Raw returns the original JSON for this union value, if it was decoded.

func (*LoginAccountResponse) UnmarshalJSON

func (u *LoginAccountResponse) UnmarshalJSON(data []byte) error

type LoginAppBrand

type LoginAppBrand string
const (
	LoginAppBrandChatgpt LoginAppBrand = "chatgpt"
	LoginAppBrandCodex   LoginAppBrand = "codex"
)

type LogoutAccountResponse

type LogoutAccountResponse struct {
}

type McpAuthStatus

type McpAuthStatus string
const (
	McpAuthStatusBearerToken McpAuthStatus = "bearerToken"
	McpAuthStatusNotLoggedIn McpAuthStatus = "notLoggedIn"
	McpAuthStatusOAuth       McpAuthStatus = "oAuth"
	McpAuthStatusUnknown     McpAuthStatus = "unknown"
	McpAuthStatusUnsupported McpAuthStatus = "unsupported"
)

type McpElicitationArrayType

type McpElicitationArrayType string
const (
	McpElicitationArrayTypeArray McpElicitationArrayType = "array"
)

type McpElicitationBooleanSchema

type McpElicitationBooleanSchema struct {
	Default     *bool                     `json:"default,omitempty"`
	Description *string                   `json:"description,omitempty"`
	Title       *string                   `json:"title,omitempty"`
	Type        McpElicitationBooleanType `json:"type"`
}

type McpElicitationBooleanType

type McpElicitationBooleanType string
const (
	McpElicitationBooleanTypeBoolean McpElicitationBooleanType = "boolean"
)

type McpElicitationConstOption

type McpElicitationConstOption struct {
	Const string `json:"const"`
	Title string `json:"title"`
}

type McpElicitationEnumSchema

type McpElicitationEnumSchema = rawMessage

McpElicitationEnumSchema is an untagged union with no discriminator; decode the raw JSON into one of: McpElicitationSingleSelectEnumSchema, McpElicitationMultiSelectEnumSchema, McpElicitationLegacyTitledEnumSchema.

type McpElicitationLegacyTitledEnumSchema

type McpElicitationLegacyTitledEnumSchema struct {
	Default     *string                  `json:"default,omitempty"`
	Description *string                  `json:"description,omitempty"`
	Enum        []string                 `json:"enum"`
	EnumNames   []string                 `json:"enumNames,omitempty"`
	Title       *string                  `json:"title,omitempty"`
	Type        McpElicitationStringType `json:"type"`
}

func (McpElicitationLegacyTitledEnumSchema) MarshalJSON

func (v McpElicitationLegacyTitledEnumSchema) MarshalJSON() ([]byte, error)

type McpElicitationMultiSelectEnumSchema

type McpElicitationMultiSelectEnumSchema = rawMessage

McpElicitationMultiSelectEnumSchema is an untagged union with no discriminator; decode the raw JSON into one of: McpElicitationUntitledMultiSelectEnumSchema, McpElicitationTitledMultiSelectEnumSchema.

type McpElicitationNumberSchema

type McpElicitationNumberSchema struct {
	Default     *float64                 `json:"default,omitempty"`
	Description *string                  `json:"description,omitempty"`
	Maximum     *float64                 `json:"maximum,omitempty"`
	Minimum     *float64                 `json:"minimum,omitempty"`
	Title       *string                  `json:"title,omitempty"`
	Type        McpElicitationNumberType `json:"type"`
}

type McpElicitationNumberType

type McpElicitationNumberType string
const (
	McpElicitationNumberTypeInteger McpElicitationNumberType = "integer"
	McpElicitationNumberTypeNumber  McpElicitationNumberType = "number"
)

type McpElicitationObjectType

type McpElicitationObjectType string
const (
	McpElicitationObjectTypeObject McpElicitationObjectType = "object"
)

type McpElicitationPrimitiveSchema

type McpElicitationPrimitiveSchema = rawMessage

McpElicitationPrimitiveSchema is an untagged union with no discriminator; decode the raw JSON into one of: McpElicitationEnumSchema, McpElicitationStringSchema, McpElicitationNumberSchema, McpElicitationBooleanSchema.

type McpElicitationSchema

type McpElicitationSchema struct {
	Schema     *string                                  `json:"$schema,omitempty"`
	Properties map[string]McpElicitationPrimitiveSchema `json:"properties"`
	Required   []string                                 `json:"required,omitempty"`
	Type       McpElicitationObjectType                 `json:"type"`
}

Typed form schema for MCP `elicitation/create` requests.

func (McpElicitationSchema) MarshalJSON

func (v McpElicitationSchema) MarshalJSON() ([]byte, error)

type McpElicitationSingleSelectEnumSchema

type McpElicitationSingleSelectEnumSchema = rawMessage

McpElicitationSingleSelectEnumSchema is an untagged union with no discriminator; decode the raw JSON into one of: McpElicitationUntitledSingleSelectEnumSchema, McpElicitationTitledSingleSelectEnumSchema.

type McpElicitationStringFormat

type McpElicitationStringFormat string
const (
	McpElicitationStringFormatDate     McpElicitationStringFormat = "date"
	McpElicitationStringFormatDateTime McpElicitationStringFormat = "date-time"
	McpElicitationStringFormatEmail    McpElicitationStringFormat = "email"
	McpElicitationStringFormatURI      McpElicitationStringFormat = "uri"
)

type McpElicitationStringSchema

type McpElicitationStringSchema struct {
	Default     *string                     `json:"default,omitempty"`
	Description *string                     `json:"description,omitempty"`
	Format      *McpElicitationStringFormat `json:"format,omitempty"`
	MaxLength   *uint64                     `json:"maxLength,omitempty"`
	MinLength   *uint64                     `json:"minLength,omitempty"`
	Title       *string                     `json:"title,omitempty"`
	Type        McpElicitationStringType    `json:"type"`
}

type McpElicitationStringType

type McpElicitationStringType string
const (
	McpElicitationStringTypeString McpElicitationStringType = "string"
)

type McpElicitationTitledEnumItems

type McpElicitationTitledEnumItems struct {
	AnyOf []McpElicitationConstOption `json:"anyOf"`
}

func (McpElicitationTitledEnumItems) MarshalJSON

func (v McpElicitationTitledEnumItems) MarshalJSON() ([]byte, error)

type McpElicitationTitledMultiSelectEnumSchema

type McpElicitationTitledMultiSelectEnumSchema struct {
	Default     []string                      `json:"default,omitempty"`
	Description *string                       `json:"description,omitempty"`
	Items       McpElicitationTitledEnumItems `json:"items"`
	MaxItems    *uint64                       `json:"maxItems,omitempty"`
	MinItems    *uint64                       `json:"minItems,omitempty"`
	Title       *string                       `json:"title,omitempty"`
	Type        McpElicitationArrayType       `json:"type"`
}

type McpElicitationTitledSingleSelectEnumSchema

type McpElicitationTitledSingleSelectEnumSchema struct {
	Default     *string                     `json:"default,omitempty"`
	Description *string                     `json:"description,omitempty"`
	OneOf       []McpElicitationConstOption `json:"oneOf"`
	Title       *string                     `json:"title,omitempty"`
	Type        McpElicitationStringType    `json:"type"`
}

func (McpElicitationTitledSingleSelectEnumSchema) MarshalJSON

type McpElicitationUntitledEnumItems

type McpElicitationUntitledEnumItems struct {
	Enum []string                 `json:"enum"`
	Type McpElicitationStringType `json:"type"`
}

func (McpElicitationUntitledEnumItems) MarshalJSON

func (v McpElicitationUntitledEnumItems) MarshalJSON() ([]byte, error)

type McpElicitationUntitledMultiSelectEnumSchema

type McpElicitationUntitledMultiSelectEnumSchema struct {
	Default     []string                        `json:"default,omitempty"`
	Description *string                         `json:"description,omitempty"`
	Items       McpElicitationUntitledEnumItems `json:"items"`
	MaxItems    *uint64                         `json:"maxItems,omitempty"`
	MinItems    *uint64                         `json:"minItems,omitempty"`
	Title       *string                         `json:"title,omitempty"`
	Type        McpElicitationArrayType         `json:"type"`
}

type McpElicitationUntitledSingleSelectEnumSchema

type McpElicitationUntitledSingleSelectEnumSchema struct {
	Default     *string                  `json:"default,omitempty"`
	Description *string                  `json:"description,omitempty"`
	Enum        []string                 `json:"enum"`
	Title       *string                  `json:"title,omitempty"`
	Type        McpElicitationStringType `json:"type"`
}

func (McpElicitationUntitledSingleSelectEnumSchema) MarshalJSON

type McpServerConnectionStatus

type McpServerConnectionStatus string
const (
	McpServerConnectionStatusAuthenticationRequired McpServerConnectionStatus = "authenticationRequired"
	McpServerConnectionStatusCancelled              McpServerConnectionStatus = "cancelled"
	McpServerConnectionStatusConnected              McpServerConnectionStatus = "connected"
	McpServerConnectionStatusDisabled               McpServerConnectionStatus = "disabled"
	McpServerConnectionStatusFailed                 McpServerConnectionStatus = "failed"
	McpServerConnectionStatusNotStarted             McpServerConnectionStatus = "notStarted"
	McpServerConnectionStatusStarting               McpServerConnectionStatus = "starting"
)

type McpServerElicitationAction

type McpServerElicitationAction string
const (
	McpServerElicitationActionAccept  McpServerElicitationAction = "accept"
	McpServerElicitationActionCancel  McpServerElicitationAction = "cancel"
	McpServerElicitationActionDecline McpServerElicitationAction = "decline"
)

type McpServerElicitationRequestParams

type McpServerElicitationRequestParams struct {
	// Tag is the value of the "mode" property observed on decode.
	Tag                    string
	Form                   *FormMcpServerElicitationRequestParams
	OpenaiForm             *OpenaiFormMcpServerElicitationRequestParams
	OpenaiUserVerification *OpenaiUserVerificationMcpServerElicitationRequestParams
	OpenaiFormCamelCase    *OpenaiFormCamelCaseMcpServerElicitationRequestParams
	URL                    *URLMcpServerElicitationRequestParams
	// contains filtered or unexported fields
}

McpServerElicitationRequestParams is an internally-tagged union (tag property "mode"). Unknown variants decode without error: only Tag and Raw() are populated.

func (McpServerElicitationRequestParams) MarshalJSON

func (u McpServerElicitationRequestParams) MarshalJSON() ([]byte, error)

func (McpServerElicitationRequestParams) Raw

Raw returns the original JSON for this union value, if it was decoded.

func (*McpServerElicitationRequestParams) UnmarshalJSON

func (u *McpServerElicitationRequestParams) UnmarshalJSON(data []byte) error

type McpServerElicitationRequestResponse

type McpServerElicitationRequestResponse struct {
	// Optional client metadata for form-mode action handling.
	Meta   any                        `json:"_meta,omitempty"`
	Action McpServerElicitationAction `json:"action"`
	// Structured user input for accepted elicitations, mirroring RMCP `CreateElicitationResult`.
	Content any `json:"content,omitempty"`
}

type McpServerInfo

type McpServerInfo struct {
	Description *string `json:"description,omitempty"`
	Icons       []any   `json:"icons,omitempty"`
	Name        string  `json:"name"`
	Title       *string `json:"title,omitempty"`
	Version     string  `json:"version"`
	WebsiteURL  *string `json:"websiteUrl,omitempty"`
}

Presentation metadata advertised by an initialized MCP server.

type McpServerStatus

type McpServerStatus struct {
	AuthStatus        McpAuthStatus      `json:"authStatus"`
	Name              string             `json:"name"`
	PluginID          *string            `json:"pluginId,omitempty"`
	ResourceTemplates []ResourceTemplate `json:"resourceTemplates"`
	Resources         []Resource         `json:"resources"`
	// Current thread-runtime connection state; null when unavailable or the configuration changed.
	RuntimeStatus *McpServerConnectionStatus `json:"runtimeStatus,omitempty"`
	ServerInfo    *McpServerInfo             `json:"serverInfo,omitempty"`
	Tools         map[string]Tool            `json:"tools"`
	// Tool discovery failed and no catalog was returned. Null when a catalog is returned, including cached or empty catalogs.
	ToolsError *string `json:"toolsError,omitempty"`
}

func (McpServerStatus) MarshalJSON

func (v McpServerStatus) MarshalJSON() ([]byte, error)

type McpServerStatusDetail

type McpServerStatusDetail string
const (
	McpServerStatusDetailFull             McpServerStatusDetail = "full"
	McpServerStatusDetailToolsAndAuthOnly McpServerStatusDetail = "toolsAndAuthOnly"
)

type McpToolCallAppContext

type McpToolCallAppContext struct {
	ActionName  *string `json:"actionName,omitempty"`
	AppName     *string `json:"appName,omitempty"`
	ConnectorID string  `json:"connectorId"`
	LinkID      *string `json:"linkId,omitempty"`
	ResourceURI *string `json:"resourceUri,omitempty"`
}

type McpToolCallError

type McpToolCallError struct {
	Message string `json:"message"`
}

type McpToolCallResult

type McpToolCallResult struct {
	Meta              any   `json:"_meta,omitempty"`
	Content           []any `json:"content"`
	StructuredContent any   `json:"structuredContent,omitempty"`
}

func (McpToolCallResult) MarshalJSON

func (v McpToolCallResult) MarshalJSON() ([]byte, error)

type McpToolCallStatus

type McpToolCallStatus string
const (
	McpToolCallStatusCompleted  McpToolCallStatus = "completed"
	McpToolCallStatusFailed     McpToolCallStatus = "failed"
	McpToolCallStatusInProgress McpToolCallStatus = "inProgress"
)

type McpToolCallThreadItem

type McpToolCallThreadItem struct {
	AppContext *McpToolCallAppContext `json:"appContext,omitempty"`
	Arguments  any                    `json:"arguments"`
	// The duration of the MCP tool call in milliseconds.
	DurationMs *int64            `json:"durationMs,omitempty"`
	Error      *McpToolCallError `json:"error,omitempty"`
	ID         string            `json:"id"`
	// Deprecated: use `appContext.resourceUri` instead.
	MCPAppResourceURI *string            `json:"mcpAppResourceUri,omitempty"`
	PluginID          *string            `json:"pluginId,omitempty"`
	ReadOnlyHint      *bool              `json:"readOnlyHint,omitempty"`
	Result            *McpToolCallResult `json:"result,omitempty"`
	Server            string             `json:"server"`
	Status            McpToolCallStatus  `json:"status"`
	Tool              string             `json:"tool"`
}

type MemoryCitation

type MemoryCitation struct {
	Entries   []MemoryCitationEntry `json:"entries"`
	ThreadIds []string              `json:"threadIds"`
}

func (MemoryCitation) MarshalJSON

func (v MemoryCitation) MarshalJSON() ([]byte, error)

type MemoryCitationEntry

type MemoryCitationEntry struct {
	LineEnd   uint64 `json:"lineEnd"`
	LineStart uint64 `json:"lineStart"`
	Note      string `json:"note"`
	Path      string `json:"path"`
}

type MentionUserInput

type MentionUserInput struct {
	Name string `json:"name"`
	Path string `json:"path"`
}

type MessagePhase

type MessagePhase string

Classifies an assistant message as interim commentary or final answer text.

const (
	MessagePhaseCommentary  MessagePhase = "commentary"
	MessagePhaseFinalAnswer MessagePhase = "final_answer"
)

type MessageResponseItem

type MessageResponseItem struct {
	Content                                []ContentItem                           `json:"content"`
	ID                                     *string                                 `json:"id,omitempty"`
	InternalChatMessageMetadataPassthrough *InternalChatMessageMetadataPassthrough `json:"internal_chat_message_metadata_passthrough,omitempty"`
	Phase                                  *MessagePhase                           `json:"phase,omitempty"`
	Role                                   string                                  `json:"role"`
}

func (MessageResponseItem) MarshalJSON

func (v MessageResponseItem) MarshalJSON() ([]byte, error)

type MinimalFileSystemSpecialPath

type MinimalFileSystemSpecialPath struct {
}

type MisalignmentErrorDetails

type MisalignmentErrorDetails struct {
	// A substantive localized explanation is required before offering continuation.
	DetailedExplanation *string `json:"detailedExplanation,omitempty"`
	// Open-ended classification; clients must accept categories added by Responses.
	ErrorType *string `json:"errorType,omitempty"`
	// Instruction to submit as the next turn's user input if continuation is confirmed.
	Steer *MisalignmentSteer `json:"steer,omitempty"`
}

type MisalignmentSteer

type MisalignmentSteer struct {
	Message string `json:"message"`
}

type ModeKind

type ModeKind string

Initial collaboration mode to use when the TUI starts.

const (
	ModeKindDefault ModeKind = "default"
	ModeKindPlan    ModeKind = "plan"
)

type Model

type Model struct {
	// Deprecated: use `serviceTiers` instead.
	AdditionalSpeedTiers   []string              `json:"additionalSpeedTiers,omitempty"`
	AvailabilityNux        *ModelAvailabilityNux `json:"availabilityNux,omitempty"`
	DefaultReasoningEffort ReasoningEffort       `json:"defaultReasoningEffort"`
	// Catalog default service tier id for this model, when one is configured.
	DefaultServiceTier *string         `json:"defaultServiceTier,omitempty"`
	Description        string          `json:"description"`
	DisplayName        string          `json:"displayName"`
	Hidden             bool            `json:"hidden"`
	ID                 string          `json:"id"`
	InputModalities    []InputModality `json:"inputModalities,omitempty"`
	IsDefault          bool            `json:"isDefault"`
	Model              string          `json:"model"`
	ModelSpecialty     *string         `json:"modelSpecialty,omitempty"`
	// Multi-agent runtime declared by this model, when available.
	MultiAgentVersion         *MultiAgentVersion      `json:"multiAgentVersion,omitempty"`
	ServiceTiers              []ModelServiceTier      `json:"serviceTiers,omitempty"`
	SupportedReasoningEfforts []ReasoningEffortOption `json:"supportedReasoningEfforts"`
	SupportsPersonality       *bool                   `json:"supportsPersonality,omitempty"`
	Upgrade                   *string                 `json:"upgrade,omitempty"`
	UpgradeInfo               *ModelUpgradeInfo       `json:"upgradeInfo,omitempty"`
}

func (Model) MarshalJSON

func (v Model) MarshalJSON() ([]byte, error)

type ModelAvailabilityNux

type ModelAvailabilityNux struct {
	Message string `json:"message"`
}

type ModelListParams

type ModelListParams struct {
	// Opaque pagination cursor returned by a previous call.
	Cursor *string `json:"cursor,omitempty"`
	// When true, include models that are hidden from the default picker list.
	IncludeHidden *bool `json:"includeHidden,omitempty"`
	// Optional page size; defaults to a reasonable server-side value.
	Limit *uint64 `json:"limit,omitempty"`
}

type ModelListResponse

type ModelListResponse struct {
	Data []Model `json:"data"`
	// Opaque cursor to pass to the next call to continue after the last item. If None, there are no more items to return.
	NextCursor *string `json:"nextCursor,omitempty"`
}

func (ModelListResponse) MarshalJSON

func (v ModelListResponse) MarshalJSON() ([]byte, error)

type ModelServiceTier

type ModelServiceTier struct {
	Description string `json:"description"`
	ID          string `json:"id"`
	Name        string `json:"name"`
}

type ModelUpgradeInfo

type ModelUpgradeInfo struct {
	MigrationMarkdown *string `json:"migrationMarkdown,omitempty"`
	Model             string  `json:"model"`
	ModelLink         *string `json:"modelLink,omitempty"`
	// Informational Unix timestamp for this upgrade's scheduled retirement, if known.
	RetirementAt *int64  `json:"retirementAt,omitempty"`
	UpgradeCopy  *string `json:"upgradeCopy,omitempty"`
}

type MultiAgentMode

type MultiAgentMode struct {
	// Unit holds the bare-string variant value, if that form was used.
	Unit   string
	Custom *string
	// contains filtered or unexported fields
}

Controls the effective multi-agent delegation instructions for a turn. `custom` means the configured mode hint defines the policy instead of a built-in policy. MultiAgentMode is a mixed union: on the wire it is either a bare string (Unit) or a single-key object (one payload field set). Unknown variants decode without error and are retained in Raw().

func (MultiAgentMode) MarshalJSON

func (u MultiAgentMode) MarshalJSON() ([]byte, error)

func (MultiAgentMode) Raw

func (u MultiAgentMode) Raw() []byte

Raw returns the original JSON for this union value, if it was decoded.

func (*MultiAgentMode) UnmarshalJSON

func (u *MultiAgentMode) UnmarshalJSON(data []byte) error

type MultiAgentVersion

type MultiAgentVersion string

Multi-agent runtime supported by a model.

const (
	MultiAgentVersionDisabled MultiAgentVersion = "disabled"
	MultiAgentVersionV1       MultiAgentVersion = "v1"
	MultiAgentVersionV2       MultiAgentVersion = "v2"
)

type NamespaceDynamicToolSpec

type NamespaceDynamicToolSpec struct {
	Description string                     `json:"description"`
	Name        string                     `json:"name"`
	Tools       []DynamicToolNamespaceTool `json:"tools"`
}

func (NamespaceDynamicToolSpec) MarshalJSON

func (v NamespaceDynamicToolSpec) MarshalJSON() ([]byte, error)

type NetworkAccess

type NetworkAccess string
const (
	NetworkAccessEnabled    NetworkAccess = "enabled"
	NetworkAccessRestricted NetworkAccess = "restricted"
)

type NetworkApprovalContext

type NetworkApprovalContext struct {
	Host     string                  `json:"host"`
	Protocol NetworkApprovalProtocol `json:"protocol"`
}

type NetworkApprovalProtocol

type NetworkApprovalProtocol string
const (
	NetworkApprovalProtocolHTTP      NetworkApprovalProtocol = "http"
	NetworkApprovalProtocolHTTPS     NetworkApprovalProtocol = "https"
	NetworkApprovalProtocolSocks5Tcp NetworkApprovalProtocol = "socks5Tcp"
	NetworkApprovalProtocolSocks5Udp NetworkApprovalProtocol = "socks5Udp"
)

type NetworkPolicyAmendment

type NetworkPolicyAmendment struct {
	Action NetworkPolicyRuleAction `json:"action"`
	Host   string                  `json:"host"`
}

type NetworkPolicyRuleAction

type NetworkPolicyRuleAction string
const (
	NetworkPolicyRuleActionAllow NetworkPolicyRuleAction = "allow"
	NetworkPolicyRuleActionDeny  NetworkPolicyRuleAction = "deny"
)

type NonSteerableTurnKind

type NonSteerableTurnKind string
const (
	NonSteerableTurnKindCompact NonSteerableTurnKind = "compact"
	NonSteerableTurnKindReview  NonSteerableTurnKind = "review"
)

type NotLoadedThreadStatus

type NotLoadedThreadStatus struct {
}

type Notification

type Notification struct {
	Method string `json:"method"`
	Params any    `json:"params,omitempty"`
}

Notification is an outbound Memoh → app-server notification.

func (Notification) MarshalJSON

func (n Notification) MarshalJSON() ([]byte, error)

type OpenPageResponsesApiWebSearchAction

type OpenPageResponsesApiWebSearchAction struct {
	URL *string `json:"url,omitempty"`
}

type OpenPageWebSearchAction

type OpenPageWebSearchAction struct {
	URL *string `json:"url,omitempty"`
}

type OpenaiFormCamelCaseMcpServerElicitationRequestParams

type OpenaiFormCamelCaseMcpServerElicitationRequestParams struct {
	Meta            any    `json:"_meta,omitempty"`
	Message         string `json:"message"`
	RequestedSchema any    `json:"requestedSchema"`
}

type OpenaiFormMcpServerElicitationRequestParams

type OpenaiFormMcpServerElicitationRequestParams struct {
	Meta            any    `json:"_meta,omitempty"`
	Message         string `json:"message"`
	RequestedSchema any    `json:"requestedSchema"`
}

type OpenaiUserVerificationMcpServerElicitationRequestParams

type OpenaiUserVerificationMcpServerElicitationRequestParams struct {
	Challenge   string `json:"challenge"`
	Description string `json:"description"`
	Title       string `json:"title"`
}

A device-authenticated approval; accepted responses contain the proof in `content`.

type OtherResponseItem

type OtherResponseItem struct {
}

type OtherResponsesApiWebSearchAction

type OtherResponsesApiWebSearchAction struct {
}

type OtherWebSearchAction

type OtherWebSearchAction struct {
}

type OutputTextContentItem

type OutputTextContentItem struct {
	Text string `json:"text"`
}

type PatchApplyStatus

type PatchApplyStatus string
const (
	PatchApplyStatusCompleted  PatchApplyStatus = "completed"
	PatchApplyStatusDeclined   PatchApplyStatus = "declined"
	PatchApplyStatusFailed     PatchApplyStatus = "failed"
	PatchApplyStatusInProgress PatchApplyStatus = "inProgress"
)

type PatchChangeKind

type PatchChangeKind struct {
	// Tag is the value of the "type" property observed on decode.
	Tag    string
	Add    *AddPatchChangeKind
	Delete *DeletePatchChangeKind
	Update *UpdatePatchChangeKind
	// contains filtered or unexported fields
}

PatchChangeKind is an internally-tagged union (tag property "type"). Unknown variants decode without error: only Tag and Raw() are populated.

func (PatchChangeKind) MarshalJSON

func (u PatchChangeKind) MarshalJSON() ([]byte, error)

func (PatchChangeKind) Raw

func (u PatchChangeKind) Raw() []byte

Raw returns the original JSON for this union value, if it was decoded.

func (*PatchChangeKind) UnmarshalJSON

func (u *PatchChangeKind) UnmarshalJSON(data []byte) error

type PathFileSystemPath

type PathFileSystemPath struct {
	Path LegacyAppPathString `json:"path"`
}

type PermissionGrantScope

type PermissionGrantScope string
const (
	PermissionGrantScopeSession PermissionGrantScope = "session"
	PermissionGrantScopeTurn    PermissionGrantScope = "turn"
)

type PermissionsRequestApprovalParams

type PermissionsRequestApprovalParams struct {
	Cwd           LegacyAppPathString      `json:"cwd"`
	EnvironmentID *string                  `json:"environmentId,omitempty"`
	ItemID        string                   `json:"itemId"`
	Permissions   RequestPermissionProfile `json:"permissions"`
	Reason        *string                  `json:"reason,omitempty"`
	// Unix timestamp (in milliseconds) when this approval request started.
	StartedAtMs int64  `json:"startedAtMs"`
	ThreadID    string `json:"threadId"`
	TurnID      string `json:"turnId"`
}

type PermissionsRequestApprovalResponse

type PermissionsRequestApprovalResponse struct {
	Permissions GrantedPermissionProfile `json:"permissions"`
	Scope       *PermissionGrantScope    `json:"scope,omitempty"`
	// Review every subsequent command in this turn before normal sandboxed execution.
	StrictAutoReview *bool `json:"strictAutoReview,omitempty"`
}

type Personality

type Personality string
const (
	PersonalityFriendly  Personality = "friendly"
	PersonalityNone      Personality = "none"
	PersonalityPragmatic Personality = "pragmatic"
)

type PlanThreadItem

type PlanThreadItem struct {
	ID   string `json:"id"`
	Text string `json:"text"`
}

EXPERIMENTAL - proposed plan item content. The completed plan item is authoritative and may not match the concatenation of `PlanDelta` text.

type PlanType

type PlanType string
const (
	PlanTypeBusiness                    PlanType = "business"
	PlanTypeEdu                         PlanType = "edu"
	PlanTypeEduPlus                     PlanType = "edu_plus"
	PlanTypeEduPro                      PlanType = "edu_pro"
	PlanTypeEnt26                       PlanType = "ent26"
	PlanTypeEnterprise                  PlanType = "enterprise"
	PlanTypeEnterpriseCbpAutomation     PlanType = "enterprise_cbp_automation"
	PlanTypeEnterpriseCbpUsageBased     PlanType = "enterprise_cbp_usage_based"
	PlanTypeFree                        PlanType = "free"
	PlanTypeGo                          PlanType = "go"
	PlanTypePlus                        PlanType = "plus"
	PlanTypePro                         PlanType = "pro"
	PlanTypeProlite                     PlanType = "prolite"
	PlanTypeSelfServeBusinessProlite    PlanType = "self_serve_business_prolite"
	PlanTypeSelfServeBusinessUsageBased PlanType = "self_serve_business_usage_based"
	PlanTypeTeam                        PlanType = "team"
	PlanTypeUnknown                     PlanType = "unknown"
)

type RPCError

type RPCError struct {
	Code    int64           `json:"code"`
	Message string          `json:"message"`
	Data    json.RawMessage `json:"data,omitempty"`
}

RPCError is the JSON-RPC error object. Codes are not enumerated by the schema; treat them as opaque and rely on CodexErrorInfo where present.

func (*RPCError) Error

func (e *RPCError) Error() string

type RateLimitReachedType

type RateLimitReachedType string
const (
	RateLimitReachedTypeRateLimitReached                 RateLimitReachedType = "rate_limit_reached"
	RateLimitReachedTypeWorkspaceMemberCreditsDepleted   RateLimitReachedType = "workspace_member_credits_depleted"
	RateLimitReachedTypeWorkspaceMemberUsageLimitReached RateLimitReachedType = "workspace_member_usage_limit_reached"
	RateLimitReachedTypeWorkspaceOwnerCreditsDepleted    RateLimitReachedType = "workspace_owner_credits_depleted"
	RateLimitReachedTypeWorkspaceOwnerUsageLimitReached  RateLimitReachedType = "workspace_owner_usage_limit_reached"
)

type RateLimitResetCredit

type RateLimitResetCredit struct {
	// Backend-provided display description for this credit, or `null` when unavailable.
	Description *string `json:"description,omitempty"`
	// Unix timestamp in seconds when the credit expires, or `null` if it does not expire.
	ExpiresAt *int64 `json:"expiresAt,omitempty"`
	// Unix timestamp in seconds when the credit was granted.
	GrantedAt int64 `json:"grantedAt"`
	// Opaque backend identifier for this reset credit.
	ID        string                     `json:"id"`
	ResetType RateLimitResetType         `json:"resetType"`
	Status    RateLimitResetCreditStatus `json:"status"`
	// Backend-provided display title for this credit, or `null` when unavailable.
	Title *string `json:"title,omitempty"`
}

type RateLimitResetCreditStatus

type RateLimitResetCreditStatus string
const (
	RateLimitResetCreditStatusAvailable RateLimitResetCreditStatus = "available"
	RateLimitResetCreditStatusRedeemed  RateLimitResetCreditStatus = "redeemed"
	RateLimitResetCreditStatusRedeeming RateLimitResetCreditStatus = "redeeming"
	RateLimitResetCreditStatusUnknown   RateLimitResetCreditStatus = "unknown"
)

type RateLimitResetCreditsSummary

type RateLimitResetCreditsSummary struct {
	AvailableCount int64 `json:"availableCount"`
	// Detail rows for available reset credits, when the backend provides them.
	Credits []RateLimitResetCredit `json:"credits,omitempty"`
}

type RateLimitResetType

type RateLimitResetType string
const (
	RateLimitResetTypeCodexRateLimits RateLimitResetType = "codexRateLimits"
	RateLimitResetTypeUnknown         RateLimitResetType = "unknown"
)

type RateLimitSnapshot

type RateLimitSnapshot struct {
	Credits         *CreditsSnapshot           `json:"credits,omitempty"`
	IndividualLimit *SpendControlLimitSnapshot `json:"individualLimit,omitempty"`
	LimitID         *string                    `json:"limitId,omitempty"`
	LimitName       *string                    `json:"limitName,omitempty"`
	// Normal model whose display name and reasoning options describe this quota alias.
	NormalModelSlug      *string               `json:"normalModelSlug,omitempty"`
	PlanType             *PlanType             `json:"planType,omitempty"`
	Primary              *RateLimitWindow      `json:"primary,omitempty"`
	RateLimitReachedType *RateLimitReachedType `json:"rateLimitReachedType,omitempty"`
	Secondary            *RateLimitWindow      `json:"secondary,omitempty"`
	// Backend-reported spend-control state. `None` is unavailable, not a sparse-update recovery.
	SpendControlReached *bool `json:"spendControlReached,omitempty"`
}

type RateLimitWindow

type RateLimitWindow struct {
	ResetsAt           *int64 `json:"resetsAt,omitempty"`
	UsedPercent        int64  `json:"usedPercent"`
	WindowDurationMins *int64 `json:"windowDurationMins,omitempty"`
}

type ReadCommandAction

type ReadCommandAction struct {
	Command string              `json:"command"`
	Name    string              `json:"name"`
	Path    LegacyAppPathString `json:"path"`
}

type ReadOnlySandboxPolicy

type ReadOnlySandboxPolicy struct {
	NetworkAccess *bool `json:"networkAccess,omitempty"`
}

type ReasoningEffort

type ReasoningEffort = string

A non-empty reasoning effort value advertised by the model.

type ReasoningEffortOption

type ReasoningEffortOption struct {
	Description     string          `json:"description"`
	ReasoningEffort ReasoningEffort `json:"reasoningEffort"`
}

type ReasoningItemContent

type ReasoningItemContent struct {
	// Tag is the value of the "type" property observed on decode.
	Tag           string
	ReasoningText *ReasoningTextReasoningItemContent
	Text          *TextReasoningItemContent
	// contains filtered or unexported fields
}

ReasoningItemContent is an internally-tagged union (tag property "type"). Unknown variants decode without error: only Tag and Raw() are populated.

func (ReasoningItemContent) MarshalJSON

func (u ReasoningItemContent) MarshalJSON() ([]byte, error)

func (ReasoningItemContent) Raw

func (u ReasoningItemContent) Raw() []byte

Raw returns the original JSON for this union value, if it was decoded.

func (*ReasoningItemContent) UnmarshalJSON

func (u *ReasoningItemContent) UnmarshalJSON(data []byte) error

type ReasoningItemReasoningSummary

type ReasoningItemReasoningSummary struct {
	// Tag is the value of the "type" property observed on decode.
	Tag         string
	SummaryText *SummaryTextReasoningItemReasoningSummary
	// contains filtered or unexported fields
}

ReasoningItemReasoningSummary is an internally-tagged union (tag property "type"). Unknown variants decode without error: only Tag and Raw() are populated.

func (ReasoningItemReasoningSummary) MarshalJSON

func (u ReasoningItemReasoningSummary) MarshalJSON() ([]byte, error)

func (ReasoningItemReasoningSummary) Raw

Raw returns the original JSON for this union value, if it was decoded.

func (*ReasoningItemReasoningSummary) UnmarshalJSON

func (u *ReasoningItemReasoningSummary) UnmarshalJSON(data []byte) error

type ReasoningResponseItem

type ReasoningResponseItem struct {
	Content                                []ReasoningItemContent                  `json:"content,omitempty"`
	EncryptedContent                       *string                                 `json:"encrypted_content,omitempty"`
	ID                                     *string                                 `json:"id,omitempty"`
	InternalChatMessageMetadataPassthrough *InternalChatMessageMetadataPassthrough `json:"internal_chat_message_metadata_passthrough,omitempty"`
	Summary                                []ReasoningItemReasoningSummary         `json:"summary"`
}

func (ReasoningResponseItem) MarshalJSON

func (v ReasoningResponseItem) MarshalJSON() ([]byte, error)

type ReasoningSummary

type ReasoningSummary string

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

const (
	ReasoningSummaryAuto     ReasoningSummary = "auto"
	ReasoningSummaryConcise  ReasoningSummary = "concise"
	ReasoningSummaryDetailed ReasoningSummary = "detailed"
	ReasoningSummaryNone     ReasoningSummary = "none"
)

type ReasoningSummaryPartAddedNotification

type ReasoningSummaryPartAddedNotification struct {
	ItemID       string `json:"itemId"`
	SummaryIndex int64  `json:"summaryIndex"`
	ThreadID     string `json:"threadId"`
	TurnID       string `json:"turnId"`
}

type ReasoningSummaryTextDeltaNotification

type ReasoningSummaryTextDeltaNotification struct {
	Delta        string `json:"delta"`
	ItemID       string `json:"itemId"`
	SummaryIndex int64  `json:"summaryIndex"`
	ThreadID     string `json:"threadId"`
	TurnID       string `json:"turnId"`
}

type ReasoningTextDeltaNotification

type ReasoningTextDeltaNotification struct {
	ContentIndex int64  `json:"contentIndex"`
	Delta        string `json:"delta"`
	ItemID       string `json:"itemId"`
	ThreadID     string `json:"threadId"`
	TurnID       string `json:"turnId"`
}

type ReasoningTextReasoningItemContent

type ReasoningTextReasoningItemContent struct {
	Text string `json:"text"`
}

type ReasoningThreadItem

type ReasoningThreadItem struct {
	Content []string `json:"content,omitempty"`
	ID      string   `json:"id"`
	Summary []string `json:"summary,omitempty"`
}

type Request

type Request struct {
	ID     RequestID `json:"id"`
	Method string    `json:"method"`
	Params any       `json:"params,omitempty"`
}

Request is an outbound Memoh → app-server request.

func (Request) MarshalJSON

func (r Request) MarshalJSON() ([]byte, error)

type RequestID

type RequestID struct {
	// contains filtered or unexported fields
}

RequestID mirrors the app-server RequestId, which is a string or a number. The original JSON representation is preserved so ids echo back byte-for-byte: 42 must not become "42".

func NewRequestID

func NewRequestID(n uint64) RequestID

NewRequestID returns a numeric request id.

func (RequestID) IsZero

func (id RequestID) IsZero() bool

IsZero reports whether the id is unset.

func (RequestID) Key

func (id RequestID) Key() string

Key returns the exact wire representation, usable as a correlation map key.

func (RequestID) MarshalJSON

func (id RequestID) MarshalJSON() ([]byte, error)

func (RequestID) String

func (id RequestID) String() string

func (*RequestID) UnmarshalJSON

func (id *RequestID) UnmarshalJSON(data []byte) error

type RequestPermissionProfile

type RequestPermissionProfile struct {
	FileSystem *AdditionalFileSystemPermissions `json:"fileSystem,omitempty"`
	Network    *AdditionalNetworkPermissions    `json:"network,omitempty"`
}

type Resource

type Resource struct {
	Meta        any     `json:"_meta,omitempty"`
	Annotations any     `json:"annotations,omitempty"`
	Description *string `json:"description,omitempty"`
	Icons       []any   `json:"icons,omitempty"`
	MimeType    *string `json:"mimeType,omitempty"`
	Name        string  `json:"name"`
	Size        *int64  `json:"size,omitempty"`
	Title       *string `json:"title,omitempty"`
	URI         string  `json:"uri"`
}

A known resource that the server is capable of reading.

type ResourceTemplate

type ResourceTemplate struct {
	Annotations any     `json:"annotations,omitempty"`
	Description *string `json:"description,omitempty"`
	MimeType    *string `json:"mimeType,omitempty"`
	Name        string  `json:"name"`
	Title       *string `json:"title,omitempty"`
	URITemplate string  `json:"uriTemplate"`
}

A template description for resources available on the server.

type Response

type Response struct {
	ID     RequestID `json:"id"`
	Result any       `json:"result"`
}

Response answers an app-server → Memoh request.

type ResponseItem

type ResponseItem struct {
	// Tag is the value of the "type" property observed on decode.
	Tag                  string
	AgentMessage         *AgentMessageResponseItem
	Compaction           *CompactionResponseItem
	CompactionTrigger    *CompactionTriggerResponseItem
	ConfigurationUpdate  *ConfigurationUpdateResponseItem
	ContextCompaction    *ContextCompactionResponseItem
	CustomToolCall       *CustomToolCallResponseItem
	CustomToolCallOutput *CustomToolCallOutputResponseItem
	FunctionCall         *FunctionCallResponseItem
	FunctionCallOutput   *FunctionCallOutputResponseItem
	ImageGenerationCall  *ImageGenerationCallResponseItem
	LocalShellCall       *LocalShellCallResponseItem
	Message              *MessageResponseItem
	Other                *OtherResponseItem
	Reasoning            *ReasoningResponseItem
	ToolSearchCall       *ToolSearchCallResponseItem
	ToolSearchOutput     *ToolSearchOutputResponseItem
	WebSearchCall        *WebSearchCallResponseItem
	// contains filtered or unexported fields
}

ResponseItem is an internally-tagged union (tag property "type"). Unknown variants decode without error: only Tag and Raw() are populated.

func (ResponseItem) MarshalJSON

func (u ResponseItem) MarshalJSON() ([]byte, error)

func (ResponseItem) Raw

func (u ResponseItem) Raw() []byte

Raw returns the original JSON for this union value, if it was decoded.

func (*ResponseItem) UnmarshalJSON

func (u *ResponseItem) UnmarshalJSON(data []byte) error

type ResponsesApiWebSearchAction

type ResponsesApiWebSearchAction struct {
	// Tag is the value of the "type" property observed on decode.
	Tag        string
	FindInPage *FindInPageResponsesApiWebSearchAction
	OpenPage   *OpenPageResponsesApiWebSearchAction
	Other      *OtherResponsesApiWebSearchAction
	Search     *SearchResponsesApiWebSearchAction
	// contains filtered or unexported fields
}

ResponsesApiWebSearchAction is an internally-tagged union (tag property "type"). Unknown variants decode without error: only Tag and Raw() are populated.

func (ResponsesApiWebSearchAction) MarshalJSON

func (u ResponsesApiWebSearchAction) MarshalJSON() ([]byte, error)

func (ResponsesApiWebSearchAction) Raw

Raw returns the original JSON for this union value, if it was decoded.

func (*ResponsesApiWebSearchAction) UnmarshalJSON

func (u *ResponsesApiWebSearchAction) UnmarshalJSON(data []byte) error

type ReviewDelivery

type ReviewDelivery string
const (
	ReviewDeliveryDetached ReviewDelivery = "detached"
	ReviewDeliveryInline   ReviewDelivery = "inline"
)

type ReviewStartParams

type ReviewStartParams struct {
	// Where to run the review: inline (default) on the current thread or detached on a new thread (returned in `reviewThreadId`). Detached delivery is deprecated and emits `deprecationNotice`. Use `thread/start` followed by an inline review for a separate review thread.
	Delivery *ReviewDelivery `json:"delivery,omitempty"`
	Target   ReviewTarget    `json:"target"`
	ThreadID string          `json:"threadId"`
}

type ReviewStartResponse

type ReviewStartResponse struct {
	// Identifies the thread where the review runs.
	ReviewThreadID string `json:"reviewThreadId"`
	Turn           Turn   `json:"turn"`
}

type ReviewTarget

type ReviewTarget struct {
	// Tag is the value of the "type" property observed on decode.
	Tag                string
	BaseBranch         *BaseBranchReviewTarget
	Commit             *CommitReviewTarget
	Custom             *CustomReviewTarget
	UncommittedChanges *UncommittedChangesReviewTarget
	// contains filtered or unexported fields
}

ReviewTarget is an internally-tagged union (tag property "type"). Unknown variants decode without error: only Tag and Raw() are populated.

func (ReviewTarget) MarshalJSON

func (u ReviewTarget) MarshalJSON() ([]byte, error)

func (ReviewTarget) Raw

func (u ReviewTarget) Raw() []byte

Raw returns the original JSON for this union value, if it was decoded.

func (*ReviewTarget) UnmarshalJSON

func (u *ReviewTarget) UnmarshalJSON(data []byte) error

type RootFileSystemSpecialPath

type RootFileSystemSpecialPath struct {
}

type SandboxMode

type SandboxMode string
const (
	SandboxModeDangerFullAccess SandboxMode = "danger-full-access"
	SandboxModeReadOnly         SandboxMode = "read-only"
	SandboxModeWorkspaceWrite   SandboxMode = "workspace-write"
)

type SandboxPolicy

type SandboxPolicy struct {
	// Tag is the value of the "type" property observed on decode.
	Tag              string
	DangerFullAccess *DangerFullAccessSandboxPolicy
	ExternalSandbox  *ExternalSandboxSandboxPolicy
	ReadOnly         *ReadOnlySandboxPolicy
	WorkspaceWrite   *WorkspaceWriteSandboxPolicy
	// contains filtered or unexported fields
}

SandboxPolicy is an internally-tagged union (tag property "type"). Unknown variants decode without error: only Tag and Raw() are populated.

func (SandboxPolicy) MarshalJSON

func (u SandboxPolicy) MarshalJSON() ([]byte, error)

func (SandboxPolicy) Raw

func (u SandboxPolicy) Raw() []byte

Raw returns the original JSON for this union value, if it was decoded.

func (*SandboxPolicy) UnmarshalJSON

func (u *SandboxPolicy) UnmarshalJSON(data []byte) error

type SearchCommandAction

type SearchCommandAction struct {
	Command string  `json:"command"`
	Path    *string `json:"path,omitempty"`
	Query   *string `json:"query,omitempty"`
}

type SearchResponsesApiWebSearchAction

type SearchResponsesApiWebSearchAction struct {
	Queries []string `json:"queries,omitempty"`
	Query   *string  `json:"query,omitempty"`
}

type SearchWebSearchAction

type SearchWebSearchAction struct {
	Queries []string `json:"queries,omitempty"`
	Query   *string  `json:"query,omitempty"`
}

type SelectedCapabilityRoot

type SelectedCapabilityRoot struct {
	// Stable identifier supplied by the capability selection platform.
	ID string `json:"id"`
	// Where the selected root can be resolved.
	Location CapabilityRootLocation `json:"location"`
}

A user-selected root that can expose one or more runtime capabilities.

type ServerRequestResolvedNotification

type ServerRequestResolvedNotification struct {
	RequestID RequestID `json:"requestId"`
	ThreadID  string    `json:"threadId"`
}

type SessionSource

type SessionSource struct {
	// Unit holds the bare-string variant value, if that form was used.
	Unit     string
	Custom   *string
	SubAgent *SubAgentSource
	// contains filtered or unexported fields
}

SessionSource is a mixed union: on the wire it is either a bare string (Unit) or a single-key object (one payload field set). Unknown variants decode without error and are retained in Raw().

func (SessionSource) MarshalJSON

func (u SessionSource) MarshalJSON() ([]byte, error)

func (SessionSource) Raw

func (u SessionSource) Raw() []byte

Raw returns the original JSON for this union value, if it was decoded.

func (*SessionSource) UnmarshalJSON

func (u *SessionSource) UnmarshalJSON(data []byte) error

type Settings

type Settings struct {
	DeveloperInstructions *string          `json:"developer_instructions,omitempty"`
	Model                 string           `json:"model"`
	ReasoningEffort       *ReasoningEffort `json:"reasoning_effort,omitempty"`
}

Settings for a collaboration mode.

type SkillDependencies

type SkillDependencies struct {
	Tools []SkillToolDependency `json:"tools"`
}

func (SkillDependencies) MarshalJSON

func (v SkillDependencies) MarshalJSON() ([]byte, error)

type SkillErrorInfo

type SkillErrorInfo struct {
	Message string `json:"message"`
	Path    string `json:"path"`
}

type SkillInterface

type SkillInterface struct {
	BrandColor    *string          `json:"brandColor,omitempty"`
	DefaultPrompt *string          `json:"defaultPrompt,omitempty"`
	DisplayName   *string          `json:"displayName,omitempty"`
	IconLarge     *AbsolutePathBuf `json:"iconLarge,omitempty"`
	// Remote large icon URL from the plugin catalog.
	IconLargeURL *string          `json:"iconLargeUrl,omitempty"`
	IconSmall    *AbsolutePathBuf `json:"iconSmall,omitempty"`
	// Remote small icon URL from the plugin catalog.
	IconSmallURL     *string `json:"iconSmallUrl,omitempty"`
	ShortDescription *string `json:"shortDescription,omitempty"`
}

type SkillMetadata

type SkillMetadata struct {
	Dependencies *SkillDependencies `json:"dependencies,omitempty"`
	Description  string             `json:"description"`
	Enabled      bool               `json:"enabled"`
	Interface    *SkillInterface    `json:"interface,omitempty"`
	Name         string             `json:"name"`
	Path         AbsolutePathBuf    `json:"path"`
	// Owning plugin ID, matching `PluginSummary.id`, when known.
	PluginID *string    `json:"pluginId,omitempty"`
	Scope    SkillScope `json:"scope"`
	// Legacy short_description from SKILL.md. Prefer SKILL.json interface.short_description.
	ShortDescription *string `json:"shortDescription,omitempty"`
}

type SkillScope

type SkillScope string
const (
	SkillScopeAdmin  SkillScope = "admin"
	SkillScopeRepo   SkillScope = "repo"
	SkillScopeSystem SkillScope = "system"
	SkillScopeUser   SkillScope = "user"
)

type SkillToolDependency

type SkillToolDependency struct {
	Command     *string `json:"command,omitempty"`
	Description *string `json:"description,omitempty"`
	Transport   *string `json:"transport,omitempty"`
	Type        string  `json:"type"`
	URL         *string `json:"url,omitempty"`
	Value       string  `json:"value"`
}

type SkillUserInput

type SkillUserInput struct {
	Name string `json:"name"`
	Path string `json:"path"`
}

type SkillsListEntry

type SkillsListEntry struct {
	Cwd    string           `json:"cwd"`
	Errors []SkillErrorInfo `json:"errors"`
	Skills []SkillMetadata  `json:"skills"`
}

func (SkillsListEntry) MarshalJSON

func (v SkillsListEntry) MarshalJSON() ([]byte, error)

type SkillsListParams

type SkillsListParams struct {
	// When empty, defaults to the current session working directory.
	Cwds []string `json:"cwds,omitempty"`
	// When true, bypass the skills cache and re-scan skills from disk.
	ForceReload *bool `json:"forceReload,omitempty"`
}

type SkillsListResponse

type SkillsListResponse struct {
	Data []SkillsListEntry `json:"data"`
}

func (SkillsListResponse) MarshalJSON

func (v SkillsListResponse) MarshalJSON() ([]byte, error)

type SlashTmpFileSystemSpecialPath

type SlashTmpFileSystemSpecialPath struct {
}

type SleepThreadItem

type SleepThreadItem struct {
	DurationMs uint64 `json:"durationMs"`
	ID         string `json:"id"`
}

Display item emitted by the interruptible `clock.sleep` tool.

type SortDirection

type SortDirection string
const (
	SortDirectionAsc  SortDirection = "asc"
	SortDirectionDesc SortDirection = "desc"
)

type SpecialFileSystemPath

type SpecialFileSystemPath struct {
	Value FileSystemSpecialPath `json:"value"`
}

type SpendControlLimitSnapshot

type SpendControlLimitSnapshot struct {
	Limit            string `json:"limit"`
	RemainingPercent int64  `json:"remainingPercent"`
	ResetsAt         int64  `json:"resetsAt"`
	Used             string `json:"used"`
}

type SubAgentActivityKind

type SubAgentActivityKind string
const (
	SubAgentActivityKindCompleted   SubAgentActivityKind = "completed"
	SubAgentActivityKindInteracted  SubAgentActivityKind = "interacted"
	SubAgentActivityKindInterrupted SubAgentActivityKind = "interrupted"
	SubAgentActivityKindStarted     SubAgentActivityKind = "started"
)

type SubAgentActivityThreadItem

type SubAgentActivityThreadItem struct {
	AgentPath     string               `json:"agentPath"`
	AgentThreadID string               `json:"agentThreadId"`
	ID            string               `json:"id"`
	Kind          SubAgentActivityKind `json:"kind"`
}

type SubAgentSource

type SubAgentSource struct {
	// Unit holds the bare-string variant value, if that form was used.
	Unit        string
	Other       *string
	ThreadSpawn *SubAgentSourceThreadSpawn
	// contains filtered or unexported fields
}

SubAgentSource is a mixed union: on the wire it is either a bare string (Unit) or a single-key object (one payload field set). Unknown variants decode without error and are retained in Raw().

func (SubAgentSource) MarshalJSON

func (u SubAgentSource) MarshalJSON() ([]byte, error)

func (SubAgentSource) Raw

func (u SubAgentSource) Raw() []byte

Raw returns the original JSON for this union value, if it was decoded.

func (*SubAgentSource) UnmarshalJSON

func (u *SubAgentSource) UnmarshalJSON(data []byte) error

type SubAgentSourceThreadSpawn

type SubAgentSourceThreadSpawn struct {
	AgentNickname  *string    `json:"agent_nickname,omitempty"`
	AgentPath      *AgentPath `json:"agent_path,omitempty"`
	AgentRole      *string    `json:"agent_role,omitempty"`
	Depth          int64      `json:"depth"`
	ParentThreadID ThreadId   `json:"parent_thread_id"`
}

type SummaryTextReasoningItemReasoningSummary

type SummaryTextReasoningItemReasoningSummary struct {
	Text string `json:"text"`
}

type SystemErrorThreadStatus

type SystemErrorThreadStatus struct {
}

type TextElement

type TextElement struct {
	// Byte range in the parent `text` buffer that this element occupies.
	ByteRange ByteRange `json:"byteRange"`
	// Optional human-readable placeholder for the element, displayed in the UI.
	Placeholder *string `json:"placeholder,omitempty"`
}

type TextPosition

type TextPosition struct {
	// 1-based column number (in Unicode scalar values).
	Column uint64 `json:"column"`
	// 1-based line number.
	Line uint64 `json:"line"`
}

type TextRange

type TextRange struct {
	End   TextPosition `json:"end"`
	Start TextPosition `json:"start"`
}

type TextReasoningItemContent

type TextReasoningItemContent struct {
	Text string `json:"text"`
}

type TextUserInput

type TextUserInput struct {
	Text string `json:"text"`
	// UI-defined spans within `text` used to render or persist special elements.
	TextElements []TextElement `json:"text_elements,omitempty"`
}

type Thread

type Thread struct {
	// Optional random unique nickname assigned to an AgentControl-spawned sub-agent.
	AgentNickname *string `json:"agentNickname,omitempty"`
	// Optional role (agent_role) assigned to an AgentControl-spawned sub-agent.
	AgentRole *string `json:"agentRole,omitempty"`
	// Whether the app server accepts direct turn input for this loaded thread. `None` means the capability is unavailable, such as for an unloaded stored thread.
	CanAcceptDirectInput *bool `json:"canAcceptDirectInput,omitempty"`
	// Version of the CLI that created the thread.
	CliVersion string `json:"cliVersion"`
	// Unix timestamp (in seconds) when the thread was created.
	CreatedAt int64 `json:"createdAt"`
	// Working directory captured for the thread.
	Cwd AbsolutePathBuf `json:"cwd"`
	// Saved Daybreak choice, independent of turn execution. Null if unset.
	DaybreakEnabled *bool `json:"daybreakEnabled,omitempty"`
	// Current environments for a loaded thread, in priority order, primary first. `null` means the thread is not loaded or the server does not expose its selection. An empty list means no environments are selected. This does not report connection status.
	Environments []ThreadEnvironment `json:"environments,omitempty"`
	// Whether the thread is ephemeral and should not be materialized on disk.
	Ephemeral bool `json:"ephemeral"`
	// Optional implementation-specific thread data.
	Extra *ThreadExtra `json:"extra,omitempty"`
	// Source thread id when this thread was created by forking another thread.
	ForkedFromID *string `json:"forkedFromId,omitempty"`
	// Optional Git metadata captured when the thread was created.
	GitInfo *GitInfo `json:"gitInfo,omitempty"`
	// Persisted thread history contract selected when this thread was created.
	HistoryMode *ThreadHistoryMode `json:"historyMode,omitempty"`
	// Identifier for this thread. Codex-generated thread IDs are UUIDv7.
	ID string `json:"id"`
	// Current configured model when loaded, otherwise the latest persisted model. Null when unavailable. This is not per-turn execution telemetry.
	Model *string `json:"model,omitempty"`
	// Model provider used for this thread (for example, 'openai').
	ModelProvider string `json:"modelProvider"`
	// Optional user-facing thread title.
	Name *string `json:"name,omitempty"`
	// Originator recorded when the thread was created, independent of its current client or executor. Null when the recorded originator is unavailable.
	Originator *string `json:"originator,omitempty"`
	// The ID of the parent thread. This will only be set if this thread is a subagent.
	ParentThreadID *string `json:"parentThreadId,omitempty"`
	// [UNSTABLE] Path to the thread on disk.
	Path *string `json:"path,omitempty"`
	// Usually the first user message in the thread, if available.
	Preview string `json:"preview"`
	// Canonical project assignment owned by app-server, if any.
	ProjectID *string `json:"projectId"`
	// Current configured reasoning effort when loaded, otherwise the latest persisted effort. Null when unset or unavailable. This is not per-turn execution telemetry.
	ReasoningEffort *ReasoningEffort `json:"reasoningEffort,omitempty"`
	// Unix timestamp (in seconds) used for thread recency ordering.
	RecencyAt *int64 `json:"recencyAt,omitempty"`
	// The independently persisted section selected for this thread, if any.
	Section *ThreadSection `json:"section,omitempty"`
	// Unix timestamp in seconds when the thread entered its current section.
	SectionEnteredAt *int64 `json:"sectionEnteredAt,omitempty"`
	// Session id shared by threads that belong to the same session tree.
	SessionID string `json:"sessionId"`
	// Origin of the thread (CLI, VSCode, codex exec, codex app-server, etc.).
	Source SessionSource `json:"source"`
	// Current runtime status for the thread.
	Status ThreadStatus `json:"status"`
	// Optional analytics source classification for this thread.
	ThreadSource *ThreadSource `json:"threadSource,omitempty"`
	// 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.
	Turns []Turn `json:"turns"`
	// Unix timestamp (in seconds) when the thread was last updated.
	UpdatedAt int64 `json:"updatedAt"`
}

func (Thread) MarshalJSON

func (v Thread) MarshalJSON() ([]byte, error)

type ThreadActiveFlag

type ThreadActiveFlag string
const (
	ThreadActiveFlagWaitingOnApproval  ThreadActiveFlag = "waitingOnApproval"
	ThreadActiveFlagWaitingOnUserInput ThreadActiveFlag = "waitingOnUserInput"
)

type ThreadCompactStartParams

type ThreadCompactStartParams struct {
	ThreadID string `json:"threadId"`
}

type ThreadCompactStartResponse

type ThreadCompactStartResponse struct {
}

type ThreadEnvironment

type ThreadEnvironment struct {
	Cwd                   LegacyAppPathString   `json:"cwd"`
	EnvironmentID         string                `json:"environmentId"`
	RuntimeWorkspaceRoots []LegacyAppPathString `json:"runtimeWorkspaceRoots"`
}

An environment selected by a loaded thread, independent of connection status.

func (ThreadEnvironment) MarshalJSON

func (v ThreadEnvironment) MarshalJSON() ([]byte, error)

type ThreadExtra

type ThreadExtra struct {
}

Extra app-server data for a thread.

type ThreadForkParams

type ThreadForkParams struct {
	ApprovalPolicy *AskForApproval `json:"approvalPolicy,omitempty"`
	// Override where approval requests are routed for review on this thread and subsequent turns.
	ApprovalsReviewer *ApprovalsReviewer `json:"approvalsReviewer,omitempty"`
	BaseInstructions  *string            `json:"baseInstructions,omitempty"`
	// Optional turn id to fork before, excluding that turn and all later turns. Cannot be combined with `last_turn_id`.
	BeforeTurnID *string        `json:"beforeTurnId,omitempty"`
	Config       map[string]any `json:"config,omitempty"`
	Cwd          *string        `json:"cwd,omitempty"`
	// When true, carry the source thread's current goal into the fork without starting its initial automatic continuation. The next explicit turn owns the goal lifecycle, and normal automatic continuation resumes after it.
	DeferGoalContinuation *bool   `json:"deferGoalContinuation,omitempty"`
	DeveloperInstructions *string `json:"developerInstructions,omitempty"`
	Ephemeral             *bool   `json:"ephemeral,omitempty"`
	// When true, return only thread metadata and live fork state without populating `thread.turns`. This is useful when the client plans to call `thread/turns/list` immediately after forking. Full-history hydration is deprecated for paginated threads; use this with `thread/turns/list` and `thread/items/list` instead.
	ExcludeTurns *bool `json:"excludeTurns,omitempty"`
	// Optional last turn id to fork through, inclusive.
	LastTurnID *string `json:"lastTurnId,omitempty"`
	// Configuration overrides for the forked thread, if any.
	Model         *string `json:"model,omitempty"`
	ModelProvider *string `json:"modelProvider,omitempty"`
	// [UNSTABLE] Specify the rollout path to fork from. If specified, the thread_id param will be ignored.
	Path *string `json:"path,omitempty"`
	// Named profile id for the forked thread. Cannot be combined with `sandbox`.
	Permissions *string `json:"permissions,omitempty"`
	// Replace the thread's runtime workspace roots. Paths must be absolute.
	RuntimeWorkspaceRoots []AbsolutePathBuf `json:"runtimeWorkspaceRoots,omitempty"`
	Sandbox               *SandboxMode      `json:"sandbox,omitempty"`
	ServiceTier           *string           `json:"serviceTier,omitempty"`
	ThreadID              string            `json:"threadId"`
	// Optional client-supplied analytics source classification for this forked thread.
	ThreadSource *ThreadSource `json:"threadSource,omitempty"`
}

There are two ways to fork a thread: 1. By thread_id: load the thread from disk by thread_id and fork it into a new thread. 2. By path: load the thread from disk by path and fork it into a new thread.

type ThreadForkResponse

type ThreadForkResponse struct {
	// Named or implicit built-in profile that produced the active permissions, when known.
	ActivePermissionProfile *ActivePermissionProfile `json:"activePermissionProfile,omitempty"`
	ApprovalPolicy          AskForApproval           `json:"approvalPolicy"`
	// Reviewer currently used for approval requests on this thread.
	ApprovalsReviewer ApprovalsReviewer `json:"approvalsReviewer"`
	Cwd               AbsolutePathBuf   `json:"cwd"`
	// Environment-native paths to instruction source files currently loaded for this thread.
	InstructionSources []LegacyAppPathString `json:"instructionSources,omitempty"`
	Model              string                `json:"model"`
	ModelProvider      string                `json:"modelProvider"`
	// @deprecated Always `explicitRequestOnly`. Use `reasoningEffort` for Ultra behavior.
	MultiAgentMode  *MultiAgentMode  `json:"multiAgentMode,omitempty"`
	ReasoningEffort *ReasoningEffort `json:"reasoningEffort,omitempty"`
	// Thread-scoped runtime workspace roots used to materialize `:workspace_roots`.
	RuntimeWorkspaceRoots []AbsolutePathBuf `json:"runtimeWorkspaceRoots,omitempty"`
	// Legacy sandbox policy retained for compatibility. Experimental clients should prefer `activePermissionProfile` for profile provenance.
	Sandbox     SandboxPolicy `json:"sandbox"`
	ServiceTier *string       `json:"serviceTier,omitempty"`
	Thread      Thread        `json:"thread"`
}

type ThreadGoal

type ThreadGoal struct {
	CreatedAt       int64            `json:"createdAt"`
	Objective       string           `json:"objective"`
	Status          ThreadGoalStatus `json:"status"`
	ThreadID        string           `json:"threadId"`
	TimeUsedSeconds int64            `json:"timeUsedSeconds"`
	TokenBudget     *int64           `json:"tokenBudget,omitempty"`
	TokensUsed      int64            `json:"tokensUsed"`
	UpdatedAt       int64            `json:"updatedAt"`
}

type ThreadGoalClearParams

type ThreadGoalClearParams struct {
	ThreadID string `json:"threadId"`
}

type ThreadGoalClearResponse

type ThreadGoalClearResponse struct {
	Cleared bool `json:"cleared"`
}

type ThreadGoalClearedNotification

type ThreadGoalClearedNotification struct {
	ThreadID string `json:"threadId"`
}

type ThreadGoalGetParams

type ThreadGoalGetParams struct {
	ThreadID string `json:"threadId"`
}

type ThreadGoalGetResponse

type ThreadGoalGetResponse struct {
	Goal *ThreadGoal `json:"goal,omitempty"`
}

type ThreadGoalSetParams

type ThreadGoalSetParams struct {
	Objective   *string           `json:"objective,omitempty"`
	Status      *ThreadGoalStatus `json:"status,omitempty"`
	ThreadID    string            `json:"threadId"`
	TokenBudget *int64            `json:"tokenBudget,omitempty"`
}

type ThreadGoalSetResponse

type ThreadGoalSetResponse struct {
	Goal ThreadGoal `json:"goal"`
}

type ThreadGoalStatus

type ThreadGoalStatus string
const (
	ThreadGoalStatusActive        ThreadGoalStatus = "active"
	ThreadGoalStatusBlocked       ThreadGoalStatus = "blocked"
	ThreadGoalStatusBudgetLimited ThreadGoalStatus = "budgetLimited"
	ThreadGoalStatusComplete      ThreadGoalStatus = "complete"
	ThreadGoalStatusPaused        ThreadGoalStatus = "paused"
	ThreadGoalStatusUsageLimited  ThreadGoalStatus = "usageLimited"
)

type ThreadGoalUpdatedNotification

type ThreadGoalUpdatedNotification struct {
	Goal     ThreadGoal `json:"goal"`
	ThreadID string     `json:"threadId"`
	TurnID   *string    `json:"turnId,omitempty"`
}

type ThreadHistoryMode

type ThreadHistoryMode string
const (
	ThreadHistoryModeLegacy    ThreadHistoryMode = "legacy"
	ThreadHistoryModePaginated ThreadHistoryMode = "paginated"
)

type ThreadId

type ThreadId = string

type ThreadItem

type ThreadItem struct {
	// Tag is the value of the "type" property observed on decode.
	Tag                 string
	AgentMessage        *AgentMessageThreadItem
	CollabAgentToolCall *CollabAgentToolCallThreadItem
	CommandExecution    *CommandExecutionThreadItem
	ContextCompaction   *ContextCompactionThreadItem
	DynamicToolCall     *DynamicToolCallThreadItem
	EnteredReviewMode   *EnteredReviewModeThreadItem
	ExitedReviewMode    *ExitedReviewModeThreadItem
	FileChange          *FileChangeThreadItem
	FunctionCallOutput  *FunctionCallOutputThreadItem
	HookPrompt          *HookPromptThreadItem
	ImageGeneration     *ImageGenerationThreadItem
	ImageView           *ImageViewThreadItem
	MCPToolCall         *McpToolCallThreadItem
	Plan                *PlanThreadItem
	Reasoning           *ReasoningThreadItem
	Sleep               *SleepThreadItem
	SubAgentActivity    *SubAgentActivityThreadItem
	UserMessage         *UserMessageThreadItem
	WebSearch           *WebSearchThreadItem
	// contains filtered or unexported fields
}

ThreadItem is an internally-tagged union (tag property "type"). Unknown variants decode without error: only Tag and Raw() are populated.

func (ThreadItem) MarshalJSON

func (u ThreadItem) MarshalJSON() ([]byte, error)

func (ThreadItem) Raw

func (u ThreadItem) Raw() []byte

Raw returns the original JSON for this union value, if it was decoded.

func (*ThreadItem) UnmarshalJSON

func (u *ThreadItem) UnmarshalJSON(data []byte) error

type ThreadReadParams

type ThreadReadParams struct {
	// When true, include turns and their items from rollout history. Full-history hydration is deprecated for paginated threads; prefer a metadata-only read and page with `thread/turns/list` and `thread/items/list`.
	IncludeTurns *bool  `json:"includeTurns,omitempty"`
	ThreadID     string `json:"threadId"`
}

type ThreadReadResponse

type ThreadReadResponse struct {
	Thread Thread `json:"thread"`
}

type ThreadResumeInitialTurnsPageParams

type ThreadResumeInitialTurnsPageParams struct {
	// How much item detail to include for each returned turn; defaults to summary.
	ItemsView *TurnItemsView `json:"itemsView,omitempty"`
	// Optional turn page size.
	Limit *uint64 `json:"limit,omitempty"`
	// Optional turn pagination direction; defaults to descending.
	SortDirection *SortDirection `json:"sortDirection,omitempty"`
}

type ThreadResumeParams

type ThreadResumeParams struct {
	ApprovalPolicy *AskForApproval `json:"approvalPolicy,omitempty"`
	// Override where approval requests are routed for review on this thread and subsequent turns.
	ApprovalsReviewer     *ApprovalsReviewer `json:"approvalsReviewer,omitempty"`
	BaseInstructions      *string            `json:"baseInstructions,omitempty"`
	Config                map[string]any     `json:"config,omitempty"`
	Cwd                   *string            `json:"cwd,omitempty"`
	DeveloperInstructions *string            `json:"developerInstructions,omitempty"`
	// When true, return only thread metadata and live-resume state without populating `thread.turns`. This is useful when the client plans to call `thread/turns/list` immediately after resuming. Full-history hydration is deprecated for paginated threads; use this with `thread/turns/list` and `thread/items/list` instead.
	ExcludeTurns *bool `json:"excludeTurns,omitempty"`
	// [UNSTABLE] FOR CODEX CLOUD - DO NOT USE. If specified, the thread will be resumed with the provided history instead of loaded from disk.
	History []ResponseItem `json:"history,omitempty"`
	// When present, include a `thread/turns/list` page in the resume response so clients can bootstrap recent turns without a second request.
	InitialTurnsPage *ThreadResumeInitialTurnsPageParams `json:"initialTurnsPage,omitempty"`
	// Configuration overrides for the resumed thread, if any.
	Model         *string `json:"model,omitempty"`
	ModelProvider *string `json:"modelProvider,omitempty"`
	// [UNSTABLE] Specify the rollout path to resume from. If specified for a non-running thread, the thread_id param will be ignored. If thread_id identifies a running thread, the path must match the active rollout path.
	Path *string `json:"path,omitempty"`
	// Named profile id for the resumed thread. Cannot be combined with `sandbox`.
	Permissions *string      `json:"permissions,omitempty"`
	Personality *Personality `json:"personality,omitempty"`
	// Replace the thread's runtime workspace roots. Paths must be absolute.
	RuntimeWorkspaceRoots []AbsolutePathBuf `json:"runtimeWorkspaceRoots,omitempty"`
	Sandbox               *SandboxMode      `json:"sandbox,omitempty"`
	ServiceTier           *string           `json:"serviceTier,omitempty"`
	ThreadID              string            `json:"threadId"`
}

There are three ways to resume a thread: 1. By thread_id: load the thread from disk by thread_id and resume it. 2. By history: instantiate the thread from memory and resume it. 3. By path: load the thread from disk by path and resume it.

type ThreadResumeResponse

type ThreadResumeResponse struct {
	// Named or implicit built-in profile that produced the active permissions, when known.
	ActivePermissionProfile *ActivePermissionProfile `json:"activePermissionProfile,omitempty"`
	ApprovalPolicy          AskForApproval           `json:"approvalPolicy"`
	// Reviewer currently used for approval requests on this thread.
	ApprovalsReviewer ApprovalsReviewer `json:"approvalsReviewer"`
	Cwd               AbsolutePathBuf   `json:"cwd"`
	// `thread/turns/list` page returned when requested by `initialTurnsPage`.
	InitialTurnsPage *TurnsPage `json:"initialTurnsPage,omitempty"`
	// Environment-native paths to instruction source files currently loaded for this thread.
	InstructionSources []LegacyAppPathString `json:"instructionSources,omitempty"`
	// Opaque cursor for hydrating paginated items backwards.
	ItemsBackwardsCursor *string `json:"itemsBackwardsCursor,omitempty"`
	Model                string  `json:"model"`
	ModelProvider        string  `json:"modelProvider"`
	// @deprecated Always `explicitRequestOnly`. Use `reasoningEffort` for Ultra behavior.
	MultiAgentMode  *MultiAgentMode  `json:"multiAgentMode,omitempty"`
	ReasoningEffort *ReasoningEffort `json:"reasoningEffort,omitempty"`
	// Thread-scoped runtime workspace roots used to materialize `:workspace_roots`.
	RuntimeWorkspaceRoots []AbsolutePathBuf `json:"runtimeWorkspaceRoots,omitempty"`
	// Legacy sandbox policy retained for compatibility. Experimental clients should prefer `activePermissionProfile` for profile provenance.
	Sandbox     SandboxPolicy `json:"sandbox"`
	ServiceTier *string       `json:"serviceTier,omitempty"`
	Thread      Thread        `json:"thread"`
	// Opaque cursor for hydrating paginated turns backwards.
	TurnsBackwardsCursor *string `json:"turnsBackwardsCursor,omitempty"`
}

type ThreadSection

type ThreadSection struct {
	// Optional appearance synchronized across clients.
	Appearance *ThreadSectionAppearance `json:"appearance,omitempty"`
	// Opaque UUIDv7 identity that remains stable when the section is renamed.
	ID string `json:"id"`
	// The current user-visible section name.
	Name string `json:"name"`
}

An independently persisted, user-visible thread section.

type ThreadSectionAppearance

type ThreadSectionAppearance struct {
	Color *string `json:"color,omitempty"`
	Icon  *string `json:"icon,omitempty"`
}

Extensible visual presentation for a custom thread section.

type ThreadSettingsUpdateParams

type ThreadSettingsUpdateParams struct {
	// Override the approval policy for subsequent turns.
	ApprovalPolicy *AskForApproval `json:"approvalPolicy,omitempty"`
	// Override where approval requests are routed for subsequent turns.
	ApprovalsReviewer *ApprovalsReviewer `json:"approvalsReviewer,omitempty"`
	// EXPERIMENTAL - Set a pre-set collaboration mode for subsequent turns.
	CollaborationMode *CollaborationMode `json:"collaborationMode,omitempty"`
	// Override the working directory for subsequent turns.
	Cwd *string `json:"cwd,omitempty"`
	// Override the reasoning effort for subsequent turns.
	Effort *ReasoningEffort `json:"effort,omitempty"`
	// Override the model for subsequent turns.
	Model *string `json:"model,omitempty"`
	// @deprecated Ignored. Use `effort: "ultra"` for proactive multi-agent behavior.
	MultiAgentMode *MultiAgentMode `json:"multiAgentMode,omitempty"`
	// Select a named permissions profile id for subsequent turns. Cannot be combined with `sandboxPolicy`.
	Permissions *string `json:"permissions,omitempty"`
	// Override the personality for subsequent turns.
	Personality *Personality `json:"personality,omitempty"`
	// Override the sandbox policy for subsequent turns.
	SandboxPolicy *SandboxPolicy `json:"sandboxPolicy,omitempty"`
	// Override the service tier for subsequent turns. `null` clears the current service tier; omission leaves it unchanged.
	ServiceTier *string `json:"serviceTier,omitempty"`
	// Override the reasoning summary for subsequent turns.
	Summary  *ReasoningSummary `json:"summary,omitempty"`
	ThreadID string            `json:"threadId"`
}

type ThreadSettingsUpdateResponse

type ThreadSettingsUpdateResponse struct {
}

type ThreadSource

type ThreadSource = string

type ThreadStartParams

type ThreadStartParams struct {
	// Allow a provider with an authoritative static model catalog to replace an unavailable requested model with its default.
	AllowProviderModelFallback *bool           `json:"allowProviderModelFallback,omitempty"`
	ApprovalPolicy             *AskForApproval `json:"approvalPolicy,omitempty"`
	// Override where approval requests are routed for review on this thread and subsequent turns.
	ApprovalsReviewer     *ApprovalsReviewer `json:"approvalsReviewer,omitempty"`
	BaseInstructions      *string            `json:"baseInstructions,omitempty"`
	Config                map[string]any     `json:"config,omitempty"`
	Cwd                   *string            `json:"cwd,omitempty"`
	DeveloperInstructions *string            `json:"developerInstructions,omitempty"`
	DynamicTools          []DynamicToolSpec  `json:"dynamicTools,omitempty"`
	// Optional sticky environments for this thread.
	Environments []TurnEnvironmentParams `json:"environments,omitempty"`
	Ephemeral    *bool                   `json:"ephemeral,omitempty"`
	// If true, opt into emitting raw Responses API items on the event stream. This is for internal use only (e.g. Codex Cloud).
	ExperimentalRawEvents *bool `json:"experimentalRawEvents,omitempty"`
	// Persisted thread history contract to use for this new thread.
	HistoryMode *ThreadHistoryMode `json:"historyMode,omitempty"`
	// Test-only experimental field used to validate experimental gating and schema filtering behavior in a stable way.
	MockExperimentalField *string `json:"mockExperimentalField,omitempty"`
	Model                 *string `json:"model,omitempty"`
	ModelProvider         *string `json:"modelProvider,omitempty"`
	// @deprecated Ignored. Use Ultra reasoning effort for proactive multi-agent behavior.
	MultiAgentMode *MultiAgentMode `json:"multiAgentMode,omitempty"`
	// Named profile id for this thread. Cannot be combined with `sandbox`.
	Permissions *string      `json:"permissions,omitempty"`
	Personality *Personality `json:"personality,omitempty"`
	// Optional project identity for this new thread. Durable threads persist the assignment; ephemeral threads expose it only in live responses.
	ProjectID *string `json:"projectId,omitempty"`
	// Replace the thread's runtime workspace roots. Paths must be absolute.
	RuntimeWorkspaceRoots []AbsolutePathBuf `json:"runtimeWorkspaceRoots,omitempty"`
	Sandbox               *SandboxMode      `json:"sandbox,omitempty"`
	// Capability roots selected for this thread by the hosting platform.
	SelectedCapabilityRoots []SelectedCapabilityRoot `json:"selectedCapabilityRoots,omitempty"`
	ServiceName             *string                  `json:"serviceName,omitempty"`
	ServiceTier             *string                  `json:"serviceTier,omitempty"`
	SessionStartSource      *ThreadStartSource       `json:"sessionStartSource,omitempty"`
	// Optional client-supplied analytics source classification for this thread.
	ThreadSource *ThreadSource `json:"threadSource,omitempty"`
}

type ThreadStartResponse

type ThreadStartResponse struct {
	// Named or implicit built-in profile that produced the active permissions, when known.
	ActivePermissionProfile *ActivePermissionProfile `json:"activePermissionProfile,omitempty"`
	ApprovalPolicy          AskForApproval           `json:"approvalPolicy"`
	// Reviewer currently used for approval requests on this thread.
	ApprovalsReviewer ApprovalsReviewer `json:"approvalsReviewer"`
	Cwd               AbsolutePathBuf   `json:"cwd"`
	// Environment-native paths to instruction source files currently loaded for this thread.
	InstructionSources []LegacyAppPathString `json:"instructionSources,omitempty"`
	Model              string                `json:"model"`
	ModelProvider      string                `json:"modelProvider"`
	// @deprecated Always `explicitRequestOnly`. Use `reasoningEffort` for Ultra behavior.
	MultiAgentMode  *MultiAgentMode  `json:"multiAgentMode,omitempty"`
	ReasoningEffort *ReasoningEffort `json:"reasoningEffort,omitempty"`
	// Thread-scoped runtime workspace roots used to materialize `:workspace_roots`.
	RuntimeWorkspaceRoots []AbsolutePathBuf `json:"runtimeWorkspaceRoots,omitempty"`
	// Legacy sandbox policy retained for compatibility. Experimental clients should prefer `activePermissionProfile` for profile provenance.
	Sandbox     SandboxPolicy `json:"sandbox"`
	ServiceTier *string       `json:"serviceTier,omitempty"`
	Thread      Thread        `json:"thread"`
}

type ThreadStartSource

type ThreadStartSource string
const (
	ThreadStartSourceClear   ThreadStartSource = "clear"
	ThreadStartSourceStartup ThreadStartSource = "startup"
)

type ThreadStartedNotification

type ThreadStartedNotification struct {
	Thread Thread `json:"thread"`
}

type ThreadStatus

type ThreadStatus struct {
	// Tag is the value of the "type" property observed on decode.
	Tag         string
	Active      *ActiveThreadStatus
	Idle        *IdleThreadStatus
	NotLoaded   *NotLoadedThreadStatus
	SystemError *SystemErrorThreadStatus
	// contains filtered or unexported fields
}

ThreadStatus is an internally-tagged union (tag property "type"). Unknown variants decode without error: only Tag and Raw() are populated.

func (ThreadStatus) MarshalJSON

func (u ThreadStatus) MarshalJSON() ([]byte, error)

func (ThreadStatus) Raw

func (u ThreadStatus) Raw() []byte

Raw returns the original JSON for this union value, if it was decoded.

func (*ThreadStatus) UnmarshalJSON

func (u *ThreadStatus) UnmarshalJSON(data []byte) error

type ThreadStatusChangedNotification

type ThreadStatusChangedNotification struct {
	Status   ThreadStatus `json:"status"`
	ThreadID string       `json:"threadId"`
}

type ThreadTokenUsage

type ThreadTokenUsage struct {
	Last               TokenUsageBreakdown `json:"last"`
	ModelContextWindow *int64              `json:"modelContextWindow,omitempty"`
	Total              TokenUsageBreakdown `json:"total"`
}

type ThreadTokenUsageUpdatedNotification

type ThreadTokenUsageUpdatedNotification struct {
	ThreadID   string           `json:"threadId"`
	TokenUsage ThreadTokenUsage `json:"tokenUsage"`
	TurnID     string           `json:"turnId"`
}

type TmpdirFileSystemSpecialPath

type TmpdirFileSystemSpecialPath struct {
}

type TokenUsageBreakdown

type TokenUsageBreakdown struct {
	CacheWriteInputTokens *int64 `json:"cacheWriteInputTokens,omitempty"`
	CachedInputTokens     int64  `json:"cachedInputTokens"`
	InputTokens           int64  `json:"inputTokens"`
	OutputTokens          int64  `json:"outputTokens"`
	ReasoningOutputTokens int64  `json:"reasoningOutputTokens"`
	TotalTokens           int64  `json:"totalTokens"`
}

type Tool

type Tool struct {
	Meta         any     `json:"_meta,omitempty"`
	Annotations  any     `json:"annotations,omitempty"`
	Description  *string `json:"description,omitempty"`
	Icons        []any   `json:"icons,omitempty"`
	InputSchema  any     `json:"inputSchema"`
	Name         string  `json:"name"`
	OutputSchema any     `json:"outputSchema,omitempty"`
	Title        *string `json:"title,omitempty"`
}

Definition for a tool the client can call.

type ToolRequestUserInputAnswer

type ToolRequestUserInputAnswer struct {
	Answers []string `json:"answers"`
}

EXPERIMENTAL. Captures a user's answer to a request_user_input question.

func (ToolRequestUserInputAnswer) MarshalJSON

func (v ToolRequestUserInputAnswer) MarshalJSON() ([]byte, error)

type ToolRequestUserInputOption

type ToolRequestUserInputOption struct {
	Description string `json:"description"`
	Label       string `json:"label"`
}

EXPERIMENTAL. Defines a single selectable option for request_user_input.

type ToolRequestUserInputParams

type ToolRequestUserInputParams struct {
	// @deprecated Use `isBlocking` to decide whether the request should block.
	AutoResolutionMs *uint64                        `json:"autoResolutionMs,omitempty"`
	IsBlocking       bool                           `json:"isBlocking"`
	ItemID           string                         `json:"itemId"`
	Questions        []ToolRequestUserInputQuestion `json:"questions"`
	ThreadID         string                         `json:"threadId"`
	TurnID           string                         `json:"turnId"`
}

EXPERIMENTAL. Params sent with a request_user_input event.

func (ToolRequestUserInputParams) MarshalJSON

func (v ToolRequestUserInputParams) MarshalJSON() ([]byte, error)

type ToolRequestUserInputQuestion

type ToolRequestUserInputQuestion struct {
	Header   string                       `json:"header"`
	ID       string                       `json:"id"`
	IsOther  *bool                        `json:"isOther,omitempty"`
	IsSecret *bool                        `json:"isSecret,omitempty"`
	Options  []ToolRequestUserInputOption `json:"options,omitempty"`
	Question string                       `json:"question"`
}

EXPERIMENTAL. Represents one request_user_input question and its required options.

type ToolRequestUserInputResponse

type ToolRequestUserInputResponse struct {
	Answers map[string]ToolRequestUserInputAnswer `json:"answers"`
}

EXPERIMENTAL. Response payload mapping question ids to answers.

func (ToolRequestUserInputResponse) MarshalJSON

func (v ToolRequestUserInputResponse) MarshalJSON() ([]byte, error)

type ToolSearchCallResponseItem

type ToolSearchCallResponseItem struct {
	Arguments                              any                                     `json:"arguments"`
	CallID                                 *string                                 `json:"call_id,omitempty"`
	Execution                              string                                  `json:"execution"`
	ID                                     *string                                 `json:"id,omitempty"`
	InternalChatMessageMetadataPassthrough *InternalChatMessageMetadataPassthrough `json:"internal_chat_message_metadata_passthrough,omitempty"`
	Status                                 *string                                 `json:"status,omitempty"`
}

type ToolSearchOutputResponseItem

type ToolSearchOutputResponseItem struct {
	CallID                                 *string                                 `json:"call_id,omitempty"`
	Execution                              string                                  `json:"execution"`
	ID                                     *string                                 `json:"id,omitempty"`
	InternalChatMessageMetadataPassthrough *InternalChatMessageMetadataPassthrough `json:"internal_chat_message_metadata_passthrough,omitempty"`
	Status                                 string                                  `json:"status"`
	Tools                                  []any                                   `json:"tools"`
}

func (ToolSearchOutputResponseItem) MarshalJSON

func (v ToolSearchOutputResponseItem) MarshalJSON() ([]byte, error)

type Turn

type Turn struct {
	// Unix timestamp (in seconds) when the turn completed.
	CompletedAt *int64 `json:"completedAt,omitempty"`
	// Duration between turn start and completion in milliseconds, if known.
	DurationMs *int64 `json:"durationMs,omitempty"`
	// Only populated when the Turn's status is failed.
	Error *TurnError `json:"error,omitempty"`
	// Identifier for this turn. Codex-generated turn IDs are UUIDv7.
	ID string `json:"id"`
	// Thread items currently included in this turn payload.
	Items []ThreadItem `json:"items"`
	// Describes how much of `items` has been loaded for this turn.
	ItemsView *TurnItemsView `json:"itemsView,omitempty"`
	// Unix timestamp (in seconds) when the turn started.
	StartedAt *int64     `json:"startedAt,omitempty"`
	Status    TurnStatus `json:"status"`
}

func (Turn) MarshalJSON

func (v Turn) MarshalJSON() ([]byte, error)

type TurnCompletedNotification

type TurnCompletedNotification struct {
	ThreadID string `json:"threadId"`
	Turn     Turn   `json:"turn"`
}

type TurnEnvironmentParams

type TurnEnvironmentParams struct {
	Cwd           LegacyAppPathString `json:"cwd"`
	EnvironmentID string              `json:"environmentId"`
	// Environment-native runtime workspace roots. Omitted defaults to `cwd`.
	RuntimeWorkspaceRoots []LegacyAppPathString `json:"runtimeWorkspaceRoots,omitempty"`
}

type TurnError

type TurnError struct {
	AdditionalDetails *string         `json:"additionalDetails,omitempty"`
	CodexErrorInfo    *CodexErrorInfo `json:"codexErrorInfo,omitempty"`
	Message           string          `json:"message"`
	// Optional public explanation and continuation instruction for a misalignment block.
	Misalignment *MisalignmentErrorDetails `json:"misalignment,omitempty"`
}

type TurnInterruptParams

type TurnInterruptParams struct {
	ThreadID string `json:"threadId"`
	TurnID   string `json:"turnId"`
}

type TurnInterruptResponse

type TurnInterruptResponse struct {
}

type TurnItemsView

type TurnItemsView string
const (
	TurnItemsViewFull      TurnItemsView = "full"
	TurnItemsViewNotLoaded TurnItemsView = "notLoaded"
	TurnItemsViewSummary   TurnItemsView = "summary"
)

type TurnPlanStep

type TurnPlanStep struct {
	Status TurnPlanStepStatus `json:"status"`
	Step   string             `json:"step"`
}

type TurnPlanStepStatus

type TurnPlanStepStatus string
const (
	TurnPlanStepStatusCompleted  TurnPlanStepStatus = "completed"
	TurnPlanStepStatusInProgress TurnPlanStepStatus = "inProgress"
	TurnPlanStepStatusPending    TurnPlanStepStatus = "pending"
)

type TurnPlanUpdatedNotification

type TurnPlanUpdatedNotification struct {
	Explanation *string        `json:"explanation,omitempty"`
	Plan        []TurnPlanStep `json:"plan"`
	ThreadID    string         `json:"threadId"`
	TurnID      string         `json:"turnId"`
}

func (TurnPlanUpdatedNotification) MarshalJSON

func (v TurnPlanUpdatedNotification) MarshalJSON() ([]byte, error)

type TurnStartParams

type TurnStartParams struct {
	// Optional client-provided context fragments keyed by an opaque source identifier.
	AdditionalContext map[string]AdditionalContextEntry `json:"additionalContext,omitempty"`
	// Override the approval policy for this turn and subsequent turns.
	ApprovalPolicy *AskForApproval `json:"approvalPolicy,omitempty"`
	// Override where approval requests are routed for review on this turn and subsequent turns.
	ApprovalsReviewer   *ApprovalsReviewer `json:"approvalsReviewer,omitempty"`
	ClientUserMessageID *string            `json:"clientUserMessageId,omitempty"`
	// EXPERIMENTAL - Set a pre-set collaboration mode. Takes precedence over model, reasoning_effort, and developer instructions if set.
	CollaborationMode *CollaborationMode `json:"collaborationMode,omitempty"`
	// Override the working directory for this turn and subsequent turns.
	Cwd *string `json:"cwd,omitempty"`
	// EXPERIMENTAL - Request a workspace-authorized cyber program for this turn. Omission preserves automatic behavior. This does not grant access.
	CyberAccessProgram *CyberAccessProgram `json:"cyberAccessProgram,omitempty"`
	// Override the reasoning effort for this turn and subsequent turns.
	Effort *ReasoningEffort `json:"effort,omitempty"`
	// Optional environments for this turn and subsequent turns.
	Environments []TurnEnvironmentParams `json:"environments,omitempty"`
	Input        []UserInput             `json:"input"`
	// Override the model for this turn and subsequent turns.
	Model *string `json:"model,omitempty"`
	// @deprecated Ignored. Use `effort: "ultra"` for proactive multi-agent behavior.
	MultiAgentMode *MultiAgentMode `json:"multiAgentMode,omitempty"`
	// Optional JSON Schema used to constrain the final assistant message for this turn.
	OutputSchema any `json:"outputSchema,omitempty"`
	// Select a named permissions profile id for this turn and subsequent turns. Cannot be combined with `sandboxPolicy`.
	Permissions *string `json:"permissions,omitempty"`
	// Override the personality for this turn and subsequent turns.
	Personality *Personality `json:"personality,omitempty"`
	// Optional metadata to enrich Codex's ResponsesAPI turn metadata.
	ResponsesapiClientMetadata map[string]string `json:"responsesapiClientMetadata,omitempty"`
	// Replace the thread's runtime workspace roots for this turn and subsequent turns. Paths must be absolute.
	RuntimeWorkspaceRoots []AbsolutePathBuf `json:"runtimeWorkspaceRoots,omitempty"`
	// Override the sandbox policy for this turn and subsequent turns.
	SandboxPolicy *SandboxPolicy `json:"sandboxPolicy,omitempty"`
	// Override the service tier for this turn and subsequent turns.
	ServiceTier *string `json:"serviceTier,omitempty"`
	// Override the service tier only when this request starts a new turn. Use "default" for standard speed. Omitted or null inherits the thread's tier. Does not change the thread's tier or a turn being steered.
	ServiceTierForTurn *string `json:"serviceTierForTurn,omitempty"`
	// Override the reasoning summary for this turn and subsequent turns.
	Summary    *ReasoningSummary `json:"summary,omitempty"`
	ThreadID   string            `json:"threadId"`
	ToolOutput *TurnToolOutput   `json:"toolOutput,omitempty"`
	// Optional source classification for the caller that starts this turn. Ignored when this request steers an already-active turn.
	TurnTrigger *string `json:"turnTrigger,omitempty"`
}

func (TurnStartParams) MarshalJSON

func (v TurnStartParams) MarshalJSON() ([]byte, error)

type TurnStartResponse

type TurnStartResponse struct {
	Turn Turn `json:"turn"`
}

type TurnStartedNotification

type TurnStartedNotification struct {
	ThreadID string `json:"threadId"`
	Turn     Turn   `json:"turn"`
}

type TurnStatus

type TurnStatus string
const (
	TurnStatusCompleted   TurnStatus = "completed"
	TurnStatusFailed      TurnStatus = "failed"
	TurnStatusInProgress  TurnStatus = "inProgress"
	TurnStatusInterrupted TurnStatus = "interrupted"
)

type TurnSteerParams

type TurnSteerParams struct {
	// Optional client-provided context fragments keyed by an opaque source identifier.
	AdditionalContext   map[string]AdditionalContextEntry `json:"additionalContext,omitempty"`
	ClientUserMessageID *string                           `json:"clientUserMessageId,omitempty"`
	// Required active turn id precondition. The request fails when it does not match the currently active turn.
	ExpectedTurnID string      `json:"expectedTurnId"`
	Input          []UserInput `json:"input"`
	// Optional metadata to enrich Codex's ResponsesAPI turn metadata.
	ResponsesapiClientMetadata map[string]string `json:"responsesapiClientMetadata,omitempty"`
	ThreadID                   string            `json:"threadId"`
}

func (TurnSteerParams) MarshalJSON

func (v TurnSteerParams) MarshalJSON() ([]byte, error)

type TurnSteerResponse

type TurnSteerResponse struct {
	TurnID string `json:"turnId"`
}

type TurnToolOutput

type TurnToolOutput struct {
	Name      string     `json:"name"`
	Namespace *string    `json:"namespace,omitempty"`
	Output    rawMessage `json:"output"`
}

type TurnsPage

type TurnsPage struct {
	BackwardsCursor *string `json:"backwardsCursor,omitempty"`
	Data            []Turn  `json:"data"`
	NextCursor      *string `json:"nextCursor,omitempty"`
}

func (TurnsPage) MarshalJSON

func (v TurnsPage) MarshalJSON() ([]byte, error)

type URLMcpServerElicitationRequestParams

type URLMcpServerElicitationRequestParams struct {
	Meta          any    `json:"_meta,omitempty"`
	ElicitationID string `json:"elicitationId"`
	Message       string `json:"message"`
	URL           string `json:"url"`
}

type UncommittedChangesReviewTarget

type UncommittedChangesReviewTarget struct {
}

Review the working tree: staged, unstaged, and untracked files.

type UnknownCommandAction

type UnknownCommandAction struct {
	Command string `json:"command"`
}

type UnknownFileSystemSpecialPath

type UnknownFileSystemSpecialPath struct {
	Path    string               `json:"path"`
	Subpath *LegacyAppPathString `json:"subpath,omitempty"`
}

type UpdatePatchChangeKind

type UpdatePatchChangeKind struct {
	MovePath *string `json:"move_path,omitempty"`
}

type UsageLimitExceededImageGenerationFailure

type UsageLimitExceededImageGenerationFailure struct {
	LimitID  string `json:"limitId"`
	ResetsAt *int64 `json:"resetsAt,omitempty"`
}

type UserInput

type UserInput struct {
	// Tag is the value of the "type" property observed on decode.
	Tag        string
	Audio      *AudioUserInput
	Image      *ImageUserInput
	LocalAudio *LocalAudioUserInput
	LocalImage *LocalImageUserInput
	Mention    *MentionUserInput
	Skill      *SkillUserInput
	Text       *TextUserInput
	// contains filtered or unexported fields
}

UserInput is an internally-tagged union (tag property "type"). Unknown variants decode without error: only Tag and Raw() are populated.

func (UserInput) MarshalJSON

func (u UserInput) MarshalJSON() ([]byte, error)

func (UserInput) Raw

func (u UserInput) Raw() []byte

Raw returns the original JSON for this union value, if it was decoded.

func (*UserInput) UnmarshalJSON

func (u *UserInput) UnmarshalJSON(data []byte) error

type UserMessageThreadItem

type UserMessageThreadItem struct {
	ClientID *string     `json:"clientId,omitempty"`
	Content  []UserInput `json:"content"`
	ID       string      `json:"id"`
}

func (UserMessageThreadItem) MarshalJSON

func (v UserMessageThreadItem) MarshalJSON() ([]byte, error)

type WarningNotification

type WarningNotification struct {
	// Concise warning message for the user.
	Message string `json:"message"`
	// Optional thread target when the warning applies to a specific thread.
	ThreadID *string `json:"threadId,omitempty"`
}

type WebSearchAction

type WebSearchAction struct {
	// Tag is the value of the "type" property observed on decode.
	Tag        string
	FindInPage *FindInPageWebSearchAction
	OpenPage   *OpenPageWebSearchAction
	Other      *OtherWebSearchAction
	Search     *SearchWebSearchAction
	// contains filtered or unexported fields
}

WebSearchAction is an internally-tagged union (tag property "type"). Unknown variants decode without error: only Tag and Raw() are populated.

func (WebSearchAction) MarshalJSON

func (u WebSearchAction) MarshalJSON() ([]byte, error)

func (WebSearchAction) Raw

func (u WebSearchAction) Raw() []byte

Raw returns the original JSON for this union value, if it was decoded.

func (*WebSearchAction) UnmarshalJSON

func (u *WebSearchAction) UnmarshalJSON(data []byte) error

type WebSearchCallResponseItem

type WebSearchCallResponseItem struct {
	Action                                 *ResponsesApiWebSearchAction            `json:"action,omitempty"`
	ID                                     *string                                 `json:"id,omitempty"`
	InternalChatMessageMetadataPassthrough *InternalChatMessageMetadataPassthrough `json:"internal_chat_message_metadata_passthrough,omitempty"`
	Status                                 *string                                 `json:"status,omitempty"`
}

type WebSearchThreadItem

type WebSearchThreadItem struct {
	Action *WebSearchAction `json:"action,omitempty"`
	ID     string           `json:"id"`
	Query  string           `json:"query"`
	// Structured search results returned out-of-band by standalone web search.
	Results []any `json:"results,omitempty"`
}

type WorkspaceWriteSandboxPolicy

type WorkspaceWriteSandboxPolicy struct {
	ExcludeSlashTmp     *bool             `json:"excludeSlashTmp,omitempty"`
	ExcludeTmpdirEnvVar *bool             `json:"excludeTmpdirEnvVar,omitempty"`
	NetworkAccess       *bool             `json:"networkAccess,omitempty"`
	WritableRoots       []AbsolutePathBuf `json:"writableRoots,omitempty"`
}

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL